diff --git a/current/Libraries/Components/View/PlatformViewPropTypes.windows.js b/current/Libraries/Components/View/PlatformViewPropTypes.windows.js
index 2eafc1d8efc..e46c2548a8e 100644
--- a/current/Libraries/Components/View/PlatformViewPropTypes.windows.js
+++ b/current/Libraries/Components/View/PlatformViewPropTypes.windows.js
@@ -81,8 +81,8 @@ module.exports = {
]),
/**
- * Mouse move handler.
- * This is explicitly defined here in order to be able to have an associated "handler detection" property
+ * Mouse move handler.
+ * This is explicitly defined here in order to be able to have an associated "handler detection" property
* on the native side
*
* @platform windows
@@ -90,17 +90,17 @@ module.exports = {
onMouseMove: PropTypes.func,
/**
- * Mouse move (capturing phase) handler.
- * This is explicitly defined here in order to be able to have an associated "handler detection" property
+ * Mouse move (capturing phase) handler.
+ * This is explicitly defined here in order to be able to have an associated "handler detection" property
* on the native side
*
* @platform windows
*/
- onMouseMoveCapture: PropTypes.func,
+ onMouseMoveCapture: PropTypes.func,
/**
- * Mouse over handler.
- * This is explicitly defined here in order to be able to have an associated "handler detection" property
+ * Mouse over handler.
+ * This is explicitly defined here in order to be able to have an associated "handler detection" property
* on the native side
*
* @platform windows
@@ -108,17 +108,17 @@ module.exports = {
onMouseOver: PropTypes.func,
/**
- * Mouse over (capturing phase) handler.
- * This is explicitly defined here in order to be able to have an associated "handler detection" property
+ * Mouse over (capturing phase) handler.
+ * This is explicitly defined here in order to be able to have an associated "handler detection" property
* on the native side
*
* @platform windows
*/
- onMouseOverCapture: PropTypes.func,
+ onMouseOverCapture: PropTypes.func,
/**
- * Mouse out handler.
- * This is explicitly defined here in order to be able to have an associated "handler detection" property
+ * Mouse out handler.
+ * This is explicitly defined here in order to be able to have an associated "handler detection" property
* on the native side
*
* @platform windows
@@ -126,17 +126,17 @@ module.exports = {
onMouseOut: PropTypes.func,
/**
- * Mouse out (capturing phase) handler.
- * This is explicitly defined here in order to be able to have an associated "handler detection" property
+ * Mouse out (capturing phase) handler.
+ * This is explicitly defined here in order to be able to have an associated "handler detection" property
* on the native side
*
* @platform windows
*/
- onMouseOutCapture: PropTypes.func,
+ onMouseOutCapture: PropTypes.func,
/**
- * Mouse enter handler.
- * This is explicitly defined here in order to be able to have an associated "handler detection" property
+ * Mouse enter handler.
+ * This is explicitly defined here in order to be able to have an associated "handler detection" property
* on the native side
*
* @platform windows
@@ -144,11 +144,15 @@ module.exports = {
onMouseEnter: PropTypes.func,
/**
- * Mouse leave handler.
- * This is explicitly defined here in order to be able to have an associated "handler detection" property
+ * Mouse leave handler.
+ * This is explicitly defined here in order to be able to have an associated "handler detection" property
* on the native side
*
* @platform windows
*/
onMouseLeave: PropTypes.func,
+
+ onPointerEntered: PropTypes.func,
+ onPointerExited: PropTypes.func,
+
};
diff --git a/vnext/App.js b/vnext/App.js
new file mode 100644
index 00000000000..fe8613d07a0
--- /dev/null
+++ b/vnext/App.js
@@ -0,0 +1,37 @@
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ * @format
+ * @flow
+ */
+
+import React, {Component} from 'react';
+import {AppRegistry} from 'react-native';
+import {StackPanel} from 'react-native-windows';
+import ToDoList from './ToDoList';
+import SampleData from './data/SampleData';
+
+const initialState = {
+ tasks: SampleData.getTasks(),
+};
+
+export default class ToDoListApp extends Component {
+ constructor() {
+ super();
+ this.state = initialState;
+ }
+
+ render() {
+ return (
+
+
+
+ );
+ }
+
+ toggleSwitchChanged(toggleState) {
+ this.setState({dude: toggleState});
+ }
+}
+
+AppRegistry.registerComponent('ToDoListApp', () => ToDoListApp);
diff --git a/vnext/Controls/ToggleSwitch.js b/vnext/Controls/ToggleSwitch.js
new file mode 100644
index 00000000000..b7b13c91bf9
--- /dev/null
+++ b/vnext/Controls/ToggleSwitch.js
@@ -0,0 +1,59 @@
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ * @format
+ * @flow
+ */
+
+import React, {Component} from 'react';
+import {Grid, Rectangle} from 'react-native-windows';
+
+export default class ToggleSwitch extends Component {
+ constructor() {
+ super();
+ this.state = {
+ on: false,
+ pointerDown: false,
+ };
+ }
+
+ render() {
+ return (
+
+
+
+ );
+ }
+
+ onPointerPressed = () => {
+ this.setState({pointerDown: true});
+ };
+
+ onPointerReleased = () => {
+ if (this.state.pointerDown) {
+ this.updateToggleState(!this.state.on);
+ }
+ this.setState({pointerDown: false});
+ };
+
+ updateToggleState(toggleState) {
+ this.setState({on: toggleState});
+ this.props.onToggleSwitchChanged(toggleState);
+ }
+}
diff --git a/vnext/Playground/Playground.sln b/vnext/Playground/Playground.sln
index a706250005f..7d38b802224 100644
--- a/vnext/Playground/Playground.sln
+++ b/vnext/Playground/Playground.sln
@@ -18,6 +18,7 @@ EndProject
Global
GlobalSection(SharedMSBuildProjectFiles) = preSolution
..\Chakra\Chakra.vcxitems*{2d5d43d9-cffc-4c40-b4cd-02efb4e2742b}*SharedItemsImports = 4
+ ..\Shared\Shared.vcxitems*{2d5d43d9-cffc-4c40-b4cd-02efb4e2742b}*SharedItemsImports = 4
..\Chakra\Chakra.vcxitems*{c38970c0-5fbf-4d69-90d8-cbac225ae895}*SharedItemsImports = 9
EndGlobalSection
GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -51,50 +52,50 @@ Global
{A990658C-CE31-4BCC-976F-0FC6B1AF693D}.Debug|ARM.Build.0 = Debug|ARM
{A990658C-CE31-4BCC-976F-0FC6B1AF693D}.Debug|x64.ActiveCfg = Debug|x64
{A990658C-CE31-4BCC-976F-0FC6B1AF693D}.Debug|x64.Build.0 = Debug|x64
- {A990658C-CE31-4BCC-976F-0FC6B1AF693D}.Debug|x86.ActiveCfg = Debug|x86
- {A990658C-CE31-4BCC-976F-0FC6B1AF693D}.Debug|x86.Build.0 = Debug|x86
+ {A990658C-CE31-4BCC-976F-0FC6B1AF693D}.Debug|x86.ActiveCfg = Debug|Win32
+ {A990658C-CE31-4BCC-976F-0FC6B1AF693D}.Debug|x86.Build.0 = Debug|Win32
{A990658C-CE31-4BCC-976F-0FC6B1AF693D}.Release|ARM.ActiveCfg = Release|ARM
{A990658C-CE31-4BCC-976F-0FC6B1AF693D}.Release|ARM.Build.0 = Release|ARM
{A990658C-CE31-4BCC-976F-0FC6B1AF693D}.Release|x64.ActiveCfg = Release|x64
{A990658C-CE31-4BCC-976F-0FC6B1AF693D}.Release|x64.Build.0 = Release|x64
- {A990658C-CE31-4BCC-976F-0FC6B1AF693D}.Release|x86.ActiveCfg = Release|x86
- {A990658C-CE31-4BCC-976F-0FC6B1AF693D}.Release|x86.Build.0 = Release|x86
+ {A990658C-CE31-4BCC-976F-0FC6B1AF693D}.Release|x86.ActiveCfg = Release|Win32
+ {A990658C-CE31-4BCC-976F-0FC6B1AF693D}.Release|x86.Build.0 = Release|Win32
{A9D95A91-4DB7-4F72-BEB6-FE8A5C89BFBD}.Debug|ARM.ActiveCfg = Debug|ARM
{A9D95A91-4DB7-4F72-BEB6-FE8A5C89BFBD}.Debug|ARM.Build.0 = Debug|ARM
{A9D95A91-4DB7-4F72-BEB6-FE8A5C89BFBD}.Debug|x64.ActiveCfg = Debug|x64
{A9D95A91-4DB7-4F72-BEB6-FE8A5C89BFBD}.Debug|x64.Build.0 = Debug|x64
- {A9D95A91-4DB7-4F72-BEB6-FE8A5C89BFBD}.Debug|x86.ActiveCfg = Debug|x86
- {A9D95A91-4DB7-4F72-BEB6-FE8A5C89BFBD}.Debug|x86.Build.0 = Debug|x86
+ {A9D95A91-4DB7-4F72-BEB6-FE8A5C89BFBD}.Debug|x86.ActiveCfg = Debug|Win32
+ {A9D95A91-4DB7-4F72-BEB6-FE8A5C89BFBD}.Debug|x86.Build.0 = Debug|Win32
{A9D95A91-4DB7-4F72-BEB6-FE8A5C89BFBD}.Release|ARM.ActiveCfg = Release|ARM
{A9D95A91-4DB7-4F72-BEB6-FE8A5C89BFBD}.Release|ARM.Build.0 = Release|ARM
{A9D95A91-4DB7-4F72-BEB6-FE8A5C89BFBD}.Release|x64.ActiveCfg = Release|x64
{A9D95A91-4DB7-4F72-BEB6-FE8A5C89BFBD}.Release|x64.Build.0 = Release|x64
- {A9D95A91-4DB7-4F72-BEB6-FE8A5C89BFBD}.Release|x86.ActiveCfg = Release|x86
- {A9D95A91-4DB7-4F72-BEB6-FE8A5C89BFBD}.Release|x86.Build.0 = Release|x86
+ {A9D95A91-4DB7-4F72-BEB6-FE8A5C89BFBD}.Release|x86.ActiveCfg = Release|Win32
+ {A9D95A91-4DB7-4F72-BEB6-FE8A5C89BFBD}.Release|x86.Build.0 = Release|Win32
{2D5D43D9-CFFC-4C40-B4CD-02EFB4E2742B}.Debug|ARM.ActiveCfg = Debug|ARM
{2D5D43D9-CFFC-4C40-B4CD-02EFB4E2742B}.Debug|ARM.Build.0 = Debug|ARM
{2D5D43D9-CFFC-4C40-B4CD-02EFB4E2742B}.Debug|x64.ActiveCfg = Debug|x64
{2D5D43D9-CFFC-4C40-B4CD-02EFB4E2742B}.Debug|x64.Build.0 = Debug|x64
- {2D5D43D9-CFFC-4C40-B4CD-02EFB4E2742B}.Debug|x86.ActiveCfg = Debug|x86
- {2D5D43D9-CFFC-4C40-B4CD-02EFB4E2742B}.Debug|x86.Build.0 = Debug|x86
+ {2D5D43D9-CFFC-4C40-B4CD-02EFB4E2742B}.Debug|x86.ActiveCfg = Debug|Win32
+ {2D5D43D9-CFFC-4C40-B4CD-02EFB4E2742B}.Debug|x86.Build.0 = Debug|Win32
{2D5D43D9-CFFC-4C40-B4CD-02EFB4E2742B}.Release|ARM.ActiveCfg = Release|ARM
{2D5D43D9-CFFC-4C40-B4CD-02EFB4E2742B}.Release|ARM.Build.0 = Release|ARM
{2D5D43D9-CFFC-4C40-B4CD-02EFB4E2742B}.Release|x64.ActiveCfg = Release|x64
{2D5D43D9-CFFC-4C40-B4CD-02EFB4E2742B}.Release|x64.Build.0 = Release|x64
- {2D5D43D9-CFFC-4C40-B4CD-02EFB4E2742B}.Release|x86.ActiveCfg = Release|x86
- {2D5D43D9-CFFC-4C40-B4CD-02EFB4E2742B}.Release|x86.Build.0 = Release|x86
+ {2D5D43D9-CFFC-4C40-B4CD-02EFB4E2742B}.Release|x86.ActiveCfg = Release|Win32
+ {2D5D43D9-CFFC-4C40-B4CD-02EFB4E2742B}.Release|x86.Build.0 = Release|Win32
{11C084A3-A57C-4296-A679-CAC17B603144}.Debug|ARM.ActiveCfg = Debug|ARM
{11C084A3-A57C-4296-A679-CAC17B603144}.Debug|ARM.Build.0 = Debug|ARM
{11C084A3-A57C-4296-A679-CAC17B603144}.Debug|x64.ActiveCfg = Debug|x64
{11C084A3-A57C-4296-A679-CAC17B603144}.Debug|x64.Build.0 = Debug|x64
- {11C084A3-A57C-4296-A679-CAC17B603144}.Debug|x86.ActiveCfg = Debug|x86
- {11C084A3-A57C-4296-A679-CAC17B603144}.Debug|x86.Build.0 = Debug|x86
+ {11C084A3-A57C-4296-A679-CAC17B603144}.Debug|x86.ActiveCfg = Debug|Win32
+ {11C084A3-A57C-4296-A679-CAC17B603144}.Debug|x86.Build.0 = Debug|Win32
{11C084A3-A57C-4296-A679-CAC17B603144}.Release|ARM.ActiveCfg = Release|ARM
{11C084A3-A57C-4296-A679-CAC17B603144}.Release|ARM.Build.0 = Release|ARM
{11C084A3-A57C-4296-A679-CAC17B603144}.Release|x64.ActiveCfg = Release|x64
{11C084A3-A57C-4296-A679-CAC17B603144}.Release|x64.Build.0 = Release|x64
- {11C084A3-A57C-4296-A679-CAC17B603144}.Release|x86.ActiveCfg = Release|x86
- {11C084A3-A57C-4296-A679-CAC17B603144}.Release|x86.Build.0 = Release|x86
+ {11C084A3-A57C-4296-A679-CAC17B603144}.Release|x86.ActiveCfg = Release|Win32
+ {11C084A3-A57C-4296-A679-CAC17B603144}.Release|x86.Build.0 = Release|Win32
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
diff --git a/vnext/Playground/Playground/Assets/Bundle/Playground/Playground/index.uwp.bundle b/vnext/Playground/Playground/Assets/Bundle/Playground/Playground/index.uwp.bundle
new file mode 100644
index 00000000000..b04eaac15fb
--- /dev/null
+++ b/vnext/Playground/Playground/Assets/Bundle/Playground/Playground/index.uwp.bundle
@@ -0,0 +1,86300 @@
+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";
+
+ global.__r = metroRequire;
+ global.__d = define;
+ global.__c = clear;
+ global.__registerSegment = registerSegment;
+ var modules = clear();
+ var EMPTY = {};
+ var _ref = {},
+ hasOwnProperty = _ref.hasOwnProperty;
+
+ function clear() {
+ modules = typeof __NUM_MODULES__ === "number" ? Array(__NUM_MODULES__ | 0) : Object.create(null);
+ return modules;
+ }
+
+ if (__DEV__) {
+ var verboseNamesToModuleIds = Object.create(null);
+ var initializingModuleIds = [];
+ }
+
+ function define(factory, moduleId, dependencyMap) {
+ if (modules[moduleId] != null) {
+ if (__DEV__) {
+ var inverseDependencies = arguments[4];
+
+ if (inverseDependencies) {
+ global.__accept(moduleId, factory, dependencyMap, inverseDependencies);
+ }
+ }
+
+ return;
+ }
+
+ modules[moduleId] = {
+ dependencyMap: dependencyMap,
+ factory: factory,
+ hasError: false,
+ importedAll: EMPTY,
+ importedDefault: EMPTY,
+ isInitialized: false,
+ publicModule: {
+ exports: {}
+ }
+ };
+
+ 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: "'.concat(verboseName, '"'));
+ } else {
+ console.warn('Requiring module "'.concat(verboseName, '" by name is only supported for ') + "debugging purposes and will BREAK IN PRODUCTION!");
+ }
+ }
+
+ var moduleIdReallyIsNumber = moduleId;
+
+ if (__DEV__) {
+ var initializingIndex = initializingModuleIds.indexOf(moduleIdReallyIsNumber);
+
+ if (initializingIndex !== -1) {
+ var cycle = initializingModuleIds.slice(initializingIndex).map(function (id) {
+ return modules[id].verboseName;
+ });
+ cycle.push(cycle[0]);
+ console.warn("Require cycle: ".concat(cycle.join(" -> "), "\n\n") + "Require cycles are allowed, but can result in uninitialized values. " + "Consider refactoring to remove the need for a cycle.");
+ }
+ }
+
+ var module = modules[moduleIdReallyIsNumber];
+ return module && module.isInitialized ? module.publicModule.exports : guardedLoadModule(moduleIdReallyIsNumber, module);
+ }
+
+ function metroImportDefault(moduleId) {
+ if (__DEV__ && typeof moduleId === "string") {
+ var verboseName = moduleId;
+ moduleId = verboseNamesToModuleIds[verboseName];
+ }
+
+ var moduleIdReallyIsNumber = moduleId;
+
+ if (modules[moduleIdReallyIsNumber] && modules[moduleIdReallyIsNumber].importedDefault !== EMPTY) {
+ return modules[moduleIdReallyIsNumber].importedDefault;
+ }
+
+ var exports = metroRequire(moduleIdReallyIsNumber);
+ var importedDefault = exports && exports.__esModule ? exports.default : exports;
+ return modules[moduleIdReallyIsNumber].importedDefault = importedDefault;
+ }
+
+ metroRequire.importDefault = metroImportDefault;
+
+ function metroImportAll(moduleId) {
+ if (__DEV__ && typeof moduleId === "string") {
+ var verboseName = moduleId;
+ moduleId = verboseNamesToModuleIds[verboseName];
+ }
+
+ var moduleIdReallyIsNumber = moduleId;
+
+ if (modules[moduleIdReallyIsNumber] && modules[moduleIdReallyIsNumber].importedAll !== EMPTY) {
+ return modules[moduleIdReallyIsNumber].importedAll;
+ }
+
+ var exports = metroRequire(moduleIdReallyIsNumber);
+ var importedAll;
+
+ if (exports && exports.__esModule) {
+ importedAll = exports;
+ } else {
+ importedAll = {};
+
+ if (exports) {
+ for (var _key in exports) {
+ if (hasOwnProperty.call(exports, _key)) {
+ importedAll[_key] = exports[_key];
+ }
+ }
+ }
+
+ importedAll.default = exports;
+ }
+
+ return modules[moduleIdReallyIsNumber].importedAll = importedAll;
+ }
+
+ metroRequire.importAll = metroImportAll;
+ var inGuard = false;
+
+ function guardedLoadModule(moduleId, module) {
+ if (!inGuard && global.ErrorUtils) {
+ inGuard = true;
+ var returnValue;
+
+ try {
+ returnValue = loadModuleImplementation(moduleId, module);
+ } catch (e) {
+ global.ErrorUtils.reportFatalError(e);
+ }
+
+ inGuard = false;
+ return returnValue;
+ } else {
+ return loadModuleImplementation(moduleId, module);
+ }
+ }
+
+ var ID_MASK_SHIFT = 16;
+ var LOCAL_ID_MASK = ~0 >>> ID_MASK_SHIFT;
+
+ function unpackModuleId(moduleId) {
+ var segmentId = moduleId >>> ID_MASK_SHIFT;
+ var localId = moduleId & LOCAL_ID_MASK;
+ return {
+ segmentId: segmentId,
+ localId: localId
+ };
+ }
+
+ metroRequire.unpackModuleId = unpackModuleId;
+
+ function packModuleId(value) {
+ return (value.segmentId << ID_MASK_SHIFT) + value.localId;
+ }
+
+ metroRequire.packModuleId = packModuleId;
+ var hooks = [];
+
+ function registerHook(cb) {
+ var hook = {
+ cb: cb
+ };
+ hooks.push(hook);
+ return {
+ release: function release() {
+ for (var i = 0; i < hooks.length; ++i) {
+ if (hooks[i] === hook) {
+ hooks.splice(i, 1);
+ break;
+ }
+ }
+ }
+ };
+ }
+
+ metroRequire.registerHook = registerHook;
+ var moduleDefinersBySegmentID = [];
+
+ function registerSegment(segmentID, moduleDefiner) {
+ moduleDefinersBySegmentID[segmentID] = moduleDefiner;
+ }
+
+ function loadModuleImplementation(moduleId, module) {
+ if (!module && moduleDefinersBySegmentID.length > 0) {
+ var _unpackModuleId = unpackModuleId(moduleId),
+ segmentId = _unpackModuleId.segmentId,
+ localId = _unpackModuleId.localId;
+
+ var definer = moduleDefinersBySegmentID[segmentId];
+
+ if (definer != null) {
+ definer(localId);
+ module = modules[moduleId];
+ }
+ }
+
+ var nativeRequire = global.nativeRequire;
+
+ if (!module && nativeRequire) {
+ var _unpackModuleId2 = unpackModuleId(moduleId),
+ _segmentId = _unpackModuleId2.segmentId,
+ _localId = _unpackModuleId2.localId;
+
+ nativeRequire(_localId, _segmentId);
+ module = modules[moduleId];
+ }
+
+ if (!module) {
+ throw unknownModuleError(moduleId);
+ }
+
+ if (module.hasError) {
+ throw moduleThrewError(moduleId, module.error);
+ }
+
+ if (__DEV__) {
+ var Systrace = metroRequire.Systrace;
+ }
+
+ module.isInitialized = true;
+ var _module = module,
+ factory = _module.factory,
+ dependencyMap = _module.dependencyMap;
+
+ if (__DEV__) {
+ initializingModuleIds.push(moduleId);
+ }
+
+ try {
+ if (__DEV__) {
+ Systrace.beginEvent("JS_require_" + (module.verboseName || moduleId));
+ }
+
+ var _moduleObject = module.publicModule;
+
+ if (__DEV__) {
+ if (module.hot) {
+ _moduleObject.hot = module.hot;
+ }
+ }
+
+ _moduleObject.id = moduleId;
+
+ if (hooks.length > 0) {
+ for (var i = 0; i < hooks.length; ++i) {
+ hooks[i].cb(moduleId, _moduleObject);
+ }
+ }
+
+ factory(global, metroRequire, metroImportDefault, metroImportAll, _moduleObject, _moduleObject.exports, dependencyMap);
+
+ if (!__DEV__) {
+ module.factory = undefined;
+ module.dependencyMap = undefined;
+ }
+
+ if (__DEV__) {
+ Systrace.endEvent();
+ }
+
+ return _moduleObject.exports;
+ } catch (e) {
+ module.hasError = true;
+ module.error = e;
+ module.isInitialized = false;
+ module.publicModule.exports = undefined;
+ throw e;
+ } finally {
+ if (__DEV__) {
+ if (initializingModuleIds.pop() !== moduleId) {
+ throw new Error("initializingModuleIds is corrupt; something is terribly wrong");
+ }
+ }
+ }
+ }
+
+ 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 ".concat(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 ".concat(id, ": "), error);
+ }
+ }
+
+ if (!inverseDependencies) {
+ throw new Error("Undefined `inverseDependencies`");
+ }
+
+ return metroAcceptAll(inverseDependencies[id], inverseDependencies, patchedModules);
+ };
+
+ global.__accept = metroAccept;
+ }
+})(typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : this);
+(function (global) {
+ if (typeof Object.assign !== 'function') {
+ Object.defineProperty(Object, 'assign', {
+ value: function assign(target, varArgs) {
+ 'use strict';
+
+ if (target == null) {
+ throw new TypeError('Cannot convert undefined or null to object');
+ }
+
+ var to = Object(target);
+
+ for (var index = 1; index < arguments.length; index++) {
+ var nextSource = arguments[index];
+
+ if (nextSource != null) {
+ for (var nextKey in nextSource) {
+ if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {
+ to[nextKey] = nextSource[nextKey];
+ }
+ }
+ }
+ }
+
+ return to;
+ },
+ writable: true,
+ configurable: true
+ });
+ }
+})(typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : 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 objectToString(o) {
+ return Object.prototype.toString.call(o);
+ }
+
+ function hasOwnProperty(obj, prop) {
+ return Object.prototype.hasOwnProperty.call(obj, prop);
+ }
+
+ return inspect;
+ }();
+
+ var OBJECT_COLUMN_NAME = '(index)';
+ var LOG_LEVELS = {
+ trace: 0,
+ info: 1,
+ warn: 2,
+ error: 3
+ };
+ var INSPECTOR_LEVELS = [];
+ INSPECTOR_LEVELS[LOG_LEVELS.trace] = 'debug';
+ INSPECTOR_LEVELS[LOG_LEVELS.info] = 'log';
+ INSPECTOR_LEVELS[LOG_LEVELS.warn] = 'warning';
+ INSPECTOR_LEVELS[LOG_LEVELS.error] = 'error';
+ var INSPECTOR_FRAMES_TO_SKIP = __DEV__ ? 2 : 1;
+
+ function getNativeLogFunction(level) {
+ return function () {
+ var str;
+
+ if (arguments.length === 1 && typeof arguments[0] === 'string') {
+ str = arguments[0];
+ } else {
+ str = Array.prototype.map.call(arguments, function (arg) {
+ return inspect(arg, {
+ depth: 10
+ });
+ }).join(', ');
+ }
+
+ var logLevel = level;
+
+ if (str.slice(0, 9) === 'Warning: ' && logLevel >= LOG_LEVELS.error) {
+ logLevel = LOG_LEVELS.warn;
+ }
+
+ if (global.__inspectorLog) {
+ global.__inspectorLog(INSPECTOR_LEVELS[logLevel], str, [].slice.call(arguments), INSPECTOR_FRAMES_TO_SKIP);
+ }
+
+ if (groupStack.length) {
+ str = groupFormat('', str);
+ }
+
+ global.nativeLoggingHook(str, logLevel);
+ };
+ }
+
+ function repeat(element, n) {
+ return Array.apply(null, Array(n)).map(function () {
+ return element;
+ });
+ }
+
+ function consoleTablePolyfill(rows) {
+ if (!Array.isArray(rows)) {
+ var data = rows;
+ rows = [];
+
+ for (var key in data) {
+ if (data.hasOwnProperty(key)) {
+ var row = data[key];
+ row[OBJECT_COLUMN_NAME] = key;
+ rows.push(row);
+ }
+ }
+ }
+
+ if (rows.length === 0) {
+ global.nativeLoggingHook('', LOG_LEVELS.info);
+ return;
+ }
+
+ var columns = Object.keys(rows[0]).sort();
+ var stringRows = [];
+ var columnWidths = [];
+ columns.forEach(function (k, i) {
+ columnWidths[i] = k.length;
+
+ for (var j = 0; j < rows.length; j++) {
+ var cellStr = (rows[j][k] || '?').toString();
+ stringRows[j] = stringRows[j] || [];
+ stringRows[j][i] = cellStr;
+ columnWidths[i] = Math.max(columnWidths[i], cellStr.length);
+ }
+ });
+
+ function joinRow(row, space) {
+ var cells = row.map(function (cell, i) {
+ var extraSpaces = repeat(' ', columnWidths[i] - cell.length).join('');
+ return cell + extraSpaces;
+ });
+ space = space || ' ';
+ return cells.join(space + '|' + space);
+ }
+
+ var separators = columnWidths.map(function (columnWidth) {
+ return repeat('-', columnWidth).join('');
+ });
+ var separatorRow = joinRow(separators, '-');
+ var header = joinRow(columns);
+ var table = [header, separatorRow];
+
+ for (var i = 0; i < rows.length; i++) {
+ table.push(joinRow(stringRows[i]));
+ }
+
+ global.nativeLoggingHook('\n' + table.join('\n'), LOG_LEVELS.info);
+ }
+
+ var GROUP_PAD = "\u2502";
+ var GROUP_OPEN = "\u2510";
+ var GROUP_CLOSE = "\u2518";
+ var groupStack = [];
+
+ function groupFormat(prefix, msg) {
+ return groupStack.join('') + prefix + ' ' + (msg || '');
+ }
+
+ function consoleGroupPolyfill(label) {
+ global.nativeLoggingHook(groupFormat(GROUP_OPEN, label), LOG_LEVELS.info);
+ groupStack.push(GROUP_PAD);
+ }
+
+ function consoleGroupCollapsedPolyfill(label) {
+ global.nativeLoggingHook(groupFormat(GROUP_CLOSE, label), LOG_LEVELS.info);
+ groupStack.push(GROUP_PAD);
+ }
+
+ function consoleGroupEndPolyfill() {
+ groupStack.pop();
+ global.nativeLoggingHook(groupFormat(GROUP_CLOSE), LOG_LEVELS.info);
+ }
+
+ if (global.nativeLoggingHook) {
+ var originalConsole = global.console;
+
+ if (__DEV__ && originalConsole) {
+ var descriptor = Object.getOwnPropertyDescriptor(global, 'console');
+
+ if (descriptor) {
+ Object.defineProperty(global, 'originalConsole', descriptor);
+ }
+ }
+
+ global.console = {
+ error: getNativeLogFunction(LOG_LEVELS.error),
+ info: getNativeLogFunction(LOG_LEVELS.info),
+ log: getNativeLogFunction(LOG_LEVELS.info),
+ warn: getNativeLogFunction(LOG_LEVELS.warn),
+ trace: getNativeLogFunction(LOG_LEVELS.trace),
+ debug: getNativeLogFunction(LOG_LEVELS.trace),
+ table: consoleTablePolyfill,
+ group: consoleGroupPolyfill,
+ groupEnd: consoleGroupEndPolyfill,
+ groupCollapsed: consoleGroupCollapsedPolyfill
+ };
+
+ if (__DEV__ && originalConsole) {
+ 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);
+ };
+ }
+ });
+ ['assert', 'clear', 'dir', 'dirxml', 'groupCollapsed', 'profile', 'profileEnd'].forEach(function (methodName) {
+ if (typeof originalConsole[methodName] === 'function') {
+ console[methodName] = function () {
+ originalConsole[methodName].apply(originalConsole, arguments);
+ };
+ }
+ });
+ }
+ } else if (!global.console) {
+ var log = global.print || function consoleLoggingStub() {};
+
+ global.console = {
+ error: log,
+ info: log,
+ log: log,
+ warn: log,
+ trace: log,
+ debug: log,
+ table: log
+ };
+ }
+})(typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : 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 || '';
+
+ function guarded() {
+ return ErrorUtils.applyWithGuard(fun, context || this, arguments, null, name);
+ }
+
+ return guarded;
+ }
+ };
+ global.ErrorUtils = ErrorUtils;
+})(typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : 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
+ });
+ }
+})(typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : 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;
+ };
+ }
+
+ if (!String.prototype.padEnd) {
+ String.prototype.padEnd = function padEnd(targetLength, padString) {
+ targetLength = targetLength >> 0;
+ padString = String(typeof padString !== 'undefined' ? padString : ' ');
+
+ if (this.length > targetLength) {
+ return String(this);
+ } else {
+ targetLength = targetLength - this.length;
+
+ if (targetLength > padString.length) {
+ padString += padString.repeat(targetLength / padString.length);
+ }
+
+ return String(this) + padString.slice(0, targetLength);
+ }
+ };
+ }
+
+ if (!String.prototype.padStart) {
+ String.prototype.padStart = function padStart(targetLength, padString) {
+ targetLength = targetLength >> 0;
+ padString = String(typeof padString !== 'undefined' ? padString : ' ');
+
+ if (this.length > targetLength) {
+ return String(this);
+ } else {
+ targetLength = targetLength - this.length;
+
+ if (targetLength > padString.length) {
+ padString += padString.repeat(targetLength / padString.length);
+ }
+
+ return padString.slice(0, targetLength) + String(this);
+ }
+ };
+ }
+})(typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : 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;
+ }
+ });
+ }
+})(typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : 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;
+ };
+ }
+})(typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : this);
+(function (global) {
+ (function () {
+ 'use strict';
+
+ var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+ if (typeof Object.entries !== 'function') {
+ Object.entries = function (object) {
+ if (object == null) {
+ throw new TypeError('Object.entries called on non-object');
+ }
+
+ var entries = [];
+
+ for (var key in object) {
+ if (hasOwnProperty.call(object, key)) {
+ entries.push([key, object[key]]);
+ }
+ }
+
+ return entries;
+ };
+ }
+
+ if (typeof Object.values !== 'function') {
+ Object.values = function (object) {
+ if (object == null) {
+ throw new TypeError('Object.values called on non-object');
+ }
+
+ var values = [];
+
+ for (var key in object) {
+ if (hasOwnProperty.call(object, key)) {
+ values.push(object[key]);
+ }
+ }
+
+ return values;
+ };
+ }
+ })();
+})(typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : this);
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+
+ var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireWildcard");
+
+ Object.defineProperty(exports, "__esModule", {
+ value: true
+ });
+ exports.default = void 0;
+
+ var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));
+
+ var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));
+
+ var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn"));
+
+ var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf"));
+
+ var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));
+
+ var _react = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[7], "react"));
+
+ var _reactNative = _$$_REQUIRE(_dependencyMap[8], "react-native");
+
+ var _reactNativeWindows = _$$_REQUIRE(_dependencyMap[9], "react-native-windows");
+
+ var _ToDoList = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "./ToDoList"));
+
+ var _SampleData = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[11], "./data/SampleData"));
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\index.uwp.js";
+ var initialState = {
+ tasks: _SampleData.default.getTasks()
+ };
+
+ var ToDoListApp = function (_Component) {
+ (0, _inherits2.default)(ToDoListApp, _Component);
+
+ function ToDoListApp() {
+ var _this;
+
+ (0, _classCallCheck2.default)(this, ToDoListApp);
+ _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(ToDoListApp).call(this));
+ _this.state = initialState;
+ return _this;
+ }
+
+ (0, _createClass2.default)(ToDoListApp, [{
+ key: "render",
+ value: function render() {
+ return _react.default.createElement(_reactNativeWindows.StackPanel, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 26
+ }
+ }, _react.default.createElement(_ToDoList.default, {
+ tasks: this.state.tasks,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 27
+ }
+ }));
+ }
+ }, {
+ key: "toggleSwitchChanged",
+ value: function toggleSwitchChanged(toggleState) {
+ this.setState({
+ dude: toggleState
+ });
+ }
+ }]);
+ return ToDoListApp;
+ }(_react.Component);
+
+ exports.default = ToDoListApp;
+
+ _reactNative.AppRegistry.registerComponent('ToDoListApp', function () {
+ return ToDoListApp;
+ });
+},0,[1,2,3,4,5,8,9,11,18,0,402,408],"index.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ function _interopRequireDefault(obj) {
+ return obj && obj.__esModule ? obj : {
+ "default": obj
+ };
+ }
+
+ module.exports = _interopRequireDefault;
+},1,[],"node_modules\\@babel\\runtime\\helpers\\interopRequireDefault.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 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;
+ }
+ }
+
+ module.exports = _interopRequireWildcard;
+},2,[],"node_modules\\@babel\\runtime\\helpers\\interopRequireWildcard.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ function _classCallCheck(instance, Constructor) {
+ if (!(instance instanceof Constructor)) {
+ throw new TypeError("Cannot call a class as a function");
+ }
+ }
+
+ module.exports = _classCallCheck;
+},3,[],"node_modules\\@babel\\runtime\\helpers\\classCallCheck.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ function _defineProperties(target, props) {
+ for (var i = 0; i < props.length; i++) {
+ var descriptor = props[i];
+ descriptor.enumerable = descriptor.enumerable || false;
+ descriptor.configurable = true;
+ if ("value" in descriptor) descriptor.writable = true;
+ Object.defineProperty(target, descriptor.key, descriptor);
+ }
+ }
+
+ function _createClass(Constructor, protoProps, staticProps) {
+ if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+ if (staticProps) _defineProperties(Constructor, staticProps);
+ return Constructor;
+ }
+
+ module.exports = _createClass;
+},4,[],"node_modules\\@babel\\runtime\\helpers\\createClass.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var _typeof = _$$_REQUIRE(_dependencyMap[0], "../helpers/typeof");
+
+ var assertThisInitialized = _$$_REQUIRE(_dependencyMap[1], "./assertThisInitialized");
+
+ function _possibleConstructorReturn(self, call) {
+ if (call && (_typeof(call) === "object" || typeof call === "function")) {
+ return call;
+ }
+
+ return assertThisInitialized(self);
+ }
+
+ module.exports = _possibleConstructorReturn;
+},5,[6,7],"node_modules\\@babel\\runtime\\helpers\\possibleConstructorReturn.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ function _typeof2(obj) {
+ if (typeof Symbol === "function" && typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") === "symbol") {
+ _typeof2 = function _typeof2(obj) {
+ return typeof obj;
+ };
+ } else {
+ _typeof2 = function _typeof2(obj) {
+ return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof obj;
+ };
+ }
+
+ return _typeof2(obj);
+ }
+
+ function _typeof(obj) {
+ if (typeof Symbol === "function" && _typeof2(typeof Symbol === "function" ? Symbol.iterator : "@@iterator") === "symbol") {
+ module.exports = _typeof = function _typeof(obj) {
+ return _typeof2(obj);
+ };
+ } else {
+ module.exports = _typeof = function _typeof(obj) {
+ return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : _typeof2(obj);
+ };
+ }
+
+ return _typeof(obj);
+ }
+
+ module.exports = _typeof;
+},6,[],"node_modules\\@babel\\runtime\\helpers\\typeof.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ function _assertThisInitialized(self) {
+ if (self === void 0) {
+ throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+ }
+
+ return self;
+ }
+
+ module.exports = _assertThisInitialized;
+},7,[],"node_modules\\@babel\\runtime\\helpers\\assertThisInitialized.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ function _getPrototypeOf(o) {
+ module.exports = _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+ return o.__proto__ || Object.getPrototypeOf(o);
+ };
+ return _getPrototypeOf(o);
+ }
+
+ module.exports = _getPrototypeOf;
+},8,[],"node_modules\\@babel\\runtime\\helpers\\getPrototypeOf.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var setPrototypeOf = _$$_REQUIRE(_dependencyMap[0], "./setPrototypeOf");
+
+ function _inherits(subClass, superClass) {
+ if (typeof superClass !== "function" && superClass !== null) {
+ throw new TypeError("Super expression must either be null or a function");
+ }
+
+ subClass.prototype = Object.create(superClass && superClass.prototype, {
+ constructor: {
+ value: subClass,
+ writable: true,
+ configurable: true
+ }
+ });
+ if (superClass) setPrototypeOf(subClass, superClass);
+ }
+
+ module.exports = _inherits;
+},9,[10],"node_modules\\@babel\\runtime\\helpers\\inherits.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ function _setPrototypeOf(o, p) {
+ module.exports = _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+ o.__proto__ = p;
+ return o;
+ };
+
+ return _setPrototypeOf(o, p);
+ }
+
+ module.exports = _setPrototypeOf;
+},10,[],"node_modules\\@babel\\runtime\\helpers\\setPrototypeOf.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ if (process.env.NODE_ENV === 'production') {
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "./cjs/react.production.min.js");
+ } else {
+ module.exports = _$$_REQUIRE(_dependencyMap[1], "./cjs/react.development.js");
+ }
+},11,[12,15],"node_modules\\react\\index.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ /** @license React v16.8.3
+ * react.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+ 'use strict';
+
+ var k = _$$_REQUIRE(_dependencyMap[0], "object-assign"),
+ n = "function" === typeof Symbol && (typeof Symbol === "function" ? Symbol.for : "@@for"),
+ p = n ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.element") : 60103,
+ q = n ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.portal") : 60106,
+ r = n ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.fragment") : 60107,
+ t = n ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.strict_mode") : 60108,
+ u = n ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.profiler") : 60114,
+ v = n ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.provider") : 60109,
+ w = n ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.context") : 60110,
+ x = n ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.concurrent_mode") : 60111,
+ y = n ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.forward_ref") : 60112,
+ z = n ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.suspense") : 60113,
+ aa = n ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.memo") : 60115,
+ ba = n ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.lazy") : 60116,
+ A = "function" === typeof Symbol && (typeof Symbol === "function" ? Symbol.iterator : "@@iterator");
+
+ function ca(a, b, d, c, e, g, h, f) {
+ if (!a) {
+ a = void 0;
+ if (void 0 === b) a = Error("Minified exception occurred; use the non-minified dev environment for the full error message and additional helpful warnings.");else {
+ var l = [d, c, e, g, h, f],
+ m = 0;
+ a = Error(b.replace(/%s/g, function () {
+ return l[m++];
+ }));
+ a.name = "Invariant Violation";
+ }
+ a.framesToPop = 1;
+ throw a;
+ }
+ }
+
+ function B(a) {
+ for (var b = arguments.length - 1, d = "https://reactjs.org/docs/error-decoder.html?invariant=" + a, c = 0; c < b; c++) {
+ d += "&args[]=" + encodeURIComponent(arguments[c + 1]);
+ }
+
+ ca(!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. ", d);
+ }
+
+ var C = {
+ isMounted: function isMounted() {
+ return !1;
+ },
+ enqueueForceUpdate: function enqueueForceUpdate() {},
+ enqueueReplaceState: function enqueueReplaceState() {},
+ enqueueSetState: function enqueueSetState() {}
+ },
+ D = {};
+
+ function E(a, b, d) {
+ this.props = a;
+ this.context = b;
+ this.refs = D;
+ this.updater = d || C;
+ }
+
+ E.prototype.isReactComponent = {};
+
+ E.prototype.setState = function (a, b) {
+ "object" !== typeof a && "function" !== typeof a && null != a ? B("85") : void 0;
+ this.updater.enqueueSetState(this, a, b, "setState");
+ };
+
+ E.prototype.forceUpdate = function (a) {
+ this.updater.enqueueForceUpdate(this, a, "forceUpdate");
+ };
+
+ function F() {}
+
+ F.prototype = E.prototype;
+
+ function G(a, b, d) {
+ this.props = a;
+ this.context = b;
+ this.refs = D;
+ this.updater = d || C;
+ }
+
+ var H = G.prototype = new F();
+ H.constructor = G;
+ k(H, E.prototype);
+ H.isPureReactComponent = !0;
+ var I = {
+ current: null
+ },
+ J = {
+ current: null
+ },
+ K = Object.prototype.hasOwnProperty,
+ L = {
+ key: !0,
+ ref: !0,
+ __self: !0,
+ __source: !0
+ };
+
+ function M(a, b, d) {
+ var c = void 0,
+ e = {},
+ g = null,
+ 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) && (e[c] = b[c]);
+ }
+ var f = arguments.length - 2;
+ if (1 === f) e.children = d;else if (1 < f) {
+ for (var l = Array(f), m = 0; m < f; m++) {
+ l[m] = arguments[m + 2];
+ }
+
+ e.children = l;
+ }
+ if (a && a.defaultProps) for (c in f = a.defaultProps, f) {
+ void 0 === e[c] && (e[c] = f[c]);
+ }
+ return {
+ $$typeof: p,
+ type: a,
+ key: g,
+ ref: h,
+ props: e,
+ _owner: J.current
+ };
+ }
+
+ function da(a, b) {
+ return {
+ $$typeof: p,
+ type: a.type,
+ key: b,
+ ref: a.ref,
+ props: a.props,
+ _owner: a._owner
+ };
+ }
+
+ function N(a) {
+ return "object" === typeof a && null !== a && a.$$typeof === p;
+ }
+
+ function escape(a) {
+ var b = {
+ "=": "=0",
+ ":": "=2"
+ };
+ return "$" + ("" + a).replace(/[=:]/g, function (a) {
+ return b[a];
+ });
+ }
+
+ var O = /\/+/g,
+ P = [];
+
+ function Q(a, b, d, c) {
+ if (P.length) {
+ var e = P.pop();
+ e.result = a;
+ e.keyPrefix = b;
+ e.func = d;
+ e.context = c;
+ e.count = 0;
+ return e;
+ }
+
+ return {
+ result: a,
+ keyPrefix: b,
+ func: d,
+ context: c,
+ count: 0
+ };
+ }
+
+ function R(a) {
+ a.result = null;
+ a.keyPrefix = null;
+ a.func = null;
+ a.context = null;
+ a.count = 0;
+ 10 > P.length && P.push(a);
+ }
+
+ function S(a, b, d, c) {
+ var e = typeof a;
+ if ("undefined" === e || "boolean" === e) a = null;
+ var g = !1;
+ if (null === a) g = !0;else switch (e) {
+ case "string":
+ case "number":
+ g = !0;
+ break;
+
+ case "object":
+ switch (a.$$typeof) {
+ case p:
+ case q:
+ g = !0;
+ }
+
+ }
+ if (g) return d(c, a, "" === b ? "." + T(a, 0) : b), 1;
+ g = 0;
+ b = "" === b ? "." : b + ":";
+ if (Array.isArray(a)) for (var h = 0; h < a.length; h++) {
+ e = a[h];
+ var f = b + T(e, h);
+ g += S(e, f, d, c);
+ } else if (null === a || "object" !== typeof a ? f = null : (f = A && a[A] || a["@@iterator"], f = "function" === typeof f ? f : null), "function" === typeof f) for (a = f.call(a), h = 0; !(e = a.next()).done;) {
+ e = e.value, f = b + T(e, h++), g += S(e, f, d, c);
+ } else "object" === e && (d = "" + a, B("31", "[object Object]" === d ? "object with keys {" + Object.keys(a).join(", ") + "}" : d, ""));
+ return g;
+ }
+
+ function U(a, b, d) {
+ return null == a ? 0 : S(a, "", b, d);
+ }
+
+ function T(a, b) {
+ return "object" === typeof a && null !== a && null != a.key ? escape(a.key) : b.toString(36);
+ }
+
+ function ea(a, b) {
+ a.func.call(a.context, b, a.count++);
+ }
+
+ function fa(a, b, d) {
+ var c = a.result,
+ e = a.keyPrefix;
+ a = a.func.call(a.context, b, a.count++);
+ Array.isArray(a) ? V(a, c, d, function (a) {
+ return a;
+ }) : null != a && (N(a) && (a = da(a, e + (!a.key || b && b.key === a.key ? "" : ("" + a.key).replace(O, "$&/") + "/") + d)), c.push(a));
+ }
+
+ function V(a, b, d, c, e) {
+ var g = "";
+ null != d && (g = ("" + d).replace(O, "$&/") + "/");
+ b = Q(b, g, c, e);
+ U(a, fa, b);
+ R(b);
+ }
+
+ function W() {
+ var a = I.current;
+ null === a ? B("307") : void 0;
+ return a;
+ }
+
+ var X = {
+ Children: {
+ map: function map(a, b, d) {
+ if (null == a) return a;
+ var c = [];
+ V(a, c, null, b, d);
+ return c;
+ },
+ forEach: function forEach(a, b, d) {
+ if (null == a) return a;
+ b = Q(null, null, b, d);
+ U(a, ea, b);
+ R(b);
+ },
+ count: function count(a) {
+ return U(a, function () {
+ return null;
+ }, null);
+ },
+ toArray: function toArray(a) {
+ var b = [];
+ V(a, b, null, function (a) {
+ return a;
+ });
+ return b;
+ },
+ only: function only(a) {
+ N(a) ? void 0 : B("143");
+ return a;
+ }
+ },
+ createRef: function createRef() {
+ return {
+ current: null
+ };
+ },
+ Component: E,
+ PureComponent: G,
+ createContext: function createContext(a, b) {
+ void 0 === b && (b = null);
+ a = {
+ $$typeof: w,
+ _calculateChangedBits: b,
+ _currentValue: a,
+ _currentValue2: a,
+ _threadCount: 0,
+ Provider: null,
+ Consumer: null
+ };
+ a.Provider = {
+ $$typeof: v,
+ _context: a
+ };
+ return a.Consumer = a;
+ },
+ forwardRef: function forwardRef(a) {
+ return {
+ $$typeof: y,
+ render: a
+ };
+ },
+ lazy: function lazy(a) {
+ return {
+ $$typeof: ba,
+ _ctor: a,
+ _status: -1,
+ _result: null
+ };
+ },
+ memo: function memo(a, b) {
+ return {
+ $$typeof: aa,
+ type: a,
+ compare: void 0 === b ? null : b
+ };
+ },
+ useCallback: function useCallback(a, b) {
+ return W().useCallback(a, b);
+ },
+ useContext: function useContext(a, b) {
+ return W().useContext(a, b);
+ },
+ useEffect: function useEffect(a, b) {
+ return W().useEffect(a, b);
+ },
+ useImperativeHandle: function useImperativeHandle(a, b, d) {
+ return W().useImperativeHandle(a, b, d);
+ },
+ useDebugValue: function useDebugValue() {},
+ useLayoutEffect: function useLayoutEffect(a, b) {
+ return W().useLayoutEffect(a, b);
+ },
+ useMemo: function useMemo(a, b) {
+ return W().useMemo(a, b);
+ },
+ useReducer: function useReducer(a, b, d) {
+ return W().useReducer(a, b, d);
+ },
+ useRef: function useRef(a) {
+ return W().useRef(a);
+ },
+ useState: function useState(a) {
+ return W().useState(a);
+ },
+ Fragment: r,
+ StrictMode: t,
+ Suspense: z,
+ createElement: M,
+ cloneElement: function cloneElement(a, b, d) {
+ null === a || void 0 === a ? B("267", a) : void 0;
+ var c = void 0,
+ e = 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) && (e[c] = void 0 === b[c] && void 0 !== l ? l[c] : b[c]);
+ }
+ }
+
+ c = arguments.length - 2;
+ if (1 === c) e.children = d;else if (1 < c) {
+ l = Array(c);
+
+ for (var m = 0; m < c; m++) {
+ l[m] = arguments[m + 2];
+ }
+
+ e.children = l;
+ }
+ return {
+ $$typeof: p,
+ type: a.type,
+ key: g,
+ ref: h,
+ props: e,
+ _owner: f
+ };
+ },
+ createFactory: function createFactory(a) {
+ var b = M.bind(null, a);
+ b.type = a;
+ return b;
+ },
+ isValidElement: N,
+ version: "16.8.3",
+ unstable_ConcurrentMode: x,
+ unstable_Profiler: u,
+ __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: {
+ ReactCurrentDispatcher: I,
+ ReactCurrentOwner: J,
+ assign: k
+ }
+ },
+ Y = {
+ default: X
+ },
+ Z = Y && X || Y;
+ module.exports = Z.default || Z;
+},12,[13],"node_modules\\react\\cjs\\react.production.min.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ /*
+ object-assign
+ (c) Sindre Sorhus
+ @license MIT
+ */
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+ var hasOwnProperty = Object.prototype.hasOwnProperty;
+ var propIsEnumerable = Object.prototype.propertyIsEnumerable;
+
+ function toObject(val) {
+ if (val === null || val === undefined) {
+ throw new TypeError('Object.assign cannot be called with null or undefined');
+ }
+
+ return Object(val);
+ }
+
+ function shouldUseNative() {
+ try {
+ if (!Object.assign) {
+ return false;
+ }
+
+ var test1 = new String('abc');
+ test1[5] = 'de';
+
+ if (Object.getOwnPropertyNames(test1)[0] === '5') {
+ return false;
+ }
+
+ var test2 = {};
+
+ for (var i = 0; i < 10; i++) {
+ test2['_' + String.fromCharCode(i)] = i;
+ }
+
+ var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
+ return test2[n];
+ });
+
+ if (order2.join('') !== '0123456789') {
+ return false;
+ }
+
+ var test3 = {};
+ 'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
+ test3[letter] = letter;
+ });
+
+ if (Object.keys(_extends({}, test3)).join('') !== 'abcdefghijklmnopqrst') {
+ return false;
+ }
+
+ return true;
+ } catch (err) {
+ return false;
+ }
+ }
+
+ module.exports = shouldUseNative() ? Object.assign : function (target, source) {
+ var from;
+ var to = toObject(target);
+ var symbols;
+
+ for (var s = 1; s < arguments.length; s++) {
+ from = Object(arguments[s]);
+
+ for (var key in from) {
+ if (hasOwnProperty.call(from, key)) {
+ to[key] = from[key];
+ }
+ }
+
+ if (getOwnPropertySymbols) {
+ symbols = getOwnPropertySymbols(from);
+
+ for (var i = 0; i < symbols.length; i++) {
+ if (propIsEnumerable.call(from, symbols[i])) {
+ to[symbols[i]] = from[symbols[i]];
+ }
+ }
+ }
+ }
+
+ return to;
+ };
+},13,[14],"node_modules\\object-assign\\index.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ function _extends() {
+ module.exports = _extends = Object.assign || function (target) {
+ for (var i = 1; i < arguments.length; i++) {
+ var source = arguments[i];
+
+ for (var key in source) {
+ if (Object.prototype.hasOwnProperty.call(source, key)) {
+ target[key] = source[key];
+ }
+ }
+ }
+
+ return target;
+ };
+
+ return _extends.apply(this, arguments);
+ }
+
+ module.exports = _extends;
+},14,[],"node_modules\\@babel\\runtime\\helpers\\extends.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ /** @license React v16.8.3
+ * react.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+ 'use strict';
+
+ if (process.env.NODE_ENV !== "production") {
+ (function () {
+ 'use strict';
+
+ var _assign = _$$_REQUIRE(_dependencyMap[0], "object-assign");
+
+ var checkPropTypes = _$$_REQUIRE(_dependencyMap[1], "prop-types/checkPropTypes");
+
+ var ReactVersion = '16.8.3';
+ var hasSymbol = typeof Symbol === 'function' && (typeof Symbol === "function" ? Symbol.for : "@@for");
+ var REACT_ELEMENT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.element') : 0xeac7;
+ var REACT_PORTAL_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.portal') : 0xeaca;
+ var REACT_FRAGMENT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.fragment') : 0xeacb;
+ var REACT_STRICT_MODE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.strict_mode') : 0xeacc;
+ var REACT_PROFILER_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.profiler') : 0xead2;
+ var REACT_PROVIDER_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.provider') : 0xeacd;
+ var REACT_CONTEXT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.context') : 0xeace;
+ var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.concurrent_mode') : 0xeacf;
+ var REACT_FORWARD_REF_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.forward_ref') : 0xead0;
+ var REACT_SUSPENSE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.suspense') : 0xead1;
+ var REACT_MEMO_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.memo') : 0xead3;
+ var REACT_LAZY_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.lazy') : 0xead4;
+ var MAYBE_ITERATOR_SYMBOL = typeof Symbol === 'function' && (typeof Symbol === "function" ? Symbol.iterator : "@@iterator");
+ var FAUX_ITERATOR_SYMBOL = '@@iterator';
+
+ function getIteratorFn(maybeIterable) {
+ if (maybeIterable === null || typeof maybeIterable !== 'object') {
+ return null;
+ }
+
+ var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+ if (typeof maybeIterator === 'function') {
+ return maybeIterator;
+ }
+
+ return null;
+ }
+
+ var validateFormat = function validateFormat() {};
+
+ {
+ 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 = void 0;
+
+ 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;
+ }
+ }
+
+ var lowPriorityWarning = function lowPriorityWarning() {};
+
+ {
+ var printWarning = function printWarning(format) {
+ for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+ args[_key - 1] = arguments[_key];
+ }
+
+ var argIndex = 0;
+ var message = 'Warning: ' + format.replace(/%s/g, function () {
+ return args[argIndex++];
+ });
+
+ if (typeof console !== 'undefined') {
+ console.warn(message);
+ }
+
+ try {
+ throw new Error(message);
+ } catch (x) {}
+ };
+
+ lowPriorityWarning = function lowPriorityWarning(condition, format) {
+ if (format === undefined) {
+ throw new Error('`lowPriorityWarning(condition, format, ...args)` requires a warning ' + 'message argument');
+ }
+
+ if (!condition) {
+ for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
+ args[_key2 - 2] = arguments[_key2];
+ }
+
+ printWarning.apply(undefined, [format].concat(args));
+ }
+ };
+ }
+ var lowPriorityWarning$1 = lowPriorityWarning;
+
+ var warningWithoutStack = function warningWithoutStack() {};
+
+ {
+ warningWithoutStack = function warningWithoutStack(condition, format) {
+ for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+ args[_key - 2] = arguments[_key];
+ }
+
+ if (format === undefined) {
+ throw new Error('`warningWithoutStack(condition, format, ...args)` requires a warning ' + 'message argument');
+ }
+
+ if (args.length > 8) {
+ throw new Error('warningWithoutStack() currently supports at most 8 arguments.');
+ }
+
+ if (condition) {
+ return;
+ }
+
+ if (typeof console !== 'undefined') {
+ var argsWithFormat = args.map(function (item) {
+ return '' + item;
+ });
+ argsWithFormat.unshift('Warning: ' + format);
+ Function.prototype.apply.call(console.error, console, argsWithFormat);
+ }
+
+ try {
+ var argIndex = 0;
+ var message = 'Warning: ' + format.replace(/%s/g, function () {
+ return args[argIndex++];
+ });
+ throw new Error(message);
+ } catch (x) {}
+ };
+ }
+ var warningWithoutStack$1 = warningWithoutStack;
+ var didWarnStateUpdateForUnmountedComponent = {};
+
+ function warnNoop(publicInstance, callerName) {
+ {
+ var _constructor = publicInstance.constructor;
+ var componentName = _constructor && (_constructor.displayName || _constructor.name) || 'ReactClass';
+ var warningKey = componentName + '.' + callerName;
+
+ if (didWarnStateUpdateForUnmountedComponent[warningKey]) {
+ return;
+ }
+
+ warningWithoutStack$1(false, "Can't call %s on a component that is not yet mounted. " + 'This is a no-op, but it might indicate a bug in your application. ' + 'Instead, assign to `this.state` directly or define a `state = {};` ' + 'class property with the desired state in the %s component.', callerName, componentName);
+ didWarnStateUpdateForUnmountedComponent[warningKey] = true;
+ }
+ }
+
+ var ReactNoopUpdateQueue = {
+ isMounted: function isMounted(publicInstance) {
+ return false;
+ },
+ enqueueForceUpdate: function enqueueForceUpdate(publicInstance, callback, callerName) {
+ warnNoop(publicInstance, 'forceUpdate');
+ },
+ enqueueReplaceState: function enqueueReplaceState(publicInstance, completeState, callback, callerName) {
+ warnNoop(publicInstance, 'replaceState');
+ },
+ enqueueSetState: function enqueueSetState(publicInstance, partialState, callback, callerName) {
+ warnNoop(publicInstance, 'setState');
+ }
+ };
+ var emptyObject = {};
+ {
+ Object.freeze(emptyObject);
+ }
+
+ function Component(props, context, updater) {
+ this.props = props;
+ this.context = context;
+ this.refs = emptyObject;
+ this.updater = updater || ReactNoopUpdateQueue;
+ }
+
+ Component.prototype.isReactComponent = {};
+
+ Component.prototype.setState = function (partialState, callback) {
+ !(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 ReactCurrentDispatcher = {
+ current: null
+ };
+ var ReactCurrentOwner = {
+ current: null
+ };
+ var BEFORE_SLASH_RE = /^(.*)[\\\/]/;
+
+ var describeComponentFrame = function describeComponentFrame(name, source, ownerName) {
+ var sourceInfo = '';
+
+ if (source) {
+ var path = source.fileName;
+ var fileName = path.replace(BEFORE_SLASH_RE, '');
+ {
+ if (/^index\./.test(fileName)) {
+ var match = path.match(BEFORE_SLASH_RE);
+
+ if (match) {
+ var pathBeforeSlash = match[1];
+
+ if (pathBeforeSlash) {
+ var folderName = pathBeforeSlash.replace(BEFORE_SLASH_RE, '');
+ fileName = folderName + '/' + fileName;
+ }
+ }
+ }
+ }
+ sourceInfo = ' (at ' + fileName + ':' + source.lineNumber + ')';
+ } else if (ownerName) {
+ sourceInfo = ' (created by ' + ownerName + ')';
+ }
+
+ return '\n in ' + (name || 'Unknown') + sourceInfo;
+ };
+
+ var Resolved = 1;
+
+ function refineResolvedLazyComponent(lazyComponent) {
+ return lazyComponent._status === Resolved ? lazyComponent._result : null;
+ }
+
+ function getWrappedName(outerType, innerType, wrapperName) {
+ var functionName = innerType.displayName || innerType.name || '';
+ return outerType.displayName || (functionName !== '' ? wrapperName + '(' + functionName + ')' : wrapperName);
+ }
+
+ function getComponentName(type) {
+ if (type == null) {
+ return null;
+ }
+
+ {
+ if (typeof type.tag === 'number') {
+ warningWithoutStack$1(false, 'Received an unexpected object in getComponentName(). ' + 'This is likely a bug in React. Please file an issue.');
+ }
+ }
+
+ if (typeof type === 'function') {
+ return type.displayName || type.name || null;
+ }
+
+ if (typeof type === 'string') {
+ return type;
+ }
+
+ switch (type) {
+ case REACT_CONCURRENT_MODE_TYPE:
+ return 'ConcurrentMode';
+
+ case REACT_FRAGMENT_TYPE:
+ return 'Fragment';
+
+ case REACT_PORTAL_TYPE:
+ return 'Portal';
+
+ case REACT_PROFILER_TYPE:
+ return 'Profiler';
+
+ case REACT_STRICT_MODE_TYPE:
+ return 'StrictMode';
+
+ case REACT_SUSPENSE_TYPE:
+ return 'Suspense';
+ }
+
+ if (typeof type === 'object') {
+ switch (type.$$typeof) {
+ case REACT_CONTEXT_TYPE:
+ return 'Context.Consumer';
+
+ case REACT_PROVIDER_TYPE:
+ return 'Context.Provider';
+
+ case REACT_FORWARD_REF_TYPE:
+ return getWrappedName(type, type.render, 'ForwardRef');
+
+ case REACT_MEMO_TYPE:
+ return getComponentName(type.type);
+
+ case REACT_LAZY_TYPE:
+ {
+ var thenable = type;
+ var resolvedThenable = refineResolvedLazyComponent(thenable);
+
+ if (resolvedThenable) {
+ return getComponentName(resolvedThenable);
+ }
+ }
+ }
+ }
+
+ return null;
+ }
+
+ var ReactDebugCurrentFrame = {};
+ var currentlyValidatingElement = null;
+
+ function setCurrentlyValidatingElement(element) {
+ {
+ currentlyValidatingElement = element;
+ }
+ }
+
+ {
+ ReactDebugCurrentFrame.getCurrentStack = null;
+
+ ReactDebugCurrentFrame.getStackAddendum = function () {
+ var stack = '';
+
+ if (currentlyValidatingElement) {
+ var name = getComponentName(currentlyValidatingElement.type);
+ var owner = currentlyValidatingElement._owner;
+ stack += describeComponentFrame(name, currentlyValidatingElement._source, owner && getComponentName(owner.type));
+ }
+
+ var impl = ReactDebugCurrentFrame.getCurrentStack;
+
+ if (impl) {
+ stack += impl() || '';
+ }
+
+ return stack;
+ };
+ }
+ var ReactSharedInternals = {
+ ReactCurrentDispatcher: ReactCurrentDispatcher,
+ ReactCurrentOwner: ReactCurrentOwner,
+ assign: _assign
+ };
+ {
+ _assign(ReactSharedInternals, {
+ ReactDebugCurrentFrame: ReactDebugCurrentFrame,
+ ReactComponentTreeHook: {}
+ });
+ }
+ var warning = warningWithoutStack$1;
+ {
+ warning = function warning(condition, format) {
+ if (condition) {
+ return;
+ }
+
+ var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+ var stack = ReactDebugCurrentFrame.getStackAddendum();
+
+ for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+ args[_key - 2] = arguments[_key];
+ }
+
+ warningWithoutStack$1.apply(undefined, [false, format + '%s'].concat(args, [stack]));
+ };
+ }
+ var warning$1 = warning;
+ var hasOwnProperty = Object.prototype.hasOwnProperty;
+ var RESERVED_PROPS = {
+ key: true,
+ ref: true,
+ __self: true,
+ __source: true
+ };
+ var specialPropKeyWarningShown = void 0;
+ var specialPropRefWarningShown = void 0;
+
+ function hasValidRef(config) {
+ {
+ if (hasOwnProperty.call(config, 'ref')) {
+ var getter = Object.getOwnPropertyDescriptor(config, 'ref').get;
+
+ if (getter && getter.isReactWarning) {
+ return false;
+ }
+ }
+ }
+ return config.ref !== undefined;
+ }
+
+ function hasValidKey(config) {
+ {
+ if (hasOwnProperty.call(config, 'key')) {
+ var getter = Object.getOwnPropertyDescriptor(config, 'key').get;
+
+ if (getter && getter.isReactWarning) {
+ return false;
+ }
+ }
+ }
+ return config.key !== undefined;
+ }
+
+ function defineKeyPropWarningGetter(props, displayName) {
+ var warnAboutAccessingKey = function warnAboutAccessingKey() {
+ if (!specialPropKeyWarningShown) {
+ specialPropKeyWarningShown = true;
+ warningWithoutStack$1(false, '%s: `key` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://fb.me/react-special-props)', displayName);
+ }
+ };
+
+ warnAboutAccessingKey.isReactWarning = true;
+ Object.defineProperty(props, 'key', {
+ get: warnAboutAccessingKey,
+ configurable: true
+ });
+ }
+
+ function defineRefPropWarningGetter(props, displayName) {
+ var warnAboutAccessingRef = function warnAboutAccessingRef() {
+ if (!specialPropRefWarningShown) {
+ specialPropRefWarningShown = true;
+ warningWithoutStack$1(false, '%s: `ref` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://fb.me/react-special-props)', displayName);
+ }
+ };
+
+ warnAboutAccessingRef.isReactWarning = true;
+ Object.defineProperty(props, 'ref', {
+ get: warnAboutAccessingRef,
+ configurable: true
+ });
+ }
+
+ var ReactElement = function ReactElement(type, key, ref, self, source, owner, props) {
+ var element = {
+ $$typeof: REACT_ELEMENT_TYPE,
+ type: type,
+ key: key,
+ ref: ref,
+ props: props,
+ _owner: owner
+ };
+ {
+ element._store = {};
+ Object.defineProperty(element._store, 'validated', {
+ configurable: false,
+ enumerable: false,
+ writable: true,
+ value: false
+ });
+ Object.defineProperty(element, '_self', {
+ configurable: false,
+ enumerable: false,
+ writable: false,
+ value: self
+ });
+ Object.defineProperty(element, '_source', {
+ configurable: false,
+ enumerable: false,
+ writable: false,
+ value: source
+ });
+
+ if (Object.freeze) {
+ Object.freeze(element.props);
+ Object.freeze(element);
+ }
+ }
+ return element;
+ };
+
+ function createElement(type, config, children) {
+ var propName = void 0;
+ var props = {};
+ var key = null;
+ var ref = null;
+ var self = null;
+ var source = null;
+
+ if (config != null) {
+ if (hasValidRef(config)) {
+ ref = config.ref;
+ }
+
+ if (hasValidKey(config)) {
+ key = '' + config.key;
+ }
+
+ self = config.__self === undefined ? null : config.__self;
+ source = config.__source === undefined ? null : config.__source;
+
+ for (propName in config) {
+ if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
+ props[propName] = config[propName];
+ }
+ }
+ }
+
+ var childrenLength = arguments.length - 2;
+
+ if (childrenLength === 1) {
+ props.children = children;
+ } else if (childrenLength > 1) {
+ var childArray = Array(childrenLength);
+
+ for (var i = 0; i < childrenLength; i++) {
+ childArray[i] = arguments[i + 2];
+ }
+
+ {
+ if (Object.freeze) {
+ Object.freeze(childArray);
+ }
+ }
+ props.children = childArray;
+ }
+
+ if (type && type.defaultProps) {
+ var defaultProps = type.defaultProps;
+
+ for (propName in defaultProps) {
+ if (props[propName] === undefined) {
+ props[propName] = defaultProps[propName];
+ }
+ }
+ }
+
+ {
+ if (key || ref) {
+ var displayName = typeof type === 'function' ? type.displayName || type.name || 'Unknown' : type;
+
+ if (key) {
+ defineKeyPropWarningGetter(props, displayName);
+ }
+
+ if (ref) {
+ defineRefPropWarningGetter(props, displayName);
+ }
+ }
+ }
+ return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);
+ }
+
+ function cloneAndReplaceKey(oldElement, newKey) {
+ var newElement = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props);
+ return newElement;
+ }
+
+ function cloneElement(element, config, children) {
+ !!(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 SEPARATOR = '.';
+ var SUBSEPARATOR = ':';
+
+ function escape(key) {
+ var escapeRegex = /[=:]/g;
+ var escaperLookup = {
+ '=': '=0',
+ ':': '=2'
+ };
+ var escapedString = ('' + key).replace(escapeRegex, function (match) {
+ return escaperLookup[match];
+ });
+ return '$' + escapedString;
+ }
+
+ var didWarnAboutMaps = false;
+ var userProvidedKeyEscapeRegex = /\/+/g;
+
+ function escapeUserProvidedKey(text) {
+ return ('' + text).replace(userProvidedKeyEscapeRegex, '$&/');
+ }
+
+ var POOL_SIZE = 10;
+ var traverseContextPool = [];
+
+ function getPooledTraverseContext(mapResult, keyPrefix, mapFunction, mapContext) {
+ if (traverseContextPool.length) {
+ var traverseContext = traverseContextPool.pop();
+ traverseContext.result = mapResult;
+ traverseContext.keyPrefix = keyPrefix;
+ traverseContext.func = mapFunction;
+ traverseContext.context = mapContext;
+ traverseContext.count = 0;
+ return traverseContext;
+ } else {
+ return {
+ result: mapResult,
+ keyPrefix: keyPrefix,
+ func: mapFunction,
+ context: mapContext,
+ count: 0
+ };
+ }
+ }
+
+ function releaseTraverseContext(traverseContext) {
+ traverseContext.result = null;
+ traverseContext.keyPrefix = null;
+ traverseContext.func = null;
+ traverseContext.context = null;
+ traverseContext.count = 0;
+
+ if (traverseContextPool.length < POOL_SIZE) {
+ traverseContextPool.push(traverseContext);
+ }
+ }
+
+ function traverseAllChildrenImpl(children, nameSoFar, callback, traverseContext) {
+ var type = typeof children;
+
+ if (type === 'undefined' || type === 'boolean') {
+ children = null;
+ }
+
+ var invokeCallback = false;
+
+ if (children === null) {
+ invokeCallback = true;
+ } else {
+ switch (type) {
+ case 'string':
+ case 'number':
+ invokeCallback = true;
+ break;
+
+ case 'object':
+ switch (children.$$typeof) {
+ case REACT_ELEMENT_TYPE:
+ case REACT_PORTAL_TYPE:
+ invokeCallback = true;
+ }
+
+ }
+ }
+
+ if (invokeCallback) {
+ callback(traverseContext, children, nameSoFar === '' ? SEPARATOR + getComponentKey(children, 0) : nameSoFar);
+ return 1;
+ }
+
+ var child = void 0;
+ var nextName = void 0;
+ var subtreeCount = 0;
+ var nextNamePrefix = nameSoFar === '' ? SEPARATOR : nameSoFar + SUBSEPARATOR;
+
+ if (Array.isArray(children)) {
+ for (var i = 0; i < children.length; i++) {
+ child = children[i];
+ nextName = nextNamePrefix + getComponentKey(child, i);
+ subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);
+ }
+ } else {
+ var iteratorFn = getIteratorFn(children);
+
+ if (typeof iteratorFn === 'function') {
+ {
+ if (iteratorFn === children.entries) {
+ !didWarnAboutMaps ? warning$1(false, 'Using Maps as children is unsupported and will likely yield ' + 'unexpected results. Convert it to a sequence/iterable of keyed ' + 'ReactElements instead.') : void 0;
+ didWarnAboutMaps = true;
+ }
+ }
+ var iterator = iteratorFn.call(children);
+ var step = void 0;
+ var ii = 0;
+
+ while (!(step = iterator.next()).done) {
+ child = step.value;
+ nextName = nextNamePrefix + getComponentKey(child, ii++);
+ subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);
+ }
+ } else if (type === 'object') {
+ var addendum = '';
+ {
+ addendum = ' If you meant to render a collection of children, use an array ' + 'instead.' + ReactDebugCurrentFrame.getStackAddendum();
+ }
+ var childrenString = '' + children;
+ 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, function (c) {
+ return c;
+ });
+ } else if (mappedChild != null) {
+ if (isValidElement(mappedChild)) {
+ mappedChild = cloneAndReplaceKey(mappedChild, keyPrefix + (mappedChild.key && (!child || child.key !== mappedChild.key) ? escapeUserProvidedKey(mappedChild.key) + '/' : '') + childKey);
+ }
+
+ result.push(mappedChild);
+ }
+ }
+
+ function mapIntoWithKeyPrefixInternal(children, array, prefix, func, context) {
+ var escapedPrefix = '';
+
+ if (prefix != null) {
+ escapedPrefix = escapeUserProvidedKey(prefix) + '/';
+ }
+
+ var traverseContext = getPooledTraverseContext(array, escapedPrefix, func, context);
+ traverseAllChildren(children, mapSingleChildIntoContext, traverseContext);
+ releaseTraverseContext(traverseContext);
+ }
+
+ function mapChildren(children, func, context) {
+ if (children == null) {
+ return children;
+ }
+
+ var result = [];
+ mapIntoWithKeyPrefixInternal(children, result, null, func, context);
+ return result;
+ }
+
+ function countChildren(children) {
+ return traverseAllChildren(children, function () {
+ return null;
+ }, null);
+ }
+
+ function toArray(children) {
+ var result = [];
+ mapIntoWithKeyPrefixInternal(children, result, null, function (child) {
+ return child;
+ });
+ return result;
+ }
+
+ function onlyChild(children) {
+ !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') ? warningWithoutStack$1(false, 'createContext: Expected the optional second argument to be a ' + 'function. Instead received: %s', calculateChangedBits) : void 0;
+ }
+ }
+
+ var context = {
+ $$typeof: REACT_CONTEXT_TYPE,
+ _calculateChangedBits: calculateChangedBits,
+ _currentValue: defaultValue,
+ _currentValue2: defaultValue,
+ _threadCount: 0,
+ Provider: null,
+ Consumer: null
+ };
+ context.Provider = {
+ $$typeof: REACT_PROVIDER_TYPE,
+ _context: context
+ };
+ var hasWarnedAboutUsingNestedContextConsumers = false;
+ var hasWarnedAboutUsingConsumerProvider = false;
+ {
+ var Consumer = {
+ $$typeof: REACT_CONTEXT_TYPE,
+ _context: context,
+ _calculateChangedBits: context._calculateChangedBits
+ };
+ Object.defineProperties(Consumer, {
+ Provider: {
+ get: function get() {
+ if (!hasWarnedAboutUsingConsumerProvider) {
+ hasWarnedAboutUsingConsumerProvider = true;
+ warning$1(false, 'Rendering is not supported and will be removed in ' + 'a future major release. Did you mean to render instead?');
+ }
+
+ return context.Provider;
+ },
+ set: function set(_Provider) {
+ context.Provider = _Provider;
+ }
+ },
+ _currentValue: {
+ get: function get() {
+ return context._currentValue;
+ },
+ set: function set(_currentValue) {
+ context._currentValue = _currentValue;
+ }
+ },
+ _currentValue2: {
+ get: function get() {
+ return context._currentValue2;
+ },
+ set: function set(_currentValue2) {
+ context._currentValue2 = _currentValue2;
+ }
+ },
+ _threadCount: {
+ get: function get() {
+ return context._threadCount;
+ },
+ set: function set(_threadCount) {
+ context._threadCount = _threadCount;
+ }
+ },
+ Consumer: {
+ get: function get() {
+ if (!hasWarnedAboutUsingNestedContextConsumers) {
+ hasWarnedAboutUsingNestedContextConsumers = true;
+ warning$1(false, 'Rendering is not supported and will be removed in ' + 'a future major release. Did you mean to render instead?');
+ }
+
+ return context.Consumer;
+ }
+ }
+ });
+ context.Consumer = Consumer;
+ }
+ {
+ context._currentRenderer = null;
+ context._currentRenderer2 = null;
+ }
+ return context;
+ }
+
+ function lazy(ctor) {
+ var lazyType = {
+ $$typeof: REACT_LAZY_TYPE,
+ _ctor: ctor,
+ _status: -1,
+ _result: null
+ };
+ {
+ var defaultProps = void 0;
+ var propTypes = void 0;
+ Object.defineProperties(lazyType, {
+ defaultProps: {
+ configurable: true,
+ get: function get() {
+ return defaultProps;
+ },
+ set: function set(newDefaultProps) {
+ warning$1(false, 'React.lazy(...): It is not supported to assign `defaultProps` to ' + 'a lazy component import. Either specify them where the component ' + 'is defined, or create a wrapping component around it.');
+ defaultProps = newDefaultProps;
+ Object.defineProperty(lazyType, 'defaultProps', {
+ enumerable: true
+ });
+ }
+ },
+ propTypes: {
+ configurable: true,
+ get: function get() {
+ return propTypes;
+ },
+ set: function set(newPropTypes) {
+ warning$1(false, 'React.lazy(...): It is not supported to assign `propTypes` to ' + 'a lazy component import. Either specify them where the component ' + 'is defined, or create a wrapping component around it.');
+ propTypes = newPropTypes;
+ Object.defineProperty(lazyType, 'propTypes', {
+ enumerable: true
+ });
+ }
+ }
+ });
+ }
+ return lazyType;
+ }
+
+ function forwardRef(render) {
+ {
+ if (render != null && render.$$typeof === REACT_MEMO_TYPE) {
+ warningWithoutStack$1(false, 'forwardRef requires a render function but received a `memo` ' + 'component. Instead of forwardRef(memo(...)), use ' + 'memo(forwardRef(...)).');
+ } else if (typeof render !== 'function') {
+ warningWithoutStack$1(false, 'forwardRef requires a render function but was given %s.', render === null ? 'null' : typeof render);
+ } else {
+ !(render.length === 0 || render.length === 2) ? warningWithoutStack$1(false, 'forwardRef render functions accept exactly two parameters: props and ref. %s', render.length === 1 ? 'Did you forget to use the ref parameter?' : 'Any additional parameter will be undefined.') : void 0;
+ }
+
+ if (render != null) {
+ !(render.defaultProps == null && render.propTypes == null) ? warningWithoutStack$1(false, 'forwardRef render functions do not support propTypes or defaultProps. ' + 'Did you accidentally pass a React component?') : void 0;
+ }
+ }
+ return {
+ $$typeof: REACT_FORWARD_REF_TYPE,
+ render: render
+ };
+ }
+
+ function isValidElementType(type) {
+ return typeof type === 'string' || typeof type === 'function' || type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || typeof type === 'object' && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE);
+ }
+
+ function memo(type, compare) {
+ {
+ if (!isValidElementType(type)) {
+ warningWithoutStack$1(false, 'memo: The first argument must be a component. Instead ' + 'received: %s', type === null ? 'null' : typeof type);
+ }
+ }
+ return {
+ $$typeof: REACT_MEMO_TYPE,
+ type: type,
+ compare: compare === undefined ? null : compare
+ };
+ }
+
+ function resolveDispatcher() {
+ var dispatcher = ReactCurrentDispatcher.current;
+ !(dispatcher !== null) ? invariant(false, 'Hooks can only be called inside the body of a function component. (https://fb.me/react-invalid-hook-call)') : void 0;
+ return dispatcher;
+ }
+
+ function useContext(Context, unstable_observedBits) {
+ var dispatcher = resolveDispatcher();
+ {
+ !(unstable_observedBits === undefined) ? warning$1(false, 'useContext() second argument is reserved for future ' + 'use in React. Passing it is not supported. ' + 'You passed: %s.%s', unstable_observedBits, typeof unstable_observedBits === 'number' && Array.isArray(arguments[2]) ? '\n\nDid you call array.map(useContext)? ' + 'Calling Hooks inside a loop is not supported. ' + 'Learn more at https://fb.me/rules-of-hooks' : '') : void 0;
+
+ if (Context._context !== undefined) {
+ var realContext = Context._context;
+
+ if (realContext.Consumer === Context) {
+ warning$1(false, 'Calling useContext(Context.Consumer) is not supported, may cause bugs, and will be ' + 'removed in a future major release. Did you mean to call useContext(Context) instead?');
+ } else if (realContext.Provider === Context) {
+ warning$1(false, 'Calling useContext(Context.Provider) is not supported. ' + 'Did you mean to call useContext(Context) instead?');
+ }
+ }
+ }
+ return dispatcher.useContext(Context, unstable_observedBits);
+ }
+
+ function useState(initialState) {
+ var dispatcher = resolveDispatcher();
+ return dispatcher.useState(initialState);
+ }
+
+ function useReducer(reducer, initialArg, init) {
+ var dispatcher = resolveDispatcher();
+ return dispatcher.useReducer(reducer, initialArg, init);
+ }
+
+ function useRef(initialValue) {
+ var dispatcher = resolveDispatcher();
+ return dispatcher.useRef(initialValue);
+ }
+
+ function useEffect(create, inputs) {
+ var dispatcher = resolveDispatcher();
+ return dispatcher.useEffect(create, inputs);
+ }
+
+ function useLayoutEffect(create, inputs) {
+ var dispatcher = resolveDispatcher();
+ return dispatcher.useLayoutEffect(create, inputs);
+ }
+
+ function useCallback(callback, inputs) {
+ var dispatcher = resolveDispatcher();
+ return dispatcher.useCallback(callback, inputs);
+ }
+
+ function useMemo(create, inputs) {
+ var dispatcher = resolveDispatcher();
+ return dispatcher.useMemo(create, inputs);
+ }
+
+ function useImperativeHandle(ref, create, inputs) {
+ var dispatcher = resolveDispatcher();
+ return dispatcher.useImperativeHandle(ref, create, inputs);
+ }
+
+ function useDebugValue(value, formatterFn) {
+ {
+ var dispatcher = resolveDispatcher();
+ return dispatcher.useDebugValue(value, formatterFn);
+ }
+ }
+
+ var propTypesMisspellWarningShown = void 0;
+ {
+ propTypesMisspellWarningShown = false;
+ }
+
+ function getDeclarationErrorAddendum() {
+ if (ReactCurrentOwner.current) {
+ var name = getComponentName(ReactCurrentOwner.current.type);
+
+ if (name) {
+ return '\n\nCheck the render method of `' + name + '`.';
+ }
+ }
+
+ return '';
+ }
+
+ function getSourceInfoErrorAddendum(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.type) + '.';
+ }
+
+ setCurrentlyValidatingElement(element);
+ {
+ warning$1(false, 'Each child in a list should have a unique "key" prop.' + '%s%s See https://fb.me/react-warning-keys for more information.', currentComponentErrorInfo, childOwner);
+ }
+ setCurrentlyValidatingElement(null);
+ }
+
+ function validateChildKeys(node, parentType) {
+ if (typeof node !== 'object') {
+ return;
+ }
+
+ if (Array.isArray(node)) {
+ for (var i = 0; i < node.length; i++) {
+ var child = node[i];
+
+ if (isValidElement(child)) {
+ validateExplicitKey(child, parentType);
+ }
+ }
+ } else if (isValidElement(node)) {
+ if (node._store) {
+ node._store.validated = true;
+ }
+ } else if (node) {
+ var iteratorFn = getIteratorFn(node);
+
+ if (typeof iteratorFn === 'function') {
+ if (iteratorFn !== node.entries) {
+ var iterator = iteratorFn.call(node);
+ var step = void 0;
+
+ while (!(step = iterator.next()).done) {
+ if (isValidElement(step.value)) {
+ validateExplicitKey(step.value, parentType);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ function validatePropTypes(element) {
+ var type = element.type;
+
+ if (type === null || type === undefined || typeof type === 'string') {
+ return;
+ }
+
+ var name = getComponentName(type);
+ var propTypes = void 0;
+
+ if (typeof type === 'function') {
+ propTypes = type.propTypes;
+ } else if (typeof type === 'object' && (type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_MEMO_TYPE)) {
+ propTypes = type.propTypes;
+ } else {
+ return;
+ }
+
+ if (propTypes) {
+ setCurrentlyValidatingElement(element);
+ checkPropTypes(propTypes, element.props, 'prop', name, ReactDebugCurrentFrame.getStackAddendum);
+ setCurrentlyValidatingElement(null);
+ } else if (type.PropTypes !== undefined && !propTypesMisspellWarningShown) {
+ propTypesMisspellWarningShown = true;
+ warningWithoutStack$1(false, 'Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?', name || 'Unknown');
+ }
+
+ if (typeof type.getDefaultProps === 'function') {
+ !type.getDefaultProps.isReactClassApproved ? warningWithoutStack$1(false, 'getDefaultProps is only used on classic React.createClass ' + 'definitions. Use a static property named `defaultProps` instead.') : void 0;
+ }
+ }
+
+ function validateFragmentProps(fragment) {
+ setCurrentlyValidatingElement(fragment);
+ var keys = Object.keys(fragment.props);
+
+ for (var i = 0; i < keys.length; i++) {
+ var key = keys[i];
+
+ if (key !== 'children' && key !== 'key') {
+ warning$1(false, 'Invalid prop `%s` supplied to `React.Fragment`. ' + 'React.Fragment can only have `key` and `children` props.', key);
+ break;
+ }
+ }
+
+ if (fragment.ref !== null) {
+ warning$1(false, 'Invalid attribute `ref` supplied to `React.Fragment`.');
+ }
+
+ setCurrentlyValidatingElement(null);
+ }
+
+ function 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();
+ }
+
+ var typeString = void 0;
+
+ if (type === null) {
+ typeString = 'null';
+ } else if (Array.isArray(type)) {
+ typeString = 'array';
+ } else if (type !== undefined && type.$$typeof === REACT_ELEMENT_TYPE) {
+ typeString = '<' + (getComponentName(type.type) || 'Unknown') + ' />';
+ info = ' Did you accidentally export a JSX literal instead of a component?';
+ } else {
+ typeString = typeof type;
+ }
+
+ warning$1(false, 'React.createElement: type is invalid -- expected a string (for ' + 'built-in components) or a class/function (for composite ' + 'components) but got: %s.%s', typeString, info);
+ }
+
+ var element = createElement.apply(this, arguments);
+
+ if (element == null) {
+ return element;
+ }
+
+ if (validType) {
+ for (var i = 2; i < arguments.length; i++) {
+ validateChildKeys(arguments[i], type);
+ }
+ }
+
+ if (type === REACT_FRAGMENT_TYPE) {
+ validateFragmentProps(element);
+ } else {
+ validatePropTypes(element);
+ }
+
+ return element;
+ }
+
+ function createFactoryWithValidation(type) {
+ var validatedFactory = createElementWithValidation.bind(null, type);
+ validatedFactory.type = type;
+ {
+ Object.defineProperty(validatedFactory, 'type', {
+ enumerable: false,
+ get: function get() {
+ lowPriorityWarning$1(false, 'Factory.type is deprecated. Access the class directly ' + 'before passing it to createFactory.');
+ Object.defineProperty(this, 'type', {
+ value: type
+ });
+ return type;
+ }
+ });
+ }
+ return validatedFactory;
+ }
+
+ function cloneElementWithValidation(element, props, children) {
+ var newElement = cloneElement.apply(this, arguments);
+
+ for (var i = 2; i < arguments.length; i++) {
+ validateChildKeys(arguments[i], newElement.type);
+ }
+
+ validatePropTypes(newElement);
+ return newElement;
+ }
+
+ var enableStableConcurrentModeAPIs = false;
+ var React = {
+ Children: {
+ map: mapChildren,
+ forEach: forEachChildren,
+ count: countChildren,
+ toArray: toArray,
+ only: onlyChild
+ },
+ createRef: createRef,
+ Component: Component,
+ PureComponent: PureComponent,
+ createContext: createContext,
+ forwardRef: forwardRef,
+ lazy: lazy,
+ memo: memo,
+ useCallback: useCallback,
+ useContext: useContext,
+ useEffect: useEffect,
+ useImperativeHandle: useImperativeHandle,
+ useDebugValue: useDebugValue,
+ useLayoutEffect: useLayoutEffect,
+ useMemo: useMemo,
+ useReducer: useReducer,
+ useRef: useRef,
+ useState: useState,
+ Fragment: REACT_FRAGMENT_TYPE,
+ StrictMode: REACT_STRICT_MODE_TYPE,
+ Suspense: REACT_SUSPENSE_TYPE,
+ createElement: createElementWithValidation,
+ cloneElement: cloneElementWithValidation,
+ createFactory: createFactoryWithValidation,
+ isValidElement: isValidElement,
+ version: ReactVersion,
+ unstable_ConcurrentMode: REACT_CONCURRENT_MODE_TYPE,
+ unstable_Profiler: REACT_PROFILER_TYPE,
+ __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: ReactSharedInternals
+ };
+
+ if (enableStableConcurrentModeAPIs) {
+ React.ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
+ React.Profiler = REACT_PROFILER_TYPE;
+ React.unstable_ConcurrentMode = undefined;
+ React.unstable_Profiler = undefined;
+ }
+
+ var React$2 = Object.freeze({
+ default: React
+ });
+ var React$3 = React$2 && React || React$2;
+ var react = React$3.default || React$3;
+ module.exports = react;
+ })();
+ }
+},15,[13,16],"node_modules\\react\\cjs\\react.development.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var printWarning = function printWarning() {};
+
+ if (process.env.NODE_ENV !== 'production') {
+ var ReactPropTypesSecret = _$$_REQUIRE(_dependencyMap[0], "./lib/ReactPropTypesSecret");
+
+ var loggedTypeFailures = {};
+ var has = Function.call.bind(Object.prototype.hasOwnProperty);
+
+ printWarning = function printWarning(text) {
+ var message = 'Warning: ' + text;
+
+ if (typeof console !== 'undefined') {
+ console.error(message);
+ }
+
+ try {
+ throw new Error(message);
+ } catch (x) {}
+ };
+ }
+
+ function checkPropTypes(typeSpecs, values, location, componentName, getStack) {
+ if (process.env.NODE_ENV !== 'production') {
+ for (var typeSpecName in typeSpecs) {
+ if (has(typeSpecs, typeSpecName)) {
+ var error;
+
+ try {
+ if (typeof typeSpecs[typeSpecName] !== 'function') {
+ var err = Error((componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' + 'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.');
+ err.name = 'Invariant Violation';
+ throw err;
+ }
+
+ error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);
+ } catch (ex) {
+ error = ex;
+ }
+
+ if (error && !(error instanceof Error)) {
+ printWarning((componentName || 'React class') + ': type specification of ' + location + ' `' + typeSpecName + '` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a ' + typeof error + '. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).');
+ }
+
+ if (error instanceof Error && !(error.message in loggedTypeFailures)) {
+ loggedTypeFailures[error.message] = true;
+ var stack = getStack ? getStack() : '';
+ printWarning('Failed ' + location + ' type: ' + error.message + (stack != null ? stack : ''));
+ }
+ }
+ }
+ }
+ }
+
+ checkPropTypes.resetWarningCache = function () {
+ if (process.env.NODE_ENV !== 'production') {
+ loggedTypeFailures = {};
+ }
+ };
+
+ module.exports = checkPropTypes;
+},16,[17],"node_modules\\prop-types\\checkPropTypes.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';
+ module.exports = ReactPropTypesSecret;
+},17,[],"node_modules\\prop-types\\lib\\ReactPropTypesSecret.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var invariant = _$$_REQUIRE(_dependencyMap[0], "invariant");
+
+ var warnOnce = _$$_REQUIRE(_dependencyMap[1], "warnOnce");
+
+ module.exports = {
+ get AccessibilityInfo() {
+ return _$$_REQUIRE(_dependencyMap[2], "AccessibilityInfo");
+ },
+
+ get ActivityIndicator() {
+ return _$$_REQUIRE(_dependencyMap[3], "ActivityIndicator");
+ },
+
+ get ART() {
+ return _$$_REQUIRE(_dependencyMap[4], "ReactNativeART");
+ },
+
+ get Button() {
+ return _$$_REQUIRE(_dependencyMap[5], "Button");
+ },
+
+ get CheckBox() {
+ return _$$_REQUIRE(_dependencyMap[6], "CheckBox");
+ },
+
+ get DatePickerIOS() {
+ return _$$_REQUIRE(_dependencyMap[7], "DatePickerIOS");
+ },
+
+ get DrawerLayoutAndroid() {
+ return _$$_REQUIRE(_dependencyMap[8], "DrawerLayoutAndroid");
+ },
+
+ get FlatList() {
+ return _$$_REQUIRE(_dependencyMap[9], "FlatList");
+ },
+
+ get Image() {
+ return _$$_REQUIRE(_dependencyMap[10], "Image");
+ },
+
+ get ImageBackground() {
+ return _$$_REQUIRE(_dependencyMap[11], "ImageBackground");
+ },
+
+ get ImageEditor() {
+ return _$$_REQUIRE(_dependencyMap[12], "ImageEditor");
+ },
+
+ get ImageStore() {
+ warnOnce('imagestore-deprecation', 'ImageStore is deprecated and will be removed in a future release. ' + 'To get a base64-encoded string from a local image use either of the following third-party libraries:' + "* expo-file-system: `readAsStringAsync(filepath, 'base64')`" + "* react-native-fs: `readFile(filepath, 'base64')`");
+ return _$$_REQUIRE(_dependencyMap[13], "ImageStore");
+ },
+
+ get InputAccessoryView() {
+ return _$$_REQUIRE(_dependencyMap[14], "InputAccessoryView");
+ },
+
+ get KeyboardAvoidingView() {
+ return _$$_REQUIRE(_dependencyMap[15], "KeyboardAvoidingView");
+ },
+
+ get ListView() {
+ warnOnce('listview-deprecation', 'ListView is deprecated and will be removed in a future release. ' + 'See https://fb.me/nolistview for more information');
+ return _$$_REQUIRE(_dependencyMap[16], "ListView");
+ },
+
+ get MaskedViewIOS() {
+ warnOnce('maskedviewios-moved', 'MaskedViewIOS has been extracted from react-native core and will be removed in a future release. ' + "It can now be installed and imported from '@react-native-community/masked-view' instead of 'react-native'. " + 'See https://github.com/react-native-community/react-native-masked-view');
+ return _$$_REQUIRE(_dependencyMap[17], "MaskedViewIOS");
+ },
+
+ get Modal() {
+ return _$$_REQUIRE(_dependencyMap[18], "Modal");
+ },
+
+ 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() {
+ warnOnce('slider-moved', 'Slider has been extracted from react-native core and will be removed in a future release. ' + "It can now be installed and imported from '@react-native-community/slider' instead of 'react-native'. " + 'See https://github.com/react-native-community/react-native-slider');
+ return _$$_REQUIRE(_dependencyMap[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() {
+ warnOnce('swipablelistview-deprecation', 'ListView and SwipeableListView are deprecated and will be removed in a future release. ' + 'See https://fb.me/nolistview for more information');
+ return _$$_REQUIRE(_dependencyMap[33], "SwipeableListView");
+ },
+
+ get Text() {
+ return _$$_REQUIRE(_dependencyMap[34], "Text");
+ },
+
+ get TextInput() {
+ return _$$_REQUIRE(_dependencyMap[35], "TextInput");
+ },
+
+ get ToolbarAndroid() {
+ return _$$_REQUIRE(_dependencyMap[36], "ToolbarAndroid");
+ },
+
+ get Touchable() {
+ return _$$_REQUIRE(_dependencyMap[37], "Touchable");
+ },
+
+ get TouchableHighlight() {
+ return _$$_REQUIRE(_dependencyMap[38], "TouchableHighlight");
+ },
+
+ get TouchableNativeFeedback() {
+ return _$$_REQUIRE(_dependencyMap[39], "TouchableNativeFeedback");
+ },
+
+ get TouchableOpacity() {
+ return _$$_REQUIRE(_dependencyMap[40], "TouchableOpacity");
+ },
+
+ get TouchableWithoutFeedback() {
+ return _$$_REQUIRE(_dependencyMap[41], "TouchableWithoutFeedback");
+ },
+
+ get View() {
+ return _$$_REQUIRE(_dependencyMap[42], "View");
+ },
+
+ get ViewPagerAndroid() {
+ warnOnce('viewpager-moved', 'ViewPagerAndroid has been extracted from react-native core and will be removed in a future release. ' + "It can now be installed and imported from '@react-native-community/viewpager' instead of 'react-native'. " + 'See https://github.com/react-native-community/react-native-viewpager');
+ return _$$_REQUIRE(_dependencyMap[43], "ViewPagerAndroid");
+ },
+
+ get VirtualizedList() {
+ return _$$_REQUIRE(_dependencyMap[44], "VirtualizedList");
+ },
+
+ get WebView() {
+ warnOnce('webview-moved', 'WebView has been extracted from react-native core and will be removed in a future release. ' + "It can now be installed and imported from 'react-native-webview' instead of 'react-native'. " + 'See https://github.com/react-native-community/react-native-webview');
+ return _$$_REQUIRE(_dependencyMap[45], "WebView");
+ },
+
+ get ActionSheetIOS() {
+ return _$$_REQUIRE(_dependencyMap[46], "ActionSheetIOS");
+ },
+
+ get Alert() {
+ return _$$_REQUIRE(_dependencyMap[47], "Alert");
+ },
+
+ get AlertIOS() {
+ warnOnce('alert-ios', 'AlertIOS is deprecated. Use the `Alert` module directly instead.');
+ return _$$_REQUIRE(_dependencyMap[47], "Alert");
+ },
+
+ get AlertMacOS() {
+ return _$$_REQUIRE(_dependencyMap[48], "AlertMacOS");
+ },
+
+ get Animated() {
+ return _$$_REQUIRE(_dependencyMap[49], "Animated");
+ },
+
+ get AppRegistry() {
+ return _$$_REQUIRE(_dependencyMap[50], "AppRegistry");
+ },
+
+ get AppState() {
+ return _$$_REQUIRE(_dependencyMap[51], "AppState");
+ },
+
+ get AsyncStorage() {
+ warnOnce('async-storage-moved', 'Async Storage has been extracted from react-native core and will be removed in a future release. ' + "It can now be installed and imported from '@react-native-community/async-storage' instead of 'react-native'. " + 'See https://github.com/react-native-community/react-native-async-storage');
+ return _$$_REQUIRE(_dependencyMap[52], "AsyncStorage");
+ },
+
+ get BackHandler() {
+ return _$$_REQUIRE(_dependencyMap[53], "BackHandler");
+ },
+
+ get CameraRoll() {
+ return _$$_REQUIRE(_dependencyMap[54], "CameraRoll");
+ },
+
+ get Clipboard() {
+ return _$$_REQUIRE(_dependencyMap[55], "Clipboard");
+ },
+
+ get DatePickerAndroid() {
+ return _$$_REQUIRE(_dependencyMap[56], "DatePickerAndroid");
+ },
+
+ get DatePickerMacOS() {
+ return _$$_REQUIRE(_dependencyMap[57], "DatePickerMacOS");
+ },
+
+ get DeviceInfo() {
+ return _$$_REQUIRE(_dependencyMap[58], "DeviceInfo");
+ },
+
+ get Dimensions() {
+ return _$$_REQUIRE(_dependencyMap[59], "Dimensions");
+ },
+
+ get Easing() {
+ return _$$_REQUIRE(_dependencyMap[60], "Easing");
+ },
+
+ get findNodeHandle() {
+ return _$$_REQUIRE(_dependencyMap[61], "ReactNative").findNodeHandle;
+ },
+
+ get I18nManager() {
+ return _$$_REQUIRE(_dependencyMap[62], "I18nManager");
+ },
+
+ get ImagePickerIOS() {
+ return _$$_REQUIRE(_dependencyMap[63], "ImagePickerIOS");
+ },
+
+ get InteractionManager() {
+ return _$$_REQUIRE(_dependencyMap[64], "InteractionManager");
+ },
+
+ get Keyboard() {
+ return _$$_REQUIRE(_dependencyMap[65], "Keyboard");
+ },
+
+ get LayoutAnimation() {
+ return _$$_REQUIRE(_dependencyMap[66], "LayoutAnimation");
+ },
+
+ get Linking() {
+ return _$$_REQUIRE(_dependencyMap[67], "Linking");
+ },
+
+ get NativeEventEmitter() {
+ return _$$_REQUIRE(_dependencyMap[68], "NativeEventEmitter");
+ },
+
+ get NetInfo() {
+ warnOnce('netinfo-moved', 'NetInfo has been extracted from react-native core and will be removed in a future release. ' + "It can now be installed and imported from '@react-native-community/netinfo' instead of 'react-native'. " + 'See https://github.com/react-native-community/react-native-netinfo');
+ return _$$_REQUIRE(_dependencyMap[69], "NetInfo");
+ },
+
+ get PanResponder() {
+ return _$$_REQUIRE(_dependencyMap[70], "PanResponder");
+ },
+
+ get PermissionsAndroid() {
+ return _$$_REQUIRE(_dependencyMap[71], "PermissionsAndroid");
+ },
+
+ get PixelRatio() {
+ return _$$_REQUIRE(_dependencyMap[72], "PixelRatio");
+ },
+
+ get PushNotificationIOS() {
+ return _$$_REQUIRE(_dependencyMap[73], "PushNotificationIOS");
+ },
+
+ get Settings() {
+ return _$$_REQUIRE(_dependencyMap[74], "Settings");
+ },
+
+ get Share() {
+ return _$$_REQUIRE(_dependencyMap[75], "Share");
+ },
+
+ get StatusBarIOS() {
+ return _$$_REQUIRE(_dependencyMap[76], "StatusBarIOS");
+ },
+
+ get StyleSheet() {
+ return _$$_REQUIRE(_dependencyMap[77], "StyleSheet");
+ },
+
+ get Systrace() {
+ return _$$_REQUIRE(_dependencyMap[78], "Systrace");
+ },
+
+ get TimePickerAndroid() {
+ return _$$_REQUIRE(_dependencyMap[79], "TimePickerAndroid");
+ },
+
+ get ToastAndroid() {
+ return _$$_REQUIRE(_dependencyMap[80], "ToastAndroid");
+ },
+
+ get TVEventHandler() {
+ return _$$_REQUIRE(_dependencyMap[81], "TVEventHandler");
+ },
+
+ get UIManager() {
+ return _$$_REQUIRE(_dependencyMap[82], "UIManager");
+ },
+
+ get unstable_batchedUpdates() {
+ return _$$_REQUIRE(_dependencyMap[61], "ReactNative").unstable_batchedUpdates;
+ },
+
+ get UTFSequence() {
+ return _$$_REQUIRE(_dependencyMap[83], "UTFSequence");
+ },
+
+ 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], "DeprecatedColorPropType");
+ },
+
+ get EdgeInsetsPropType() {
+ return _$$_REQUIRE(_dependencyMap[95], "DeprecatedEdgeInsetsPropType");
+ },
+
+ get PointPropType() {
+ return _$$_REQUIRE(_dependencyMap[96], "DeprecatedPointPropType");
+ },
+
+ get ViewPropTypes() {
+ return _$$_REQUIRE(_dependencyMap[97], "DeprecatedViewPropTypes");
+ },
+
+ get BackAndroid() {
+ invariant(false, 'BackAndroid is deprecated and has been removed from this package. ' + 'Use BackHandler instead');
+ },
+
+ 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');
+ },
+
+ get NavigatorIOS() {
+ invariant(false, 'NavigatorIOS is deprecated and has been removed from this package. ' + 'Learn about alternative navigation solutions at http://facebook.github.io/react-native/docs/navigation.html');
+ }
+
+ };
+},18,[19,20,23,31,197,207,296,297,298,268,287,299,301,302,303,305,306,312,313,350,352,195,353,333,275,292,354,355,357,358,272,360,361,365,208,367,369,213,221,235,236,226,81,370,269,371,372,145,146,237,373,168,384,379,385,386,387,388,56,55,264,84,320,389,245,278,279,390,131,391,363,150,54,392,393,394,395,53,48,396,397,217,71,339,398,399,331,24,155,36,35,75,184,400,59,210,401,222],"node_modules\\react-native\\Libraries\\react-native\\react-native-implementation.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var invariant = function invariant(condition, format, a, b, c, d, e, f) {
+ if (process.env.NODE_ENV !== 'production') {
+ if (format === undefined) {
+ throw new Error('invariant requires an error message argument');
+ }
+ }
+
+ if (!condition) {
+ var error;
+
+ if (format === undefined) {
+ error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');
+ } else {
+ var args = [a, b, c, d, e, f];
+ var argIndex = 0;
+ error = new Error(format.replace(/%s/g, function () {
+ return args[argIndex++];
+ }));
+ error.name = 'Invariant Violation';
+ }
+
+ error.framesToPop = 1;
+ throw error;
+ }
+ };
+
+ module.exports = invariant;
+},19,[],"node_modules\\invariant\\browser.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var warning = _$$_REQUIRE(_dependencyMap[0], "fbjs/lib/warning");
+
+ var warnedKeys = {};
+
+ function warnOnce(key, message) {
+ if (warnedKeys[key]) {
+ return;
+ }
+
+ warning(false, message);
+ warnedKeys[key] = true;
+ }
+
+ module.exports = warnOnce;
+},20,[21],"node_modules\\react-native\\Libraries\\Utilities\\warnOnce.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var emptyFunction = _$$_REQUIRE(_dependencyMap[0], "./emptyFunction");
+
+ function printWarning(format) {
+ for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+ args[_key - 1] = arguments[_key];
+ }
+
+ var argIndex = 0;
+ var message = 'Warning: ' + format.replace(/%s/g, function () {
+ return args[argIndex++];
+ });
+
+ if (typeof console !== 'undefined') {
+ console.error(message);
+ }
+
+ try {
+ throw new Error(message);
+ } catch (x) {}
+ }
+
+ var warning = process.env.NODE_ENV !== "production" ? function (condition, format) {
+ if (format === undefined) {
+ throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument');
+ }
+
+ if (!condition) {
+ for (var _len2 = arguments.length, args = new Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
+ args[_key2 - 2] = arguments[_key2];
+ }
+
+ printWarning.apply(void 0, [format].concat(args));
+ }
+ } : emptyFunction;
+ module.exports = warning;
+},21,[22],"node_modules\\fbjs\\lib\\warning.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ "use strict";
+
+ function makeEmptyFunction(arg) {
+ return function () {
+ return arg;
+ };
+ }
+
+ var emptyFunction = function emptyFunction() {};
+
+ emptyFunction.thatReturns = makeEmptyFunction;
+ emptyFunction.thatReturnsFalse = makeEmptyFunction(false);
+ emptyFunction.thatReturnsTrue = makeEmptyFunction(true);
+ emptyFunction.thatReturnsNull = makeEmptyFunction(null);
+
+ emptyFunction.thatReturnsThis = function () {
+ return this;
+ };
+
+ emptyFunction.thatReturnsArgument = function (arg) {
+ return arg;
+ };
+
+ module.exports = emptyFunction;
+},22,[],"node_modules\\fbjs\\lib\\emptyFunction.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var RCTDeviceEventEmitter = _$$_REQUIRE(_dependencyMap[0], "RCTDeviceEventEmitter");
+
+ var TOUCH_EXPLORATION_EVENT = 'touchExplorationDidChange';
+
+ var _subscriptions = new Map();
+
+ var AccessibilityInfo = {
+ fetch: function fetch() {
+ return new Promise(function (_resolve, _reject) {
+ return false;
+ });
+ },
+ addEventListener: function addEventListener(eventName, handler) {
+ var listener = RCTDeviceEventEmitter.addListener(TOUCH_EXPLORATION_EVENT, function (enabledInner) {
+ handler(enabledInner);
+ });
+
+ _subscriptions.set(handler, listener);
+ },
+ removeEventListener: function removeEventListener(eventName, handler) {
+ var listener = _subscriptions.get(handler);
+
+ if (!listener) {
+ return;
+ }
+
+ listener.remove();
+
+ _subscriptions.delete(handler);
+ }
+ };
+ module.exports = AccessibilityInfo;
+},23,[24],"Libraries\\Components\\AccessibilityInfo\\AccessibilityInfo.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _get = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/get");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var EventEmitter = _$$_REQUIRE(_dependencyMap[6], "EventEmitter");
+
+ var EventSubscriptionVendor = _$$_REQUIRE(_dependencyMap[7], "EventSubscriptionVendor");
+
+ function checkNativeEventModule(eventType) {
+ if (eventType) {
+ if (eventType.lastIndexOf('statusBar', 0) === 0) {
+ throw new Error('`' + eventType + '` event should be registered via the StatusBarIOS module');
+ }
+
+ if (eventType.lastIndexOf('keyboard', 0) === 0) {
+ throw new Error('`' + eventType + '` event should be registered via the Keyboard module');
+ }
+
+ if (eventType === 'appStateDidChange' || eventType === 'memoryWarning') {
+ throw new Error('`' + eventType + '` event should be registered via the AppState module');
+ }
+ }
+ }
+
+ var RCTDeviceEventEmitter = function (_EventEmitter) {
+ _inherits(RCTDeviceEventEmitter, _EventEmitter);
+
+ function RCTDeviceEventEmitter() {
+ var _this;
+
+ _classCallCheck(this, RCTDeviceEventEmitter);
+
+ var sharedSubscriber = new EventSubscriptionVendor();
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(RCTDeviceEventEmitter).call(this, sharedSubscriber));
+ _this.sharedSubscriber = sharedSubscriber;
+ return _this;
+ }
+
+ _createClass(RCTDeviceEventEmitter, [{
+ key: "addListener",
+ value: function addListener(eventType, listener, context) {
+ if (__DEV__) {
+ checkNativeEventModule(eventType);
+ }
+
+ return _get(_getPrototypeOf(RCTDeviceEventEmitter.prototype), "addListener", this).call(this, eventType, listener, context);
+ }
+ }, {
+ key: "removeAllListeners",
+ value: function removeAllListeners(eventType) {
+ if (__DEV__) {
+ checkNativeEventModule(eventType);
+ }
+
+ _get(_getPrototypeOf(RCTDeviceEventEmitter.prototype), "removeAllListeners", this).call(this, eventType);
+ }
+ }, {
+ key: "removeSubscription",
+ value: function removeSubscription(subscription) {
+ if (subscription.emitter !== this) {
+ subscription.emitter.removeSubscription(subscription);
+ } else {
+ _get(_getPrototypeOf(RCTDeviceEventEmitter.prototype), "removeSubscription", this).call(this, subscription);
+ }
+ }
+ }]);
+
+ return RCTDeviceEventEmitter;
+ }(EventEmitter);
+
+ module.exports = new RCTDeviceEventEmitter();
+},24,[3,4,5,8,25,9,27,30],"node_modules\\react-native\\Libraries\\EventEmitter\\RCTDeviceEventEmitter.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var superPropBase = _$$_REQUIRE(_dependencyMap[0], "./superPropBase");
+
+ function _get(target, property, receiver) {
+ if (typeof Reflect !== "undefined" && Reflect.get) {
+ module.exports = _get = Reflect.get;
+ } else {
+ module.exports = _get = function _get(target, property, receiver) {
+ var base = superPropBase(target, property);
+ if (!base) return;
+ var desc = Object.getOwnPropertyDescriptor(base, property);
+
+ if (desc.get) {
+ return desc.get.call(receiver);
+ }
+
+ return desc.value;
+ };
+ }
+
+ return _get(target, property, receiver || target);
+ }
+
+ module.exports = _get;
+},25,[26],"node_modules\\@babel\\runtime\\helpers\\get.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var getPrototypeOf = _$$_REQUIRE(_dependencyMap[0], "./getPrototypeOf");
+
+ function _superPropBase(object, property) {
+ while (!Object.prototype.hasOwnProperty.call(object, property)) {
+ object = getPrototypeOf(object);
+ if (object === null) break;
+ }
+
+ return object;
+ }
+
+ module.exports = _superPropBase;
+},26,[8],"node_modules\\@babel\\runtime\\helpers\\superPropBase.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var EmitterSubscription = _$$_REQUIRE(_dependencyMap[2], "EmitterSubscription");
+
+ var EventSubscriptionVendor = _$$_REQUIRE(_dependencyMap[3], "EventSubscriptionVendor");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[4], "invariant");
+
+ var 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.map(function (subscription) {
+ return subscription.listener;
+ }) : [];
+ }
+ }, {
+ key: "emit",
+ value: function emit(eventType) {
+ var subscriptions = this._subscriber.getSubscriptionsForType(eventType);
+
+ if (subscriptions) {
+ for (var i = 0, l = subscriptions.length; i < l; i++) {
+ var subscription = subscriptions[i];
+
+ if (subscription && subscription.listener) {
+ this._currentSubscription = subscription;
+ subscription.listener.apply(subscription.context, Array.prototype.slice.call(arguments, 1));
+ }
+ }
+
+ this._currentSubscription = null;
+ }
+ }
+ }, {
+ key: "removeListener",
+ value: function removeListener(eventType, listener) {
+ var subscriptions = this._subscriber.getSubscriptionsForType(eventType);
+
+ if (subscriptions) {
+ for (var i = 0, l = subscriptions.length; i < l; i++) {
+ var subscription = subscriptions[i];
+
+ if (subscription && subscription.listener === listener) {
+ subscription.remove();
+ }
+ }
+ }
+ }
+ }]);
+
+ return EventEmitter;
+ }();
+
+ module.exports = EventEmitter;
+},27,[3,4,28,30,19],"node_modules\\react-native\\Libraries\\vendor\\emitter\\EventEmitter.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var EventSubscription = _$$_REQUIRE(_dependencyMap[5], "EventSubscription");
+
+ var EmitterSubscription = function (_EventSubscription) {
+ _inherits(EmitterSubscription, _EventSubscription);
+
+ function EmitterSubscription(emitter, subscriber, listener, context) {
+ var _this;
+
+ _classCallCheck(this, EmitterSubscription);
+
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(EmitterSubscription).call(this, subscriber));
+ _this.emitter = emitter;
+ _this.listener = listener;
+ _this.context = context;
+ return _this;
+ }
+
+ _createClass(EmitterSubscription, [{
+ key: "remove",
+ value: function remove() {
+ this.emitter.removeSubscription(this);
+ }
+ }]);
+
+ return EmitterSubscription;
+ }(EventSubscription);
+
+ module.exports = EmitterSubscription;
+},28,[3,4,5,8,9,29],"node_modules\\react-native\\Libraries\\vendor\\emitter\\EmitterSubscription.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var EventSubscription = function () {
+ function EventSubscription(subscriber) {
+ _classCallCheck(this, EventSubscription);
+
+ this.subscriber = subscriber;
+ }
+
+ _createClass(EventSubscription, [{
+ key: "remove",
+ value: function remove() {
+ this.subscriber.removeSubscription(this);
+ }
+ }]);
+
+ return EventSubscription;
+ }();
+
+ module.exports = EventSubscription;
+},29,[3,4],"node_modules\\react-native\\Libraries\\vendor\\emitter\\EventSubscription.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[2], "invariant");
+
+ var EventSubscriptionVendor = function () {
+ function EventSubscriptionVendor() {
+ _classCallCheck(this, EventSubscriptionVendor);
+
+ this._subscriptionsForType = {};
+ this._currentSubscription = null;
+ }
+
+ _createClass(EventSubscriptionVendor, [{
+ key: "addSubscription",
+ value: function addSubscription(eventType, subscription) {
+ invariant(subscription.subscriber === this, 'The subscriber of the subscription is incorrectly set.');
+
+ if (!this._subscriptionsForType[eventType]) {
+ this._subscriptionsForType[eventType] = [];
+ }
+
+ var key = this._subscriptionsForType[eventType].length;
+
+ this._subscriptionsForType[eventType].push(subscription);
+
+ subscription.eventType = eventType;
+ subscription.key = key;
+ return subscription;
+ }
+ }, {
+ key: "removeAllSubscriptions",
+ value: function removeAllSubscriptions(eventType) {
+ if (eventType === undefined) {
+ this._subscriptionsForType = {};
+ } else {
+ delete this._subscriptionsForType[eventType];
+ }
+ }
+ }, {
+ key: "removeSubscription",
+ value: function removeSubscription(subscription) {
+ var eventType = subscription.eventType;
+ var key = subscription.key;
+ var subscriptionsForType = this._subscriptionsForType[eventType];
+
+ if (subscriptionsForType) {
+ delete subscriptionsForType[key];
+ }
+ }
+ }, {
+ key: "getSubscriptionsForType",
+ value: function getSubscriptionsForType(eventType) {
+ return this._subscriptionsForType[eventType];
+ }
+ }]);
+
+ return EventSubscriptionVendor;
+ }();
+
+ module.exports = EventSubscriptionVendor;
+},30,[3,4,19],"node_modules\\react-native\\Libraries\\vendor\\emitter\\EventSubscriptionVendor.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/defineProperty");
+
+ var _objectWithoutProperties = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/objectWithoutProperties");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Components\\ActivityIndicator\\ActivityIndicator.js";
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var Platform = _$$_REQUIRE(_dependencyMap[3], "Platform");
+
+ var React = _$$_REQUIRE(_dependencyMap[4], "React");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[5], "StyleSheet");
+
+ var View = _$$_REQUIRE(_dependencyMap[6], "View");
+
+ var RCTActivityIndicatorViewNativeComponent = _$$_REQUIRE(_dependencyMap[7], "RCTActivityIndicatorViewNativeComponent");
+
+ var RCTActivityIndicator = Platform.OS === 'android' ? _$$_REQUIRE(_dependencyMap[8], "ProgressBarAndroid") : RCTActivityIndicatorViewNativeComponent;
+ var GRAY = '#999999';
+
+ var ActivityIndicator = function ActivityIndicator(props, forwardedRef) {
+ var onLayout = props.onLayout,
+ style = props.style,
+ restProps = _objectWithoutProperties(props, ["onLayout", "style"]);
+
+ 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: StyleSheet.compose(styles.container, style),
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 98
+ }
+ }, React.createElement(RCTActivityIndicator, _extends({}, nativeProps, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 106
+ }
+ })));
+ };
+
+ var ActivityIndicatorWithRef = React.forwardRef(ActivityIndicator);
+ ActivityIndicatorWithRef.displayName = 'ActivityIndicator';
+ ActivityIndicatorWithRef.defaultProps = {
+ animating: true,
+ color: Platform.OS === 'ios' ? GRAY : null,
+ hidesWhenStopped: true,
+ size: 'small'
+ };
+ var styles = StyleSheet.create({
+ container: {
+ alignItems: 'center',
+ justifyContent: 'center'
+ },
+ sizeSmall: {
+ width: 20,
+ height: 20
+ },
+ sizeLarge: {
+ width: 36,
+ height: 36
+ }
+ });
+ module.exports = ActivityIndicatorWithRef;
+},31,[14,32,33,35,52,53,81,194,195],"node_modules\\react-native\\Libraries\\Components\\ActivityIndicator\\ActivityIndicator.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ function _defineProperty(obj, key, value) {
+ if (key in obj) {
+ Object.defineProperty(obj, key, {
+ value: value,
+ enumerable: true,
+ configurable: true,
+ writable: true
+ });
+ } else {
+ obj[key] = value;
+ }
+
+ return obj;
+ }
+
+ module.exports = _defineProperty;
+},32,[],"node_modules\\@babel\\runtime\\helpers\\defineProperty.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var objectWithoutPropertiesLoose = _$$_REQUIRE(_dependencyMap[0], "./objectWithoutPropertiesLoose");
+
+ function _objectWithoutProperties(source, excluded) {
+ if (source == null) return {};
+ var target = objectWithoutPropertiesLoose(source, excluded);
+ var key, i;
+
+ if (Object.getOwnPropertySymbols) {
+ var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+
+ for (i = 0; i < sourceSymbolKeys.length; i++) {
+ key = sourceSymbolKeys[i];
+ if (excluded.indexOf(key) >= 0) continue;
+ if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+ target[key] = source[key];
+ }
+ }
+
+ return target;
+ }
+
+ module.exports = _objectWithoutProperties;
+},33,[34],"node_modules\\@babel\\runtime\\helpers\\objectWithoutProperties.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ function _objectWithoutPropertiesLoose(source, excluded) {
+ if (source == null) return {};
+ var target = {};
+ var sourceKeys = Object.keys(source);
+ var key, i;
+
+ for (i = 0; i < sourceKeys.length; i++) {
+ key = sourceKeys[i];
+ if (excluded.indexOf(key) >= 0) continue;
+ target[key] = source[key];
+ }
+
+ return target;
+ }
+
+ module.exports = _objectWithoutPropertiesLoose;
+},34,[],"node_modules\\@babel\\runtime\\helpers\\objectWithoutPropertiesLoose.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var NativeModules = _$$_REQUIRE(_dependencyMap[0], "NativeModules");
+
+ var Platform = {
+ OS: 'uwp',
+
+ get Version() {
+ var constants = NativeModules.PlatformConstants;
+ return constants && constants.Version;
+ },
+
+ get isTesting() {
+ var constants = NativeModules.PlatformConstants;
+ return constants && constants.isTesting;
+ },
+
+ select: function select(obj) {
+ return 'uwp' in obj ? obj.uwp : obj.default;
+ }
+ };
+ module.exports = Platform;
+},35,[36],"Libraries\\Utilities\\Platform.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _objectWithoutProperties = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/objectWithoutProperties");
+
+ var _extends = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/extends");
+
+ var _slicedToArray = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/slicedToArray");
+
+ var BatchedBridge = _$$_REQUIRE(_dependencyMap[3], "BatchedBridge");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[4], "invariant");
+
+ function genModule(config, moduleID) {
+ if (!config) {
+ return null;
+ }
+
+ var _config = _slicedToArray(config, 5),
+ moduleName = _config[0],
+ constants = _config[1],
+ methods = _config[2],
+ promiseMethods = _config[3],
+ syncMethods = _config[4];
+
+ invariant(!moduleName.startsWith('RCT') && !moduleName.startsWith('RK'), "Module name prefixes should've been stripped by the native side " + "but wasn't for " + moduleName);
+
+ if (!constants && !methods) {
+ return {
+ name: moduleName
+ };
+ }
+
+ var module = {};
+ methods && methods.forEach(function (methodName, methodID) {
+ var isPromise = promiseMethods && arrayContains(promiseMethods, methodID);
+ var isSync = syncMethods && arrayContains(syncMethods, methodID);
+ invariant(!isPromise || !isSync, 'Cannot have a method that is both async and a sync hook');
+ var methodType = isPromise ? 'promise' : isSync ? 'sync' : 'async';
+ module[methodName] = genMethod(moduleID, methodID, methodType);
+ });
+
+ _extends(module, constants);
+
+ if (module.getConstants == null) {
+ module.getConstants = function () {
+ return constants;
+ };
+ } else {
+ console.warn("Unable to define method 'getConstants()' on NativeModule '" + moduleName + "'. NativeModule '" + moduleName + "' already has a constant or method called 'getConstants'. Please remove it.");
+ }
+
+ if (__DEV__) {
+ BatchedBridge.createDebugLookup(moduleID, moduleName, methods);
+ }
+
+ return {
+ name: moduleName,
+ module: module
+ };
+ }
+
+ global.__fbGenNativeModule = genModule;
+
+ function loadModule(name, moduleID) {
+ invariant(global.nativeRequireModuleConfig, "Can't lazily create module without nativeRequireModuleConfig");
+ var config = global.nativeRequireModuleConfig(name);
+ var info = genModule(config, moduleID);
+ return info && info.module;
+ }
+
+ function genMethod(moduleID, methodID, type) {
+ var fn = null;
+
+ if (type === 'promise') {
+ fn = function fn() {
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ 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[5], "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;
+},36,[33,14,37,41,19,51],"node_modules\\react-native\\Libraries\\BatchedBridge\\NativeModules.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var arrayWithHoles = _$$_REQUIRE(_dependencyMap[0], "./arrayWithHoles");
+
+ var iterableToArrayLimit = _$$_REQUIRE(_dependencyMap[1], "./iterableToArrayLimit");
+
+ var nonIterableRest = _$$_REQUIRE(_dependencyMap[2], "./nonIterableRest");
+
+ function _slicedToArray(arr, i) {
+ return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || nonIterableRest();
+ }
+
+ module.exports = _slicedToArray;
+},37,[38,39,40],"node_modules\\@babel\\runtime\\helpers\\slicedToArray.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ function _arrayWithHoles(arr) {
+ if (Array.isArray(arr)) return arr;
+ }
+
+ module.exports = _arrayWithHoles;
+},38,[],"node_modules\\@babel\\runtime\\helpers\\arrayWithHoles.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 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;
+ }
+
+ module.exports = _iterableToArrayLimit;
+},39,[],"node_modules\\@babel\\runtime\\helpers\\iterableToArrayLimit.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ function _nonIterableRest() {
+ throw new TypeError("Invalid attempt to destructure non-iterable instance");
+ }
+
+ module.exports = _nonIterableRest;
+},40,[],"node_modules\\@babel\\runtime\\helpers\\nonIterableRest.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var MessageQueue = _$$_REQUIRE(_dependencyMap[0], "MessageQueue");
+
+ var BatchedBridge = new MessageQueue();
+ Object.defineProperty(global, '__fbBatchedBridge', {
+ configurable: true,
+ value: BatchedBridge
+ });
+ module.exports = BatchedBridge;
+},41,[42],"node_modules\\react-native\\Libraries\\BatchedBridge\\BatchedBridge.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _toConsumableArray = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/toConsumableArray");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ var ErrorUtils = _$$_REQUIRE(_dependencyMap[3], "ErrorUtils");
+
+ var Systrace = _$$_REQUIRE(_dependencyMap[4], "Systrace");
+
+ var deepFreezeAndThrowOnMutationInDev = _$$_REQUIRE(_dependencyMap[5], "deepFreezeAndThrowOnMutationInDev");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[6], "invariant");
+
+ var stringifySafe = _$$_REQUIRE(_dependencyMap[7], "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 MessageQueue = function () {
+ function MessageQueue() {
+ _classCallCheck(this, MessageQueue);
+
+ this._lazyCallableModules = {};
+ this._queue = [[], [], [], 0];
+ this._successCallbacks = {};
+ this._failureCallbacks = {};
+ this._callID = 0;
+ this._lastFlush = 0;
+ this._eventLoopStartTime = Date.now();
+ this._immediatesCallback = null;
+
+ if (__DEV__) {
+ this._debugInfo = {};
+ this._remoteModuleTable = {};
+ this._remoteMethodTable = {};
+ }
+
+ this.callFunctionReturnFlushedQueue = this.callFunctionReturnFlushedQueue.bind(this);
+ this.callFunctionReturnResultAndFlushedQueue = this.callFunctionReturnResultAndFlushedQueue.bind(this);
+ this.flushedQueue = this.flushedQueue.bind(this);
+ this.invokeCallbackAndReturnFlushedQueue = this.invokeCallbackAndReturnFlushedQueue.bind(this);
+ }
+
+ _createClass(MessageQueue, [{
+ key: "callFunctionReturnFlushedQueue",
+ value: function callFunctionReturnFlushedQueue(module, method, args) {
+ var _this = this;
+
+ this.__guard(function () {
+ _this.__callFunction(module, method, args);
+ });
+
+ return this.flushedQueue();
+ }
+ }, {
+ key: "callFunctionReturnResultAndFlushedQueue",
+ value: function callFunctionReturnResultAndFlushedQueue(module, method, args) {
+ var _this2 = this;
+
+ var result;
+
+ this.__guard(function () {
+ result = _this2.__callFunction(module, method, args);
+ });
+
+ return [result, this.flushedQueue()];
+ }
+ }, {
+ key: "invokeCallbackAndReturnFlushedQueue",
+ value: function invokeCallbackAndReturnFlushedQueue(cbID, args) {
+ var _this3 = this;
+
+ this.__guard(function () {
+ _this3.__invokeCallback(cbID, args);
+ });
+
+ return this.flushedQueue();
+ }
+ }, {
+ key: "flushedQueue",
+ value: function flushedQueue() {
+ var _this4 = this;
+
+ this.__guard(function () {
+ _this4.__callImmediates();
+ });
+
+ var queue = this._queue;
+ this._queue = [[], [], [], this._callID];
+ return queue[0].length ? queue : null;
+ }
+ }, {
+ key: "getEventLoopRunningTime",
+ value: function getEventLoopRunningTime() {
+ return Date.now() - this._eventLoopStartTime;
+ }
+ }, {
+ key: "registerCallableModule",
+ value: function registerCallableModule(name, module) {
+ this._lazyCallableModules[name] = function () {
+ return module;
+ };
+ }
+ }, {
+ key: "registerLazyCallableModule",
+ value: function registerLazyCallableModule(name, factory) {
+ var module;
+ var getValue = factory;
+
+ this._lazyCallableModules[name] = function () {
+ if (getValue) {
+ module = getValue();
+ getValue = null;
+ }
+
+ return module;
+ };
+ }
+ }, {
+ key: "getCallableModule",
+ value: function getCallableModule(name) {
+ var getValue = this._lazyCallableModules[name];
+ return getValue ? getValue() : null;
+ }
+ }, {
+ key: "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 === 'string') {
+ return true;
+ }
+
+ if (t === 'number') {
+ return isFinite(val);
+ }
+
+ if (t === 'function' || t !== 'object') {
+ return false;
+ }
+
+ if (Array.isArray(val)) {
+ return val.every(isValidArgument);
+ }
+
+ for (var k in val) {
+ if (typeof val[k] !== 'function' && !isValidArgument(val[k])) {
+ return false;
+ }
+ }
+
+ return true;
+ };
+
+ var replacer = function replacer(key, val) {
+ var t = typeof val;
+
+ if (t === 'function') {
+ return '<>';
+ } else if (t === 'number' && !isFinite(val)) {
+ return '<<' + val.toString() + '>>';
+ } else {
+ return val;
+ }
+ };
+
+ invariant(isValidArgument(params), '%s is not usable as a native method argument', JSON.stringify(params, replacer));
+ deepFreezeAndThrowOnMutationInDev(params);
+ }
+
+ this._queue[PARAMS].push(params);
+
+ var now = Date.now();
+
+ if (global.nativeFlushQueueImmediate && now - this._lastFlush >= MIN_TIME_BETWEEN_FLUSHES_MS) {
+ var queue = this._queue;
+ this._queue = [[], [], [], this._callID];
+ this._lastFlush = now;
+ global.nativeFlushQueueImmediate(queue);
+ }
+
+ Systrace.counterEvent('pending_js_to_native_queue', this._queue[0].length);
+
+ if (__DEV__ && this.__spy && isFinite(moduleID)) {
+ this.__spy({
+ type: TO_NATIVE,
+ module: this._remoteModuleTable[moduleID],
+ method: this._remoteMethodTable[moduleID][methodID],
+ args: params
+ });
+ } else if (this.__spy) {
+ this.__spy({
+ type: TO_NATIVE,
+ module: moduleID + '',
+ method: methodID,
+ args: params
+ });
+ }
+ }
+ }, {
+ key: "createDebugLookup",
+ value: function createDebugLookup(moduleID, name, methods) {
+ if (__DEV__) {
+ this._remoteModuleTable[moduleID] = name;
+ this._remoteMethodTable[moduleID] = methods;
+ }
+ }
+ }, {
+ key: "setImmediatesCallback",
+ value: function setImmediatesCallback(fn) {
+ this._immediatesCallback = fn;
+ }
+ }, {
+ key: "__guard",
+ value: function __guard(fn) {
+ if (this.__shouldPauseOnThrow()) {
+ fn();
+ } else {
+ try {
+ fn();
+ } catch (error) {
+ ErrorUtils.reportFatalError(error);
+ }
+ }
+ }
+ }, {
+ key: "__shouldPauseOnThrow",
+ value: function __shouldPauseOnThrow() {
+ return typeof DebuggerInternal !== 'undefined' && DebuggerInternal.shouldPauseOnThrow === true;
+ }
+ }, {
+ key: "__callImmediates",
+ value: function __callImmediates() {
+ Systrace.beginEvent('JSTimers.callImmediates()');
+
+ if (this._immediatesCallback != null) {
+ this._immediatesCallback();
+ }
+
+ Systrace.endEvent();
+ }
+ }, {
+ key: "__callFunction",
+ value: function __callFunction(module, method, args) {
+ this._lastFlush = Date.now();
+ this._eventLoopStartTime = this._lastFlush;
+
+ if (__DEV__ || this.__spy) {
+ Systrace.beginEvent(module + "." + method + "(" + stringifySafe(args) + ")");
+ } else {
+ Systrace.beginEvent(module + "." + method + "(...)");
+ }
+
+ if (this.__spy) {
+ this.__spy({
+ type: TO_JS,
+ module: module,
+ method: method,
+ args: args
+ });
+ }
+
+ var moduleMethods = this.getCallableModule(module);
+ invariant(!!moduleMethods, 'Module %s is not a registered callable module (calling %s)', module, method);
+ invariant(!!moduleMethods[method], 'Method %s does not exist on module %s', method, module);
+ var result = moduleMethods[method].apply(moduleMethods, args);
+ Systrace.endEvent();
+ return result;
+ }
+ }, {
+ key: "__invokeCallback",
+ value: function __invokeCallback(cbID, args) {
+ this._lastFlush = Date.now();
+ this._eventLoopStartTime = this._lastFlush;
+ var callID = cbID >>> 1;
+ var isSuccess = cbID & 1;
+ var callback = isSuccess ? this._successCallbacks[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 ? '' : 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;
+},42,[43,3,4,47,48,49,19,50],"node_modules\\react-native\\Libraries\\BatchedBridge\\MessageQueue.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var arrayWithoutHoles = _$$_REQUIRE(_dependencyMap[0], "./arrayWithoutHoles");
+
+ var iterableToArray = _$$_REQUIRE(_dependencyMap[1], "./iterableToArray");
+
+ var nonIterableSpread = _$$_REQUIRE(_dependencyMap[2], "./nonIterableSpread");
+
+ function _toConsumableArray(arr) {
+ return arrayWithoutHoles(arr) || iterableToArray(arr) || nonIterableSpread();
+ }
+
+ module.exports = _toConsumableArray;
+},43,[44,45,46],"node_modules\\@babel\\runtime\\helpers\\toConsumableArray.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ function _arrayWithoutHoles(arr) {
+ if (Array.isArray(arr)) {
+ for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) {
+ arr2[i] = arr[i];
+ }
+
+ return arr2;
+ }
+ }
+
+ module.exports = _arrayWithoutHoles;
+},44,[],"node_modules\\@babel\\runtime\\helpers\\arrayWithoutHoles.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ function _iterableToArray(iter) {
+ if ((typeof Symbol === "function" ? Symbol.iterator : "@@iterator") in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
+ }
+
+ module.exports = _iterableToArray;
+},45,[],"node_modules\\@babel\\runtime\\helpers\\iterableToArray.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ function _nonIterableSpread() {
+ throw new TypeError("Invalid attempt to spread non-iterable instance");
+ }
+
+ module.exports = _nonIterableSpread;
+},46,[],"node_modules\\@babel\\runtime\\helpers\\nonIterableSpread.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ module.exports = global.ErrorUtils;
+},47,[],"node_modules\\react-native\\Libraries\\vendor\\core\\ErrorUtils.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var invariant = _$$_REQUIRE(_dependencyMap[0], "invariant");
+
+ var TRACE_TAG_REACT_APPS = 1 << 17;
+ var TRACE_TAG_JS_VM_CALLS = 1 << 27;
+ var _enabled = false;
+ var _asyncCookie = 0;
+ var _markStack = [];
+
+ var _markStackIndex = -1;
+
+ var _canInstallReactHook = false;
+ var REACT_MARKER = "\u269B";
+ var userTimingPolyfill = __DEV__ ? {
+ mark: function mark(markName) {
+ if (_enabled) {
+ _markStackIndex++;
+ _markStack[_markStackIndex] = markName;
+ var systraceLabel = markName;
+
+ if (markName[0] === REACT_MARKER) {
+ var indexOfId = markName.lastIndexOf(' (#');
+ var cutoffIndex = indexOfId !== -1 ? indexOfId : markName.length;
+ systraceLabel = markName.slice(2, cutoffIndex);
+ }
+
+ Systrace.beginEvent(systraceLabel);
+ }
+ },
+ measure: function measure(measureName, startMark, endMark) {
+ if (_enabled) {
+ invariant(typeof measureName === 'string' && typeof startMark === 'string' && typeof endMark === 'undefined', 'Only performance.measure(string, string) overload is supported.');
+ var topMark = _markStack[_markStackIndex];
+ invariant(startMark === topMark, 'There was a mismatching performance.measure() call. ' + 'Expected "%s" but got "%s."', topMark, startMark);
+ _markStackIndex--;
+ Systrace.endEvent();
+ }
+ },
+ clearMarks: function clearMarks(markName) {
+ if (_enabled) {
+ if (_markStackIndex === -1) {
+ return;
+ }
+
+ if (markName === _markStack[_markStackIndex]) {
+ if (userTimingPolyfill != null) {
+ userTimingPolyfill.measure(markName, markName);
+ }
+ }
+ }
+ },
+ clearMeasures: function clearMeasures() {}
+ } : null;
+ var Systrace = {
+ installReactHook: function installReactHook() {
+ if (_enabled) {
+ if (__DEV__) {
+ global.performance = userTimingPolyfill;
+ }
+ }
+
+ _canInstallReactHook = true;
+ },
+ setEnabled: function setEnabled(enabled) {
+ if (_enabled !== enabled) {
+ if (__DEV__) {
+ if (enabled) {
+ global.nativeTraceBeginLegacy && global.nativeTraceBeginLegacy(TRACE_TAG_JS_VM_CALLS);
+ } else {
+ global.nativeTraceEndLegacy && global.nativeTraceEndLegacy(TRACE_TAG_JS_VM_CALLS);
+ }
+
+ if (_canInstallReactHook) {
+ if (enabled && global.performance === undefined) {
+ global.performance = userTimingPolyfill;
+ }
+ }
+ }
+
+ _enabled = enabled;
+ }
+ },
+ isEnabled: function isEnabled() {
+ return _enabled;
+ },
+ beginEvent: function beginEvent(profileName, args) {
+ if (_enabled) {
+ profileName = typeof profileName === 'function' ? profileName() : profileName;
+ global.nativeTraceBeginSection(TRACE_TAG_REACT_APPS, profileName, args);
+ }
+ },
+ endEvent: function endEvent() {
+ if (_enabled) {
+ global.nativeTraceEndSection(TRACE_TAG_REACT_APPS);
+ }
+ },
+ beginAsyncEvent: function beginAsyncEvent(profileName) {
+ var cookie = _asyncCookie;
+
+ if (_enabled) {
+ _asyncCookie++;
+ profileName = typeof profileName === 'function' ? profileName() : profileName;
+ global.nativeTraceBeginAsyncSection(TRACE_TAG_REACT_APPS, profileName, cookie);
+ }
+
+ return cookie;
+ },
+ endAsyncEvent: function endAsyncEvent(profileName, cookie) {
+ if (_enabled) {
+ profileName = typeof profileName === 'function' ? profileName() : profileName;
+ global.nativeTraceEndAsyncSection(TRACE_TAG_REACT_APPS, profileName, cookie);
+ }
+ },
+ counterEvent: function counterEvent(profileName, value) {
+ if (_enabled) {
+ profileName = typeof profileName === 'function' ? profileName() : profileName;
+ global.nativeTraceCounter && global.nativeTraceCounter(TRACE_TAG_REACT_APPS, profileName, value);
+ }
+ }
+ };
+
+ if (__DEV__) {
+ _$$_REQUIRE.Systrace = Systrace;
+ }
+
+ module.exports = Systrace;
+},48,[19],"node_modules\\react-native\\Libraries\\Performance\\Systrace.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ function deepFreezeAndThrowOnMutationInDev(object) {
+ if (__DEV__) {
+ if (typeof object !== 'object' || object === null || Object.isFrozen(object) || Object.isSealed(object)) {
+ return object;
+ }
+
+ var keys = Object.keys(object);
+ var _hasOwnProperty = Object.prototype.hasOwnProperty;
+
+ for (var i = 0; i < keys.length; i++) {
+ var key = keys[i];
+
+ if (_hasOwnProperty.call(object, key)) {
+ Object.defineProperty(object, key, {
+ get: identity.bind(null, object[key])
+ });
+ Object.defineProperty(object, key, {
+ set: throwOnImmutableMutation.bind(null, key)
+ });
+ }
+ }
+
+ Object.freeze(object);
+ Object.seal(object);
+
+ for (var _i = 0; _i < keys.length; _i++) {
+ var _key = keys[_i];
+
+ if (_hasOwnProperty.call(object, _key)) {
+ deepFreezeAndThrowOnMutationInDev(object[_key]);
+ }
+ }
+ }
+
+ return object;
+ }
+
+ function throwOnImmutableMutation(key, value) {
+ throw Error('You attempted to set the key `' + key + '` with the value `' + JSON.stringify(value) + '` on an object that is meant to be immutable ' + 'and has been frozen.');
+ }
+
+ function identity(value) {
+ return value;
+ }
+
+ module.exports = deepFreezeAndThrowOnMutationInDev;
+},49,[],"node_modules\\react-native\\Libraries\\Utilities\\deepFreezeAndThrowOnMutationInDev.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ function stringifySafe(arg) {
+ var ret;
+ var type = typeof arg;
+
+ if (arg === undefined) {
+ ret = 'undefined';
+ } else if (arg === null) {
+ ret = 'null';
+ } else if (type === 'string') {
+ ret = '"' + arg + '"';
+ } else if (type === 'function') {
+ try {
+ ret = arg.toString();
+ } catch (e) {
+ ret = '[function unknown]';
+ }
+ } else {
+ 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;
+},50,[],"node_modules\\react-native\\Libraries\\Utilities\\stringifySafe.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ function defineLazyObjectProperty(object, name, descriptor) {
+ var get = descriptor.get;
+ var enumerable = descriptor.enumerable !== false;
+ var writable = descriptor.writable !== false;
+ var value;
+ var valueSet = false;
+
+ function getValue() {
+ if (!valueSet) {
+ valueSet = true;
+ setValue(get());
+ }
+
+ return value;
+ }
+
+ function setValue(newValue) {
+ value = newValue;
+ valueSet = true;
+ Object.defineProperty(object, name, {
+ value: newValue,
+ configurable: true,
+ enumerable: enumerable,
+ writable: writable
+ });
+ }
+
+ Object.defineProperty(object, name, {
+ get: getValue,
+ set: setValue,
+ configurable: true,
+ enumerable: enumerable
+ });
+ }
+
+ module.exports = defineLazyObjectProperty;
+},51,[],"node_modules\\react-native\\Libraries\\Utilities\\defineLazyObjectProperty.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "react");
+},52,[11],"node_modules\\react-native\\Libraries\\react-native\\React.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var PixelRatio = _$$_REQUIRE(_dependencyMap[1], "PixelRatio");
+
+ var ReactNativeStyleAttributes = _$$_REQUIRE(_dependencyMap[2], "ReactNativeStyleAttributes");
+
+ var StyleSheetValidation = _$$_REQUIRE(_dependencyMap[3], "StyleSheetValidation");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[4], "Platform");
+
+ var flatten = _$$_REQUIRE(_dependencyMap[5], "flattenStyle");
+
+ var hairlineWidth = Platform.OS === 'win32' || Platform.OS === 'windesktop' ? 0.5 : PixelRatio.roundToNearestPixel(0.4);
+
+ if (hairlineWidth === 0) {
+ hairlineWidth = 1 / PixelRatio.get();
+ }
+
+ var absoluteFill = {
+ position: 'absolute',
+ left: 0,
+ right: 0,
+ top: 0,
+ bottom: 0
+ };
+
+ if (__DEV__) {
+ Object.freeze(absoluteFill);
+ }
+
+ module.exports = {
+ hairlineWidth: hairlineWidth,
+ absoluteFill: absoluteFill,
+ absoluteFillObject: absoluteFill,
+ compose: function compose(style1, style2) {
+ if (style1 != null && style2 != null) {
+ return [style1, style2];
+ } else {
+ return style1 != null ? style1 : style2;
+ }
+ },
+ flatten: flatten,
+ setStyleAttributePreprocessor: function setStyleAttributePreprocessor(property, process) {
+ var value;
+
+ if (ReactNativeStyleAttributes[property] === true) {
+ value = {};
+ } else if (typeof ReactNativeStyleAttributes[property] === 'object') {
+ value = ReactNativeStyleAttributes[property];
+ } else {
+ console.error(property + " is not a valid style attribute");
+ return;
+ }
+
+ if (__DEV__ && typeof value.process === 'function') {
+ console.warn("Overwriting " + property + " style attribute preprocessor");
+ }
+
+ ReactNativeStyleAttributes[property] = _objectSpread({}, value, {
+ process: process
+ });
+ },
+ create: function create(obj) {
+ if (__DEV__) {
+ for (var _key in obj) {
+ StyleSheetValidation.validateStyle(_key, obj);
+
+ if (obj[_key]) {
+ Object.freeze(obj[_key]);
+ }
+ }
+ }
+
+ return obj;
+ }
+ };
+},53,[32,54,57,79,35,80],"node_modules\\react-native\\Libraries\\StyleSheet\\StyleSheet.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var Dimensions = _$$_REQUIRE(_dependencyMap[2], "Dimensions");
+
+ var PixelRatio = function () {
+ function PixelRatio() {
+ _classCallCheck(this, PixelRatio);
+ }
+
+ _createClass(PixelRatio, null, [{
+ key: "get",
+ value: function get() {
+ return Dimensions.get('window').scale;
+ }
+ }, {
+ key: "getFontScale",
+ value: function getFontScale() {
+ return Dimensions.get('window').fontScale || PixelRatio.get();
+ }
+ }, {
+ key: "getPixelSizeForLayoutSize",
+ value: function getPixelSizeForLayoutSize(layoutSize) {
+ return Math.round(layoutSize * PixelRatio.get());
+ }
+ }, {
+ key: "roundToNearestPixel",
+ value: function roundToNearestPixel(layoutSize) {
+ var ratio = PixelRatio.get();
+ return Math.round(layoutSize * ratio) / ratio;
+ }
+ }, {
+ key: "startDetecting",
+ value: function startDetecting() {}
+ }]);
+
+ return PixelRatio;
+ }();
+
+ module.exports = PixelRatio;
+},54,[3,4,55],"node_modules\\react-native\\Libraries\\Utilities\\PixelRatio.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ var EventEmitter = _$$_REQUIRE(_dependencyMap[3], "EventEmitter");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[4], "Platform");
+
+ var RCTDeviceEventEmitter = _$$_REQUIRE(_dependencyMap[5], "RCTDeviceEventEmitter");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[6], "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[7], "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;
+},55,[14,3,4,27,35,24,19,56],"node_modules\\react-native\\Libraries\\Utilities\\Dimensions.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var DeviceInfo = _$$_REQUIRE(_dependencyMap[0], "NativeModules").DeviceInfo;
+
+ var invariant = _$$_REQUIRE(_dependencyMap[1], "invariant");
+
+ invariant(DeviceInfo, 'DeviceInfo native module is not installed correctly');
+ module.exports = DeviceInfo;
+},56,[36,19],"node_modules\\react-native\\Libraries\\Utilities\\DeviceInfo.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var DeprecatedImageStylePropTypes = _$$_REQUIRE(_dependencyMap[1], "DeprecatedImageStylePropTypes");
+
+ var TextStylePropTypes = _$$_REQUIRE(_dependencyMap[2], "TextStylePropTypes");
+
+ var DeprecatedViewStylePropTypes = _$$_REQUIRE(_dependencyMap[3], "DeprecatedViewStylePropTypes");
+
+ var processColor = _$$_REQUIRE(_dependencyMap[4], "processColor");
+
+ var processTransform = _$$_REQUIRE(_dependencyMap[5], "processTransform");
+
+ var sizesDiffer = _$$_REQUIRE(_dependencyMap[6], "sizesDiffer");
+
+ var ReactNativeStyleAttributes = {};
+
+ for (var _i = 0, _Object$keys = Object.keys(_objectSpread({}, DeprecatedViewStylePropTypes, {}, TextStylePropTypes, {}, DeprecatedImageStylePropTypes)); _i < _Object$keys.length; _i++) {
+ var attributeName = _Object$keys[_i];
+ ReactNativeStyleAttributes[attributeName] = true;
+ }
+
+ ReactNativeStyleAttributes.transform = {
+ process: processTransform
+ };
+ ReactNativeStyleAttributes.shadowOffset = {
+ diff: sizesDiffer
+ };
+ var colorAttributes = {
+ process: processColor
+ };
+ ReactNativeStyleAttributes.backgroundColor = colorAttributes;
+ ReactNativeStyleAttributes.borderBottomColor = colorAttributes;
+ ReactNativeStyleAttributes.borderColor = colorAttributes;
+ ReactNativeStyleAttributes.borderLeftColor = colorAttributes;
+ ReactNativeStyleAttributes.borderRightColor = colorAttributes;
+ ReactNativeStyleAttributes.borderTopColor = colorAttributes;
+ ReactNativeStyleAttributes.borderStartColor = colorAttributes;
+ ReactNativeStyleAttributes.borderEndColor = colorAttributes;
+ ReactNativeStyleAttributes.color = colorAttributes;
+ ReactNativeStyleAttributes.shadowColor = colorAttributes;
+ ReactNativeStyleAttributes.textDecorationColor = colorAttributes;
+ ReactNativeStyleAttributes.tintColor = colorAttributes;
+ ReactNativeStyleAttributes.textShadowColor = colorAttributes;
+ ReactNativeStyleAttributes.overlayColor = colorAttributes;
+ module.exports = ReactNativeStyleAttributes;
+},57,[32,58,73,74,75,76,78],"node_modules\\react-native\\Libraries\\Components\\View\\ReactNativeStyleAttributes.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var DeprecatedColorPropType = _$$_REQUIRE(_dependencyMap[1], "DeprecatedColorPropType");
+
+ var DeprecatedLayoutPropTypes = _$$_REQUIRE(_dependencyMap[2], "DeprecatedLayoutPropTypes");
+
+ var ReactPropTypes = _$$_REQUIRE(_dependencyMap[3], "prop-types");
+
+ var DeprecatedShadowPropTypesIOS = _$$_REQUIRE(_dependencyMap[4], "DeprecatedShadowPropTypesIOS");
+
+ var DeprecatedTransformPropTypes = _$$_REQUIRE(_dependencyMap[5], "DeprecatedTransformPropTypes");
+
+ var ImageStylePropTypes = _objectSpread({}, DeprecatedLayoutPropTypes, {}, DeprecatedShadowPropTypesIOS, {}, DeprecatedTransformPropTypes, {
+ resizeMode: ReactPropTypes.oneOf(['center', 'contain', 'cover', 'repeat', 'stretch']),
+ backfaceVisibility: ReactPropTypes.oneOf(['visible', 'hidden']),
+ backgroundColor: DeprecatedColorPropType,
+ borderColor: DeprecatedColorPropType,
+ borderWidth: ReactPropTypes.number,
+ borderRadius: ReactPropTypes.number,
+ overflow: ReactPropTypes.oneOf(['visible', 'hidden']),
+ tintColor: DeprecatedColorPropType,
+ opacity: ReactPropTypes.number,
+ overlayColor: ReactPropTypes.string,
+ borderTopLeftRadius: ReactPropTypes.number,
+ borderTopRightRadius: ReactPropTypes.number,
+ borderBottomLeftRadius: ReactPropTypes.number,
+ borderBottomRightRadius: ReactPropTypes.number
+ });
+
+ module.exports = ImageStylePropTypes;
+},58,[32,59,61,62,68,69],"node_modules\\react-native\\Libraries\\DeprecatedPropTypes\\DeprecatedImageStylePropTypes.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var normalizeColor = _$$_REQUIRE(_dependencyMap[0], "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;
+},59,[60],"node_modules\\react-native\\Libraries\\DeprecatedPropTypes\\DeprecatedColorPropType.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var Platform = _$$_REQUIRE(_dependencyMap[0], "Platform");
+
+ 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 (typeof color === 'object' && color !== null && Platform.OS === 'macos') {
+ if ('semantic' in color) {
+ return color;
+ } else if ('dynamic' in color && color.dynamic !== undefined) {
+ var dynamic = color.dynamic;
+ var dynamicColor = {
+ dynamic: {
+ light: normalizeColor(dynamic.light),
+ dark: normalizeColor(dynamic.dark)
+ }
+ };
+ return dynamicColor;
+ }
+ }
+
+ if (typeof color !== 'string') {
+ 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;
+},60,[35],"node_modules\\react-native\\Libraries\\Color\\normalizeColor.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var ReactPropTypes = _$$_REQUIRE(_dependencyMap[0], "prop-types");
+
+ var LayoutPropTypes = {
+ display: ReactPropTypes.oneOf(['none', 'flex']),
+ width: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ height: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ start: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ end: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ top: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ left: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ right: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ bottom: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ minWidth: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ maxWidth: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ minHeight: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ maxHeight: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ margin: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ marginVertical: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ marginHorizontal: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ marginTop: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ marginBottom: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ marginLeft: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ marginRight: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ marginStart: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ marginEnd: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ padding: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ paddingVertical: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ paddingHorizontal: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ paddingTop: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ paddingBottom: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ paddingLeft: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ paddingRight: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ paddingStart: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ paddingEnd: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ borderWidth: ReactPropTypes.number,
+ borderTopWidth: ReactPropTypes.number,
+ borderStartWidth: ReactPropTypes.number,
+ borderEndWidth: ReactPropTypes.number,
+ borderRightWidth: ReactPropTypes.number,
+ borderBottomWidth: ReactPropTypes.number,
+ borderLeftWidth: ReactPropTypes.number,
+ position: ReactPropTypes.oneOf(['absolute', 'relative']),
+ flexDirection: ReactPropTypes.oneOf(['row', 'row-reverse', 'column', 'column-reverse']),
+ flexWrap: ReactPropTypes.oneOf(['wrap', 'nowrap', 'wrap-reverse']),
+ justifyContent: ReactPropTypes.oneOf(['flex-start', 'flex-end', 'center', 'space-between', 'space-around', 'space-evenly']),
+ alignItems: ReactPropTypes.oneOf(['flex-start', 'flex-end', 'center', 'stretch', 'baseline']),
+ alignSelf: ReactPropTypes.oneOf(['auto', 'flex-start', 'flex-end', 'center', 'stretch', 'baseline']),
+ alignContent: ReactPropTypes.oneOf(['flex-start', 'flex-end', 'center', 'stretch', 'space-between', 'space-around']),
+ overflow: ReactPropTypes.oneOf(['visible', 'hidden', 'scroll']),
+ flex: ReactPropTypes.number,
+ flexGrow: ReactPropTypes.number,
+ flexShrink: ReactPropTypes.number,
+ flexBasis: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ aspectRatio: ReactPropTypes.number,
+ zIndex: ReactPropTypes.number,
+ direction: ReactPropTypes.oneOf(['inherit', 'ltr', 'rtl'])
+ };
+ module.exports = LayoutPropTypes;
+},61,[62],"node_modules\\react-native\\Libraries\\DeprecatedPropTypes\\DeprecatedLayoutPropTypes.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ if (process.env.NODE_ENV !== 'production') {
+ var ReactIs = _$$_REQUIRE(_dependencyMap[0], "react-is");
+
+ var throwOnDirectAccess = true;
+ module.exports = _$$_REQUIRE(_dependencyMap[1], "./factoryWithTypeCheckers")(ReactIs.isElement, throwOnDirectAccess);
+ } else {
+ module.exports = _$$_REQUIRE(_dependencyMap[2], "./factoryWithThrowingShims")();
+ }
+},62,[63,66,67],"node_modules\\prop-types\\index.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ if (process.env.NODE_ENV === 'production') {
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "./cjs/react-is.production.min.js");
+ } else {
+ module.exports = _$$_REQUIRE(_dependencyMap[1], "./cjs/react-is.development.js");
+ }
+},63,[64,65],"node_modules\\react-is\\index.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ /** @license React v16.8.6
+ * react-is.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+ 'use strict';
+
+ Object.defineProperty(exports, "__esModule", {
+ value: !0
+ });
+ var b = "function" === typeof Symbol && (typeof Symbol === "function" ? Symbol.for : "@@for"),
+ c = b ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.element") : 60103,
+ d = b ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.portal") : 60106,
+ e = b ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.fragment") : 60107,
+ f = b ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.strict_mode") : 60108,
+ g = b ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.profiler") : 60114,
+ h = b ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.provider") : 60109,
+ k = b ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.context") : 60110,
+ l = b ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.async_mode") : 60111,
+ m = b ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.concurrent_mode") : 60111,
+ n = b ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.forward_ref") : 60112,
+ p = b ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.suspense") : 60113,
+ q = b ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.memo") : 60115,
+ r = b ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.lazy") : 60116;
+
+ function t(a) {
+ if ("object" === typeof a && null !== a) {
+ var u = a.$$typeof;
+
+ switch (u) {
+ case c:
+ switch (a = a.type, a) {
+ case l:
+ case m:
+ case e:
+ case g:
+ case f:
+ case p:
+ return a;
+
+ default:
+ switch (a = a && a.$$typeof, a) {
+ case k:
+ case n:
+ case h:
+ return a;
+
+ default:
+ return u;
+ }
+
+ }
+
+ case r:
+ case q:
+ case d:
+ return u;
+ }
+ }
+ }
+
+ function v(a) {
+ return t(a) === m;
+ }
+
+ exports.typeOf = t;
+ exports.AsyncMode = l;
+ exports.ConcurrentMode = m;
+ exports.ContextConsumer = k;
+ exports.ContextProvider = h;
+ exports.Element = c;
+ exports.ForwardRef = n;
+ exports.Fragment = e;
+ exports.Lazy = r;
+ exports.Memo = q;
+ exports.Portal = d;
+ exports.Profiler = g;
+ exports.StrictMode = f;
+ exports.Suspense = p;
+
+ exports.isValidElementType = function (a) {
+ return "string" === typeof a || "function" === typeof a || a === e || a === m || a === g || a === f || a === p || "object" === typeof a && null !== a && (a.$$typeof === r || a.$$typeof === q || a.$$typeof === h || a.$$typeof === k || a.$$typeof === n);
+ };
+
+ exports.isAsyncMode = function (a) {
+ return v(a) || t(a) === l;
+ };
+
+ exports.isConcurrentMode = v;
+
+ exports.isContextConsumer = function (a) {
+ return t(a) === k;
+ };
+
+ exports.isContextProvider = function (a) {
+ return t(a) === h;
+ };
+
+ exports.isElement = function (a) {
+ return "object" === typeof a && null !== a && a.$$typeof === c;
+ };
+
+ exports.isForwardRef = function (a) {
+ return t(a) === n;
+ };
+
+ exports.isFragment = function (a) {
+ return t(a) === e;
+ };
+
+ exports.isLazy = function (a) {
+ return t(a) === r;
+ };
+
+ exports.isMemo = function (a) {
+ return t(a) === q;
+ };
+
+ exports.isPortal = function (a) {
+ return t(a) === d;
+ };
+
+ exports.isProfiler = function (a) {
+ return t(a) === g;
+ };
+
+ exports.isStrictMode = function (a) {
+ return t(a) === f;
+ };
+
+ exports.isSuspense = function (a) {
+ return t(a) === p;
+ };
+},64,[],"node_modules\\react-is\\cjs\\react-is.production.min.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ /** @license React v16.8.6
+ * react-is.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+ 'use strict';
+
+ if (process.env.NODE_ENV !== "production") {
+ (function () {
+ 'use strict';
+
+ Object.defineProperty(exports, '__esModule', {
+ value: true
+ });
+ var hasSymbol = typeof Symbol === 'function' && (typeof Symbol === "function" ? Symbol.for : "@@for");
+ var REACT_ELEMENT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.element') : 0xeac7;
+ var REACT_PORTAL_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.portal') : 0xeaca;
+ var REACT_FRAGMENT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.fragment') : 0xeacb;
+ var REACT_STRICT_MODE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.strict_mode') : 0xeacc;
+ var REACT_PROFILER_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.profiler') : 0xead2;
+ var REACT_PROVIDER_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.provider') : 0xeacd;
+ var REACT_CONTEXT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.context') : 0xeace;
+ var REACT_ASYNC_MODE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.async_mode') : 0xeacf;
+ var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.concurrent_mode') : 0xeacf;
+ var REACT_FORWARD_REF_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.forward_ref') : 0xead0;
+ var REACT_SUSPENSE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.suspense') : 0xead1;
+ var REACT_MEMO_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.memo') : 0xead3;
+ var REACT_LAZY_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.lazy') : 0xead4;
+
+ function isValidElementType(type) {
+ return typeof type === 'string' || typeof type === 'function' || type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || typeof type === 'object' && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE);
+ }
+
+ var lowPriorityWarning = function lowPriorityWarning() {};
+
+ {
+ var printWarning = function printWarning(format) {
+ for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+ args[_key - 1] = arguments[_key];
+ }
+
+ var argIndex = 0;
+ var message = 'Warning: ' + format.replace(/%s/g, function () {
+ return args[argIndex++];
+ });
+
+ if (typeof console !== 'undefined') {
+ console.warn(message);
+ }
+
+ try {
+ throw new Error(message);
+ } catch (x) {}
+ };
+
+ lowPriorityWarning = function lowPriorityWarning(condition, format) {
+ if (format === undefined) {
+ throw new Error('`lowPriorityWarning(condition, format, ...args)` requires a warning ' + 'message argument');
+ }
+
+ if (!condition) {
+ for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
+ args[_key2 - 2] = arguments[_key2];
+ }
+
+ printWarning.apply(undefined, [format].concat(args));
+ }
+ };
+ }
+ var lowPriorityWarning$1 = lowPriorityWarning;
+
+ function typeOf(object) {
+ if (typeof object === 'object' && object !== null) {
+ var $$typeof = object.$$typeof;
+
+ switch ($$typeof) {
+ case REACT_ELEMENT_TYPE:
+ var type = object.type;
+
+ switch (type) {
+ case REACT_ASYNC_MODE_TYPE:
+ case REACT_CONCURRENT_MODE_TYPE:
+ case REACT_FRAGMENT_TYPE:
+ case REACT_PROFILER_TYPE:
+ case REACT_STRICT_MODE_TYPE:
+ case REACT_SUSPENSE_TYPE:
+ return type;
+
+ default:
+ var $$typeofType = type && type.$$typeof;
+
+ switch ($$typeofType) {
+ case REACT_CONTEXT_TYPE:
+ case REACT_FORWARD_REF_TYPE:
+ case REACT_PROVIDER_TYPE:
+ return $$typeofType;
+
+ default:
+ return $$typeof;
+ }
+
+ }
+
+ case REACT_LAZY_TYPE:
+ case REACT_MEMO_TYPE:
+ case REACT_PORTAL_TYPE:
+ return $$typeof;
+ }
+ }
+
+ return undefined;
+ }
+
+ var AsyncMode = REACT_ASYNC_MODE_TYPE;
+ var ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
+ var ContextConsumer = REACT_CONTEXT_TYPE;
+ var ContextProvider = REACT_PROVIDER_TYPE;
+ var Element = REACT_ELEMENT_TYPE;
+ var ForwardRef = REACT_FORWARD_REF_TYPE;
+ var Fragment = REACT_FRAGMENT_TYPE;
+ var Lazy = REACT_LAZY_TYPE;
+ var Memo = REACT_MEMO_TYPE;
+ var Portal = REACT_PORTAL_TYPE;
+ var Profiler = REACT_PROFILER_TYPE;
+ var StrictMode = REACT_STRICT_MODE_TYPE;
+ var Suspense = REACT_SUSPENSE_TYPE;
+ var hasWarnedAboutDeprecatedIsAsyncMode = false;
+
+ function isAsyncMode(object) {
+ {
+ if (!hasWarnedAboutDeprecatedIsAsyncMode) {
+ hasWarnedAboutDeprecatedIsAsyncMode = true;
+ lowPriorityWarning$1(false, 'The ReactIs.isAsyncMode() alias has been deprecated, ' + 'and will be removed in React 17+. Update your code to use ' + 'ReactIs.isConcurrentMode() instead. It has the exact same API.');
+ }
+ }
+ return isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE;
+ }
+
+ function isConcurrentMode(object) {
+ return typeOf(object) === REACT_CONCURRENT_MODE_TYPE;
+ }
+
+ function isContextConsumer(object) {
+ return typeOf(object) === REACT_CONTEXT_TYPE;
+ }
+
+ function isContextProvider(object) {
+ return typeOf(object) === REACT_PROVIDER_TYPE;
+ }
+
+ function isElement(object) {
+ return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+ }
+
+ function isForwardRef(object) {
+ return typeOf(object) === REACT_FORWARD_REF_TYPE;
+ }
+
+ function isFragment(object) {
+ return typeOf(object) === REACT_FRAGMENT_TYPE;
+ }
+
+ function isLazy(object) {
+ return typeOf(object) === REACT_LAZY_TYPE;
+ }
+
+ function isMemo(object) {
+ return typeOf(object) === REACT_MEMO_TYPE;
+ }
+
+ function isPortal(object) {
+ return typeOf(object) === REACT_PORTAL_TYPE;
+ }
+
+ function isProfiler(object) {
+ return typeOf(object) === REACT_PROFILER_TYPE;
+ }
+
+ function isStrictMode(object) {
+ return typeOf(object) === REACT_STRICT_MODE_TYPE;
+ }
+
+ function isSuspense(object) {
+ return typeOf(object) === REACT_SUSPENSE_TYPE;
+ }
+
+ exports.typeOf = typeOf;
+ exports.AsyncMode = AsyncMode;
+ exports.ConcurrentMode = ConcurrentMode;
+ exports.ContextConsumer = ContextConsumer;
+ exports.ContextProvider = ContextProvider;
+ exports.Element = Element;
+ exports.ForwardRef = ForwardRef;
+ exports.Fragment = Fragment;
+ exports.Lazy = Lazy;
+ exports.Memo = Memo;
+ exports.Portal = Portal;
+ exports.Profiler = Profiler;
+ exports.StrictMode = StrictMode;
+ exports.Suspense = Suspense;
+ exports.isValidElementType = isValidElementType;
+ exports.isAsyncMode = isAsyncMode;
+ exports.isConcurrentMode = isConcurrentMode;
+ exports.isContextConsumer = isContextConsumer;
+ exports.isContextProvider = isContextProvider;
+ exports.isElement = isElement;
+ exports.isForwardRef = isForwardRef;
+ exports.isFragment = isFragment;
+ exports.isLazy = isLazy;
+ exports.isMemo = isMemo;
+ exports.isPortal = isPortal;
+ exports.isProfiler = isProfiler;
+ exports.isStrictMode = isStrictMode;
+ exports.isSuspense = isSuspense;
+ })();
+ }
+},65,[],"node_modules\\react-is\\cjs\\react-is.development.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var ReactIs = _$$_REQUIRE(_dependencyMap[0], "react-is");
+
+ var assign = _$$_REQUIRE(_dependencyMap[1], "object-assign");
+
+ var ReactPropTypesSecret = _$$_REQUIRE(_dependencyMap[2], "./lib/ReactPropTypesSecret");
+
+ var checkPropTypes = _$$_REQUIRE(_dependencyMap[3], "./checkPropTypes");
+
+ var has = Function.call.bind(Object.prototype.hasOwnProperty);
+
+ var printWarning = function printWarning() {};
+
+ if (process.env.NODE_ENV !== 'production') {
+ printWarning = function printWarning(text) {
+ var message = 'Warning: ' + text;
+
+ if (typeof console !== 'undefined') {
+ console.error(message);
+ }
+
+ try {
+ throw new Error(message);
+ } catch (x) {}
+ };
+ }
+
+ function emptyFunctionThatReturnsNull() {
+ return null;
+ }
+
+ module.exports = function (isValidElement, throwOnDirectAccess) {
+ var ITERATOR_SYMBOL = typeof Symbol === 'function' && (typeof Symbol === "function" ? Symbol.iterator : "@@iterator");
+ var FAUX_ITERATOR_SYMBOL = '@@iterator';
+
+ function getIteratorFn(maybeIterable) {
+ var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);
+
+ if (typeof iteratorFn === 'function') {
+ return iteratorFn;
+ }
+ }
+
+ var ANONYMOUS = '<>';
+ var ReactPropTypes = {
+ array: createPrimitiveTypeChecker('array'),
+ bool: createPrimitiveTypeChecker('boolean'),
+ func: createPrimitiveTypeChecker('function'),
+ number: createPrimitiveTypeChecker('number'),
+ object: createPrimitiveTypeChecker('object'),
+ string: createPrimitiveTypeChecker('string'),
+ symbol: createPrimitiveTypeChecker('symbol'),
+ any: createAnyTypeChecker(),
+ arrayOf: createArrayOfTypeChecker,
+ element: createElementTypeChecker(),
+ elementType: createElementTypeTypeChecker(),
+ instanceOf: createInstanceTypeChecker,
+ node: createNodeChecker(),
+ objectOf: createObjectOfTypeChecker,
+ oneOf: createEnumTypeChecker,
+ oneOfType: createUnionTypeChecker,
+ shape: createShapeTypeChecker,
+ exact: createStrictShapeTypeChecker
+ };
+
+ function is(x, y) {
+ if (x === y) {
+ return x !== 0 || 1 / x === 1 / y;
+ } else {
+ return x !== x && y !== y;
+ }
+ }
+
+ function PropTypeError(message) {
+ this.message = message;
+ this.stack = '';
+ }
+
+ PropTypeError.prototype = Error.prototype;
+
+ function createChainableTypeChecker(validate) {
+ if (process.env.NODE_ENV !== 'production') {
+ var manualPropTypeCallCache = {};
+ var manualPropTypeWarningCount = 0;
+ }
+
+ function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {
+ componentName = componentName || ANONYMOUS;
+ propFullName = propFullName || propName;
+
+ if (secret !== ReactPropTypesSecret) {
+ if (throwOnDirectAccess) {
+ var err = new Error('Calling PropTypes validators directly is not supported by the `prop-types` package. ' + 'Use `PropTypes.checkPropTypes()` to call them. ' + 'Read more at http://fb.me/use-check-prop-types');
+ err.name = 'Invariant Violation';
+ throw err;
+ } else if (process.env.NODE_ENV !== 'production' && typeof console !== 'undefined') {
+ var cacheKey = componentName + ':' + propName;
+
+ if (!manualPropTypeCallCache[cacheKey] && manualPropTypeWarningCount < 3) {
+ printWarning('You are manually calling a React.PropTypes validation ' + 'function for the `' + propFullName + '` prop on `' + componentName + '`. This is deprecated ' + 'and will throw in the standalone `prop-types` package. ' + 'You may be seeing this warning due to a third-party PropTypes ' + 'library. See https://fb.me/react-warning-dont-call-proptypes ' + 'for details.');
+ manualPropTypeCallCache[cacheKey] = true;
+ manualPropTypeWarningCount++;
+ }
+ }
+ }
+
+ if (props[propName] == null) {
+ if (isRequired) {
+ if (props[propName] === null) {
+ return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required ' + ('in `' + componentName + '`, but its value is `null`.'));
+ }
+
+ return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required in ' + ('`' + componentName + '`, but its value is `undefined`.'));
+ }
+
+ return null;
+ } else {
+ return validate(props, propName, componentName, location, propFullName);
+ }
+ }
+
+ var chainedCheckType = checkType.bind(null, false);
+ chainedCheckType.isRequired = checkType.bind(null, true);
+ return chainedCheckType;
+ }
+
+ function createPrimitiveTypeChecker(expectedType) {
+ function validate(props, propName, componentName, location, propFullName, secret) {
+ var propValue = props[propName];
+ var propType = getPropType(propValue);
+
+ if (propType !== expectedType) {
+ var preciseType = getPreciseType(propValue);
+ return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + preciseType + '` supplied to `' + componentName + '`, expected ') + ('`' + expectedType + '`.'));
+ }
+
+ return null;
+ }
+
+ return createChainableTypeChecker(validate);
+ }
+
+ function createAnyTypeChecker() {
+ return createChainableTypeChecker(emptyFunctionThatReturnsNull);
+ }
+
+ function createArrayOfTypeChecker(typeChecker) {
+ function validate(props, propName, componentName, location, propFullName) {
+ if (typeof typeChecker !== 'function') {
+ return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside arrayOf.');
+ }
+
+ var propValue = props[propName];
+
+ if (!Array.isArray(propValue)) {
+ var propType = getPropType(propValue);
+ return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an array.'));
+ }
+
+ for (var i = 0; i < propValue.length; i++) {
+ var error = typeChecker(propValue, i, componentName, location, propFullName + '[' + i + ']', ReactPropTypesSecret);
+
+ if (error instanceof Error) {
+ return error;
+ }
+ }
+
+ return null;
+ }
+
+ return createChainableTypeChecker(validate);
+ }
+
+ function createElementTypeChecker() {
+ function validate(props, propName, componentName, location, propFullName) {
+ var propValue = props[propName];
+
+ if (!isValidElement(propValue)) {
+ var propType = getPropType(propValue);
+ return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement.'));
+ }
+
+ return null;
+ }
+
+ return createChainableTypeChecker(validate);
+ }
+
+ function createElementTypeTypeChecker() {
+ function validate(props, propName, componentName, location, propFullName) {
+ var propValue = props[propName];
+
+ if (!ReactIs.isValidElementType(propValue)) {
+ var propType = getPropType(propValue);
+ return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement type.'));
+ }
+
+ return null;
+ }
+
+ return createChainableTypeChecker(validate);
+ }
+
+ function createInstanceTypeChecker(expectedClass) {
+ function validate(props, propName, componentName, location, propFullName) {
+ if (!(props[propName] instanceof expectedClass)) {
+ var expectedClassName = expectedClass.name || ANONYMOUS;
+ var actualClassName = getClassName(props[propName]);
+ return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + actualClassName + '` supplied to `' + componentName + '`, expected ') + ('instance of `' + expectedClassName + '`.'));
+ }
+
+ return null;
+ }
+
+ return createChainableTypeChecker(validate);
+ }
+
+ function createEnumTypeChecker(expectedValues) {
+ if (!Array.isArray(expectedValues)) {
+ if (process.env.NODE_ENV !== 'production') {
+ if (arguments.length > 1) {
+ printWarning('Invalid arguments supplied to oneOf, expected an array, got ' + arguments.length + ' arguments. ' + 'A common mistake is to write oneOf(x, y, z) instead of oneOf([x, y, z]).');
+ } else {
+ printWarning('Invalid argument supplied to oneOf, expected an array.');
+ }
+ }
+
+ return emptyFunctionThatReturnsNull;
+ }
+
+ function validate(props, propName, componentName, location, propFullName) {
+ var propValue = props[propName];
+
+ for (var i = 0; i < expectedValues.length; i++) {
+ if (is(propValue, expectedValues[i])) {
+ return null;
+ }
+ }
+
+ var valuesString = JSON.stringify(expectedValues, function replacer(key, value) {
+ var type = getPreciseType(value);
+
+ if (type === 'symbol') {
+ return String(value);
+ }
+
+ return value;
+ });
+ return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of value `' + String(propValue) + '` ' + ('supplied to `' + componentName + '`, expected one of ' + valuesString + '.'));
+ }
+
+ return createChainableTypeChecker(validate);
+ }
+
+ function createObjectOfTypeChecker(typeChecker) {
+ function validate(props, propName, componentName, location, propFullName) {
+ if (typeof typeChecker !== 'function') {
+ return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside objectOf.');
+ }
+
+ var propValue = props[propName];
+ var propType = getPropType(propValue);
+
+ if (propType !== 'object') {
+ return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an object.'));
+ }
+
+ for (var key in propValue) {
+ if (has(propValue, key)) {
+ var error = typeChecker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
+
+ if (error instanceof Error) {
+ return error;
+ }
+ }
+ }
+
+ return null;
+ }
+
+ return createChainableTypeChecker(validate);
+ }
+
+ function createUnionTypeChecker(arrayOfTypeCheckers) {
+ if (!Array.isArray(arrayOfTypeCheckers)) {
+ process.env.NODE_ENV !== 'production' ? printWarning('Invalid argument supplied to oneOfType, expected an instance of array.') : void 0;
+ return emptyFunctionThatReturnsNull;
+ }
+
+ for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
+ var checker = arrayOfTypeCheckers[i];
+
+ if (typeof checker !== 'function') {
+ printWarning('Invalid argument supplied to oneOfType. Expected an array of check functions, but ' + 'received ' + getPostfixForTypeWarning(checker) + ' at index ' + i + '.');
+ return emptyFunctionThatReturnsNull;
+ }
+ }
+
+ function validate(props, propName, componentName, location, propFullName) {
+ for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
+ var checker = arrayOfTypeCheckers[i];
+
+ if (checker(props, propName, componentName, location, propFullName, ReactPropTypesSecret) == null) {
+ return null;
+ }
+ }
+
+ return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`.'));
+ }
+
+ return createChainableTypeChecker(validate);
+ }
+
+ function createNodeChecker() {
+ function validate(props, propName, componentName, location, propFullName) {
+ if (!isNode(props[propName])) {
+ return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`, expected a ReactNode.'));
+ }
+
+ return null;
+ }
+
+ return createChainableTypeChecker(validate);
+ }
+
+ function createShapeTypeChecker(shapeTypes) {
+ function validate(props, propName, componentName, location, propFullName) {
+ var propValue = props[propName];
+ var propType = getPropType(propValue);
+
+ if (propType !== 'object') {
+ return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));
+ }
+
+ for (var key in shapeTypes) {
+ var checker = shapeTypes[key];
+
+ if (!checker) {
+ continue;
+ }
+
+ var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
+
+ if (error) {
+ return error;
+ }
+ }
+
+ return null;
+ }
+
+ return createChainableTypeChecker(validate);
+ }
+
+ function createStrictShapeTypeChecker(shapeTypes) {
+ function validate(props, propName, componentName, location, propFullName) {
+ var propValue = props[propName];
+ var propType = getPropType(propValue);
+
+ if (propType !== 'object') {
+ return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));
+ }
+
+ var allKeys = assign({}, props[propName], shapeTypes);
+
+ for (var key in allKeys) {
+ var checker = shapeTypes[key];
+
+ if (!checker) {
+ return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` key `' + key + '` supplied to `' + componentName + '`.' + '\nBad object: ' + JSON.stringify(props[propName], null, ' ') + '\nValid keys: ' + JSON.stringify(Object.keys(shapeTypes), null, ' '));
+ }
+
+ var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
+
+ if (error) {
+ return error;
+ }
+ }
+
+ return null;
+ }
+
+ return createChainableTypeChecker(validate);
+ }
+
+ function isNode(propValue) {
+ switch (typeof propValue) {
+ case 'number':
+ case 'string':
+ case 'undefined':
+ return true;
+
+ case 'boolean':
+ return !propValue;
+
+ case 'object':
+ if (Array.isArray(propValue)) {
+ return propValue.every(isNode);
+ }
+
+ if (propValue === null || isValidElement(propValue)) {
+ return true;
+ }
+
+ var iteratorFn = getIteratorFn(propValue);
+
+ if (iteratorFn) {
+ var iterator = iteratorFn.call(propValue);
+ var step;
+
+ if (iteratorFn !== propValue.entries) {
+ while (!(step = iterator.next()).done) {
+ if (!isNode(step.value)) {
+ return false;
+ }
+ }
+ } else {
+ while (!(step = iterator.next()).done) {
+ var entry = step.value;
+
+ if (entry) {
+ if (!isNode(entry[1])) {
+ return false;
+ }
+ }
+ }
+ }
+ } else {
+ return false;
+ }
+
+ return true;
+
+ default:
+ return false;
+ }
+ }
+
+ function isSymbol(propType, propValue) {
+ if (propType === 'symbol') {
+ return true;
+ }
+
+ if (!propValue) {
+ return false;
+ }
+
+ if (propValue['@@toStringTag'] === 'Symbol') {
+ return true;
+ }
+
+ if (typeof Symbol === 'function' && propValue instanceof Symbol) {
+ return true;
+ }
+
+ return false;
+ }
+
+ function getPropType(propValue) {
+ var propType = typeof propValue;
+
+ if (Array.isArray(propValue)) {
+ return 'array';
+ }
+
+ if (propValue instanceof RegExp) {
+ return 'object';
+ }
+
+ if (isSymbol(propType, propValue)) {
+ return 'symbol';
+ }
+
+ return propType;
+ }
+
+ function getPreciseType(propValue) {
+ if (typeof propValue === 'undefined' || propValue === null) {
+ return '' + propValue;
+ }
+
+ var propType = getPropType(propValue);
+
+ if (propType === 'object') {
+ if (propValue instanceof Date) {
+ return 'date';
+ } else if (propValue instanceof RegExp) {
+ return 'regexp';
+ }
+ }
+
+ return propType;
+ }
+
+ function getPostfixForTypeWarning(value) {
+ var type = getPreciseType(value);
+
+ switch (type) {
+ case 'array':
+ case 'object':
+ return 'an ' + type;
+
+ case 'boolean':
+ case 'date':
+ case 'regexp':
+ return 'a ' + type;
+
+ default:
+ return type;
+ }
+ }
+
+ function getClassName(propValue) {
+ if (!propValue.constructor || !propValue.constructor.name) {
+ return ANONYMOUS;
+ }
+
+ return propValue.constructor.name;
+ }
+
+ ReactPropTypes.checkPropTypes = checkPropTypes;
+ ReactPropTypes.resetWarningCache = checkPropTypes.resetWarningCache;
+ ReactPropTypes.PropTypes = ReactPropTypes;
+ return ReactPropTypes;
+ };
+},66,[63,13,17,16],"node_modules\\prop-types\\factoryWithTypeCheckers.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var ReactPropTypesSecret = _$$_REQUIRE(_dependencyMap[0], "./lib/ReactPropTypesSecret");
+
+ function emptyFunction() {}
+
+ function emptyFunctionWithReset() {}
+
+ emptyFunctionWithReset.resetWarningCache = emptyFunction;
+
+ module.exports = function () {
+ function shim(props, propName, componentName, location, propFullName, secret) {
+ if (secret === ReactPropTypesSecret) {
+ return;
+ }
+
+ var err = new Error('Calling PropTypes validators directly is not supported by the `prop-types` package. ' + 'Use PropTypes.checkPropTypes() to call them. ' + 'Read more at http://fb.me/use-check-prop-types');
+ err.name = 'Invariant Violation';
+ throw err;
+ }
+
+ ;
+ shim.isRequired = shim;
+
+ function getShim() {
+ return shim;
+ }
+
+ ;
+ var ReactPropTypes = {
+ array: shim,
+ bool: shim,
+ func: shim,
+ number: shim,
+ object: shim,
+ string: shim,
+ symbol: shim,
+ any: shim,
+ arrayOf: getShim,
+ element: shim,
+ elementType: shim,
+ instanceOf: getShim,
+ node: shim,
+ objectOf: getShim,
+ oneOf: getShim,
+ oneOfType: getShim,
+ shape: getShim,
+ exact: getShim,
+ checkPropTypes: emptyFunctionWithReset,
+ resetWarningCache: emptyFunction
+ };
+ ReactPropTypes.PropTypes = ReactPropTypes;
+ return ReactPropTypes;
+ };
+},67,[17],"node_modules\\prop-types\\factoryWithThrowingShims.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var DeprecatedColorPropType = _$$_REQUIRE(_dependencyMap[0], "DeprecatedColorPropType");
+
+ var ReactPropTypes = _$$_REQUIRE(_dependencyMap[1], "prop-types");
+
+ var DeprecatedShadowPropTypesIOS = {
+ shadowColor: DeprecatedColorPropType,
+ shadowOffset: ReactPropTypes.shape({
+ width: ReactPropTypes.number,
+ height: ReactPropTypes.number
+ }),
+ shadowOpacity: ReactPropTypes.number,
+ shadowRadius: ReactPropTypes.number
+ };
+ module.exports = DeprecatedShadowPropTypesIOS;
+},68,[59,62],"node_modules\\react-native\\Libraries\\DeprecatedPropTypes\\DeprecatedShadowPropTypesIOS.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var ReactPropTypes = _$$_REQUIRE(_dependencyMap[0], "prop-types");
+
+ var deprecatedPropType = _$$_REQUIRE(_dependencyMap[1], "deprecatedPropType");
+
+ var TransformMatrixPropType = function TransformMatrixPropType(props, propName, componentName) {
+ if (props[propName]) {
+ return new Error('The transformMatrix style property is deprecated. ' + 'Use `transform: [{ matrix: ... }]` instead.');
+ }
+ };
+
+ var DecomposedMatrixPropType = function DecomposedMatrixPropType(props, propName, componentName) {
+ if (props[propName]) {
+ return new Error('The decomposedMatrix style property is deprecated. ' + 'Use `transform: [...]` instead.');
+ }
+ };
+
+ var DeprecatedTransformPropTypes = {
+ transform: ReactPropTypes.arrayOf(ReactPropTypes.oneOfType([ReactPropTypes.shape({
+ perspective: ReactPropTypes.number
+ }), ReactPropTypes.shape({
+ rotate: ReactPropTypes.string
+ }), ReactPropTypes.shape({
+ rotateX: ReactPropTypes.string
+ }), ReactPropTypes.shape({
+ rotateY: ReactPropTypes.string
+ }), ReactPropTypes.shape({
+ rotateZ: ReactPropTypes.string
+ }), ReactPropTypes.shape({
+ scale: ReactPropTypes.number
+ }), ReactPropTypes.shape({
+ scaleX: ReactPropTypes.number
+ }), ReactPropTypes.shape({
+ scaleY: ReactPropTypes.number
+ }), ReactPropTypes.shape({
+ translateX: ReactPropTypes.number
+ }), ReactPropTypes.shape({
+ translateY: ReactPropTypes.number
+ }), ReactPropTypes.shape({
+ skewX: ReactPropTypes.string
+ }), ReactPropTypes.shape({
+ skewY: ReactPropTypes.string
+ })])),
+ transformMatrix: TransformMatrixPropType,
+ decomposedMatrix: DecomposedMatrixPropType,
+ scaleX: deprecatedPropType(ReactPropTypes.number, 'Use the transform prop instead.'),
+ scaleY: deprecatedPropType(ReactPropTypes.number, 'Use the transform prop instead.'),
+ rotation: deprecatedPropType(ReactPropTypes.number, 'Use the transform prop instead.'),
+ translateX: deprecatedPropType(ReactPropTypes.number, 'Use the transform prop instead.'),
+ translateY: deprecatedPropType(ReactPropTypes.number, 'Use the transform prop instead.')
+ };
+ module.exports = DeprecatedTransformPropTypes;
+},69,[62,70],"node_modules\\react-native\\Libraries\\DeprecatedPropTypes\\DeprecatedTransformPropTypes.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var UIManager = _$$_REQUIRE(_dependencyMap[0], "UIManager");
+
+ function deprecatedPropType(propType, explanation) {
+ return function validate(props, propName, componentName) {
+ if (!UIManager.getViewManagerConfig(componentName) && props[propName] !== undefined) {
+ console.warn("`" + propName + "` supplied to `" + componentName + "` has been deprecated. " + explanation);
+ }
+
+ for (var _len = arguments.length, rest = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {
+ rest[_key - 3] = arguments[_key];
+ }
+
+ return propType.apply(void 0, [props, propName, componentName].concat(rest));
+ };
+ }
+
+ module.exports = deprecatedPropType;
+},70,[71],"node_modules\\react-native\\Libraries\\Utilities\\deprecatedPropType.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var NativeModules = _$$_REQUIRE(_dependencyMap[0], "NativeModules");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[1], "Platform");
+
+ var UIManagerProperties = _$$_REQUIRE(_dependencyMap[2], "UIManagerProperties");
+
+ var defineLazyObjectProperty = _$$_REQUIRE(_dependencyMap[3], "defineLazyObjectProperty");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[4], "invariant");
+
+ var UIManager = NativeModules.UIManager;
+ var viewManagerConfigs = {};
+ 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.');
+ };
+
+ var triedLoadingConfig = new Set();
+
+ UIManager.getViewManagerConfig = function (viewManagerName) {
+ if (viewManagerConfigs[viewManagerName] === undefined && UIManager.getConstantsForViewManager) {
+ try {
+ viewManagerConfigs[viewManagerName] = UIManager.getConstantsForViewManager(viewManagerName);
+ } catch (e) {
+ viewManagerConfigs[viewManagerName] = null;
+ }
+ }
+
+ var config = viewManagerConfigs[viewManagerName];
+
+ if (config) {
+ return config;
+ }
+
+ if (!global.nativeCallSyncHook) {
+ return config;
+ }
+
+ if (UIManager.lazilyLoadView && !triedLoadingConfig.has(viewManagerName)) {
+ var result = UIManager.lazilyLoadView(viewManagerName);
+ triedLoadingConfig.add(viewManagerName);
+
+ if (result.viewConfig) {
+ UIManager[viewManagerName] = result.viewConfig;
+ lazifyViewManagerConfig(viewManagerName);
+ }
+ }
+
+ return viewManagerConfigs[viewManagerName];
+ };
+
+ function lazifyViewManagerConfig(viewName) {
+ var viewConfig = UIManager[viewName];
+
+ if (viewConfig.Manager) {
+ viewManagerConfigs[viewName] = viewConfig;
+ defineLazyObjectProperty(viewConfig, 'Constants', {
+ get: function get() {
+ var viewManager = NativeModules[viewConfig.Manager];
+ var constants = {};
+ viewManager && Object.keys(viewManager).forEach(function (key) {
+ var value = viewManager[key];
+
+ if (typeof value !== 'function') {
+ constants[key] = value;
+ }
+ });
+ return constants;
+ }
+ });
+ defineLazyObjectProperty(viewConfig, 'Commands', {
+ get: function get() {
+ var viewManager = NativeModules[viewConfig.Manager];
+ var commands = {};
+ var index = 0;
+ viewManager && Object.keys(viewManager).forEach(function (key) {
+ var value = viewManager[key];
+
+ if (typeof value === 'function') {
+ commands[key] = index++;
+ }
+ });
+ return commands;
+ }
+ });
+ }
+ }
+
+ if (Platform.OS === 'ios' || Platform.OS === 'macos') {
+ Object.keys(UIManager).forEach(function (viewName) {
+ lazifyViewManagerConfig(viewName);
+ });
+ } 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);
+ }
+ }
+
+ if (!global.nativeCallSyncHook) {
+ Object.keys(UIManager).forEach(function (viewManagerName) {
+ if (!UIManagerProperties.includes(viewManagerName)) {
+ if (!viewManagerConfigs[viewManagerName]) {
+ viewManagerConfigs[viewManagerName] = UIManager[viewManagerName];
+ }
+
+ defineLazyObjectProperty(UIManager, viewManagerName, {
+ get: function get() {
+ console.warn("Accessing view manager configs directly off UIManager via UIManager['" + viewManagerName + "'] " + ("is no longer supported. Use UIManager.getViewManagerConfig('" + viewManagerName + "') instead."));
+ return UIManager.getViewManagerConfig(viewManagerName);
+ }
+ });
+ }
+ });
+ }
+
+ module.exports = UIManager;
+},71,[36,35,72,51,19],"node_modules\\react-native\\Libraries\\ReactNative\\UIManager.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ module.exports = ['clearJSResponder', 'configureNextLayoutAnimation', 'createView', 'dismissPopupMenu', 'dispatchViewManagerCommand', 'findSubviewIn', 'getConstantsForViewManager', 'getDefaultEventTypes', 'manageChildren', 'measure', 'measureInWindow', 'measureLayout', 'measureLayoutRelativeToParent', 'playTouchSound', 'removeRootView', 'removeSubviewsFromContainerWithID', 'replaceExistingNonRootView', 'sendAccessibilityEvent', 'setChildren', 'setJSResponder', 'setLayoutAnimationEnabledExperimental', 'showPopupMenu', 'updateView', 'viewIsDescendantOf', 'PopupMenu', 'LazyViewManagersEnabled', 'ViewManagerNames', 'StyleConstants', 'AccessibilityEventTypes', 'UIView', '__takeSnapshot', 'takeSnapshot', 'getViewManagerConfig', 'blur', 'focus', 'genericBubblingEventTypes', 'genericDirectEventTypes', 'lazilyLoadView'];
+},72,[],"node_modules\\react-native\\Libraries\\ReactNative\\UIManagerProperties.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var DeprecatedColorPropType = _$$_REQUIRE(_dependencyMap[1], "DeprecatedColorPropType");
+
+ var ReactPropTypes = _$$_REQUIRE(_dependencyMap[2], "prop-types");
+
+ var DeprecatedViewStylePropTypes = _$$_REQUIRE(_dependencyMap[3], "DeprecatedViewStylePropTypes");
+
+ var TextStylePropTypes = _objectSpread({}, DeprecatedViewStylePropTypes, {
+ color: DeprecatedColorPropType,
+ fontFamily: ReactPropTypes.string,
+ fontPath: ReactPropTypes.string,
+ fontSize: ReactPropTypes.number,
+ fontStyle: ReactPropTypes.oneOf(['normal', 'italic']),
+ fontWeight: ReactPropTypes.oneOf(['normal', 'bold', '100', '200', '300', '400', '500', '600', '700', '800', '900']),
+ fontVariant: ReactPropTypes.arrayOf(ReactPropTypes.oneOf(['small-caps', 'oldstyle-nums', 'lining-nums', 'tabular-nums', 'proportional-nums'])),
+ textShadowOffset: ReactPropTypes.shape({
+ width: ReactPropTypes.number,
+ height: ReactPropTypes.number
+ }),
+ textShadowRadius: ReactPropTypes.number,
+ textShadowColor: DeprecatedColorPropType,
+ letterSpacing: ReactPropTypes.number,
+ lineHeight: ReactPropTypes.number,
+ textAlign: ReactPropTypes.oneOf(['auto', 'left', 'right', 'center', 'justify']),
+ textAlignVertical: ReactPropTypes.oneOf(['auto', 'top', 'bottom', 'center']),
+ includeFontPadding: ReactPropTypes.bool,
+ textDecorationLine: ReactPropTypes.oneOf(['none', 'underline', 'line-through', 'underline line-through']),
+ textDecorationStyle: ReactPropTypes.oneOf(['solid', 'double', 'dotted', 'dashed']),
+ textDecorationColor: DeprecatedColorPropType,
+ textTransform: ReactPropTypes.oneOf(['none', 'capitalize', 'uppercase', 'lowercase']),
+ writingDirection: ReactPropTypes.oneOf(['auto', 'ltr', 'rtl'])
+ });
+
+ module.exports = TextStylePropTypes;
+},73,[32,59,62,74],"node_modules\\react-native\\Libraries\\Text\\TextStylePropTypes.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var DeprecatedColorPropType = _$$_REQUIRE(_dependencyMap[1], "DeprecatedColorPropType");
+
+ var DeprecatedLayoutPropTypes = _$$_REQUIRE(_dependencyMap[2], "DeprecatedLayoutPropTypes");
+
+ var ReactPropTypes = _$$_REQUIRE(_dependencyMap[3], "prop-types");
+
+ var DeprecatedShadowPropTypesIOS = _$$_REQUIRE(_dependencyMap[4], "DeprecatedShadowPropTypesIOS");
+
+ var DeprecatedTransformPropTypes = _$$_REQUIRE(_dependencyMap[5], "DeprecatedTransformPropTypes");
+
+ var DeprecatedViewStylePropTypes = _objectSpread({}, DeprecatedLayoutPropTypes, {}, DeprecatedShadowPropTypesIOS, {}, DeprecatedTransformPropTypes, {
+ backfaceVisibility: ReactPropTypes.oneOf(['visible', 'hidden']),
+ backgroundColor: DeprecatedColorPropType,
+ borderColor: DeprecatedColorPropType,
+ borderTopColor: DeprecatedColorPropType,
+ borderRightColor: DeprecatedColorPropType,
+ borderBottomColor: DeprecatedColorPropType,
+ borderLeftColor: DeprecatedColorPropType,
+ borderStartColor: DeprecatedColorPropType,
+ borderEndColor: DeprecatedColorPropType,
+ borderRadius: ReactPropTypes.number,
+ borderTopLeftRadius: ReactPropTypes.number,
+ borderTopRightRadius: ReactPropTypes.number,
+ borderTopStartRadius: ReactPropTypes.number,
+ borderTopEndRadius: ReactPropTypes.number,
+ borderBottomLeftRadius: ReactPropTypes.number,
+ borderBottomRightRadius: ReactPropTypes.number,
+ borderBottomStartRadius: ReactPropTypes.number,
+ borderBottomEndRadius: ReactPropTypes.number,
+ borderStyle: ReactPropTypes.oneOf(['solid', 'dotted', 'dashed']),
+ borderWidth: ReactPropTypes.number,
+ borderTopWidth: ReactPropTypes.number,
+ borderRightWidth: ReactPropTypes.number,
+ borderBottomWidth: ReactPropTypes.number,
+ borderLeftWidth: ReactPropTypes.number,
+ opacity: ReactPropTypes.number,
+ elevation: ReactPropTypes.number
+ });
+
+ module.exports = DeprecatedViewStylePropTypes;
+},74,[32,59,61,62,68,69],"node_modules\\react-native\\Libraries\\DeprecatedPropTypes\\DeprecatedViewStylePropTypes.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var Platform = _$$_REQUIRE(_dependencyMap[0], "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;
+ }
+
+ if (typeof int32Color === 'object' && Platform.OS === 'macos') {
+ if ('dynamic' in int32Color && int32Color.dynamic !== undefined) {
+ var dynamic = int32Color.dynamic;
+ var dynamicColor = {
+ dynamic: {
+ light: processColor(dynamic.light),
+ dark: processColor(dynamic.dark)
+ }
+ };
+ return dynamicColor;
+ }
+
+ return int32Color;
+ }
+
+ if (typeof int32Color !== 'number') {
+ return null;
+ }
+
+ int32Color = (int32Color << 24 | int32Color >>> 8) >>> 0;
+
+ if (Platform.OS === 'android') {
+ int32Color = int32Color | 0x0;
+ }
+
+ return int32Color;
+ }
+
+ module.exports = processColor;
+},75,[35,60],"node_modules\\react-native\\Libraries\\StyleSheet\\processColor.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var MatrixMath = _$$_REQUIRE(_dependencyMap[0], "MatrixMath");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[1], "Platform");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[2], "invariant");
+
+ var stringifySafe = _$$_REQUIRE(_dependencyMap[3], "stringifySafe");
+
+ function processTransform(transform) {
+ if (__DEV__) {
+ _validateTransforms(transform);
+ }
+
+ if (Platform.OS === 'android' || Platform.OS === 'ios' || Platform.OS === 'macos') {
+ 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 by .');
+ 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;
+},76,[77,35,19,50],"node_modules\\react-native\\Libraries\\StyleSheet\\processTransform.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _slicedToArray = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/slicedToArray");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[1], "invariant");
+
+ var MatrixMath = {
+ createIdentityMatrix: function createIdentityMatrix() {
+ return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+ },
+ createCopy: function createCopy(m) {
+ return [m[0], m[1], m[2], m[3], m[4], m[5], m[6], m[7], m[8], m[9], m[10], m[11], m[12], m[13], m[14], m[15]];
+ },
+ createOrthographic: function createOrthographic(left, right, bottom, top, near, far) {
+ var a = 2 / (right - left);
+ var b = 2 / (top - bottom);
+ var c = -2 / (far - near);
+ var tx = -(right + left) / (right - left);
+ var ty = -(top + bottom) / (top - bottom);
+ var tz = -(far + near) / (far - near);
+ return [a, 0, 0, 0, 0, b, 0, 0, 0, 0, c, 0, tx, ty, tz, 1];
+ },
+ createFrustum: function createFrustum(left, right, bottom, top, near, far) {
+ var r_width = 1 / (right - left);
+ var r_height = 1 / (top - bottom);
+ var r_depth = 1 / (near - far);
+ var x = 2 * (near * r_width);
+ var y = 2 * (near * r_height);
+ var A = (right + left) * r_width;
+ var B = (top + bottom) * r_height;
+ var C = (far + near) * r_depth;
+ var D = 2 * (far * near * r_depth);
+ return [x, 0, 0, 0, 0, y, 0, 0, A, B, C, -1, 0, 0, D, 0];
+ },
+ createPerspective: function createPerspective(fovInRadians, aspect, near, far) {
+ var h = 1 / Math.tan(fovInRadians / 2);
+ var r_depth = 1 / (near - far);
+ var C = (far + near) * r_depth;
+ var D = 2 * (far * near * r_depth);
+ return [h / aspect, 0, 0, 0, 0, h, 0, 0, 0, 0, C, -1, 0, 0, D, 0];
+ },
+ createTranslate2d: function createTranslate2d(x, y) {
+ var mat = MatrixMath.createIdentityMatrix();
+ MatrixMath.reuseTranslate2dCommand(mat, x, y);
+ return mat;
+ },
+ reuseTranslate2dCommand: function reuseTranslate2dCommand(matrixCommand, x, y) {
+ matrixCommand[12] = x;
+ matrixCommand[13] = y;
+ },
+ reuseTranslate3dCommand: function reuseTranslate3dCommand(matrixCommand, x, y, z) {
+ matrixCommand[12] = x;
+ matrixCommand[13] = y;
+ matrixCommand[14] = z;
+ },
+ createScale: function createScale(factor) {
+ var mat = MatrixMath.createIdentityMatrix();
+ MatrixMath.reuseScaleCommand(mat, factor);
+ return mat;
+ },
+ reuseScaleCommand: function reuseScaleCommand(matrixCommand, factor) {
+ matrixCommand[0] = factor;
+ matrixCommand[5] = factor;
+ },
+ reuseScale3dCommand: function reuseScale3dCommand(matrixCommand, x, y, z) {
+ matrixCommand[0] = x;
+ matrixCommand[5] = y;
+ matrixCommand[10] = z;
+ },
+ reusePerspectiveCommand: function reusePerspectiveCommand(matrixCommand, p) {
+ matrixCommand[11] = -1 / p;
+ },
+ reuseScaleXCommand: function reuseScaleXCommand(matrixCommand, factor) {
+ matrixCommand[0] = factor;
+ },
+ reuseScaleYCommand: function reuseScaleYCommand(matrixCommand, factor) {
+ matrixCommand[5] = factor;
+ },
+ reuseScaleZCommand: function reuseScaleZCommand(matrixCommand, factor) {
+ matrixCommand[10] = factor;
+ },
+ reuseRotateXCommand: function reuseRotateXCommand(matrixCommand, radians) {
+ matrixCommand[5] = Math.cos(radians);
+ matrixCommand[6] = Math.sin(radians);
+ matrixCommand[9] = -Math.sin(radians);
+ matrixCommand[10] = Math.cos(radians);
+ },
+ reuseRotateYCommand: function reuseRotateYCommand(matrixCommand, amount) {
+ matrixCommand[0] = Math.cos(amount);
+ matrixCommand[2] = -Math.sin(amount);
+ matrixCommand[8] = Math.sin(amount);
+ matrixCommand[10] = Math.cos(amount);
+ },
+ reuseRotateZCommand: function reuseRotateZCommand(matrixCommand, radians) {
+ matrixCommand[0] = Math.cos(radians);
+ matrixCommand[1] = Math.sin(radians);
+ matrixCommand[4] = -Math.sin(radians);
+ matrixCommand[5] = Math.cos(radians);
+ },
+ createRotateZ: function createRotateZ(radians) {
+ var mat = MatrixMath.createIdentityMatrix();
+ MatrixMath.reuseRotateZCommand(mat, radians);
+ return mat;
+ },
+ reuseSkewXCommand: function reuseSkewXCommand(matrixCommand, radians) {
+ matrixCommand[4] = Math.tan(radians);
+ },
+ reuseSkewYCommand: function reuseSkewYCommand(matrixCommand, radians) {
+ matrixCommand[1] = Math.tan(radians);
+ },
+ multiplyInto: function multiplyInto(out, a, b) {
+ var a00 = a[0],
+ a01 = a[1],
+ a02 = a[2],
+ a03 = a[3],
+ a10 = a[4],
+ a11 = a[5],
+ a12 = a[6],
+ a13 = a[7],
+ a20 = a[8],
+ a21 = a[9],
+ a22 = a[10],
+ a23 = a[11],
+ a30 = a[12],
+ a31 = a[13],
+ a32 = a[14],
+ a33 = a[15];
+ var b0 = b[0],
+ b1 = b[1],
+ b2 = b[2],
+ b3 = b[3];
+ out[0] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+ out[1] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+ out[2] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+ out[3] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+ b0 = b[4];
+ b1 = b[5];
+ b2 = b[6];
+ b3 = b[7];
+ out[4] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+ out[5] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+ out[6] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+ out[7] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+ b0 = b[8];
+ b1 = b[9];
+ b2 = b[10];
+ b3 = b[11];
+ out[8] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+ out[9] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+ out[10] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+ out[11] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+ b0 = b[12];
+ b1 = b[13];
+ b2 = b[14];
+ b3 = b[15];
+ out[12] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+ out[13] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+ out[14] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+ out[15] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+ },
+ determinant: function determinant(matrix) {
+ var _matrix = _slicedToArray(matrix, 16),
+ m00 = _matrix[0],
+ m01 = _matrix[1],
+ m02 = _matrix[2],
+ m03 = _matrix[3],
+ m10 = _matrix[4],
+ m11 = _matrix[5],
+ m12 = _matrix[6],
+ m13 = _matrix[7],
+ m20 = _matrix[8],
+ m21 = _matrix[9],
+ m22 = _matrix[10],
+ m23 = _matrix[11],
+ m30 = _matrix[12],
+ m31 = _matrix[13],
+ m32 = _matrix[14],
+ m33 = _matrix[15];
+
+ return m03 * m12 * m21 * m30 - m02 * m13 * m21 * m30 - m03 * m11 * m22 * m30 + m01 * m13 * m22 * m30 + m02 * m11 * m23 * m30 - m01 * m12 * m23 * m30 - m03 * m12 * m20 * m31 + m02 * m13 * m20 * m31 + m03 * m10 * m22 * m31 - m00 * m13 * m22 * m31 - m02 * m10 * m23 * m31 + m00 * m12 * m23 * m31 + m03 * m11 * m20 * m32 - m01 * m13 * m20 * m32 - m03 * m10 * m21 * m32 + m00 * m13 * m21 * m32 + m01 * m10 * m23 * m32 - m00 * m11 * m23 * m32 - m02 * m11 * m20 * m33 + m01 * m12 * m20 * m33 + m02 * m10 * m21 * m33 - m00 * m12 * m21 * m33 - m01 * m10 * m22 * m33 + m00 * m11 * m22 * m33;
+ },
+ inverse: function inverse(matrix) {
+ var det = MatrixMath.determinant(matrix);
+
+ if (!det) {
+ return matrix;
+ }
+
+ var _matrix2 = _slicedToArray(matrix, 16),
+ m00 = _matrix2[0],
+ m01 = _matrix2[1],
+ m02 = _matrix2[2],
+ m03 = _matrix2[3],
+ m10 = _matrix2[4],
+ m11 = _matrix2[5],
+ m12 = _matrix2[6],
+ m13 = _matrix2[7],
+ m20 = _matrix2[8],
+ m21 = _matrix2[9],
+ m22 = _matrix2[10],
+ m23 = _matrix2[11],
+ m30 = _matrix2[12],
+ m31 = _matrix2[13],
+ m32 = _matrix2[14],
+ m33 = _matrix2[15];
+
+ return [(m12 * m23 * m31 - m13 * m22 * m31 + m13 * m21 * m32 - m11 * m23 * m32 - m12 * m21 * m33 + m11 * m22 * m33) / det, (m03 * m22 * m31 - m02 * m23 * m31 - m03 * m21 * m32 + m01 * m23 * m32 + m02 * m21 * m33 - m01 * m22 * m33) / det, (m02 * m13 * m31 - m03 * m12 * m31 + m03 * m11 * m32 - m01 * m13 * m32 - m02 * m11 * m33 + m01 * m12 * m33) / det, (m03 * m12 * m21 - m02 * m13 * m21 - m03 * m11 * m22 + m01 * m13 * m22 + m02 * m11 * m23 - m01 * m12 * m23) / det, (m13 * m22 * m30 - m12 * m23 * m30 - m13 * m20 * m32 + m10 * m23 * m32 + m12 * m20 * m33 - m10 * m22 * m33) / det, (m02 * m23 * m30 - m03 * m22 * m30 + m03 * m20 * m32 - m00 * m23 * m32 - m02 * m20 * m33 + m00 * m22 * m33) / det, (m03 * m12 * m30 - m02 * m13 * m30 - m03 * m10 * m32 + m00 * m13 * m32 + m02 * m10 * m33 - m00 * m12 * m33) / det, (m02 * m13 * m20 - m03 * m12 * m20 + m03 * m10 * m22 - m00 * m13 * m22 - m02 * m10 * m23 + m00 * m12 * m23) / det, (m11 * m23 * m30 - m13 * m21 * m30 + m13 * m20 * m31 - m10 * m23 * m31 - m11 * m20 * m33 + m10 * m21 * m33) / det, (m03 * m21 * m30 - m01 * m23 * m30 - m03 * m20 * m31 + m00 * m23 * m31 + m01 * m20 * m33 - m00 * m21 * m33) / det, (m01 * m13 * m30 - m03 * m11 * m30 + m03 * m10 * m31 - m00 * m13 * m31 - m01 * m10 * m33 + m00 * m11 * m33) / det, (m03 * m11 * m20 - m01 * m13 * m20 - m03 * m10 * m21 + m00 * m13 * m21 + m01 * m10 * m23 - m00 * m11 * m23) / det, (m12 * m21 * m30 - m11 * m22 * m30 - m12 * m20 * m31 + m10 * m22 * m31 + m11 * m20 * m32 - m10 * m21 * m32) / det, (m01 * m22 * m30 - m02 * m21 * m30 + m02 * m20 * m31 - m00 * m22 * m31 - m01 * m20 * m32 + m00 * m21 * m32) / det, (m02 * m11 * m30 - m01 * m12 * m30 - m02 * m10 * m31 + m00 * m12 * m31 + m01 * m10 * m32 - m00 * m11 * m32) / det, (m01 * m12 * m20 - m02 * m11 * m20 + m02 * m10 * m21 - m00 * m12 * m21 - m01 * m10 * m22 + m00 * m11 * m22) / det];
+ },
+ transpose: function transpose(m) {
+ return [m[0], m[4], m[8], m[12], m[1], m[5], m[9], m[13], m[2], m[6], m[10], m[14], m[3], m[7], m[11], m[15]];
+ },
+ multiplyVectorByMatrix: function multiplyVectorByMatrix(v, m) {
+ var _v = _slicedToArray(v, 4),
+ vx = _v[0],
+ vy = _v[1],
+ vz = _v[2],
+ vw = _v[3];
+
+ return [vx * m[0] + vy * m[4] + vz * m[8] + vw * m[12], vx * m[1] + vy * m[5] + vz * m[9] + vw * m[13], vx * m[2] + vy * m[6] + vz * m[10] + vw * m[14], vx * m[3] + vy * m[7] + vz * m[11] + vw * m[15]];
+ },
+ v3Length: function v3Length(a) {
+ return Math.sqrt(a[0] * a[0] + a[1] * a[1] + a[2] * a[2]);
+ },
+ v3Normalize: function v3Normalize(vector, v3Length) {
+ var im = 1 / (v3Length || MatrixMath.v3Length(vector));
+ return [vector[0] * im, vector[1] * im, vector[2] * im];
+ },
+ v3Dot: function v3Dot(a, b) {
+ return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+ },
+ v3Combine: function v3Combine(a, b, aScale, bScale) {
+ return [aScale * a[0] + bScale * b[0], aScale * a[1] + bScale * b[1], aScale * a[2] + bScale * b[2]];
+ },
+ v3Cross: function v3Cross(a, b) {
+ return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+ },
+ quaternionToDegreesXYZ: function quaternionToDegreesXYZ(q, matrix, row) {
+ var _q = _slicedToArray(q, 4),
+ qx = _q[0],
+ qy = _q[1],
+ qz = _q[2],
+ qw = _q[3];
+
+ var qw2 = qw * qw;
+ var qx2 = qx * qx;
+ var qy2 = qy * qy;
+ var qz2 = qz * qz;
+ var test = qx * qy + qz * qw;
+ var unit = qw2 + qx2 + qy2 + qz2;
+ var conv = 180 / Math.PI;
+
+ if (test > 0.49999 * unit) {
+ return [0, 2 * Math.atan2(qx, qw) * conv, 90];
+ }
+
+ if (test < -0.49999 * unit) {
+ return [0, -2 * Math.atan2(qx, qw) * conv, -90];
+ }
+
+ return [MatrixMath.roundTo3Places(Math.atan2(2 * qx * qw - 2 * qy * qz, 1 - 2 * qx2 - 2 * qz2) * conv), MatrixMath.roundTo3Places(Math.atan2(2 * qy * qw - 2 * qx * qz, 1 - 2 * qy2 - 2 * qz2) * conv), MatrixMath.roundTo3Places(Math.asin(2 * qx * qy + 2 * qz * qw) * conv)];
+ },
+ roundTo3Places: function roundTo3Places(n) {
+ var arr = n.toString().split('e');
+ return Math.round(arr[0] + 'e' + (arr[1] ? +arr[1] - 3 : 3)) * 0.001;
+ },
+ decomposeMatrix: function decomposeMatrix(transformMatrix) {
+ invariant(transformMatrix.length === 16, 'Matrix decomposition needs a list of 3d matrix values, received %s', transformMatrix);
+ var perspective = [];
+ var quaternion = [];
+ var scale = [];
+ var skew = [];
+ var translation = [];
+
+ if (!transformMatrix[15]) {
+ return;
+ }
+
+ var matrix = [];
+ var perspectiveMatrix = [];
+
+ for (var i = 0; i < 4; i++) {
+ matrix.push([]);
+
+ for (var j = 0; j < 4; j++) {
+ var value = transformMatrix[i * 4 + j] / transformMatrix[15];
+ matrix[i].push(value);
+ perspectiveMatrix.push(j === 3 ? 0 : value);
+ }
+ }
+
+ perspectiveMatrix[15] = 1;
+
+ if (!MatrixMath.determinant(perspectiveMatrix)) {
+ return;
+ }
+
+ if (matrix[0][3] !== 0 || matrix[1][3] !== 0 || matrix[2][3] !== 0) {
+ var rightHandSide = [matrix[0][3], matrix[1][3], matrix[2][3], matrix[3][3]];
+ var inversePerspectiveMatrix = MatrixMath.inverse(perspectiveMatrix);
+ var transposedInversePerspectiveMatrix = MatrixMath.transpose(inversePerspectiveMatrix);
+ perspective = MatrixMath.multiplyVectorByMatrix(rightHandSide, transposedInversePerspectiveMatrix);
+ } else {
+ perspective[0] = perspective[1] = perspective[2] = 0;
+ perspective[3] = 1;
+ }
+
+ for (var _i = 0; _i < 3; _i++) {
+ translation[_i] = matrix[3][_i];
+ }
+
+ var row = [];
+
+ for (var _i2 = 0; _i2 < 3; _i2++) {
+ row[_i2] = [matrix[_i2][0], matrix[_i2][1], matrix[_i2][2]];
+ }
+
+ scale[0] = MatrixMath.v3Length(row[0]);
+ row[0] = MatrixMath.v3Normalize(row[0], scale[0]);
+ skew[0] = MatrixMath.v3Dot(row[0], row[1]);
+ row[1] = MatrixMath.v3Combine(row[1], row[0], 1.0, -skew[0]);
+ skew[0] = MatrixMath.v3Dot(row[0], row[1]);
+ row[1] = MatrixMath.v3Combine(row[1], row[0], 1.0, -skew[0]);
+ scale[1] = MatrixMath.v3Length(row[1]);
+ row[1] = MatrixMath.v3Normalize(row[1], scale[1]);
+ skew[0] /= scale[1];
+ skew[1] = MatrixMath.v3Dot(row[0], row[2]);
+ row[2] = MatrixMath.v3Combine(row[2], row[0], 1.0, -skew[1]);
+ skew[2] = MatrixMath.v3Dot(row[1], row[2]);
+ row[2] = MatrixMath.v3Combine(row[2], row[1], 1.0, -skew[2]);
+ scale[2] = MatrixMath.v3Length(row[2]);
+ row[2] = MatrixMath.v3Normalize(row[2], scale[2]);
+ skew[1] /= scale[2];
+ skew[2] /= scale[2];
+ var pdum3 = MatrixMath.v3Cross(row[1], row[2]);
+
+ if (MatrixMath.v3Dot(row[0], pdum3) < 0) {
+ for (var _i3 = 0; _i3 < 3; _i3++) {
+ scale[_i3] *= -1;
+ row[_i3][0] *= -1;
+ row[_i3][1] *= -1;
+ row[_i3][2] *= -1;
+ }
+ }
+
+ quaternion[0] = 0.5 * Math.sqrt(Math.max(1 + row[0][0] - row[1][1] - row[2][2], 0));
+ quaternion[1] = 0.5 * Math.sqrt(Math.max(1 - row[0][0] + row[1][1] - row[2][2], 0));
+ quaternion[2] = 0.5 * Math.sqrt(Math.max(1 - row[0][0] - row[1][1] + row[2][2], 0));
+ quaternion[3] = 0.5 * Math.sqrt(Math.max(1 + row[0][0] + row[1][1] + row[2][2], 0));
+
+ if (row[2][1] > row[1][2]) {
+ quaternion[0] = -quaternion[0];
+ }
+
+ if (row[0][2] > row[2][0]) {
+ quaternion[1] = -quaternion[1];
+ }
+
+ if (row[1][0] > row[0][1]) {
+ quaternion[2] = -quaternion[2];
+ }
+
+ var rotationDegrees;
+
+ if (quaternion[0] < 0.001 && quaternion[0] >= 0 && quaternion[1] < 0.001 && quaternion[1] >= 0) {
+ rotationDegrees = [0, 0, MatrixMath.roundTo3Places(Math.atan2(row[0][1], row[0][0]) * 180 / Math.PI)];
+ } else {
+ rotationDegrees = MatrixMath.quaternionToDegreesXYZ(quaternion, matrix, row);
+ }
+
+ return {
+ rotationDegrees: rotationDegrees,
+ perspective: perspective,
+ quaternion: quaternion,
+ scale: scale,
+ skew: skew,
+ translation: translation,
+ rotate: rotationDegrees[2],
+ rotateX: rotationDegrees[0],
+ rotateY: rotationDegrees[1],
+ scaleX: scale[0],
+ scaleY: scale[1],
+ translateX: translation[0],
+ translateY: translation[1]
+ };
+ }
+ };
+ module.exports = MatrixMath;
+},77,[37,19],"node_modules\\react-native\\Libraries\\Utilities\\MatrixMath.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var dummySize = {
+ width: undefined,
+ height: undefined
+ };
+
+ var sizesDiffer = function sizesDiffer(one, two) {
+ one = one || dummySize;
+ two = two || dummySize;
+ return one !== two && (one.width !== two.width || one.height !== two.height);
+ };
+
+ module.exports = sizesDiffer;
+},78,[],"node_modules\\react-native\\Libraries\\Utilities\\differ\\sizesDiffer.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var DeprecatedImageStylePropTypes = _$$_REQUIRE(_dependencyMap[2], "DeprecatedImageStylePropTypes");
+
+ var TextStylePropTypes = _$$_REQUIRE(_dependencyMap[3], "TextStylePropTypes");
+
+ var DeprecatedViewStylePropTypes = _$$_REQUIRE(_dependencyMap[4], "DeprecatedViewStylePropTypes");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[5], "invariant");
+
+ var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';
+
+ var StyleSheetValidation = function () {
+ function StyleSheetValidation() {
+ _classCallCheck(this, StyleSheetValidation);
+ }
+
+ _createClass(StyleSheetValidation, null, [{
+ key: "validateStyleProp",
+ value: function validateStyleProp(prop, style, caller) {
+ if (!__DEV__ || global.__RCTProfileIsProfiling) {
+ return;
+ }
+
+ if (allStylePropTypes[prop] === undefined) {
+ var message1 = '"' + prop + '" is not a valid style property.';
+ var message2 = '\nValid style props: ' + JSON.stringify(Object.keys(allStylePropTypes).sort(), null, ' ');
+ styleError(message1, style, caller, message2);
+ }
+
+ var error = allStylePropTypes[prop](style, prop, caller, 'prop', null, ReactPropTypesSecret);
+
+ if (error) {
+ styleError(error.message, style, caller);
+ }
+ }
+ }, {
+ key: "validateStyle",
+ value: function validateStyle(name, styles) {
+ if (!__DEV__ || global.__RCTProfileIsProfiling) {
+ return;
+ }
+
+ for (var prop in styles[name]) {
+ StyleSheetValidation.validateStyleProp(prop, styles[name], 'StyleSheet ' + name);
+ }
+ }
+ }, {
+ key: "addValidStylePropTypes",
+ value: function addValidStylePropTypes(stylePropTypes) {
+ if (!__DEV__ || global.__RCTProfileIsProfiling) {
+ return;
+ }
+
+ for (var key in stylePropTypes) {
+ allStylePropTypes[key] = stylePropTypes[key];
+ }
+ }
+ }]);
+
+ return StyleSheetValidation;
+ }();
+
+ var styleError = function styleError(message1, style, caller, message2) {
+ invariant(false, message1 + '\n' + (caller || '<>') + ': ' + JSON.stringify(style, null, ' ') + (message2 || ''));
+ };
+
+ var allStylePropTypes = {};
+
+ if (__DEV__ && !global.__RCTProfileIsProfiling) {
+ StyleSheetValidation.addValidStylePropTypes(DeprecatedImageStylePropTypes);
+ StyleSheetValidation.addValidStylePropTypes(TextStylePropTypes);
+ StyleSheetValidation.addValidStylePropTypes(DeprecatedViewStylePropTypes);
+ }
+
+ module.exports = StyleSheetValidation;
+},79,[3,4,58,73,74,19],"node_modules\\react-native\\Libraries\\StyleSheet\\StyleSheetValidation.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ function flattenStyle(style) {
+ if (style === null || typeof style !== 'object') {
+ return undefined;
+ }
+
+ if (!Array.isArray(style)) {
+ return style;
+ }
+
+ var result = {};
+
+ for (var i = 0, styleLength = style.length; i < styleLength; ++i) {
+ var computedStyle = flattenStyle(style[i]);
+
+ if (computedStyle) {
+ for (var key in computedStyle) {
+ result[key] = computedStyle[key];
+ }
+ }
+ }
+
+ return result;
+ }
+
+ module.exports = flattenStyle;
+},80,[],"node_modules\\react-native\\Libraries\\StyleSheet\\flattenStyle.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Components\\View\\View.js";
+
+ var React = _$$_REQUIRE(_dependencyMap[1], "React");
+
+ var TextAncestor = _$$_REQUIRE(_dependencyMap[2], "TextAncestor");
+
+ var ViewNativeComponent = _$$_REQUIRE(_dependencyMap[3], "ViewNativeComponent");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[4], "invariant");
+
+ var ViewToExport = ViewNativeComponent;
+
+ if (__DEV__) {
+ if (!global.__RCTProfileIsProfiling) {
+ var View = function View(props, forwardedRef) {
+ return React.createElement(TextAncestor.Consumer, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 39
+ }
+ }, function (hasTextAncestor) {
+ invariant(!hasTextAncestor, 'Nesting of within is not currently supported.');
+ return React.createElement(ViewNativeComponent, _extends({}, props, {
+ ref: forwardedRef,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 45
+ }
+ }));
+ });
+ };
+
+ ViewToExport = React.forwardRef(View);
+ ViewToExport.displayName = 'View';
+ }
+ }
+
+ module.exports = ViewToExport;
+},81,[14,52,82,83,19],"node_modules\\react-native\\Libraries\\Components\\View\\View.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var React = _$$_REQUIRE(_dependencyMap[0], "React");
+
+ module.exports = React.createContext(false);
+},82,[52],"node_modules\\react-native\\Libraries\\Text\\TextAncestor.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var ReactNative = _$$_REQUIRE(_dependencyMap[0], "ReactNative");
+
+ var requireNativeComponent = _$$_REQUIRE(_dependencyMap[1], "requireNativeComponent");
+
+ var NativeViewComponent = requireNativeComponent('RCTView');
+ module.exports = NativeViewComponent;
+},83,[84,184],"node_modules\\react-native\\Libraries\\Components\\View\\ViewNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var ReactNative;
+
+ if (__DEV__) {
+ ReactNative = _$$_REQUIRE(_dependencyMap[0], "ReactNativeRenderer-dev");
+ } else {
+ ReactNative = _$$_REQUIRE(_dependencyMap[1], "ReactNativeRenderer-prod");
+ }
+
+ module.exports = ReactNative;
+},84,[85,183],"node_modules\\react-native\\Libraries\\Renderer\\shims\\ReactNative.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ if (__DEV__) {
+ (function () {
+ "use strict";
+
+ _$$_REQUIRE(_dependencyMap[1], "InitializeCore");
+
+ var ReactNativeViewConfigRegistry = _$$_REQUIRE(_dependencyMap[2], "ReactNativeViewConfigRegistry");
+
+ var UIManager = _$$_REQUIRE(_dependencyMap[3], "UIManager");
+
+ var RCTEventEmitter = _$$_REQUIRE(_dependencyMap[4], "RCTEventEmitter");
+
+ var React = _$$_REQUIRE(_dependencyMap[5], "react");
+
+ var deepFreezeAndThrowOnMutationInDev = _$$_REQUIRE(_dependencyMap[6], "deepFreezeAndThrowOnMutationInDev");
+
+ var deepDiffer = _$$_REQUIRE(_dependencyMap[7], "deepDiffer");
+
+ var flattenStyle = _$$_REQUIRE(_dependencyMap[8], "flattenStyle");
+
+ var TextInputState = _$$_REQUIRE(_dependencyMap[9], "TextInputState");
+
+ var checkPropTypes = _$$_REQUIRE(_dependencyMap[10], "prop-types/checkPropTypes");
+
+ var tracing = _$$_REQUIRE(_dependencyMap[11], "scheduler/tracing");
+
+ var scheduler = _$$_REQUIRE(_dependencyMap[12], "scheduler");
+
+ var ExceptionsManager = _$$_REQUIRE(_dependencyMap[13], "ExceptionsManager");
+
+ var validateFormat = function validateFormat() {};
+
+ {
+ 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 = void 0;
+
+ 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;
+ }
+ }
+
+ var invokeGuardedCallbackImpl = function invokeGuardedCallbackImpl(name, func, context, a, b, c, d, e, f) {
+ var funcArgs = Array.prototype.slice.call(arguments, 3);
+
+ try {
+ func.apply(context, funcArgs);
+ } catch (error) {
+ this.onError(error);
+ }
+ };
+
+ {
+ if (typeof window !== "undefined" && typeof window.dispatchEvent === "function" && typeof document !== "undefined" && typeof document.createEvent === "function") {
+ var fakeNode = document.createElement("react");
+
+ var invokeGuardedCallbackDev = function invokeGuardedCallbackDev(name, func, context, a, b, c, d, e, f) {
+ 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 windowEvent = window.event;
+ var windowEventDescriptor = Object.getOwnPropertyDescriptor(window, "event");
+ var funcArgs = Array.prototype.slice.call(arguments, 3);
+
+ function callCallback() {
+ fakeNode.removeEventListener(evtType, callCallback, false);
+
+ if (typeof window.event !== "undefined" && window.hasOwnProperty("event")) {
+ window.event = windowEvent;
+ }
+
+ func.apply(context, funcArgs);
+ didError = false;
+ }
+
+ var error = void 0;
+ var didSetError = false;
+ var isCrossOriginError = false;
+
+ function handleWindowError(event) {
+ error = event.error;
+ didSetError = true;
+
+ if (error === null && event.colno === 0 && event.lineno === 0) {
+ isCrossOriginError = true;
+ }
+
+ if (event.defaultPrevented) {
+ if (error != null && typeof error === "object") {
+ try {
+ error._suppressLogging = true;
+ } catch (inner) {}
+ }
+ }
+ }
+
+ var evtType = "react-" + (name ? name : "invokeguardedcallback");
+ window.addEventListener("error", handleWindowError);
+ fakeNode.addEventListener(evtType, callCallback, false);
+ evt.initEvent(evtType, false, false);
+ fakeNode.dispatchEvent(evt);
+
+ if (windowEventDescriptor) {
+ Object.defineProperty(window, "event", windowEventDescriptor);
+ }
+
+ if (didError) {
+ if (!didSetError) {
+ error = new Error("An error was thrown inside one of your components, but React " + "doesn't know what it was. This is likely due to browser " + 'flakiness. React does its best to preserve the "Pause on ' + 'exceptions" behavior of the DevTools, which requires some ' + "DEV-mode only tricks. It's possible that these don't work in " + "your browser. Try triggering the error in production mode, " + "or switching to a modern browser. If you suspect that this is " + "actually an issue with React, please file an issue.");
+ } else if (isCrossOriginError) {
+ error = new Error("A cross-origin error was thrown. React doesn't have access to " + "the actual error object in development. " + "See https://fb.me/react-crossorigin-error for more information.");
+ }
+
+ this.onError(error);
+ }
+
+ window.removeEventListener("error", handleWindowError);
+ };
+
+ invokeGuardedCallbackImpl = invokeGuardedCallbackDev;
+ }
+ }
+ var invokeGuardedCallbackImpl$1 = invokeGuardedCallbackImpl;
+ var hasError = false;
+ var caughtError = null;
+ var hasRethrowError = false;
+ var rethrowError = null;
+ var reporter = {
+ onError: function onError(error) {
+ hasError = true;
+ caughtError = error;
+ }
+ };
+
+ function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
+ hasError = false;
+ caughtError = null;
+ invokeGuardedCallbackImpl$1.apply(reporter, arguments);
+ }
+
+ function invokeGuardedCallbackAndCatchFirstError(name, func, context, a, b, c, d, e, f) {
+ invokeGuardedCallback.apply(this, arguments);
+
+ if (hasError) {
+ var error = clearCaughtError();
+
+ if (!hasRethrowError) {
+ hasRethrowError = true;
+ rethrowError = error;
+ }
+ }
+ }
+
+ function rethrowCaughtError() {
+ if (hasRethrowError) {
+ var error = rethrowError;
+ hasRethrowError = false;
+ rethrowError = null;
+ throw error;
+ }
+ }
+
+ function hasCaughtError() {
+ return hasError;
+ }
+
+ function clearCaughtError() {
+ if (hasError) {
+ var error = caughtError;
+ hasError = false;
+ caughtError = null;
+ return error;
+ } else {
+ 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 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 warningWithoutStack = function warningWithoutStack() {};
+
+ {
+ warningWithoutStack = function warningWithoutStack(condition, format) {
+ for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+ args[_key - 2] = arguments[_key];
+ }
+
+ if (format === undefined) {
+ throw new Error("`warningWithoutStack(condition, format, ...args)` requires a warning " + "message argument");
+ }
+
+ if (args.length > 8) {
+ throw new Error("warningWithoutStack() currently supports at most 8 arguments.");
+ }
+
+ if (condition) {
+ return;
+ }
+
+ if (typeof console !== "undefined") {
+ var argsWithFormat = args.map(function (item) {
+ return "" + item;
+ });
+ argsWithFormat.unshift("Warning: " + format);
+ Function.prototype.apply.call(console.error, console, argsWithFormat);
+ }
+
+ try {
+ var argIndex = 0;
+ var message = "Warning: " + format.replace(/%s/g, function () {
+ return args[argIndex++];
+ });
+ throw new Error(message);
+ } catch (x) {}
+ };
+ }
+ var warningWithoutStack$1 = warningWithoutStack;
+ var getFiberCurrentPropsFromNode = null;
+ var getInstanceFromNode = null;
+ var getNodeFromInstance = null;
+
+ function setComponentTree(getFiberCurrentPropsFromNodeImpl, getInstanceFromNodeImpl, getNodeFromInstanceImpl) {
+ getFiberCurrentPropsFromNode = getFiberCurrentPropsFromNodeImpl;
+ getInstanceFromNode = getInstanceFromNodeImpl;
+ getNodeFromInstance = getNodeFromInstanceImpl;
+ {
+ !(getNodeFromInstance && getInstanceFromNode) ? warningWithoutStack$1(false, "EventPluginUtils.setComponentTree(...): Injected " + "module is missing getNodeFromInstance or getInstanceFromNode.") : void 0;
+ }
+ }
+
+ var validateEventDispatches = void 0;
+ {
+ validateEventDispatches = function validateEventDispatches(event) {
+ var dispatchListeners = event._dispatchListeners;
+ var dispatchInstances = event._dispatchInstances;
+ var listenersIsArr = Array.isArray(dispatchListeners);
+ var listenersLen = listenersIsArr ? dispatchListeners.length : dispatchListeners ? 1 : 0;
+ var instancesIsArr = Array.isArray(dispatchInstances);
+ var instancesLen = instancesIsArr ? dispatchInstances.length : dispatchInstances ? 1 : 0;
+ !(instancesIsArr === listenersIsArr && instancesLen === listenersLen) ? warningWithoutStack$1(false, "EventPluginUtils: Invalid `event`.") : void 0;
+ };
+ }
+
+ function executeDispatch(event, listener, inst) {
+ var type = event.type || "unknown-event";
+ event.currentTarget = getNodeFromInstance(inst);
+ invokeGuardedCallbackAndCatchFirstError(type, listener, undefined, event);
+ event.currentTarget = null;
+ }
+
+ function executeDispatchesInOrder(event) {
+ var dispatchListeners = event._dispatchListeners;
+ var dispatchInstances = event._dispatchInstances;
+ {
+ validateEventDispatches(event);
+ }
+
+ if (Array.isArray(dispatchListeners)) {
+ for (var i = 0; i < dispatchListeners.length; i++) {
+ if (event.isPropagationStopped()) {
+ break;
+ }
+
+ executeDispatch(event, dispatchListeners[i], dispatchInstances[i]);
+ }
+ } else if (dispatchListeners) {
+ executeDispatch(event, dispatchListeners, dispatchInstances);
+ }
+
+ event._dispatchListeners = null;
+ event._dispatchInstances = null;
+ }
+
+ function executeDispatchesInOrderStopAtTrueImpl(event) {
+ var dispatchListeners = event._dispatchListeners;
+ var dispatchInstances = event._dispatchInstances;
+ {
+ validateEventDispatches(event);
+ }
+
+ if (Array.isArray(dispatchListeners)) {
+ for (var i = 0; i < dispatchListeners.length; i++) {
+ if (event.isPropagationStopped()) {
+ break;
+ }
+
+ if (dispatchListeners[i](event, dispatchInstances[i])) {
+ return dispatchInstances[i];
+ }
+ }
+ } else if (dispatchListeners) {
+ if (dispatchListeners(event, dispatchInstances)) {
+ return dispatchInstances;
+ }
+ }
+
+ return null;
+ }
+
+ function executeDispatchesInOrderStopAtTrue(event) {
+ var ret = executeDispatchesInOrderStopAtTrueImpl(event);
+ event._dispatchInstances = null;
+ event._dispatchListeners = null;
+ return ret;
+ }
+
+ function executeDirectDispatch(event) {
+ {
+ validateEventDispatches(event);
+ }
+ var dispatchListener = event._dispatchListeners;
+ var dispatchInstance = event._dispatchInstances;
+ 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) {
+ if (event) {
+ executeDispatchesInOrder(event);
+
+ if (!event.isPersistent()) {
+ event.constructor.release(event);
+ }
+ }
+ };
+
+ var executeDispatchesAndReleaseTopLevel = function executeDispatchesAndReleaseTopLevel(e) {
+ return executeDispatchesAndRelease(e);
+ };
+
+ 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) {
+ if (events !== null) {
+ eventQueue = accumulateInto(eventQueue, events);
+ }
+
+ var processingEventQueue = eventQueue;
+ eventQueue = null;
+
+ if (!processingEventQueue) {
+ return;
+ }
+
+ forEachAccumulated(processingEventQueue, executeDispatchesAndReleaseTopLevel);
+ invariant(!eventQueue, "processEventQueue(): Additional events were enqueued while processing " + "an event queue. Support for this has not yet been implemented.");
+ rethrowCaughtError();
+ }
+
+ function runExtractedEventsInBatch(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+ var events = extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget);
+ runEventsInBatch(events);
+ }
+
+ var FunctionComponent = 0;
+ var ClassComponent = 1;
+ var IndeterminateComponent = 2;
+ var HostRoot = 3;
+ var HostPortal = 4;
+ var HostComponent = 5;
+ var HostText = 6;
+ var Fragment = 7;
+ var Mode = 8;
+ var ContextConsumer = 9;
+ var ContextProvider = 10;
+ var ForwardRef = 11;
+ var Profiler = 12;
+ var SuspenseComponent = 13;
+ var MemoComponent = 14;
+ var SimpleMemoComponent = 15;
+ var LazyComponent = 16;
+ var IncompleteClassComponent = 17;
+ var DehydratedSuspenseComponent = 18;
+
+ function getParent(inst) {
+ do {
+ inst = inst.return;
+ } while (inst && inst.tag !== HostComponent);
+
+ if (inst) {
+ return inst;
+ }
+
+ return null;
+ }
+
+ function getLowestCommonAncestor(instA, instB) {
+ var depthA = 0;
+
+ for (var tempA = instA; tempA; tempA = getParent(tempA)) {
+ depthA++;
+ }
+
+ var depthB = 0;
+
+ for (var tempB = instB; tempB; tempB = getParent(tempB)) {
+ depthB++;
+ }
+
+ while (depthA - depthB > 0) {
+ instA = getParent(instA);
+ depthA--;
+ }
+
+ while (depthB - depthA > 0) {
+ instB = getParent(instB);
+ depthB--;
+ }
+
+ var depth = depthA;
+
+ while (depth--) {
+ if (instA === instB || instA === instB.alternate) {
+ return instA;
+ }
+
+ instA = getParent(instA);
+ instB = getParent(instB);
+ }
+
+ return null;
+ }
+
+ function isAncestor(instA, instB) {
+ while (instB) {
+ if (instA === instB || instA === instB.alternate) {
+ return true;
+ }
+
+ instB = getParent(instB);
+ }
+
+ return false;
+ }
+
+ function getParentInstance(inst) {
+ return getParent(inst);
+ }
+
+ function traverseTwoPhase(inst, fn, arg) {
+ var path = [];
+
+ while (inst) {
+ path.push(inst);
+ inst = getParent(inst);
+ }
+
+ var i = void 0;
+
+ for (i = path.length; i-- > 0;) {
+ fn(path[i], "captured", arg);
+ }
+
+ for (i = 0; i < path.length; i++) {
+ fn(path[i], "bubbled", arg);
+ }
+ }
+
+ function listenerAtPhase(inst, event, propagationPhase) {
+ var registrationName = event.dispatchConfig.phasedRegistrationNames[propagationPhase];
+ return getListener(inst, registrationName);
+ }
+
+ function accumulateDirectionalDispatches(inst, phase, event) {
+ {
+ !inst ? warningWithoutStack$1(false, "Dispatching inst must not be null") : void 0;
+ }
+ var listener = listenerAtPhase(inst, event, phase);
+
+ if (listener) {
+ event._dispatchListeners = accumulateInto(event._dispatchListeners, listener);
+ event._dispatchInstances = accumulateInto(event._dispatchInstances, inst);
+ }
+ }
+
+ function accumulateTwoPhaseDispatchesSingle(event) {
+ if (event && event.dispatchConfig.phasedRegistrationNames) {
+ traverseTwoPhase(event._targetInst, accumulateDirectionalDispatches, event);
+ }
+ }
+
+ function accumulateTwoPhaseDispatchesSingleSkipTarget(event) {
+ if (event && event.dispatchConfig.phasedRegistrationNames) {
+ var targetInst = event._targetInst;
+ var parentInst = targetInst ? getParentInstance(targetInst) : null;
+ traverseTwoPhase(parentInst, accumulateDirectionalDispatches, event);
+ }
+ }
+
+ function accumulateDispatches(inst, ignoredDirection, event) {
+ if (inst && event && event.dispatchConfig.registrationName) {
+ var registrationName = event.dispatchConfig.registrationName;
+ var listener = getListener(inst, registrationName);
+
+ if (listener) {
+ event._dispatchListeners = accumulateInto(event._dispatchListeners, listener);
+ event._dispatchInstances = accumulateInto(event._dispatchInstances, inst);
+ }
+ }
+ }
+
+ function accumulateDirectDispatchesSingle(event) {
+ if (event && event.dispatchConfig.registrationName) {
+ accumulateDispatches(event._targetInst, null, event);
+ }
+ }
+
+ function accumulateTwoPhaseDispatches(events) {
+ forEachAccumulated(events, accumulateTwoPhaseDispatchesSingle);
+ }
+
+ function accumulateTwoPhaseDispatchesSkipTarget(events) {
+ forEachAccumulated(events, accumulateTwoPhaseDispatchesSingleSkipTarget);
+ }
+
+ function accumulateDirectDispatches(events) {
+ forEachAccumulated(events, accumulateDirectDispatchesSingle);
+ }
+
+ var EVENT_POOL_SIZE = 10;
+ var EventInterface = {
+ type: null,
+ target: null,
+ currentTarget: function currentTarget() {
+ return null;
+ },
+ eventPhase: null,
+ bubbles: null,
+ cancelable: null,
+ timeStamp: function timeStamp(event) {
+ return event.timeStamp || Date.now();
+ },
+ defaultPrevented: null,
+ isTrusted: null
+ };
+
+ function functionThatReturnsTrue() {
+ return true;
+ }
+
+ function functionThatReturnsFalse() {
+ return false;
+ }
+
+ function SyntheticEvent(dispatchConfig, targetInst, nativeEvent, nativeEventTarget) {
+ {
+ delete this.nativeEvent;
+ delete this.preventDefault;
+ delete this.stopPropagation;
+ delete this.isDefaultPrevented;
+ delete this.isPropagationStopped;
+ }
+ this.dispatchConfig = dispatchConfig;
+ this._targetInst = targetInst;
+ this.nativeEvent = nativeEvent;
+ var Interface = this.constructor.Interface;
+
+ for (var propName in Interface) {
+ if (!Interface.hasOwnProperty(propName)) {
+ continue;
+ }
+
+ {
+ delete this[propName];
+ }
+ var normalize = Interface[propName];
+
+ if (normalize) {
+ this[propName] = normalize(nativeEvent);
+ } else {
+ if (propName === "target") {
+ this.target = nativeEventTarget;
+ } else {
+ this[propName] = nativeEvent[propName];
+ }
+ }
+ }
+
+ var defaultPrevented = nativeEvent.defaultPrevented != null ? nativeEvent.defaultPrevented : nativeEvent.returnValue === false;
+
+ if (defaultPrevented) {
+ this.isDefaultPrevented = functionThatReturnsTrue;
+ } else {
+ this.isDefaultPrevented = functionThatReturnsFalse;
+ }
+
+ this.isPropagationStopped = functionThatReturnsFalse;
+ return this;
+ }
+
+ _extends(SyntheticEvent.prototype, {
+ preventDefault: function preventDefault() {
+ this.defaultPrevented = true;
+ var event = this.nativeEvent;
+
+ if (!event) {
+ return;
+ }
+
+ if (event.preventDefault) {
+ event.preventDefault();
+ } else if (typeof event.returnValue !== "unknown") {
+ event.returnValue = false;
+ }
+
+ this.isDefaultPrevented = functionThatReturnsTrue;
+ },
+ stopPropagation: function stopPropagation() {
+ var event = this.nativeEvent;
+
+ if (!event) {
+ return;
+ }
+
+ if (event.stopPropagation) {
+ event.stopPropagation();
+ } else if (typeof event.cancelBubble !== "unknown") {
+ event.cancelBubble = true;
+ }
+
+ this.isPropagationStopped = functionThatReturnsTrue;
+ },
+ persist: function persist() {
+ this.isPersistent = functionThatReturnsTrue;
+ },
+ isPersistent: functionThatReturnsFalse,
+ destructor: function destructor() {
+ var Interface = this.constructor.Interface;
+
+ for (var propName in Interface) {
+ {
+ Object.defineProperty(this, propName, getPooledWarningPropertyDefinition(propName, Interface[propName]));
+ }
+ }
+
+ this.dispatchConfig = null;
+ this._targetInst = null;
+ this.nativeEvent = null;
+ this.isDefaultPrevented = functionThatReturnsFalse;
+ this.isPropagationStopped = functionThatReturnsFalse;
+ this._dispatchListeners = null;
+ this._dispatchInstances = null;
+ {
+ Object.defineProperty(this, "nativeEvent", getPooledWarningPropertyDefinition("nativeEvent", null));
+ Object.defineProperty(this, "isDefaultPrevented", getPooledWarningPropertyDefinition("isDefaultPrevented", functionThatReturnsFalse));
+ Object.defineProperty(this, "isPropagationStopped", getPooledWarningPropertyDefinition("isPropagationStopped", functionThatReturnsFalse));
+ Object.defineProperty(this, "preventDefault", getPooledWarningPropertyDefinition("preventDefault", function () {}));
+ Object.defineProperty(this, "stopPropagation", getPooledWarningPropertyDefinition("stopPropagation", function () {}));
+ }
+ }
+ });
+
+ SyntheticEvent.Interface = EventInterface;
+
+ SyntheticEvent.extend = function (Interface) {
+ var Super = this;
+
+ var E = function E() {};
+
+ E.prototype = Super.prototype;
+ var prototype = new E();
+
+ function Class() {
+ return Super.apply(this, arguments);
+ }
+
+ _extends(prototype, Class.prototype);
+
+ Class.prototype = prototype;
+ Class.prototype.constructor = Class;
+ Class.Interface = _extends({}, Super.Interface, Interface);
+ Class.extend = Super.extend;
+ addEventPoolingTo(Class);
+ return Class;
+ };
+
+ addEventPoolingTo(SyntheticEvent);
+
+ function getPooledWarningPropertyDefinition(propName, getVal) {
+ var isFunction = typeof getVal === "function";
+ return {
+ configurable: true,
+ set: set,
+ get: get$$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 ? warningWithoutStack$1(false, "This synthetic event is reused for performance reasons. If you're seeing this, " + "you're %s `%s` on a released/nullified synthetic event. %s. " + "If you must keep the original synthetic event around, use event.persist(). " + "See https://fb.me/react-event-pooling for more information.", action, propName, result) : void 0;
+ }
+ }
+
+ function getPooledEvent(dispatchConfig, targetInst, nativeEvent, nativeInst) {
+ var EventConstructor = this;
+
+ if (EventConstructor.eventPool.length) {
+ var instance = EventConstructor.eventPool.pop();
+ EventConstructor.call(instance, dispatchConfig, targetInst, nativeEvent, nativeInst);
+ return instance;
+ }
+
+ return new EventConstructor(dispatchConfig, targetInst, nativeEvent, nativeInst);
+ }
+
+ function releasePooledEvent(event) {
+ var EventConstructor = this;
+ 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 ResponderSyntheticEvent = SyntheticEvent.extend({
+ touchHistory: function touchHistory(nativeEvent) {
+ return null;
+ }
+ });
+ var TOP_TOUCH_START = "topTouchStart";
+ var TOP_TOUCH_MOVE = "topTouchMove";
+ var TOP_TOUCH_END = "topTouchEnd";
+ var TOP_TOUCH_CANCEL = "topTouchCancel";
+ var TOP_SCROLL = "topScroll";
+ var TOP_SELECTION_CHANGE = "topSelectionChange";
+
+ function isStartish(topLevelType) {
+ return topLevelType === TOP_TOUCH_START;
+ }
+
+ function isMoveish(topLevelType) {
+ return topLevelType === TOP_TOUCH_MOVE;
+ }
+
+ function isEndish(topLevelType) {
+ return topLevelType === TOP_TOUCH_END || topLevelType === TOP_TOUCH_CANCEL;
+ }
+
+ var startDependencies = [TOP_TOUCH_START];
+ var moveDependencies = [TOP_TOUCH_MOVE];
+ var endDependencies = [TOP_TOUCH_CANCEL, TOP_TOUCH_END];
+ var MAX_TOUCH_BANK = 20;
+ var touchBank = [];
+ var touchHistory = {
+ touchBank: touchBank,
+ numberActiveTouches: 0,
+ indexOfSingleActiveTouch: -1,
+ mostRecentTimeStamp: 0
+ };
+
+ function timestampForTouch(touch) {
+ return touch.timeStamp || touch.timestamp;
+ }
+
+ function createTouchRecord(touch) {
+ return {
+ touchActive: true,
+ startPageX: touch.pageX,
+ startPageY: touch.pageY,
+ startTimeStamp: timestampForTouch(touch),
+ currentPageX: touch.pageX,
+ currentPageY: touch.pageY,
+ currentTimeStamp: timestampForTouch(touch),
+ previousPageX: touch.pageX,
+ previousPageY: touch.pageY,
+ previousTimeStamp: timestampForTouch(touch)
+ };
+ }
+
+ function resetTouchRecord(touchRecord, touch) {
+ touchRecord.touchActive = true;
+ touchRecord.startPageX = touch.pageX;
+ touchRecord.startPageY = touch.pageY;
+ touchRecord.startTimeStamp = timestampForTouch(touch);
+ touchRecord.currentPageX = touch.pageX;
+ touchRecord.currentPageY = touch.pageY;
+ touchRecord.currentTimeStamp = timestampForTouch(touch);
+ touchRecord.previousPageX = touch.pageX;
+ touchRecord.previousPageY = touch.pageY;
+ touchRecord.previousTimeStamp = timestampForTouch(touch);
+ }
+
+ function getTouchIdentifier(_ref) {
+ var identifier = _ref.identifier;
+ invariant(identifier != null, "Touch object is missing identifier.");
+ {
+ !(identifier <= MAX_TOUCH_BANK) ? warningWithoutStack$1(false, "Touch identifier %s is greater than maximum supported %s which causes " + "performance issues backfilling array locations for all of the indices.", identifier, MAX_TOUCH_BANK) : void 0;
+ }
+ return identifier;
+ }
+
+ function recordTouchStart(touch) {
+ var identifier = getTouchIdentifier(touch);
+ var touchRecord = touchBank[identifier];
+
+ if (touchRecord) {
+ resetTouchRecord(touchRecord, touch);
+ } else {
+ touchBank[identifier] = createTouchRecord(touch);
+ }
+
+ touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
+ }
+
+ function recordTouchMove(touch) {
+ var touchRecord = touchBank[getTouchIdentifier(touch)];
+
+ if (touchRecord) {
+ touchRecord.touchActive = true;
+ touchRecord.previousPageX = touchRecord.currentPageX;
+ touchRecord.previousPageY = touchRecord.currentPageY;
+ touchRecord.previousTimeStamp = touchRecord.currentTimeStamp;
+ touchRecord.currentPageX = touch.pageX;
+ touchRecord.currentPageY = touch.pageY;
+ touchRecord.currentTimeStamp = timestampForTouch(touch);
+ touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
+ } else {
+ console.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) ? warningWithoutStack$1(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 ReactNativeBridgeEventPlugin = {
+ eventTypes: ReactNativeViewConfigRegistry.eventTypes,
+ extractEvents: function extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+ if (targetInst == null) {
+ return null;
+ }
+
+ var bubbleDispatchConfig = ReactNativeViewConfigRegistry.customBubblingEventTypes[topLevelType];
+ var directDispatchConfig = ReactNativeViewConfigRegistry.customDirectEventTypes[topLevelType];
+ invariant(bubbleDispatchConfig || directDispatchConfig, 'Unsupported top level event type "%s" dispatched', topLevelType);
+ var event = SyntheticEvent.getPooled(bubbleDispatchConfig || directDispatchConfig, targetInst, nativeEvent, nativeEventTarget);
+
+ if (bubbleDispatchConfig) {
+ accumulateTwoPhaseDispatches(event);
+ } else if (directDispatchConfig) {
+ accumulateDirectDispatches(event);
+ } else {
+ return null;
+ }
+
+ return event;
+ }
+ };
+ var ReactNativeEventPluginOrder = ["ResponderEventPlugin", "ReactNativeBridgeEventPlugin"];
+ injection.injectEventPluginOrder(ReactNativeEventPluginOrder);
+ injection.injectEventPluginsByName({
+ ResponderEventPlugin: ResponderEventPlugin,
+ ReactNativeBridgeEventPlugin: ReactNativeBridgeEventPlugin
+ });
+ var instanceCache = {};
+ 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 restoreImpl = null;
+ var restoreTarget = null;
+ var restoreQueue = null;
+
+ function restoreStateOfTarget(target) {
+ var internalInstance = getInstanceFromNode(target);
+
+ if (!internalInstance) {
+ return;
+ }
+
+ invariant(typeof restoreImpl === "function", "setRestoreImplementation() needs to be called to handle a target for controlled " + "events. This error is likely caused by a bug in React. Please file an issue.");
+ var props = getFiberCurrentPropsFromNode(internalInstance.stateNode);
+ restoreImpl(internalInstance.stateNode, internalInstance.type, props);
+ }
+
+ function needsStateRestore() {
+ return restoreTarget !== null || restoreQueue !== null;
+ }
+
+ function restoreStateIfNeeded() {
+ if (!restoreTarget) {
+ return;
+ }
+
+ var target = restoreTarget;
+ var queuedTargets = restoreQueue;
+ restoreTarget = null;
+ restoreQueue = null;
+ restoreStateOfTarget(target);
+
+ if (queuedTargets) {
+ for (var i = 0; i < queuedTargets.length; i++) {
+ restoreStateOfTarget(queuedTargets[i]);
+ }
+ }
+ }
+
+ var _batchedUpdatesImpl = function _batchedUpdatesImpl(fn, bookkeeping) {
+ return fn(bookkeeping);
+ };
+
+ var _flushInteractiveUpdatesImpl = function _flushInteractiveUpdatesImpl() {};
+
+ var isBatching = false;
+
+ function batchedUpdates(fn, bookkeeping) {
+ if (isBatching) {
+ return fn(bookkeeping);
+ }
+
+ isBatching = true;
+
+ try {
+ return _batchedUpdatesImpl(fn, bookkeeping);
+ } finally {
+ isBatching = false;
+ var controlledComponentsHavePendingUpdates = needsStateRestore();
+
+ if (controlledComponentsHavePendingUpdates) {
+ _flushInteractiveUpdatesImpl();
+
+ restoreStateIfNeeded();
+ }
+ }
+ }
+
+ function setBatchingImplementation(batchedUpdatesImpl, interactiveUpdatesImpl, flushInteractiveUpdatesImpl) {
+ _batchedUpdatesImpl = batchedUpdatesImpl;
+ _flushInteractiveUpdatesImpl = flushInteractiveUpdatesImpl;
+ }
+
+ 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) {
+ {
+ warningWithoutStack$1(false, "A view is reporting that a touch occurred on tag zero.");
+ }
+ } else {
+ rootNodeID = target;
+ }
+ }
+
+ _receiveRootNodeIDEvent(rootNodeID, eventTopLevelType, nativeEvent);
+ }
+ }
+
+ var ReactNativeGlobalResponderHandler = {
+ onChange: function onChange(from, to, blockNativeResponder) {
+ if (to !== null) {
+ var tag = to.stateNode._nativeTag;
+ UIManager.setJSResponder(tag, blockNativeResponder);
+ } else {
+ UIManager.clearJSResponder();
+ }
+ }
+ };
+ RCTEventEmitter.register({
+ receiveEvent: receiveEvent,
+ receiveTouches: receiveTouches
+ });
+ setComponentTree(getFiberCurrentPropsFromNode$1, getInstanceFromTag, getTagFromInstance);
+ ResponderEventPlugin.injection.injectGlobalResponderHandler(ReactNativeGlobalResponderHandler);
+
+ function get$1(key) {
+ return key._reactInternalFiber;
+ }
+
+ function set(key, value) {
+ key._reactInternalFiber = value;
+ }
+
+ var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+ if (!ReactSharedInternals.hasOwnProperty("ReactCurrentDispatcher")) {
+ ReactSharedInternals.ReactCurrentDispatcher = {
+ current: null
+ };
+ }
+
+ var hasSymbol = typeof Symbol === "function" && (typeof Symbol === "function" ? Symbol.for : "@@for");
+ var REACT_ELEMENT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.element") : 0xeac7;
+ var REACT_PORTAL_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.portal") : 0xeaca;
+ var REACT_FRAGMENT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.fragment") : 0xeacb;
+ var REACT_STRICT_MODE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.strict_mode") : 0xeacc;
+ var REACT_PROFILER_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.profiler") : 0xead2;
+ var REACT_PROVIDER_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.provider") : 0xeacd;
+ var REACT_CONTEXT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.context") : 0xeace;
+ var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.concurrent_mode") : 0xeacf;
+ var REACT_FORWARD_REF_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.forward_ref") : 0xead0;
+ var REACT_SUSPENSE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.suspense") : 0xead1;
+ var REACT_MEMO_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.memo") : 0xead3;
+ var REACT_LAZY_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.lazy") : 0xead4;
+ var MAYBE_ITERATOR_SYMBOL = typeof Symbol === "function" && (typeof Symbol === "function" ? Symbol.iterator : "@@iterator");
+ var FAUX_ITERATOR_SYMBOL = "@@iterator";
+
+ function getIteratorFn(maybeIterable) {
+ if (maybeIterable === null || typeof maybeIterable !== "object") {
+ return null;
+ }
+
+ var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+ if (typeof maybeIterator === "function") {
+ return maybeIterator;
+ }
+
+ return null;
+ }
+
+ var Pending = 0;
+ var Resolved = 1;
+ var Rejected = 2;
+
+ function refineResolvedLazyComponent(lazyComponent) {
+ return lazyComponent._status === Resolved ? lazyComponent._result : null;
+ }
+
+ function getWrappedName(outerType, innerType, wrapperName) {
+ var functionName = innerType.displayName || innerType.name || "";
+ return outerType.displayName || (functionName !== "" ? wrapperName + "(" + functionName + ")" : wrapperName);
+ }
+
+ function getComponentName(type) {
+ if (type == null) {
+ return null;
+ }
+
+ {
+ if (typeof type.tag === "number") {
+ warningWithoutStack$1(false, "Received an unexpected object in getComponentName(). " + "This is likely a bug in React. Please file an issue.");
+ }
+ }
+
+ if (typeof type === "function") {
+ return type.displayName || type.name || null;
+ }
+
+ if (typeof type === "string") {
+ return type;
+ }
+
+ switch (type) {
+ case REACT_CONCURRENT_MODE_TYPE:
+ return "ConcurrentMode";
+
+ case REACT_FRAGMENT_TYPE:
+ return "Fragment";
+
+ case REACT_PORTAL_TYPE:
+ return "Portal";
+
+ case REACT_PROFILER_TYPE:
+ return "Profiler";
+
+ case REACT_STRICT_MODE_TYPE:
+ return "StrictMode";
+
+ case REACT_SUSPENSE_TYPE:
+ return "Suspense";
+ }
+
+ if (typeof type === "object") {
+ switch (type.$$typeof) {
+ case REACT_CONTEXT_TYPE:
+ return "Context.Consumer";
+
+ case REACT_PROVIDER_TYPE:
+ return "Context.Provider";
+
+ case REACT_FORWARD_REF_TYPE:
+ return getWrappedName(type, type.render, "ForwardRef");
+
+ case REACT_MEMO_TYPE:
+ return getComponentName(type.type);
+
+ case REACT_LAZY_TYPE:
+ {
+ var thenable = type;
+ var resolvedThenable = refineResolvedLazyComponent(thenable);
+
+ if (resolvedThenable) {
+ return getComponentName(resolvedThenable);
+ }
+ }
+ }
+ }
+
+ return null;
+ }
+
+ var NoEffect = 0;
+ var PerformedWork = 1;
+ var Placement = 2;
+ var Update = 4;
+ var PlacementAndUpdate = 6;
+ var Deletion = 8;
+ var ContentReset = 16;
+ var Callback = 32;
+ var DidCapture = 64;
+ var Ref = 128;
+ var Snapshot = 256;
+ var Passive = 512;
+ var LifecycleEffectMask = 932;
+ var HostEffectMask = 1023;
+ var Incomplete = 1024;
+ var ShouldCapture = 2048;
+ var ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner;
+ var MOUNTING = 1;
+ var MOUNTED = 2;
+ var UNMOUNTED = 3;
+
+ function isFiberMountedImpl(fiber) {
+ var node = fiber;
+
+ if (!fiber.alternate) {
+ if ((node.effectTag & Placement) !== NoEffect) {
+ return MOUNTING;
+ }
+
+ while (node.return) {
+ node = node.return;
+
+ if ((node.effectTag & Placement) !== NoEffect) {
+ return MOUNTING;
+ }
+ }
+ } else {
+ while (node.return) {
+ node = node.return;
+ }
+ }
+
+ if (node.tag === HostRoot) {
+ return MOUNTED;
+ }
+
+ return UNMOUNTED;
+ }
+
+ function isFiberMounted(fiber) {
+ return isFiberMountedImpl(fiber) === MOUNTED;
+ }
+
+ function isMounted(component) {
+ {
+ var owner = ReactCurrentOwner$1.current;
+
+ if (owner !== null && owner.tag === ClassComponent) {
+ var ownerFiber = owner;
+ var instance = ownerFiber.stateNode;
+ !instance._warnedAboutRefsInRender ? warningWithoutStack$1(false, "%s is accessing isMounted inside its render() function. " + "render() should be a pure function of props and state. It should " + "never access something that requires stale data from the previous " + "render, such as refs. Move this logic to componentDidMount and " + "componentDidUpdate instead.", getComponentName(ownerFiber.type) || "A component") : void 0;
+ instance._warnedAboutRefsInRender = true;
+ }
+ }
+ var fiber = get$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;
+ }
+
+ var emptyObject = {};
+ 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, props, validAttributes);
+ }
+
+ function clearProperties(updatePayload, prevProps, validAttributes) {
+ return diffProperties(updatePayload, prevProps, emptyObject, validAttributes);
+ }
+
+ function create(props, validAttributes) {
+ return addProperties(null, props, validAttributes);
+ }
+
+ function diff(prevProps, nextProps, validAttributes) {
+ return diffProperties(null, prevProps, nextProps, validAttributes);
+ }
+
+ function mountSafeCallback_NOT_REALLY_SAFE(context, callback) {
+ return function () {
+ if (!callback) {
+ return undefined;
+ }
+
+ if (typeof context.__isMounted === "boolean") {
+ if (!context.__isMounted) {
+ return undefined;
+ }
+ }
+
+ return callback.apply(context, arguments);
+ };
+ }
+
+ function throwOnStylesProp(component, props) {
+ if (props.styles !== undefined) {
+ var owner = component._owner || null;
+ var name = component.constructor.displayName;
+ var msg = "`styles` is not a supported property of `" + name + "`, did " + "you mean `style` (singular)?";
+
+ if (owner && owner.constructor && owner.constructor.displayName) {
+ msg += "\n\nCheck the `" + owner.constructor.displayName + "` parent " + " component.";
+ }
+
+ throw new Error(msg);
+ }
+ }
+
+ function warnForStyleProps(props, validAttributes) {
+ for (var key in validAttributes.style) {
+ if (!(validAttributes[key] || props[key] === undefined)) {
+ console.error("You are setting the style `{ " + key + ": ... }` as a prop. You " + "should nest it in a style object. " + "E.g. `{ style: { " + key + ": ... } }`");
+ }
+ }
+ }
+
+ var debugRenderPhaseSideEffects = false;
+ var debugRenderPhaseSideEffectsForStrictMode = false;
+ var enableUserTimingAPI = true;
+ var replayFailedUnitOfWorkWithInvokeGuardedCallback = true;
+ var warnAboutDeprecatedLifecycles = false;
+ var enableProfilerTimer = true;
+ var enableSchedulerTracing = true;
+ var enableSuspenseServerRenderer = false;
+ var warnAboutDeprecatedSetNativeProps = false;
+
+ 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_NOT_REALLY_SAFE(this, callback));
+ };
+
+ ReactNativeFiberHostComponent.prototype.measureInWindow = function measureInWindow(callback) {
+ UIManager.measureInWindow(this._nativeTag, mountSafeCallback_NOT_REALLY_SAFE(this, callback));
+ };
+
+ ReactNativeFiberHostComponent.prototype.measureLayout = function measureLayout(relativeToNativeNode, onSuccess, onFail) {
+ UIManager.measureLayout(this._nativeTag, relativeToNativeNode, mountSafeCallback_NOT_REALLY_SAFE(this, onFail), mountSafeCallback_NOT_REALLY_SAFE(this, onSuccess));
+ };
+
+ ReactNativeFiberHostComponent.prototype.setNativeProps = function setNativeProps(nativeProps) {
+ {
+ if (warnAboutDeprecatedSetNativeProps) {
+ warningWithoutStack$1(false, "Warning: Calling ref.setNativeProps(nativeProps) " + "is deprecated and will be removed in a future release. " + "Use the setNativeProps export from the react-native package instead." + "\n\timport {setNativeProps} from 'react-native';\n\tsetNativeProps(ref, nativeProps);\n");
+ }
+
+ warnForStyleProps(nativeProps, this.viewConfig.validAttributes);
+ }
+ var updatePayload = create(nativeProps, this.viewConfig.validAttributes);
+
+ if (updatePayload != null) {
+ 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;
+
+ function setTimeoutCallback() {
+ frameDeadline = now$1() + 5;
+ var callback = scheduledCallback;
+ scheduledCallback = null;
+
+ if (callback !== null) {
+ callback();
+ }
+ }
+
+ function scheduleDeferredCallback$1(callback, options) {
+ scheduledCallback = callback;
+ var timeoutId = setTimeout(setTimeoutCallback, 1);
+ return timeoutId;
+ }
+
+ function cancelDeferredCallback$1(callbackID) {
+ scheduledCallback = null;
+ clearTimeout(callbackID);
+ }
+
+ function shouldYield$1() {
+ return frameDeadline <= now$1();
+ }
+
+ 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;
+ var cloneHiddenInstance = shim;
+ var cloneUnhiddenInstance = shim;
+ var createHiddenTextInstance = shim;
+
+ function shim$1() {
+ invariant(false, "The current renderer does not support hydration. " + "This error is likely caused by a bug in React. " + "Please file an issue.");
+ }
+
+ var supportsHydration = false;
+ var canHydrateInstance = shim$1;
+ var canHydrateTextInstance = shim$1;
+ var canHydrateSuspenseInstance = shim$1;
+ var isSuspenseInstancePending = shim$1;
+ var isSuspenseInstanceFallback = shim$1;
+ var registerSuspenseInstanceRetry = shim$1;
+ var getNextHydratableSibling = shim$1;
+ var getFirstHydratableChild = shim$1;
+ var hydrateInstance = shim$1;
+ var hydrateTextInstance = shim$1;
+ var getNextHydratableInstanceAfterSuspenseInstance = shim$1;
+ var clearSuspenseBoundary = shim$1;
+ var clearSuspenseBoundaryFromContainer = shim$1;
+ var didNotMatchHydratedContainerTextInstance = shim$1;
+ var didNotMatchHydratedTextInstance = shim$1;
+ var didNotHydrateContainerInstance = shim$1;
+ var didNotHydrateInstance = shim$1;
+ var didNotFindHydratableContainerInstance = shim$1;
+ var didNotFindHydratableContainerTextInstance = shim$1;
+ var didNotFindHydratableContainerSuspenseInstance = shim$1;
+ var didNotFindHydratableInstance = shim$1;
+ var didNotFindHydratableTextInstance = shim$1;
+ var didNotFindHydratableSuspenseInstance = shim$1;
+ var UPDATE_SIGNAL = {};
+ {
+ Object.freeze(UPDATE_SIGNAL);
+ }
+ var nextReactTag = 3;
+
+ function allocateTag() {
+ var tag = nextReactTag;
+
+ if (tag % 10 === 1) {
+ tag += 2;
+ }
+
+ nextReactTag = tag + 2;
+ return tag;
+ }
+
+ function recursivelyUncacheFiberNode(node) {
+ if (typeof node === "number") {
+ uncacheFiberNode(node);
+ } else {
+ uncacheFiberNode(node._nativeTag);
+
+ node._children.forEach(recursivelyUncacheFiberNode);
+ }
+ }
+
+ function appendInitialChild(parentInstance, child) {
+ parentInstance._children.push(child);
+ }
+
+ function createInstance(type, props, rootContainerInstance, hostContext, internalInstanceHandle) {
+ var tag = allocateTag();
+ var viewConfig = ReactNativeViewConfigRegistry.get(type);
+ {
+ for (var key in viewConfig.validAttributes) {
+ if (props.hasOwnProperty(key)) {
+ deepFreezeAndThrowOnMutationInDev(props[key]);
+ }
+ }
+ }
+ invariant(type !== "RCTView" || !hostContext.isInAParentText, "Nesting of within 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 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 UPDATE_SIGNAL;
+ }
+
+ function resetAfterCommit(containerInfo) {}
+
+ var now$$1 = now$1;
+ var isPrimaryRenderer = true;
+ var scheduleDeferredCallback$$1 = scheduleDeferredCallback$1;
+ var cancelDeferredCallback$$1 = cancelDeferredCallback$1;
+ var shouldYield$$1 = shouldYield$1;
+ var scheduleTimeout = setTimeout;
+ var cancelTimeout = clearTimeout;
+ var noTimeout = -1;
+ var schedulePassiveEffects = scheduleDeferredCallback$$1;
+ var cancelPassiveEffects = 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) {}
+
+ function hideInstance(instance) {
+ var viewConfig = instance.viewConfig;
+ var updatePayload = create({
+ style: {
+ display: "none"
+ }
+ }, viewConfig.validAttributes);
+ UIManager.updateView(instance._nativeTag, viewConfig.uiViewClassName, updatePayload);
+ }
+
+ function hideTextInstance(textInstance) {
+ throw new Error("Not yet implemented.");
+ }
+
+ function unhideInstance(instance, props) {
+ var viewConfig = instance.viewConfig;
+ var updatePayload = diff(_extends({}, props, {
+ style: [props.style, {
+ display: "none"
+ }]
+ }), props, viewConfig.validAttributes);
+ UIManager.updateView(instance._nativeTag, viewConfig.uiViewClassName, updatePayload);
+ }
+
+ function unhideTextInstance(textInstance, text) {
+ throw new Error("Not yet implemented.");
+ }
+
+ var BEFORE_SLASH_RE = /^(.*)[\\\/]/;
+
+ var describeComponentFrame = function describeComponentFrame(name, source, ownerName) {
+ var sourceInfo = "";
+
+ if (source) {
+ var path = source.fileName;
+ var fileName = path.replace(BEFORE_SLASH_RE, "");
+ {
+ if (/^index\./.test(fileName)) {
+ var match = path.match(BEFORE_SLASH_RE);
+
+ if (match) {
+ var pathBeforeSlash = match[1];
+
+ if (pathBeforeSlash) {
+ var folderName = pathBeforeSlash.replace(BEFORE_SLASH_RE, "");
+ fileName = folderName + "/" + fileName;
+ }
+ }
+ }
+ }
+ sourceInfo = " (at " + fileName + ":" + source.lineNumber + ")";
+ } else if (ownerName) {
+ sourceInfo = " (created by " + ownerName + ")";
+ }
+
+ return "\n in " + (name || "Unknown") + sourceInfo;
+ };
+
+ var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+
+ function describeFiber(fiber) {
+ switch (fiber.tag) {
+ case HostRoot:
+ case HostPortal:
+ case HostText:
+ case Fragment:
+ case ContextProvider:
+ case ContextConsumer:
+ return "";
+
+ default:
+ var owner = fiber._debugOwner;
+ var source = fiber._debugSource;
+ var name = getComponentName(fiber.type);
+ var ownerName = null;
+
+ if (owner) {
+ ownerName = getComponentName(owner.type);
+ }
+
+ return describeComponentFrame(name, source, ownerName);
+ }
+ }
+
+ function getStackByFiberInDevAndProd(workInProgress) {
+ var info = "";
+ var node = workInProgress;
+
+ do {
+ info += describeFiber(node);
+ node = node.return;
+ } while (node);
+
+ return info;
+ }
+
+ var current = null;
+ var phase = null;
+
+ function getCurrentFiberOwnerNameInDevOrNull() {
+ {
+ if (current === null) {
+ return null;
+ }
+
+ var owner = current._debugOwner;
+
+ if (owner !== null && typeof owner !== "undefined") {
+ return getComponentName(owner.type);
+ }
+ }
+ return null;
+ }
+
+ function getCurrentFiberStackInDev() {
+ {
+ if (current === null) {
+ return "";
+ }
+
+ return getStackByFiberInDevAndProd(current);
+ }
+ return "";
+ }
+
+ function resetCurrentFiber() {
+ {
+ ReactDebugCurrentFrame.getCurrentStack = null;
+ current = null;
+ phase = null;
+ }
+ }
+
+ function setCurrentFiber(fiber) {
+ {
+ ReactDebugCurrentFrame.getCurrentStack = getCurrentFiberStackInDev;
+ current = fiber;
+ phase = null;
+ }
+ }
+
+ function setCurrentPhase(lifeCyclePhase) {
+ {
+ phase = lifeCyclePhase;
+ }
+ }
+
+ var reactEmoji = "\u269B";
+ var warningEmoji = "\u26D4";
+ var supportsUserTiming = typeof performance !== "undefined" && typeof performance.mark === "function" && typeof performance.clearMarks === "function" && typeof performance.measure === "function" && typeof performance.clearMeasures === "function";
+ var currentFiber = null;
+ var currentPhase = null;
+ var currentPhaseFiber = null;
+ var isCommitting = false;
+ var hasScheduledUpdateInCurrentCommit = false;
+ var hasScheduledUpdateInCurrentPhase = false;
+ var commitCountInCurrentWorkLoop = 0;
+ var effectCountInCurrentCommit = 0;
+ var isWaitingForCallback = false;
+ var labelsInCurrentCommit = new Set();
+
+ var formatMarkName = function formatMarkName(markName) {
+ return reactEmoji + " " + markName;
+ };
+
+ var formatLabel = function formatLabel(label, warning) {
+ var prefix = warning ? warningEmoji + " " : reactEmoji + " ";
+ var suffix = warning ? " Warning: " + warning : "";
+ return "" + prefix + label + suffix;
+ };
+
+ var beginMark = function beginMark(markName) {
+ performance.mark(formatMarkName(markName));
+ };
+
+ var clearMark = function clearMark(markName) {
+ performance.clearMarks(formatMarkName(markName));
+ };
+
+ var endMark = function endMark(label, markName, warning) {
+ var formattedMarkName = formatMarkName(markName);
+ var formattedLabel = formatLabel(label, warning);
+
+ try {
+ performance.measure(formattedLabel, formattedMarkName);
+ } catch (err) {}
+
+ performance.clearMarks(formattedMarkName);
+ performance.clearMeasures(formattedLabel);
+ };
+
+ var getFiberMarkName = function getFiberMarkName(label, debugID) {
+ return label + " (#" + debugID + ")";
+ };
+
+ var getFiberLabel = function getFiberLabel(componentName, isMounted, phase) {
+ if (phase === null) {
+ return componentName + " [" + (isMounted ? "update" : "mount") + "]";
+ } else {
+ return componentName + "." + phase;
+ }
+ };
+
+ var beginFiberMark = function beginFiberMark(fiber, phase) {
+ var componentName = getComponentName(fiber.type) || "Unknown";
+ var debugID = fiber._debugID;
+ var isMounted = fiber.alternate !== null;
+ var label = getFiberLabel(componentName, isMounted, phase);
+
+ if (isCommitting && labelsInCurrentCommit.has(label)) {
+ return false;
+ }
+
+ labelsInCurrentCommit.add(label);
+ var markName = getFiberMarkName(label, debugID);
+ beginMark(markName);
+ return true;
+ };
+
+ var clearFiberMark = function clearFiberMark(fiber, phase) {
+ var componentName = getComponentName(fiber.type) || "Unknown";
+ var debugID = fiber._debugID;
+ var isMounted = fiber.alternate !== null;
+ var label = getFiberLabel(componentName, isMounted, phase);
+ var markName = getFiberMarkName(label, debugID);
+ clearMark(markName);
+ };
+
+ var endFiberMark = function endFiberMark(fiber, phase, warning) {
+ var componentName = getComponentName(fiber.type) || "Unknown";
+ var debugID = fiber._debugID;
+ var isMounted = fiber.alternate !== null;
+ var label = getFiberLabel(componentName, isMounted, phase);
+ var markName = getFiberMarkName(label, debugID);
+ endMark(label, markName, warning);
+ };
+
+ var shouldIgnoreFiber = function shouldIgnoreFiber(fiber) {
+ switch (fiber.tag) {
+ case HostRoot:
+ case HostComponent:
+ case HostText:
+ case HostPortal:
+ case Fragment:
+ case ContextProvider:
+ case ContextConsumer:
+ case Mode:
+ return true;
+
+ default:
+ return false;
+ }
+ };
+
+ var clearPendingPhaseMeasurement = function clearPendingPhaseMeasurement() {
+ if (currentPhase !== null && currentPhaseFiber !== null) {
+ clearFiberMark(currentPhaseFiber, currentPhase);
+ }
+
+ currentPhaseFiber = null;
+ currentPhase = null;
+ hasScheduledUpdateInCurrentPhase = false;
+ };
+
+ var pauseTimers = function pauseTimers() {
+ var fiber = currentFiber;
+
+ while (fiber) {
+ if (fiber._debugIsCurrentlyTiming) {
+ endFiberMark(fiber, null, null);
+ }
+
+ fiber = fiber.return;
+ }
+ };
+
+ var resumeTimersRecursively = function resumeTimersRecursively(fiber) {
+ if (fiber.return !== null) {
+ resumeTimersRecursively(fiber.return);
+ }
+
+ if (fiber._debugIsCurrentlyTiming) {
+ beginFiberMark(fiber, null);
+ }
+ };
+
+ var resumeTimers = function resumeTimers() {
+ if (currentFiber !== null) {
+ resumeTimersRecursively(currentFiber);
+ }
+ };
+
+ function recordEffect() {
+ if (enableUserTimingAPI) {
+ effectCountInCurrentCommit++;
+ }
+ }
+
+ function recordScheduleUpdate() {
+ if (enableUserTimingAPI) {
+ if (isCommitting) {
+ hasScheduledUpdateInCurrentCommit = true;
+ }
+
+ if (currentPhase !== null && currentPhase !== "componentWillMount" && currentPhase !== "componentWillReceiveProps") {
+ hasScheduledUpdateInCurrentPhase = true;
+ }
+ }
+ }
+
+ function startRequestCallbackTimer() {
+ if (enableUserTimingAPI) {
+ if (supportsUserTiming && !isWaitingForCallback) {
+ isWaitingForCallback = true;
+ beginMark("(Waiting for async callback...)");
+ }
+ }
+ }
+
+ function stopRequestCallbackTimer(didExpire, expirationTime) {
+ if (enableUserTimingAPI) {
+ if (supportsUserTiming) {
+ isWaitingForCallback = false;
+ var warning = didExpire ? "React was blocked by main thread" : null;
+ endMark("(Waiting for async callback... will force flush in " + expirationTime + " ms)", "(Waiting for async callback...)", warning);
+ }
+ }
+ }
+
+ function startWorkTimer(fiber) {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming || shouldIgnoreFiber(fiber)) {
+ return;
+ }
+
+ currentFiber = fiber;
+
+ if (!beginFiberMark(fiber, null)) {
+ return;
+ }
+
+ fiber._debugIsCurrentlyTiming = true;
+ }
+ }
+
+ function cancelWorkTimer(fiber) {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming || shouldIgnoreFiber(fiber)) {
+ return;
+ }
+
+ fiber._debugIsCurrentlyTiming = false;
+ clearFiberMark(fiber, null);
+ }
+ }
+
+ function stopWorkTimer(fiber) {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming || shouldIgnoreFiber(fiber)) {
+ return;
+ }
+
+ currentFiber = fiber.return;
+
+ if (!fiber._debugIsCurrentlyTiming) {
+ return;
+ }
+
+ fiber._debugIsCurrentlyTiming = false;
+ endFiberMark(fiber, null, null);
+ }
+ }
+
+ function stopFailedWorkTimer(fiber) {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming || shouldIgnoreFiber(fiber)) {
+ return;
+ }
+
+ currentFiber = fiber.return;
+
+ if (!fiber._debugIsCurrentlyTiming) {
+ return;
+ }
+
+ fiber._debugIsCurrentlyTiming = false;
+ var warning = fiber.tag === SuspenseComponent || fiber.tag === DehydratedSuspenseComponent ? "Rendering was suspended" : "An error was thrown inside this error boundary";
+ endFiberMark(fiber, null, warning);
+ }
+ }
+
+ function startPhaseTimer(fiber, phase) {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ clearPendingPhaseMeasurement();
+
+ if (!beginFiberMark(fiber, phase)) {
+ return;
+ }
+
+ currentPhaseFiber = fiber;
+ currentPhase = phase;
+ }
+ }
+
+ function stopPhaseTimer() {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ if (currentPhase !== null && currentPhaseFiber !== null) {
+ var warning = hasScheduledUpdateInCurrentPhase ? "Scheduled a cascading update" : null;
+ endFiberMark(currentPhaseFiber, currentPhase, warning);
+ }
+
+ currentPhase = null;
+ currentPhaseFiber = null;
+ }
+ }
+
+ function startWorkLoopTimer(nextUnitOfWork) {
+ if (enableUserTimingAPI) {
+ currentFiber = nextUnitOfWork;
+
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ commitCountInCurrentWorkLoop = 0;
+ beginMark("(React Tree Reconciliation)");
+ resumeTimers();
+ }
+ }
+
+ function stopWorkLoopTimer(interruptedBy, didCompleteRoot) {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ var warning = null;
+
+ if (interruptedBy !== null) {
+ if (interruptedBy.tag === HostRoot) {
+ warning = "A top-level update interrupted the previous render";
+ } else {
+ var componentName = getComponentName(interruptedBy.type) || "Unknown";
+ warning = "An update to " + componentName + " interrupted the previous render";
+ }
+ } else if (commitCountInCurrentWorkLoop > 1) {
+ warning = "There were cascading updates";
+ }
+
+ commitCountInCurrentWorkLoop = 0;
+ var label = didCompleteRoot ? "(React Tree Reconciliation: Completed Root)" : "(React Tree Reconciliation: Yielded)";
+ pauseTimers();
+ endMark(label, "(React Tree Reconciliation)", warning);
+ }
+ }
+
+ function startCommitTimer() {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ isCommitting = true;
+ hasScheduledUpdateInCurrentCommit = false;
+ labelsInCurrentCommit.clear();
+ beginMark("(Committing Changes)");
+ }
+ }
+
+ function stopCommitTimer() {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ var warning = null;
+
+ if (hasScheduledUpdateInCurrentCommit) {
+ warning = "Lifecycle hook scheduled a cascading update";
+ } else if (commitCountInCurrentWorkLoop > 0) {
+ warning = "Caused by a cascading update in earlier commit";
+ }
+
+ hasScheduledUpdateInCurrentCommit = false;
+ commitCountInCurrentWorkLoop++;
+ isCommitting = false;
+ labelsInCurrentCommit.clear();
+ endMark("(Committing Changes)", "(Committing Changes)", warning);
+ }
+ }
+
+ function startCommitSnapshotEffectsTimer() {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ effectCountInCurrentCommit = 0;
+ beginMark("(Committing Snapshot Effects)");
+ }
+ }
+
+ function stopCommitSnapshotEffectsTimer() {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ var count = effectCountInCurrentCommit;
+ effectCountInCurrentCommit = 0;
+ endMark("(Committing Snapshot Effects: " + count + " Total)", "(Committing Snapshot Effects)", null);
+ }
+ }
+
+ function startCommitHostEffectsTimer() {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ effectCountInCurrentCommit = 0;
+ beginMark("(Committing Host Effects)");
+ }
+ }
+
+ function stopCommitHostEffectsTimer() {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ var count = effectCountInCurrentCommit;
+ effectCountInCurrentCommit = 0;
+ endMark("(Committing Host Effects: " + count + " Total)", "(Committing Host Effects)", null);
+ }
+ }
+
+ function startCommitLifeCyclesTimer() {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ effectCountInCurrentCommit = 0;
+ beginMark("(Calling Lifecycle Methods)");
+ }
+ }
+
+ function stopCommitLifeCyclesTimer() {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ var count = effectCountInCurrentCommit;
+ effectCountInCurrentCommit = 0;
+ endMark("(Calling Lifecycle Methods: " + count + " Total)", "(Calling Lifecycle Methods)", null);
+ }
+ }
+
+ var valueStack = [];
+ var fiberStack = void 0;
+ {
+ fiberStack = [];
+ }
+ var index = -1;
+
+ function createCursor(defaultValue) {
+ return {
+ current: defaultValue
+ };
+ }
+
+ function pop(cursor, fiber) {
+ if (index < 0) {
+ {
+ warningWithoutStack$1(false, "Unexpected pop.");
+ }
+ return;
+ }
+
+ {
+ if (fiber !== fiberStack[index]) {
+ warningWithoutStack$1(false, "Unexpected Fiber popped.");
+ }
+ }
+ cursor.current = valueStack[index];
+ valueStack[index] = null;
+ {
+ fiberStack[index] = null;
+ }
+ index--;
+ }
+
+ function push(cursor, value, fiber) {
+ index++;
+ valueStack[index] = cursor.current;
+ {
+ fiberStack[index] = fiber;
+ }
+ cursor.current = value;
+ }
+
+ function checkThatStackIsEmpty() {
+ {
+ if (index !== -1) {
+ warningWithoutStack$1(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 emptyContextObject = {};
+ {
+ Object.freeze(emptyContextObject);
+ }
+ var contextStackCursor = createCursor(emptyContextObject);
+ var didPerformWorkStackCursor = createCursor(false);
+ var previousContext = emptyContextObject;
+
+ function getUnmaskedContext(workInProgress, Component, didPushOwnContextIfProvider) {
+ if (didPushOwnContextIfProvider && isContextProvider(Component)) {
+ 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 emptyContextObject;
+ }
+
+ var instance = workInProgress.stateNode;
+
+ if (instance && instance.__reactInternalMemoizedUnmaskedChildContext === unmaskedContext) {
+ return instance.__reactInternalMemoizedMaskedChildContext;
+ }
+
+ var context = {};
+
+ for (var key in contextTypes) {
+ context[key] = unmaskedContext[key];
+ }
+
+ {
+ var name = getComponentName(type) || "Unknown";
+ checkPropTypes(contextTypes, context, "context", name, getCurrentFiberStackInDev);
+ }
+
+ if (instance) {
+ cacheContext(workInProgress, unmaskedContext, context);
+ }
+
+ return context;
+ }
+
+ function hasContextChanged() {
+ return didPerformWorkStackCursor.current;
+ }
+
+ function isContextProvider(type) {
+ var childContextTypes = type.childContextTypes;
+ return childContextTypes !== null && childContextTypes !== undefined;
+ }
+
+ function popContext(fiber) {
+ pop(didPerformWorkStackCursor, fiber);
+ pop(contextStackCursor, fiber);
+ }
+
+ function popTopLevelContextObject(fiber) {
+ pop(didPerformWorkStackCursor, fiber);
+ pop(contextStackCursor, fiber);
+ }
+
+ function pushTopLevelContextObject(fiber, context, didChange) {
+ invariant(contextStackCursor.current === emptyContextObject, "Unexpected context found on stack. " + "This error is likely caused by a bug in React. Please file an issue.");
+ push(contextStackCursor, context, fiber);
+ push(didPerformWorkStackCursor, didChange, fiber);
+ }
+
+ function processChildContext(fiber, type, parentContext) {
+ var instance = fiber.stateNode;
+ var childContextTypes = type.childContextTypes;
+
+ if (typeof instance.getChildContext !== "function") {
+ {
+ var componentName = getComponentName(type) || "Unknown";
+
+ if (!warnedAboutMissingGetChildContext[componentName]) {
+ warnedAboutMissingGetChildContext[componentName] = true;
+ warningWithoutStack$1(false, "%s.childContextTypes is specified but there is no getChildContext() method " + "on the instance. You can either define getChildContext() on %s or remove " + "childContextTypes from it.", componentName, componentName);
+ }
+ }
+ return parentContext;
+ }
+
+ var childContext = void 0;
+ {
+ setCurrentPhase("getChildContext");
+ }
+ startPhaseTimer(fiber, "getChildContext");
+ childContext = instance.getChildContext();
+ stopPhaseTimer();
+ {
+ setCurrentPhase(null);
+ }
+
+ for (var contextKey in childContext) {
+ invariant(contextKey in childContextTypes, '%s.getChildContext(): key "%s" is not defined in childContextTypes.', getComponentName(type) || "Unknown", contextKey);
+ }
+
+ {
+ var name = getComponentName(type) || "Unknown";
+ checkPropTypes(childContextTypes, childContext, "child context", name, getCurrentFiberStackInDev);
+ }
+ return _extends({}, parentContext, childContext);
+ }
+
+ function pushContextProvider(workInProgress) {
+ var instance = workInProgress.stateNode;
+ var memoizedMergedChildContext = instance && instance.__reactInternalMemoizedMergedChildContext || emptyContextObject;
+ previousContext = contextStackCursor.current;
+ push(contextStackCursor, memoizedMergedChildContext, workInProgress);
+ push(didPerformWorkStackCursor, didPerformWorkStackCursor.current, workInProgress);
+ return true;
+ }
+
+ function invalidateContextProvider(workInProgress, type, didChange) {
+ 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, type, previousContext);
+ instance.__reactInternalMemoizedMergedChildContext = mergedContext;
+ pop(didPerformWorkStackCursor, workInProgress);
+ pop(contextStackCursor, workInProgress);
+ push(contextStackCursor, mergedContext, workInProgress);
+ push(didPerformWorkStackCursor, didChange, workInProgress);
+ } else {
+ pop(didPerformWorkStackCursor, workInProgress);
+ push(didPerformWorkStackCursor, didChange, workInProgress);
+ }
+ }
+
+ function findCurrentUnmaskedContext(fiber) {
+ 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;
+
+ do {
+ switch (node.tag) {
+ case HostRoot:
+ return node.stateNode.context;
+
+ case ClassComponent:
+ {
+ var Component = node.type;
+
+ if (isContextProvider(Component)) {
+ return node.stateNode.__reactInternalMemoizedMergedChildContext;
+ }
+
+ break;
+ }
+ }
+
+ node = node.return;
+ } while (node !== null);
+
+ invariant(false, "Found unexpected detached subtree parent. " + "This error is likely caused by a bug in React. Please file an issue.");
+ }
+
+ 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;
+ warningWithoutStack$1(false, "React DevTools encountered an error: %s", err);
+ }
+ }
+ };
+ }
+
+ var isDevToolsPresent = typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined";
+
+ function injectInternals(internals) {
+ if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === "undefined") {
+ return false;
+ }
+
+ var hook = __REACT_DEVTOOLS_GLOBAL_HOOK__;
+
+ if (hook.isDisabled) {
+ return true;
+ }
+
+ if (!hook.supportsFiber) {
+ {
+ warningWithoutStack$1(false, "The installed version of React DevTools is too old and will not work " + "with the current version of React. Please update React DevTools. " + "https://fb.me/react-devtools");
+ }
+ return true;
+ }
+
+ try {
+ var rendererID = hook.inject(internals);
+ onCommitFiberRoot = catchErrors(function (root) {
+ return hook.onCommitFiberRoot(rendererID, root);
+ });
+ onCommitFiberUnmount = catchErrors(function (fiber) {
+ return hook.onCommitFiberUnmount(rendererID, fiber);
+ });
+ } catch (err) {
+ {
+ warningWithoutStack$1(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 maxSigned31BitInt = 1073741823;
+ var NoWork = 0;
+ var Never = 1;
+ var Sync = maxSigned31BitInt;
+ var UNIT_SIZE = 10;
+ var MAGIC_NUMBER_OFFSET = maxSigned31BitInt - 1;
+
+ function msToExpirationTime(ms) {
+ return MAGIC_NUMBER_OFFSET - (ms / UNIT_SIZE | 0);
+ }
+
+ function expirationTimeToMs(expirationTime) {
+ return (MAGIC_NUMBER_OFFSET - expirationTime) * UNIT_SIZE;
+ }
+
+ function ceiling(num, precision) {
+ return ((num / precision | 0) + 1) * precision;
+ }
+
+ function computeExpirationBucket(currentTime, expirationInMs, bucketSizeMs) {
+ return MAGIC_NUMBER_OFFSET - ceiling(MAGIC_NUMBER_OFFSET - currentTime + expirationInMs / UNIT_SIZE, bucketSizeMs / UNIT_SIZE);
+ }
+
+ var LOW_PRIORITY_EXPIRATION = 5000;
+ var LOW_PRIORITY_BATCH_SIZE = 250;
+
+ function computeAsyncExpiration(currentTime) {
+ return computeExpirationBucket(currentTime, LOW_PRIORITY_EXPIRATION, LOW_PRIORITY_BATCH_SIZE);
+ }
+
+ var HIGH_PRIORITY_EXPIRATION = 500;
+ var HIGH_PRIORITY_BATCH_SIZE = 100;
+
+ function computeInteractiveExpiration(currentTime) {
+ return computeExpirationBucket(currentTime, HIGH_PRIORITY_EXPIRATION, HIGH_PRIORITY_BATCH_SIZE);
+ }
+
+ var NoContext = 0;
+ var ConcurrentMode = 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.elementType = null;
+ this.type = null;
+ this.stateNode = null;
+ this.return = null;
+ this.child = null;
+ this.sibling = null;
+ this.index = 0;
+ this.ref = null;
+ this.pendingProps = pendingProps;
+ this.memoizedProps = null;
+ this.updateQueue = null;
+ this.memoizedState = null;
+ this.contextDependencies = null;
+ this.mode = mode;
+ this.effectTag = NoEffect;
+ this.nextEffect = null;
+ this.firstEffect = null;
+ this.lastEffect = null;
+ this.expirationTime = NoWork;
+ this.childExpirationTime = NoWork;
+ this.alternate = null;
+
+ if (enableProfilerTimer) {
+ this.actualDuration = Number.NaN;
+ this.actualStartTime = Number.NaN;
+ this.selfBaseDuration = Number.NaN;
+ this.treeBaseDuration = Number.NaN;
+ this.actualDuration = 0;
+ this.actualStartTime = -1;
+ this.selfBaseDuration = 0;
+ this.treeBaseDuration = 0;
+ }
+
+ {
+ this._debugID = debugCounter++;
+ this._debugSource = null;
+ this._debugOwner = null;
+ this._debugIsCurrentlyTiming = false;
+
+ if (!hasBadMapPolyfill && typeof Object.preventExtensions === "function") {
+ Object.preventExtensions(this);
+ }
+ }
+ }
+
+ var createFiber = function createFiber(tag, pendingProps, key, mode) {
+ return new FiberNode(tag, pendingProps, key, mode);
+ };
+
+ function shouldConstruct(Component) {
+ var prototype = Component.prototype;
+ return !!(prototype && prototype.isReactComponent);
+ }
+
+ function isSimpleFunctionComponent(type) {
+ return typeof type === "function" && !shouldConstruct(type) && type.defaultProps === undefined;
+ }
+
+ function resolveLazyComponentTag(Component) {
+ if (typeof Component === "function") {
+ return shouldConstruct(Component) ? ClassComponent : FunctionComponent;
+ } else if (Component !== undefined && Component !== null) {
+ var $$typeof = Component.$$typeof;
+
+ if ($$typeof === REACT_FORWARD_REF_TYPE) {
+ return ForwardRef;
+ }
+
+ if ($$typeof === REACT_MEMO_TYPE) {
+ return MemoComponent;
+ }
+ }
+
+ return IndeterminateComponent;
+ }
+
+ function createWorkInProgress(current, pendingProps, expirationTime) {
+ var workInProgress = current.alternate;
+
+ if (workInProgress === null) {
+ workInProgress = createFiber(current.tag, pendingProps, current.key, current.mode);
+ workInProgress.elementType = current.elementType;
+ workInProgress.type = current.type;
+ workInProgress.stateNode = current.stateNode;
+ {
+ workInProgress._debugID = current._debugID;
+ workInProgress._debugSource = current._debugSource;
+ workInProgress._debugOwner = current._debugOwner;
+ }
+ workInProgress.alternate = current;
+ current.alternate = workInProgress;
+ } else {
+ workInProgress.pendingProps = pendingProps;
+ workInProgress.effectTag = NoEffect;
+ workInProgress.nextEffect = null;
+ workInProgress.firstEffect = null;
+ workInProgress.lastEffect = null;
+
+ if (enableProfilerTimer) {
+ workInProgress.actualDuration = 0;
+ workInProgress.actualStartTime = -1;
+ }
+ }
+
+ workInProgress.childExpirationTime = current.childExpirationTime;
+ workInProgress.expirationTime = current.expirationTime;
+ workInProgress.child = current.child;
+ workInProgress.memoizedProps = current.memoizedProps;
+ workInProgress.memoizedState = current.memoizedState;
+ workInProgress.updateQueue = current.updateQueue;
+ workInProgress.contextDependencies = current.contextDependencies;
+ workInProgress.sibling = current.sibling;
+ workInProgress.index = current.index;
+ workInProgress.ref = current.ref;
+
+ if (enableProfilerTimer) {
+ workInProgress.selfBaseDuration = current.selfBaseDuration;
+ workInProgress.treeBaseDuration = current.treeBaseDuration;
+ }
+
+ return workInProgress;
+ }
+
+ function createHostRootFiber(isConcurrent) {
+ var mode = isConcurrent ? ConcurrentMode | StrictMode : NoContext;
+
+ if (enableProfilerTimer && isDevToolsPresent) {
+ mode |= ProfileMode;
+ }
+
+ return createFiber(HostRoot, null, null, mode);
+ }
+
+ function createFiberFromTypeAndProps(type, key, pendingProps, owner, mode, expirationTime) {
+ var fiber = void 0;
+ var fiberTag = IndeterminateComponent;
+ var resolvedType = type;
+
+ if (typeof type === "function") {
+ if (shouldConstruct(type)) {
+ fiberTag = ClassComponent;
+ }
+ } else if (typeof type === "string") {
+ fiberTag = HostComponent;
+ } else {
+ getTag: switch (type) {
+ case REACT_FRAGMENT_TYPE:
+ return createFiberFromFragment(pendingProps.children, mode, expirationTime, key);
+
+ case REACT_CONCURRENT_MODE_TYPE:
+ return createFiberFromMode(pendingProps, mode | ConcurrentMode | StrictMode, expirationTime, key);
+
+ case REACT_STRICT_MODE_TYPE:
+ return createFiberFromMode(pendingProps, mode | StrictMode, expirationTime, key);
+
+ case REACT_PROFILER_TYPE:
+ return createFiberFromProfiler(pendingProps, mode, expirationTime, key);
+
+ case REACT_SUSPENSE_TYPE:
+ return createFiberFromSuspense(pendingProps, mode, expirationTime, key);
+
+ default:
+ {
+ if (typeof type === "object" && type !== null) {
+ switch (type.$$typeof) {
+ case REACT_PROVIDER_TYPE:
+ fiberTag = ContextProvider;
+ break getTag;
+
+ case REACT_CONTEXT_TYPE:
+ fiberTag = ContextConsumer;
+ break getTag;
+
+ case REACT_FORWARD_REF_TYPE:
+ fiberTag = ForwardRef;
+ break getTag;
+
+ case REACT_MEMO_TYPE:
+ fiberTag = MemoComponent;
+ break getTag;
+
+ case REACT_LAZY_TYPE:
+ fiberTag = LazyComponent;
+ resolvedType = null;
+ break getTag;
+ }
+ }
+
+ var info = "";
+ {
+ if (type === undefined || typeof type === "object" && type !== null && Object.keys(type).length === 0) {
+ info += " You likely forgot to export your component from the file " + "it's defined in, or you might have mixed up default and " + "named imports.";
+ }
+
+ var ownerName = owner ? getComponentName(owner.type) : null;
+
+ if (ownerName) {
+ info += "\n\nCheck the render method of `" + ownerName + "`.";
+ }
+ }
+ 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);
+ }
+ }
+ }
+
+ fiber = createFiber(fiberTag, pendingProps, key, mode);
+ fiber.elementType = type;
+ fiber.type = resolvedType;
+ fiber.expirationTime = expirationTime;
+ return fiber;
+ }
+
+ function createFiberFromElement(element, mode, expirationTime) {
+ var owner = null;
+ {
+ owner = element._owner;
+ }
+ var type = element.type;
+ var key = element.key;
+ var pendingProps = element.props;
+ var fiber = createFiberFromTypeAndProps(type, key, pendingProps, owner, mode, expirationTime);
+ {
+ fiber._debugSource = element._source;
+ fiber._debugOwner = element._owner;
+ }
+ return fiber;
+ }
+
+ function createFiberFromFragment(elements, mode, expirationTime, key) {
+ var fiber = createFiber(Fragment, elements, key, mode);
+ fiber.expirationTime = expirationTime;
+ return fiber;
+ }
+
+ function createFiberFromProfiler(pendingProps, mode, expirationTime, key) {
+ {
+ if (typeof pendingProps.id !== "string" || typeof pendingProps.onRender !== "function") {
+ warningWithoutStack$1(false, 'Profiler must specify an "id" string and "onRender" function as props');
+ }
+ }
+ var fiber = createFiber(Profiler, pendingProps, key, mode | ProfileMode);
+ fiber.elementType = REACT_PROFILER_TYPE;
+ fiber.type = REACT_PROFILER_TYPE;
+ fiber.expirationTime = expirationTime;
+ return fiber;
+ }
+
+ function createFiberFromMode(pendingProps, mode, expirationTime, key) {
+ var fiber = createFiber(Mode, pendingProps, key, mode);
+ var type = (mode & ConcurrentMode) === NoContext ? REACT_STRICT_MODE_TYPE : REACT_CONCURRENT_MODE_TYPE;
+ fiber.elementType = type;
+ fiber.type = type;
+ fiber.expirationTime = expirationTime;
+ return fiber;
+ }
+
+ function createFiberFromSuspense(pendingProps, mode, expirationTime, key) {
+ var fiber = createFiber(SuspenseComponent, pendingProps, key, mode);
+ var type = REACT_SUSPENSE_TYPE;
+ fiber.elementType = type;
+ fiber.type = 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.elementType = "DELETED";
+ fiber.type = "DELETED";
+ return fiber;
+ }
+
+ function createFiberFromPortal(portal, mode, expirationTime) {
+ var pendingProps = portal.children !== null ? portal.children : [];
+ var fiber = createFiber(HostPortal, pendingProps, portal.key, mode);
+ fiber.expirationTime = expirationTime;
+ fiber.stateNode = {
+ containerInfo: portal.containerInfo,
+ pendingChildren: null,
+ implementation: portal.implementation
+ };
+ return fiber;
+ }
+
+ function assignFiberPropertiesInDEV(target, source) {
+ if (target === null) {
+ target = createFiber(IndeterminateComponent, null, null, NoContext);
+ }
+
+ target.tag = source.tag;
+ target.key = source.key;
+ target.elementType = source.elementType;
+ target.type = source.type;
+ target.stateNode = source.stateNode;
+ target.return = source.return;
+ target.child = source.child;
+ target.sibling = source.sibling;
+ target.index = source.index;
+ target.ref = source.ref;
+ target.pendingProps = source.pendingProps;
+ target.memoizedProps = source.memoizedProps;
+ target.updateQueue = source.updateQueue;
+ target.memoizedState = source.memoizedState;
+ target.contextDependencies = source.contextDependencies;
+ target.mode = source.mode;
+ target.effectTag = source.effectTag;
+ target.nextEffect = source.nextEffect;
+ target.firstEffect = source.firstEffect;
+ target.lastEffect = source.lastEffect;
+ target.expirationTime = source.expirationTime;
+ target.childExpirationTime = source.childExpirationTime;
+ target.alternate = source.alternate;
+
+ if (enableProfilerTimer) {
+ target.actualDuration = source.actualDuration;
+ target.actualStartTime = source.actualStartTime;
+ target.selfBaseDuration = source.selfBaseDuration;
+ target.treeBaseDuration = source.treeBaseDuration;
+ }
+
+ target._debugID = source._debugID;
+ target._debugSource = source._debugSource;
+ target._debugOwner = source._debugOwner;
+ target._debugIsCurrentlyTiming = source._debugIsCurrentlyTiming;
+ return target;
+ }
+
+ function createFiberRoot(containerInfo, isConcurrent, hydrate) {
+ var uninitializedFiber = createHostRootFiber(isConcurrent);
+ var root = void 0;
+
+ if (enableSchedulerTracing) {
+ root = {
+ current: uninitializedFiber,
+ containerInfo: containerInfo,
+ pendingChildren: null,
+ earliestPendingTime: NoWork,
+ latestPendingTime: NoWork,
+ earliestSuspendedTime: NoWork,
+ latestSuspendedTime: NoWork,
+ latestPingedTime: NoWork,
+ pingCache: null,
+ didError: false,
+ pendingCommitExpirationTime: NoWork,
+ finishedWork: null,
+ timeoutHandle: noTimeout,
+ context: null,
+ pendingContext: null,
+ hydrate: hydrate,
+ nextExpirationTimeToWorkOn: NoWork,
+ expirationTime: NoWork,
+ firstBatch: null,
+ nextScheduledRoot: null,
+ interactionThreadID: tracing.unstable_getThreadID(),
+ memoizedInteractions: new Set(),
+ pendingInteractionMap: new Map()
+ };
+ } else {
+ root = {
+ current: uninitializedFiber,
+ containerInfo: containerInfo,
+ pendingChildren: null,
+ pingCache: null,
+ earliestPendingTime: NoWork,
+ latestPendingTime: NoWork,
+ earliestSuspendedTime: NoWork,
+ latestSuspendedTime: NoWork,
+ latestPingedTime: NoWork,
+ didError: false,
+ pendingCommitExpirationTime: NoWork,
+ finishedWork: null,
+ timeoutHandle: noTimeout,
+ context: null,
+ pendingContext: null,
+ hydrate: hydrate,
+ nextExpirationTimeToWorkOn: NoWork,
+ expirationTime: NoWork,
+ firstBatch: null,
+ nextScheduledRoot: null
+ };
+ }
+
+ uninitializedFiber.stateNode = root;
+ return root;
+ }
+
+ var lowPriorityWarning = function lowPriorityWarning() {};
+
+ {
+ var printWarning = function printWarning(format) {
+ for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+ args[_key - 1] = arguments[_key];
+ }
+
+ var argIndex = 0;
+ var message = "Warning: " + format.replace(/%s/g, function () {
+ return args[argIndex++];
+ });
+
+ if (typeof console !== "undefined") {
+ console.warn(message);
+ }
+
+ try {
+ throw new Error(message);
+ } catch (x) {}
+ };
+
+ lowPriorityWarning = function lowPriorityWarning(condition, format) {
+ if (format === undefined) {
+ throw new Error("`lowPriorityWarning(condition, format, ...args)` requires a warning " + "message argument");
+ }
+
+ if (!condition) {
+ for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
+ args[_key2 - 2] = arguments[_key2];
+ }
+
+ printWarning.apply(undefined, [format].concat(args));
+ }
+ };
+ }
+ var lowPriorityWarning$1 = lowPriorityWarning;
+ var ReactStrictModeWarnings = {
+ 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 lifecyclesWarningMessages = [];
+ 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.type) || "Component");
+ didWarnAboutUnsafeLifecycles.add(fiber.type);
+ });
+ var formatted = lifecycle.replace("UNSAFE_", "");
+ var suggestion = LIFECYCLE_SUGGESTIONS[lifecycle];
+ var sortedComponentNames = setToSortedString(componentNames);
+ lifecyclesWarningMessages.push(formatted + ": Please update the following components to use " + (suggestion + " instead: " + sortedComponentNames));
+ }
+ });
+
+ if (lifecyclesWarningMessages.length > 0) {
+ var strictRootComponentStack = getStackByFiberInDevAndProd(strictRoot);
+ warningWithoutStack$1(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, lifecyclesWarningMessages.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.type) || "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.type) || "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.type) || "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) {
+ warningWithoutStack$1(false, "Expected to find a StrictMode component in a strict mode tree. " + "This error is likely caused by a bug in React. Please file an issue.");
+ return;
+ }
+
+ if (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) {
+ warningWithoutStack$1(false, "Expected to find a StrictMode component in a strict mode tree. " + "This error is likely caused by a bug in React. Please file an issue.");
+ return;
+ }
+
+ if (didWarnAboutLegacyContext.has(fiber.type)) {
+ return;
+ }
+
+ var warningsForRoot = pendingLegacyContextWarning.get(strictRoot);
+
+ if (fiber.type.contextTypes != null || fiber.type.childContextTypes != null || instance !== null && typeof instance.getChildContext === "function") {
+ if (warningsForRoot === undefined) {
+ warningsForRoot = [];
+ pendingLegacyContextWarning.set(strictRoot, warningsForRoot);
+ }
+
+ warningsForRoot.push(fiber);
+ }
+ };
+
+ ReactStrictModeWarnings.flushLegacyContextWarning = function () {
+ pendingLegacyContextWarning.forEach(function (fiberArray, strictRoot) {
+ var uniqueNames = new Set();
+ fiberArray.forEach(function (fiber) {
+ uniqueNames.add(getComponentName(fiber.type) || "Component");
+ didWarnAboutLegacyContext.add(fiber.type);
+ });
+ var sortedNames = setToSortedString(uniqueNames);
+ var strictRootComponentStack = getStackByFiberInDevAndProd(strictRoot);
+ warningWithoutStack$1(false, "Legacy context API has been detected within a strict-mode tree: %s" + "\n\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;
+ }
+ }
+ }
+
+ findNextExpirationTimeToWorkOn(expirationTime, root);
+ }
+
+ function markCommittedPriorityLevels(root, earliestRemainingTime) {
+ root.didError = false;
+
+ if (earliestRemainingTime === NoWork) {
+ root.earliestPendingTime = NoWork;
+ root.latestPendingTime = NoWork;
+ root.earliestSuspendedTime = NoWork;
+ root.latestSuspendedTime = NoWork;
+ root.latestPingedTime = NoWork;
+ findNextExpirationTimeToWorkOn(NoWork, root);
+ return;
+ }
+
+ if (earliestRemainingTime < root.latestPingedTime) {
+ root.latestPingedTime = NoWork;
+ }
+
+ 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);
+ findNextExpirationTimeToWorkOn(NoWork, root);
+ return;
+ }
+
+ var latestSuspendedTime = root.latestSuspendedTime;
+
+ if (earliestRemainingTime < latestSuspendedTime) {
+ root.earliestSuspendedTime = NoWork;
+ root.latestSuspendedTime = NoWork;
+ root.latestPingedTime = NoWork;
+ markPendingPriorityLevel(root, earliestRemainingTime);
+ findNextExpirationTimeToWorkOn(NoWork, root);
+ return;
+ }
+
+ if (earliestRemainingTime > earliestSuspendedTime) {
+ markPendingPriorityLevel(root, earliestRemainingTime);
+ findNextExpirationTimeToWorkOn(NoWork, root);
+ return;
+ }
+
+ findNextExpirationTimeToWorkOn(NoWork, root);
+ }
+
+ function hasLowerPriorityWork(root, erroredExpirationTime) {
+ var latestPendingTime = root.latestPendingTime;
+ var latestSuspendedTime = root.latestSuspendedTime;
+ var latestPingedTime = root.latestPingedTime;
+ return latestPendingTime !== NoWork && latestPendingTime < erroredExpirationTime || latestSuspendedTime !== NoWork && latestSuspendedTime < erroredExpirationTime || latestPingedTime !== NoWork && latestPingedTime < erroredExpirationTime;
+ }
+
+ function isPriorityLevelSuspended(root, expirationTime) {
+ var earliestSuspendedTime = root.earliestSuspendedTime;
+ var latestSuspendedTime = root.latestSuspendedTime;
+ return earliestSuspendedTime !== NoWork && expirationTime <= earliestSuspendedTime && expirationTime >= latestSuspendedTime;
+ }
+
+ function markSuspendedPriorityLevel(root, suspendedTime) {
+ root.didError = false;
+ clearPing(root, suspendedTime);
+ 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 earliestSuspendedTime = root.earliestSuspendedTime;
+ var latestSuspendedTime = root.latestSuspendedTime;
+
+ if (earliestSuspendedTime === NoWork) {
+ root.earliestSuspendedTime = root.latestSuspendedTime = suspendedTime;
+ } else {
+ if (earliestSuspendedTime < suspendedTime) {
+ root.earliestSuspendedTime = suspendedTime;
+ } else if (latestSuspendedTime > suspendedTime) {
+ root.latestSuspendedTime = suspendedTime;
+ }
+ }
+
+ findNextExpirationTimeToWorkOn(suspendedTime, root);
+ }
+
+ function markPingedPriorityLevel(root, pingedTime) {
+ root.didError = false;
+ var latestPingedTime = root.latestPingedTime;
+
+ if (latestPingedTime === NoWork || latestPingedTime > pingedTime) {
+ root.latestPingedTime = pingedTime;
+ }
+
+ findNextExpirationTimeToWorkOn(pingedTime, root);
+ }
+
+ function clearPing(root, completedTime) {
+ var latestPingedTime = root.latestPingedTime;
+
+ if (latestPingedTime >= completedTime) {
+ root.latestPingedTime = NoWork;
+ }
+ }
+
+ function findEarliestOutstandingPriorityLevel(root, renderExpirationTime) {
+ var earliestExpirationTime = renderExpirationTime;
+ var earliestPendingTime = root.earliestPendingTime;
+ var earliestSuspendedTime = root.earliestSuspendedTime;
+
+ if (earliestPendingTime > earliestExpirationTime) {
+ earliestExpirationTime = earliestPendingTime;
+ }
+
+ if (earliestSuspendedTime > earliestExpirationTime) {
+ earliestExpirationTime = earliestSuspendedTime;
+ }
+
+ return earliestExpirationTime;
+ }
+
+ function didExpireAtExpirationTime(root, currentTime) {
+ var expirationTime = root.expirationTime;
+
+ if (expirationTime !== NoWork && currentTime <= expirationTime) {
+ root.nextExpirationTimeToWorkOn = currentTime;
+ }
+ }
+
+ function findNextExpirationTimeToWorkOn(completedExpirationTime, root) {
+ var earliestSuspendedTime = root.earliestSuspendedTime;
+ var latestSuspendedTime = root.latestSuspendedTime;
+ var earliestPendingTime = root.earliestPendingTime;
+ var latestPingedTime = root.latestPingedTime;
+ var nextExpirationTimeToWorkOn = earliestPendingTime !== NoWork ? earliestPendingTime : latestPingedTime;
+
+ if (nextExpirationTimeToWorkOn === NoWork && (completedExpirationTime === NoWork || latestSuspendedTime < completedExpirationTime)) {
+ nextExpirationTimeToWorkOn = latestSuspendedTime;
+ }
+
+ var expirationTime = nextExpirationTimeToWorkOn;
+
+ if (expirationTime !== NoWork && earliestSuspendedTime > expirationTime) {
+ expirationTime = earliestSuspendedTime;
+ }
+
+ root.nextExpirationTimeToWorkOn = nextExpirationTimeToWorkOn;
+ root.expirationTime = expirationTime;
+ }
+
+ var warning = warningWithoutStack$1;
+ {
+ warning = function warning(condition, format) {
+ if (condition) {
+ return;
+ }
+
+ var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+ var stack = ReactDebugCurrentFrame.getStackAddendum();
+
+ for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+ args[_key - 2] = arguments[_key];
+ }
+
+ warningWithoutStack$1.apply(undefined, [false, format + "%s"].concat(args, [stack]));
+ };
+ }
+ var warning$1 = warning;
+
+ function is(x, y) {
+ return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y;
+ }
+
+ var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+ function shallowEqual(objA, objB) {
+ if (is(objA, objB)) {
+ return true;
+ }
+
+ if (typeof objA !== "object" || objA === null || typeof objB !== "object" || objB === null) {
+ return false;
+ }
+
+ var keysA = Object.keys(objA);
+ var keysB = Object.keys(objB);
+
+ if (keysA.length !== keysB.length) {
+ return false;
+ }
+
+ for (var i = 0; i < keysA.length; i++) {
+ if (!hasOwnProperty.call(objB, keysA[i]) || !is(objA[keysA[i]], objB[keysA[i]])) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ function resolveDefaultProps(Component, baseProps) {
+ if (Component && Component.defaultProps) {
+ var props = _extends({}, baseProps);
+
+ var defaultProps = Component.defaultProps;
+
+ for (var propName in defaultProps) {
+ if (props[propName] === undefined) {
+ props[propName] = defaultProps[propName];
+ }
+ }
+
+ return props;
+ }
+
+ return baseProps;
+ }
+
+ function readLazyComponentType(lazyComponent) {
+ var status = lazyComponent._status;
+ var result = lazyComponent._result;
+
+ switch (status) {
+ case Resolved:
+ {
+ var Component = result;
+ return Component;
+ }
+
+ case Rejected:
+ {
+ var error = result;
+ throw error;
+ }
+
+ case Pending:
+ {
+ var thenable = result;
+ throw thenable;
+ }
+
+ default:
+ {
+ lazyComponent._status = Pending;
+ var ctor = lazyComponent._ctor;
+
+ var _thenable = ctor();
+
+ _thenable.then(function (moduleObject) {
+ if (lazyComponent._status === Pending) {
+ var defaultExport = moduleObject.default;
+ {
+ if (defaultExport === undefined) {
+ warning$1(false, "lazy: Expected the result of a dynamic import() call. " + "Instead received: %s\n\nYour code should look like: \n " + "const MyComponent = lazy(() => import('./MyComponent'))", moduleObject);
+ }
+ }
+ lazyComponent._status = Resolved;
+ lazyComponent._result = defaultExport;
+ }
+ }, function (error) {
+ if (lazyComponent._status === Pending) {
+ lazyComponent._status = Rejected;
+ lazyComponent._result = error;
+ }
+ });
+
+ switch (lazyComponent._status) {
+ case Resolved:
+ return lazyComponent._result;
+
+ case Rejected:
+ throw lazyComponent._result;
+ }
+
+ lazyComponent._result = _thenable;
+ throw _thenable;
+ }
+ }
+ }
+
+ var fakeInternalInstance = {};
+ var isArray$1 = Array.isArray;
+ var emptyRefsObject = new React.Component().refs;
+ var didWarnAboutStateAssignmentForComponent = void 0;
+ var didWarnAboutUninitializedState = void 0;
+ var didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate = void 0;
+ var didWarnAboutLegacyLifecyclesAndDerivedState = void 0;
+ var didWarnAboutUndefinedDerivedState = void 0;
+ var warnOnUndefinedDerivedState = void 0;
+ var warnOnInvalidCallback = void 0;
+ var didWarnAboutDirectlyAssigningPropsToState = void 0;
+ var didWarnAboutContextTypeAndContextTypes = void 0;
+ var didWarnAboutInvalidateContextType = void 0;
+ {
+ didWarnAboutStateAssignmentForComponent = new Set();
+ didWarnAboutUninitializedState = new Set();
+ didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate = new Set();
+ didWarnAboutLegacyLifecyclesAndDerivedState = new Set();
+ didWarnAboutDirectlyAssigningPropsToState = new Set();
+ didWarnAboutUndefinedDerivedState = new Set();
+ didWarnAboutContextTypeAndContextTypes = new Set();
+ didWarnAboutInvalidateContextType = new Set();
+ var didWarnOnInvalidCallback = new Set();
+
+ warnOnInvalidCallback = function warnOnInvalidCallback(callback, callerName) {
+ if (callback === null || typeof callback === "function") {
+ return;
+ }
+
+ var key = callerName + "_" + callback;
+
+ if (!didWarnOnInvalidCallback.has(key)) {
+ didWarnOnInvalidCallback.add(key);
+ warningWithoutStack$1(false, "%s(...): Expected the last optional `callback` argument to be a " + "function. Instead received: %s.", callerName, callback);
+ }
+ };
+
+ warnOnUndefinedDerivedState = function warnOnUndefinedDerivedState(type, partialState) {
+ if (partialState === undefined) {
+ var componentName = getComponentName(type) || "Component";
+
+ if (!didWarnAboutUndefinedDerivedState.has(componentName)) {
+ didWarnAboutUndefinedDerivedState.add(componentName);
+ warningWithoutStack$1(false, "%s.getDerivedStateFromProps(): A valid state object (or null) must be returned. " + "You have returned undefined.", componentName);
+ }
+ }
+ };
+
+ Object.defineProperty(fakeInternalInstance, "_processChildContext", {
+ enumerable: false,
+ value: function value() {
+ 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, ctor, getDerivedStateFromProps, nextProps) {
+ var prevState = workInProgress.memoizedState;
+ {
+ if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
+ getDerivedStateFromProps(nextProps, prevState);
+ }
+ }
+ var partialState = getDerivedStateFromProps(nextProps, prevState);
+ {
+ warnOnUndefinedDerivedState(ctor, partialState);
+ }
+ var memoizedState = partialState === null || partialState === undefined ? prevState : _extends({}, prevState, partialState);
+ workInProgress.memoizedState = memoizedState;
+ var updateQueue = workInProgress.updateQueue;
+
+ if (updateQueue !== null && workInProgress.expirationTime === NoWork) {
+ updateQueue.baseState = memoizedState;
+ }
+ }
+
+ var classComponentUpdater = {
+ isMounted: isMounted,
+ enqueueSetState: function enqueueSetState(inst, payload, callback) {
+ var fiber = get$1(inst);
+ var currentTime = requestCurrentTime();
+ var expirationTime = computeExpirationForFiber(currentTime, fiber);
+ var update = createUpdate(expirationTime);
+ update.payload = payload;
+
+ if (callback !== undefined && callback !== null) {
+ {
+ warnOnInvalidCallback(callback, "setState");
+ }
+ update.callback = callback;
+ }
+
+ flushPassiveEffects();
+ enqueueUpdate(fiber, update);
+ scheduleWork(fiber, expirationTime);
+ },
+ enqueueReplaceState: function enqueueReplaceState(inst, payload, callback) {
+ var fiber = get$1(inst);
+ var currentTime = requestCurrentTime();
+ 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;
+ }
+
+ flushPassiveEffects();
+ enqueueUpdate(fiber, update);
+ scheduleWork(fiber, expirationTime);
+ },
+ enqueueForceUpdate: function enqueueForceUpdate(inst, callback) {
+ var fiber = get$1(inst);
+ var currentTime = requestCurrentTime();
+ var expirationTime = computeExpirationForFiber(currentTime, fiber);
+ var update = createUpdate(expirationTime);
+ update.tag = ForceUpdate;
+
+ if (callback !== undefined && callback !== null) {
+ {
+ warnOnInvalidCallback(callback, "forceUpdate");
+ }
+ update.callback = callback;
+ }
+
+ flushPassiveEffects();
+ enqueueUpdate(fiber, update);
+ scheduleWork(fiber, expirationTime);
+ }
+ };
+
+ function checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext) {
+ var instance = workInProgress.stateNode;
+
+ if (typeof instance.shouldComponentUpdate === "function") {
+ startPhaseTimer(workInProgress, "shouldComponentUpdate");
+ var shouldUpdate = instance.shouldComponentUpdate(newProps, newState, nextContext);
+ stopPhaseTimer();
+ {
+ !(shouldUpdate !== undefined) ? warningWithoutStack$1(false, "%s.shouldComponentUpdate(): Returned undefined instead of a " + "boolean value. Make sure to return true or false.", getComponentName(ctor) || "Component") : void 0;
+ }
+ return shouldUpdate;
+ }
+
+ if (ctor.prototype && ctor.prototype.isPureReactComponent) {
+ return !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState);
+ }
+
+ return true;
+ }
+
+ function checkClassInstance(workInProgress, ctor, newProps) {
+ var instance = workInProgress.stateNode;
+ {
+ var name = getComponentName(ctor) || "Component";
+ var renderPresent = instance.render;
+
+ if (!renderPresent) {
+ if (ctor.prototype && typeof ctor.prototype.render === "function") {
+ warningWithoutStack$1(false, "%s(...): No `render` method found on the returned component " + "instance: did you accidentally return an object from the constructor?", name);
+ } else {
+ warningWithoutStack$1(false, "%s(...): No `render` method found on the returned component " + "instance: you may have forgotten to define `render`.", name);
+ }
+ }
+
+ var noGetInitialStateOnES6 = !instance.getInitialState || instance.getInitialState.isReactClassApproved || instance.state;
+ !noGetInitialStateOnES6 ? warningWithoutStack$1(false, "getInitialState was defined on %s, a plain JavaScript class. " + "This is only supported for classes created using React.createClass. " + "Did you mean to define a state property instead?", name) : void 0;
+ var noGetDefaultPropsOnES6 = !instance.getDefaultProps || instance.getDefaultProps.isReactClassApproved;
+ !noGetDefaultPropsOnES6 ? warningWithoutStack$1(false, "getDefaultProps was defined on %s, a plain JavaScript class. " + "This is only supported for classes created using React.createClass. " + "Use a static property to define defaultProps instead.", name) : void 0;
+ var noInstancePropTypes = !instance.propTypes;
+ !noInstancePropTypes ? warningWithoutStack$1(false, "propTypes was defined as an instance property on %s. Use a static " + "property to define propTypes instead.", name) : void 0;
+ var noInstanceContextType = !instance.contextType;
+ !noInstanceContextType ? warningWithoutStack$1(false, "contextType was defined as an instance property on %s. Use a static " + "property to define contextType instead.", name) : void 0;
+ var noInstanceContextTypes = !instance.contextTypes;
+ !noInstanceContextTypes ? warningWithoutStack$1(false, "contextTypes was defined as an instance property on %s. Use a static " + "property to define contextTypes instead.", name) : void 0;
+
+ if (ctor.contextType && ctor.contextTypes && !didWarnAboutContextTypeAndContextTypes.has(ctor)) {
+ didWarnAboutContextTypeAndContextTypes.add(ctor);
+ warningWithoutStack$1(false, "%s declares both contextTypes and contextType static properties. " + "The legacy contextTypes property will be ignored.", name);
+ }
+
+ var noComponentShouldUpdate = typeof instance.componentShouldUpdate !== "function";
+ !noComponentShouldUpdate ? warningWithoutStack$1(false, "%s has a method called " + "componentShouldUpdate(). Did you mean shouldComponentUpdate()? " + "The name is phrased as a question because the function is " + "expected to return a value.", name) : void 0;
+
+ if (ctor.prototype && ctor.prototype.isPureReactComponent && typeof instance.shouldComponentUpdate !== "undefined") {
+ warningWithoutStack$1(false, "%s has a method called shouldComponentUpdate(). " + "shouldComponentUpdate should not be used when extending React.PureComponent. " + "Please extend React.Component if shouldComponentUpdate is used.", getComponentName(ctor) || "A pure component");
+ }
+
+ var noComponentDidUnmount = typeof instance.componentDidUnmount !== "function";
+ !noComponentDidUnmount ? warningWithoutStack$1(false, "%s has a method called " + "componentDidUnmount(). But there is no such lifecycle method. " + "Did you mean componentWillUnmount()?", name) : void 0;
+ var noComponentDidReceiveProps = typeof instance.componentDidReceiveProps !== "function";
+ !noComponentDidReceiveProps ? warningWithoutStack$1(false, "%s has a method called " + "componentDidReceiveProps(). But there is no such lifecycle method. " + "If you meant to update the state in response to changing props, " + "use componentWillReceiveProps(). If you meant to fetch data or " + "run side-effects or mutations after React has updated the UI, use componentDidUpdate().", name) : void 0;
+ var noComponentWillRecieveProps = typeof instance.componentWillRecieveProps !== "function";
+ !noComponentWillRecieveProps ? warningWithoutStack$1(false, "%s has a method called " + "componentWillRecieveProps(). Did you mean componentWillReceiveProps()?", name) : void 0;
+ var noUnsafeComponentWillRecieveProps = typeof instance.UNSAFE_componentWillRecieveProps !== "function";
+ !noUnsafeComponentWillRecieveProps ? warningWithoutStack$1(false, "%s has a method called " + "UNSAFE_componentWillRecieveProps(). Did you mean UNSAFE_componentWillReceiveProps()?", name) : void 0;
+ var hasMutatedProps = instance.props !== newProps;
+ !(instance.props === undefined || !hasMutatedProps) ? warningWithoutStack$1(false, "%s(...): When calling super() in `%s`, make sure to pass " + "up the same props that your component's constructor was passed.", name, name) : void 0;
+ var noInstanceDefaultProps = !instance.defaultProps;
+ !noInstanceDefaultProps ? warningWithoutStack$1(false, "Setting defaultProps as an instance property on %s is not supported and will be ignored." + " Instead, define defaultProps as a static property on %s.", name, name) : void 0;
+
+ if (typeof instance.getSnapshotBeforeUpdate === "function" && typeof instance.componentDidUpdate !== "function" && !didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.has(ctor)) {
+ didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.add(ctor);
+ warningWithoutStack$1(false, "%s: getSnapshotBeforeUpdate() should be used with componentDidUpdate(). " + "This component defines getSnapshotBeforeUpdate() only.", getComponentName(ctor));
+ }
+
+ var noInstanceGetDerivedStateFromProps = typeof instance.getDerivedStateFromProps !== "function";
+ !noInstanceGetDerivedStateFromProps ? warningWithoutStack$1(false, "%s: getDerivedStateFromProps() is defined as an instance method " + "and will be ignored. Instead, declare it as a static method.", name) : void 0;
+ var noInstanceGetDerivedStateFromCatch = typeof instance.getDerivedStateFromError !== "function";
+ !noInstanceGetDerivedStateFromCatch ? warningWithoutStack$1(false, "%s: getDerivedStateFromError() is defined as an instance method " + "and will be ignored. Instead, declare it as a static method.", name) : void 0;
+ var noStaticGetSnapshotBeforeUpdate = typeof ctor.getSnapshotBeforeUpdate !== "function";
+ !noStaticGetSnapshotBeforeUpdate ? warningWithoutStack$1(false, "%s: getSnapshotBeforeUpdate() is defined as a static method " + "and will be ignored. Instead, declare it as an instance method.", name) : void 0;
+ var _state = instance.state;
+
+ if (_state && (typeof _state !== "object" || isArray$1(_state))) {
+ warningWithoutStack$1(false, "%s.state: must be set to an object or null", name);
+ }
+
+ if (typeof instance.getChildContext === "function") {
+ !(typeof ctor.childContextTypes === "object") ? warningWithoutStack$1(false, "%s.getChildContext(): childContextTypes must be defined in order to " + "use getChildContext().", name) : void 0;
+ }
+ }
+ }
+
+ function adoptClassInstance(workInProgress, instance) {
+ instance.updater = classComponentUpdater;
+ workInProgress.stateNode = instance;
+ set(instance, workInProgress);
+ {
+ instance._reactInternalInstance = fakeInternalInstance;
+ }
+ }
+
+ function constructClassInstance(workInProgress, ctor, props, renderExpirationTime) {
+ var isLegacyContextConsumer = false;
+ var unmaskedContext = emptyContextObject;
+ var context = null;
+ var contextType = ctor.contextType;
+
+ if (typeof contextType === "object" && contextType !== null) {
+ {
+ if (contextType.$$typeof !== REACT_CONTEXT_TYPE && !didWarnAboutInvalidateContextType.has(ctor)) {
+ didWarnAboutInvalidateContextType.add(ctor);
+ warningWithoutStack$1(false, "%s defines an invalid contextType. " + "contextType should point to the Context object returned by React.createContext(). " + "Did you accidentally pass the Context.Provider instead?", getComponentName(ctor) || "Component");
+ }
+ }
+ context = _readContext(contextType);
+ } else {
+ unmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
+ var contextTypes = ctor.contextTypes;
+ isLegacyContextConsumer = contextTypes !== null && contextTypes !== undefined;
+ context = isLegacyContextConsumer ? getMaskedContext(workInProgress, unmaskedContext) : emptyContextObject;
+ }
+
+ {
+ if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
+ new ctor(props, context);
+ }
+ }
+ var instance = new ctor(props, context);
+ var state = workInProgress.memoizedState = instance.state !== null && instance.state !== undefined ? instance.state : null;
+ adoptClassInstance(workInProgress, instance);
+ {
+ if (typeof ctor.getDerivedStateFromProps === "function" && state === null) {
+ var componentName = getComponentName(ctor) || "Component";
+
+ if (!didWarnAboutUninitializedState.has(componentName)) {
+ didWarnAboutUninitializedState.add(componentName);
+ warningWithoutStack$1(false, "`%s` uses `getDerivedStateFromProps` but its initial state is " + "%s. This is not recommended. Instead, define the initial state by " + "assigning an object to `this.state` in the constructor of `%s`. " + "This ensures that `getDerivedStateFromProps` arguments have a consistent shape.", componentName, instance.state === null ? "null" : "undefined", componentName);
+ }
+ }
+
+ if (typeof ctor.getDerivedStateFromProps === "function" || typeof instance.getSnapshotBeforeUpdate === "function") {
+ var foundWillMountName = null;
+ var foundWillReceivePropsName = null;
+ var foundWillUpdateName = null;
+
+ if (typeof instance.componentWillMount === "function" && instance.componentWillMount.__suppressDeprecationWarning !== true) {
+ foundWillMountName = "componentWillMount";
+ } else if (typeof instance.UNSAFE_componentWillMount === "function") {
+ foundWillMountName = "UNSAFE_componentWillMount";
+ }
+
+ if (typeof instance.componentWillReceiveProps === "function" && instance.componentWillReceiveProps.__suppressDeprecationWarning !== true) {
+ foundWillReceivePropsName = "componentWillReceiveProps";
+ } else if (typeof instance.UNSAFE_componentWillReceiveProps === "function") {
+ foundWillReceivePropsName = "UNSAFE_componentWillReceiveProps";
+ }
+
+ if (typeof instance.componentWillUpdate === "function" && instance.componentWillUpdate.__suppressDeprecationWarning !== true) {
+ foundWillUpdateName = "componentWillUpdate";
+ } else if (typeof instance.UNSAFE_componentWillUpdate === "function") {
+ foundWillUpdateName = "UNSAFE_componentWillUpdate";
+ }
+
+ if (foundWillMountName !== null || foundWillReceivePropsName !== null || foundWillUpdateName !== null) {
+ var _componentName = getComponentName(ctor) || "Component";
+
+ var newApiName = typeof ctor.getDerivedStateFromProps === "function" ? "getDerivedStateFromProps()" : "getSnapshotBeforeUpdate()";
+
+ if (!didWarnAboutLegacyLifecyclesAndDerivedState.has(_componentName)) {
+ didWarnAboutLegacyLifecyclesAndDerivedState.add(_componentName);
+ warningWithoutStack$1(false, "Unsafe legacy lifecycles will not be called for components using new component APIs.\n\n" + "%s uses %s but also contains the following legacy lifecycles:%s%s%s\n\n" + "The above lifecycles should be removed. Learn more about this warning here:\n" + "https://fb.me/react-async-component-lifecycle-hooks", _componentName, newApiName, foundWillMountName !== null ? "\n " + foundWillMountName : "", foundWillReceivePropsName !== null ? "\n " + foundWillReceivePropsName : "", foundWillUpdateName !== null ? "\n " + foundWillUpdateName : "");
+ }
+ }
+ }
+ }
+
+ if (isLegacyContextConsumer) {
+ cacheContext(workInProgress, unmaskedContext, context);
+ }
+
+ return instance;
+ }
+
+ function callComponentWillMount(workInProgress, instance) {
+ startPhaseTimer(workInProgress, "componentWillMount");
+ var oldState = instance.state;
+
+ if (typeof instance.componentWillMount === "function") {
+ instance.componentWillMount();
+ }
+
+ if (typeof instance.UNSAFE_componentWillMount === "function") {
+ instance.UNSAFE_componentWillMount();
+ }
+
+ stopPhaseTimer();
+
+ if (oldState !== instance.state) {
+ {
+ warningWithoutStack$1(false, "%s.componentWillMount(): Assigning directly to this.state is " + "deprecated (except inside a component's " + "constructor). Use setState instead.", getComponentName(workInProgress.type) || "Component");
+ }
+ classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
+ }
+ }
+
+ function callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext) {
+ var oldState = instance.state;
+ startPhaseTimer(workInProgress, "componentWillReceiveProps");
+
+ if (typeof instance.componentWillReceiveProps === "function") {
+ instance.componentWillReceiveProps(newProps, nextContext);
+ }
+
+ if (typeof instance.UNSAFE_componentWillReceiveProps === "function") {
+ instance.UNSAFE_componentWillReceiveProps(newProps, nextContext);
+ }
+
+ stopPhaseTimer();
+
+ if (instance.state !== oldState) {
+ {
+ var componentName = getComponentName(workInProgress.type) || "Component";
+
+ if (!didWarnAboutStateAssignmentForComponent.has(componentName)) {
+ didWarnAboutStateAssignmentForComponent.add(componentName);
+ warningWithoutStack$1(false, "%s.componentWillReceiveProps(): Assigning directly to " + "this.state is deprecated (except inside a component's " + "constructor). Use setState instead.", componentName);
+ }
+ }
+ classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
+ }
+ }
+
+ function mountClassInstance(workInProgress, ctor, newProps, renderExpirationTime) {
+ {
+ checkClassInstance(workInProgress, ctor, newProps);
+ }
+ var instance = workInProgress.stateNode;
+ instance.props = newProps;
+ instance.state = workInProgress.memoizedState;
+ instance.refs = emptyRefsObject;
+ var contextType = ctor.contextType;
+
+ if (typeof contextType === "object" && contextType !== null) {
+ instance.context = _readContext(contextType);
+ } else {
+ var unmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
+ instance.context = getMaskedContext(workInProgress, unmaskedContext);
+ }
+
+ {
+ if (instance.state === newProps) {
+ var componentName = getComponentName(ctor) || "Component";
+
+ if (!didWarnAboutDirectlyAssigningPropsToState.has(componentName)) {
+ didWarnAboutDirectlyAssigningPropsToState.add(componentName);
+ warningWithoutStack$1(false, "%s: It is not recommended to assign props directly to state " + "because updates to props won't be reflected in state. " + "In most cases, it is better to use props directly.", componentName);
+ }
+ }
+
+ if (workInProgress.mode & StrictMode) {
+ ReactStrictModeWarnings.recordUnsafeLifecycleWarnings(workInProgress, instance);
+ ReactStrictModeWarnings.recordLegacyContextWarning(workInProgress, instance);
+ }
+
+ if (warnAboutDeprecatedLifecycles) {
+ ReactStrictModeWarnings.recordDeprecationWarnings(workInProgress, instance);
+ }
+ }
+ var updateQueue = workInProgress.updateQueue;
+
+ if (updateQueue !== null) {
+ processUpdateQueue(workInProgress, updateQueue, newProps, instance, renderExpirationTime);
+ instance.state = workInProgress.memoizedState;
+ }
+
+ var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+
+ if (typeof getDerivedStateFromProps === "function") {
+ applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, newProps);
+ instance.state = workInProgress.memoizedState;
+ }
+
+ if (typeof ctor.getDerivedStateFromProps !== "function" && typeof instance.getSnapshotBeforeUpdate !== "function" && (typeof instance.UNSAFE_componentWillMount === "function" || typeof instance.componentWillMount === "function")) {
+ callComponentWillMount(workInProgress, instance);
+ updateQueue = workInProgress.updateQueue;
+
+ if (updateQueue !== null) {
+ processUpdateQueue(workInProgress, updateQueue, newProps, instance, renderExpirationTime);
+ instance.state = workInProgress.memoizedState;
+ }
+ }
+
+ if (typeof instance.componentDidMount === "function") {
+ workInProgress.effectTag |= Update;
+ }
+ }
+
+ function resumeMountClassInstance(workInProgress, ctor, newProps, renderExpirationTime) {
+ var instance = workInProgress.stateNode;
+ var oldProps = workInProgress.memoizedProps;
+ instance.props = oldProps;
+ var oldContext = instance.context;
+ var contextType = ctor.contextType;
+ var nextContext = void 0;
+
+ if (typeof contextType === "object" && contextType !== null) {
+ nextContext = _readContext(contextType);
+ } else {
+ var nextLegacyUnmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
+ nextContext = getMaskedContext(workInProgress, nextLegacyUnmaskedContext);
+ }
+
+ var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+ var hasNewLifecycles = typeof getDerivedStateFromProps === "function" || typeof instance.getSnapshotBeforeUpdate === "function";
+
+ if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillReceiveProps === "function" || typeof instance.componentWillReceiveProps === "function")) {
+ if (oldProps !== newProps || oldContext !== nextContext) {
+ callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext);
+ }
+ }
+
+ resetHasForceUpdateBeforeProcessing();
+ var oldState = workInProgress.memoizedState;
+ var newState = instance.state = oldState;
+ var updateQueue = workInProgress.updateQueue;
+
+ if (updateQueue !== null) {
+ processUpdateQueue(workInProgress, updateQueue, newProps, instance, renderExpirationTime);
+ newState = workInProgress.memoizedState;
+ }
+
+ if (oldProps === newProps && oldState === newState && !hasContextChanged() && !checkHasForceUpdateAfterProcessing()) {
+ if (typeof instance.componentDidMount === "function") {
+ workInProgress.effectTag |= Update;
+ }
+
+ return false;
+ }
+
+ if (typeof getDerivedStateFromProps === "function") {
+ applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, newProps);
+ newState = workInProgress.memoizedState;
+ }
+
+ var shouldUpdate = checkHasForceUpdateAfterProcessing() || checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext);
+
+ if (shouldUpdate) {
+ if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillMount === "function" || typeof instance.componentWillMount === "function")) {
+ startPhaseTimer(workInProgress, "componentWillMount");
+
+ if (typeof instance.componentWillMount === "function") {
+ instance.componentWillMount();
+ }
+
+ if (typeof instance.UNSAFE_componentWillMount === "function") {
+ instance.UNSAFE_componentWillMount();
+ }
+
+ stopPhaseTimer();
+ }
+
+ if (typeof instance.componentDidMount === "function") {
+ workInProgress.effectTag |= Update;
+ }
+ } else {
+ if (typeof instance.componentDidMount === "function") {
+ workInProgress.effectTag |= Update;
+ }
+
+ workInProgress.memoizedProps = newProps;
+ workInProgress.memoizedState = newState;
+ }
+
+ instance.props = newProps;
+ instance.state = newState;
+ instance.context = nextContext;
+ return shouldUpdate;
+ }
+
+ function updateClassInstance(current, workInProgress, ctor, newProps, renderExpirationTime) {
+ var instance = workInProgress.stateNode;
+ var oldProps = workInProgress.memoizedProps;
+ instance.props = workInProgress.type === workInProgress.elementType ? oldProps : resolveDefaultProps(workInProgress.type, oldProps);
+ var oldContext = instance.context;
+ var contextType = ctor.contextType;
+ var nextContext = void 0;
+
+ if (typeof contextType === "object" && contextType !== null) {
+ nextContext = _readContext(contextType);
+ } else {
+ var nextUnmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
+ nextContext = getMaskedContext(workInProgress, nextUnmaskedContext);
+ }
+
+ var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+ var hasNewLifecycles = typeof getDerivedStateFromProps === "function" || typeof instance.getSnapshotBeforeUpdate === "function";
+
+ if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillReceiveProps === "function" || typeof instance.componentWillReceiveProps === "function")) {
+ if (oldProps !== newProps || oldContext !== nextContext) {
+ callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext);
+ }
+ }
+
+ resetHasForceUpdateBeforeProcessing();
+ var oldState = workInProgress.memoizedState;
+ var newState = instance.state = oldState;
+ var updateQueue = workInProgress.updateQueue;
+
+ if (updateQueue !== null) {
+ processUpdateQueue(workInProgress, updateQueue, newProps, instance, renderExpirationTime);
+ newState = workInProgress.memoizedState;
+ }
+
+ if (oldProps === newProps && oldState === newState && !hasContextChanged() && !checkHasForceUpdateAfterProcessing()) {
+ if (typeof instance.componentDidUpdate === "function") {
+ if (oldProps !== current.memoizedProps || oldState !== current.memoizedState) {
+ workInProgress.effectTag |= Update;
+ }
+ }
+
+ if (typeof instance.getSnapshotBeforeUpdate === "function") {
+ if (oldProps !== current.memoizedProps || oldState !== current.memoizedState) {
+ workInProgress.effectTag |= Snapshot;
+ }
+ }
+
+ return false;
+ }
+
+ if (typeof getDerivedStateFromProps === "function") {
+ applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, newProps);
+ newState = workInProgress.memoizedState;
+ }
+
+ var shouldUpdate = checkHasForceUpdateAfterProcessing() || checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext);
+
+ if (shouldUpdate) {
+ if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillUpdate === "function" || typeof instance.componentWillUpdate === "function")) {
+ startPhaseTimer(workInProgress, "componentWillUpdate");
+
+ if (typeof instance.componentWillUpdate === "function") {
+ instance.componentWillUpdate(newProps, newState, nextContext);
+ }
+
+ if (typeof instance.UNSAFE_componentWillUpdate === "function") {
+ instance.UNSAFE_componentWillUpdate(newProps, newState, nextContext);
+ }
+
+ stopPhaseTimer();
+ }
+
+ if (typeof instance.componentDidUpdate === "function") {
+ workInProgress.effectTag |= Update;
+ }
+
+ if (typeof instance.getSnapshotBeforeUpdate === "function") {
+ workInProgress.effectTag |= Snapshot;
+ }
+ } else {
+ if (typeof instance.componentDidUpdate === "function") {
+ if (oldProps !== current.memoizedProps || oldState !== current.memoizedState) {
+ workInProgress.effectTag |= Update;
+ }
+ }
+
+ if (typeof instance.getSnapshotBeforeUpdate === "function") {
+ if (oldProps !== current.memoizedProps || oldState !== current.memoizedState) {
+ workInProgress.effectTag |= Snapshot;
+ }
+ }
+
+ workInProgress.memoizedProps = newProps;
+ workInProgress.memoizedState = newState;
+ }
+
+ instance.props = newProps;
+ instance.state = newState;
+ instance.context = nextContext;
+ return shouldUpdate;
+ }
+
+ var didWarnAboutMaps = void 0;
+ var didWarnAboutGenerators = void 0;
+ var didWarnAboutStringRefInStrictMode = void 0;
+ var ownerHasKeyUseWarning = void 0;
+ var ownerHasFunctionTypeWarning = void 0;
+
+ var warnForMissingKey = function warnForMissingKey(child) {};
+
+ {
+ didWarnAboutMaps = false;
+ didWarnAboutGenerators = 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 a list should have a unique " + '"key" prop. See https://fb.me/react-warning-keys for ' + "more information." + getCurrentFiberStackInDev();
+
+ if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {
+ return;
+ }
+
+ ownerHasKeyUseWarning[currentComponentErrorInfo] = true;
+ warning$1(false, "Each child in a list should have a unique " + '"key" prop. See https://fb.me/react-warning-keys for ' + "more information.");
+ };
+ }
+ var isArray = Array.isArray;
+
+ function coerceRef(returnFiber, current$$1, element) {
+ var mixedRef = element.ref;
+
+ if (mixedRef !== null && typeof mixedRef !== "function" && typeof mixedRef !== "object") {
+ {
+ if (returnFiber.mode & StrictMode) {
+ var componentName = getComponentName(returnFiber.type) || "Component";
+
+ if (!didWarnAboutStringRefInStrictMode[componentName]) {
+ warningWithoutStack$1(false, 'A string ref, "%s", has been found within a strict mode tree. ' + "String refs are a source of potential bugs and should be avoided. " + "We recommend using createRef() instead." + "\n%s" + "\n\nLearn more about using refs safely here:" + "\nhttps://fb.me/react-strict-mode-string-ref", mixedRef, getStackByFiberInDevAndProd(returnFiber));
+ didWarnAboutStringRefInStrictMode[componentName] = true;
+ }
+ }
+ }
+
+ if (element._owner) {
+ var owner = element._owner;
+ var inst = void 0;
+
+ if (owner) {
+ var ownerFiber = owner;
+ invariant(ownerFiber.tag === ClassComponent, "Function components cannot have refs. " + "Did you mean to use React.forwardRef()?");
+ 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$$1 !== null && current$$1.ref !== null && typeof current$$1.ref === "function" && current$$1.ref._stringRef === stringRef) {
+ return current$$1.ref;
+ }
+
+ var ref = function ref(value) {
+ var refs = inst.refs;
+
+ if (refs === emptyRefsObject) {
+ refs = inst.refs = {};
+ }
+
+ if (value === null) {
+ delete refs[stringRef];
+ } else {
+ refs[stringRef] = value;
+ }
+ };
+
+ ref._stringRef = stringRef;
+ return ref;
+ } else {
+ invariant(typeof mixedRef === "string", "Expected ref to be a function, a string, an object returned by React.createRef(), or null.");
+ 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 function 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." + getCurrentFiberStackInDev();
+ }
+ 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 from render. " + "Or maybe you meant to call this function rather than return it." + getCurrentFiberStackInDev();
+
+ if (ownerHasFunctionTypeWarning[currentComponentErrorInfo]) {
+ return;
+ }
+
+ ownerHasFunctionTypeWarning[currentComponentErrorInfo] = true;
+ warning$1(false, "Functions are not valid as a React child. This may happen if " + "you return a Component instead of from render. " + "Or maybe you meant to call this function rather than return it.");
+ }
+
+ function ChildReconciler(shouldTrackSideEffects) {
+ function deleteChild(returnFiber, childToDelete) {
+ if (!shouldTrackSideEffects) {
+ return;
+ }
+
+ var last = returnFiber.lastEffect;
+
+ if (last !== null) {
+ last.nextEffect = childToDelete;
+ returnFiber.lastEffect = childToDelete;
+ } else {
+ returnFiber.firstEffect = returnFiber.lastEffect = childToDelete;
+ }
+
+ childToDelete.nextEffect = null;
+ childToDelete.effectTag = Deletion;
+ }
+
+ function deleteRemainingChildren(returnFiber, currentFirstChild) {
+ if (!shouldTrackSideEffects) {
+ return null;
+ }
+
+ var childToDelete = currentFirstChild;
+
+ while (childToDelete !== null) {
+ deleteChild(returnFiber, childToDelete);
+ childToDelete = childToDelete.sibling;
+ }
+
+ return null;
+ }
+
+ function mapRemainingChildren(returnFiber, currentFirstChild) {
+ var existingChildren = new Map();
+ var existingChild = currentFirstChild;
+
+ while (existingChild !== null) {
+ if (existingChild.key !== null) {
+ existingChildren.set(existingChild.key, existingChild);
+ } else {
+ existingChildren.set(existingChild.index, existingChild);
+ }
+
+ existingChild = existingChild.sibling;
+ }
+
+ return existingChildren;
+ }
+
+ function useFiber(fiber, pendingProps, expirationTime) {
+ var clone = createWorkInProgress(fiber, pendingProps, expirationTime);
+ clone.index = 0;
+ clone.sibling = null;
+ return clone;
+ }
+
+ function placeChild(newFiber, lastPlacedIndex, newIndex) {
+ newFiber.index = newIndex;
+
+ if (!shouldTrackSideEffects) {
+ return lastPlacedIndex;
+ }
+
+ var current$$1 = newFiber.alternate;
+
+ if (current$$1 !== null) {
+ var oldIndex = current$$1.index;
+
+ if (oldIndex < lastPlacedIndex) {
+ newFiber.effectTag = Placement;
+ return lastPlacedIndex;
+ } else {
+ return oldIndex;
+ }
+ } else {
+ newFiber.effectTag = Placement;
+ return lastPlacedIndex;
+ }
+ }
+
+ function placeSingleChild(newFiber) {
+ if (shouldTrackSideEffects && newFiber.alternate === null) {
+ newFiber.effectTag = Placement;
+ }
+
+ return newFiber;
+ }
+
+ function updateTextNode(returnFiber, current$$1, textContent, expirationTime) {
+ if (current$$1 === null || current$$1.tag !== HostText) {
+ var created = createFiberFromText(textContent, returnFiber.mode, expirationTime);
+ created.return = returnFiber;
+ return created;
+ } else {
+ var existing = useFiber(current$$1, textContent, expirationTime);
+ existing.return = returnFiber;
+ return existing;
+ }
+ }
+
+ function updateElement(returnFiber, current$$1, element, expirationTime) {
+ if (current$$1 !== null && current$$1.elementType === element.type) {
+ var existing = useFiber(current$$1, element.props, expirationTime);
+ existing.ref = coerceRef(returnFiber, current$$1, element);
+ existing.return = returnFiber;
+ {
+ existing._debugSource = element._source;
+ existing._debugOwner = element._owner;
+ }
+ return existing;
+ } else {
+ var created = createFiberFromElement(element, returnFiber.mode, expirationTime);
+ created.ref = coerceRef(returnFiber, current$$1, element);
+ created.return = returnFiber;
+ return created;
+ }
+ }
+
+ function updatePortal(returnFiber, current$$1, portal, expirationTime) {
+ if (current$$1 === null || current$$1.tag !== HostPortal || current$$1.stateNode.containerInfo !== portal.containerInfo || current$$1.stateNode.implementation !== portal.implementation) {
+ var created = createFiberFromPortal(portal, returnFiber.mode, expirationTime);
+ created.return = returnFiber;
+ return created;
+ } else {
+ var existing = useFiber(current$$1, portal.children || [], expirationTime);
+ existing.return = returnFiber;
+ return existing;
+ }
+ }
+
+ function updateFragment(returnFiber, current$$1, fragment, expirationTime, key) {
+ if (current$$1 === null || current$$1.tag !== Fragment) {
+ var created = createFiberFromFragment(fragment, returnFiber.mode, expirationTime, key);
+ created.return = returnFiber;
+ return created;
+ } else {
+ var existing = useFiber(current$$1, fragment, expirationTime);
+ existing.return = returnFiber;
+ return existing;
+ }
+ }
+
+ function createChild(returnFiber, newChild, expirationTime) {
+ if (typeof newChild === "string" || typeof newChild === "number") {
+ var created = createFiberFromText("" + newChild, returnFiber.mode, expirationTime);
+ created.return = returnFiber;
+ return created;
+ }
+
+ if (typeof newChild === "object" && newChild !== null) {
+ switch (newChild.$$typeof) {
+ case REACT_ELEMENT_TYPE:
+ {
+ var _created = createFiberFromElement(newChild, returnFiber.mode, expirationTime);
+
+ _created.ref = coerceRef(returnFiber, null, newChild);
+ _created.return = returnFiber;
+ return _created;
+ }
+
+ case REACT_PORTAL_TYPE:
+ {
+ var _created2 = createFiberFromPortal(newChild, returnFiber.mode, expirationTime);
+
+ _created2.return = returnFiber;
+ return _created2;
+ }
+ }
+
+ if (isArray(newChild) || getIteratorFn(newChild)) {
+ var _created3 = createFiberFromFragment(newChild, returnFiber.mode, expirationTime, null);
+
+ _created3.return = returnFiber;
+ return _created3;
+ }
+
+ throwOnInvalidObjectType(returnFiber, newChild);
+ }
+
+ {
+ if (typeof newChild === "function") {
+ warnOnFunctionType();
+ }
+ }
+ return null;
+ }
+
+ function updateSlot(returnFiber, oldFiber, newChild, expirationTime) {
+ var key = oldFiber !== null ? oldFiber.key : null;
+
+ if (typeof newChild === "string" || typeof newChild === "number") {
+ if (key !== null) {
+ return null;
+ }
+
+ return updateTextNode(returnFiber, oldFiber, "" + newChild, expirationTime);
+ }
+
+ if (typeof newChild === "object" && newChild !== null) {
+ switch (newChild.$$typeof) {
+ case REACT_ELEMENT_TYPE:
+ {
+ if (newChild.key === key) {
+ if (newChild.type === REACT_FRAGMENT_TYPE) {
+ return updateFragment(returnFiber, oldFiber, newChild.props.children, expirationTime, key);
+ }
+
+ return updateElement(returnFiber, oldFiber, newChild, expirationTime);
+ } else {
+ return null;
+ }
+ }
+
+ case REACT_PORTAL_TYPE:
+ {
+ if (newChild.key === key) {
+ return updatePortal(returnFiber, oldFiber, newChild, expirationTime);
+ } else {
+ return null;
+ }
+ }
+ }
+
+ if (isArray(newChild) || getIteratorFn(newChild)) {
+ if (key !== null) {
+ return null;
+ }
+
+ return updateFragment(returnFiber, oldFiber, newChild, expirationTime, null);
+ }
+
+ throwOnInvalidObjectType(returnFiber, newChild);
+ }
+
+ {
+ if (typeof newChild === "function") {
+ warnOnFunctionType();
+ }
+ }
+ return null;
+ }
+
+ function updateFromMap(existingChildren, returnFiber, newIdx, newChild, expirationTime) {
+ if (typeof newChild === "string" || typeof newChild === "number") {
+ var matchedFiber = existingChildren.get(newIdx) || null;
+ return updateTextNode(returnFiber, matchedFiber, "" + newChild, expirationTime);
+ }
+
+ if (typeof newChild === "object" && newChild !== null) {
+ switch (newChild.$$typeof) {
+ case REACT_ELEMENT_TYPE:
+ {
+ var _matchedFiber = existingChildren.get(newChild.key === null ? newIdx : newChild.key) || null;
+
+ if (newChild.type === REACT_FRAGMENT_TYPE) {
+ return updateFragment(returnFiber, _matchedFiber, newChild.props.children, expirationTime, newChild.key);
+ }
+
+ return updateElement(returnFiber, _matchedFiber, newChild, expirationTime);
+ }
+
+ case REACT_PORTAL_TYPE:
+ {
+ var _matchedFiber2 = existingChildren.get(newChild.key === null ? newIdx : newChild.key) || null;
+
+ return updatePortal(returnFiber, _matchedFiber2, newChild, expirationTime);
+ }
+ }
+
+ if (isArray(newChild) || getIteratorFn(newChild)) {
+ var _matchedFiber3 = existingChildren.get(newIdx) || null;
+
+ return updateFragment(returnFiber, _matchedFiber3, newChild, expirationTime, null);
+ }
+
+ throwOnInvalidObjectType(returnFiber, newChild);
+ }
+
+ {
+ if (typeof newChild === "function") {
+ warnOnFunctionType();
+ }
+ }
+ return null;
+ }
+
+ function warnOnInvalidKey(child, knownKeys) {
+ {
+ if (typeof child !== "object" || child === null) {
+ return knownKeys;
+ }
+
+ switch (child.$$typeof) {
+ case REACT_ELEMENT_TYPE:
+ case REACT_PORTAL_TYPE:
+ warnForMissingKey(child);
+ var key = child.key;
+
+ if (typeof key !== "string") {
+ break;
+ }
+
+ if (knownKeys === null) {
+ knownKeys = new Set();
+ knownKeys.add(key);
+ break;
+ }
+
+ if (!knownKeys.has(key)) {
+ knownKeys.add(key);
+ break;
+ }
+
+ warning$1(false, "Encountered two children with the same key, `%s`. " + "Keys should be unique so that components maintain their identity " + "across updates. Non-unique keys may cause children to be " + "duplicated and/or omitted — the behavior is unsupported and " + "could change in a future version.", key);
+ break;
+
+ default:
+ break;
+ }
+ }
+ return knownKeys;
+ }
+
+ function reconcileChildrenArray(returnFiber, currentFirstChild, newChildren, expirationTime) {
+ {
+ var knownKeys = null;
+
+ for (var i = 0; i < newChildren.length; i++) {
+ var child = newChildren[i];
+ knownKeys = warnOnInvalidKey(child, knownKeys);
+ }
+ }
+ var resultingFirstChild = null;
+ var previousNewFiber = null;
+ var oldFiber = currentFirstChild;
+ var lastPlacedIndex = 0;
+ var newIdx = 0;
+ var nextOldFiber = null;
+
+ for (; oldFiber !== null && newIdx < newChildren.length; newIdx++) {
+ if (oldFiber.index > newIdx) {
+ nextOldFiber = oldFiber;
+ oldFiber = null;
+ } else {
+ nextOldFiber = oldFiber.sibling;
+ }
+
+ var newFiber = updateSlot(returnFiber, oldFiber, newChildren[newIdx], expirationTime);
+
+ if (newFiber === null) {
+ if (oldFiber === null) {
+ oldFiber = nextOldFiber;
+ }
+
+ break;
+ }
+
+ if (shouldTrackSideEffects) {
+ if (oldFiber && newFiber.alternate === null) {
+ deleteChild(returnFiber, oldFiber);
+ }
+ }
+
+ lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
+
+ if (previousNewFiber === null) {
+ resultingFirstChild = newFiber;
+ } else {
+ previousNewFiber.sibling = newFiber;
+ }
+
+ previousNewFiber = newFiber;
+ oldFiber = nextOldFiber;
+ }
+
+ if (newIdx === newChildren.length) {
+ deleteRemainingChildren(returnFiber, oldFiber);
+ return resultingFirstChild;
+ }
+
+ if (oldFiber === null) {
+ for (; newIdx < newChildren.length; newIdx++) {
+ var _newFiber = createChild(returnFiber, newChildren[newIdx], expirationTime);
+
+ if (!_newFiber) {
+ 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 (typeof Symbol === "function" && newChildrenIterable[typeof Symbol === "function" ? Symbol.toStringTag : "@@toStringTag"] === "Generator") {
+ !didWarnAboutGenerators ? warning$1(false, "Using Generators as children is unsupported and will likely yield " + "unexpected results because enumerating a generator mutates it. " + "You may convert it to an array with `Array.from()` or the " + "`[...spread]` operator before rendering. Keep in mind " + "you might need to polyfill these features for older browsers.") : void 0;
+ didWarnAboutGenerators = true;
+ }
+
+ if (newChildrenIterable.entries === iteratorFn) {
+ !didWarnAboutMaps ? warning$1(false, "Using Maps as children is unsupported and will likely yield " + "unexpected results. Convert it to a sequence/iterable of keyed " + "ReactElements instead.") : void 0;
+ didWarnAboutMaps = true;
+ }
+
+ var _newChildren = iteratorFn.call(newChildrenIterable);
+
+ if (_newChildren) {
+ var knownKeys = null;
+
+ var _step = _newChildren.next();
+
+ for (; !_step.done; _step = _newChildren.next()) {
+ var child = _step.value;
+ knownKeys = warnOnInvalidKey(child, knownKeys);
+ }
+ }
+ }
+ var newChildren = iteratorFn.call(newChildrenIterable);
+ 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.elementType === 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(newChild)) {
+ return reconcileChildrenArray(returnFiber, currentFirstChild, newChild, expirationTime);
+ }
+
+ if (getIteratorFn(newChild)) {
+ return reconcileChildrenIterator(returnFiber, currentFirstChild, newChild, expirationTime);
+ }
+
+ if (isObject) {
+ throwOnInvalidObjectType(returnFiber, newChild);
+ }
+
+ {
+ if (typeof newChild === "function") {
+ warnOnFunctionType();
+ }
+ }
+
+ if (typeof newChild === "undefined" && !isUnkeyedTopLevelFragment) {
+ switch (returnFiber.tag) {
+ case ClassComponent:
+ {
+ {
+ var instance = returnFiber.stateNode;
+
+ if (instance.render._isMockFunction) {
+ break;
+ }
+ }
+ }
+
+ case FunctionComponent:
+ {
+ var Component = returnFiber.type;
+ 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$$1, workInProgress) {
+ invariant(current$$1 === null || workInProgress.child === current$$1.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 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 NoEffect$1 = 0;
+ var UnmountSnapshot = 2;
+ var UnmountMutation = 4;
+ var MountMutation = 8;
+ var UnmountLayout = 16;
+ var MountLayout = 32;
+ var MountPassive = 64;
+ var UnmountPassive = 128;
+ var ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher;
+ var didWarnAboutMismatchedHooksForComponent = void 0;
+ {
+ didWarnAboutMismatchedHooksForComponent = new Set();
+ }
+ var renderExpirationTime = NoWork;
+ var currentlyRenderingFiber$1 = null;
+ var firstCurrentHook = null;
+ var currentHook = null;
+ var nextCurrentHook = null;
+ var firstWorkInProgressHook = null;
+ var workInProgressHook = null;
+ var nextWorkInProgressHook = null;
+ var remainingExpirationTime = NoWork;
+ var componentUpdateQueue = null;
+ var sideEffectTag = 0;
+ var didScheduleRenderPhaseUpdate = false;
+ var renderPhaseUpdates = null;
+ var numberOfReRenders = 0;
+ var RE_RENDER_LIMIT = 25;
+ var currentHookNameInDev = null;
+
+ function warnOnHookMismatchInDev() {
+ {
+ var componentName = getComponentName(currentlyRenderingFiber$1.type);
+
+ if (!didWarnAboutMismatchedHooksForComponent.has(componentName)) {
+ didWarnAboutMismatchedHooksForComponent.add(componentName);
+ var secondColumnStart = 22;
+ var table = "";
+ var prevHook = firstCurrentHook;
+ var nextHook = firstWorkInProgressHook;
+ var n = 1;
+
+ while (prevHook !== null && nextHook !== null) {
+ var oldHookName = prevHook._debugType;
+ var newHookName = nextHook._debugType;
+ var row = n + ". " + oldHookName;
+
+ while (row.length < secondColumnStart) {
+ row += " ";
+ }
+
+ row += newHookName + "\n";
+ table += row;
+ prevHook = prevHook.next;
+ nextHook = nextHook.next;
+ n++;
+ }
+
+ warning$1(false, "React has detected a change in the order of Hooks called by %s. " + "This will lead to bugs and errors if not fixed. " + "For more information, read the Rules of Hooks: https://fb.me/rules-of-hooks\n\n" + " Previous render Next render\n" + " -------------------------------\n" + "%s" + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", componentName, table);
+ }
+ }
+ }
+
+ function throwInvalidHookError() {
+ invariant(false, "Hooks can only be called inside the body of a function component. " + "(https://fb.me/react-invalid-hook-call)");
+ }
+
+ function areHookInputsEqual(nextDeps, prevDeps) {
+ if (prevDeps === null) {
+ {
+ warning$1(false, "%s received a final argument during this render, but not during " + "the previous render. Even though the final argument is optional, " + "its type cannot change between renders.", currentHookNameInDev);
+ }
+ return false;
+ }
+
+ {
+ if (nextDeps.length !== prevDeps.length) {
+ warning$1(false, "The final argument passed to %s changed size between renders. The " + "order and size of this array must remain constant.\n\n" + "Previous: %s\n" + "Incoming: %s", currentHookNameInDev, "[" + nextDeps.join(", ") + "]", "[" + prevDeps.join(", ") + "]");
+ }
+ }
+
+ for (var i = 0; i < prevDeps.length && i < nextDeps.length; i++) {
+ if (is(nextDeps[i], prevDeps[i])) {
+ continue;
+ }
+
+ return false;
+ }
+
+ return true;
+ }
+
+ function renderWithHooks(current, workInProgress, Component, props, refOrContext, nextRenderExpirationTime) {
+ renderExpirationTime = nextRenderExpirationTime;
+ currentlyRenderingFiber$1 = workInProgress;
+ firstCurrentHook = nextCurrentHook = current !== null ? current.memoizedState : null;
+ {
+ ReactCurrentDispatcher$1.current = nextCurrentHook === null ? HooksDispatcherOnMountInDEV : HooksDispatcherOnUpdateInDEV;
+ }
+ var children = Component(props, refOrContext);
+
+ if (didScheduleRenderPhaseUpdate) {
+ do {
+ didScheduleRenderPhaseUpdate = false;
+ numberOfReRenders += 1;
+ firstCurrentHook = nextCurrentHook = current !== null ? current.memoizedState : null;
+ nextWorkInProgressHook = firstWorkInProgressHook;
+ currentHook = null;
+ workInProgressHook = null;
+ componentUpdateQueue = null;
+ ReactCurrentDispatcher$1.current = HooksDispatcherOnUpdateInDEV;
+ children = Component(props, refOrContext);
+ } while (didScheduleRenderPhaseUpdate);
+
+ renderPhaseUpdates = null;
+ numberOfReRenders = 0;
+ }
+
+ {
+ currentHookNameInDev = null;
+ }
+ ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
+ var renderedWork = currentlyRenderingFiber$1;
+ renderedWork.memoizedState = firstWorkInProgressHook;
+ renderedWork.expirationTime = remainingExpirationTime;
+ renderedWork.updateQueue = componentUpdateQueue;
+ renderedWork.effectTag |= sideEffectTag;
+ var didRenderTooFewHooks = currentHook !== null && currentHook.next !== null;
+ renderExpirationTime = NoWork;
+ currentlyRenderingFiber$1 = null;
+ firstCurrentHook = null;
+ currentHook = null;
+ nextCurrentHook = null;
+ firstWorkInProgressHook = null;
+ workInProgressHook = null;
+ nextWorkInProgressHook = null;
+ remainingExpirationTime = NoWork;
+ componentUpdateQueue = null;
+ sideEffectTag = 0;
+ invariant(!didRenderTooFewHooks, "Rendered fewer hooks than expected. This may be caused by an accidental " + "early return statement.");
+ return children;
+ }
+
+ function bailoutHooks(current, workInProgress, expirationTime) {
+ workInProgress.updateQueue = current.updateQueue;
+ workInProgress.effectTag &= ~(Passive | Update);
+
+ if (current.expirationTime <= expirationTime) {
+ current.expirationTime = NoWork;
+ }
+ }
+
+ function resetHooks() {
+ ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
+ renderExpirationTime = NoWork;
+ currentlyRenderingFiber$1 = null;
+ firstCurrentHook = null;
+ currentHook = null;
+ nextCurrentHook = null;
+ firstWorkInProgressHook = null;
+ workInProgressHook = null;
+ nextWorkInProgressHook = null;
+ remainingExpirationTime = NoWork;
+ componentUpdateQueue = null;
+ sideEffectTag = 0;
+ {
+ currentHookNameInDev = null;
+ }
+ didScheduleRenderPhaseUpdate = false;
+ renderPhaseUpdates = null;
+ numberOfReRenders = 0;
+ }
+
+ function mountWorkInProgressHook() {
+ var hook = {
+ memoizedState: null,
+ baseState: null,
+ queue: null,
+ baseUpdate: null,
+ next: null
+ };
+ {
+ hook._debugType = currentHookNameInDev;
+ }
+
+ if (workInProgressHook === null) {
+ firstWorkInProgressHook = workInProgressHook = hook;
+ } else {
+ workInProgressHook = workInProgressHook.next = hook;
+ }
+
+ return workInProgressHook;
+ }
+
+ function updateWorkInProgressHook() {
+ if (nextWorkInProgressHook !== null) {
+ workInProgressHook = nextWorkInProgressHook;
+ nextWorkInProgressHook = workInProgressHook.next;
+ currentHook = nextCurrentHook;
+ nextCurrentHook = currentHook !== null ? currentHook.next : null;
+ } else {
+ invariant(nextCurrentHook !== null, "Rendered more hooks than during the previous render.");
+ currentHook = nextCurrentHook;
+ var newHook = {
+ memoizedState: currentHook.memoizedState,
+ baseState: currentHook.baseState,
+ queue: currentHook.queue,
+ baseUpdate: currentHook.baseUpdate,
+ next: null
+ };
+
+ if (workInProgressHook === null) {
+ workInProgressHook = firstWorkInProgressHook = newHook;
+ } else {
+ workInProgressHook = workInProgressHook.next = newHook;
+ }
+
+ nextCurrentHook = currentHook.next;
+ {
+ newHook._debugType = currentHookNameInDev;
+
+ if (currentHookNameInDev !== currentHook._debugType) {
+ warnOnHookMismatchInDev();
+ }
+ }
+ }
+
+ return workInProgressHook;
+ }
+
+ function createFunctionComponentUpdateQueue() {
+ return {
+ lastEffect: null
+ };
+ }
+
+ function basicStateReducer(state, action) {
+ return typeof action === "function" ? action(state) : action;
+ }
+
+ function mountContext(context, observedBits) {
+ {
+ mountWorkInProgressHook();
+ }
+ return _readContext(context, observedBits);
+ }
+
+ function updateContext(context, observedBits) {
+ {
+ updateWorkInProgressHook();
+ }
+ return _readContext(context, observedBits);
+ }
+
+ function mountReducer(reducer, initialArg, init) {
+ var hook = mountWorkInProgressHook();
+ var initialState = void 0;
+
+ if (init !== undefined) {
+ initialState = init(initialArg);
+ } else {
+ initialState = initialArg;
+ }
+
+ hook.memoizedState = hook.baseState = initialState;
+ var queue = hook.queue = {
+ last: null,
+ dispatch: null,
+ eagerReducer: reducer,
+ eagerState: initialState
+ };
+ var dispatch = queue.dispatch = dispatchAction.bind(null, currentlyRenderingFiber$1, queue);
+ return [hook.memoizedState, dispatch];
+ }
+
+ function updateReducer(reducer, initialArg, init) {
+ var hook = updateWorkInProgressHook();
+ var queue = hook.queue;
+ invariant(queue !== null, "Should have a queue. This is likely a bug in React. Please file an issue.");
+
+ if (numberOfReRenders > 0) {
+ var _dispatch = queue.dispatch;
+
+ if (renderPhaseUpdates !== null) {
+ var firstRenderPhaseUpdate = renderPhaseUpdates.get(queue);
+
+ if (firstRenderPhaseUpdate !== undefined) {
+ renderPhaseUpdates.delete(queue);
+ var newState = hook.memoizedState;
+ var update = firstRenderPhaseUpdate;
+
+ do {
+ var _action = update.action;
+ newState = reducer(newState, _action);
+ update = update.next;
+ } while (update !== null);
+
+ if (!is(newState, hook.memoizedState)) {
+ markWorkInProgressReceivedUpdate();
+ }
+
+ hook.memoizedState = newState;
+
+ if (hook.baseUpdate === queue.last) {
+ hook.baseState = newState;
+ }
+
+ queue.eagerReducer = reducer;
+ queue.eagerState = newState;
+ return [newState, _dispatch];
+ }
+ }
+
+ return [hook.memoizedState, _dispatch];
+ }
+
+ var last = queue.last;
+ var baseUpdate = hook.baseUpdate;
+ var baseState = hook.baseState;
+ var first = void 0;
+
+ if (baseUpdate !== null) {
+ if (last !== null) {
+ last.next = null;
+ }
+
+ first = baseUpdate.next;
+ } else {
+ first = last !== null ? last.next : null;
+ }
+
+ if (first !== null) {
+ var _newState = baseState;
+ var newBaseState = null;
+ var newBaseUpdate = null;
+ var prevUpdate = baseUpdate;
+ var _update = first;
+ var didSkip = false;
+
+ do {
+ var updateExpirationTime = _update.expirationTime;
+
+ if (updateExpirationTime < renderExpirationTime) {
+ if (!didSkip) {
+ didSkip = true;
+ newBaseUpdate = prevUpdate;
+ newBaseState = _newState;
+ }
+
+ if (updateExpirationTime > remainingExpirationTime) {
+ remainingExpirationTime = updateExpirationTime;
+ }
+ } else {
+ if (_update.eagerReducer === reducer) {
+ _newState = _update.eagerState;
+ } else {
+ var _action2 = _update.action;
+ _newState = reducer(_newState, _action2);
+ }
+ }
+
+ prevUpdate = _update;
+ _update = _update.next;
+ } while (_update !== null && _update !== first);
+
+ if (!didSkip) {
+ newBaseUpdate = prevUpdate;
+ newBaseState = _newState;
+ }
+
+ if (!is(_newState, hook.memoizedState)) {
+ markWorkInProgressReceivedUpdate();
+ }
+
+ hook.memoizedState = _newState;
+ hook.baseUpdate = newBaseUpdate;
+ hook.baseState = newBaseState;
+ queue.eagerReducer = reducer;
+ queue.eagerState = _newState;
+ }
+
+ var dispatch = queue.dispatch;
+ return [hook.memoizedState, dispatch];
+ }
+
+ function mountState(initialState) {
+ var hook = mountWorkInProgressHook();
+
+ if (typeof initialState === "function") {
+ initialState = initialState();
+ }
+
+ hook.memoizedState = hook.baseState = initialState;
+ var queue = hook.queue = {
+ last: null,
+ dispatch: null,
+ eagerReducer: basicStateReducer,
+ eagerState: initialState
+ };
+ var dispatch = queue.dispatch = dispatchAction.bind(null, currentlyRenderingFiber$1, queue);
+ return [hook.memoizedState, dispatch];
+ }
+
+ function updateState(initialState) {
+ return updateReducer(basicStateReducer, initialState);
+ }
+
+ function pushEffect(tag, create, destroy, deps) {
+ var effect = {
+ tag: tag,
+ create: create,
+ destroy: destroy,
+ deps: deps,
+ next: null
+ };
+
+ if (componentUpdateQueue === null) {
+ componentUpdateQueue = createFunctionComponentUpdateQueue();
+ componentUpdateQueue.lastEffect = effect.next = effect;
+ } else {
+ var _lastEffect = componentUpdateQueue.lastEffect;
+
+ if (_lastEffect === null) {
+ componentUpdateQueue.lastEffect = effect.next = effect;
+ } else {
+ var firstEffect = _lastEffect.next;
+ _lastEffect.next = effect;
+ effect.next = firstEffect;
+ componentUpdateQueue.lastEffect = effect;
+ }
+ }
+
+ return effect;
+ }
+
+ function mountRef(initialValue) {
+ var hook = mountWorkInProgressHook();
+ var ref = {
+ current: initialValue
+ };
+ {
+ Object.seal(ref);
+ }
+ hook.memoizedState = ref;
+ return ref;
+ }
+
+ function updateRef(initialValue) {
+ var hook = updateWorkInProgressHook();
+ return hook.memoizedState;
+ }
+
+ function mountEffectImpl(fiberEffectTag, hookEffectTag, create, deps) {
+ var hook = mountWorkInProgressHook();
+ var nextDeps = deps === undefined ? null : deps;
+ sideEffectTag |= fiberEffectTag;
+ hook.memoizedState = pushEffect(hookEffectTag, create, undefined, nextDeps);
+ }
+
+ function updateEffectImpl(fiberEffectTag, hookEffectTag, create, deps) {
+ var hook = updateWorkInProgressHook();
+ var nextDeps = deps === undefined ? null : deps;
+ var destroy = undefined;
+
+ if (currentHook !== null) {
+ var prevEffect = currentHook.memoizedState;
+ destroy = prevEffect.destroy;
+
+ if (nextDeps !== null) {
+ var prevDeps = prevEffect.deps;
+
+ if (areHookInputsEqual(nextDeps, prevDeps)) {
+ pushEffect(NoEffect$1, create, destroy, nextDeps);
+ return;
+ }
+ }
+ }
+
+ sideEffectTag |= fiberEffectTag;
+ hook.memoizedState = pushEffect(hookEffectTag, create, destroy, nextDeps);
+ }
+
+ function mountEffect(create, deps) {
+ return mountEffectImpl(Update | Passive, UnmountPassive | MountPassive, create, deps);
+ }
+
+ function updateEffect(create, deps) {
+ return updateEffectImpl(Update | Passive, UnmountPassive | MountPassive, create, deps);
+ }
+
+ function mountLayoutEffect(create, deps) {
+ return mountEffectImpl(Update, UnmountMutation | MountLayout, create, deps);
+ }
+
+ function updateLayoutEffect(create, deps) {
+ return updateEffectImpl(Update, UnmountMutation | MountLayout, create, deps);
+ }
+
+ function imperativeHandleEffect(create, ref) {
+ if (typeof ref === "function") {
+ var refCallback = ref;
+
+ var _inst = create();
+
+ refCallback(_inst);
+ return function () {
+ refCallback(null);
+ };
+ } else if (ref !== null && ref !== undefined) {
+ var refObject = ref;
+ {
+ !refObject.hasOwnProperty("current") ? warning$1(false, "Expected useImperativeHandle() first argument to either be a " + "ref callback or React.createRef() object. Instead received: %s.", "an object with keys {" + Object.keys(refObject).join(", ") + "}") : void 0;
+ }
+
+ var _inst2 = create();
+
+ refObject.current = _inst2;
+ return function () {
+ refObject.current = null;
+ };
+ }
+ }
+
+ function mountImperativeHandle(ref, create, deps) {
+ {
+ !(typeof create === "function") ? warning$1(false, "Expected useImperativeHandle() second argument to be a function " + "that creates a handle. Instead received: %s.", create !== null ? typeof create : "null") : void 0;
+ }
+ var effectDeps = deps !== null && deps !== undefined ? deps.concat([ref]) : null;
+ return mountEffectImpl(Update, UnmountMutation | MountLayout, imperativeHandleEffect.bind(null, create, ref), effectDeps);
+ }
+
+ function updateImperativeHandle(ref, create, deps) {
+ {
+ !(typeof create === "function") ? warning$1(false, "Expected useImperativeHandle() second argument to be a function " + "that creates a handle. Instead received: %s.", create !== null ? typeof create : "null") : void 0;
+ }
+ var effectDeps = deps !== null && deps !== undefined ? deps.concat([ref]) : null;
+ return updateEffectImpl(Update, UnmountMutation | MountLayout, imperativeHandleEffect.bind(null, create, ref), effectDeps);
+ }
+
+ function mountDebugValue(value, formatterFn) {}
+
+ var updateDebugValue = mountDebugValue;
+
+ function mountCallback(callback, deps) {
+ var hook = mountWorkInProgressHook();
+ var nextDeps = deps === undefined ? null : deps;
+ hook.memoizedState = [callback, nextDeps];
+ return callback;
+ }
+
+ function updateCallback(callback, deps) {
+ var hook = updateWorkInProgressHook();
+ var nextDeps = deps === undefined ? null : deps;
+ var prevState = hook.memoizedState;
+
+ if (prevState !== null) {
+ if (nextDeps !== null) {
+ var prevDeps = prevState[1];
+
+ if (areHookInputsEqual(nextDeps, prevDeps)) {
+ return prevState[0];
+ }
+ }
+ }
+
+ hook.memoizedState = [callback, nextDeps];
+ return callback;
+ }
+
+ function mountMemo(nextCreate, deps) {
+ var hook = mountWorkInProgressHook();
+ var nextDeps = deps === undefined ? null : deps;
+ var nextValue = nextCreate();
+ hook.memoizedState = [nextValue, nextDeps];
+ return nextValue;
+ }
+
+ function updateMemo(nextCreate, deps) {
+ var hook = updateWorkInProgressHook();
+ var nextDeps = deps === undefined ? null : deps;
+ var prevState = hook.memoizedState;
+
+ if (prevState !== null) {
+ if (nextDeps !== null) {
+ var prevDeps = prevState[1];
+
+ if (areHookInputsEqual(nextDeps, prevDeps)) {
+ return prevState[0];
+ }
+ }
+ }
+
+ var nextValue = nextCreate();
+ hook.memoizedState = [nextValue, nextDeps];
+ return nextValue;
+ }
+
+ var shouldWarnForUnbatchedSetState = false;
+ {
+ if ("undefined" !== typeof jest) {
+ shouldWarnForUnbatchedSetState = true;
+ }
+ }
+
+ function dispatchAction(fiber, queue, action) {
+ invariant(numberOfReRenders < RE_RENDER_LIMIT, "Too many re-renders. React limits the number of renders to prevent " + "an infinite loop.");
+ {
+ !(arguments.length <= 3) ? warning$1(false, "State updates from the useState() and useReducer() Hooks don't support the " + "second callback argument. To execute a side effect after " + "rendering, declare it in the component body with useEffect().") : void 0;
+ }
+ var alternate = fiber.alternate;
+
+ if (fiber === currentlyRenderingFiber$1 || alternate !== null && alternate === currentlyRenderingFiber$1) {
+ didScheduleRenderPhaseUpdate = true;
+ var update = {
+ expirationTime: renderExpirationTime,
+ action: action,
+ eagerReducer: null,
+ eagerState: null,
+ next: null
+ };
+
+ if (renderPhaseUpdates === null) {
+ renderPhaseUpdates = new Map();
+ }
+
+ var firstRenderPhaseUpdate = renderPhaseUpdates.get(queue);
+
+ if (firstRenderPhaseUpdate === undefined) {
+ renderPhaseUpdates.set(queue, update);
+ } else {
+ var lastRenderPhaseUpdate = firstRenderPhaseUpdate;
+
+ while (lastRenderPhaseUpdate.next !== null) {
+ lastRenderPhaseUpdate = lastRenderPhaseUpdate.next;
+ }
+
+ lastRenderPhaseUpdate.next = update;
+ }
+ } else {
+ flushPassiveEffects();
+ var currentTime = requestCurrentTime();
+
+ var _expirationTime = computeExpirationForFiber(currentTime, fiber);
+
+ var _update2 = {
+ expirationTime: _expirationTime,
+ action: action,
+ eagerReducer: null,
+ eagerState: null,
+ next: null
+ };
+ var _last = queue.last;
+
+ if (_last === null) {
+ _update2.next = _update2;
+ } else {
+ var first = _last.next;
+
+ if (first !== null) {
+ _update2.next = first;
+ }
+
+ _last.next = _update2;
+ }
+
+ queue.last = _update2;
+
+ if (fiber.expirationTime === NoWork && (alternate === null || alternate.expirationTime === NoWork)) {
+ var _eagerReducer = queue.eagerReducer;
+
+ if (_eagerReducer !== null) {
+ var prevDispatcher = void 0;
+ {
+ prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;
+ }
+
+ try {
+ var currentState = queue.eagerState;
+
+ var _eagerState = _eagerReducer(currentState, action);
+
+ _update2.eagerReducer = _eagerReducer;
+ _update2.eagerState = _eagerState;
+
+ if (is(_eagerState, currentState)) {
+ return;
+ }
+ } catch (error) {} finally {
+ {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ }
+ }
+ }
+
+ {
+ if (shouldWarnForUnbatchedSetState === true) {
+ warnIfNotCurrentlyBatchingInDev(fiber);
+ }
+ }
+ scheduleWork(fiber, _expirationTime);
+ }
+ }
+
+ var ContextOnlyDispatcher = {
+ readContext: _readContext,
+ useCallback: throwInvalidHookError,
+ useContext: throwInvalidHookError,
+ useEffect: throwInvalidHookError,
+ useImperativeHandle: throwInvalidHookError,
+ useLayoutEffect: throwInvalidHookError,
+ useMemo: throwInvalidHookError,
+ useReducer: throwInvalidHookError,
+ useRef: throwInvalidHookError,
+ useState: throwInvalidHookError,
+ useDebugValue: throwInvalidHookError
+ };
+ var HooksDispatcherOnMountInDEV = null;
+ var HooksDispatcherOnUpdateInDEV = null;
+ var InvalidNestedHooksDispatcherOnMountInDEV = null;
+ var InvalidNestedHooksDispatcherOnUpdateInDEV = null;
+ {
+ var warnInvalidContextAccess = function warnInvalidContextAccess() {
+ warning$1(false, "Context can only be read while React is rendering. " + "In classes, you can read it in the render method or getDerivedStateFromProps. " + "In function components, you can read it directly in the function body, but not " + "inside Hooks like useReducer() or useMemo().");
+ };
+
+ var warnInvalidHookAccess = function warnInvalidHookAccess() {
+ warning$1(false, "Do not call Hooks inside useEffect(...), useMemo(...), or other built-in Hooks. " + "You can only call Hooks at the top level of your React function. " + "For more information, see " + "https://fb.me/rules-of-hooks");
+ };
+
+ HooksDispatcherOnMountInDEV = {
+ readContext: function readContext(context, observedBits) {
+ return _readContext(context, observedBits);
+ },
+ useCallback: function useCallback(callback, deps) {
+ currentHookNameInDev = "useCallback";
+ return mountCallback(callback, deps);
+ },
+ useContext: function useContext(context, observedBits) {
+ currentHookNameInDev = "useContext";
+ return mountContext(context, observedBits);
+ },
+ useEffect: function useEffect(create, deps) {
+ currentHookNameInDev = "useEffect";
+ return mountEffect(create, deps);
+ },
+ useImperativeHandle: function useImperativeHandle(ref, create, deps) {
+ currentHookNameInDev = "useImperativeHandle";
+ return mountImperativeHandle(ref, create, deps);
+ },
+ useLayoutEffect: function useLayoutEffect(create, deps) {
+ currentHookNameInDev = "useLayoutEffect";
+ return mountLayoutEffect(create, deps);
+ },
+ useMemo: function useMemo(create, deps) {
+ currentHookNameInDev = "useMemo";
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;
+
+ try {
+ return mountMemo(create, deps);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useReducer: function useReducer(reducer, initialArg, init) {
+ currentHookNameInDev = "useReducer";
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;
+
+ try {
+ return mountReducer(reducer, initialArg, init);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useRef: function useRef(initialValue) {
+ currentHookNameInDev = "useRef";
+ return mountRef(initialValue);
+ },
+ useState: function useState(initialState) {
+ currentHookNameInDev = "useState";
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;
+
+ try {
+ return mountState(initialState);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useDebugValue: function useDebugValue(value, formatterFn) {
+ currentHookNameInDev = "useDebugValue";
+ return mountDebugValue(value, formatterFn);
+ }
+ };
+ HooksDispatcherOnUpdateInDEV = {
+ readContext: function readContext(context, observedBits) {
+ return _readContext(context, observedBits);
+ },
+ useCallback: function useCallback(callback, deps) {
+ currentHookNameInDev = "useCallback";
+ return updateCallback(callback, deps);
+ },
+ useContext: function useContext(context, observedBits) {
+ currentHookNameInDev = "useContext";
+ return updateContext(context, observedBits);
+ },
+ useEffect: function useEffect(create, deps) {
+ currentHookNameInDev = "useEffect";
+ return updateEffect(create, deps);
+ },
+ useImperativeHandle: function useImperativeHandle(ref, create, deps) {
+ currentHookNameInDev = "useImperativeHandle";
+ return updateImperativeHandle(ref, create, deps);
+ },
+ useLayoutEffect: function useLayoutEffect(create, deps) {
+ currentHookNameInDev = "useLayoutEffect";
+ return updateLayoutEffect(create, deps);
+ },
+ useMemo: function useMemo(create, deps) {
+ currentHookNameInDev = "useMemo";
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;
+
+ try {
+ return updateMemo(create, deps);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useReducer: function useReducer(reducer, initialArg, init) {
+ currentHookNameInDev = "useReducer";
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;
+
+ try {
+ return updateReducer(reducer, initialArg, init);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useRef: function useRef(initialValue) {
+ currentHookNameInDev = "useRef";
+ return updateRef(initialValue);
+ },
+ useState: function useState(initialState) {
+ currentHookNameInDev = "useState";
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;
+
+ try {
+ return updateState(initialState);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useDebugValue: function useDebugValue(value, formatterFn) {
+ currentHookNameInDev = "useDebugValue";
+ return updateDebugValue(value, formatterFn);
+ }
+ };
+ InvalidNestedHooksDispatcherOnMountInDEV = {
+ readContext: function readContext(context, observedBits) {
+ warnInvalidContextAccess();
+ return _readContext(context, observedBits);
+ },
+ useCallback: function useCallback(callback, deps) {
+ currentHookNameInDev = "useCallback";
+ warnInvalidHookAccess();
+ return mountCallback(callback, deps);
+ },
+ useContext: function useContext(context, observedBits) {
+ currentHookNameInDev = "useContext";
+ warnInvalidHookAccess();
+ return mountContext(context, observedBits);
+ },
+ useEffect: function useEffect(create, deps) {
+ currentHookNameInDev = "useEffect";
+ warnInvalidHookAccess();
+ return mountEffect(create, deps);
+ },
+ useImperativeHandle: function useImperativeHandle(ref, create, deps) {
+ currentHookNameInDev = "useImperativeHandle";
+ warnInvalidHookAccess();
+ return mountImperativeHandle(ref, create, deps);
+ },
+ useLayoutEffect: function useLayoutEffect(create, deps) {
+ currentHookNameInDev = "useLayoutEffect";
+ warnInvalidHookAccess();
+ return mountLayoutEffect(create, deps);
+ },
+ useMemo: function useMemo(create, deps) {
+ currentHookNameInDev = "useMemo";
+ warnInvalidHookAccess();
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;
+
+ try {
+ return mountMemo(create, deps);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useReducer: function useReducer(reducer, initialArg, init) {
+ currentHookNameInDev = "useReducer";
+ warnInvalidHookAccess();
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;
+
+ try {
+ return mountReducer(reducer, initialArg, init);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useRef: function useRef(initialValue) {
+ currentHookNameInDev = "useRef";
+ warnInvalidHookAccess();
+ return mountRef(initialValue);
+ },
+ useState: function useState(initialState) {
+ currentHookNameInDev = "useState";
+ warnInvalidHookAccess();
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;
+
+ try {
+ return mountState(initialState);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useDebugValue: function useDebugValue(value, formatterFn) {
+ currentHookNameInDev = "useDebugValue";
+ warnInvalidHookAccess();
+ return mountDebugValue(value, formatterFn);
+ }
+ };
+ InvalidNestedHooksDispatcherOnUpdateInDEV = {
+ readContext: function readContext(context, observedBits) {
+ warnInvalidContextAccess();
+ return _readContext(context, observedBits);
+ },
+ useCallback: function useCallback(callback, deps) {
+ currentHookNameInDev = "useCallback";
+ warnInvalidHookAccess();
+ return updateCallback(callback, deps);
+ },
+ useContext: function useContext(context, observedBits) {
+ currentHookNameInDev = "useContext";
+ warnInvalidHookAccess();
+ return updateContext(context, observedBits);
+ },
+ useEffect: function useEffect(create, deps) {
+ currentHookNameInDev = "useEffect";
+ warnInvalidHookAccess();
+ return updateEffect(create, deps);
+ },
+ useImperativeHandle: function useImperativeHandle(ref, create, deps) {
+ currentHookNameInDev = "useImperativeHandle";
+ warnInvalidHookAccess();
+ return updateImperativeHandle(ref, create, deps);
+ },
+ useLayoutEffect: function useLayoutEffect(create, deps) {
+ currentHookNameInDev = "useLayoutEffect";
+ warnInvalidHookAccess();
+ return updateLayoutEffect(create, deps);
+ },
+ useMemo: function useMemo(create, deps) {
+ currentHookNameInDev = "useMemo";
+ warnInvalidHookAccess();
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;
+
+ try {
+ return updateMemo(create, deps);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useReducer: function useReducer(reducer, initialArg, init) {
+ currentHookNameInDev = "useReducer";
+ warnInvalidHookAccess();
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;
+
+ try {
+ return updateReducer(reducer, initialArg, init);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useRef: function useRef(initialValue) {
+ currentHookNameInDev = "useRef";
+ warnInvalidHookAccess();
+ return updateRef(initialValue);
+ },
+ useState: function useState(initialState) {
+ currentHookNameInDev = "useState";
+ warnInvalidHookAccess();
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;
+
+ try {
+ return updateState(initialState);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useDebugValue: function useDebugValue(value, formatterFn) {
+ currentHookNameInDev = "useDebugValue";
+ warnInvalidHookAccess();
+ return updateDebugValue(value, formatterFn);
+ }
+ };
+ }
+ var commitTime = 0;
+ var profilerStartTime = -1;
+
+ function getCommitTime() {
+ return commitTime;
+ }
+
+ function recordCommitTime() {
+ if (!enableProfilerTimer) {
+ return;
+ }
+
+ commitTime = now$$1();
+ }
+
+ function startProfilerTimer(fiber) {
+ if (!enableProfilerTimer) {
+ return;
+ }
+
+ profilerStartTime = now$$1();
+
+ if (fiber.actualStartTime < 0) {
+ fiber.actualStartTime = now$$1();
+ }
+ }
+
+ function stopProfilerTimerIfRunning(fiber) {
+ if (!enableProfilerTimer) {
+ return;
+ }
+
+ profilerStartTime = -1;
+ }
+
+ function stopProfilerTimerIfRunningAndRecordDelta(fiber, overrideBaseTime) {
+ if (!enableProfilerTimer) {
+ return;
+ }
+
+ if (profilerStartTime >= 0) {
+ var elapsedTime = now$$1() - profilerStartTime;
+ fiber.actualDuration += elapsedTime;
+
+ if (overrideBaseTime) {
+ fiber.selfBaseDuration = elapsedTime;
+ }
+
+ profilerStartTime = -1;
+ }
+ }
+
+ var hydrationParentFiber = null;
+ var nextHydratableInstance = null;
+ var isHydrating = false;
+
+ function enterHydrationState(fiber) {
+ if (!supportsHydration) {
+ return false;
+ }
+
+ var parentInstance = fiber.stateNode.containerInfo;
+ nextHydratableInstance = getFirstHydratableChild(parentInstance);
+ hydrationParentFiber = fiber;
+ isHydrating = true;
+ return true;
+ }
+
+ function reenterHydrationStateFromDehydratedSuspenseInstance(fiber) {
+ if (!supportsHydration) {
+ return false;
+ }
+
+ var suspenseInstance = fiber.stateNode;
+ nextHydratableInstance = getNextHydratableSibling(suspenseInstance);
+ popToNextHostParent(fiber);
+ isHydrating = true;
+ return true;
+ }
+
+ function deleteHydratableInstance(returnFiber, instance) {
+ {
+ switch (returnFiber.tag) {
+ case HostRoot:
+ didNotHydrateContainerInstance(returnFiber.stateNode.containerInfo, instance);
+ break;
+
+ case HostComponent:
+ didNotHydrateInstance(returnFiber.type, returnFiber.memoizedProps, returnFiber.stateNode, instance);
+ break;
+ }
+ }
+ var childToDelete = createFiberFromHostInstanceForDeletion();
+ childToDelete.stateNode = instance;
+ childToDelete.return = returnFiber;
+ childToDelete.effectTag = Deletion;
+
+ if (returnFiber.lastEffect !== null) {
+ returnFiber.lastEffect.nextEffect = childToDelete;
+ returnFiber.lastEffect = childToDelete;
+ } else {
+ returnFiber.firstEffect = returnFiber.lastEffect = childToDelete;
+ }
+ }
+
+ function insertNonHydratedInstance(returnFiber, fiber) {
+ fiber.effectTag |= Placement;
+ {
+ switch (returnFiber.tag) {
+ case HostRoot:
+ {
+ var parentContainer = returnFiber.stateNode.containerInfo;
+
+ switch (fiber.tag) {
+ case HostComponent:
+ var type = fiber.type;
+ var props = fiber.pendingProps;
+ didNotFindHydratableContainerInstance(parentContainer, type, props);
+ break;
+
+ case HostText:
+ var text = fiber.pendingProps;
+ didNotFindHydratableContainerTextInstance(parentContainer, text);
+ break;
+
+ case SuspenseComponent:
+ didNotFindHydratableContainerSuspenseInstance(parentContainer);
+ break;
+ }
+
+ break;
+ }
+
+ case HostComponent:
+ {
+ var parentType = returnFiber.type;
+ var parentProps = returnFiber.memoizedProps;
+ var parentInstance = returnFiber.stateNode;
+
+ switch (fiber.tag) {
+ case HostComponent:
+ var _type = fiber.type;
+ var _props = fiber.pendingProps;
+ didNotFindHydratableInstance(parentType, parentProps, parentInstance, _type, _props);
+ break;
+
+ case HostText:
+ var _text = fiber.pendingProps;
+ didNotFindHydratableTextInstance(parentType, parentProps, parentInstance, _text);
+ break;
+
+ case SuspenseComponent:
+ didNotFindHydratableSuspenseInstance(parentType, parentProps, parentInstance);
+ break;
+ }
+
+ break;
+ }
+
+ default:
+ return;
+ }
+ }
+ }
+
+ function tryHydrate(fiber, nextInstance) {
+ switch (fiber.tag) {
+ case HostComponent:
+ {
+ var type = fiber.type;
+ var props = fiber.pendingProps;
+ var instance = canHydrateInstance(nextInstance, type, props);
+
+ if (instance !== null) {
+ fiber.stateNode = instance;
+ return true;
+ }
+
+ return false;
+ }
+
+ case HostText:
+ {
+ var text = fiber.pendingProps;
+ var textInstance = canHydrateTextInstance(nextInstance, text);
+
+ if (textInstance !== null) {
+ fiber.stateNode = textInstance;
+ return true;
+ }
+
+ return false;
+ }
+
+ case SuspenseComponent:
+ {
+ if (enableSuspenseServerRenderer) {
+ var suspenseInstance = canHydrateSuspenseInstance(nextInstance);
+
+ if (suspenseInstance !== null) {
+ fiber.tag = DehydratedSuspenseComponent;
+ fiber.stateNode = suspenseInstance;
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ default:
+ return false;
+ }
+ }
+
+ function tryToClaimNextHydratableInstance(fiber) {
+ if (!isHydrating) {
+ return;
+ }
+
+ var nextInstance = nextHydratableInstance;
+
+ if (!nextInstance) {
+ insertNonHydratedInstance(hydrationParentFiber, fiber);
+ isHydrating = false;
+ hydrationParentFiber = fiber;
+ return;
+ }
+
+ var firstAttemptedInstance = nextInstance;
+
+ if (!tryHydrate(fiber, nextInstance)) {
+ nextInstance = getNextHydratableSibling(firstAttemptedInstance);
+
+ if (!nextInstance || !tryHydrate(fiber, nextInstance)) {
+ insertNonHydratedInstance(hydrationParentFiber, fiber);
+ isHydrating = false;
+ hydrationParentFiber = fiber;
+ return;
+ }
+
+ deleteHydratableInstance(hydrationParentFiber, firstAttemptedInstance);
+ }
+
+ hydrationParentFiber = fiber;
+ nextHydratableInstance = getFirstHydratableChild(nextInstance);
+ }
+
+ function prepareToHydrateHostInstance(fiber, rootContainerInstance, hostContext) {
+ if (!supportsHydration) {
+ 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 skipPastDehydratedSuspenseInstance(fiber) {
+ if (!supportsHydration) {
+ invariant(false, "Expected skipPastDehydratedSuspenseInstance() to never be called. " + "This error is likely caused by a bug in React. Please file an issue.");
+ }
+
+ var suspenseInstance = fiber.stateNode;
+ invariant(suspenseInstance, "Expected to have a hydrated suspense instance. " + "This error is likely caused by a bug in React. Please file an issue.");
+ nextHydratableInstance = getNextHydratableInstanceAfterSuspenseInstance(suspenseInstance);
+ }
+
+ function popToNextHostParent(fiber) {
+ var parent = fiber.return;
+
+ while (parent !== null && parent.tag !== HostComponent && parent.tag !== HostRoot && parent.tag !== DehydratedSuspenseComponent) {
+ parent = parent.return;
+ }
+
+ hydrationParentFiber = parent;
+ }
+
+ function popHydrationState(fiber) {
+ if (!supportsHydration) {
+ return false;
+ }
+
+ if (fiber !== hydrationParentFiber) {
+ return false;
+ }
+
+ if (!isHydrating) {
+ popToNextHostParent(fiber);
+ isHydrating = true;
+ return false;
+ }
+
+ var type = fiber.type;
+
+ if (fiber.tag !== HostComponent || type !== "head" && type !== "body" && !shouldSetTextContent(type, fiber.memoizedProps)) {
+ var nextInstance = nextHydratableInstance;
+
+ while (nextInstance) {
+ deleteHydratableInstance(fiber, nextInstance);
+ nextInstance = getNextHydratableSibling(nextInstance);
+ }
+ }
+
+ popToNextHostParent(fiber);
+ nextHydratableInstance = hydrationParentFiber ? getNextHydratableSibling(fiber.stateNode) : null;
+ return true;
+ }
+
+ function resetHydrationState() {
+ if (!supportsHydration) {
+ return;
+ }
+
+ hydrationParentFiber = null;
+ nextHydratableInstance = null;
+ isHydrating = false;
+ }
+
+ var ReactCurrentOwner$3 = ReactSharedInternals.ReactCurrentOwner;
+ var didReceiveUpdate = false;
+ var didWarnAboutBadClass = void 0;
+ var didWarnAboutContextTypeOnFunctionComponent = void 0;
+ var didWarnAboutGetDerivedStateOnFunctionComponent = void 0;
+ var didWarnAboutFunctionRefs = void 0;
+ var didWarnAboutReassigningProps = void 0;
+ {
+ didWarnAboutBadClass = {};
+ didWarnAboutContextTypeOnFunctionComponent = {};
+ didWarnAboutGetDerivedStateOnFunctionComponent = {};
+ didWarnAboutFunctionRefs = {};
+ didWarnAboutReassigningProps = false;
+ }
+
+ function reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime) {
+ if (current$$1 === null) {
+ workInProgress.child = mountChildFibers(workInProgress, null, nextChildren, renderExpirationTime);
+ } else {
+ workInProgress.child = reconcileChildFibers(workInProgress, current$$1.child, nextChildren, renderExpirationTime);
+ }
+ }
+
+ function forceUnmountCurrentAndReconcile(current$$1, workInProgress, nextChildren, renderExpirationTime) {
+ workInProgress.child = reconcileChildFibers(workInProgress, current$$1.child, null, renderExpirationTime);
+ workInProgress.child = reconcileChildFibers(workInProgress, null, nextChildren, renderExpirationTime);
+ }
+
+ function updateForwardRef(current$$1, workInProgress, Component, nextProps, renderExpirationTime) {
+ {
+ if (workInProgress.type !== workInProgress.elementType) {
+ var innerPropTypes = Component.propTypes;
+
+ if (innerPropTypes) {
+ checkPropTypes(innerPropTypes, nextProps, "prop", getComponentName(Component), getCurrentFiberStackInDev);
+ }
+ }
+ }
+ var render = Component.render;
+ var ref = workInProgress.ref;
+ var nextChildren = void 0;
+ prepareToReadContext(workInProgress, renderExpirationTime);
+ {
+ ReactCurrentOwner$3.current = workInProgress;
+ setCurrentPhase("render");
+ nextChildren = renderWithHooks(current$$1, workInProgress, render, nextProps, ref, renderExpirationTime);
+
+ if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
+ if (workInProgress.memoizedState !== null) {
+ nextChildren = renderWithHooks(current$$1, workInProgress, render, nextProps, ref, renderExpirationTime);
+ }
+ }
+
+ setCurrentPhase(null);
+ }
+
+ if (current$$1 !== null && !didReceiveUpdate) {
+ bailoutHooks(current$$1, workInProgress, renderExpirationTime);
+ return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ }
+
+ workInProgress.effectTag |= PerformedWork;
+ reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
+ return workInProgress.child;
+ }
+
+ function updateMemoComponent(current$$1, workInProgress, Component, nextProps, updateExpirationTime, renderExpirationTime) {
+ if (current$$1 === null) {
+ var type = Component.type;
+
+ if (isSimpleFunctionComponent(type) && Component.compare === null && Component.defaultProps === undefined) {
+ workInProgress.tag = SimpleMemoComponent;
+ workInProgress.type = type;
+ {
+ validateFunctionComponentInDev(workInProgress, type);
+ }
+ return updateSimpleMemoComponent(current$$1, workInProgress, type, nextProps, updateExpirationTime, renderExpirationTime);
+ }
+
+ {
+ var innerPropTypes = type.propTypes;
+
+ if (innerPropTypes) {
+ checkPropTypes(innerPropTypes, nextProps, "prop", getComponentName(type), getCurrentFiberStackInDev);
+ }
+ }
+ var child = createFiberFromTypeAndProps(Component.type, null, nextProps, null, workInProgress.mode, renderExpirationTime);
+ child.ref = workInProgress.ref;
+ child.return = workInProgress;
+ workInProgress.child = child;
+ return child;
+ }
+
+ {
+ var _type = Component.type;
+ var _innerPropTypes = _type.propTypes;
+
+ if (_innerPropTypes) {
+ checkPropTypes(_innerPropTypes, nextProps, "prop", getComponentName(_type), getCurrentFiberStackInDev);
+ }
+ }
+ var currentChild = current$$1.child;
+
+ if (updateExpirationTime < renderExpirationTime) {
+ var prevProps = currentChild.memoizedProps;
+ var compare = Component.compare;
+ compare = compare !== null ? compare : shallowEqual;
+
+ if (compare(prevProps, nextProps) && current$$1.ref === workInProgress.ref) {
+ return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ }
+ }
+
+ workInProgress.effectTag |= PerformedWork;
+ var newChild = createWorkInProgress(currentChild, nextProps, renderExpirationTime);
+ newChild.ref = workInProgress.ref;
+ newChild.return = workInProgress;
+ workInProgress.child = newChild;
+ return newChild;
+ }
+
+ function updateSimpleMemoComponent(current$$1, workInProgress, Component, nextProps, updateExpirationTime, renderExpirationTime) {
+ {
+ if (workInProgress.type !== workInProgress.elementType) {
+ var outerMemoType = workInProgress.elementType;
+
+ if (outerMemoType.$$typeof === REACT_LAZY_TYPE) {
+ outerMemoType = refineResolvedLazyComponent(outerMemoType);
+ }
+
+ var outerPropTypes = outerMemoType && outerMemoType.propTypes;
+
+ if (outerPropTypes) {
+ checkPropTypes(outerPropTypes, nextProps, "prop", getComponentName(outerMemoType), getCurrentFiberStackInDev);
+ }
+ }
+ }
+
+ if (current$$1 !== null) {
+ var prevProps = current$$1.memoizedProps;
+
+ if (shallowEqual(prevProps, nextProps) && current$$1.ref === workInProgress.ref) {
+ didReceiveUpdate = false;
+
+ if (updateExpirationTime < renderExpirationTime) {
+ return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ }
+ }
+ }
+
+ return updateFunctionComponent(current$$1, workInProgress, Component, nextProps, renderExpirationTime);
+ }
+
+ function updateFragment(current$$1, workInProgress, renderExpirationTime) {
+ var nextChildren = workInProgress.pendingProps;
+ reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
+ return workInProgress.child;
+ }
+
+ function updateMode(current$$1, workInProgress, renderExpirationTime) {
+ var nextChildren = workInProgress.pendingProps.children;
+ reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
+ return workInProgress.child;
+ }
+
+ function updateProfiler(current$$1, workInProgress, renderExpirationTime) {
+ if (enableProfilerTimer) {
+ workInProgress.effectTag |= Update;
+ }
+
+ var nextProps = workInProgress.pendingProps;
+ var nextChildren = nextProps.children;
+ reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
+ return workInProgress.child;
+ }
+
+ function markRef(current$$1, workInProgress) {
+ var ref = workInProgress.ref;
+
+ if (current$$1 === null && ref !== null || current$$1 !== null && current$$1.ref !== ref) {
+ workInProgress.effectTag |= Ref;
+ }
+ }
+
+ function updateFunctionComponent(current$$1, workInProgress, Component, nextProps, renderExpirationTime) {
+ {
+ if (workInProgress.type !== workInProgress.elementType) {
+ var innerPropTypes = Component.propTypes;
+
+ if (innerPropTypes) {
+ checkPropTypes(innerPropTypes, nextProps, "prop", getComponentName(Component), getCurrentFiberStackInDev);
+ }
+ }
+ }
+ var unmaskedContext = getUnmaskedContext(workInProgress, Component, true);
+ var context = getMaskedContext(workInProgress, unmaskedContext);
+ var nextChildren = void 0;
+ prepareToReadContext(workInProgress, renderExpirationTime);
+ {
+ ReactCurrentOwner$3.current = workInProgress;
+ setCurrentPhase("render");
+ nextChildren = renderWithHooks(current$$1, workInProgress, Component, nextProps, context, renderExpirationTime);
+
+ if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
+ if (workInProgress.memoizedState !== null) {
+ nextChildren = renderWithHooks(current$$1, workInProgress, Component, nextProps, context, renderExpirationTime);
+ }
+ }
+
+ setCurrentPhase(null);
+ }
+
+ if (current$$1 !== null && !didReceiveUpdate) {
+ bailoutHooks(current$$1, workInProgress, renderExpirationTime);
+ return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ }
+
+ workInProgress.effectTag |= PerformedWork;
+ reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
+ return workInProgress.child;
+ }
+
+ function updateClassComponent(current$$1, workInProgress, Component, nextProps, renderExpirationTime) {
+ {
+ if (workInProgress.type !== workInProgress.elementType) {
+ var innerPropTypes = Component.propTypes;
+
+ if (innerPropTypes) {
+ checkPropTypes(innerPropTypes, nextProps, "prop", getComponentName(Component), getCurrentFiberStackInDev);
+ }
+ }
+ }
+ var hasContext = void 0;
+
+ if (isContextProvider(Component)) {
+ hasContext = true;
+ pushContextProvider(workInProgress);
+ } else {
+ hasContext = false;
+ }
+
+ prepareToReadContext(workInProgress, renderExpirationTime);
+ var instance = workInProgress.stateNode;
+ var shouldUpdate = void 0;
+
+ if (instance === null) {
+ if (current$$1 !== null) {
+ current$$1.alternate = null;
+ workInProgress.alternate = null;
+ workInProgress.effectTag |= Placement;
+ }
+
+ constructClassInstance(workInProgress, Component, nextProps, renderExpirationTime);
+ mountClassInstance(workInProgress, Component, nextProps, renderExpirationTime);
+ shouldUpdate = true;
+ } else if (current$$1 === null) {
+ shouldUpdate = resumeMountClassInstance(workInProgress, Component, nextProps, renderExpirationTime);
+ } else {
+ shouldUpdate = updateClassInstance(current$$1, workInProgress, Component, nextProps, renderExpirationTime);
+ }
+
+ var nextUnitOfWork = finishClassComponent(current$$1, workInProgress, Component, shouldUpdate, hasContext, renderExpirationTime);
+ {
+ var inst = workInProgress.stateNode;
+
+ if (inst.props !== nextProps) {
+ !didWarnAboutReassigningProps ? warning$1(false, "It looks like %s is reassigning its own `this.props` while rendering. " + "This is not supported and can lead to confusing bugs.", getComponentName(workInProgress.type) || "a component") : void 0;
+ didWarnAboutReassigningProps = true;
+ }
+ }
+ return nextUnitOfWork;
+ }
+
+ function finishClassComponent(current$$1, workInProgress, Component, shouldUpdate, hasContext, renderExpirationTime) {
+ markRef(current$$1, workInProgress);
+ var didCaptureError = (workInProgress.effectTag & DidCapture) !== NoEffect;
+
+ if (!shouldUpdate && !didCaptureError) {
+ if (hasContext) {
+ invalidateContextProvider(workInProgress, Component, false);
+ }
+
+ return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ }
+
+ var instance = workInProgress.stateNode;
+ ReactCurrentOwner$3.current = workInProgress;
+ var nextChildren = void 0;
+
+ if (didCaptureError && typeof Component.getDerivedStateFromError !== "function") {
+ nextChildren = null;
+
+ if (enableProfilerTimer) {
+ stopProfilerTimerIfRunning(workInProgress);
+ }
+ } else {
+ {
+ setCurrentPhase("render");
+ nextChildren = instance.render();
+
+ if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
+ instance.render();
+ }
+
+ setCurrentPhase(null);
+ }
+ }
+
+ workInProgress.effectTag |= PerformedWork;
+
+ if (current$$1 !== null && didCaptureError) {
+ forceUnmountCurrentAndReconcile(current$$1, workInProgress, nextChildren, renderExpirationTime);
+ } else {
+ reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
+ }
+
+ workInProgress.memoizedState = instance.state;
+
+ if (hasContext) {
+ invalidateContextProvider(workInProgress, Component, true);
+ }
+
+ return workInProgress.child;
+ }
+
+ function pushHostRootContext(workInProgress) {
+ var root = workInProgress.stateNode;
+
+ if (root.pendingContext) {
+ pushTopLevelContextObject(workInProgress, root.pendingContext, root.pendingContext !== root.context);
+ } else if (root.context) {
+ pushTopLevelContextObject(workInProgress, root.context, false);
+ }
+
+ pushHostContainer(workInProgress, root.containerInfo);
+ }
+
+ function updateHostRoot(current$$1, workInProgress, renderExpirationTime) {
+ pushHostRootContext(workInProgress);
+ var updateQueue = workInProgress.updateQueue;
+ invariant(updateQueue !== null, "If the root does not have an updateQueue, we should have already " + "bailed out. This error is likely caused by a bug in React. Please " + "file an issue.");
+ var nextProps = workInProgress.pendingProps;
+ var prevState = workInProgress.memoizedState;
+ var prevChildren = prevState !== null ? prevState.element : null;
+ processUpdateQueue(workInProgress, updateQueue, nextProps, null, renderExpirationTime);
+ var nextState = workInProgress.memoizedState;
+ var nextChildren = nextState.element;
+
+ if (nextChildren === prevChildren) {
+ resetHydrationState();
+ return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ }
+
+ var root = workInProgress.stateNode;
+
+ if ((current$$1 === null || current$$1.child === null) && root.hydrate && enterHydrationState(workInProgress)) {
+ workInProgress.effectTag |= Placement;
+ workInProgress.child = mountChildFibers(workInProgress, null, nextChildren, renderExpirationTime);
+ } else {
+ reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
+ resetHydrationState();
+ }
+
+ return workInProgress.child;
+ }
+
+ function updateHostComponent(current$$1, workInProgress, renderExpirationTime) {
+ pushHostContext(workInProgress);
+
+ if (current$$1 === null) {
+ tryToClaimNextHydratableInstance(workInProgress);
+ }
+
+ var type = workInProgress.type;
+ var nextProps = workInProgress.pendingProps;
+ var prevProps = current$$1 !== null ? current$$1.memoizedProps : null;
+ var nextChildren = nextProps.children;
+ var isDirectTextChild = shouldSetTextContent(type, nextProps);
+
+ if (isDirectTextChild) {
+ nextChildren = null;
+ } else if (prevProps !== null && shouldSetTextContent(type, prevProps)) {
+ workInProgress.effectTag |= ContentReset;
+ }
+
+ markRef(current$$1, workInProgress);
+
+ if (renderExpirationTime !== Never && workInProgress.mode & ConcurrentMode && shouldDeprioritizeSubtree(type, nextProps)) {
+ workInProgress.expirationTime = workInProgress.childExpirationTime = Never;
+ return null;
+ }
+
+ reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
+ return workInProgress.child;
+ }
+
+ function updateHostText(current$$1, workInProgress) {
+ if (current$$1 === null) {
+ tryToClaimNextHydratableInstance(workInProgress);
+ }
+
+ return null;
+ }
+
+ function mountLazyComponent(_current, workInProgress, elementType, updateExpirationTime, renderExpirationTime) {
+ if (_current !== null) {
+ _current.alternate = null;
+ workInProgress.alternate = null;
+ workInProgress.effectTag |= Placement;
+ }
+
+ var props = workInProgress.pendingProps;
+ cancelWorkTimer(workInProgress);
+ var Component = readLazyComponentType(elementType);
+ workInProgress.type = Component;
+ var resolvedTag = workInProgress.tag = resolveLazyComponentTag(Component);
+ startWorkTimer(workInProgress);
+ var resolvedProps = resolveDefaultProps(Component, props);
+ var child = void 0;
+
+ switch (resolvedTag) {
+ case FunctionComponent:
+ {
+ {
+ validateFunctionComponentInDev(workInProgress, Component);
+ }
+ child = updateFunctionComponent(null, workInProgress, Component, resolvedProps, renderExpirationTime);
+ break;
+ }
+
+ case ClassComponent:
+ {
+ child = updateClassComponent(null, workInProgress, Component, resolvedProps, renderExpirationTime);
+ break;
+ }
+
+ case ForwardRef:
+ {
+ child = updateForwardRef(null, workInProgress, Component, resolvedProps, renderExpirationTime);
+ break;
+ }
+
+ case MemoComponent:
+ {
+ {
+ if (workInProgress.type !== workInProgress.elementType) {
+ var outerPropTypes = Component.propTypes;
+
+ if (outerPropTypes) {
+ checkPropTypes(outerPropTypes, resolvedProps, "prop", getComponentName(Component), getCurrentFiberStackInDev);
+ }
+ }
+ }
+ child = updateMemoComponent(null, workInProgress, Component, resolveDefaultProps(Component.type, resolvedProps), updateExpirationTime, renderExpirationTime);
+ break;
+ }
+
+ default:
+ {
+ var hint = "";
+ {
+ if (Component !== null && typeof Component === "object" && Component.$$typeof === REACT_LAZY_TYPE) {
+ hint = " Did you wrap a component in React.lazy() more than once?";
+ }
+ }
+ invariant(false, "Element type is invalid. Received a promise that resolves to: %s. " + "Lazy element type must resolve to a class or function.%s", Component, hint);
+ }
+ }
+
+ return child;
+ }
+
+ function mountIncompleteClassComponent(_current, workInProgress, Component, nextProps, renderExpirationTime) {
+ if (_current !== null) {
+ _current.alternate = null;
+ workInProgress.alternate = null;
+ workInProgress.effectTag |= Placement;
+ }
+
+ workInProgress.tag = ClassComponent;
+ var hasContext = void 0;
+
+ if (isContextProvider(Component)) {
+ hasContext = true;
+ pushContextProvider(workInProgress);
+ } else {
+ hasContext = false;
+ }
+
+ prepareToReadContext(workInProgress, renderExpirationTime);
+ constructClassInstance(workInProgress, Component, nextProps, renderExpirationTime);
+ mountClassInstance(workInProgress, Component, nextProps, renderExpirationTime);
+ return finishClassComponent(null, workInProgress, Component, true, hasContext, renderExpirationTime);
+ }
+
+ function mountIndeterminateComponent(_current, workInProgress, Component, renderExpirationTime) {
+ if (_current !== null) {
+ _current.alternate = null;
+ workInProgress.alternate = null;
+ workInProgress.effectTag |= Placement;
+ }
+
+ var props = workInProgress.pendingProps;
+ var unmaskedContext = getUnmaskedContext(workInProgress, Component, false);
+ var context = getMaskedContext(workInProgress, unmaskedContext);
+ prepareToReadContext(workInProgress, renderExpirationTime);
+ var value = void 0;
+ {
+ if (Component.prototype && typeof Component.prototype.render === "function") {
+ var componentName = getComponentName(Component) || "Unknown";
+
+ if (!didWarnAboutBadClass[componentName]) {
+ warningWithoutStack$1(false, "The <%s /> component appears to have a render method, but doesn't extend React.Component. " + "This is likely to cause errors. Change %s to extend React.Component instead.", componentName, componentName);
+ didWarnAboutBadClass[componentName] = true;
+ }
+ }
+
+ if (workInProgress.mode & StrictMode) {
+ ReactStrictModeWarnings.recordLegacyContextWarning(workInProgress, null);
+ }
+
+ ReactCurrentOwner$3.current = workInProgress;
+ value = renderWithHooks(null, workInProgress, Component, props, context, renderExpirationTime);
+ }
+ workInProgress.effectTag |= PerformedWork;
+
+ if (typeof value === "object" && value !== null && typeof value.render === "function" && value.$$typeof === undefined) {
+ workInProgress.tag = ClassComponent;
+ resetHooks();
+ var hasContext = false;
+
+ if (isContextProvider(Component)) {
+ hasContext = true;
+ pushContextProvider(workInProgress);
+ } else {
+ hasContext = false;
+ }
+
+ workInProgress.memoizedState = value.state !== null && value.state !== undefined ? value.state : null;
+ var getDerivedStateFromProps = Component.getDerivedStateFromProps;
+
+ if (typeof getDerivedStateFromProps === "function") {
+ applyDerivedStateFromProps(workInProgress, Component, getDerivedStateFromProps, props);
+ }
+
+ adoptClassInstance(workInProgress, value);
+ mountClassInstance(workInProgress, Component, props, renderExpirationTime);
+ return finishClassComponent(null, workInProgress, Component, true, hasContext, renderExpirationTime);
+ } else {
+ workInProgress.tag = FunctionComponent;
+ {
+ if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
+ if (workInProgress.memoizedState !== null) {
+ value = renderWithHooks(null, workInProgress, Component, props, context, renderExpirationTime);
+ }
+ }
+ }
+ reconcileChildren(null, workInProgress, value, renderExpirationTime);
+ {
+ validateFunctionComponentInDev(workInProgress, Component);
+ }
+ return workInProgress.child;
+ }
+ }
+
+ function validateFunctionComponentInDev(workInProgress, Component) {
+ if (Component) {
+ !!Component.childContextTypes ? warningWithoutStack$1(false, "%s(...): childContextTypes cannot be defined on a function component.", Component.displayName || Component.name || "Component") : void 0;
+ }
+
+ if (workInProgress.ref !== null) {
+ var info = "";
+ var ownerName = getCurrentFiberOwnerNameInDevOrNull();
+
+ if (ownerName) {
+ info += "\n\nCheck the render method of `" + ownerName + "`.";
+ }
+
+ var warningKey = ownerName || workInProgress._debugID || "";
+ var debugSource = workInProgress._debugSource;
+
+ if (debugSource) {
+ warningKey = debugSource.fileName + ":" + debugSource.lineNumber;
+ }
+
+ if (!didWarnAboutFunctionRefs[warningKey]) {
+ didWarnAboutFunctionRefs[warningKey] = true;
+ warning$1(false, "Function components cannot be given refs. " + "Attempts to access this ref will fail. " + "Did you mean to use React.forwardRef()?%s", info);
+ }
+ }
+
+ if (typeof Component.getDerivedStateFromProps === "function") {
+ var componentName = getComponentName(Component) || "Unknown";
+
+ if (!didWarnAboutGetDerivedStateOnFunctionComponent[componentName]) {
+ warningWithoutStack$1(false, "%s: Function components do not support getDerivedStateFromProps.", componentName);
+ didWarnAboutGetDerivedStateOnFunctionComponent[componentName] = true;
+ }
+ }
+
+ if (typeof Component.contextType === "object" && Component.contextType !== null) {
+ var _componentName = getComponentName(Component) || "Unknown";
+
+ if (!didWarnAboutContextTypeOnFunctionComponent[_componentName]) {
+ warningWithoutStack$1(false, "%s: Function components do not support contextType.", _componentName);
+ didWarnAboutContextTypeOnFunctionComponent[_componentName] = true;
+ }
+ }
+ }
+
+ function updateSuspenseComponent(current$$1, workInProgress, renderExpirationTime) {
+ var mode = workInProgress.mode;
+ var nextProps = workInProgress.pendingProps;
+ var nextState = workInProgress.memoizedState;
+ var nextDidTimeout = void 0;
+
+ if ((workInProgress.effectTag & DidCapture) === NoEffect) {
+ nextState = null;
+ nextDidTimeout = false;
+ } else {
+ nextState = {
+ timedOutAt: nextState !== null ? nextState.timedOutAt : NoWork
+ };
+ nextDidTimeout = true;
+ workInProgress.effectTag &= ~DidCapture;
+ }
+
+ var child = void 0;
+ var next = void 0;
+
+ if (current$$1 === null) {
+ if (enableSuspenseServerRenderer) {
+ if (nextProps.fallback !== undefined) {
+ tryToClaimNextHydratableInstance(workInProgress);
+
+ if (workInProgress.tag === DehydratedSuspenseComponent) {
+ return updateDehydratedSuspenseComponent(null, workInProgress, renderExpirationTime);
+ }
+ }
+ }
+
+ if (nextDidTimeout) {
+ var nextFallbackChildren = nextProps.fallback;
+ var primaryChildFragment = createFiberFromFragment(null, mode, NoWork, null);
+
+ if ((workInProgress.mode & ConcurrentMode) === NoContext) {
+ var progressedState = workInProgress.memoizedState;
+ var progressedPrimaryChild = progressedState !== null ? workInProgress.child.child : workInProgress.child;
+ primaryChildFragment.child = progressedPrimaryChild;
+ }
+
+ var fallbackChildFragment = createFiberFromFragment(nextFallbackChildren, mode, renderExpirationTime, null);
+ primaryChildFragment.sibling = fallbackChildFragment;
+ child = primaryChildFragment;
+ next = fallbackChildFragment;
+ child.return = next.return = workInProgress;
+ } else {
+ var nextPrimaryChildren = nextProps.children;
+ child = next = mountChildFibers(workInProgress, null, nextPrimaryChildren, renderExpirationTime);
+ }
+ } else {
+ var prevState = current$$1.memoizedState;
+ var prevDidTimeout = prevState !== null;
+
+ if (prevDidTimeout) {
+ var currentPrimaryChildFragment = current$$1.child;
+ var currentFallbackChildFragment = currentPrimaryChildFragment.sibling;
+
+ if (nextDidTimeout) {
+ var _nextFallbackChildren = nextProps.fallback;
+
+ var _primaryChildFragment = createWorkInProgress(currentPrimaryChildFragment, currentPrimaryChildFragment.pendingProps, NoWork);
+
+ if ((workInProgress.mode & ConcurrentMode) === NoContext) {
+ var _progressedState = workInProgress.memoizedState;
+
+ var _progressedPrimaryChild = _progressedState !== null ? workInProgress.child.child : workInProgress.child;
+
+ if (_progressedPrimaryChild !== currentPrimaryChildFragment.child) {
+ _primaryChildFragment.child = _progressedPrimaryChild;
+ }
+ }
+
+ if (enableProfilerTimer && workInProgress.mode & ProfileMode) {
+ var treeBaseDuration = 0;
+ var hiddenChild = _primaryChildFragment.child;
+
+ while (hiddenChild !== null) {
+ treeBaseDuration += hiddenChild.treeBaseDuration;
+ hiddenChild = hiddenChild.sibling;
+ }
+
+ _primaryChildFragment.treeBaseDuration = treeBaseDuration;
+ }
+
+ var _fallbackChildFragment = _primaryChildFragment.sibling = createWorkInProgress(currentFallbackChildFragment, _nextFallbackChildren, currentFallbackChildFragment.expirationTime);
+
+ child = _primaryChildFragment;
+ _primaryChildFragment.childExpirationTime = NoWork;
+ next = _fallbackChildFragment;
+ child.return = next.return = workInProgress;
+ } else {
+ var _nextPrimaryChildren = nextProps.children;
+ var currentPrimaryChild = currentPrimaryChildFragment.child;
+ var primaryChild = reconcileChildFibers(workInProgress, currentPrimaryChild, _nextPrimaryChildren, renderExpirationTime);
+ child = next = primaryChild;
+ }
+ } else {
+ var _currentPrimaryChild = current$$1.child;
+
+ if (nextDidTimeout) {
+ var _nextFallbackChildren2 = nextProps.fallback;
+
+ var _primaryChildFragment2 = createFiberFromFragment(null, mode, NoWork, null);
+
+ _primaryChildFragment2.child = _currentPrimaryChild;
+
+ if ((workInProgress.mode & ConcurrentMode) === NoContext) {
+ var _progressedState2 = workInProgress.memoizedState;
+
+ var _progressedPrimaryChild2 = _progressedState2 !== null ? workInProgress.child.child : workInProgress.child;
+
+ _primaryChildFragment2.child = _progressedPrimaryChild2;
+ }
+
+ if (enableProfilerTimer && workInProgress.mode & ProfileMode) {
+ var _treeBaseDuration = 0;
+ var _hiddenChild = _primaryChildFragment2.child;
+
+ while (_hiddenChild !== null) {
+ _treeBaseDuration += _hiddenChild.treeBaseDuration;
+ _hiddenChild = _hiddenChild.sibling;
+ }
+
+ _primaryChildFragment2.treeBaseDuration = _treeBaseDuration;
+ }
+
+ var _fallbackChildFragment2 = _primaryChildFragment2.sibling = createFiberFromFragment(_nextFallbackChildren2, mode, renderExpirationTime, null);
+
+ _fallbackChildFragment2.effectTag |= Placement;
+ child = _primaryChildFragment2;
+ _primaryChildFragment2.childExpirationTime = NoWork;
+ next = _fallbackChildFragment2;
+ child.return = next.return = workInProgress;
+ } else {
+ var _nextPrimaryChildren2 = nextProps.children;
+ next = child = reconcileChildFibers(workInProgress, _currentPrimaryChild, _nextPrimaryChildren2, renderExpirationTime);
+ }
+ }
+
+ workInProgress.stateNode = current$$1.stateNode;
+ }
+
+ workInProgress.memoizedState = nextState;
+ workInProgress.child = child;
+ return next;
+ }
+
+ function updateDehydratedSuspenseComponent(current$$1, workInProgress, renderExpirationTime) {
+ if (current$$1 === null) {
+ workInProgress.expirationTime = Never;
+ return null;
+ }
+
+ if ((workInProgress.effectTag & DidCapture) !== NoEffect) {
+ workInProgress.child = null;
+ return null;
+ }
+
+ var hasContextChanged$$1 = current$$1.childExpirationTime >= renderExpirationTime;
+ var suspenseInstance = current$$1.stateNode;
+
+ if (didReceiveUpdate || hasContextChanged$$1 || isSuspenseInstanceFallback(suspenseInstance)) {
+ current$$1.alternate = null;
+ workInProgress.alternate = null;
+ var returnFiber = workInProgress.return;
+ invariant(returnFiber !== null, "Suspense boundaries are never on the root. " + "This is probably a bug in React.");
+ var last = returnFiber.lastEffect;
+
+ if (last !== null) {
+ last.nextEffect = current$$1;
+ returnFiber.lastEffect = current$$1;
+ } else {
+ returnFiber.firstEffect = returnFiber.lastEffect = current$$1;
+ }
+
+ current$$1.nextEffect = null;
+ current$$1.effectTag = Deletion;
+ workInProgress.tag = SuspenseComponent;
+ workInProgress.stateNode = null;
+ workInProgress.memoizedState = null;
+ workInProgress.effectTag |= Placement;
+ return updateSuspenseComponent(null, workInProgress, renderExpirationTime);
+ } else if (isSuspenseInstancePending(suspenseInstance)) {
+ workInProgress.effectTag |= DidCapture;
+ workInProgress.child = null;
+ registerSuspenseInstanceRetry(suspenseInstance, retryTimedOutBoundary.bind(null, current$$1));
+ return null;
+ } else {
+ reenterHydrationStateFromDehydratedSuspenseInstance(workInProgress);
+ var nextProps = workInProgress.pendingProps;
+ var nextChildren = nextProps.children;
+ workInProgress.child = mountChildFibers(workInProgress, null, nextChildren, renderExpirationTime);
+ return workInProgress.child;
+ }
+ }
+
+ function updatePortalComponent(current$$1, workInProgress, renderExpirationTime) {
+ pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+ var nextChildren = workInProgress.pendingProps;
+
+ if (current$$1 === null) {
+ workInProgress.child = reconcileChildFibers(workInProgress, null, nextChildren, renderExpirationTime);
+ } else {
+ reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
+ }
+
+ return workInProgress.child;
+ }
+
+ function updateContextProvider(current$$1, workInProgress, renderExpirationTime) {
+ var providerType = workInProgress.type;
+ var context = providerType._context;
+ var newProps = workInProgress.pendingProps;
+ var oldProps = workInProgress.memoizedProps;
+ var newValue = newProps.value;
+ {
+ var providerPropTypes = workInProgress.type.propTypes;
+
+ if (providerPropTypes) {
+ checkPropTypes(providerPropTypes, newProps, "prop", "Context.Provider", getCurrentFiberStackInDev);
+ }
+ }
+ pushProvider(workInProgress, newValue);
+
+ if (oldProps !== null) {
+ var oldValue = oldProps.value;
+ var changedBits = calculateChangedBits(context, newValue, oldValue);
+
+ if (changedBits === 0) {
+ if (oldProps.children === newProps.children && !hasContextChanged()) {
+ return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ }
+ } else {
+ propagateContextChange(workInProgress, context, changedBits, renderExpirationTime);
+ }
+ }
+
+ var newChildren = newProps.children;
+ reconcileChildren(current$$1, workInProgress, newChildren, renderExpirationTime);
+ return workInProgress.child;
+ }
+
+ var hasWarnedAboutUsingContextAsConsumer = false;
+
+ function updateContextConsumer(current$$1, workInProgress, renderExpirationTime) {
+ var context = workInProgress.type;
+ {
+ if (context._context === undefined) {
+ if (context !== context.Consumer) {
+ if (!hasWarnedAboutUsingContextAsConsumer) {
+ hasWarnedAboutUsingContextAsConsumer = true;
+ warning$1(false, "Rendering directly is not supported and will be removed in " + "a future major release. Did you mean to render instead?");
+ }
+ }
+ } else {
+ context = context._context;
+ }
+ }
+ var newProps = workInProgress.pendingProps;
+ var render = newProps.children;
+ {
+ !(typeof render === "function") ? warningWithoutStack$1(false, "A context consumer was rendered with multiple children, or a child " + "that isn't a function. A context consumer expects a single child " + "that is a function. If you did pass a function, make sure there " + "is no trailing or leading whitespace around it.") : void 0;
+ }
+ prepareToReadContext(workInProgress, renderExpirationTime);
+
+ var newValue = _readContext(context, newProps.unstable_observedBits);
+
+ var newChildren = void 0;
+ {
+ ReactCurrentOwner$3.current = workInProgress;
+ setCurrentPhase("render");
+ newChildren = render(newValue);
+ setCurrentPhase(null);
+ }
+ workInProgress.effectTag |= PerformedWork;
+ reconcileChildren(current$$1, workInProgress, newChildren, renderExpirationTime);
+ return workInProgress.child;
+ }
+
+ function markWorkInProgressReceivedUpdate() {
+ didReceiveUpdate = true;
+ }
+
+ function bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime) {
+ cancelWorkTimer(workInProgress);
+
+ if (current$$1 !== null) {
+ workInProgress.contextDependencies = current$$1.contextDependencies;
+ }
+
+ if (enableProfilerTimer) {
+ stopProfilerTimerIfRunning(workInProgress);
+ }
+
+ var childExpirationTime = workInProgress.childExpirationTime;
+
+ if (childExpirationTime < renderExpirationTime) {
+ return null;
+ } else {
+ cloneChildFibers(current$$1, workInProgress);
+ return workInProgress.child;
+ }
+ }
+
+ function beginWork(current$$1, workInProgress, renderExpirationTime) {
+ var updateExpirationTime = workInProgress.expirationTime;
+
+ if (current$$1 !== null) {
+ var oldProps = current$$1.memoizedProps;
+ var newProps = workInProgress.pendingProps;
+
+ if (oldProps !== newProps || hasContextChanged()) {
+ didReceiveUpdate = true;
+ } else if (updateExpirationTime < renderExpirationTime) {
+ didReceiveUpdate = false;
+
+ switch (workInProgress.tag) {
+ case HostRoot:
+ pushHostRootContext(workInProgress);
+ resetHydrationState();
+ break;
+
+ case HostComponent:
+ pushHostContext(workInProgress);
+ break;
+
+ case ClassComponent:
+ {
+ var Component = workInProgress.type;
+
+ if (isContextProvider(Component)) {
+ pushContextProvider(workInProgress);
+ }
+
+ break;
+ }
+
+ case HostPortal:
+ pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+ break;
+
+ case ContextProvider:
+ {
+ var newValue = workInProgress.memoizedProps.value;
+ pushProvider(workInProgress, newValue);
+ break;
+ }
+
+ case Profiler:
+ if (enableProfilerTimer) {
+ workInProgress.effectTag |= Update;
+ }
+
+ break;
+
+ case SuspenseComponent:
+ {
+ var state = workInProgress.memoizedState;
+ var didTimeout = state !== null;
+
+ if (didTimeout) {
+ var primaryChildFragment = workInProgress.child;
+ var primaryChildExpirationTime = primaryChildFragment.childExpirationTime;
+
+ if (primaryChildExpirationTime !== NoWork && primaryChildExpirationTime >= renderExpirationTime) {
+ return updateSuspenseComponent(current$$1, workInProgress, renderExpirationTime);
+ } else {
+ var child = bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+
+ if (child !== null) {
+ return child.sibling;
+ } else {
+ return null;
+ }
+ }
+ }
+
+ break;
+ }
+
+ case DehydratedSuspenseComponent:
+ {
+ if (enableSuspenseServerRenderer) {
+ workInProgress.effectTag |= DidCapture;
+ break;
+ }
+ }
+ }
+
+ return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ }
+ } else {
+ didReceiveUpdate = false;
+ }
+
+ workInProgress.expirationTime = NoWork;
+
+ switch (workInProgress.tag) {
+ case IndeterminateComponent:
+ {
+ var elementType = workInProgress.elementType;
+ return mountIndeterminateComponent(current$$1, workInProgress, elementType, renderExpirationTime);
+ }
+
+ case LazyComponent:
+ {
+ var _elementType = workInProgress.elementType;
+ return mountLazyComponent(current$$1, workInProgress, _elementType, updateExpirationTime, renderExpirationTime);
+ }
+
+ case FunctionComponent:
+ {
+ var _Component = workInProgress.type;
+ var unresolvedProps = workInProgress.pendingProps;
+ var resolvedProps = workInProgress.elementType === _Component ? unresolvedProps : resolveDefaultProps(_Component, unresolvedProps);
+ return updateFunctionComponent(current$$1, workInProgress, _Component, resolvedProps, renderExpirationTime);
+ }
+
+ case ClassComponent:
+ {
+ var _Component2 = workInProgress.type;
+ var _unresolvedProps = workInProgress.pendingProps;
+
+ var _resolvedProps = workInProgress.elementType === _Component2 ? _unresolvedProps : resolveDefaultProps(_Component2, _unresolvedProps);
+
+ return updateClassComponent(current$$1, workInProgress, _Component2, _resolvedProps, renderExpirationTime);
+ }
+
+ case HostRoot:
+ return updateHostRoot(current$$1, workInProgress, renderExpirationTime);
+
+ case HostComponent:
+ return updateHostComponent(current$$1, workInProgress, renderExpirationTime);
+
+ case HostText:
+ return updateHostText(current$$1, workInProgress);
+
+ case SuspenseComponent:
+ return updateSuspenseComponent(current$$1, workInProgress, renderExpirationTime);
+
+ case HostPortal:
+ return updatePortalComponent(current$$1, workInProgress, renderExpirationTime);
+
+ case ForwardRef:
+ {
+ var type = workInProgress.type;
+ var _unresolvedProps2 = workInProgress.pendingProps;
+
+ var _resolvedProps2 = workInProgress.elementType === type ? _unresolvedProps2 : resolveDefaultProps(type, _unresolvedProps2);
+
+ return updateForwardRef(current$$1, workInProgress, type, _resolvedProps2, renderExpirationTime);
+ }
+
+ case Fragment:
+ return updateFragment(current$$1, workInProgress, renderExpirationTime);
+
+ case Mode:
+ return updateMode(current$$1, workInProgress, renderExpirationTime);
+
+ case Profiler:
+ return updateProfiler(current$$1, workInProgress, renderExpirationTime);
+
+ case ContextProvider:
+ return updateContextProvider(current$$1, workInProgress, renderExpirationTime);
+
+ case ContextConsumer:
+ return updateContextConsumer(current$$1, workInProgress, renderExpirationTime);
+
+ case MemoComponent:
+ {
+ var _type2 = workInProgress.type;
+ var _unresolvedProps3 = workInProgress.pendingProps;
+
+ var _resolvedProps3 = resolveDefaultProps(_type2, _unresolvedProps3);
+
+ {
+ if (workInProgress.type !== workInProgress.elementType) {
+ var outerPropTypes = _type2.propTypes;
+
+ if (outerPropTypes) {
+ checkPropTypes(outerPropTypes, _resolvedProps3, "prop", getComponentName(_type2), getCurrentFiberStackInDev);
+ }
+ }
+ }
+ _resolvedProps3 = resolveDefaultProps(_type2.type, _resolvedProps3);
+ return updateMemoComponent(current$$1, workInProgress, _type2, _resolvedProps3, updateExpirationTime, renderExpirationTime);
+ }
+
+ case SimpleMemoComponent:
+ {
+ return updateSimpleMemoComponent(current$$1, workInProgress, workInProgress.type, workInProgress.pendingProps, updateExpirationTime, renderExpirationTime);
+ }
+
+ case IncompleteClassComponent:
+ {
+ var _Component3 = workInProgress.type;
+ var _unresolvedProps4 = workInProgress.pendingProps;
+
+ var _resolvedProps4 = workInProgress.elementType === _Component3 ? _unresolvedProps4 : resolveDefaultProps(_Component3, _unresolvedProps4);
+
+ return mountIncompleteClassComponent(current$$1, workInProgress, _Component3, _resolvedProps4, renderExpirationTime);
+ }
+
+ case DehydratedSuspenseComponent:
+ {
+ if (enableSuspenseServerRenderer) {
+ return updateDehydratedSuspenseComponent(current$$1, workInProgress, renderExpirationTime);
+ }
+
+ break;
+ }
+ }
+
+ invariant(false, "Unknown unit of work tag. This error is likely caused by a bug in " + "React. Please file an issue.");
+ }
+
+ var valueCursor = createCursor(null);
+ var rendererSigil = void 0;
+ {
+ rendererSigil = {};
+ }
+ var currentlyRenderingFiber = null;
+ var lastContextDependency = null;
+ var lastContextWithAllBitsObserved = null;
+ var isDisallowedContextReadInDEV = false;
+
+ function resetContextDependences() {
+ currentlyRenderingFiber = null;
+ lastContextDependency = null;
+ lastContextWithAllBitsObserved = null;
+ {
+ isDisallowedContextReadInDEV = false;
+ }
+ }
+
+ function enterDisallowedContextReadInDEV() {
+ {
+ isDisallowedContextReadInDEV = true;
+ }
+ }
+
+ function exitDisallowedContextReadInDEV() {
+ {
+ isDisallowedContextReadInDEV = false;
+ }
+ }
+
+ function pushProvider(providerFiber, nextValue) {
+ var context = providerFiber.type._context;
+
+ if (isPrimaryRenderer) {
+ push(valueCursor, context._currentValue, providerFiber);
+ context._currentValue = nextValue;
+ {
+ !(context._currentRenderer === undefined || context._currentRenderer === null || context._currentRenderer === rendererSigil) ? warningWithoutStack$1(false, "Detected multiple renderers concurrently rendering the " + "same context provider. This is currently unsupported.") : void 0;
+ context._currentRenderer = rendererSigil;
+ }
+ } else {
+ push(valueCursor, context._currentValue2, providerFiber);
+ context._currentValue2 = nextValue;
+ {
+ !(context._currentRenderer2 === undefined || context._currentRenderer2 === null || context._currentRenderer2 === rendererSigil) ? warningWithoutStack$1(false, "Detected multiple renderers concurrently rendering the " + "same context provider. This is currently unsupported.") : void 0;
+ context._currentRenderer2 = rendererSigil;
+ }
+ }
+ }
+
+ function popProvider(providerFiber) {
+ var currentValue = valueCursor.current;
+ pop(valueCursor, providerFiber);
+ var context = providerFiber.type._context;
+
+ if (isPrimaryRenderer) {
+ context._currentValue = currentValue;
+ } else {
+ context._currentValue2 = currentValue;
+ }
+ }
+
+ function calculateChangedBits(context, newValue, oldValue) {
+ if (is(oldValue, newValue)) {
+ return 0;
+ } else {
+ var changedBits = typeof context._calculateChangedBits === "function" ? context._calculateChangedBits(oldValue, newValue) : maxSigned31BitInt;
+ {
+ !((changedBits & maxSigned31BitInt) === changedBits) ? warning$1(false, "calculateChangedBits: Expected the return value to be a " + "31-bit integer. Instead received: %s", changedBits) : void 0;
+ }
+ return changedBits | 0;
+ }
+ }
+
+ function scheduleWorkOnParentPath(parent, renderExpirationTime) {
+ var node = parent;
+
+ while (node !== null) {
+ var alternate = node.alternate;
+
+ if (node.childExpirationTime < renderExpirationTime) {
+ node.childExpirationTime = renderExpirationTime;
+
+ if (alternate !== null && alternate.childExpirationTime < renderExpirationTime) {
+ alternate.childExpirationTime = renderExpirationTime;
+ }
+ } else if (alternate !== null && alternate.childExpirationTime < renderExpirationTime) {
+ alternate.childExpirationTime = renderExpirationTime;
+ } else {
+ break;
+ }
+
+ node = node.return;
+ }
+ }
+
+ function propagateContextChange(workInProgress, context, changedBits, renderExpirationTime) {
+ var fiber = workInProgress.child;
+
+ if (fiber !== null) {
+ fiber.return = workInProgress;
+ }
+
+ while (fiber !== null) {
+ var nextFiber = void 0;
+ var list = fiber.contextDependencies;
+
+ if (list !== null) {
+ nextFiber = fiber.child;
+ var dependency = list.first;
+
+ while (dependency !== null) {
+ if (dependency.context === context && (dependency.observedBits & changedBits) !== 0) {
+ if (fiber.tag === ClassComponent) {
+ var update = createUpdate(renderExpirationTime);
+ update.tag = ForceUpdate;
+ enqueueUpdate(fiber, update);
+ }
+
+ if (fiber.expirationTime < renderExpirationTime) {
+ fiber.expirationTime = renderExpirationTime;
+ }
+
+ var alternate = fiber.alternate;
+
+ if (alternate !== null && alternate.expirationTime < renderExpirationTime) {
+ alternate.expirationTime = renderExpirationTime;
+ }
+
+ scheduleWorkOnParentPath(fiber.return, renderExpirationTime);
+
+ if (list.expirationTime < renderExpirationTime) {
+ list.expirationTime = renderExpirationTime;
+ }
+
+ break;
+ }
+
+ dependency = dependency.next;
+ }
+ } else if (fiber.tag === ContextProvider) {
+ nextFiber = fiber.type === workInProgress.type ? null : fiber.child;
+ } else if (enableSuspenseServerRenderer && fiber.tag === DehydratedSuspenseComponent) {
+ if (fiber.expirationTime < renderExpirationTime) {
+ fiber.expirationTime = renderExpirationTime;
+ }
+
+ var _alternate = fiber.alternate;
+
+ if (_alternate !== null && _alternate.expirationTime < renderExpirationTime) {
+ _alternate.expirationTime = renderExpirationTime;
+ }
+
+ scheduleWorkOnParentPath(fiber, renderExpirationTime);
+ nextFiber = fiber.sibling;
+ } else {
+ nextFiber = fiber.child;
+ }
+
+ if (nextFiber !== null) {
+ nextFiber.return = fiber;
+ } else {
+ nextFiber = fiber;
+
+ while (nextFiber !== null) {
+ if (nextFiber === workInProgress) {
+ nextFiber = null;
+ break;
+ }
+
+ var sibling = nextFiber.sibling;
+
+ if (sibling !== null) {
+ sibling.return = nextFiber.return;
+ nextFiber = sibling;
+ break;
+ }
+
+ nextFiber = nextFiber.return;
+ }
+ }
+
+ fiber = nextFiber;
+ }
+ }
+
+ function prepareToReadContext(workInProgress, renderExpirationTime) {
+ currentlyRenderingFiber = workInProgress;
+ lastContextDependency = null;
+ lastContextWithAllBitsObserved = null;
+ var currentDependencies = workInProgress.contextDependencies;
+
+ if (currentDependencies !== null && currentDependencies.expirationTime >= renderExpirationTime) {
+ markWorkInProgressReceivedUpdate();
+ }
+
+ workInProgress.contextDependencies = null;
+ }
+
+ function _readContext(context, observedBits) {
+ {
+ !!isDisallowedContextReadInDEV ? warning$1(false, "Context can only be read while React is rendering. " + "In classes, you can read it in the render method or getDerivedStateFromProps. " + "In function components, you can read it directly in the function body, but not " + "inside Hooks like useReducer() or useMemo().") : void 0;
+ }
+
+ if (lastContextWithAllBitsObserved === context) {} else if (observedBits === false || observedBits === 0) {} else {
+ var resolvedObservedBits = void 0;
+
+ if (typeof observedBits !== "number" || observedBits === maxSigned31BitInt) {
+ lastContextWithAllBitsObserved = context;
+ resolvedObservedBits = maxSigned31BitInt;
+ } else {
+ resolvedObservedBits = observedBits;
+ }
+
+ var contextItem = {
+ context: context,
+ observedBits: resolvedObservedBits,
+ next: null
+ };
+
+ if (lastContextDependency === null) {
+ invariant(currentlyRenderingFiber !== null, "Context can only be read while React is rendering. " + "In classes, you can read it in the render method or getDerivedStateFromProps. " + "In function components, you can read it directly in the function body, but not " + "inside Hooks like useReducer() or useMemo().");
+ lastContextDependency = contextItem;
+ currentlyRenderingFiber.contextDependencies = {
+ first: contextItem,
+ expirationTime: NoWork
+ };
+ } else {
+ lastContextDependency = lastContextDependency.next = contextItem;
+ }
+ }
+
+ return isPrimaryRenderer ? context._currentValue : context._currentValue2;
+ }
+
+ var UpdateState = 0;
+ var ReplaceState = 1;
+ var ForceUpdate = 2;
+ var CaptureUpdate = 3;
+ var hasForceUpdate = false;
+ var didWarnUpdateInsideUpdate = void 0;
+ var currentlyProcessingQueue = void 0;
+ var resetCurrentlyProcessingQueue = void 0;
+ {
+ didWarnUpdateInsideUpdate = false;
+ currentlyProcessingQueue = null;
+
+ resetCurrentlyProcessingQueue = function resetCurrentlyProcessingQueue() {
+ currentlyProcessingQueue = null;
+ };
+ }
+
+ function createUpdateQueue(baseState) {
+ var queue = {
+ baseState: baseState,
+ firstUpdate: null,
+ lastUpdate: null,
+ firstCapturedUpdate: null,
+ lastCapturedUpdate: null,
+ firstEffect: null,
+ lastEffect: null,
+ firstCapturedEffect: null,
+ lastCapturedEffect: null
+ };
+ return queue;
+ }
+
+ function cloneUpdateQueue(currentQueue) {
+ var queue = {
+ baseState: currentQueue.baseState,
+ firstUpdate: currentQueue.firstUpdate,
+ lastUpdate: currentQueue.lastUpdate,
+ firstCapturedUpdate: null,
+ lastCapturedUpdate: null,
+ firstEffect: null,
+ lastEffect: null,
+ firstCapturedEffect: null,
+ lastCapturedEffect: null
+ };
+ return queue;
+ }
+
+ function createUpdate(expirationTime) {
+ return {
+ expirationTime: expirationTime,
+ tag: UpdateState,
+ payload: null,
+ callback: null,
+ next: null,
+ nextEffect: null
+ };
+ }
+
+ function appendUpdateToQueue(queue, update) {
+ if (queue.lastUpdate === null) {
+ queue.firstUpdate = queue.lastUpdate = update;
+ } else {
+ queue.lastUpdate.next = update;
+ queue.lastUpdate = update;
+ }
+ }
+
+ function enqueueUpdate(fiber, update) {
+ var alternate = fiber.alternate;
+ var queue1 = void 0;
+ var queue2 = void 0;
+
+ if (alternate === null) {
+ queue1 = fiber.updateQueue;
+ queue2 = null;
+
+ if (queue1 === null) {
+ queue1 = fiber.updateQueue = createUpdateQueue(fiber.memoizedState);
+ }
+ } else {
+ queue1 = fiber.updateQueue;
+ queue2 = alternate.updateQueue;
+
+ if (queue1 === null) {
+ if (queue2 === null) {
+ queue1 = fiber.updateQueue = createUpdateQueue(fiber.memoizedState);
+ queue2 = alternate.updateQueue = createUpdateQueue(alternate.memoizedState);
+ } else {
+ queue1 = fiber.updateQueue = cloneUpdateQueue(queue2);
+ }
+ } else {
+ if (queue2 === null) {
+ queue2 = alternate.updateQueue = cloneUpdateQueue(queue1);
+ } else {}
+ }
+ }
+
+ if (queue2 === null || queue1 === queue2) {
+ appendUpdateToQueue(queue1, update);
+ } else {
+ if (queue1.lastUpdate === null || queue2.lastUpdate === null) {
+ appendUpdateToQueue(queue1, update);
+ appendUpdateToQueue(queue2, update);
+ } else {
+ appendUpdateToQueue(queue1, update);
+ queue2.lastUpdate = update;
+ }
+ }
+
+ {
+ if (fiber.tag === ClassComponent && (currentlyProcessingQueue === queue1 || queue2 !== null && currentlyProcessingQueue === queue2) && !didWarnUpdateInsideUpdate) {
+ warningWithoutStack$1(false, "An update (setState, replaceState, or forceUpdate) was scheduled " + "from inside an update function. Update functions should be pure, " + "with zero side-effects. Consider using componentDidUpdate or a " + "callback.");
+ didWarnUpdateInsideUpdate = true;
+ }
+ }
+ }
+
+ function enqueueCapturedUpdate(workInProgress, update) {
+ var workInProgressQueue = workInProgress.updateQueue;
+
+ if (workInProgressQueue === null) {
+ workInProgressQueue = workInProgress.updateQueue = createUpdateQueue(workInProgress.memoizedState);
+ } else {
+ workInProgressQueue = ensureWorkInProgressQueueIsAClone(workInProgress, workInProgressQueue);
+ }
+
+ if (workInProgressQueue.lastCapturedUpdate === null) {
+ workInProgressQueue.firstCapturedUpdate = workInProgressQueue.lastCapturedUpdate = update;
+ } else {
+ workInProgressQueue.lastCapturedUpdate.next = update;
+ workInProgressQueue.lastCapturedUpdate = update;
+ }
+ }
+
+ function ensureWorkInProgressQueueIsAClone(workInProgress, queue) {
+ var current = workInProgress.alternate;
+
+ if (current !== null) {
+ if (queue === current.updateQueue) {
+ queue = workInProgress.updateQueue = cloneUpdateQueue(queue);
+ }
+ }
+
+ return queue;
+ }
+
+ function getStateFromUpdate(workInProgress, queue, update, prevState, nextProps, instance) {
+ switch (update.tag) {
+ case ReplaceState:
+ {
+ var _payload = update.payload;
+
+ if (typeof _payload === "function") {
+ {
+ enterDisallowedContextReadInDEV();
+
+ if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
+ _payload.call(instance, prevState, nextProps);
+ }
+ }
+
+ var nextState = _payload.call(instance, prevState, nextProps);
+
+ {
+ exitDisallowedContextReadInDEV();
+ }
+ return nextState;
+ }
+
+ return _payload;
+ }
+
+ case CaptureUpdate:
+ {
+ workInProgress.effectTag = workInProgress.effectTag & ~ShouldCapture | DidCapture;
+ }
+
+ case UpdateState:
+ {
+ var _payload2 = update.payload;
+ var partialState = void 0;
+
+ if (typeof _payload2 === "function") {
+ {
+ enterDisallowedContextReadInDEV();
+
+ if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
+ _payload2.call(instance, prevState, nextProps);
+ }
+ }
+ partialState = _payload2.call(instance, prevState, nextProps);
+ {
+ exitDisallowedContextReadInDEV();
+ }
+ } else {
+ partialState = _payload2;
+ }
+
+ if (partialState === null || partialState === undefined) {
+ return prevState;
+ }
+
+ return _extends({}, prevState, partialState);
+ }
+
+ case ForceUpdate:
+ {
+ hasForceUpdate = true;
+ return prevState;
+ }
+ }
+
+ return prevState;
+ }
+
+ function processUpdateQueue(workInProgress, queue, props, instance, renderExpirationTime) {
+ hasForceUpdate = false;
+ queue = ensureWorkInProgressQueueIsAClone(workInProgress, queue);
+ {
+ currentlyProcessingQueue = queue;
+ }
+ var newBaseState = queue.baseState;
+ var newFirstUpdate = null;
+ var newExpirationTime = NoWork;
+ var update = queue.firstUpdate;
+ var resultState = newBaseState;
+
+ while (update !== null) {
+ var updateExpirationTime = update.expirationTime;
+
+ if (updateExpirationTime < renderExpirationTime) {
+ if (newFirstUpdate === null) {
+ newFirstUpdate = update;
+ newBaseState = resultState;
+ }
+
+ if (newExpirationTime < updateExpirationTime) {
+ newExpirationTime = updateExpirationTime;
+ }
+ } else {
+ resultState = getStateFromUpdate(workInProgress, queue, update, resultState, props, instance);
+ var _callback = update.callback;
+
+ if (_callback !== null) {
+ workInProgress.effectTag |= Callback;
+ update.nextEffect = null;
+
+ if (queue.lastEffect === null) {
+ queue.firstEffect = queue.lastEffect = update;
+ } else {
+ queue.lastEffect.nextEffect = update;
+ queue.lastEffect = update;
+ }
+ }
+ }
+
+ update = update.next;
+ }
+
+ var newFirstCapturedUpdate = null;
+ update = queue.firstCapturedUpdate;
+
+ while (update !== null) {
+ var _updateExpirationTime = update.expirationTime;
+
+ if (_updateExpirationTime < renderExpirationTime) {
+ if (newFirstCapturedUpdate === null) {
+ newFirstCapturedUpdate = update;
+
+ if (newFirstUpdate === null) {
+ newBaseState = resultState;
+ }
+ }
+
+ if (newExpirationTime < _updateExpirationTime) {
+ newExpirationTime = _updateExpirationTime;
+ }
+ } else {
+ resultState = getStateFromUpdate(workInProgress, queue, update, resultState, props, instance);
+ var _callback2 = update.callback;
+
+ if (_callback2 !== null) {
+ workInProgress.effectTag |= Callback;
+ update.nextEffect = null;
+
+ if (queue.lastCapturedEffect === null) {
+ queue.firstCapturedEffect = queue.lastCapturedEffect = update;
+ } else {
+ queue.lastCapturedEffect.nextEffect = update;
+ queue.lastCapturedEffect = update;
+ }
+ }
+ }
+
+ update = update.next;
+ }
+
+ if (newFirstUpdate === null) {
+ queue.lastUpdate = null;
+ }
+
+ if (newFirstCapturedUpdate === null) {
+ queue.lastCapturedUpdate = null;
+ } else {
+ workInProgress.effectTag |= Callback;
+ }
+
+ if (newFirstUpdate === null && newFirstCapturedUpdate === null) {
+ newBaseState = resultState;
+ }
+
+ queue.baseState = newBaseState;
+ queue.firstUpdate = newFirstUpdate;
+ queue.firstCapturedUpdate = newFirstCapturedUpdate;
+ workInProgress.expirationTime = newExpirationTime;
+ workInProgress.memoizedState = resultState;
+ {
+ currentlyProcessingQueue = null;
+ }
+ }
+
+ function callCallback(callback, context) {
+ 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;
+ }
+
+ commitUpdateEffects(finishedQueue.firstEffect, instance);
+ finishedQueue.firstEffect = finishedQueue.lastEffect = null;
+ commitUpdateEffects(finishedQueue.firstCapturedEffect, instance);
+ finishedQueue.firstCapturedEffect = finishedQueue.lastCapturedEffect = null;
+ }
+
+ function commitUpdateEffects(effect, instance) {
+ while (effect !== null) {
+ var _callback3 = effect.callback;
+
+ if (_callback3 !== null) {
+ effect.callback = null;
+ callCallback(_callback3, instance);
+ }
+
+ effect = effect.nextEffect;
+ }
+ }
+
+ function createCapturedValue(value, source) {
+ return {
+ value: value,
+ source: source,
+ stack: getStackByFiberInDevAndProd(source)
+ };
+ }
+
+ function markUpdate(workInProgress) {
+ workInProgress.effectTag |= Update;
+ }
+
+ function markRef$1(workInProgress) {
+ workInProgress.effectTag |= Ref;
+ }
+
+ var _appendAllChildren = void 0;
+
+ var updateHostContainer = void 0;
+ var updateHostComponent$1 = void 0;
+ var updateHostText$1 = void 0;
+
+ if (supportsMutation) {
+ _appendAllChildren = function appendAllChildren(parent, workInProgress, needsVisibilityToggle, isHidden) {
+ var node = workInProgress.child;
+
+ while (node !== null) {
+ if (node.tag === HostComponent || node.tag === HostText) {
+ appendInitialChild(parent, node.stateNode);
+ } else if (node.tag === HostPortal) {} else if (node.child !== null) {
+ node.child.return = node;
+ node = node.child;
+ continue;
+ }
+
+ if (node === workInProgress) {
+ return;
+ }
+
+ while (node.sibling === null) {
+ if (node.return === null || node.return === workInProgress) {
+ return;
+ }
+
+ node = node.return;
+ }
+
+ node.sibling.return = node.return;
+ node = node.sibling;
+ }
+ };
+
+ updateHostContainer = function updateHostContainer(workInProgress) {};
+
+ updateHostComponent$1 = function updateHostComponent$1(current, workInProgress, type, newProps, rootContainerInstance) {
+ var oldProps = current.memoizedProps;
+
+ if (oldProps === newProps) {
+ return;
+ }
+
+ var instance = workInProgress.stateNode;
+ var currentHostContext = getHostContext();
+ var updatePayload = prepareUpdate(instance, type, oldProps, newProps, rootContainerInstance, currentHostContext);
+ workInProgress.updateQueue = updatePayload;
+
+ if (updatePayload) {
+ markUpdate(workInProgress);
+ }
+ };
+
+ updateHostText$1 = function updateHostText$1(current, workInProgress, oldText, newText) {
+ if (oldText !== newText) {
+ markUpdate(workInProgress);
+ }
+ };
+ } else if (supportsPersistence) {
+ _appendAllChildren = function appendAllChildren(parent, workInProgress, needsVisibilityToggle, isHidden) {
+ var node = workInProgress.child;
+
+ while (node !== null) {
+ branches: if (node.tag === HostComponent) {
+ var instance = node.stateNode;
+
+ if (needsVisibilityToggle) {
+ var props = node.memoizedProps;
+ var type = node.type;
+
+ if (isHidden) {
+ instance = cloneHiddenInstance(instance, type, props, node);
+ } else {
+ instance = cloneUnhiddenInstance(instance, type, props, node);
+ }
+
+ node.stateNode = instance;
+ }
+
+ appendInitialChild(parent, instance);
+ } else if (node.tag === HostText) {
+ var _instance = node.stateNode;
+
+ if (needsVisibilityToggle) {
+ var text = node.memoizedProps;
+ var rootContainerInstance = getRootHostContainer();
+ var currentHostContext = getHostContext();
+
+ if (isHidden) {
+ _instance = createHiddenTextInstance(text, rootContainerInstance, currentHostContext, workInProgress);
+ } else {
+ _instance = createTextInstance(text, rootContainerInstance, currentHostContext, workInProgress);
+ }
+
+ node.stateNode = _instance;
+ }
+
+ appendInitialChild(parent, _instance);
+ } else if (node.tag === HostPortal) {} else if (node.tag === SuspenseComponent) {
+ var current = node.alternate;
+
+ if (current !== null) {
+ var oldState = current.memoizedState;
+ var newState = node.memoizedState;
+ var oldIsHidden = oldState !== null;
+ var newIsHidden = newState !== null;
+
+ if (oldIsHidden !== newIsHidden) {
+ var primaryChildParent = newIsHidden ? node.child : node;
+
+ if (primaryChildParent !== null) {
+ _appendAllChildren(parent, primaryChildParent, true, newIsHidden);
+ }
+
+ break branches;
+ }
+ }
+
+ if (node.child !== null) {
+ node.child.return = node;
+ node = node.child;
+ continue;
+ }
+ } else if (node.child !== null) {
+ node.child.return = node;
+ node = node.child;
+ continue;
+ }
+
+ node = node;
+
+ if (node === workInProgress) {
+ return;
+ }
+
+ while (node.sibling === null) {
+ if (node.return === null || node.return === workInProgress) {
+ return;
+ }
+
+ node = node.return;
+ }
+
+ node.sibling.return = node.return;
+ node = node.sibling;
+ }
+ };
+
+ var appendAllChildrenToContainer = function appendAllChildrenToContainer(containerChildSet, workInProgress, needsVisibilityToggle, isHidden) {
+ var node = workInProgress.child;
+
+ while (node !== null) {
+ branches: if (node.tag === HostComponent) {
+ var instance = node.stateNode;
+
+ if (needsVisibilityToggle) {
+ var props = node.memoizedProps;
+ var type = node.type;
+
+ if (isHidden) {
+ instance = cloneHiddenInstance(instance, type, props, node);
+ } else {
+ instance = cloneUnhiddenInstance(instance, type, props, node);
+ }
+
+ node.stateNode = instance;
+ }
+
+ appendChildToContainerChildSet(containerChildSet, instance);
+ } else if (node.tag === HostText) {
+ var _instance2 = node.stateNode;
+
+ if (needsVisibilityToggle) {
+ var text = node.memoizedProps;
+ var rootContainerInstance = getRootHostContainer();
+ var currentHostContext = getHostContext();
+
+ if (isHidden) {
+ _instance2 = createHiddenTextInstance(text, rootContainerInstance, currentHostContext, workInProgress);
+ } else {
+ _instance2 = createTextInstance(text, rootContainerInstance, currentHostContext, workInProgress);
+ }
+
+ node.stateNode = _instance2;
+ }
+
+ appendChildToContainerChildSet(containerChildSet, _instance2);
+ } else if (node.tag === HostPortal) {} else if (node.tag === SuspenseComponent) {
+ var current = node.alternate;
+
+ if (current !== null) {
+ var oldState = current.memoizedState;
+ var newState = node.memoizedState;
+ var oldIsHidden = oldState !== null;
+ var newIsHidden = newState !== null;
+
+ if (oldIsHidden !== newIsHidden) {
+ var primaryChildParent = newIsHidden ? node.child : node;
+
+ if (primaryChildParent !== null) {
+ appendAllChildrenToContainer(containerChildSet, primaryChildParent, true, newIsHidden);
+ }
+
+ break branches;
+ }
+ }
+
+ if (node.child !== null) {
+ node.child.return = node;
+ node = node.child;
+ continue;
+ }
+ } else if (node.child !== null) {
+ node.child.return = node;
+ node = node.child;
+ continue;
+ }
+
+ node = node;
+
+ if (node === workInProgress) {
+ return;
+ }
+
+ while (node.sibling === null) {
+ if (node.return === null || node.return === workInProgress) {
+ return;
+ }
+
+ node = node.return;
+ }
+
+ node.sibling.return = node.return;
+ node = node.sibling;
+ }
+ };
+
+ updateHostContainer = function updateHostContainer(workInProgress) {
+ var portalOrRoot = workInProgress.stateNode;
+ var childrenUnchanged = workInProgress.firstEffect === null;
+
+ if (childrenUnchanged) {} else {
+ var container = portalOrRoot.containerInfo;
+ var newChildSet = createContainerChildSet(container);
+ appendAllChildrenToContainer(newChildSet, workInProgress, false, false);
+ portalOrRoot.pendingChildren = newChildSet;
+ markUpdate(workInProgress);
+ finalizeContainerChildren(container, newChildSet);
+ }
+ };
+
+ updateHostComponent$1 = function updateHostComponent$1(current, workInProgress, type, newProps, rootContainerInstance) {
+ var currentInstance = current.stateNode;
+ var oldProps = current.memoizedProps;
+ var childrenUnchanged = workInProgress.firstEffect === null;
+
+ if (childrenUnchanged && oldProps === newProps) {
+ workInProgress.stateNode = currentInstance;
+ return;
+ }
+
+ var recyclableInstance = workInProgress.stateNode;
+ var currentHostContext = getHostContext();
+ var updatePayload = null;
+
+ if (oldProps !== newProps) {
+ updatePayload = prepareUpdate(recyclableInstance, type, oldProps, newProps, rootContainerInstance, currentHostContext);
+ }
+
+ if (childrenUnchanged && updatePayload === null) {
+ workInProgress.stateNode = currentInstance;
+ return;
+ }
+
+ var newInstance = cloneInstance(currentInstance, updatePayload, type, oldProps, newProps, workInProgress, childrenUnchanged, recyclableInstance);
+
+ if (finalizeInitialChildren(newInstance, type, newProps, rootContainerInstance, currentHostContext)) {
+ markUpdate(workInProgress);
+ }
+
+ workInProgress.stateNode = newInstance;
+
+ if (childrenUnchanged) {
+ markUpdate(workInProgress);
+ } else {
+ _appendAllChildren(newInstance, workInProgress, false, false);
+ }
+ };
+
+ updateHostText$1 = function updateHostText$1(current, workInProgress, oldText, newText) {
+ if (oldText !== newText) {
+ var rootContainerInstance = getRootHostContainer();
+ var currentHostContext = getHostContext();
+ workInProgress.stateNode = createTextInstance(newText, rootContainerInstance, currentHostContext, workInProgress);
+ markUpdate(workInProgress);
+ }
+ };
+ } else {
+ updateHostContainer = function updateHostContainer(workInProgress) {};
+
+ updateHostComponent$1 = function updateHostComponent$1(current, workInProgress, type, newProps, rootContainerInstance) {};
+
+ updateHostText$1 = function updateHostText$1(current, workInProgress, oldText, newText) {};
+ }
+
+ function completeWork(current, workInProgress, renderExpirationTime) {
+ var newProps = workInProgress.pendingProps;
+
+ switch (workInProgress.tag) {
+ case IndeterminateComponent:
+ break;
+
+ case LazyComponent:
+ break;
+
+ case SimpleMemoComponent:
+ case FunctionComponent:
+ break;
+
+ case ClassComponent:
+ {
+ var Component = workInProgress.type;
+
+ if (isContextProvider(Component)) {
+ popContext(workInProgress);
+ }
+
+ break;
+ }
+
+ case HostRoot:
+ {
+ popHostContainer(workInProgress);
+ popTopLevelContextObject(workInProgress);
+ var fiberRoot = workInProgress.stateNode;
+
+ if (fiberRoot.pendingContext) {
+ fiberRoot.context = fiberRoot.pendingContext;
+ fiberRoot.pendingContext = null;
+ }
+
+ if (current === null || current.child === null) {
+ popHydrationState(workInProgress);
+ workInProgress.effectTag &= ~Placement;
+ }
+
+ updateHostContainer(workInProgress);
+ break;
+ }
+
+ case HostComponent:
+ {
+ popHostContext(workInProgress);
+ var rootContainerInstance = getRootHostContainer();
+ var type = workInProgress.type;
+
+ if (current !== null && workInProgress.stateNode != null) {
+ updateHostComponent$1(current, workInProgress, type, newProps, rootContainerInstance);
+
+ if (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.");
+ break;
+ }
+
+ 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, false, false);
+
+ if (finalizeInitialChildren(instance, type, newProps, rootContainerInstance, currentHostContext)) {
+ markUpdate(workInProgress);
+ }
+
+ workInProgress.stateNode = instance;
+ }
+
+ if (workInProgress.ref !== null) {
+ markRef$1(workInProgress);
+ }
+ }
+
+ break;
+ }
+
+ case HostText:
+ {
+ var newText = newProps;
+
+ if (current && workInProgress.stateNode != null) {
+ var oldText = current.memoizedProps;
+ updateHostText$1(current, workInProgress, oldText, newText);
+ } else {
+ if (typeof newText !== "string") {
+ 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.");
+ }
+
+ var _rootContainerInstance = getRootHostContainer();
+
+ var _currentHostContext = getHostContext();
+
+ var _wasHydrated = popHydrationState(workInProgress);
+
+ if (_wasHydrated) {
+ if (prepareToHydrateHostTextInstance(workInProgress)) {
+ markUpdate(workInProgress);
+ }
+ } else {
+ workInProgress.stateNode = createTextInstance(newText, _rootContainerInstance, _currentHostContext, workInProgress);
+ }
+ }
+
+ break;
+ }
+
+ case ForwardRef:
+ break;
+
+ case SuspenseComponent:
+ {
+ var nextState = workInProgress.memoizedState;
+
+ if ((workInProgress.effectTag & DidCapture) !== NoEffect) {
+ workInProgress.expirationTime = renderExpirationTime;
+ return workInProgress;
+ }
+
+ var nextDidTimeout = nextState !== null;
+ var prevDidTimeout = current !== null && current.memoizedState !== null;
+
+ if (current === null) {
+ popHydrationState(workInProgress);
+ } else if (!nextDidTimeout && prevDidTimeout) {
+ var currentFallbackChild = current.child.sibling;
+
+ if (currentFallbackChild !== null) {
+ var first = workInProgress.firstEffect;
+
+ if (first !== null) {
+ workInProgress.firstEffect = currentFallbackChild;
+ currentFallbackChild.nextEffect = first;
+ } else {
+ workInProgress.firstEffect = workInProgress.lastEffect = currentFallbackChild;
+ currentFallbackChild.nextEffect = null;
+ }
+
+ currentFallbackChild.effectTag = Deletion;
+ }
+ }
+
+ if (nextDidTimeout || prevDidTimeout) {
+ workInProgress.effectTag |= Update;
+ }
+
+ break;
+ }
+
+ case Fragment:
+ break;
+
+ case Mode:
+ break;
+
+ case Profiler:
+ break;
+
+ case HostPortal:
+ popHostContainer(workInProgress);
+ updateHostContainer(workInProgress);
+ break;
+
+ case ContextProvider:
+ popProvider(workInProgress);
+ break;
+
+ case ContextConsumer:
+ break;
+
+ case MemoComponent:
+ break;
+
+ case IncompleteClassComponent:
+ {
+ var _Component = workInProgress.type;
+
+ if (isContextProvider(_Component)) {
+ popContext(workInProgress);
+ }
+
+ break;
+ }
+
+ case DehydratedSuspenseComponent:
+ {
+ if (enableSuspenseServerRenderer) {
+ if (current === null) {
+ var _wasHydrated2 = popHydrationState(workInProgress);
+
+ invariant(_wasHydrated2, "A dehydrated suspense component was completed without a hydrated node. " + "This is probably a bug in React.");
+ skipPastDehydratedSuspenseInstance(workInProgress);
+ } else if ((workInProgress.effectTag & DidCapture) === NoEffect) {
+ current.alternate = null;
+ workInProgress.alternate = null;
+ workInProgress.tag = SuspenseComponent;
+ workInProgress.memoizedState = null;
+ workInProgress.stateNode = null;
+ }
+ }
+
+ break;
+ }
+
+ default:
+ invariant(false, "Unknown unit of work tag. This error is likely caused by a bug in " + "React. Please file an issue.");
+ }
+
+ return null;
+ }
+
+ function shouldCaptureSuspense(workInProgress) {
+ if (workInProgress.memoizedProps.fallback === undefined) {
+ return false;
+ }
+
+ var nextState = workInProgress.memoizedState;
+ return nextState === null;
+ }
+
+ 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 componentName = capturedError.componentName,
+ componentStack = capturedError.componentStack,
+ errorBoundaryName = capturedError.errorBoundaryName,
+ errorBoundaryFound = capturedError.errorBoundaryFound,
+ willRetry = capturedError.willRetry;
+
+ if (error != null && error._suppressLogging) {
+ if (errorBoundaryFound && willRetry) {
+ return;
+ }
+
+ console.error(error);
+ }
+
+ var componentNameMessage = componentName ? "The above error occurred in the <" + componentName + "> component:" : "The above error occurred in one of your React components:";
+ var errorBoundaryMessage = void 0;
+
+ if (errorBoundaryFound && errorBoundaryName) {
+ if (willRetry) {
+ errorBoundaryMessage = "React will try to recreate this component tree from scratch " + ("using the error boundary you provided, " + errorBoundaryName + ".");
+ } else {
+ errorBoundaryMessage = "This error was initially handled by the error boundary " + errorBoundaryName + ".\n" + "Recreating the tree from scratch failed so React will unmount the tree.";
+ }
+ } else {
+ errorBoundaryMessage = "Consider adding an error boundary to your tree to customize error handling behavior.\n" + "Visit https://fb.me/react-error-boundaries to learn more about error boundaries.";
+ }
+
+ var combinedMessage = "" + componentNameMessage + componentStack + "\n\n" + ("" + errorBoundaryMessage);
+ console.error(combinedMessage);
+ }
+ }
+
+ var didWarnAboutUndefinedSnapshotBeforeUpdate = null;
+ {
+ didWarnAboutUndefinedSnapshotBeforeUpdate = new Set();
+ }
+ var PossiblyWeakSet$1 = typeof WeakSet === "function" ? WeakSet : Set;
+
+ function logError(boundary, errorInfo) {
+ var source = errorInfo.source;
+ var stack = errorInfo.stack;
+
+ if (stack === null && source !== null) {
+ stack = getStackByFiberInDevAndProd(source);
+ }
+
+ var capturedError = {
+ componentName: source !== null ? getComponentName(source.type) : null,
+ componentStack: stack !== null ? stack : "",
+ error: errorInfo.value,
+ errorBoundary: null,
+ errorBoundaryName: null,
+ errorBoundaryFound: false,
+ willRetry: false
+ };
+
+ if (boundary !== null && boundary.tag === ClassComponent) {
+ capturedError.errorBoundary = boundary.stateNode;
+ capturedError.errorBoundaryName = getComponentName(boundary.type);
+ capturedError.errorBoundaryFound = true;
+ capturedError.willRetry = true;
+ }
+
+ try {
+ logCapturedError(capturedError);
+ } catch (e) {
+ setTimeout(function () {
+ throw e;
+ });
+ }
+ }
+
+ var callComponentWillUnmountWithTimer = function callComponentWillUnmountWithTimer(current$$1, instance) {
+ startPhaseTimer(current$$1, "componentWillUnmount");
+ instance.props = current$$1.memoizedProps;
+ instance.state = current$$1.memoizedState;
+ instance.componentWillUnmount();
+ stopPhaseTimer();
+ };
+
+ function safelyCallComponentWillUnmount(current$$1, instance) {
+ {
+ invokeGuardedCallback(null, callComponentWillUnmountWithTimer, null, current$$1, instance);
+
+ if (hasCaughtError()) {
+ var unmountError = clearCaughtError();
+ captureCommitPhaseError(current$$1, unmountError);
+ }
+ }
+ }
+
+ function safelyDetachRef(current$$1) {
+ var ref = current$$1.ref;
+
+ if (ref !== null) {
+ if (typeof ref === "function") {
+ {
+ invokeGuardedCallback(null, ref, null, null);
+
+ if (hasCaughtError()) {
+ var refError = clearCaughtError();
+ captureCommitPhaseError(current$$1, refError);
+ }
+ }
+ } else {
+ ref.current = null;
+ }
+ }
+ }
+
+ function safelyCallDestroy(current$$1, destroy) {
+ {
+ invokeGuardedCallback(null, destroy, null);
+
+ if (hasCaughtError()) {
+ var error = clearCaughtError();
+ captureCommitPhaseError(current$$1, error);
+ }
+ }
+ }
+
+ function commitBeforeMutationLifeCycles(current$$1, finishedWork) {
+ switch (finishedWork.tag) {
+ case FunctionComponent:
+ case ForwardRef:
+ case SimpleMemoComponent:
+ {
+ commitHookEffectList(UnmountSnapshot, NoEffect$1, finishedWork);
+ return;
+ }
+
+ case ClassComponent:
+ {
+ if (finishedWork.effectTag & Snapshot) {
+ if (current$$1 !== null) {
+ var prevProps = current$$1.memoizedProps;
+ var prevState = current$$1.memoizedState;
+ startPhaseTimer(finishedWork, "getSnapshotBeforeUpdate");
+ var instance = finishedWork.stateNode;
+ {
+ if (finishedWork.type === finishedWork.elementType && !didWarnAboutReassigningProps) {
+ !(instance.props === finishedWork.memoizedProps) ? warning$1(false, "Expected %s props to match memoized props before " + "getSnapshotBeforeUpdate. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
+ !(instance.state === finishedWork.memoizedState) ? warning$1(false, "Expected %s state to match memoized state before " + "getSnapshotBeforeUpdate. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
+ }
+ }
+ var snapshot = instance.getSnapshotBeforeUpdate(finishedWork.elementType === finishedWork.type ? prevProps : resolveDefaultProps(finishedWork.type, prevProps), prevState);
+ {
+ var didWarnSet = didWarnAboutUndefinedSnapshotBeforeUpdate;
+
+ if (snapshot === undefined && !didWarnSet.has(finishedWork.type)) {
+ didWarnSet.add(finishedWork.type);
+ warningWithoutStack$1(false, "%s.getSnapshotBeforeUpdate(): A snapshot value (or null) " + "must be returned. You have returned undefined.", getComponentName(finishedWork.type));
+ }
+ }
+ instance.__reactInternalSnapshotBeforeUpdate = snapshot;
+ stopPhaseTimer();
+ }
+ }
+
+ return;
+ }
+
+ case HostRoot:
+ case HostComponent:
+ case HostText:
+ case HostPortal:
+ case IncompleteClassComponent:
+ return;
+
+ default:
+ {
+ 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 commitHookEffectList(unmountTag, mountTag, finishedWork) {
+ var updateQueue = finishedWork.updateQueue;
+ var lastEffect = updateQueue !== null ? updateQueue.lastEffect : null;
+
+ if (lastEffect !== null) {
+ var firstEffect = lastEffect.next;
+ var effect = firstEffect;
+
+ do {
+ if ((effect.tag & unmountTag) !== NoEffect$1) {
+ var destroy = effect.destroy;
+ effect.destroy = undefined;
+
+ if (destroy !== undefined) {
+ destroy();
+ }
+ }
+
+ if ((effect.tag & mountTag) !== NoEffect$1) {
+ var create = effect.create;
+ effect.destroy = create();
+ {
+ var _destroy = effect.destroy;
+
+ if (_destroy !== undefined && typeof _destroy !== "function") {
+ var addendum = void 0;
+
+ if (_destroy === null) {
+ addendum = " You returned null. If your effect does not require clean " + "up, return undefined (or nothing).";
+ } else if (typeof _destroy.then === "function") {
+ addendum = "\n\nIt looks like you wrote useEffect(async () => ...) or returned a Promise. " + "Instead, you may write an async function separately " + "and then call it from inside the effect:\n\n" + "async function fetchComment(commentId) {\n" + " // You can await here\n" + "}\n\n" + "useEffect(() => {\n" + " fetchComment(commentId);\n" + "}, [commentId]);\n\n" + "In the future, React will provide a more idiomatic solution for data fetching " + "that doesn't involve writing effects manually.";
+ } else {
+ addendum = " You returned: " + _destroy;
+ }
+
+ warningWithoutStack$1(false, "An Effect function must not return anything besides a function, " + "which is used for clean-up.%s%s", addendum, getStackByFiberInDevAndProd(finishedWork));
+ }
+ }
+ }
+
+ effect = effect.next;
+ } while (effect !== firstEffect);
+ }
+ }
+
+ function commitPassiveHookEffects(finishedWork) {
+ commitHookEffectList(UnmountPassive, NoEffect$1, finishedWork);
+ commitHookEffectList(NoEffect$1, MountPassive, finishedWork);
+ }
+
+ function commitLifeCycles(finishedRoot, current$$1, finishedWork, committedExpirationTime) {
+ switch (finishedWork.tag) {
+ case FunctionComponent:
+ case ForwardRef:
+ case SimpleMemoComponent:
+ {
+ commitHookEffectList(UnmountLayout, MountLayout, finishedWork);
+ break;
+ }
+
+ case ClassComponent:
+ {
+ var instance = finishedWork.stateNode;
+
+ if (finishedWork.effectTag & Update) {
+ if (current$$1 === null) {
+ startPhaseTimer(finishedWork, "componentDidMount");
+ {
+ if (finishedWork.type === finishedWork.elementType && !didWarnAboutReassigningProps) {
+ !(instance.props === finishedWork.memoizedProps) ? warning$1(false, "Expected %s props to match memoized props before " + "componentDidMount. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
+ !(instance.state === finishedWork.memoizedState) ? warning$1(false, "Expected %s state to match memoized state before " + "componentDidMount. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
+ }
+ }
+ instance.componentDidMount();
+ stopPhaseTimer();
+ } else {
+ var prevProps = finishedWork.elementType === finishedWork.type ? current$$1.memoizedProps : resolveDefaultProps(finishedWork.type, current$$1.memoizedProps);
+ var prevState = current$$1.memoizedState;
+ startPhaseTimer(finishedWork, "componentDidUpdate");
+ {
+ if (finishedWork.type === finishedWork.elementType && !didWarnAboutReassigningProps) {
+ !(instance.props === finishedWork.memoizedProps) ? warning$1(false, "Expected %s props to match memoized props before " + "componentDidUpdate. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
+ !(instance.state === finishedWork.memoizedState) ? warning$1(false, "Expected %s state to match memoized state before " + "componentDidUpdate. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
+ }
+ }
+ instance.componentDidUpdate(prevProps, prevState, instance.__reactInternalSnapshotBeforeUpdate);
+ stopPhaseTimer();
+ }
+ }
+
+ var updateQueue = finishedWork.updateQueue;
+
+ if (updateQueue !== null) {
+ {
+ if (finishedWork.type === finishedWork.elementType && !didWarnAboutReassigningProps) {
+ !(instance.props === finishedWork.memoizedProps) ? warning$1(false, "Expected %s props to match memoized props before " + "processing the update queue. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
+ !(instance.state === finishedWork.memoizedState) ? warning$1(false, "Expected %s state to match memoized state before " + "processing the update queue. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
+ }
+ }
+ commitUpdateQueue(finishedWork, updateQueue, instance, committedExpirationTime);
+ }
+
+ return;
+ }
+
+ case HostRoot:
+ {
+ var _updateQueue = finishedWork.updateQueue;
+
+ if (_updateQueue !== null) {
+ var _instance = null;
+
+ if (finishedWork.child !== null) {
+ switch (finishedWork.child.tag) {
+ case HostComponent:
+ _instance = getPublicInstance(finishedWork.child.stateNode);
+ break;
+
+ case ClassComponent:
+ _instance = finishedWork.child.stateNode;
+ break;
+ }
+ }
+
+ commitUpdateQueue(finishedWork, _updateQueue, _instance, committedExpirationTime);
+ }
+
+ return;
+ }
+
+ case HostComponent:
+ {
+ var _instance2 = finishedWork.stateNode;
+
+ if (current$$1 === null && finishedWork.effectTag & Update) {
+ var type = finishedWork.type;
+ var props = finishedWork.memoizedProps;
+ }
+
+ return;
+ }
+
+ case HostText:
+ {
+ return;
+ }
+
+ case HostPortal:
+ {
+ return;
+ }
+
+ case Profiler:
+ {
+ if (enableProfilerTimer) {
+ var onRender = finishedWork.memoizedProps.onRender;
+
+ if (enableSchedulerTracing) {
+ onRender(finishedWork.memoizedProps.id, current$$1 === null ? "mount" : "update", finishedWork.actualDuration, finishedWork.treeBaseDuration, finishedWork.actualStartTime, getCommitTime(), finishedRoot.memoizedInteractions);
+ } else {
+ onRender(finishedWork.memoizedProps.id, current$$1 === null ? "mount" : "update", finishedWork.actualDuration, finishedWork.treeBaseDuration, finishedWork.actualStartTime, getCommitTime());
+ }
+ }
+
+ return;
+ }
+
+ case SuspenseComponent:
+ break;
+
+ case IncompleteClassComponent:
+ break;
+
+ 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 hideOrUnhideAllChildren(finishedWork, isHidden) {
+ if (supportsMutation) {
+ var node = finishedWork;
+
+ while (true) {
+ if (node.tag === HostComponent) {
+ var instance = node.stateNode;
+
+ if (isHidden) {
+ hideInstance(instance);
+ } else {
+ unhideInstance(node.stateNode, node.memoizedProps);
+ }
+ } else if (node.tag === HostText) {
+ var _instance3 = node.stateNode;
+
+ if (isHidden) {
+ hideTextInstance(_instance3);
+ } else {
+ unhideTextInstance(_instance3, node.memoizedProps);
+ }
+ } else if (node.tag === SuspenseComponent && node.memoizedState !== null) {
+ var fallbackChildFragment = node.child.sibling;
+ fallbackChildFragment.return = node;
+ node = fallbackChildFragment;
+ continue;
+ } else if (node.child !== null) {
+ node.child.return = node;
+ node = node.child;
+ continue;
+ }
+
+ if (node === finishedWork) {
+ return;
+ }
+
+ while (node.sibling === null) {
+ if (node.return === null || node.return === finishedWork) {
+ return;
+ }
+
+ node = node.return;
+ }
+
+ node.sibling.return = node.return;
+ node = node.sibling;
+ }
+ }
+ }
+
+ function commitAttachRef(finishedWork) {
+ var ref = finishedWork.ref;
+
+ if (ref !== null) {
+ var instance = finishedWork.stateNode;
+ var instanceToUse = void 0;
+
+ switch (finishedWork.tag) {
+ case HostComponent:
+ instanceToUse = getPublicInstance(instance);
+ break;
+
+ default:
+ instanceToUse = instance;
+ }
+
+ if (typeof ref === "function") {
+ ref(instanceToUse);
+ } else {
+ {
+ if (!ref.hasOwnProperty("current")) {
+ warningWithoutStack$1(false, "Unexpected ref object provided for %s. " + "Use either a ref-setter function or React.createRef().%s", getComponentName(finishedWork.type), getStackByFiberInDevAndProd(finishedWork));
+ }
+ }
+ ref.current = instanceToUse;
+ }
+ }
+ }
+
+ function commitDetachRef(current$$1) {
+ var currentRef = current$$1.ref;
+
+ if (currentRef !== null) {
+ if (typeof currentRef === "function") {
+ currentRef(null);
+ } else {
+ currentRef.current = null;
+ }
+ }
+ }
+
+ function commitUnmount(current$$1) {
+ onCommitUnmount(current$$1);
+
+ switch (current$$1.tag) {
+ case FunctionComponent:
+ case ForwardRef:
+ case MemoComponent:
+ case SimpleMemoComponent:
+ {
+ var updateQueue = current$$1.updateQueue;
+
+ if (updateQueue !== null) {
+ var lastEffect = updateQueue.lastEffect;
+
+ if (lastEffect !== null) {
+ var firstEffect = lastEffect.next;
+ var effect = firstEffect;
+
+ do {
+ var destroy = effect.destroy;
+
+ if (destroy !== undefined) {
+ safelyCallDestroy(current$$1, destroy);
+ }
+
+ effect = effect.next;
+ } while (effect !== firstEffect);
+ }
+ }
+
+ break;
+ }
+
+ case ClassComponent:
+ {
+ safelyDetachRef(current$$1);
+ var instance = current$$1.stateNode;
+
+ if (typeof instance.componentWillUnmount === "function") {
+ safelyCallComponentWillUnmount(current$$1, instance);
+ }
+
+ return;
+ }
+
+ case HostComponent:
+ {
+ safelyDetachRef(current$$1);
+ return;
+ }
+
+ case HostPortal:
+ {
+ if (supportsMutation) {
+ unmountHostComponents(current$$1);
+ } else if (supportsPersistence) {
+ emptyPortalContainer(current$$1);
+ }
+
+ 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$$1) {
+ current$$1.return = null;
+ current$$1.child = null;
+ current$$1.memoizedState = null;
+ current$$1.updateQueue = null;
+ var alternate = current$$1.alternate;
+
+ if (alternate !== null) {
+ alternate.return = null;
+ alternate.child = null;
+ alternate.memoizedState = null;
+ alternate.updateQueue = null;
+ }
+ }
+
+ function emptyPortalContainer(current$$1) {
+ if (!supportsPersistence) {
+ return;
+ }
+
+ var portal = current$$1.stateNode;
+ var containerInfo = portal.containerInfo;
+ var emptyChildSet = createContainerChildSet(containerInfo);
+ replaceContainerChildren(containerInfo, emptyChildSet);
+ }
+
+ function commitContainer(finishedWork) {
+ if (!supportsPersistence) {
+ return;
+ }
+
+ switch (finishedWork.tag) {
+ case ClassComponent:
+ {
+ 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 && node.tag !== DehydratedSuspenseComponent) {
+ if (node.effectTag & Placement) {
+ continue siblings;
+ }
+
+ if (node.child === null || node.tag === HostPortal) {
+ continue siblings;
+ } else {
+ node.child.return = node;
+ node = node.child;
+ }
+ }
+
+ if (!(node.effectTag & Placement)) {
+ return node.stateNode;
+ }
+ }
+ }
+
+ function commitPlacement(finishedWork) {
+ if (!supportsMutation) {
+ return;
+ }
+
+ var parentFiber = getHostParentFiber(finishedWork);
+ var parent = void 0;
+ var isContainer = void 0;
+
+ 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$$1) {
+ var node = current$$1;
+ var currentParentIsValid = false;
+ var currentParent = void 0;
+ var currentParentIsContainer = void 0;
+
+ while (true) {
+ if (!currentParentIsValid) {
+ var parent = node.return;
+
+ findParent: while (true) {
+ 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 (enableSuspenseServerRenderer && node.tag === DehydratedSuspenseComponent) {
+ if (currentParentIsContainer) {
+ clearSuspenseBoundaryFromContainer(currentParent, node.stateNode);
+ } else {
+ clearSuspenseBoundary(currentParent, node.stateNode);
+ }
+ } else if (node.tag === HostPortal) {
+ if (node.child !== null) {
+ currentParent = node.stateNode.containerInfo;
+ currentParentIsContainer = true;
+ node.child.return = node;
+ node = node.child;
+ continue;
+ }
+ } else {
+ commitUnmount(node);
+
+ if (node.child !== null) {
+ node.child.return = node;
+ node = node.child;
+ continue;
+ }
+ }
+
+ if (node === current$$1) {
+ return;
+ }
+
+ while (node.sibling === null) {
+ if (node.return === null || node.return === current$$1) {
+ return;
+ }
+
+ node = node.return;
+
+ if (node.tag === HostPortal) {
+ currentParentIsValid = false;
+ }
+ }
+
+ node.sibling.return = node.return;
+ node = node.sibling;
+ }
+ }
+
+ function commitDeletion(current$$1) {
+ if (supportsMutation) {
+ unmountHostComponents(current$$1);
+ } else {
+ commitNestedUnmounts(current$$1);
+ }
+
+ detachFiber(current$$1);
+ }
+
+ function commitWork(current$$1, finishedWork) {
+ if (!supportsMutation) {
+ switch (finishedWork.tag) {
+ case FunctionComponent:
+ case ForwardRef:
+ case MemoComponent:
+ case SimpleMemoComponent:
+ {
+ commitHookEffectList(UnmountMutation, MountMutation, finishedWork);
+ return;
+ }
+ }
+
+ commitContainer(finishedWork);
+ return;
+ }
+
+ switch (finishedWork.tag) {
+ case FunctionComponent:
+ case ForwardRef:
+ case MemoComponent:
+ case SimpleMemoComponent:
+ {
+ commitHookEffectList(UnmountMutation, MountMutation, finishedWork);
+ return;
+ }
+
+ case ClassComponent:
+ {
+ return;
+ }
+
+ case HostComponent:
+ {
+ var instance = finishedWork.stateNode;
+
+ if (instance != null) {
+ var newProps = finishedWork.memoizedProps;
+ var oldProps = current$$1 !== null ? current$$1.memoizedProps : newProps;
+ var type = finishedWork.type;
+ var updatePayload = finishedWork.updateQueue;
+ finishedWork.updateQueue = null;
+
+ if (updatePayload !== null) {
+ commitUpdate(instance, updatePayload, type, oldProps, newProps, finishedWork);
+ }
+ }
+
+ return;
+ }
+
+ case HostText:
+ {
+ 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$$1 !== null ? current$$1.memoizedProps : newText;
+ commitTextUpdate(textInstance, oldText, newText);
+ return;
+ }
+
+ case HostRoot:
+ {
+ return;
+ }
+
+ case Profiler:
+ {
+ return;
+ }
+
+ case SuspenseComponent:
+ {
+ var newState = finishedWork.memoizedState;
+ var newDidTimeout = void 0;
+ var primaryChildParent = finishedWork;
+
+ if (newState === null) {
+ newDidTimeout = false;
+ } else {
+ newDidTimeout = true;
+ primaryChildParent = finishedWork.child;
+
+ if (newState.timedOutAt === NoWork) {
+ newState.timedOutAt = requestCurrentTime();
+ }
+ }
+
+ if (primaryChildParent !== null) {
+ hideOrUnhideAllChildren(primaryChildParent, newDidTimeout);
+ }
+
+ var thenables = finishedWork.updateQueue;
+
+ if (thenables !== null) {
+ finishedWork.updateQueue = null;
+ var retryCache = finishedWork.stateNode;
+
+ if (retryCache === null) {
+ retryCache = finishedWork.stateNode = new PossiblyWeakSet$1();
+ }
+
+ thenables.forEach(function (thenable) {
+ var retry = resolveRetryThenable.bind(null, finishedWork, thenable);
+
+ if (enableSchedulerTracing) {
+ retry = tracing.unstable_wrap(retry);
+ }
+
+ if (!retryCache.has(thenable)) {
+ retryCache.add(thenable);
+ thenable.then(retry, retry);
+ }
+ });
+ }
+
+ return;
+ }
+
+ case IncompleteClassComponent:
+ {
+ 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$$1) {
+ if (!supportsMutation) {
+ return;
+ }
+
+ resetTextContent(current$$1.stateNode);
+ }
+
+ var PossiblyWeakSet = typeof WeakSet === "function" ? WeakSet : Set;
+ var PossiblyWeakMap = typeof WeakMap === "function" ? WeakMap : Map;
+
+ function createRootErrorUpdate(fiber, errorInfo, expirationTime) {
+ var update = createUpdate(expirationTime);
+ 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 getDerivedStateFromError = fiber.type.getDerivedStateFromError;
+
+ if (typeof getDerivedStateFromError === "function") {
+ var error = errorInfo.value;
+
+ update.payload = function () {
+ return getDerivedStateFromError(error);
+ };
+ }
+
+ var inst = fiber.stateNode;
+
+ if (inst !== null && typeof inst.componentDidCatch === "function") {
+ update.callback = function callback() {
+ if (typeof getDerivedStateFromError !== "function") {
+ markLegacyErrorBoundaryAsFailed(this);
+ }
+
+ var error = errorInfo.value;
+ var stack = errorInfo.stack;
+ logError(fiber, errorInfo);
+ this.componentDidCatch(error, {
+ componentStack: stack !== null ? stack : ""
+ });
+ {
+ if (typeof getDerivedStateFromError !== "function") {
+ !(fiber.expirationTime === Sync) ? warningWithoutStack$1(false, "%s: Error boundaries should implement getDerivedStateFromError(). " + "In that method, return a state update to display an error message or fallback UI.", getComponentName(fiber.type) || "Unknown") : void 0;
+ }
+ }
+ };
+ }
+
+ return update;
+ }
+
+ function attachPingListener(root, renderExpirationTime, thenable) {
+ var pingCache = root.pingCache;
+ var threadIDs = void 0;
+
+ if (pingCache === null) {
+ pingCache = root.pingCache = new PossiblyWeakMap();
+ threadIDs = new Set();
+ pingCache.set(thenable, threadIDs);
+ } else {
+ threadIDs = pingCache.get(thenable);
+
+ if (threadIDs === undefined) {
+ threadIDs = new Set();
+ pingCache.set(thenable, threadIDs);
+ }
+ }
+
+ if (!threadIDs.has(renderExpirationTime)) {
+ threadIDs.add(renderExpirationTime);
+ var ping = pingSuspendedRoot.bind(null, root, thenable, renderExpirationTime);
+
+ if (enableSchedulerTracing) {
+ ping = tracing.unstable_wrap(ping);
+ }
+
+ thenable.then(ping, ping);
+ }
+ }
+
+ function throwException(root, returnFiber, sourceFiber, value, renderExpirationTime) {
+ sourceFiber.effectTag |= Incomplete;
+ sourceFiber.firstEffect = sourceFiber.lastEffect = null;
+
+ if (value !== null && typeof value === "object" && typeof value.then === "function") {
+ var thenable = value;
+ var _workInProgress = returnFiber;
+ var earliestTimeoutMs = -1;
+ var startTimeMs = -1;
+
+ do {
+ if (_workInProgress.tag === SuspenseComponent) {
+ var current$$1 = _workInProgress.alternate;
+
+ if (current$$1 !== null) {
+ var currentState = current$$1.memoizedState;
+
+ if (currentState !== null) {
+ var timedOutAt = currentState.timedOutAt;
+ startTimeMs = expirationTimeToMs(timedOutAt);
+ break;
+ }
+ }
+
+ var timeoutPropMs = _workInProgress.pendingProps.maxDuration;
+
+ if (typeof timeoutPropMs === "number") {
+ if (timeoutPropMs <= 0) {
+ earliestTimeoutMs = 0;
+ } else if (earliestTimeoutMs === -1 || timeoutPropMs < earliestTimeoutMs) {
+ earliestTimeoutMs = timeoutPropMs;
+ }
+ }
+ }
+
+ _workInProgress = _workInProgress.return;
+ } while (_workInProgress !== null);
+
+ _workInProgress = returnFiber;
+
+ do {
+ if (_workInProgress.tag === SuspenseComponent && shouldCaptureSuspense(_workInProgress)) {
+ var thenables = _workInProgress.updateQueue;
+
+ if (thenables === null) {
+ var updateQueue = new Set();
+ updateQueue.add(thenable);
+ _workInProgress.updateQueue = updateQueue;
+ } else {
+ thenables.add(thenable);
+ }
+
+ if ((_workInProgress.mode & ConcurrentMode) === NoEffect) {
+ _workInProgress.effectTag |= DidCapture;
+ sourceFiber.effectTag &= ~(LifecycleEffectMask | Incomplete);
+
+ if (sourceFiber.tag === ClassComponent) {
+ var currentSourceFiber = sourceFiber.alternate;
+
+ if (currentSourceFiber === null) {
+ sourceFiber.tag = IncompleteClassComponent;
+ } else {
+ var update = createUpdate(Sync);
+ update.tag = ForceUpdate;
+ enqueueUpdate(sourceFiber, update);
+ }
+ }
+
+ sourceFiber.expirationTime = Sync;
+ return;
+ }
+
+ attachPingListener(root, renderExpirationTime, thenable);
+ var absoluteTimeoutMs = void 0;
+
+ if (earliestTimeoutMs === -1) {
+ absoluteTimeoutMs = maxSigned31BitInt;
+ } else {
+ if (startTimeMs === -1) {
+ var earliestExpirationTime = findEarliestOutstandingPriorityLevel(root, renderExpirationTime);
+ var earliestExpirationTimeMs = expirationTimeToMs(earliestExpirationTime);
+ startTimeMs = earliestExpirationTimeMs - LOW_PRIORITY_EXPIRATION;
+ }
+
+ absoluteTimeoutMs = startTimeMs + earliestTimeoutMs;
+ }
+
+ renderDidSuspend(root, absoluteTimeoutMs, renderExpirationTime);
+ _workInProgress.effectTag |= ShouldCapture;
+ _workInProgress.expirationTime = renderExpirationTime;
+ return;
+ } else if (enableSuspenseServerRenderer && _workInProgress.tag === DehydratedSuspenseComponent) {
+ attachPingListener(root, renderExpirationTime, thenable);
+ var retryCache = _workInProgress.memoizedState;
+
+ if (retryCache === null) {
+ retryCache = _workInProgress.memoizedState = new PossiblyWeakSet();
+ var _current = _workInProgress.alternate;
+ invariant(_current, "A dehydrated suspense boundary must commit before trying to render. " + "This is probably a bug in React.");
+ _current.memoizedState = retryCache;
+ }
+
+ if (!retryCache.has(thenable)) {
+ retryCache.add(thenable);
+ var retry = resolveRetryThenable.bind(null, _workInProgress, thenable);
+
+ if (enableSchedulerTracing) {
+ retry = tracing.unstable_wrap(retry);
+ }
+
+ thenable.then(retry, retry);
+ }
+
+ _workInProgress.effectTag |= ShouldCapture;
+ _workInProgress.expirationTime = renderExpirationTime;
+ return;
+ }
+
+ _workInProgress = _workInProgress.return;
+ } while (_workInProgress !== null);
+
+ value = new Error((getComponentName(sourceFiber.type) || "A React component") + " suspended while rendering, but no fallback UI was specified.\n" + "\n" + "Add a component higher in the tree to " + "provide a loading indicator or placeholder to display." + getStackByFiberInDevAndProd(sourceFiber));
+ }
+
+ renderDidError();
+ value = createCapturedValue(value, sourceFiber);
+ var workInProgress = returnFiber;
+
+ do {
+ switch (workInProgress.tag) {
+ case HostRoot:
+ {
+ var _errorInfo = value;
+ workInProgress.effectTag |= ShouldCapture;
+ workInProgress.expirationTime = renderExpirationTime;
+
+ var _update = createRootErrorUpdate(workInProgress, _errorInfo, renderExpirationTime);
+
+ enqueueCapturedUpdate(workInProgress, _update);
+ return;
+ }
+
+ case ClassComponent:
+ var errorInfo = value;
+ var ctor = workInProgress.type;
+ var instance = workInProgress.stateNode;
+
+ if ((workInProgress.effectTag & DidCapture) === NoEffect && (typeof ctor.getDerivedStateFromError === "function" || instance !== null && typeof instance.componentDidCatch === "function" && !isAlreadyFailedLegacyErrorBoundary(instance))) {
+ workInProgress.effectTag |= ShouldCapture;
+ workInProgress.expirationTime = renderExpirationTime;
+
+ var _update2 = createClassErrorUpdate(workInProgress, errorInfo, renderExpirationTime);
+
+ enqueueCapturedUpdate(workInProgress, _update2);
+ return;
+ }
+
+ break;
+
+ default:
+ break;
+ }
+
+ workInProgress = workInProgress.return;
+ } while (workInProgress !== null);
+ }
+
+ function unwindWork(workInProgress, renderExpirationTime) {
+ switch (workInProgress.tag) {
+ case ClassComponent:
+ {
+ var Component = workInProgress.type;
+
+ if (isContextProvider(Component)) {
+ popContext(workInProgress);
+ }
+
+ var effectTag = workInProgress.effectTag;
+
+ if (effectTag & ShouldCapture) {
+ workInProgress.effectTag = effectTag & ~ShouldCapture | DidCapture;
+ return workInProgress;
+ }
+
+ return null;
+ }
+
+ case HostRoot:
+ {
+ popHostContainer(workInProgress);
+ popTopLevelContextObject(workInProgress);
+ var _effectTag = workInProgress.effectTag;
+ invariant((_effectTag & DidCapture) === NoEffect, "The root failed to unmount after an error. This is likely a bug in " + "React. Please file an issue.");
+ workInProgress.effectTag = _effectTag & ~ShouldCapture | DidCapture;
+ return workInProgress;
+ }
+
+ case HostComponent:
+ {
+ popHostContext(workInProgress);
+ return null;
+ }
+
+ case SuspenseComponent:
+ {
+ var _effectTag2 = workInProgress.effectTag;
+
+ if (_effectTag2 & ShouldCapture) {
+ workInProgress.effectTag = _effectTag2 & ~ShouldCapture | DidCapture;
+ return workInProgress;
+ }
+
+ return null;
+ }
+
+ case DehydratedSuspenseComponent:
+ {
+ if (enableSuspenseServerRenderer) {
+ var _effectTag3 = workInProgress.effectTag;
+
+ if (_effectTag3 & ShouldCapture) {
+ workInProgress.effectTag = _effectTag3 & ~ShouldCapture | DidCapture;
+ return workInProgress;
+ }
+ }
+
+ return null;
+ }
+
+ case HostPortal:
+ popHostContainer(workInProgress);
+ return null;
+
+ case ContextProvider:
+ popProvider(workInProgress);
+ return null;
+
+ default:
+ return null;
+ }
+ }
+
+ function unwindInterruptedWork(interruptedWork) {
+ switch (interruptedWork.tag) {
+ case ClassComponent:
+ {
+ var childContextTypes = interruptedWork.type.childContextTypes;
+
+ if (childContextTypes !== null && childContextTypes !== undefined) {
+ popContext(interruptedWork);
+ }
+
+ break;
+ }
+
+ case HostRoot:
+ {
+ popHostContainer(interruptedWork);
+ popTopLevelContextObject(interruptedWork);
+ break;
+ }
+
+ case HostComponent:
+ {
+ popHostContext(interruptedWork);
+ break;
+ }
+
+ case HostPortal:
+ popHostContainer(interruptedWork);
+ break;
+
+ case ContextProvider:
+ popProvider(interruptedWork);
+ break;
+
+ default:
+ break;
+ }
+ }
+
+ var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+ var ReactCurrentOwner$2 = ReactSharedInternals.ReactCurrentOwner;
+ var didWarnAboutStateTransition = void 0;
+ var didWarnSetStateChildContext = void 0;
+ var warnAboutUpdateOnUnmounted = void 0;
+ var warnAboutInvalidUpdates = void 0;
+
+ if (enableSchedulerTracing) {
+ invariant(tracing.__interactionsRef != null && tracing.__interactionsRef.current != null, "It is not supported to run the profiling version of a renderer (for example, `react-dom/profiling`) " + "without also replacing the `scheduler/tracing` module with `scheduler/tracing-profiling`. " + "Your bundler might have a setting for aliasing both modules. " + "Learn more at http://fb.me/react-profiling");
+ }
+
+ {
+ didWarnAboutStateTransition = false;
+ didWarnSetStateChildContext = false;
+ var didWarnStateUpdateForUnmountedComponent = {};
+
+ warnAboutUpdateOnUnmounted = function warnAboutUpdateOnUnmounted(fiber, isClass) {
+ var componentName = getComponentName(fiber.type) || "ReactComponent";
+
+ if (didWarnStateUpdateForUnmountedComponent[componentName]) {
+ return;
+ }
+
+ warningWithoutStack$1(false, "Can't perform a React state update on an unmounted component. This " + "is a no-op, but it indicates a memory leak in your application. To " + "fix, cancel all subscriptions and asynchronous tasks in %s.%s", isClass ? "the componentWillUnmount method" : "a useEffect cleanup function", getStackByFiberInDevAndProd(fiber));
+ didWarnStateUpdateForUnmountedComponent[componentName] = true;
+ };
+
+ warnAboutInvalidUpdates = function warnAboutInvalidUpdates(instance) {
+ switch (phase) {
+ case "getChildContext":
+ if (didWarnSetStateChildContext) {
+ return;
+ }
+
+ warningWithoutStack$1(false, "setState(...): Cannot call setState() inside getChildContext()");
+ didWarnSetStateChildContext = true;
+ break;
+
+ case "render":
+ if (didWarnAboutStateTransition) {
+ return;
+ }
+
+ warningWithoutStack$1(false, "Cannot update during an existing state transition (such as within " + "`render`). Render methods should be a pure function of props and state.");
+ didWarnAboutStateTransition = true;
+ break;
+ }
+ };
+ }
+ var isWorking = false;
+ var nextUnitOfWork = null;
+ var nextRoot = null;
+ var nextRenderExpirationTime = NoWork;
+ var nextLatestAbsoluteTimeoutMs = -1;
+ var nextRenderDidError = false;
+ var nextEffect = null;
+ var isCommitting$1 = false;
+ var rootWithPendingPassiveEffects = null;
+ var passiveEffectCallbackHandle = null;
+ var passiveEffectCallback = null;
+ var legacyErrorBoundariesThatAlreadyFailed = null;
+ var interruptedBy = null;
+ var stashedWorkInProgressProperties = void 0;
+ var replayUnitOfWork = void 0;
+ var mayReplayFailedUnitOfWork = void 0;
+ var isReplayingFailedUnitOfWork = void 0;
+ var originalReplayError = void 0;
+ var rethrowOriginalError = void 0;
+
+ if (true && replayFailedUnitOfWorkWithInvokeGuardedCallback) {
+ stashedWorkInProgressProperties = null;
+ mayReplayFailedUnitOfWork = true;
+ isReplayingFailedUnitOfWork = false;
+ originalReplayError = null;
+
+ replayUnitOfWork = function replayUnitOfWork(failedUnitOfWork, thrownValue, isYieldy) {
+ if (thrownValue !== null && typeof thrownValue === "object" && typeof thrownValue.then === "function") {
+ return;
+ }
+
+ if (stashedWorkInProgressProperties === null) {
+ warningWithoutStack$1(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:
+ {
+ var Component = failedUnitOfWork.type;
+
+ if (isContextProvider(Component)) {
+ popContext(failedUnitOfWork);
+ }
+
+ break;
+ }
+
+ case HostPortal:
+ popHostContainer(failedUnitOfWork);
+ break;
+
+ case ContextProvider:
+ popProvider(failedUnitOfWork);
+ break;
+ }
+
+ isReplayingFailedUnitOfWork = true;
+ originalReplayError = thrownValue;
+ invokeGuardedCallback(null, workLoop, null, isYieldy);
+ isReplayingFailedUnitOfWork = false;
+ originalReplayError = null;
+
+ if (hasCaughtError()) {
+ var replayError = clearCaughtError();
+
+ if (replayError != null && thrownValue != null) {
+ try {
+ if (replayError._suppressLogging) {
+ thrownValue._suppressLogging = true;
+ }
+ } catch (inner) {}
+ }
+ } 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;
+ nextLatestAbsoluteTimeoutMs = -1;
+ nextRenderDidError = false;
+ nextUnitOfWork = null;
+ }
+
+ function commitAllHostEffects() {
+ while (nextEffect !== null) {
+ {
+ setCurrentFiber(nextEffect);
+ }
+ recordEffect();
+ var effectTag = nextEffect.effectTag;
+
+ if (effectTag & ContentReset) {
+ commitResetTextContent(nextEffect);
+ }
+
+ if (effectTag & Ref) {
+ var current$$1 = nextEffect.alternate;
+
+ if (current$$1 !== null) {
+ commitDetachRef(current$$1);
+ }
+ }
+
+ var primaryEffectTag = effectTag & (Placement | Update | Deletion);
+
+ switch (primaryEffectTag) {
+ case Placement:
+ {
+ commitPlacement(nextEffect);
+ nextEffect.effectTag &= ~Placement;
+ break;
+ }
+
+ case PlacementAndUpdate:
+ {
+ commitPlacement(nextEffect);
+ nextEffect.effectTag &= ~Placement;
+ var _current = nextEffect.alternate;
+ commitWork(_current, nextEffect);
+ break;
+ }
+
+ case Update:
+ {
+ var _current2 = nextEffect.alternate;
+ commitWork(_current2, nextEffect);
+ break;
+ }
+
+ case Deletion:
+ {
+ commitDeletion(nextEffect);
+ break;
+ }
+ }
+
+ nextEffect = nextEffect.nextEffect;
+ }
+
+ {
+ resetCurrentFiber();
+ }
+ }
+
+ function commitBeforeMutationLifecycles() {
+ while (nextEffect !== null) {
+ {
+ setCurrentFiber(nextEffect);
+ }
+ var effectTag = nextEffect.effectTag;
+
+ if (effectTag & Snapshot) {
+ recordEffect();
+ var current$$1 = nextEffect.alternate;
+ commitBeforeMutationLifeCycles(current$$1, nextEffect);
+ }
+
+ nextEffect = nextEffect.nextEffect;
+ }
+
+ {
+ resetCurrentFiber();
+ }
+ }
+
+ function commitAllLifeCycles(finishedRoot, committedExpirationTime) {
+ {
+ ReactStrictModeWarnings.flushPendingUnsafeLifecycleWarnings();
+ ReactStrictModeWarnings.flushLegacyContextWarning();
+
+ if (warnAboutDeprecatedLifecycles) {
+ ReactStrictModeWarnings.flushPendingDeprecationWarnings();
+ }
+ }
+
+ while (nextEffect !== null) {
+ {
+ setCurrentFiber(nextEffect);
+ }
+ var effectTag = nextEffect.effectTag;
+
+ if (effectTag & (Update | Callback)) {
+ recordEffect();
+ var current$$1 = nextEffect.alternate;
+ commitLifeCycles(finishedRoot, current$$1, nextEffect, committedExpirationTime);
+ }
+
+ if (effectTag & Ref) {
+ recordEffect();
+ commitAttachRef(nextEffect);
+ }
+
+ if (effectTag & Passive) {
+ rootWithPendingPassiveEffects = finishedRoot;
+ }
+
+ nextEffect = nextEffect.nextEffect;
+ }
+
+ {
+ resetCurrentFiber();
+ }
+ }
+
+ function commitPassiveEffects(root, firstEffect) {
+ rootWithPendingPassiveEffects = null;
+ passiveEffectCallbackHandle = null;
+ passiveEffectCallback = null;
+ var previousIsRendering = isRendering;
+ isRendering = true;
+ var effect = firstEffect;
+
+ do {
+ {
+ setCurrentFiber(effect);
+ }
+
+ if (effect.effectTag & Passive) {
+ var didError = false;
+ var error = void 0;
+ {
+ invokeGuardedCallback(null, commitPassiveHookEffects, null, effect);
+
+ if (hasCaughtError()) {
+ didError = true;
+ error = clearCaughtError();
+ }
+ }
+
+ if (didError) {
+ captureCommitPhaseError(effect, error);
+ }
+ }
+
+ effect = effect.nextEffect;
+ } while (effect !== null);
+
+ {
+ resetCurrentFiber();
+ }
+ isRendering = previousIsRendering;
+ var rootExpirationTime = root.expirationTime;
+
+ if (rootExpirationTime !== NoWork) {
+ requestWork(root, rootExpirationTime);
+ }
+
+ if (!isBatchingUpdates && !isRendering) {
+ performSyncWork();
+ }
+ }
+
+ function isAlreadyFailedLegacyErrorBoundary(instance) {
+ return legacyErrorBoundariesThatAlreadyFailed !== null && legacyErrorBoundariesThatAlreadyFailed.has(instance);
+ }
+
+ function markLegacyErrorBoundaryAsFailed(instance) {
+ if (legacyErrorBoundariesThatAlreadyFailed === null) {
+ legacyErrorBoundariesThatAlreadyFailed = new Set([instance]);
+ } else {
+ legacyErrorBoundariesThatAlreadyFailed.add(instance);
+ }
+ }
+
+ function flushPassiveEffects() {
+ if (passiveEffectCallbackHandle !== null) {
+ cancelPassiveEffects(passiveEffectCallbackHandle);
+ }
+
+ if (passiveEffectCallback !== null) {
+ passiveEffectCallback();
+ }
+ }
+
+ 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 updateExpirationTimeBeforeCommit = finishedWork.expirationTime;
+ var childExpirationTimeBeforeCommit = finishedWork.childExpirationTime;
+ var earliestRemainingTimeBeforeCommit = childExpirationTimeBeforeCommit > updateExpirationTimeBeforeCommit ? childExpirationTimeBeforeCommit : updateExpirationTimeBeforeCommit;
+ markCommittedPriorityLevels(root, earliestRemainingTimeBeforeCommit);
+ var prevInteractions = null;
+
+ if (enableSchedulerTracing) {
+ prevInteractions = tracing.__interactionsRef.current;
+ tracing.__interactionsRef.current = root.memoizedInteractions;
+ }
+
+ ReactCurrentOwner$2.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(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(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(null, commitAllLifeCycles, null, root, 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 (firstEffect !== null && rootWithPendingPassiveEffects !== null) {
+ var callback = commitPassiveEffects.bind(null, root, firstEffect);
+
+ if (enableSchedulerTracing) {
+ callback = tracing.unstable_wrap(callback);
+ }
+
+ passiveEffectCallbackHandle = scheduler.unstable_runWithPriority(scheduler.unstable_NormalPriority, function () {
+ return schedulePassiveEffects(callback);
+ });
+ passiveEffectCallback = callback;
+ }
+
+ isCommitting$1 = false;
+ isWorking = false;
+ stopCommitLifeCyclesTimer();
+ stopCommitTimer();
+ onCommitRoot(finishedWork.stateNode);
+
+ if (true && ReactFiberInstrumentation_1.debugTool) {
+ ReactFiberInstrumentation_1.debugTool.onCommitWork(finishedWork);
+ }
+
+ var updateExpirationTimeAfterCommit = finishedWork.expirationTime;
+ var childExpirationTimeAfterCommit = finishedWork.childExpirationTime;
+ var earliestRemainingTimeAfterCommit = childExpirationTimeAfterCommit > updateExpirationTimeAfterCommit ? childExpirationTimeAfterCommit : updateExpirationTimeAfterCommit;
+
+ if (earliestRemainingTimeAfterCommit === NoWork) {
+ legacyErrorBoundariesThatAlreadyFailed = null;
+ }
+
+ onCommit(root, earliestRemainingTimeAfterCommit);
+
+ if (enableSchedulerTracing) {
+ tracing.__interactionsRef.current = prevInteractions;
+ var subscriber = void 0;
+
+ try {
+ subscriber = tracing.__subscriberRef.current;
+
+ if (subscriber !== null && root.memoizedInteractions.size > 0) {
+ var threadID = computeThreadID(committedExpirationTime, root.interactionThreadID);
+ subscriber.onWorkStopped(root.memoizedInteractions, threadID);
+ }
+ } catch (error) {
+ if (!hasUnhandledError) {
+ hasUnhandledError = true;
+ unhandledError = error;
+ }
+ } finally {
+ var pendingInteractionMap = root.pendingInteractionMap;
+ pendingInteractionMap.forEach(function (scheduledInteractions, scheduledExpirationTime) {
+ if (scheduledExpirationTime > earliestRemainingTimeAfterCommit) {
+ pendingInteractionMap.delete(scheduledExpirationTime);
+ scheduledInteractions.forEach(function (interaction) {
+ interaction.__count--;
+
+ if (subscriber !== null && interaction.__count === 0) {
+ try {
+ subscriber.onInteractionScheduledWorkCompleted(interaction);
+ } catch (error) {
+ if (!hasUnhandledError) {
+ hasUnhandledError = true;
+ unhandledError = error;
+ }
+ }
+ }
+ });
+ }
+ });
+ }
+ }
+ }
+
+ function resetChildExpirationTime(workInProgress, renderTime) {
+ if (renderTime !== Never && workInProgress.childExpirationTime === Never) {
+ return;
+ }
+
+ var newChildExpirationTime = NoWork;
+
+ if (enableProfilerTimer && workInProgress.mode & ProfileMode) {
+ var actualDuration = workInProgress.actualDuration;
+ var treeBaseDuration = workInProgress.selfBaseDuration;
+ var shouldBubbleActualDurations = workInProgress.alternate === null || workInProgress.child !== workInProgress.alternate.child;
+ var child = workInProgress.child;
+
+ while (child !== null) {
+ var childUpdateExpirationTime = child.expirationTime;
+ var childChildExpirationTime = child.childExpirationTime;
+
+ if (childUpdateExpirationTime > newChildExpirationTime) {
+ newChildExpirationTime = childUpdateExpirationTime;
+ }
+
+ if (childChildExpirationTime > newChildExpirationTime) {
+ newChildExpirationTime = childChildExpirationTime;
+ }
+
+ if (shouldBubbleActualDurations) {
+ actualDuration += child.actualDuration;
+ }
+
+ treeBaseDuration += child.treeBaseDuration;
+ child = child.sibling;
+ }
+
+ workInProgress.actualDuration = actualDuration;
+ workInProgress.treeBaseDuration = treeBaseDuration;
+ } else {
+ var _child = workInProgress.child;
+
+ while (_child !== null) {
+ var _childUpdateExpirationTime = _child.expirationTime;
+ var _childChildExpirationTime = _child.childExpirationTime;
+
+ if (_childUpdateExpirationTime > newChildExpirationTime) {
+ newChildExpirationTime = _childUpdateExpirationTime;
+ }
+
+ if (_childChildExpirationTime > newChildExpirationTime) {
+ newChildExpirationTime = _childChildExpirationTime;
+ }
+
+ _child = _child.sibling;
+ }
+ }
+
+ workInProgress.childExpirationTime = newChildExpirationTime;
+ }
+
+ function completeUnitOfWork(workInProgress) {
+ while (true) {
+ var current$$1 = workInProgress.alternate;
+ {
+ setCurrentFiber(workInProgress);
+ }
+ var returnFiber = workInProgress.return;
+ var siblingFiber = workInProgress.sibling;
+
+ if ((workInProgress.effectTag & Incomplete) === NoEffect) {
+ if (true && replayFailedUnitOfWorkWithInvokeGuardedCallback) {
+ mayReplayFailedUnitOfWork = false;
+ }
+
+ nextUnitOfWork = workInProgress;
+
+ if (enableProfilerTimer) {
+ if (workInProgress.mode & ProfileMode) {
+ startProfilerTimer(workInProgress);
+ }
+
+ nextUnitOfWork = completeWork(current$$1, workInProgress, nextRenderExpirationTime);
+
+ if (workInProgress.mode & ProfileMode) {
+ stopProfilerTimerIfRunningAndRecordDelta(workInProgress, false);
+ }
+ } else {
+ nextUnitOfWork = completeWork(current$$1, workInProgress, nextRenderExpirationTime);
+ }
+
+ if (true && replayFailedUnitOfWorkWithInvokeGuardedCallback) {
+ mayReplayFailedUnitOfWork = true;
+ }
+
+ stopWorkTimer(workInProgress);
+ resetChildExpirationTime(workInProgress, nextRenderExpirationTime);
+ {
+ resetCurrentFiber();
+ }
+
+ if (nextUnitOfWork !== null) {
+ return nextUnitOfWork;
+ }
+
+ 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 {
+ if (enableProfilerTimer && workInProgress.mode & ProfileMode) {
+ stopProfilerTimerIfRunningAndRecordDelta(workInProgress, false);
+ var actualDuration = workInProgress.actualDuration;
+ var child = workInProgress.child;
+
+ while (child !== null) {
+ actualDuration += child.actualDuration;
+ child = child.sibling;
+ }
+
+ workInProgress.actualDuration = actualDuration;
+ }
+
+ var next = unwindWork(workInProgress, nextRenderExpirationTime);
+
+ if (workInProgress.effectTag & DidCapture) {
+ stopFailedWorkTimer(workInProgress);
+ } else {
+ stopWorkTimer(workInProgress);
+ }
+
+ {
+ 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$$1 = workInProgress.alternate;
+ startWorkTimer(workInProgress);
+ {
+ setCurrentFiber(workInProgress);
+ }
+
+ if (true && replayFailedUnitOfWorkWithInvokeGuardedCallback) {
+ stashedWorkInProgressProperties = assignFiberPropertiesInDEV(stashedWorkInProgressProperties, workInProgress);
+ }
+
+ var next = void 0;
+
+ if (enableProfilerTimer) {
+ if (workInProgress.mode & ProfileMode) {
+ startProfilerTimer(workInProgress);
+ }
+
+ next = beginWork(current$$1, workInProgress, nextRenderExpirationTime);
+ workInProgress.memoizedProps = workInProgress.pendingProps;
+
+ if (workInProgress.mode & ProfileMode) {
+ stopProfilerTimerIfRunningAndRecordDelta(workInProgress, true);
+ }
+ } else {
+ next = beginWork(current$$1, workInProgress, nextRenderExpirationTime);
+ workInProgress.memoizedProps = workInProgress.pendingProps;
+ }
+
+ {
+ resetCurrentFiber();
+
+ if (isReplayingFailedUnitOfWork) {
+ rethrowOriginalError();
+ }
+ }
+
+ if (true && ReactFiberInstrumentation_1.debugTool) {
+ ReactFiberInstrumentation_1.debugTool.onBeginWork(workInProgress);
+ }
+
+ if (next === null) {
+ next = completeUnitOfWork(workInProgress);
+ }
+
+ ReactCurrentOwner$2.current = null;
+ return next;
+ }
+
+ function workLoop(isYieldy) {
+ if (!isYieldy) {
+ while (nextUnitOfWork !== null) {
+ nextUnitOfWork = performUnitOfWork(nextUnitOfWork);
+ }
+ } else {
+ while (nextUnitOfWork !== null && !shouldYield$$1()) {
+ nextUnitOfWork = performUnitOfWork(nextUnitOfWork);
+ }
+ }
+ }
+
+ function renderRoot(root, isYieldy) {
+ invariant(!isWorking, "renderRoot was called recursively. This error is likely caused " + "by a bug in React. Please file an issue.");
+ flushPassiveEffects();
+ isWorking = true;
+ var previousDispatcher = ReactCurrentDispatcher.current;
+ ReactCurrentDispatcher.current = ContextOnlyDispatcher;
+ var expirationTime = root.nextExpirationTimeToWorkOn;
+
+ if (expirationTime !== nextRenderExpirationTime || root !== nextRoot || nextUnitOfWork === null) {
+ resetStack();
+ nextRoot = root;
+ nextRenderExpirationTime = expirationTime;
+ nextUnitOfWork = createWorkInProgress(nextRoot.current, null, nextRenderExpirationTime);
+ root.pendingCommitExpirationTime = NoWork;
+
+ if (enableSchedulerTracing) {
+ var interactions = new Set();
+ root.pendingInteractionMap.forEach(function (scheduledInteractions, scheduledExpirationTime) {
+ if (scheduledExpirationTime >= expirationTime) {
+ scheduledInteractions.forEach(function (interaction) {
+ return interactions.add(interaction);
+ });
+ }
+ });
+ root.memoizedInteractions = interactions;
+
+ if (interactions.size > 0) {
+ var subscriber = tracing.__subscriberRef.current;
+
+ if (subscriber !== null) {
+ var threadID = computeThreadID(expirationTime, root.interactionThreadID);
+
+ try {
+ subscriber.onWorkStarted(interactions, threadID);
+ } catch (error) {
+ if (!hasUnhandledError) {
+ hasUnhandledError = true;
+ unhandledError = error;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ var prevInteractions = null;
+
+ if (enableSchedulerTracing) {
+ prevInteractions = tracing.__interactionsRef.current;
+ tracing.__interactionsRef.current = root.memoizedInteractions;
+ }
+
+ var didFatal = false;
+ startWorkLoopTimer(nextUnitOfWork);
+
+ do {
+ try {
+ workLoop(isYieldy);
+ } catch (thrownValue) {
+ resetContextDependences();
+ resetHooks();
+ var mayReplay = void 0;
+
+ if (true && replayFailedUnitOfWorkWithInvokeGuardedCallback) {
+ mayReplay = mayReplayFailedUnitOfWork;
+ mayReplayFailedUnitOfWork = true;
+ }
+
+ if (nextUnitOfWork === null) {
+ didFatal = true;
+ onUncaughtError(thrownValue);
+ } else {
+ if (enableProfilerTimer && nextUnitOfWork.mode & ProfileMode) {
+ stopProfilerTimerIfRunningAndRecordDelta(nextUnitOfWork, true);
+ }
+
+ {
+ resetCurrentlyProcessingQueue();
+ }
+
+ if (true && replayFailedUnitOfWorkWithInvokeGuardedCallback) {
+ if (mayReplay) {
+ var failedUnitOfWork = nextUnitOfWork;
+ 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);
+ } else {
+ throwException(root, returnFiber, sourceFiber, thrownValue, nextRenderExpirationTime);
+ nextUnitOfWork = completeUnitOfWork(sourceFiber);
+ continue;
+ }
+ }
+ }
+
+ break;
+ } while (true);
+
+ if (enableSchedulerTracing) {
+ tracing.__interactionsRef.current = prevInteractions;
+ }
+
+ isWorking = false;
+ ReactCurrentDispatcher.current = previousDispatcher;
+ resetContextDependences();
+ resetHooks();
+
+ if (didFatal) {
+ var _didCompleteRoot = false;
+ stopWorkLoopTimer(interruptedBy, _didCompleteRoot);
+ interruptedBy = null;
+ {
+ resetStackAfterFatalErrorInDev();
+ }
+ nextRoot = null;
+ onFatal(root);
+ return;
+ }
+
+ if (nextUnitOfWork !== null) {
+ var _didCompleteRoot2 = false;
+ stopWorkLoopTimer(interruptedBy, _didCompleteRoot2);
+ interruptedBy = null;
+ onYield(root);
+ return;
+ }
+
+ var didCompleteRoot = true;
+ stopWorkLoopTimer(interruptedBy, didCompleteRoot);
+ 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.");
+ nextRoot = null;
+ interruptedBy = null;
+
+ if (nextRenderDidError) {
+ if (hasLowerPriorityWork(root, expirationTime)) {
+ markSuspendedPriorityLevel(root, expirationTime);
+ var suspendedExpirationTime = expirationTime;
+ var rootExpirationTime = root.expirationTime;
+ onSuspend(root, rootWorkInProgress, suspendedExpirationTime, rootExpirationTime, -1);
+ return;
+ } else if (!root.didError && isYieldy) {
+ root.didError = true;
+
+ var _suspendedExpirationTime = root.nextExpirationTimeToWorkOn = expirationTime;
+
+ var _rootExpirationTime = root.expirationTime = Sync;
+
+ onSuspend(root, rootWorkInProgress, _suspendedExpirationTime, _rootExpirationTime, -1);
+ return;
+ }
+ }
+
+ if (isYieldy && nextLatestAbsoluteTimeoutMs !== -1) {
+ var _suspendedExpirationTime2 = expirationTime;
+ markSuspendedPriorityLevel(root, _suspendedExpirationTime2);
+ var earliestExpirationTime = findEarliestOutstandingPriorityLevel(root, expirationTime);
+ var earliestExpirationTimeMs = expirationTimeToMs(earliestExpirationTime);
+
+ if (earliestExpirationTimeMs < nextLatestAbsoluteTimeoutMs) {
+ nextLatestAbsoluteTimeoutMs = earliestExpirationTimeMs;
+ }
+
+ var currentTimeMs = expirationTimeToMs(requestCurrentTime());
+ var msUntilTimeout = nextLatestAbsoluteTimeoutMs - currentTimeMs;
+ msUntilTimeout = msUntilTimeout < 0 ? 0 : msUntilTimeout;
+ var _rootExpirationTime2 = root.expirationTime;
+ onSuspend(root, rootWorkInProgress, _suspendedExpirationTime2, _rootExpirationTime2, msUntilTimeout);
+ return;
+ }
+
+ onComplete(root, rootWorkInProgress, expirationTime);
+ }
+
+ function captureCommitPhaseError(sourceFiber, value) {
+ var expirationTime = Sync;
+ var fiber = sourceFiber.return;
+
+ while (fiber !== null) {
+ switch (fiber.tag) {
+ case ClassComponent:
+ var ctor = fiber.type;
+ var instance = fiber.stateNode;
+
+ if (typeof ctor.getDerivedStateFromError === "function" || typeof instance.componentDidCatch === "function" && !isAlreadyFailedLegacyErrorBoundary(instance)) {
+ var errorInfo = createCapturedValue(value, sourceFiber);
+ var update = createClassErrorUpdate(fiber, errorInfo, expirationTime);
+ enqueueUpdate(fiber, update);
+ scheduleWork(fiber, expirationTime);
+ return;
+ }
+
+ break;
+
+ case HostRoot:
+ {
+ var _errorInfo = createCapturedValue(value, sourceFiber);
+
+ var _update = createRootErrorUpdate(fiber, _errorInfo, expirationTime);
+
+ enqueueUpdate(fiber, _update);
+ 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);
+ scheduleWork(rootFiber, expirationTime);
+ }
+ }
+
+ function computeThreadID(expirationTime, interactionThreadID) {
+ return expirationTime * 1000 + interactionThreadID;
+ }
+
+ function computeExpirationForFiber(currentTime, fiber) {
+ var priorityLevel = scheduler.unstable_getCurrentPriorityLevel();
+ var expirationTime = void 0;
+
+ if ((fiber.mode & ConcurrentMode) === NoContext) {
+ expirationTime = Sync;
+ } else if (isWorking && !isCommitting$1) {
+ expirationTime = nextRenderExpirationTime;
+ } else {
+ switch (priorityLevel) {
+ case scheduler.unstable_ImmediatePriority:
+ expirationTime = Sync;
+ break;
+
+ case scheduler.unstable_UserBlockingPriority:
+ expirationTime = computeInteractiveExpiration(currentTime);
+ break;
+
+ case scheduler.unstable_NormalPriority:
+ expirationTime = computeAsyncExpiration(currentTime);
+ break;
+
+ case scheduler.unstable_LowPriority:
+ case scheduler.unstable_IdlePriority:
+ expirationTime = Never;
+ break;
+
+ default:
+ invariant(false, "Unknown priority level. This error is likely caused by a bug in " + "React. Please file an issue.");
+ }
+
+ if (nextRoot !== null && expirationTime === nextRenderExpirationTime) {
+ expirationTime -= 1;
+ }
+ }
+
+ if (priorityLevel === scheduler.unstable_UserBlockingPriority && (lowestPriorityPendingInteractiveExpirationTime === NoWork || expirationTime < lowestPriorityPendingInteractiveExpirationTime)) {
+ lowestPriorityPendingInteractiveExpirationTime = expirationTime;
+ }
+
+ return expirationTime;
+ }
+
+ function renderDidSuspend(root, absoluteTimeoutMs, suspendedTime) {
+ if (absoluteTimeoutMs >= 0 && nextLatestAbsoluteTimeoutMs < absoluteTimeoutMs) {
+ nextLatestAbsoluteTimeoutMs = absoluteTimeoutMs;
+ }
+ }
+
+ function renderDidError() {
+ nextRenderDidError = true;
+ }
+
+ function pingSuspendedRoot(root, thenable, pingTime) {
+ var pingCache = root.pingCache;
+
+ if (pingCache !== null) {
+ pingCache.delete(thenable);
+ }
+
+ if (nextRoot !== null && nextRenderExpirationTime === pingTime) {
+ nextRoot = null;
+ } else {
+ if (isPriorityLevelSuspended(root, pingTime)) {
+ markPingedPriorityLevel(root, pingTime);
+ var rootExpirationTime = root.expirationTime;
+
+ if (rootExpirationTime !== NoWork) {
+ requestWork(root, rootExpirationTime);
+ }
+ }
+ }
+ }
+
+ function retryTimedOutBoundary(boundaryFiber) {
+ var currentTime = requestCurrentTime();
+ var retryTime = computeExpirationForFiber(currentTime, boundaryFiber);
+ var root = scheduleWorkToRoot(boundaryFiber, retryTime);
+
+ if (root !== null) {
+ markPendingPriorityLevel(root, retryTime);
+ var rootExpirationTime = root.expirationTime;
+
+ if (rootExpirationTime !== NoWork) {
+ requestWork(root, rootExpirationTime);
+ }
+ }
+ }
+
+ function resolveRetryThenable(boundaryFiber, thenable) {
+ var retryCache = void 0;
+
+ if (enableSuspenseServerRenderer) {
+ switch (boundaryFiber.tag) {
+ case SuspenseComponent:
+ retryCache = boundaryFiber.stateNode;
+ break;
+
+ case DehydratedSuspenseComponent:
+ retryCache = boundaryFiber.memoizedState;
+ break;
+
+ default:
+ invariant(false, "Pinged unknown suspense boundary type. " + "This is probably a bug in React.");
+ }
+ } else {
+ retryCache = boundaryFiber.stateNode;
+ }
+
+ if (retryCache !== null) {
+ retryCache.delete(thenable);
+ }
+
+ retryTimedOutBoundary(boundaryFiber);
+ }
+
+ function scheduleWorkToRoot(fiber, expirationTime) {
+ recordScheduleUpdate();
+ {
+ if (fiber.tag === ClassComponent) {
+ var instance = fiber.stateNode;
+ warnAboutInvalidUpdates(instance);
+ }
+ }
+
+ if (fiber.expirationTime < expirationTime) {
+ fiber.expirationTime = expirationTime;
+ }
+
+ var alternate = fiber.alternate;
+
+ if (alternate !== null && alternate.expirationTime < expirationTime) {
+ alternate.expirationTime = expirationTime;
+ }
+
+ var node = fiber.return;
+ var root = null;
+
+ if (node === null && fiber.tag === HostRoot) {
+ root = fiber.stateNode;
+ } else {
+ while (node !== null) {
+ alternate = node.alternate;
+
+ if (node.childExpirationTime < expirationTime) {
+ node.childExpirationTime = expirationTime;
+
+ if (alternate !== null && alternate.childExpirationTime < expirationTime) {
+ alternate.childExpirationTime = expirationTime;
+ }
+ } else if (alternate !== null && alternate.childExpirationTime < expirationTime) {
+ alternate.childExpirationTime = expirationTime;
+ }
+
+ if (node.return === null && node.tag === HostRoot) {
+ root = node.stateNode;
+ break;
+ }
+
+ node = node.return;
+ }
+ }
+
+ if (enableSchedulerTracing) {
+ if (root !== null) {
+ var interactions = tracing.__interactionsRef.current;
+
+ if (interactions.size > 0) {
+ var pendingInteractionMap = root.pendingInteractionMap;
+ var pendingInteractions = pendingInteractionMap.get(expirationTime);
+
+ if (pendingInteractions != null) {
+ interactions.forEach(function (interaction) {
+ if (!pendingInteractions.has(interaction)) {
+ interaction.__count++;
+ }
+
+ pendingInteractions.add(interaction);
+ });
+ } else {
+ pendingInteractionMap.set(expirationTime, new Set(interactions));
+ interactions.forEach(function (interaction) {
+ interaction.__count++;
+ });
+ }
+
+ var subscriber = tracing.__subscriberRef.current;
+
+ if (subscriber !== null) {
+ var threadID = computeThreadID(expirationTime, root.interactionThreadID);
+ subscriber.onWorkScheduled(interactions, threadID);
+ }
+ }
+ }
+ }
+
+ return root;
+ }
+
+ function warnIfNotCurrentlyBatchingInDev(fiber) {
+ {
+ if (isRendering === false && isBatchingUpdates === false) {
+ warningWithoutStack$1(false, "An update to %s inside a test was not wrapped in act(...).\n\n" + "When testing, code that causes React state updates should be wrapped into act(...):\n\n" + "act(() => {\n" + " /* fire events that update state */\n" + "});\n" + "/* assert on the output */\n\n" + "This ensures that you're testing the behavior the user would see in the browser." + " Learn more at https://fb.me/react-wrap-tests-with-act" + "%s", getComponentName(fiber.type), getStackByFiberInDevAndProd(fiber));
+ }
+ }
+ }
+
+ function scheduleWork(fiber, expirationTime) {
+ var root = scheduleWorkToRoot(fiber, expirationTime);
+
+ if (root === null) {
+ {
+ switch (fiber.tag) {
+ case ClassComponent:
+ warnAboutUpdateOnUnmounted(fiber, true);
+ break;
+
+ case FunctionComponent:
+ case ForwardRef:
+ case MemoComponent:
+ case SimpleMemoComponent:
+ warnAboutUpdateOnUnmounted(fiber, false);
+ break;
+ }
+ }
+ return;
+ }
+
+ 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) {
+ nestedUpdateCount = 0;
+ 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.");
+ }
+ }
+
+ var firstScheduledRoot = null;
+ var lastScheduledRoot = null;
+ var callbackExpirationTime = NoWork;
+ var callbackID = void 0;
+ var isRendering = false;
+ var nextFlushedRoot = null;
+ var nextFlushedExpirationTime = NoWork;
+ var lowestPriorityPendingInteractiveExpirationTime = NoWork;
+ var hasUnhandledError = false;
+ var unhandledError = null;
+ var isBatchingUpdates = false;
+ var isUnbatchingUpdates = false;
+ var completedBatches = null;
+ var originalStartTimeMs = now$$1();
+ var currentRendererTime = msToExpirationTime(originalStartTimeMs);
+ var currentSchedulerTime = currentRendererTime;
+ var NESTED_UPDATE_LIMIT = 50;
+ var nestedUpdateCount = 0;
+ var lastCommittedRootDuringThisBatch = null;
+
+ function recomputeCurrentRendererTime() {
+ var currentTimeMs = now$$1() - originalStartTimeMs;
+ currentRendererTime = msToExpirationTime(currentTimeMs);
+ }
+
+ function scheduleCallbackWithExpirationTime(root, expirationTime) {
+ if (callbackExpirationTime !== NoWork) {
+ if (expirationTime < callbackExpirationTime) {
+ return;
+ } else {
+ if (callbackID !== null) {
+ cancelDeferredCallback$$1(callbackID);
+ }
+ }
+ } else {
+ startRequestCallbackTimer();
+ }
+
+ callbackExpirationTime = expirationTime;
+ var currentMs = now$$1() - originalStartTimeMs;
+ var expirationTimeMs = expirationTimeToMs(expirationTime);
+ var timeout = expirationTimeMs - currentMs;
+ callbackID = scheduleDeferredCallback$$1(performAsyncWork, {
+ timeout: timeout
+ });
+ }
+
+ function onFatal(root) {
+ root.finishedWork = null;
+ }
+
+ function onComplete(root, finishedWork, expirationTime) {
+ root.pendingCommitExpirationTime = expirationTime;
+ root.finishedWork = finishedWork;
+ }
+
+ function onSuspend(root, finishedWork, suspendedExpirationTime, rootExpirationTime, msUntilTimeout) {
+ root.expirationTime = rootExpirationTime;
+
+ if (msUntilTimeout === 0 && !shouldYield$$1()) {
+ root.pendingCommitExpirationTime = suspendedExpirationTime;
+ root.finishedWork = finishedWork;
+ } else if (msUntilTimeout > 0) {
+ root.timeoutHandle = scheduleTimeout(onTimeout.bind(null, root, finishedWork, suspendedExpirationTime), msUntilTimeout);
+ }
+ }
+
+ function onYield(root) {
+ root.finishedWork = null;
+ }
+
+ function onTimeout(root, finishedWork, suspendedExpirationTime) {
+ root.pendingCommitExpirationTime = suspendedExpirationTime;
+ root.finishedWork = finishedWork;
+ recomputeCurrentRendererTime();
+ currentSchedulerTime = currentRendererTime;
+ flushRoot(root, suspendedExpirationTime);
+ }
+
+ function onCommit(root, expirationTime) {
+ root.expirationTime = expirationTime;
+ root.finishedWork = null;
+ }
+
+ function requestCurrentTime() {
+ if (isRendering) {
+ return currentSchedulerTime;
+ }
+
+ findHighestPriorityRoot();
+
+ if (nextFlushedExpirationTime === NoWork || nextFlushedExpirationTime === Never) {
+ recomputeCurrentRendererTime();
+ currentSchedulerTime = currentRendererTime;
+ return currentSchedulerTime;
+ }
+
+ return currentSchedulerTime;
+ }
+
+ 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(root, 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 (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 (remainingExpirationTime > highestPriorityWork) {
+ highestPriorityWork = remainingExpirationTime;
+ highestPriorityRoot = root;
+ }
+
+ if (root === lastScheduledRoot) {
+ break;
+ }
+
+ if (highestPriorityWork === Sync) {
+ break;
+ }
+
+ previousScheduledRoot = root;
+ root = root.nextScheduledRoot;
+ }
+ }
+ }
+
+ nextFlushedRoot = highestPriorityRoot;
+ nextFlushedExpirationTime = highestPriorityWork;
+ }
+
+ function performAsyncWork(didTimeout) {
+ if (didTimeout) {
+ if (firstScheduledRoot !== null) {
+ recomputeCurrentRendererTime();
+ var root = firstScheduledRoot;
+
+ do {
+ didExpireAtExpirationTime(root, currentRendererTime);
+ root = root.nextScheduledRoot;
+ } while (root !== firstScheduledRoot);
+ }
+ }
+
+ performWork(NoWork, true);
+ }
+
+ function performSyncWork() {
+ performWork(Sync, false);
+ }
+
+ function performWork(minExpirationTime, isYieldy) {
+ findHighestPriorityRoot();
+
+ if (isYieldy) {
+ recomputeCurrentRendererTime();
+ currentSchedulerTime = currentRendererTime;
+
+ if (enableUserTimingAPI) {
+ var didExpire = nextFlushedExpirationTime > currentRendererTime;
+ var timeout = expirationTimeToMs(nextFlushedExpirationTime);
+ stopRequestCallbackTimer(didExpire, timeout);
+ }
+
+ while (nextFlushedRoot !== null && nextFlushedExpirationTime !== NoWork && minExpirationTime <= nextFlushedExpirationTime && !(shouldYield$$1() && currentRendererTime > nextFlushedExpirationTime)) {
+ performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, currentRendererTime > nextFlushedExpirationTime);
+ findHighestPriorityRoot();
+ recomputeCurrentRendererTime();
+ currentSchedulerTime = currentRendererTime;
+ }
+ } else {
+ while (nextFlushedRoot !== null && nextFlushedExpirationTime !== NoWork && minExpirationTime <= nextFlushedExpirationTime) {
+ performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, false);
+ findHighestPriorityRoot();
+ }
+ }
+
+ if (isYieldy) {
+ callbackExpirationTime = NoWork;
+ callbackID = null;
+ }
+
+ if (nextFlushedExpirationTime !== NoWork) {
+ scheduleCallbackWithExpirationTime(nextFlushedRoot, nextFlushedExpirationTime);
+ }
+
+ 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();
+ }
+
+ function finishRendering() {
+ nestedUpdateCount = 0;
+ lastCommittedRootDuringThisBatch = null;
+
+ 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;
+ var timeoutHandle = root.timeoutHandle;
+
+ if (timeoutHandle !== noTimeout) {
+ root.timeoutHandle = noTimeout;
+ cancelTimeout(timeoutHandle);
+ }
+
+ renderRoot(root, isYieldy);
+ 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;
+ var _timeoutHandle = root.timeoutHandle;
+
+ if (_timeoutHandle !== noTimeout) {
+ root.timeoutHandle = noTimeout;
+ cancelTimeout(_timeoutHandle);
+ }
+
+ renderRoot(root, isYieldy);
+ _finishedWork = root.finishedWork;
+
+ if (_finishedWork !== null) {
+ if (!shouldYield$$1()) {
+ completeRoot(root, _finishedWork, expirationTime);
+ } else {
+ root.finishedWork = _finishedWork;
+ }
+ }
+ }
+ }
+
+ 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;
+
+ if (root === lastCommittedRootDuringThisBatch) {
+ nestedUpdateCount++;
+ } else {
+ lastCommittedRootDuringThisBatch = root;
+ nestedUpdateCount = 0;
+ }
+
+ scheduler.unstable_runWithPriority(scheduler.unstable_ImmediatePriority, function () {
+ commitRoot(root, finishedWork);
+ });
+ }
+
+ 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 interactiveUpdates$1(fn, a, b) {
+ if (!isBatchingUpdates && !isRendering && lowestPriorityPendingInteractiveExpirationTime !== NoWork) {
+ performWork(lowestPriorityPendingInteractiveExpirationTime, false);
+ lowestPriorityPendingInteractiveExpirationTime = NoWork;
+ }
+
+ var previousIsBatchingUpdates = isBatchingUpdates;
+ isBatchingUpdates = true;
+
+ try {
+ return scheduler.unstable_runWithPriority(scheduler.unstable_UserBlockingPriority, function () {
+ return fn(a, b);
+ });
+ } finally {
+ isBatchingUpdates = previousIsBatchingUpdates;
+
+ if (!isBatchingUpdates && !isRendering) {
+ performSyncWork();
+ }
+ }
+ }
+
+ function flushInteractiveUpdates$1() {
+ if (!isRendering && lowestPriorityPendingInteractiveExpirationTime !== NoWork) {
+ performWork(lowestPriorityPendingInteractiveExpirationTime, false);
+ lowestPriorityPendingInteractiveExpirationTime = NoWork;
+ }
+ }
+
+ var didWarnAboutNestedUpdates = void 0;
+ var didWarnAboutFindNodeInStrictMode = void 0;
+ {
+ didWarnAboutNestedUpdates = false;
+ didWarnAboutFindNodeInStrictMode = {};
+ }
+
+ function getContextForSubtree(parentComponent) {
+ if (!parentComponent) {
+ return emptyContextObject;
+ }
+
+ var fiber = get$1(parentComponent);
+ var parentContext = findCurrentUnmaskedContext(fiber);
+
+ if (fiber.tag === ClassComponent) {
+ var Component = fiber.type;
+
+ if (isContextProvider(Component)) {
+ return processChildContext(fiber, Component, parentContext);
+ }
+ }
+
+ return parentContext;
+ }
+
+ function scheduleRootUpdate(current$$1, element, expirationTime, callback) {
+ {
+ if (phase === "render" && current !== null && !didWarnAboutNestedUpdates) {
+ didWarnAboutNestedUpdates = true;
+ warningWithoutStack$1(false, "Render methods should be a pure function of props and state; " + "triggering nested component updates from render is not allowed. " + "If necessary, trigger nested updates in componentDidUpdate.\n\n" + "Check the render method of %s.", getComponentName(current.type) || "Unknown");
+ }
+ }
+ var update = createUpdate(expirationTime);
+ update.payload = {
+ element: element
+ };
+ callback = callback === undefined ? null : callback;
+
+ if (callback !== null) {
+ !(typeof callback === "function") ? warningWithoutStack$1(false, "render(...): Expected the last optional `callback` argument to be a " + "function. Instead received: %s.", callback) : void 0;
+ update.callback = callback;
+ }
+
+ flushPassiveEffects();
+ enqueueUpdate(current$$1, update);
+ scheduleWork(current$$1, expirationTime);
+ return expirationTime;
+ }
+
+ function updateContainerAtExpirationTime(element, container, parentComponent, expirationTime, callback) {
+ var current$$1 = container.current;
+ {
+ if (ReactFiberInstrumentation_1.debugTool) {
+ if (current$$1.alternate === null) {
+ ReactFiberInstrumentation_1.debugTool.onMountContainer(container);
+ } else if (element === null) {
+ ReactFiberInstrumentation_1.debugTool.onUnmountContainer(container);
+ } else {
+ ReactFiberInstrumentation_1.debugTool.onUpdateContainer(container);
+ }
+ }
+ }
+ var context = getContextForSubtree(parentComponent);
+
+ if (container.context === null) {
+ container.context = context;
+ } else {
+ container.pendingContext = context;
+ }
+
+ return scheduleRootUpdate(current$$1, element, expirationTime, callback);
+ }
+
+ function findHostInstance(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 findHostInstanceWithWarning(component, methodName) {
+ {
+ 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;
+ }
+
+ if (hostFiber.mode & StrictMode) {
+ var componentName = getComponentName(fiber.type) || "Component";
+
+ if (!didWarnAboutFindNodeInStrictMode[componentName]) {
+ didWarnAboutFindNodeInStrictMode[componentName] = true;
+
+ if (fiber.mode & StrictMode) {
+ warningWithoutStack$1(false, "%s is deprecated in StrictMode. " + "%s was passed an instance of %s which is inside StrictMode. " + "Instead, add a ref directly to the element you want to reference." + "\n%s" + "\n\nLearn more about using refs safely here:" + "\nhttps://fb.me/react-strict-mode-find-node", methodName, methodName, componentName, getStackByFiberInDevAndProd(hostFiber));
+ } else {
+ warningWithoutStack$1(false, "%s is deprecated in StrictMode. " + "%s was passed an instance of %s which renders StrictMode children. " + "Instead, add a ref directly to the element you want to reference." + "\n%s" + "\n\nLearn more about using refs safely here:" + "\nhttps://fb.me/react-strict-mode-find-node", methodName, methodName, componentName, getStackByFiberInDevAndProd(hostFiber));
+ }
+ }
+ }
+
+ return hostFiber.stateNode;
+ }
+ return findHostInstance(component);
+ }
+
+ function createContainer(containerInfo, isConcurrent, hydrate) {
+ return createFiberRoot(containerInfo, isConcurrent, hydrate);
+ }
+
+ function updateContainer(element, container, parentComponent, callback) {
+ var current$$1 = container.current;
+ var currentTime = requestCurrentTime();
+ var expirationTime = computeExpirationForFiber(currentTime, current$$1);
+ 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;
+ }
+ }
+
+ var overrideProps = null;
+ {
+ var copyWithSetImpl = function copyWithSetImpl(obj, path, idx, value) {
+ if (idx >= path.length) {
+ return value;
+ }
+
+ var key = path[idx];
+ var updated = Array.isArray(obj) ? obj.slice() : _extends({}, obj);
+ updated[key] = copyWithSetImpl(obj[key], path, idx + 1, value);
+ return updated;
+ };
+
+ var copyWithSet = function copyWithSet(obj, path, value) {
+ return copyWithSetImpl(obj, path, 0, value);
+ };
+
+ overrideProps = function overrideProps(fiber, path, value) {
+ flushPassiveEffects();
+ fiber.pendingProps = copyWithSet(fiber.memoizedProps, path, value);
+
+ if (fiber.alternate) {
+ fiber.alternate.pendingProps = fiber.pendingProps;
+ }
+
+ scheduleWork(fiber, Sync);
+ };
+ }
+
+ function injectIntoDevTools(devToolsConfig) {
+ var _findFiberByHostInstance = devToolsConfig.findFiberByHostInstance;
+ var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+ return injectInternals(_extends({}, devToolsConfig, {
+ overrideProps: overrideProps,
+ currentDispatcherRef: ReactCurrentDispatcher,
+ findHostInstanceByFiber: function findHostInstanceByFiber(fiber) {
+ var hostFiber = findCurrentHostFiber(fiber);
+
+ if (hostFiber === null) {
+ return null;
+ }
+
+ return hostFiber.stateNode;
+ },
+ findFiberByHostInstance: function findFiberByHostInstance(instance) {
+ if (!_findFiberByHostInstance) {
+ return null;
+ }
+
+ return _findFiberByHostInstance(instance);
+ }
+ }));
+ }
+
+ function _createPortal(children, containerInfo, implementation) {
+ var key = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
+ return {
+ $$typeof: REACT_PORTAL_TYPE,
+ key: key == null ? null : "" + key,
+ children: children,
+ containerInfo: containerInfo,
+ implementation: implementation
+ };
+ }
+
+ var ReactVersion = "16.8.3";
+
+ var NativeMethodsMixin = function NativeMethodsMixin(findNodeHandle, findHostInstance) {
+ var NativeMethodsMixin = {
+ measure: function measure(callback) {
+ UIManager.measure(findNodeHandle(this), mountSafeCallback_NOT_REALLY_SAFE(this, callback));
+ },
+ measureInWindow: function measureInWindow(callback) {
+ UIManager.measureInWindow(findNodeHandle(this), mountSafeCallback_NOT_REALLY_SAFE(this, callback));
+ },
+ measureLayout: function measureLayout(relativeToNativeNode, onSuccess, onFail) {
+ UIManager.measureLayout(findNodeHandle(this), relativeToNativeNode, mountSafeCallback_NOT_REALLY_SAFE(this, onFail), mountSafeCallback_NOT_REALLY_SAFE(this, onSuccess));
+ },
+ setNativeProps: function setNativeProps(nativeProps) {
+ {
+ if (warnAboutDeprecatedSetNativeProps) {
+ warningWithoutStack$1(false, "Warning: Calling ref.setNativeProps(nativeProps) " + "is deprecated and will be removed in a future release. " + "Use the setNativeProps export from the react-native package instead." + "\n\timport {setNativeProps} from 'react-native';\n\tsetNativeProps(ref, nativeProps);\n");
+ }
+ }
+ var maybeInstance = void 0;
+
+ try {
+ maybeInstance = findHostInstance(this);
+ } catch (error) {}
+
+ if (maybeInstance == null) {
+ return;
+ }
+
+ var nativeTag = maybeInstance._nativeTag || maybeInstance.canonical._nativeTag;
+ var viewConfig = maybeInstance.viewConfig || maybeInstance.canonical.viewConfig;
+ {
+ warnForStyleProps(nativeProps, viewConfig.validAttributes);
+ }
+ var updatePayload = create(nativeProps, viewConfig.validAttributes);
+
+ if (updatePayload != null) {
+ UIManager.updateView(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_NOT_REALLY_SAFE(this, callback));
+ };
+
+ ReactNativeComponent.prototype.measureInWindow = function measureInWindow(callback) {
+ UIManager.measureInWindow(findNodeHandle(this), mountSafeCallback_NOT_REALLY_SAFE(this, callback));
+ };
+
+ ReactNativeComponent.prototype.measureLayout = function measureLayout(relativeToNativeNode, onSuccess, onFail) {
+ UIManager.measureLayout(findNodeHandle(this), relativeToNativeNode, mountSafeCallback_NOT_REALLY_SAFE(this, onFail), mountSafeCallback_NOT_REALLY_SAFE(this, onSuccess));
+ };
+
+ ReactNativeComponent.prototype.setNativeProps = function setNativeProps(nativeProps) {
+ {
+ if (warnAboutDeprecatedSetNativeProps) {
+ warningWithoutStack$1(false, "Warning: Calling ref.setNativeProps(nativeProps) " + "is deprecated and will be removed in a future release. " + "Use the setNativeProps export from the react-native package instead." + "\n\timport {setNativeProps} from 'react-native';\n\tsetNativeProps(ref, nativeProps);\n");
+ }
+ }
+ var maybeInstance = void 0;
+
+ try {
+ maybeInstance = findHostInstance(this);
+ } catch (error) {}
+
+ if (maybeInstance == null) {
+ return;
+ }
+
+ var nativeTag = maybeInstance._nativeTag || maybeInstance.canonical._nativeTag;
+ var viewConfig = maybeInstance.viewConfig || maybeInstance.canonical.viewConfig;
+ var updatePayload = create(nativeProps, viewConfig.validAttributes);
+
+ if (updatePayload != null) {
+ UIManager.updateView(nativeTag, viewConfig.uiViewClassName, updatePayload);
+ }
+ };
+
+ return ReactNativeComponent;
+ }(React.Component);
+
+ return ReactNativeComponent;
+ };
+
+ var emptyObject$1 = {};
+ {
+ Object.freeze(emptyObject$1);
+ }
+ 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$1;
+ }
+
+ return emptyObject$1;
+ };
+
+ var getHostNode = function getHostNode(fiber, findNodeHandle) {
+ var hostNode = void 0;
+
+ while (fiber) {
+ if (fiber.stateNode !== null && fiber.tag === HostComponent) {
+ hostNode = findNodeHandle(fiber.stateNode);
+ }
+
+ if (hostNode) {
+ return hostNode;
+ }
+
+ fiber = fiber.child;
+ }
+
+ return null;
+ };
+
+ var createHierarchy = function createHierarchy(fiberHierarchy) {
+ return fiberHierarchy.map(function (fiber) {
+ return {
+ name: getComponentName(fiber.type),
+ getInspectorData: function getInspectorData(findNodeHandle) {
+ return {
+ measure: function measure(callback) {
+ return 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$1,
+ selection: null,
+ source: null
+ };
+ }
+
+ var fiber = findCurrentFiberUsingSlowPath(closestInstance);
+ var fiberHierarchy = getOwnerHierarchy(fiber);
+ var instance = lastNonHostInstance(fiberHierarchy);
+ var hierarchy = createHierarchy(fiberHierarchy);
+ var props = getHostProps(instance);
+ var source = instance._debugSource;
+ var selection = fiberHierarchy.indexOf(instance);
+ return {
+ hierarchy: hierarchy,
+ props: props,
+ selection: selection,
+ source: source
+ };
+ };
+ }
+
+ function setNativeProps(handle, nativeProps) {
+ if (handle._nativeTag == null) {
+ !(handle._nativeTag != null) ? warningWithoutStack$1(false, "setNativeProps was called with a ref that isn't a " + "native component. Use React.forwardRef to get access to the underlying native component") : void 0;
+ return;
+ }
+
+ {
+ warnForStyleProps(nativeProps, handle.viewConfig.validAttributes);
+ }
+ var updatePayload = create(nativeProps, handle.viewConfig.validAttributes);
+
+ if (updatePayload != null) {
+ UIManager.updateView(handle._nativeTag, handle.viewConfig.uiViewClassName, updatePayload);
+ }
+ }
+
+ var ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner;
+
+ function findNodeHandle(componentOrHandle) {
+ {
+ var owner = ReactCurrentOwner.current;
+
+ if (owner !== null && owner.stateNode !== null) {
+ !owner.stateNode._warnedAboutRefsInRender ? warningWithoutStack$1(false, "%s is accessing findNodeHandle inside its render(). " + "render() should be a pure function of props and state. It should " + "never access something that requires stale data from the previous " + "render, such as refs. Move this logic to componentDidMount and " + "componentDidUpdate instead.", getComponentName(owner.type) || "A component") : void 0;
+ owner.stateNode._warnedAboutRefsInRender = true;
+ }
+ }
+
+ if (componentOrHandle == null) {
+ return null;
+ }
+
+ if (typeof componentOrHandle === "number") {
+ return componentOrHandle;
+ }
+
+ if (componentOrHandle._nativeTag) {
+ return componentOrHandle._nativeTag;
+ }
+
+ if (componentOrHandle.canonical && componentOrHandle.canonical._nativeTag) {
+ return componentOrHandle.canonical._nativeTag;
+ }
+
+ var hostInstance = void 0;
+ {
+ hostInstance = findHostInstanceWithWarning(componentOrHandle, "findNodeHandle");
+ }
+
+ if (hostInstance == null) {
+ return hostInstance;
+ }
+
+ if (hostInstance.canonical) {
+ return hostInstance.canonical._nativeTag;
+ }
+
+ return hostInstance._nativeTag;
+ }
+
+ setBatchingImplementation(batchedUpdates$1, interactiveUpdates$1, flushInteractiveUpdates$1);
+
+ function computeComponentStackForErrorReporting(reactTag) {
+ var fiber = getInstanceFromTag(reactTag);
+
+ if (!fiber) {
+ return "";
+ }
+
+ return getStackByFiberInDevAndProd(fiber);
+ }
+
+ var roots = new Map();
+ var ReactNativeRenderer = {
+ NativeComponent: ReactNativeComponent(findNodeHandle, findHostInstance),
+ findNodeHandle: findNodeHandle,
+ setNativeProps: setNativeProps,
+ 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;
+ module.exports = reactNativeRenderer;
+ })();
+ }
+},85,[14,86,173,71,174,11,49,175,80,176,16,177,180,98],"node_modules\\react-native\\Libraries\\Renderer\\oss\\ReactNativeRenderer-dev.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var start = Date.now();
+
+ _$$_REQUIRE(_dependencyMap[0], "setUpGlobals");
+
+ _$$_REQUIRE(_dependencyMap[1], "polyfillES6Collections");
+
+ _$$_REQUIRE(_dependencyMap[2], "setUpSystrace");
+
+ _$$_REQUIRE(_dependencyMap[3], "setUpErrorHandling");
+
+ _$$_REQUIRE(_dependencyMap[4], "checkNativeVersion");
+
+ _$$_REQUIRE(_dependencyMap[5], "polyfillPromise");
+
+ _$$_REQUIRE(_dependencyMap[6], "setUpRegeneratorRuntime");
+
+ _$$_REQUIRE(_dependencyMap[7], "setUpTimers");
+
+ _$$_REQUIRE(_dependencyMap[8], "setUpXHR");
+
+ _$$_REQUIRE(_dependencyMap[9], "setUpAlert");
+
+ _$$_REQUIRE(_dependencyMap[10], "setUpGeolocation");
+
+ _$$_REQUIRE(_dependencyMap[11], "setUpBatchedBridge");
+
+ _$$_REQUIRE(_dependencyMap[12], "setUpSegmentFetcher");
+
+ if (__DEV__) {
+ _$$_REQUIRE(_dependencyMap[13], "setUpDeveloperTools");
+ }
+
+ var PerformanceLogger = _$$_REQUIRE(_dependencyMap[14], "PerformanceLogger");
+
+ PerformanceLogger.markPoint('initializeCore_start', PerformanceLogger.currentTimestamp() - (Date.now() - start));
+ PerformanceLogger.markPoint('initializeCore_end');
+},86,[87,88,96,97,107,110,117,118,123,144,147,151,165,166,156],"node_modules\\react-native\\Libraries\\Core\\InitializeCore.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ if (global.GLOBAL === undefined) {
+ global.GLOBAL = global;
+ }
+
+ if (global.window === undefined) {
+ global.window = global;
+ }
+
+ if (global.self === undefined) {
+ global.self = global;
+ }
+
+ global.process = global.process || {};
+ global.process.env = global.process.env || {};
+
+ if (!global.process.env.NODE_ENV) {
+ global.process.env.NODE_ENV = __DEV__ ? 'development' : 'production';
+ }
+},87,[],"node_modules\\react-native\\Libraries\\Core\\setUpGlobals.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _require = _$$_REQUIRE(_dependencyMap[0], "PolyfillFunctions"),
+ polyfillGlobal = _require.polyfillGlobal;
+
+ var _shouldPolyfillCollection = _$$_REQUIRE(_dependencyMap[1], "_shouldPolyfillES6Collection");
+
+ if (_shouldPolyfillCollection('Map')) {
+ _$$_REQUIRE(_dependencyMap[2], "_wrapObjectFreezeAndFriends");
+
+ polyfillGlobal('Map', function () {
+ return _$$_REQUIRE(_dependencyMap[3], "Map");
+ });
+ }
+
+ if (_shouldPolyfillCollection('Set')) {
+ _$$_REQUIRE(_dependencyMap[2], "_wrapObjectFreezeAndFriends");
+
+ polyfillGlobal('Set', function () {
+ return _$$_REQUIRE(_dependencyMap[4], "Set");
+ });
+ }
+},88,[89,90,91,92,95],"node_modules\\react-native\\Libraries\\Core\\polyfillES6Collections.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var defineLazyObjectProperty = _$$_REQUIRE(_dependencyMap[0], "defineLazyObjectProperty");
+
+ function polyfillObjectProperty(object, name, getValue) {
+ var descriptor = Object.getOwnPropertyDescriptor(object, name);
+
+ if (__DEV__ && descriptor) {
+ var backupName = "original" + name[0].toUpperCase() + name.substr(1);
+ Object.defineProperty(object, backupName, descriptor);
+ }
+
+ var _ref = descriptor || {},
+ enumerable = _ref.enumerable,
+ writable = _ref.writable,
+ configurable = _ref.configurable;
+
+ if (descriptor && !configurable) {
+ console.error('Failed to set polyfill. ' + name + ' is not configurable.');
+ return;
+ }
+
+ defineLazyObjectProperty(object, name, {
+ get: getValue,
+ enumerable: enumerable !== false,
+ writable: writable !== false
+ });
+ }
+
+ function polyfillGlobal(name, getValue) {
+ polyfillObjectProperty(global, name, getValue);
+ }
+
+ module.exports = {
+ polyfillObjectProperty: polyfillObjectProperty,
+ polyfillGlobal: polyfillGlobal
+ };
+},89,[51],"node_modules\\react-native\\Libraries\\Utilities\\PolyfillFunctions.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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;
+},90,[],"node_modules\\react-native\\Libraries\\vendor\\core\\_shouldPolyfillES6Collection.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var testMap;
+
+ function getTestMap() {
+ return testMap || (testMap = new (_$$_REQUIRE(_dependencyMap[0], "./Map"))());
+ }
+
+ ['freeze', 'seal', 'preventExtensions'].forEach(function (name) {
+ var method = Object[name];
+
+ if (typeof method === 'function') {
+ Object[name] = function (obj) {
+ try {
+ getTestMap().set(obj, obj).delete(obj);
+ } finally {
+ return method.call(Object, obj);
+ }
+ };
+ }
+ });
+},91,[92],"node_modules\\react-native\\Libraries\\vendor\\core\\_wrapObjectFreezeAndFriends.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _shouldPolyfillES6Collection = _$$_REQUIRE(_dependencyMap[2], "_shouldPolyfillES6Collection");
+
+ var guid = _$$_REQUIRE(_dependencyMap[3], "guid");
+
+ var toIterator = _$$_REQUIRE(_dependencyMap[4], "toIterator");
+
+ module.exports = function (global, undefined) {
+ if (!_shouldPolyfillES6Collection('Map')) {
+ return global.Map;
+ }
+
+ _$$_REQUIRE(_dependencyMap[5], "./_wrapObjectFreezeAndFriends");
+
+ var hasOwn = Object.prototype.hasOwnProperty;
+ 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 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 (hasOwn.call(map, 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);
+ }
+ }
+
+ var getHash = function () {
+ var propIsEnumerable = Object.prototype.propertyIsEnumerable;
+ var hashProperty = '__MAP_POLYFILL_INTERNAL_HASH__';
+ var hashCounter = 0;
+ var nonExtensibleObjects = [];
+ var nonExtensibleHashes = [];
+ return function getHash(o) {
+ if (hasOwn.call(o, hashProperty)) {
+ return o[hashProperty];
+ }
+
+ if (!isES5) {
+ if (hasOwn.call(o, 'propertyIsEnumerable') && hasOwn.call(o.propertyIsEnumerable, hashProperty)) {
+ return o.propertyIsEnumerable[hashProperty];
+ }
+ }
+
+ if (isExtensible(o)) {
+ if (isES5) {
+ Object.defineProperty(o, hashProperty, {
+ enumerable: false,
+ writable: false,
+ configurable: false,
+ value: ++hashCounter
+ });
+ return hashCounter;
+ }
+
+ if (o.propertyIsEnumerable) {
+ o.propertyIsEnumerable = function () {
+ return propIsEnumerable.apply(this, arguments);
+ };
+
+ return o.propertyIsEnumerable[hashProperty] = ++hashCounter;
+ }
+ }
+
+ var index = nonExtensibleObjects.indexOf(o);
+
+ if (index < 0) {
+ index = nonExtensibleObjects.length;
+ nonExtensibleObjects[index] = o;
+ nonExtensibleHashes[index] = ++hashCounter;
+ }
+
+ return nonExtensibleHashes[index];
+ };
+ }();
+
+ return Map;
+ }(Function('return this')());
+},92,[3,4,90,93,94,91],"node_modules\\react-native\\Libraries\\vendor\\core\\Map.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ function guid() {
+ return 'f' + (Math.random() * (1 << 30)).toString(16).replace('.', '');
+ }
+
+ module.exports = guid;
+},93,[],"node_modules\\react-native\\Libraries\\vendor\\core\\guid.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ var 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;
+},94,[14,3,4],"node_modules\\react-native\\Libraries\\vendor\\core\\toIterator.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var Map = _$$_REQUIRE(_dependencyMap[2], "Map");
+
+ var _shouldPolyfillES6Collection = _$$_REQUIRE(_dependencyMap[3], "_shouldPolyfillES6Collection");
+
+ var toIterator = _$$_REQUIRE(_dependencyMap[4], "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')());
+},95,[3,4,92,90,94],"node_modules\\react-native\\Libraries\\vendor\\core\\Set.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ if (global.__RCTProfileIsProfiling) {
+ var Systrace = _$$_REQUIRE(_dependencyMap[0], "Systrace");
+
+ Systrace.installReactHook();
+ Systrace.setEnabled(true);
+ }
+},96,[48],"node_modules\\react-native\\Libraries\\Core\\setUpSystrace.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var ExceptionsManager = _$$_REQUIRE(_dependencyMap[0], "ExceptionsManager");
+
+ ExceptionsManager.installConsoleErrorReporter();
+
+ if (!global.__fbDisableExceptionsManager) {
+ var handleError = function handleError(e, isFatal) {
+ try {
+ ExceptionsManager.handleException(e, isFatal);
+ } catch (ee) {
+ console.log('Failed to print error: ', ee.message);
+ throw e;
+ }
+ };
+
+ var ErrorUtils = _$$_REQUIRE(_dependencyMap[1], "ErrorUtils");
+
+ ErrorUtils.setGlobalHandler(handleError);
+ }
+},97,[98,47],"node_modules\\react-native\\Libraries\\Core\\setUpErrorHandling.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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;
+ var message = e.jsEngine == null ? e.message : e.message + ", js engine: " + e.jsEngine;
+
+ if (isFatal) {
+ ExceptionsManager.reportFatalException(message, stack, currentExceptionID);
+ } else {
+ ExceptionsManager.reportSoftException(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
+ };
+},98,[36,99,101,50],"node_modules\\react-native\\Libraries\\Core\\ExceptionsManager.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ function parseErrorStack(e) {
+ if (!e || !e.stack) {
+ return [];
+ }
+
+ var stacktraceParser = _$$_REQUIRE(_dependencyMap[0], "stacktrace-parser");
+
+ var stack = Array.isArray(e.stack) ? e.stack : stacktraceParser.parse(e.stack);
+ var framesToPop = typeof e.framesToPop === 'number' ? e.framesToPop : 0;
+
+ while (framesToPop--) {
+ stack.shift();
+ }
+
+ return stack;
+ }
+
+ module.exports = parseErrorStack;
+},99,[100],"node_modules\\react-native\\Libraries\\Core\\Devtools\\parseErrorStack.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ (function (global, factory) {
+ typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : typeof define === 'function' && define.amd ? define(['exports'], factory) : (global = global || self, factory(global.stackTraceParser = {}));
+ })(this, function (exports) {
+ 'use strict';
+
+ var UNKNOWN_FUNCTION = '';
+
+ function parse(stackString) {
+ var lines = stackString.split('\n');
+ return lines.reduce(function (stack, line) {
+ var parseResult = parseChrome(line) || parseWinjs(line) || parseGecko(line) || parseJSC(line) || parseNode(line);
+
+ if (parseResult) {
+ stack.push(parseResult);
+ }
+
+ return stack;
+ }, []);
+ }
+
+ var chromeRe = /^\s*at (.*?) ?\(((?:file|https?|blob|chrome-extension|native|eval|webpack||\/).*?)(?::(\d+))?(?::(\d+))?\)?\s*$/i;
+ var chromeEvalRe = /\((\S*)(?::(\d+))(?::(\d+))\)/;
+
+ function parseChrome(line) {
+ var parts = chromeRe.exec(line);
+
+ if (!parts) {
+ return null;
+ }
+
+ var isNative = parts[2] && parts[2].indexOf('native') === 0;
+ var isEval = parts[2] && parts[2].indexOf('eval') === 0;
+ var submatch = chromeEvalRe.exec(parts[2]);
+
+ if (isEval && submatch != null) {
+ parts[2] = submatch[1];
+ parts[3] = submatch[2];
+ parts[4] = submatch[3];
+ }
+
+ return {
+ file: !isNative ? parts[2] : null,
+ methodName: parts[1] || UNKNOWN_FUNCTION,
+ arguments: isNative ? [parts[2]] : [],
+ lineNumber: parts[3] ? +parts[3] : null,
+ column: parts[4] ? +parts[4] : null
+ };
+ }
+
+ var winjsRe = /^\s*at (?:((?:\[object object\])?.+) )?\(?((?:file|ms-appx|https?|webpack|blob):.*?):(\d+)(?::(\d+))?\)?\s*$/i;
+
+ function parseWinjs(line) {
+ var parts = winjsRe.exec(line);
+
+ if (!parts) {
+ return null;
+ }
+
+ return {
+ file: parts[2],
+ methodName: parts[1] || UNKNOWN_FUNCTION,
+ arguments: [],
+ lineNumber: +parts[3],
+ column: parts[4] ? +parts[4] : null
+ };
+ }
+
+ var geckoRe = /^\s*(.*?)(?:\((.*?)\))?(?:^|@)((?:file|https?|blob|chrome|webpack|resource|\[native).*?|[^@]*bundle)(?::(\d+))?(?::(\d+))?\s*$/i;
+ var geckoEvalRe = /(\S+) line (\d+)(?: > eval line \d+)* > eval/i;
+
+ function parseGecko(line) {
+ var parts = geckoRe.exec(line);
+
+ if (!parts) {
+ return null;
+ }
+
+ var isEval = parts[3] && parts[3].indexOf(' > eval') > -1;
+ var submatch = geckoEvalRe.exec(parts[3]);
+
+ if (isEval && submatch != null) {
+ parts[3] = submatch[1];
+ parts[4] = submatch[2];
+ parts[5] = null;
+ }
+
+ return {
+ file: parts[3],
+ methodName: parts[1] || UNKNOWN_FUNCTION,
+ arguments: parts[2] ? parts[2].split(',') : [],
+ lineNumber: parts[4] ? +parts[4] : null,
+ column: parts[5] ? +parts[5] : null
+ };
+ }
+
+ var javaScriptCoreRe = /^(?:\s*([^@]*)(?:\((.*?)\))?@)?(\S.*?):(\d+)(?::(\d+))?\s*$/i;
+
+ function parseJSC(line) {
+ var parts = javaScriptCoreRe.exec(line);
+
+ if (!parts) {
+ return null;
+ }
+
+ return {
+ file: parts[3],
+ methodName: parts[1] || UNKNOWN_FUNCTION,
+ arguments: [],
+ lineNumber: +parts[4],
+ column: parts[5] ? +parts[5] : null
+ };
+ }
+
+ var nodeRe = /^\s*at (?:((?:\[object object\])?\S+(?: \[as \S+\])?) )?\(?(.*?):(\d+)(?::(\d+))?\)?\s*$/i;
+
+ function parseNode(line) {
+ var parts = nodeRe.exec(line);
+
+ if (!parts) {
+ return null;
+ }
+
+ return {
+ file: parts[2],
+ methodName: parts[1] || UNKNOWN_FUNCTION,
+ arguments: [],
+ lineNumber: +parts[3],
+ column: parts[4] ? +parts[4] : null
+ };
+ }
+
+ exports.parse = parse;
+ Object.defineProperty(exports, '__esModule', {
+ value: true
+ });
+ });
+},100,[],"node_modules\\stacktrace-parser\\dist\\stack-trace-parser.umd.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _regeneratorRuntime = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/regenerator");
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/defineProperty");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var getDevServer = _$$_REQUIRE(_dependencyMap[2], "getDevServer");
+
+ var _require = _$$_REQUIRE(_dependencyMap[3], "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[4], "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();
+ }
+ }
+ });
+ }
+
+ module.exports = symbolicateStackTrace;
+},101,[102,32,104,36,105],"node_modules\\react-native\\Libraries\\Core\\Devtools\\symbolicateStackTrace.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "regenerator-runtime");
+},102,[103],"node_modules\\@babel\\runtime\\regenerator\\index.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var runtime = function (exports) {
+ "use strict";
+
+ var Op = Object.prototype;
+ var hasOwn = Op.hasOwnProperty;
+ var undefined;
+ var $Symbol = typeof Symbol === "function" ? Symbol : {};
+ var iteratorSymbol = $Symbol.iterator || "@@iterator";
+ var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";
+ var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
+
+ function wrap(innerFn, outerFn, self, tryLocsList) {
+ var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
+ var generator = Object.create(protoGenerator.prototype);
+ var context = new Context(tryLocsList || []);
+ generator._invoke = makeInvokeMethod(innerFn, self, context);
+ return generator;
+ }
+
+ exports.wrap = wrap;
+
+ function tryCatch(fn, obj, arg) {
+ try {
+ return {
+ type: "normal",
+ arg: fn.call(obj, arg)
+ };
+ } catch (err) {
+ return {
+ type: "throw",
+ arg: err
+ };
+ }
+ }
+
+ var GenStateSuspendedStart = "suspendedStart";
+ var GenStateSuspendedYield = "suspendedYield";
+ var GenStateExecuting = "executing";
+ var GenStateCompleted = "completed";
+ var ContinueSentinel = {};
+
+ function Generator() {}
+
+ function GeneratorFunction() {}
+
+ function GeneratorFunctionPrototype() {}
+
+ var IteratorPrototype = {};
+
+ IteratorPrototype[iteratorSymbol] = function () {
+ return this;
+ };
+
+ var getProto = Object.getPrototypeOf;
+ var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
+
+ if (NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
+ IteratorPrototype = NativeIteratorPrototype;
+ }
+
+ var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
+ GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;
+ GeneratorFunctionPrototype.constructor = GeneratorFunction;
+ GeneratorFunctionPrototype[toStringTagSymbol] = GeneratorFunction.displayName = "GeneratorFunction";
+
+ function defineIteratorMethods(prototype) {
+ ["next", "throw", "return"].forEach(function (method) {
+ prototype[method] = function (arg) {
+ return this._invoke(method, arg);
+ };
+ });
+ }
+
+ exports.isGeneratorFunction = function (genFun) {
+ var ctor = typeof genFun === "function" && genFun.constructor;
+ return ctor ? ctor === GeneratorFunction || (ctor.displayName || ctor.name) === "GeneratorFunction" : false;
+ };
+
+ exports.mark = function (genFun) {
+ if (Object.setPrototypeOf) {
+ Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
+ } else {
+ genFun.__proto__ = GeneratorFunctionPrototype;
+
+ if (!(toStringTagSymbol in genFun)) {
+ genFun[toStringTagSymbol] = "GeneratorFunction";
+ }
+ }
+
+ genFun.prototype = Object.create(Gp);
+ return genFun;
+ };
+
+ exports.awrap = function (arg) {
+ return {
+ __await: arg
+ };
+ };
+
+ function AsyncIterator(generator) {
+ function invoke(method, arg, resolve, reject) {
+ var record = tryCatch(generator[method], generator, arg);
+
+ if (record.type === "throw") {
+ reject(record.arg);
+ } else {
+ var result = record.arg;
+ var value = result.value;
+
+ if (value && typeof value === "object" && hasOwn.call(value, "__await")) {
+ return Promise.resolve(value.__await).then(function (value) {
+ invoke("next", value, resolve, reject);
+ }, function (err) {
+ invoke("throw", err, resolve, reject);
+ });
+ }
+
+ return Promise.resolve(value).then(function (unwrapped) {
+ result.value = unwrapped;
+ resolve(result);
+ }, function (error) {
+ return invoke("throw", error, resolve, reject);
+ });
+ }
+ }
+
+ var previousPromise;
+
+ function enqueue(method, arg) {
+ function callInvokeWithMethodAndArg() {
+ return new Promise(function (resolve, reject) {
+ invoke(method, arg, resolve, reject);
+ });
+ }
+
+ return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
+ }
+
+ this._invoke = enqueue;
+ }
+
+ defineIteratorMethods(AsyncIterator.prototype);
+
+ AsyncIterator.prototype[asyncIteratorSymbol] = function () {
+ return this;
+ };
+
+ exports.AsyncIterator = AsyncIterator;
+
+ exports.async = function (innerFn, outerFn, self, tryLocsList) {
+ var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList));
+ return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {
+ return result.done ? result.value : iter.next();
+ });
+ };
+
+ function makeInvokeMethod(innerFn, self, context) {
+ var state = GenStateSuspendedStart;
+ return function invoke(method, arg) {
+ if (state === GenStateExecuting) {
+ throw new Error("Generator is already running");
+ }
+
+ if (state === GenStateCompleted) {
+ if (method === "throw") {
+ throw arg;
+ }
+
+ return doneResult();
+ }
+
+ context.method = method;
+ context.arg = arg;
+
+ while (true) {
+ var delegate = context.delegate;
+
+ if (delegate) {
+ var delegateResult = maybeInvokeDelegate(delegate, context);
+
+ if (delegateResult) {
+ if (delegateResult === ContinueSentinel) continue;
+ return delegateResult;
+ }
+ }
+
+ if (context.method === "next") {
+ context.sent = context._sent = context.arg;
+ } else if (context.method === "throw") {
+ if (state === GenStateSuspendedStart) {
+ state = GenStateCompleted;
+ throw context.arg;
+ }
+
+ context.dispatchException(context.arg);
+ } else if (context.method === "return") {
+ context.abrupt("return", context.arg);
+ }
+
+ state = GenStateExecuting;
+ var record = tryCatch(innerFn, self, context);
+
+ if (record.type === "normal") {
+ state = context.done ? GenStateCompleted : GenStateSuspendedYield;
+
+ if (record.arg === ContinueSentinel) {
+ continue;
+ }
+
+ return {
+ value: record.arg,
+ done: context.done
+ };
+ } else if (record.type === "throw") {
+ state = GenStateCompleted;
+ context.method = "throw";
+ context.arg = record.arg;
+ }
+ }
+ };
+ }
+
+ function maybeInvokeDelegate(delegate, context) {
+ var method = delegate.iterator[context.method];
+
+ if (method === undefined) {
+ context.delegate = null;
+
+ if (context.method === "throw") {
+ if (delegate.iterator["return"]) {
+ context.method = "return";
+ context.arg = undefined;
+ maybeInvokeDelegate(delegate, context);
+
+ if (context.method === "throw") {
+ return ContinueSentinel;
+ }
+ }
+
+ context.method = "throw";
+ context.arg = new TypeError("The iterator does not provide a 'throw' method");
+ }
+
+ return ContinueSentinel;
+ }
+
+ var record = tryCatch(method, delegate.iterator, context.arg);
+
+ if (record.type === "throw") {
+ context.method = "throw";
+ context.arg = record.arg;
+ context.delegate = null;
+ return ContinueSentinel;
+ }
+
+ var info = record.arg;
+
+ if (!info) {
+ context.method = "throw";
+ context.arg = new TypeError("iterator result is not an object");
+ context.delegate = null;
+ return ContinueSentinel;
+ }
+
+ if (info.done) {
+ context[delegate.resultName] = info.value;
+ context.next = delegate.nextLoc;
+
+ if (context.method !== "return") {
+ context.method = "next";
+ context.arg = undefined;
+ }
+ } else {
+ return info;
+ }
+
+ context.delegate = null;
+ return ContinueSentinel;
+ }
+
+ defineIteratorMethods(Gp);
+ Gp[toStringTagSymbol] = "Generator";
+
+ Gp[iteratorSymbol] = function () {
+ return this;
+ };
+
+ Gp.toString = function () {
+ return "[object Generator]";
+ };
+
+ function pushTryEntry(locs) {
+ var entry = {
+ tryLoc: locs[0]
+ };
+
+ if (1 in locs) {
+ entry.catchLoc = locs[1];
+ }
+
+ if (2 in locs) {
+ entry.finallyLoc = locs[2];
+ entry.afterLoc = locs[3];
+ }
+
+ this.tryEntries.push(entry);
+ }
+
+ function resetTryEntry(entry) {
+ var record = entry.completion || {};
+ record.type = "normal";
+ delete record.arg;
+ entry.completion = record;
+ }
+
+ function Context(tryLocsList) {
+ this.tryEntries = [{
+ tryLoc: "root"
+ }];
+ tryLocsList.forEach(pushTryEntry, this);
+ this.reset(true);
+ }
+
+ exports.keys = function (object) {
+ var keys = [];
+
+ for (var key in object) {
+ keys.push(key);
+ }
+
+ keys.reverse();
+ return function next() {
+ while (keys.length) {
+ var key = keys.pop();
+
+ if (key in object) {
+ next.value = key;
+ next.done = false;
+ return next;
+ }
+ }
+
+ next.done = true;
+ return next;
+ };
+ };
+
+ function values(iterable) {
+ if (iterable) {
+ var iteratorMethod = iterable[iteratorSymbol];
+
+ if (iteratorMethod) {
+ return iteratorMethod.call(iterable);
+ }
+
+ if (typeof iterable.next === "function") {
+ return iterable;
+ }
+
+ if (!isNaN(iterable.length)) {
+ var i = -1,
+ next = function next() {
+ while (++i < iterable.length) {
+ if (hasOwn.call(iterable, i)) {
+ next.value = iterable[i];
+ next.done = false;
+ return next;
+ }
+ }
+
+ next.value = undefined;
+ next.done = true;
+ return next;
+ };
+
+ return next.next = next;
+ }
+ }
+
+ return {
+ next: doneResult
+ };
+ }
+
+ exports.values = values;
+
+ function doneResult() {
+ return {
+ value: undefined,
+ done: true
+ };
+ }
+
+ Context.prototype = {
+ constructor: Context,
+ reset: function reset(skipTempReset) {
+ this.prev = 0;
+ this.next = 0;
+ this.sent = this._sent = undefined;
+ this.done = false;
+ this.delegate = null;
+ this.method = "next";
+ this.arg = undefined;
+ this.tryEntries.forEach(resetTryEntry);
+
+ if (!skipTempReset) {
+ for (var name in this) {
+ if (name.charAt(0) === "t" && hasOwn.call(this, name) && !isNaN(+name.slice(1))) {
+ this[name] = undefined;
+ }
+ }
+ }
+ },
+ stop: function stop() {
+ this.done = true;
+ var rootEntry = this.tryEntries[0];
+ var rootRecord = rootEntry.completion;
+
+ if (rootRecord.type === "throw") {
+ throw rootRecord.arg;
+ }
+
+ return this.rval;
+ },
+ dispatchException: function dispatchException(exception) {
+ if (this.done) {
+ throw exception;
+ }
+
+ var context = this;
+
+ function handle(loc, caught) {
+ record.type = "throw";
+ record.arg = exception;
+ context.next = loc;
+
+ if (caught) {
+ context.method = "next";
+ context.arg = undefined;
+ }
+
+ return !!caught;
+ }
+
+ for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+ var entry = this.tryEntries[i];
+ var record = entry.completion;
+
+ if (entry.tryLoc === "root") {
+ return handle("end");
+ }
+
+ if (entry.tryLoc <= this.prev) {
+ var hasCatch = hasOwn.call(entry, "catchLoc");
+ var hasFinally = hasOwn.call(entry, "finallyLoc");
+
+ if (hasCatch && hasFinally) {
+ if (this.prev < entry.catchLoc) {
+ return handle(entry.catchLoc, true);
+ } else if (this.prev < entry.finallyLoc) {
+ return handle(entry.finallyLoc);
+ }
+ } else if (hasCatch) {
+ if (this.prev < entry.catchLoc) {
+ return handle(entry.catchLoc, true);
+ }
+ } else if (hasFinally) {
+ if (this.prev < entry.finallyLoc) {
+ return handle(entry.finallyLoc);
+ }
+ } else {
+ throw new Error("try statement without catch or finally");
+ }
+ }
+ }
+ },
+ abrupt: function abrupt(type, arg) {
+ for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+ var entry = this.tryEntries[i];
+
+ if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
+ var finallyEntry = entry;
+ break;
+ }
+ }
+
+ if (finallyEntry && (type === "break" || type === "continue") && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc) {
+ finallyEntry = null;
+ }
+
+ var record = finallyEntry ? finallyEntry.completion : {};
+ record.type = type;
+ record.arg = arg;
+
+ if (finallyEntry) {
+ this.method = "next";
+ this.next = finallyEntry.finallyLoc;
+ return ContinueSentinel;
+ }
+
+ return this.complete(record);
+ },
+ complete: function complete(record, afterLoc) {
+ if (record.type === "throw") {
+ throw record.arg;
+ }
+
+ if (record.type === "break" || record.type === "continue") {
+ this.next = record.arg;
+ } else if (record.type === "return") {
+ this.rval = this.arg = record.arg;
+ this.method = "return";
+ this.next = "end";
+ } else if (record.type === "normal" && afterLoc) {
+ this.next = afterLoc;
+ }
+
+ return ContinueSentinel;
+ },
+ finish: function finish(finallyLoc) {
+ for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+ var entry = this.tryEntries[i];
+
+ if (entry.finallyLoc === finallyLoc) {
+ this.complete(entry.completion, entry.afterLoc);
+ resetTryEntry(entry);
+ return ContinueSentinel;
+ }
+ }
+ },
+ "catch": function _catch(tryLoc) {
+ for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+ var entry = this.tryEntries[i];
+
+ if (entry.tryLoc === tryLoc) {
+ var record = entry.completion;
+
+ if (record.type === "throw") {
+ var thrown = record.arg;
+ resetTryEntry(entry);
+ }
+
+ return thrown;
+ }
+ }
+
+ throw new Error("illegal catch attempt");
+ },
+ delegateYield: function delegateYield(iterable, resultName, nextLoc) {
+ this.delegate = {
+ iterator: values(iterable),
+ resultName: resultName,
+ nextLoc: nextLoc
+ };
+
+ if (this.method === "next") {
+ this.arg = undefined;
+ }
+
+ return ContinueSentinel;
+ }
+ };
+ return exports;
+ }(typeof module === "object" ? module.exports : {});
+
+ try {
+ regeneratorRuntime = runtime;
+ } catch (accidentalStrictMode) {
+ Function("r", "regeneratorRuntime = r")(runtime);
+ }
+},103,[],"node_modules\\regenerator-runtime\\runtime.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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;
+},104,[36],"node_modules\\react-native\\Libraries\\Core\\Devtools\\getDevServer.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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
+ };
+ }
+},105,[106],"node_modules\\react-native\\Libraries\\Network\\fetch.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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;
+ }
+
+ if ('responseType' in xhr && support.blob) {
+ xhr.responseType = 'blob';
+ }
+
+ 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);
+},106,[],"node_modules\\react-native\\Libraries\\vendor\\core\\whatwg-fetch.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var ReactNativeVersionCheck = _$$_REQUIRE(_dependencyMap[0], "ReactNativeVersionCheck");
+
+ ReactNativeVersionCheck.checkVersions();
+},107,[108],"node_modules\\react-native\\Libraries\\Core\\checkNativeVersion.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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 : '');
+ }
+},108,[36,109],"node_modules\\react-native\\Libraries\\Core\\ReactNativeVersionCheck.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ exports.version = {
+ major: 0,
+ minor: 59,
+ patch: 0,
+ prerelease: null
+ };
+},109,[],"node_modules\\react-native\\Libraries\\Core\\ReactNativeVersion.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _require = _$$_REQUIRE(_dependencyMap[0], "PolyfillFunctions"),
+ polyfillGlobal = _require.polyfillGlobal;
+
+ polyfillGlobal('Promise', function () {
+ return _$$_REQUIRE(_dependencyMap[1], "Promise");
+ });
+},110,[89,111],"node_modules\\react-native\\Libraries\\Core\\polyfillPromise.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var Promise = _$$_REQUIRE(_dependencyMap[0], "promise/setimmediate/es6-extensions");
+
+ _$$_REQUIRE(_dependencyMap[1], "promise/setimmediate/done");
+
+ Promise.prototype.finally = function (onSettled) {
+ return this.then(onSettled, onSettled);
+ };
+
+ if (__DEV__) {
+ _$$_REQUIRE(_dependencyMap[2], "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[3], "pretty-format")(error);
+ }
+
+ var warning = "Possible Unhandled Promise Rejection (id: " + id + "):\n" + (message + "\n") + (stack == null ? '' : stack);
+ console.warn(warning);
+ },
+ onHandled: function onHandled(id) {
+ var warning = "Promise Rejection Handled (id: " + id + ")\n" + 'This means you can ignore any previous messages of the form ' + ("\"Possible Unhandled Promise Rejection (id: " + id + "):\"");
+ console.warn(warning);
+ }
+ });
+ }
+
+ module.exports = Promise;
+},111,[112,114,115,116],"node_modules\\react-native\\Libraries\\Promise.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var Promise = _$$_REQUIRE(_dependencyMap[0], "./core.js");
+
+ module.exports = Promise;
+ var TRUE = valuePromise(true);
+ var FALSE = valuePromise(false);
+ var NULL = valuePromise(null);
+ var UNDEFINED = valuePromise(undefined);
+ var ZERO = valuePromise(0);
+ var EMPTYSTRING = valuePromise('');
+
+ function valuePromise(value) {
+ var p = new Promise(Promise._61);
+ p._65 = 1;
+ p._55 = value;
+ return p;
+ }
+
+ Promise.resolve = function (value) {
+ if (value instanceof Promise) return value;
+ if (value === null) return NULL;
+ if (value === undefined) return UNDEFINED;
+ if (value === true) return TRUE;
+ if (value === false) return FALSE;
+ if (value === 0) return ZERO;
+ if (value === '') return EMPTYSTRING;
+
+ if (typeof value === 'object' || typeof value === 'function') {
+ try {
+ var then = value.then;
+
+ if (typeof then === 'function') {
+ return new Promise(then.bind(value));
+ }
+ } catch (ex) {
+ return new Promise(function (resolve, reject) {
+ reject(ex);
+ });
+ }
+ }
+
+ return valuePromise(value);
+ };
+
+ Promise.all = function (arr) {
+ var args = Array.prototype.slice.call(arr);
+ return new Promise(function (resolve, reject) {
+ if (args.length === 0) return resolve([]);
+ var remaining = args.length;
+
+ function res(i, val) {
+ if (val && (typeof val === 'object' || typeof val === 'function')) {
+ if (val instanceof Promise && val.then === Promise.prototype.then) {
+ while (val._65 === 3) {
+ val = val._55;
+ }
+
+ if (val._65 === 1) return res(i, val._55);
+ if (val._65 === 2) reject(val._55);
+ val.then(function (val) {
+ res(i, val);
+ }, reject);
+ return;
+ } else {
+ var then = val.then;
+
+ if (typeof then === 'function') {
+ var p = new Promise(then.bind(val));
+ p.then(function (val) {
+ res(i, val);
+ }, reject);
+ return;
+ }
+ }
+ }
+
+ args[i] = val;
+
+ if (--remaining === 0) {
+ resolve(args);
+ }
+ }
+
+ for (var i = 0; i < args.length; i++) {
+ res(i, args[i]);
+ }
+ });
+ };
+
+ Promise.reject = function (value) {
+ return new Promise(function (resolve, reject) {
+ reject(value);
+ });
+ };
+
+ Promise.race = function (values) {
+ return new Promise(function (resolve, reject) {
+ values.forEach(function (value) {
+ Promise.resolve(value).then(resolve, reject);
+ });
+ });
+ };
+
+ Promise.prototype['catch'] = function (onRejected) {
+ return this.then(null, onRejected);
+ };
+},112,[113],"node_modules\\promise\\setimmediate\\es6-extensions.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ function noop() {}
+
+ var LAST_ERROR = null;
+ var IS_ERROR = {};
+
+ function getThen(obj) {
+ try {
+ return obj.then;
+ } catch (ex) {
+ LAST_ERROR = ex;
+ return IS_ERROR;
+ }
+ }
+
+ function tryCallOne(fn, a) {
+ try {
+ return fn(a);
+ } catch (ex) {
+ LAST_ERROR = ex;
+ return IS_ERROR;
+ }
+ }
+
+ function tryCallTwo(fn, a, b) {
+ try {
+ fn(a, b);
+ } catch (ex) {
+ LAST_ERROR = ex;
+ return IS_ERROR;
+ }
+ }
+
+ module.exports = Promise;
+
+ function Promise(fn) {
+ if (typeof this !== 'object') {
+ throw new TypeError('Promises must be constructed via new');
+ }
+
+ if (typeof fn !== 'function') {
+ throw new TypeError('Promise constructor\'s argument is not a function');
+ }
+
+ this._40 = 0;
+ this._65 = 0;
+ this._55 = null;
+ this._72 = null;
+ if (fn === noop) return;
+ doResolve(fn, this);
+ }
+
+ Promise._37 = null;
+ Promise._87 = null;
+ Promise._61 = noop;
+
+ Promise.prototype.then = function (onFulfilled, onRejected) {
+ if (this.constructor !== Promise) {
+ return safeThen(this, onFulfilled, onRejected);
+ }
+
+ var res = new Promise(noop);
+ handle(this, new Handler(onFulfilled, onRejected, res));
+ return res;
+ };
+
+ function safeThen(self, onFulfilled, onRejected) {
+ return new self.constructor(function (resolve, reject) {
+ var res = new Promise(noop);
+ res.then(resolve, reject);
+ handle(self, new Handler(onFulfilled, onRejected, res));
+ });
+ }
+
+ function handle(self, deferred) {
+ while (self._65 === 3) {
+ self = self._55;
+ }
+
+ if (Promise._37) {
+ Promise._37(self);
+ }
+
+ if (self._65 === 0) {
+ if (self._40 === 0) {
+ self._40 = 1;
+ self._72 = deferred;
+ return;
+ }
+
+ if (self._40 === 1) {
+ self._40 = 2;
+ self._72 = [self._72, deferred];
+ return;
+ }
+
+ self._72.push(deferred);
+
+ return;
+ }
+
+ handleResolved(self, deferred);
+ }
+
+ function handleResolved(self, deferred) {
+ setImmediate(function () {
+ var cb = self._65 === 1 ? deferred.onFulfilled : deferred.onRejected;
+
+ if (cb === null) {
+ if (self._65 === 1) {
+ resolve(deferred.promise, self._55);
+ } else {
+ reject(deferred.promise, self._55);
+ }
+
+ return;
+ }
+
+ var ret = tryCallOne(cb, self._55);
+
+ if (ret === IS_ERROR) {
+ reject(deferred.promise, LAST_ERROR);
+ } else {
+ resolve(deferred.promise, ret);
+ }
+ });
+ }
+
+ function resolve(self, newValue) {
+ if (newValue === self) {
+ return reject(self, new TypeError('A promise cannot be resolved with itself.'));
+ }
+
+ if (newValue && (typeof newValue === 'object' || typeof newValue === 'function')) {
+ var then = getThen(newValue);
+
+ if (then === IS_ERROR) {
+ return reject(self, LAST_ERROR);
+ }
+
+ if (then === self.then && newValue instanceof Promise) {
+ self._65 = 3;
+ self._55 = newValue;
+ finale(self);
+ return;
+ } else if (typeof then === 'function') {
+ doResolve(then.bind(newValue), self);
+ return;
+ }
+ }
+
+ self._65 = 1;
+ self._55 = newValue;
+ finale(self);
+ }
+
+ function reject(self, newValue) {
+ self._65 = 2;
+ self._55 = newValue;
+
+ if (Promise._87) {
+ Promise._87(self, newValue);
+ }
+
+ finale(self);
+ }
+
+ function finale(self) {
+ if (self._40 === 1) {
+ handle(self, self._72);
+ self._72 = null;
+ }
+
+ if (self._40 === 2) {
+ for (var i = 0; i < self._72.length; i++) {
+ handle(self, self._72[i]);
+ }
+
+ self._72 = null;
+ }
+ }
+
+ function Handler(onFulfilled, onRejected, promise) {
+ this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null;
+ this.onRejected = typeof onRejected === 'function' ? onRejected : null;
+ this.promise = promise;
+ }
+
+ function doResolve(fn, promise) {
+ var done = false;
+ var res = tryCallTwo(fn, function (value) {
+ if (done) return;
+ done = true;
+ resolve(promise, value);
+ }, function (reason) {
+ if (done) return;
+ done = true;
+ reject(promise, reason);
+ });
+
+ if (!done && res === IS_ERROR) {
+ done = true;
+ reject(promise, LAST_ERROR);
+ }
+ }
+},113,[],"node_modules\\promise\\setimmediate\\core.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var Promise = _$$_REQUIRE(_dependencyMap[0], "./core.js");
+
+ module.exports = Promise;
+
+ Promise.prototype.done = function (onFulfilled, onRejected) {
+ var self = arguments.length ? this.then.apply(this, arguments) : this;
+ self.then(null, function (err) {
+ setTimeout(function () {
+ throw err;
+ }, 0);
+ });
+ };
+},114,[113],"node_modules\\promise\\setimmediate\\done.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var Promise = _$$_REQUIRE(_dependencyMap[0], "./core");
+
+ 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;
+ });
+ }
+},115,[113],"node_modules\\promise\\setimmediate\\rejection-tracking.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ (function (global, factory) {
+ typeof exports === 'object' && typeof module !== 'undefined' ? factory() : typeof define === 'function' && define.amd ? define(factory) : factory();
+ })(this, function () {
+ 'use strict';
+
+ function createCommonjsModule(fn, module) {
+ return module = {
+ exports: {}
+ }, fn(module, module.exports), module.exports;
+ }
+
+ var colorName = {
+ "aliceblue": [240, 248, 255],
+ "antiquewhite": [250, 235, 215],
+ "aqua": [0, 255, 255],
+ "aquamarine": [127, 255, 212],
+ "azure": [240, 255, 255],
+ "beige": [245, 245, 220],
+ "bisque": [255, 228, 196],
+ "black": [0, 0, 0],
+ "blanchedalmond": [255, 235, 205],
+ "blue": [0, 0, 255],
+ "blueviolet": [138, 43, 226],
+ "brown": [165, 42, 42],
+ "burlywood": [222, 184, 135],
+ "cadetblue": [95, 158, 160],
+ "chartreuse": [127, 255, 0],
+ "chocolate": [210, 105, 30],
+ "coral": [255, 127, 80],
+ "cornflowerblue": [100, 149, 237],
+ "cornsilk": [255, 248, 220],
+ "crimson": [220, 20, 60],
+ "cyan": [0, 255, 255],
+ "darkblue": [0, 0, 139],
+ "darkcyan": [0, 139, 139],
+ "darkgoldenrod": [184, 134, 11],
+ "darkgray": [169, 169, 169],
+ "darkgreen": [0, 100, 0],
+ "darkgrey": [169, 169, 169],
+ "darkkhaki": [189, 183, 107],
+ "darkmagenta": [139, 0, 139],
+ "darkolivegreen": [85, 107, 47],
+ "darkorange": [255, 140, 0],
+ "darkorchid": [153, 50, 204],
+ "darkred": [139, 0, 0],
+ "darksalmon": [233, 150, 122],
+ "darkseagreen": [143, 188, 143],
+ "darkslateblue": [72, 61, 139],
+ "darkslategray": [47, 79, 79],
+ "darkslategrey": [47, 79, 79],
+ "darkturquoise": [0, 206, 209],
+ "darkviolet": [148, 0, 211],
+ "deeppink": [255, 20, 147],
+ "deepskyblue": [0, 191, 255],
+ "dimgray": [105, 105, 105],
+ "dimgrey": [105, 105, 105],
+ "dodgerblue": [30, 144, 255],
+ "firebrick": [178, 34, 34],
+ "floralwhite": [255, 250, 240],
+ "forestgreen": [34, 139, 34],
+ "fuchsia": [255, 0, 255],
+ "gainsboro": [220, 220, 220],
+ "ghostwhite": [248, 248, 255],
+ "gold": [255, 215, 0],
+ "goldenrod": [218, 165, 32],
+ "gray": [128, 128, 128],
+ "green": [0, 128, 0],
+ "greenyellow": [173, 255, 47],
+ "grey": [128, 128, 128],
+ "honeydew": [240, 255, 240],
+ "hotpink": [255, 105, 180],
+ "indianred": [205, 92, 92],
+ "indigo": [75, 0, 130],
+ "ivory": [255, 255, 240],
+ "khaki": [240, 230, 140],
+ "lavender": [230, 230, 250],
+ "lavenderblush": [255, 240, 245],
+ "lawngreen": [124, 252, 0],
+ "lemonchiffon": [255, 250, 205],
+ "lightblue": [173, 216, 230],
+ "lightcoral": [240, 128, 128],
+ "lightcyan": [224, 255, 255],
+ "lightgoldenrodyellow": [250, 250, 210],
+ "lightgray": [211, 211, 211],
+ "lightgreen": [144, 238, 144],
+ "lightgrey": [211, 211, 211],
+ "lightpink": [255, 182, 193],
+ "lightsalmon": [255, 160, 122],
+ "lightseagreen": [32, 178, 170],
+ "lightskyblue": [135, 206, 250],
+ "lightslategray": [119, 136, 153],
+ "lightslategrey": [119, 136, 153],
+ "lightsteelblue": [176, 196, 222],
+ "lightyellow": [255, 255, 224],
+ "lime": [0, 255, 0],
+ "limegreen": [50, 205, 50],
+ "linen": [250, 240, 230],
+ "magenta": [255, 0, 255],
+ "maroon": [128, 0, 0],
+ "mediumaquamarine": [102, 205, 170],
+ "mediumblue": [0, 0, 205],
+ "mediumorchid": [186, 85, 211],
+ "mediumpurple": [147, 112, 219],
+ "mediumseagreen": [60, 179, 113],
+ "mediumslateblue": [123, 104, 238],
+ "mediumspringgreen": [0, 250, 154],
+ "mediumturquoise": [72, 209, 204],
+ "mediumvioletred": [199, 21, 133],
+ "midnightblue": [25, 25, 112],
+ "mintcream": [245, 255, 250],
+ "mistyrose": [255, 228, 225],
+ "moccasin": [255, 228, 181],
+ "navajowhite": [255, 222, 173],
+ "navy": [0, 0, 128],
+ "oldlace": [253, 245, 230],
+ "olive": [128, 128, 0],
+ "olivedrab": [107, 142, 35],
+ "orange": [255, 165, 0],
+ "orangered": [255, 69, 0],
+ "orchid": [218, 112, 214],
+ "palegoldenrod": [238, 232, 170],
+ "palegreen": [152, 251, 152],
+ "paleturquoise": [175, 238, 238],
+ "palevioletred": [219, 112, 147],
+ "papayawhip": [255, 239, 213],
+ "peachpuff": [255, 218, 185],
+ "peru": [205, 133, 63],
+ "pink": [255, 192, 203],
+ "plum": [221, 160, 221],
+ "powderblue": [176, 224, 230],
+ "purple": [128, 0, 128],
+ "rebeccapurple": [102, 51, 153],
+ "red": [255, 0, 0],
+ "rosybrown": [188, 143, 143],
+ "royalblue": [65, 105, 225],
+ "saddlebrown": [139, 69, 19],
+ "salmon": [250, 128, 114],
+ "sandybrown": [244, 164, 96],
+ "seagreen": [46, 139, 87],
+ "seashell": [255, 245, 238],
+ "sienna": [160, 82, 45],
+ "silver": [192, 192, 192],
+ "skyblue": [135, 206, 235],
+ "slateblue": [106, 90, 205],
+ "slategray": [112, 128, 144],
+ "slategrey": [112, 128, 144],
+ "snow": [255, 250, 250],
+ "springgreen": [0, 255, 127],
+ "steelblue": [70, 130, 180],
+ "tan": [210, 180, 140],
+ "teal": [0, 128, 128],
+ "thistle": [216, 191, 216],
+ "tomato": [255, 99, 71],
+ "turquoise": [64, 224, 208],
+ "violet": [238, 130, 238],
+ "wheat": [245, 222, 179],
+ "white": [255, 255, 255],
+ "whitesmoke": [245, 245, 245],
+ "yellow": [255, 255, 0],
+ "yellowgreen": [154, 205, 50]
+ };
+ var conversions = createCommonjsModule(function (module) {
+ var reverseKeywords = {};
+
+ for (var key in colorName) {
+ if (colorName.hasOwnProperty(key)) {
+ reverseKeywords[colorName[key]] = key;
+ }
+ }
+
+ var convert = module.exports = {
+ rgb: {
+ channels: 3,
+ labels: 'rgb'
+ },
+ hsl: {
+ channels: 3,
+ labels: 'hsl'
+ },
+ hsv: {
+ channels: 3,
+ labels: 'hsv'
+ },
+ hwb: {
+ channels: 3,
+ labels: 'hwb'
+ },
+ cmyk: {
+ channels: 4,
+ labels: 'cmyk'
+ },
+ xyz: {
+ channels: 3,
+ labels: 'xyz'
+ },
+ lab: {
+ channels: 3,
+ labels: 'lab'
+ },
+ lch: {
+ channels: 3,
+ labels: 'lch'
+ },
+ hex: {
+ channels: 1,
+ labels: ['hex']
+ },
+ keyword: {
+ channels: 1,
+ labels: ['keyword']
+ },
+ ansi16: {
+ channels: 1,
+ labels: ['ansi16']
+ },
+ ansi256: {
+ channels: 1,
+ labels: ['ansi256']
+ },
+ hcg: {
+ channels: 3,
+ labels: ['h', 'c', 'g']
+ },
+ apple: {
+ channels: 3,
+ labels: ['r16', 'g16', 'b16']
+ },
+ gray: {
+ channels: 1,
+ labels: ['gray']
+ }
+ };
+
+ for (var model in convert) {
+ if (convert.hasOwnProperty(model)) {
+ if (!('channels' in convert[model])) {
+ throw new Error('missing channels property: ' + model);
+ }
+
+ if (!('labels' in convert[model])) {
+ throw new Error('missing channel labels property: ' + model);
+ }
+
+ if (convert[model].labels.length !== convert[model].channels) {
+ throw new Error('channel and label counts mismatch: ' + model);
+ }
+
+ var channels = convert[model].channels;
+ var labels = convert[model].labels;
+ delete convert[model].channels;
+ delete convert[model].labels;
+ Object.defineProperty(convert[model], 'channels', {
+ value: channels
+ });
+ Object.defineProperty(convert[model], 'labels', {
+ value: labels
+ });
+ }
+ }
+
+ convert.rgb.hsl = function (rgb) {
+ var r = rgb[0] / 255;
+ var g = rgb[1] / 255;
+ var b = rgb[2] / 255;
+ var min = Math.min(r, g, b);
+ var max = Math.max(r, g, b);
+ var delta = max - min;
+ var h;
+ var s;
+ var l;
+
+ if (max === min) {
+ h = 0;
+ } else if (r === max) {
+ h = (g - b) / delta;
+ } else if (g === max) {
+ h = 2 + (b - r) / delta;
+ } else if (b === max) {
+ h = 4 + (r - g) / delta;
+ }
+
+ h = Math.min(h * 60, 360);
+
+ if (h < 0) {
+ h += 360;
+ }
+
+ l = (min + max) / 2;
+
+ if (max === min) {
+ s = 0;
+ } else if (l <= 0.5) {
+ s = delta / (max + min);
+ } else {
+ s = delta / (2 - max - min);
+ }
+
+ return [h, s * 100, l * 100];
+ };
+
+ convert.rgb.hsv = function (rgb) {
+ var rdif;
+ var gdif;
+ var bdif;
+ var h;
+ var s;
+ var r = rgb[0] / 255;
+ var g = rgb[1] / 255;
+ var b = rgb[2] / 255;
+ var v = Math.max(r, g, b);
+ var diff = v - Math.min(r, g, b);
+
+ var diffc = function diffc(c) {
+ return (v - c) / 6 / diff + 1 / 2;
+ };
+
+ if (diff === 0) {
+ h = s = 0;
+ } else {
+ s = diff / v;
+ rdif = diffc(r);
+ gdif = diffc(g);
+ bdif = diffc(b);
+
+ if (r === v) {
+ h = bdif - gdif;
+ } else if (g === v) {
+ h = 1 / 3 + rdif - bdif;
+ } else if (b === v) {
+ h = 2 / 3 + gdif - rdif;
+ }
+
+ if (h < 0) {
+ h += 1;
+ } else if (h > 1) {
+ h -= 1;
+ }
+ }
+
+ return [h * 360, s * 100, v * 100];
+ };
+
+ convert.rgb.hwb = function (rgb) {
+ var r = rgb[0];
+ var g = rgb[1];
+ var b = rgb[2];
+ var h = convert.rgb.hsl(rgb)[0];
+ var w = 1 / 255 * Math.min(r, Math.min(g, b));
+ b = 1 - 1 / 255 * Math.max(r, Math.max(g, b));
+ return [h, w * 100, b * 100];
+ };
+
+ convert.rgb.cmyk = function (rgb) {
+ var r = rgb[0] / 255;
+ var g = rgb[1] / 255;
+ var b = rgb[2] / 255;
+ var c;
+ var m;
+ var y;
+ var k;
+ k = Math.min(1 - r, 1 - g, 1 - b);
+ c = (1 - r - k) / (1 - k) || 0;
+ m = (1 - g - k) / (1 - k) || 0;
+ y = (1 - b - k) / (1 - k) || 0;
+ return [c * 100, m * 100, y * 100, k * 100];
+ };
+
+ function comparativeDistance(x, y) {
+ return Math.pow(x[0] - y[0], 2) + Math.pow(x[1] - y[1], 2) + Math.pow(x[2] - y[2], 2);
+ }
+
+ convert.rgb.keyword = function (rgb) {
+ var reversed = reverseKeywords[rgb];
+
+ if (reversed) {
+ return reversed;
+ }
+
+ var currentClosestDistance = Infinity;
+ var currentClosestKeyword;
+
+ for (var keyword in colorName) {
+ if (colorName.hasOwnProperty(keyword)) {
+ var value = colorName[keyword];
+ var distance = comparativeDistance(rgb, value);
+
+ if (distance < currentClosestDistance) {
+ currentClosestDistance = distance;
+ currentClosestKeyword = keyword;
+ }
+ }
+ }
+
+ return currentClosestKeyword;
+ };
+
+ convert.keyword.rgb = function (keyword) {
+ return colorName[keyword];
+ };
+
+ convert.rgb.xyz = function (rgb) {
+ var r = rgb[0] / 255;
+ var g = rgb[1] / 255;
+ var b = rgb[2] / 255;
+ r = r > 0.04045 ? Math.pow((r + 0.055) / 1.055, 2.4) : r / 12.92;
+ g = g > 0.04045 ? Math.pow((g + 0.055) / 1.055, 2.4) : g / 12.92;
+ b = b > 0.04045 ? Math.pow((b + 0.055) / 1.055, 2.4) : b / 12.92;
+ var x = r * 0.4124 + g * 0.3576 + b * 0.1805;
+ var y = r * 0.2126 + g * 0.7152 + b * 0.0722;
+ var z = r * 0.0193 + g * 0.1192 + b * 0.9505;
+ return [x * 100, y * 100, z * 100];
+ };
+
+ convert.rgb.lab = function (rgb) {
+ var xyz = convert.rgb.xyz(rgb);
+ var x = xyz[0];
+ var y = xyz[1];
+ var z = xyz[2];
+ var l;
+ var a;
+ var b;
+ x /= 95.047;
+ y /= 100;
+ z /= 108.883;
+ x = x > 0.008856 ? Math.pow(x, 1 / 3) : 7.787 * x + 16 / 116;
+ y = y > 0.008856 ? Math.pow(y, 1 / 3) : 7.787 * y + 16 / 116;
+ z = z > 0.008856 ? Math.pow(z, 1 / 3) : 7.787 * z + 16 / 116;
+ l = 116 * y - 16;
+ a = 500 * (x - y);
+ b = 200 * (y - z);
+ return [l, a, b];
+ };
+
+ convert.hsl.rgb = function (hsl) {
+ var h = hsl[0] / 360;
+ var s = hsl[1] / 100;
+ var l = hsl[2] / 100;
+ var t1;
+ var t2;
+ var t3;
+ var rgb;
+ var val;
+
+ if (s === 0) {
+ val = l * 255;
+ return [val, val, val];
+ }
+
+ if (l < 0.5) {
+ t2 = l * (1 + s);
+ } else {
+ t2 = l + s - l * s;
+ }
+
+ t1 = 2 * l - t2;
+ rgb = [0, 0, 0];
+
+ for (var i = 0; i < 3; i++) {
+ t3 = h + 1 / 3 * -(i - 1);
+
+ if (t3 < 0) {
+ t3++;
+ }
+
+ if (t3 > 1) {
+ t3--;
+ }
+
+ if (6 * t3 < 1) {
+ val = t1 + (t2 - t1) * 6 * t3;
+ } else if (2 * t3 < 1) {
+ val = t2;
+ } else if (3 * t3 < 2) {
+ val = t1 + (t2 - t1) * (2 / 3 - t3) * 6;
+ } else {
+ val = t1;
+ }
+
+ rgb[i] = val * 255;
+ }
+
+ return rgb;
+ };
+
+ convert.hsl.hsv = function (hsl) {
+ var h = hsl[0];
+ var s = hsl[1] / 100;
+ var l = hsl[2] / 100;
+ var smin = s;
+ var lmin = Math.max(l, 0.01);
+ var sv;
+ var v;
+ l *= 2;
+ s *= l <= 1 ? l : 2 - l;
+ smin *= lmin <= 1 ? lmin : 2 - lmin;
+ v = (l + s) / 2;
+ sv = l === 0 ? 2 * smin / (lmin + smin) : 2 * s / (l + s);
+ return [h, sv * 100, v * 100];
+ };
+
+ convert.hsv.rgb = function (hsv) {
+ var h = hsv[0] / 60;
+ var s = hsv[1] / 100;
+ var v = hsv[2] / 100;
+ var hi = Math.floor(h) % 6;
+ var f = h - Math.floor(h);
+ var p = 255 * v * (1 - s);
+ var q = 255 * v * (1 - s * f);
+ var t = 255 * v * (1 - s * (1 - f));
+ v *= 255;
+
+ switch (hi) {
+ case 0:
+ return [v, t, p];
+
+ case 1:
+ return [q, v, p];
+
+ case 2:
+ return [p, v, t];
+
+ case 3:
+ return [p, q, v];
+
+ case 4:
+ return [t, p, v];
+
+ case 5:
+ return [v, p, q];
+ }
+ };
+
+ convert.hsv.hsl = function (hsv) {
+ var h = hsv[0];
+ var s = hsv[1] / 100;
+ var v = hsv[2] / 100;
+ var vmin = Math.max(v, 0.01);
+ var lmin;
+ var sl;
+ var l;
+ l = (2 - s) * v;
+ lmin = (2 - s) * vmin;
+ sl = s * vmin;
+ sl /= lmin <= 1 ? lmin : 2 - lmin;
+ sl = sl || 0;
+ l /= 2;
+ return [h, sl * 100, l * 100];
+ };
+
+ convert.hwb.rgb = function (hwb) {
+ var h = hwb[0] / 360;
+ var wh = hwb[1] / 100;
+ var bl = hwb[2] / 100;
+ var ratio = wh + bl;
+ var i;
+ var v;
+ var f;
+ var n;
+
+ if (ratio > 1) {
+ wh /= ratio;
+ bl /= ratio;
+ }
+
+ i = Math.floor(6 * h);
+ v = 1 - bl;
+ f = 6 * h - i;
+
+ if ((i & 0x01) !== 0) {
+ f = 1 - f;
+ }
+
+ n = wh + f * (v - wh);
+ var r;
+ var g;
+ var b;
+
+ switch (i) {
+ default:
+ case 6:
+ case 0:
+ r = v;
+ g = n;
+ b = wh;
+ break;
+
+ case 1:
+ r = n;
+ g = v;
+ b = wh;
+ break;
+
+ case 2:
+ r = wh;
+ g = v;
+ b = n;
+ break;
+
+ case 3:
+ r = wh;
+ g = n;
+ b = v;
+ break;
+
+ case 4:
+ r = n;
+ g = wh;
+ b = v;
+ break;
+
+ case 5:
+ r = v;
+ g = wh;
+ b = n;
+ break;
+ }
+
+ return [r * 255, g * 255, b * 255];
+ };
+
+ convert.cmyk.rgb = function (cmyk) {
+ var c = cmyk[0] / 100;
+ var m = cmyk[1] / 100;
+ var y = cmyk[2] / 100;
+ var k = cmyk[3] / 100;
+ var r;
+ var g;
+ var b;
+ r = 1 - Math.min(1, c * (1 - k) + k);
+ g = 1 - Math.min(1, m * (1 - k) + k);
+ b = 1 - Math.min(1, y * (1 - k) + k);
+ return [r * 255, g * 255, b * 255];
+ };
+
+ convert.xyz.rgb = function (xyz) {
+ var x = xyz[0] / 100;
+ var y = xyz[1] / 100;
+ var z = xyz[2] / 100;
+ var r;
+ var g;
+ var b;
+ r = x * 3.2406 + y * -1.5372 + z * -0.4986;
+ g = x * -0.9689 + y * 1.8758 + z * 0.0415;
+ b = x * 0.0557 + y * -0.2040 + z * 1.0570;
+ r = r > 0.0031308 ? 1.055 * Math.pow(r, 1.0 / 2.4) - 0.055 : r * 12.92;
+ g = g > 0.0031308 ? 1.055 * Math.pow(g, 1.0 / 2.4) - 0.055 : g * 12.92;
+ b = b > 0.0031308 ? 1.055 * Math.pow(b, 1.0 / 2.4) - 0.055 : b * 12.92;
+ r = Math.min(Math.max(0, r), 1);
+ g = Math.min(Math.max(0, g), 1);
+ b = Math.min(Math.max(0, b), 1);
+ return [r * 255, g * 255, b * 255];
+ };
+
+ convert.xyz.lab = function (xyz) {
+ var x = xyz[0];
+ var y = xyz[1];
+ var z = xyz[2];
+ var l;
+ var a;
+ var b;
+ x /= 95.047;
+ y /= 100;
+ z /= 108.883;
+ x = x > 0.008856 ? Math.pow(x, 1 / 3) : 7.787 * x + 16 / 116;
+ y = y > 0.008856 ? Math.pow(y, 1 / 3) : 7.787 * y + 16 / 116;
+ z = z > 0.008856 ? Math.pow(z, 1 / 3) : 7.787 * z + 16 / 116;
+ l = 116 * y - 16;
+ a = 500 * (x - y);
+ b = 200 * (y - z);
+ return [l, a, b];
+ };
+
+ convert.lab.xyz = function (lab) {
+ var l = lab[0];
+ var a = lab[1];
+ var b = lab[2];
+ var x;
+ var y;
+ var z;
+ y = (l + 16) / 116;
+ x = a / 500 + y;
+ z = y - b / 200;
+ var y2 = Math.pow(y, 3);
+ var x2 = Math.pow(x, 3);
+ var z2 = Math.pow(z, 3);
+ y = y2 > 0.008856 ? y2 : (y - 16 / 116) / 7.787;
+ x = x2 > 0.008856 ? x2 : (x - 16 / 116) / 7.787;
+ z = z2 > 0.008856 ? z2 : (z - 16 / 116) / 7.787;
+ x *= 95.047;
+ y *= 100;
+ z *= 108.883;
+ return [x, y, z];
+ };
+
+ convert.lab.lch = function (lab) {
+ var l = lab[0];
+ var a = lab[1];
+ var b = lab[2];
+ var hr;
+ var h;
+ var c;
+ hr = Math.atan2(b, a);
+ h = hr * 360 / 2 / Math.PI;
+
+ if (h < 0) {
+ h += 360;
+ }
+
+ c = Math.sqrt(a * a + b * b);
+ return [l, c, h];
+ };
+
+ convert.lch.lab = function (lch) {
+ var l = lch[0];
+ var c = lch[1];
+ var h = lch[2];
+ var a;
+ var b;
+ var hr;
+ hr = h / 360 * 2 * Math.PI;
+ a = c * Math.cos(hr);
+ b = c * Math.sin(hr);
+ return [l, a, b];
+ };
+
+ convert.rgb.ansi16 = function (args) {
+ var r = args[0];
+ var g = args[1];
+ var b = args[2];
+ var value = 1 in arguments ? arguments[1] : convert.rgb.hsv(args)[2];
+ value = Math.round(value / 50);
+
+ if (value === 0) {
+ return 30;
+ }
+
+ var ansi = 30 + (Math.round(b / 255) << 2 | Math.round(g / 255) << 1 | Math.round(r / 255));
+
+ if (value === 2) {
+ ansi += 60;
+ }
+
+ return ansi;
+ };
+
+ convert.hsv.ansi16 = function (args) {
+ return convert.rgb.ansi16(convert.hsv.rgb(args), args[2]);
+ };
+
+ convert.rgb.ansi256 = function (args) {
+ var r = args[0];
+ var g = args[1];
+ var b = args[2];
+
+ if (r === g && g === b) {
+ if (r < 8) {
+ return 16;
+ }
+
+ if (r > 248) {
+ return 231;
+ }
+
+ return Math.round((r - 8) / 247 * 24) + 232;
+ }
+
+ var ansi = 16 + 36 * Math.round(r / 255 * 5) + 6 * Math.round(g / 255 * 5) + Math.round(b / 255 * 5);
+ return ansi;
+ };
+
+ convert.ansi16.rgb = function (args) {
+ var color = args % 10;
+
+ if (color === 0 || color === 7) {
+ if (args > 50) {
+ color += 3.5;
+ }
+
+ color = color / 10.5 * 255;
+ return [color, color, color];
+ }
+
+ var mult = (~~(args > 50) + 1) * 0.5;
+ var r = (color & 1) * mult * 255;
+ var g = (color >> 1 & 1) * mult * 255;
+ var b = (color >> 2 & 1) * mult * 255;
+ return [r, g, b];
+ };
+
+ convert.ansi256.rgb = function (args) {
+ if (args >= 232) {
+ var c = (args - 232) * 10 + 8;
+ return [c, c, c];
+ }
+
+ args -= 16;
+ var rem;
+ var r = Math.floor(args / 36) / 5 * 255;
+ var g = Math.floor((rem = args % 36) / 6) / 5 * 255;
+ var b = rem % 6 / 5 * 255;
+ return [r, g, b];
+ };
+
+ convert.rgb.hex = function (args) {
+ var integer = ((Math.round(args[0]) & 0xFF) << 16) + ((Math.round(args[1]) & 0xFF) << 8) + (Math.round(args[2]) & 0xFF);
+ var string = integer.toString(16).toUpperCase();
+ return '000000'.substring(string.length) + string;
+ };
+
+ convert.hex.rgb = function (args) {
+ var match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
+
+ if (!match) {
+ return [0, 0, 0];
+ }
+
+ var colorString = match[0];
+
+ if (match[0].length === 3) {
+ colorString = colorString.split('').map(function (char) {
+ return char + char;
+ }).join('');
+ }
+
+ var integer = parseInt(colorString, 16);
+ var r = integer >> 16 & 0xFF;
+ var g = integer >> 8 & 0xFF;
+ var b = integer & 0xFF;
+ return [r, g, b];
+ };
+
+ convert.rgb.hcg = function (rgb) {
+ var r = rgb[0] / 255;
+ var g = rgb[1] / 255;
+ var b = rgb[2] / 255;
+ var max = Math.max(Math.max(r, g), b);
+ var min = Math.min(Math.min(r, g), b);
+ var chroma = max - min;
+ var grayscale;
+ var hue;
+
+ if (chroma < 1) {
+ grayscale = min / (1 - chroma);
+ } else {
+ grayscale = 0;
+ }
+
+ if (chroma <= 0) {
+ hue = 0;
+ } else if (max === r) {
+ hue = (g - b) / chroma % 6;
+ } else if (max === g) {
+ hue = 2 + (b - r) / chroma;
+ } else {
+ hue = 4 + (r - g) / chroma + 4;
+ }
+
+ hue /= 6;
+ hue %= 1;
+ return [hue * 360, chroma * 100, grayscale * 100];
+ };
+
+ convert.hsl.hcg = function (hsl) {
+ var s = hsl[1] / 100;
+ var l = hsl[2] / 100;
+ var c = 1;
+ var f = 0;
+
+ if (l < 0.5) {
+ c = 2.0 * s * l;
+ } else {
+ c = 2.0 * s * (1.0 - l);
+ }
+
+ if (c < 1.0) {
+ f = (l - 0.5 * c) / (1.0 - c);
+ }
+
+ return [hsl[0], c * 100, f * 100];
+ };
+
+ convert.hsv.hcg = function (hsv) {
+ var s = hsv[1] / 100;
+ var v = hsv[2] / 100;
+ var c = s * v;
+ var f = 0;
+
+ if (c < 1.0) {
+ f = (v - c) / (1 - c);
+ }
+
+ return [hsv[0], c * 100, f * 100];
+ };
+
+ convert.hcg.rgb = function (hcg) {
+ var h = hcg[0] / 360;
+ var c = hcg[1] / 100;
+ var g = hcg[2] / 100;
+
+ if (c === 0.0) {
+ return [g * 255, g * 255, g * 255];
+ }
+
+ var pure = [0, 0, 0];
+ var hi = h % 1 * 6;
+ var v = hi % 1;
+ var w = 1 - v;
+ var mg = 0;
+
+ switch (Math.floor(hi)) {
+ case 0:
+ pure[0] = 1;
+ pure[1] = v;
+ pure[2] = 0;
+ break;
+
+ case 1:
+ pure[0] = w;
+ pure[1] = 1;
+ pure[2] = 0;
+ break;
+
+ case 2:
+ pure[0] = 0;
+ pure[1] = 1;
+ pure[2] = v;
+ break;
+
+ case 3:
+ pure[0] = 0;
+ pure[1] = w;
+ pure[2] = 1;
+ break;
+
+ case 4:
+ pure[0] = v;
+ pure[1] = 0;
+ pure[2] = 1;
+ break;
+
+ default:
+ pure[0] = 1;
+ pure[1] = 0;
+ pure[2] = w;
+ }
+
+ mg = (1.0 - c) * g;
+ return [(c * pure[0] + mg) * 255, (c * pure[1] + mg) * 255, (c * pure[2] + mg) * 255];
+ };
+
+ convert.hcg.hsv = function (hcg) {
+ var c = hcg[1] / 100;
+ var g = hcg[2] / 100;
+ var v = c + g * (1.0 - c);
+ var f = 0;
+
+ if (v > 0.0) {
+ f = c / v;
+ }
+
+ return [hcg[0], f * 100, v * 100];
+ };
+
+ convert.hcg.hsl = function (hcg) {
+ var c = hcg[1] / 100;
+ var g = hcg[2] / 100;
+ var l = g * (1.0 - c) + 0.5 * c;
+ var s = 0;
+
+ if (l > 0.0 && l < 0.5) {
+ s = c / (2 * l);
+ } else if (l >= 0.5 && l < 1.0) {
+ s = c / (2 * (1 - l));
+ }
+
+ return [hcg[0], s * 100, l * 100];
+ };
+
+ convert.hcg.hwb = function (hcg) {
+ var c = hcg[1] / 100;
+ var g = hcg[2] / 100;
+ var v = c + g * (1.0 - c);
+ return [hcg[0], (v - c) * 100, (1 - v) * 100];
+ };
+
+ convert.hwb.hcg = function (hwb) {
+ var w = hwb[1] / 100;
+ var b = hwb[2] / 100;
+ var v = 1 - b;
+ var c = v - w;
+ var g = 0;
+
+ if (c < 1) {
+ g = (v - c) / (1 - c);
+ }
+
+ return [hwb[0], c * 100, g * 100];
+ };
+
+ convert.apple.rgb = function (apple) {
+ return [apple[0] / 65535 * 255, apple[1] / 65535 * 255, apple[2] / 65535 * 255];
+ };
+
+ convert.rgb.apple = function (rgb) {
+ return [rgb[0] / 255 * 65535, rgb[1] / 255 * 65535, rgb[2] / 255 * 65535];
+ };
+
+ convert.gray.rgb = function (args) {
+ return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255];
+ };
+
+ convert.gray.hsl = convert.gray.hsv = function (args) {
+ return [0, 0, args[0]];
+ };
+
+ convert.gray.hwb = function (gray) {
+ return [0, 100, gray[0]];
+ };
+
+ convert.gray.cmyk = function (gray) {
+ return [0, 0, 0, gray[0]];
+ };
+
+ convert.gray.lab = function (gray) {
+ return [gray[0], 0, 0];
+ };
+
+ convert.gray.hex = function (gray) {
+ var val = Math.round(gray[0] / 100 * 255) & 0xFF;
+ var integer = (val << 16) + (val << 8) + val;
+ var string = integer.toString(16).toUpperCase();
+ return '000000'.substring(string.length) + string;
+ };
+
+ convert.rgb.gray = function (rgb) {
+ var val = (rgb[0] + rgb[1] + rgb[2]) / 3;
+ return [val / 255 * 100];
+ };
+ });
+ var conversions_1 = conversions.rgb;
+ var conversions_2 = conversions.hsl;
+ var conversions_3 = conversions.hsv;
+ var conversions_4 = conversions.hwb;
+ var conversions_5 = conversions.cmyk;
+ var conversions_6 = conversions.xyz;
+ var conversions_7 = conversions.lab;
+ var conversions_8 = conversions.lch;
+ var conversions_9 = conversions.hex;
+ var conversions_10 = conversions.keyword;
+ var conversions_11 = conversions.ansi16;
+ var conversions_12 = conversions.ansi256;
+ var conversions_13 = conversions.hcg;
+ var conversions_14 = conversions.apple;
+ var conversions_15 = conversions.gray;
+
+ function buildGraph() {
+ var graph = {};
+ var models = Object.keys(conversions);
+
+ for (var len = models.length, i = 0; i < len; i++) {
+ graph[models[i]] = {
+ distance: -1,
+ parent: null
+ };
+ }
+
+ return graph;
+ }
+
+ function deriveBFS(fromModel) {
+ var graph = buildGraph();
+ var queue = [fromModel];
+ graph[fromModel].distance = 0;
+
+ while (queue.length) {
+ var current = queue.pop();
+ var adjacents = Object.keys(conversions[current]);
+
+ for (var len = adjacents.length, i = 0; i < len; i++) {
+ var adjacent = adjacents[i];
+ var node = graph[adjacent];
+
+ if (node.distance === -1) {
+ node.distance = graph[current].distance + 1;
+ node.parent = current;
+ queue.unshift(adjacent);
+ }
+ }
+ }
+
+ return graph;
+ }
+
+ function link(from, to) {
+ return function (args) {
+ return to(from(args));
+ };
+ }
+
+ function wrapConversion(toModel, graph) {
+ var path = [graph[toModel].parent, toModel];
+ var fn = conversions[graph[toModel].parent][toModel];
+ var cur = graph[toModel].parent;
+
+ while (graph[cur].parent) {
+ path.unshift(graph[cur].parent);
+ fn = link(conversions[graph[cur].parent][cur], fn);
+ cur = graph[cur].parent;
+ }
+
+ fn.conversion = path;
+ return fn;
+ }
+
+ var route = function route(fromModel) {
+ var graph = deriveBFS(fromModel);
+ var conversion = {};
+ var models = Object.keys(graph);
+
+ for (var len = models.length, i = 0; i < len; i++) {
+ var toModel = models[i];
+ var node = graph[toModel];
+
+ if (node.parent === null) {
+ continue;
+ }
+
+ conversion[toModel] = wrapConversion(toModel, graph);
+ }
+
+ return conversion;
+ };
+
+ var _typeof = typeof Symbol === "function" && typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") === "symbol" ? function (obj) {
+ return typeof obj;
+ } : function (obj) {
+ return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof obj;
+ };
+
+ var classCallCheck = function classCallCheck(instance, Constructor) {
+ if (!(instance instanceof Constructor)) {
+ throw new TypeError("Cannot call a class as a function");
+ }
+ };
+
+ var inherits = 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 possibleConstructorReturn = 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;
+ };
+
+ var convert = {};
+ var models = Object.keys(conversions);
+
+ function wrapRaw(fn) {
+ var wrappedFn = function wrappedFn(args) {
+ if (args === undefined || args === null) {
+ return args;
+ }
+
+ if (arguments.length > 1) {
+ args = Array.prototype.slice.call(arguments);
+ }
+
+ return fn(args);
+ };
+
+ if ('conversion' in fn) {
+ wrappedFn.conversion = fn.conversion;
+ }
+
+ return wrappedFn;
+ }
+
+ function wrapRounded(fn) {
+ var wrappedFn = function wrappedFn(args) {
+ if (args === undefined || args === null) {
+ return args;
+ }
+
+ if (arguments.length > 1) {
+ args = Array.prototype.slice.call(arguments);
+ }
+
+ var result = fn(args);
+
+ if ((typeof result === 'undefined' ? 'undefined' : _typeof(result)) === 'object') {
+ for (var len = result.length, i = 0; i < len; i++) {
+ result[i] = Math.round(result[i]);
+ }
+ }
+
+ return result;
+ };
+
+ if ('conversion' in fn) {
+ wrappedFn.conversion = fn.conversion;
+ }
+
+ return wrappedFn;
+ }
+
+ models.forEach(function (fromModel) {
+ convert[fromModel] = {};
+ Object.defineProperty(convert[fromModel], 'channels', {
+ value: conversions[fromModel].channels
+ });
+ Object.defineProperty(convert[fromModel], 'labels', {
+ value: conversions[fromModel].labels
+ });
+ var routes = route(fromModel);
+ var routeModels = Object.keys(routes);
+ routeModels.forEach(function (toModel) {
+ var fn = routes[toModel];
+ convert[fromModel][toModel] = wrapRounded(fn);
+ convert[fromModel][toModel].raw = wrapRaw(fn);
+ });
+ });
+ var colorConvert = convert;
+ var ansiStyles = createCommonjsModule(function (module) {
+ var wrapAnsi16 = function wrapAnsi16(fn, offset) {
+ return function () {
+ var code = fn.apply(colorConvert, arguments);
+ return '\x1B[' + (code + offset) + 'm';
+ };
+ };
+
+ var wrapAnsi256 = function wrapAnsi256(fn, offset) {
+ return function () {
+ var code = fn.apply(colorConvert, arguments);
+ return '\x1B[' + (38 + offset) + ';5;' + code + 'm';
+ };
+ };
+
+ var wrapAnsi16m = function wrapAnsi16m(fn, offset) {
+ return function () {
+ var rgb = fn.apply(colorConvert, arguments);
+ return '\x1B[' + (38 + offset) + ';2;' + rgb[0] + ';' + rgb[1] + ';' + rgb[2] + 'm';
+ };
+ };
+
+ function assembleStyles() {
+ var codes = new Map();
+ var styles = {
+ modifier: {
+ reset: [0, 0],
+ bold: [1, 22],
+ dim: [2, 22],
+ italic: [3, 23],
+ underline: [4, 24],
+ inverse: [7, 27],
+ hidden: [8, 28],
+ strikethrough: [9, 29]
+ },
+ color: {
+ black: [30, 39],
+ red: [31, 39],
+ green: [32, 39],
+ yellow: [33, 39],
+ blue: [34, 39],
+ magenta: [35, 39],
+ cyan: [36, 39],
+ white: [37, 39],
+ gray: [90, 39],
+ redBright: [91, 39],
+ greenBright: [92, 39],
+ yellowBright: [93, 39],
+ blueBright: [94, 39],
+ magentaBright: [95, 39],
+ cyanBright: [96, 39],
+ whiteBright: [97, 39]
+ },
+ bgColor: {
+ bgBlack: [40, 49],
+ bgRed: [41, 49],
+ bgGreen: [42, 49],
+ bgYellow: [43, 49],
+ bgBlue: [44, 49],
+ bgMagenta: [45, 49],
+ bgCyan: [46, 49],
+ bgWhite: [47, 49],
+ bgBlackBright: [100, 49],
+ bgRedBright: [101, 49],
+ bgGreenBright: [102, 49],
+ bgYellowBright: [103, 49],
+ bgBlueBright: [104, 49],
+ bgMagentaBright: [105, 49],
+ bgCyanBright: [106, 49],
+ bgWhiteBright: [107, 49]
+ }
+ };
+ styles.color.grey = styles.color.gray;
+ var _iteratorNormalCompletion = true;
+ var _didIteratorError = false;
+ var _iteratorError = undefined;
+
+ try {
+ for (var _iterator = Object.keys(styles)[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+ var groupName = _step.value;
+ var group = styles[groupName];
+ var _iteratorNormalCompletion3 = true;
+ var _didIteratorError3 = false;
+ var _iteratorError3 = undefined;
+
+ try {
+ for (var _iterator3 = Object.keys(group)[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+ var styleName = _step3.value;
+ var style = group[styleName];
+ styles[styleName] = {
+ open: '\x1B[' + style[0] + 'm',
+ close: '\x1B[' + style[1] + 'm'
+ };
+ group[styleName] = styles[styleName];
+ codes.set(style[0], style[1]);
+ }
+ } catch (err) {
+ _didIteratorError3 = true;
+ _iteratorError3 = err;
+ } finally {
+ try {
+ if (!_iteratorNormalCompletion3 && _iterator3.return) {
+ _iterator3.return();
+ }
+ } finally {
+ if (_didIteratorError3) {
+ throw _iteratorError3;
+ }
+ }
+ }
+
+ Object.defineProperty(styles, groupName, {
+ value: group,
+ enumerable: false
+ });
+ Object.defineProperty(styles, 'codes', {
+ value: codes,
+ enumerable: false
+ });
+ }
+ } catch (err) {
+ _didIteratorError = true;
+ _iteratorError = err;
+ } finally {
+ try {
+ if (!_iteratorNormalCompletion && _iterator.return) {
+ _iterator.return();
+ }
+ } finally {
+ if (_didIteratorError) {
+ throw _iteratorError;
+ }
+ }
+ }
+
+ var ansi2ansi = function ansi2ansi(n) {
+ return n;
+ };
+
+ var rgb2rgb = function rgb2rgb(r, g, b) {
+ return [r, g, b];
+ };
+
+ styles.color.close = '\x1B[39m';
+ styles.bgColor.close = '\x1B[49m';
+ styles.color.ansi = {
+ ansi: wrapAnsi16(ansi2ansi, 0)
+ };
+ styles.color.ansi256 = {
+ ansi256: wrapAnsi256(ansi2ansi, 0)
+ };
+ styles.color.ansi16m = {
+ rgb: wrapAnsi16m(rgb2rgb, 0)
+ };
+ styles.bgColor.ansi = {
+ ansi: wrapAnsi16(ansi2ansi, 10)
+ };
+ styles.bgColor.ansi256 = {
+ ansi256: wrapAnsi256(ansi2ansi, 10)
+ };
+ styles.bgColor.ansi16m = {
+ rgb: wrapAnsi16m(rgb2rgb, 10)
+ };
+ var _iteratorNormalCompletion2 = true;
+ var _didIteratorError2 = false;
+ var _iteratorError2 = undefined;
+
+ try {
+ for (var _iterator2 = Object.keys(colorConvert)[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+ var key = _step2.value;
+
+ if (_typeof(colorConvert[key]) !== 'object') {
+ continue;
+ }
+
+ var suite = colorConvert[key];
+
+ if (key === 'ansi16') {
+ key = 'ansi';
+ }
+
+ if ('ansi16' in suite) {
+ styles.color.ansi[key] = wrapAnsi16(suite.ansi16, 0);
+ styles.bgColor.ansi[key] = wrapAnsi16(suite.ansi16, 10);
+ }
+
+ if ('ansi256' in suite) {
+ styles.color.ansi256[key] = wrapAnsi256(suite.ansi256, 0);
+ styles.bgColor.ansi256[key] = wrapAnsi256(suite.ansi256, 10);
+ }
+
+ if ('rgb' in suite) {
+ styles.color.ansi16m[key] = wrapAnsi16m(suite.rgb, 0);
+ styles.bgColor.ansi16m[key] = wrapAnsi16m(suite.rgb, 10);
+ }
+ }
+ } catch (err) {
+ _didIteratorError2 = true;
+ _iteratorError2 = err;
+ } finally {
+ try {
+ if (!_iteratorNormalCompletion2 && _iterator2.return) {
+ _iterator2.return();
+ }
+ } finally {
+ if (_didIteratorError2) {
+ throw _iteratorError2;
+ }
+ }
+ }
+
+ return styles;
+ }
+
+ Object.defineProperty(module, 'exports', {
+ enumerable: true,
+ get: assembleStyles
+ });
+ });
+
+ var getSymbols = Object.getOwnPropertySymbols || function (obj) {
+ return [];
+ };
+
+ var isSymbol = function isSymbol(key) {
+ return (typeof key === 'undefined' ? 'undefined' : _typeof(key)) === 'symbol' || toString.call(key) === '[object Symbol]';
+ };
+
+ function printIteratorEntries(iterator, config, indentation, depth, refs, printer) {
+ var separator = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : ': ';
+ var result = '';
+ var current = iterator.next();
+
+ if (!current.done) {
+ result += config.spacingOuter;
+ var indentationNext = indentation + config.indent;
+
+ while (!current.done) {
+ var name = printer(current.value[0], config, indentationNext, depth, refs);
+ var value = printer(current.value[1], config, indentationNext, depth, refs);
+ result += indentationNext + name + separator + value;
+ current = iterator.next();
+
+ if (!current.done) {
+ result += ',' + config.spacingInner;
+ } else if (!config.min) {
+ result += ',';
+ }
+ }
+
+ result += config.spacingOuter + indentation;
+ }
+
+ return result;
+ }
+
+ function printIteratorValues(iterator, config, indentation, depth, refs, printer) {
+ var result = '';
+ var current = iterator.next();
+
+ if (!current.done) {
+ result += config.spacingOuter;
+ var indentationNext = indentation + config.indent;
+
+ while (!current.done) {
+ result += indentationNext + printer(current.value, config, indentationNext, depth, refs);
+ current = iterator.next();
+
+ if (!current.done) {
+ result += ',' + config.spacingInner;
+ } else if (!config.min) {
+ result += ',';
+ }
+ }
+
+ result += config.spacingOuter + indentation;
+ }
+
+ return result;
+ }
+
+ function printListItems(list, config, indentation, depth, refs, printer) {
+ var result = '';
+
+ if (list.length) {
+ result += config.spacingOuter;
+ var indentationNext = indentation + config.indent;
+
+ for (var i = 0; i < list.length; i++) {
+ result += indentationNext + printer(list[i], config, indentationNext, depth, refs);
+
+ if (i < list.length - 1) {
+ result += ',' + config.spacingInner;
+ } else if (!config.min) {
+ result += ',';
+ }
+ }
+
+ result += config.spacingOuter + indentation;
+ }
+
+ return result;
+ }
+
+ function printObjectProperties(val, config, indentation, depth, refs, printer) {
+ var result = '';
+ var keys = Object.keys(val).sort();
+ var symbols = getSymbols(val);
+
+ if (symbols.length) {
+ keys = keys.filter(function (key) {
+ return !isSymbol(key);
+ }).concat(symbols);
+ }
+
+ if (keys.length) {
+ result += config.spacingOuter;
+ var indentationNext = indentation + config.indent;
+
+ for (var i = 0; i < keys.length; i++) {
+ var key = keys[i];
+ var name = printer(key, config, indentationNext, depth, refs);
+ var value = printer(val[key], config, indentationNext, depth, refs);
+ result += indentationNext + name + ': ' + value;
+
+ if (i < keys.length - 1) {
+ result += ',' + config.spacingInner;
+ } else if (!config.min) {
+ result += ',';
+ }
+ }
+
+ result += config.spacingOuter + indentation;
+ }
+
+ return result;
+ }
+
+ var asymmetricMatcher = (typeof Symbol === "function" ? Symbol.for : "@@for")('jest.asymmetricMatcher');
+ var SPACE = ' ';
+
+ var serialize = function serialize(val, config, indentation, depth, refs, printer) {
+ var stringedValue = val.toString();
+
+ if (stringedValue === 'ArrayContaining' || stringedValue === 'ArrayNotContaining') {
+ if (++depth > config.maxDepth) {
+ return '[' + stringedValue + ']';
+ }
+
+ return stringedValue + SPACE + '[' + printListItems(val.sample, config, indentation, depth, refs, printer) + ']';
+ }
+
+ if (stringedValue === 'ObjectContaining' || stringedValue === 'ObjectNotContaining') {
+ if (++depth > config.maxDepth) {
+ return '[' + stringedValue + ']';
+ }
+
+ return stringedValue + SPACE + '{' + printObjectProperties(val.sample, config, indentation, depth, refs, printer) + '}';
+ }
+
+ if (stringedValue === 'StringMatching' || stringedValue === 'StringNotMatching') {
+ return stringedValue + SPACE + printer(val.sample, config, indentation, depth, refs);
+ }
+
+ if (stringedValue === 'StringContaining' || stringedValue === 'StringNotContaining') {
+ return stringedValue + SPACE + printer(val.sample, config, indentation, depth, refs);
+ }
+
+ return val.toAsymmetricMatcher();
+ };
+
+ var test = function test(val) {
+ return val && val.$$typeof === asymmetricMatcher;
+ };
+
+ var AsymmetricMatcher = {
+ serialize: serialize,
+ test: test
+ };
+
+ var ansiRegex = function ansiRegex(options) {
+ options = _extends({
+ onlyFirst: false
+ }, options);
+ var pattern = ["[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[a-zA-Z\\d]*)*)?\\u0007)", '(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))'].join('|');
+ return new RegExp(pattern, options.onlyFirst ? undefined : 'g');
+ };
+
+ var toHumanReadableAnsi = function toHumanReadableAnsi(text) {
+ return text.replace(ansiRegex(), function (match, offset, string) {
+ switch (match) {
+ case ansiStyles.red.close:
+ case ansiStyles.green.close:
+ case ansiStyles.cyan.close:
+ case ansiStyles.gray.close:
+ case ansiStyles.white.close:
+ case ansiStyles.yellow.close:
+ case ansiStyles.bgRed.close:
+ case ansiStyles.bgGreen.close:
+ case ansiStyles.bgYellow.close:
+ case ansiStyles.inverse.close:
+ case ansiStyles.dim.close:
+ case ansiStyles.bold.close:
+ case ansiStyles.reset.open:
+ case ansiStyles.reset.close:
+ return '';
+
+ case ansiStyles.red.open:
+ return '';
+
+ case ansiStyles.green.open:
+ return '';
+
+ case ansiStyles.cyan.open:
+ return '';
+
+ case ansiStyles.gray.open:
+ return '';
+
+ case ansiStyles.white.open:
+ return '';
+
+ case ansiStyles.yellow.open:
+ return '';
+
+ case ansiStyles.bgRed.open:
+ return '';
+
+ case ansiStyles.bgGreen.open:
+ return '';
+
+ case ansiStyles.bgYellow.open:
+ return '';
+
+ case ansiStyles.inverse.open:
+ return '';
+
+ case ansiStyles.dim.open:
+ return '';
+
+ case ansiStyles.bold.open:
+ return '';
+
+ default:
+ return '';
+ }
+ });
+ };
+
+ var test$1 = function test(val) {
+ return typeof val === 'string' && val.match(ansiRegex());
+ };
+
+ var serialize$1 = function serialize(val, config, indentation, depth, refs, printer) {
+ return printer(toHumanReadableAnsi(val), config, indentation, depth, refs);
+ };
+
+ var ConvertAnsi = {
+ serialize: serialize$1,
+ test: test$1
+ };
+ var SPACE$1 = ' ';
+ var OBJECT_NAMES = ['DOMStringMap', 'NamedNodeMap'];
+ var ARRAY_REGEXP = /^(HTML\w*Collection|NodeList)$/;
+
+ var testName = function testName(name) {
+ return OBJECT_NAMES.indexOf(name) !== -1 || ARRAY_REGEXP.test(name);
+ };
+
+ var test$2 = function test(val) {
+ return val && val.constructor && val.constructor.name && testName(val.constructor.name);
+ };
+
+ var propsReducer = function propsReducer(props, attribute) {
+ props[attribute.name] = attribute.value;
+ return props;
+ };
+
+ var serialize$2 = function serialize(collection, config, indentation, depth, refs, printer) {
+ var name = collection.constructor.name;
+
+ if (++depth > config.maxDepth) {
+ return '[' + name + ']';
+ }
+
+ return (config.min ? '' : name + SPACE$1) + (OBJECT_NAMES.indexOf(name) !== -1 ? '{' + printObjectProperties(name === 'NamedNodeMap' ? Array.prototype.reduce.call(collection, propsReducer, {}) : _extends({}, collection), config, indentation, depth, refs, printer) + '}' : '[' + printListItems(Array.from(collection), config, indentation, depth, refs, printer) + ']');
+ };
+
+ var DOMCollection = {
+ serialize: serialize$2,
+ test: test$2
+ };
+
+ function escapeHTML(str) {
+ return str.replace(//g, '>');
+ }
+
+ var printProps = function printProps(keys, props, config, indentation, depth, refs, printer) {
+ var indentationNext = indentation + config.indent;
+ var colors = config.colors;
+ return keys.map(function (key) {
+ var value = props[key];
+ var printed = printer(value, config, indentationNext, depth, refs);
+
+ if (typeof value !== 'string') {
+ if (printed.indexOf('\n') !== -1) {
+ printed = config.spacingOuter + indentationNext + printed + config.spacingOuter + indentation;
+ }
+
+ printed = '{' + printed + '}';
+ }
+
+ return config.spacingInner + indentation + colors.prop.open + key + colors.prop.close + '=' + colors.value.open + printed + colors.value.close;
+ }).join('');
+ };
+
+ var printChildren = function printChildren(children, config, indentation, depth, refs, printer) {
+ return children.map(function (child) {
+ return config.spacingOuter + indentation + (typeof child === 'string' ? printText(child, config) : printer(child, config, indentation, depth, refs));
+ }).join('');
+ };
+
+ var printText = function printText(text, config) {
+ var contentColor = config.colors.content;
+ return contentColor.open + escapeHTML(text) + contentColor.close;
+ };
+
+ var printComment = function printComment(comment, config) {
+ var commentColor = config.colors.comment;
+ return commentColor.open + '' + commentColor.close;
+ };
+
+ var printElement = function printElement(type, printedProps, printedChildren, config, indentation) {
+ var tagColor = config.colors.tag;
+ return tagColor.open + '<' + type + (printedProps && tagColor.close + printedProps + config.spacingOuter + indentation + tagColor.open) + (printedChildren ? '>' + tagColor.close + printedChildren + config.spacingOuter + indentation + tagColor.open + '' + tagColor.close;
+ };
+
+ var printElementAsLeaf = function printElementAsLeaf(type, config) {
+ var tagColor = config.colors.tag;
+ return tagColor.open + '<' + type + tagColor.close + ' …' + tagColor.open + ' />' + tagColor.close;
+ };
+
+ var ELEMENT_NODE = 1;
+ var TEXT_NODE = 3;
+ var COMMENT_NODE = 8;
+ var FRAGMENT_NODE = 11;
+ var ELEMENT_REGEXP = /^((HTML|SVG)\w*)?Element$/;
+
+ var testNode = function testNode(nodeType, name) {
+ return nodeType === ELEMENT_NODE && ELEMENT_REGEXP.test(name) || nodeType === TEXT_NODE && name === 'Text' || nodeType === COMMENT_NODE && name === 'Comment' || nodeType === FRAGMENT_NODE && name === 'DocumentFragment';
+ };
+
+ var test$3 = function test(val) {
+ return val && val.constructor && val.constructor.name && testNode(val.nodeType, val.constructor.name);
+ };
+
+ var keysMapper = function keysMapper(attribute) {
+ return attribute.name;
+ };
+
+ var propsReducer$1 = function propsReducer(props, attribute) {
+ props[attribute.name] = attribute.value;
+ return props;
+ };
+
+ var serialize$3 = function serialize(node, config, indentation, depth, refs, printer) {
+ if (node.nodeType === TEXT_NODE) {
+ return printText(node.data, config);
+ }
+
+ if (node.nodeType === COMMENT_NODE) {
+ return printComment(node.data, config);
+ }
+
+ var type = node.nodeType === FRAGMENT_NODE ? 'DocumentFragment' : node.tagName.toLowerCase();
+
+ if (++depth > config.maxDepth) {
+ return printElementAsLeaf(type, config);
+ }
+
+ return printElement(type, printProps(Array.prototype.map.call(node.attributes || [], keysMapper).sort(), Array.prototype.reduce.call(node.attributes || [], propsReducer$1, {}), config, indentation + config.indent, depth, refs, printer), printChildren(Array.prototype.slice.call(node.childNodes || node.children), config, indentation + config.indent, depth, refs, printer), config, indentation);
+ };
+
+ var DOMElement = {
+ serialize: serialize$3,
+ test: test$3
+ };
+ var IS_ITERABLE_SENTINEL = '@@__IMMUTABLE_ITERABLE__@@';
+ var IS_LIST_SENTINEL = '@@__IMMUTABLE_LIST__@@';
+ var IS_KEYED_SENTINEL = '@@__IMMUTABLE_KEYED__@@';
+ var IS_MAP_SENTINEL = '@@__IMMUTABLE_MAP__@@';
+ var IS_ORDERED_SENTINEL = '@@__IMMUTABLE_ORDERED__@@';
+ var IS_RECORD_SENTINEL = '@@__IMMUTABLE_RECORD__@@';
+ var IS_SEQ_SENTINEL = '@@__IMMUTABLE_SEQ__@@';
+ var IS_SET_SENTINEL = '@@__IMMUTABLE_SET__@@';
+ var IS_STACK_SENTINEL = '@@__IMMUTABLE_STACK__@@';
+
+ var getImmutableName = function getImmutableName(name) {
+ return 'Immutable.' + name;
+ };
+
+ var printAsLeaf = function printAsLeaf(name) {
+ return '[' + name + ']';
+ };
+
+ var SPACE$2 = ' ';
+ var LAZY = '…';
+
+ var printImmutableEntries = function printImmutableEntries(val, config, indentation, depth, refs, printer, type) {
+ return ++depth > config.maxDepth ? printAsLeaf(getImmutableName(type)) : getImmutableName(type) + SPACE$2 + '{' + printIteratorEntries(val.entries(), config, indentation, depth, refs, printer) + '}';
+ };
+
+ var getRecordEntries = function getRecordEntries(val) {
+ var i = 0;
+ return {
+ next: function next() {
+ if (i < val._keys.length) {
+ var key = val._keys[i++];
+ return {
+ done: false,
+ value: [key, val.get(key)]
+ };
+ }
+
+ return {
+ done: true
+ };
+ }
+ };
+ };
+
+ var printImmutableRecord = function printImmutableRecord(val, config, indentation, depth, refs, printer) {
+ var name = getImmutableName(val._name || 'Record');
+ return ++depth > config.maxDepth ? printAsLeaf(name) : name + SPACE$2 + '{' + printIteratorEntries(getRecordEntries(val), config, indentation, depth, refs, printer) + '}';
+ };
+
+ var printImmutableSeq = function printImmutableSeq(val, config, indentation, depth, refs, printer) {
+ var name = getImmutableName('Seq');
+
+ if (++depth > config.maxDepth) {
+ return printAsLeaf(name);
+ }
+
+ if (val[IS_KEYED_SENTINEL]) {
+ return name + SPACE$2 + '{' + (val._iter || val._object ? printIteratorEntries(val.entries(), config, indentation, depth, refs, printer) : LAZY) + '}';
+ }
+
+ return name + SPACE$2 + '[' + (val._iter || val._array || val._collection || val._iterable ? printIteratorValues(val.values(), config, indentation, depth, refs, printer) : LAZY) + ']';
+ };
+
+ var printImmutableValues = function printImmutableValues(val, config, indentation, depth, refs, printer, type) {
+ return ++depth > config.maxDepth ? printAsLeaf(getImmutableName(type)) : getImmutableName(type) + SPACE$2 + '[' + printIteratorValues(val.values(), config, indentation, depth, refs, printer) + ']';
+ };
+
+ var serialize$4 = function serialize(val, config, indentation, depth, refs, printer) {
+ if (val[IS_MAP_SENTINEL]) {
+ return printImmutableEntries(val, config, indentation, depth, refs, printer, val[IS_ORDERED_SENTINEL] ? 'OrderedMap' : 'Map');
+ }
+
+ if (val[IS_LIST_SENTINEL]) {
+ return printImmutableValues(val, config, indentation, depth, refs, printer, 'List');
+ }
+
+ if (val[IS_SET_SENTINEL]) {
+ return printImmutableValues(val, config, indentation, depth, refs, printer, val[IS_ORDERED_SENTINEL] ? 'OrderedSet' : 'Set');
+ }
+
+ if (val[IS_STACK_SENTINEL]) {
+ return printImmutableValues(val, config, indentation, depth, refs, printer, 'Stack');
+ }
+
+ if (val[IS_SEQ_SENTINEL]) {
+ return printImmutableSeq(val, config, indentation, depth, refs, printer);
+ }
+
+ return printImmutableRecord(val, config, indentation, depth, refs, printer);
+ };
+
+ var test$4 = function test(val) {
+ return val && (val[IS_ITERABLE_SENTINEL] === true || val[IS_RECORD_SENTINEL] === true);
+ };
+
+ var Immutable = {
+ serialize: serialize$4,
+ test: test$4
+ };
+ var elementSymbol = (typeof Symbol === "function" ? Symbol.for : "@@for")('react.element');
+ var fragmentSymbol = (typeof Symbol === "function" ? Symbol.for : "@@for")('react.fragment');
+ var forwardRefSymbol = (typeof Symbol === "function" ? Symbol.for : "@@for")('react.forward_ref');
+ var providerSymbol = (typeof Symbol === "function" ? Symbol.for : "@@for")('react.provider');
+ var contextSymbol = (typeof Symbol === "function" ? Symbol.for : "@@for")('react.context');
+
+ var getChildren = function getChildren(arg) {
+ var children = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+
+ if (Array.isArray(arg)) {
+ arg.forEach(function (item) {
+ getChildren(item, children);
+ });
+ } else if (arg != null && arg !== false) {
+ children.push(arg);
+ }
+
+ return children;
+ };
+
+ var getType = function getType(element) {
+ var type = element.type;
+
+ if (typeof type === 'string') {
+ return type;
+ }
+
+ if (typeof type === 'function') {
+ return type.displayName || type.name || 'Unknown';
+ }
+
+ if (type === fragmentSymbol) {
+ return 'React.Fragment';
+ }
+
+ if ((typeof type === 'undefined' ? 'undefined' : _typeof(type)) === 'object' && type !== null) {
+ if (type.$$typeof === providerSymbol) {
+ return 'Context.Provider';
+ }
+
+ if (type.$$typeof === contextSymbol) {
+ return 'Context.Consumer';
+ }
+
+ if (type.$$typeof === forwardRefSymbol) {
+ var functionName = type.render.displayName || type.render.name || '';
+ return functionName !== '' ? 'ForwardRef(' + functionName + ')' : 'ForwardRef';
+ }
+ }
+
+ return 'UNDEFINED';
+ };
+
+ var getPropKeys = function getPropKeys(element) {
+ var props = element.props;
+ return Object.keys(props).filter(function (key) {
+ return key !== 'children' && props[key] !== undefined;
+ }).sort();
+ };
+
+ var serialize$5 = function serialize(element, config, indentation, depth, refs, printer) {
+ return ++depth > config.maxDepth ? printElementAsLeaf(getType(element), config) : printElement(getType(element), printProps(getPropKeys(element), element.props, config, indentation + config.indent, depth, refs, printer), printChildren(getChildren(element.props.children), config, indentation + config.indent, depth, refs, printer), config, indentation);
+ };
+
+ var test$5 = function test(val) {
+ return val && val.$$typeof === elementSymbol;
+ };
+
+ var ReactElement = {
+ serialize: serialize$5,
+ test: test$5
+ };
+ var testSymbol = (typeof Symbol === "function" ? Symbol.for : "@@for")('react.test.json');
+
+ var getPropKeys$1 = function getPropKeys(object) {
+ var props = object.props;
+ return props ? Object.keys(props).filter(function (key) {
+ return props[key] !== undefined;
+ }).sort() : [];
+ };
+
+ var serialize$6 = function serialize(object, config, indentation, depth, refs, printer) {
+ return ++depth > config.maxDepth ? printElementAsLeaf(object.type, config) : printElement(object.type, object.props ? printProps(getPropKeys$1(object), object.props, config, indentation + config.indent, depth, refs, printer) : '', object.children ? printChildren(object.children, config, indentation + config.indent, depth, refs, printer) : '', config, indentation);
+ };
+
+ var test$6 = function test(val) {
+ return val && val.$$typeof === testSymbol;
+ };
+
+ var ReactTestComponent = {
+ serialize: serialize$6,
+ test: test$6
+ };
+ var toString$1 = Object.prototype.toString;
+ var toISOString = Date.prototype.toISOString;
+ var errorToString = Error.prototype.toString;
+ var regExpToString = RegExp.prototype.toString;
+ var symbolToString = (typeof Symbol === "function" ? Symbol.prototype : "@@prototype").toString;
+
+ var getConstructorName = function getConstructorName(val) {
+ return typeof val.constructor === 'function' && val.constructor.name || 'Object';
+ };
+
+ var isWindow = function isWindow(val) {
+ return typeof window !== 'undefined' && val === window;
+ };
+
+ var SYMBOL_REGEXP = /^Symbol\((.*)\)(.*)$/;
+ var NEWLINE_REGEXP = /\n/gi;
+
+ var PrettyFormatPluginError = function (_Error) {
+ inherits(PrettyFormatPluginError, _Error);
+
+ function PrettyFormatPluginError(message, stack) {
+ classCallCheck(this, PrettyFormatPluginError);
+
+ var _this = possibleConstructorReturn(this, (PrettyFormatPluginError.__proto__ || Object.getPrototypeOf(PrettyFormatPluginError)).call(this, message));
+
+ _this.stack = stack;
+ _this.name = _this.constructor.name;
+ return _this;
+ }
+
+ return PrettyFormatPluginError;
+ }(Error);
+
+ function isToStringedArrayType(toStringed) {
+ return toStringed === '[object Array]' || toStringed === '[object ArrayBuffer]' || toStringed === '[object DataView]' || toStringed === '[object Float32Array]' || toStringed === '[object Float64Array]' || toStringed === '[object Int8Array]' || toStringed === '[object Int16Array]' || toStringed === '[object Int32Array]' || toStringed === '[object Uint8Array]' || toStringed === '[object Uint8ClampedArray]' || toStringed === '[object Uint16Array]' || toStringed === '[object Uint32Array]';
+ }
+
+ function printNumber(val) {
+ return Object.is(val, -0) ? '-0' : String(val);
+ }
+
+ function printFunction(val, printFunctionName) {
+ if (!printFunctionName) {
+ return '[Function]';
+ }
+
+ return '[Function ' + (val.name || 'anonymous') + ']';
+ }
+
+ function printSymbol(val) {
+ return symbolToString.call(val).replace(SYMBOL_REGEXP, 'Symbol($1)');
+ }
+
+ function printError(val) {
+ return '[' + errorToString.call(val) + ']';
+ }
+
+ function printBasicValue(val, printFunctionName, escapeRegex, escapeString) {
+ if (val === true || val === false) {
+ return '' + val;
+ }
+
+ if (val === undefined) {
+ return 'undefined';
+ }
+
+ if (val === null) {
+ return 'null';
+ }
+
+ var typeOf = typeof val === 'undefined' ? 'undefined' : _typeof(val);
+
+ if (typeOf === 'number') {
+ return printNumber(val);
+ }
+
+ if (typeOf === 'string') {
+ if (escapeString) {
+ return '"' + val.replace(/"|\\/g, '\\$&') + '"';
+ }
+
+ return '"' + val + '"';
+ }
+
+ if (typeOf === 'function') {
+ return printFunction(val, printFunctionName);
+ }
+
+ if (typeOf === 'symbol') {
+ return printSymbol(val);
+ }
+
+ var toStringed = toString$1.call(val);
+
+ if (toStringed === '[object WeakMap]') {
+ return 'WeakMap {}';
+ }
+
+ if (toStringed === '[object WeakSet]') {
+ return 'WeakSet {}';
+ }
+
+ if (toStringed === '[object Function]' || toStringed === '[object GeneratorFunction]') {
+ return printFunction(val, printFunctionName);
+ }
+
+ if (toStringed === '[object Symbol]') {
+ return printSymbol(val);
+ }
+
+ if (toStringed === '[object Date]') {
+ return isNaN(+val) ? 'Date { NaN }' : toISOString.call(val);
+ }
+
+ if (toStringed === '[object Error]') {
+ return printError(val);
+ }
+
+ if (toStringed === '[object RegExp]') {
+ if (escapeRegex) {
+ return regExpToString.call(val).replace(/[\\^$*+?.()|[\]{}]/g, '\\$&');
+ }
+
+ return regExpToString.call(val);
+ }
+
+ if (val instanceof Error) {
+ return printError(val);
+ }
+
+ return null;
+ }
+
+ function printComplexValue(val, config, indentation, depth, refs, hasCalledToJSON) {
+ if (refs.indexOf(val) !== -1) {
+ return '[Circular]';
+ }
+
+ refs = refs.slice();
+ refs.push(val);
+ var hitMaxDepth = ++depth > config.maxDepth;
+ var min = config.min;
+
+ if (config.callToJSON && !hitMaxDepth && val.toJSON && typeof val.toJSON === 'function' && !hasCalledToJSON) {
+ return printer(val.toJSON(), config, indentation, depth, refs, true);
+ }
+
+ var toStringed = toString$1.call(val);
+
+ if (toStringed === '[object Arguments]') {
+ return hitMaxDepth ? '[Arguments]' : (min ? '' : 'Arguments ') + '[' + printListItems(val, config, indentation, depth, refs, printer) + ']';
+ }
+
+ if (isToStringedArrayType(toStringed)) {
+ return hitMaxDepth ? '[' + val.constructor.name + ']' : (min ? '' : val.constructor.name + ' ') + '[' + printListItems(val, config, indentation, depth, refs, printer) + ']';
+ }
+
+ if (toStringed === '[object Map]') {
+ return hitMaxDepth ? '[Map]' : 'Map {' + printIteratorEntries(val.entries(), config, indentation, depth, refs, printer, ' => ') + '}';
+ }
+
+ if (toStringed === '[object Set]') {
+ return hitMaxDepth ? '[Set]' : 'Set {' + printIteratorValues(val.values(), config, indentation, depth, refs, printer) + '}';
+ }
+
+ return hitMaxDepth || isWindow(val) ? '[' + getConstructorName(val) + ']' : (min ? '' : getConstructorName(val) + ' ') + '{' + printObjectProperties(val, config, indentation, depth, refs, printer) + '}';
+ }
+
+ function printPlugin(plugin, val, config, indentation, depth, refs) {
+ var printed = void 0;
+
+ try {
+ printed = plugin.serialize ? plugin.serialize(val, config, indentation, depth, refs, printer) : plugin.print(val, function (valChild) {
+ return printer(valChild, config, indentation, depth, refs);
+ }, function (str) {
+ var indentationNext = indentation + config.indent;
+ return indentationNext + str.replace(NEWLINE_REGEXP, '\n' + indentationNext);
+ }, {
+ edgeSpacing: config.spacingOuter,
+ min: config.min,
+ spacing: config.spacingInner
+ }, config.colors);
+ } catch (error) {
+ throw new PrettyFormatPluginError(error.message, error.stack);
+ }
+
+ if (typeof printed !== 'string') {
+ throw new Error('pretty-format: Plugin must return type "string" but instead returned "' + (typeof printed === 'undefined' ? 'undefined' : _typeof(printed)) + '".');
+ }
+
+ return printed;
+ }
+
+ function findPlugin(plugins, val) {
+ for (var p = 0; p < plugins.length; p++) {
+ try {
+ if (plugins[p].test(val)) {
+ return plugins[p];
+ }
+ } catch (error) {
+ throw new PrettyFormatPluginError(error.message, error.stack);
+ }
+ }
+
+ return null;
+ }
+
+ function printer(val, config, indentation, depth, refs, hasCalledToJSON) {
+ var plugin = findPlugin(config.plugins, val);
+
+ if (plugin !== null) {
+ return printPlugin(plugin, val, config, indentation, depth, refs);
+ }
+
+ var basicResult = printBasicValue(val, config.printFunctionName, config.escapeRegex, config.escapeString);
+
+ if (basicResult !== null) {
+ return basicResult;
+ }
+
+ return printComplexValue(val, config, indentation, depth, refs, hasCalledToJSON);
+ }
+
+ var DEFAULT_THEME = {
+ comment: 'gray',
+ content: 'reset',
+ prop: 'yellow',
+ tag: 'cyan',
+ value: 'green'
+ };
+ var DEFAULT_THEME_KEYS = Object.keys(DEFAULT_THEME);
+ var DEFAULT_OPTIONS = {
+ callToJSON: true,
+ escapeRegex: false,
+ escapeString: true,
+ highlight: false,
+ indent: 2,
+ maxDepth: Infinity,
+ min: false,
+ plugins: [],
+ printFunctionName: true,
+ theme: DEFAULT_THEME
+ };
+
+ function validateOptions(options) {
+ Object.keys(options).forEach(function (key) {
+ if (!DEFAULT_OPTIONS.hasOwnProperty(key)) {
+ throw new Error('pretty-format: Unknown option "' + key + '".');
+ }
+ });
+
+ if (options.min && options.indent !== undefined && options.indent !== 0) {
+ throw new Error('pretty-format: Options "min" and "indent" cannot be used together.');
+ }
+
+ if (options.theme !== undefined) {
+ if (options.theme === null) {
+ throw new Error('pretty-format: Option "theme" must not be null.');
+ }
+
+ if (_typeof(options.theme) !== 'object') {
+ throw new Error('pretty-format: Option "theme" must be of type "object" but instead received "' + _typeof(options.theme) + '".');
+ }
+ }
+ }
+
+ var getColorsHighlight = function getColorsHighlight(options) {
+ return DEFAULT_THEME_KEYS.reduce(function (colors, key) {
+ var value = options.theme && options.theme[key] !== undefined ? options.theme[key] : DEFAULT_THEME[key];
+ var color = ansiStyles[value];
+
+ if (color && typeof color.close === 'string' && typeof color.open === 'string') {
+ colors[key] = color;
+ } else {
+ throw new Error('pretty-format: Option "theme" has a key "' + key + '" whose value "' + value + '" is undefined in ansi-styles.');
+ }
+
+ return colors;
+ }, Object.create(null));
+ };
+
+ var getColorsEmpty = function getColorsEmpty() {
+ return DEFAULT_THEME_KEYS.reduce(function (colors, key) {
+ colors[key] = {
+ close: '',
+ open: ''
+ };
+ return colors;
+ }, Object.create(null));
+ };
+
+ var getPrintFunctionName = function getPrintFunctionName(options) {
+ return options && options.printFunctionName !== undefined ? options.printFunctionName : DEFAULT_OPTIONS.printFunctionName;
+ };
+
+ var getEscapeRegex = function getEscapeRegex(options) {
+ return options && options.escapeRegex !== undefined ? options.escapeRegex : DEFAULT_OPTIONS.escapeRegex;
+ };
+
+ var getEscapeString = function getEscapeString(options) {
+ return options && options.escapeString !== undefined ? options.escapeString : DEFAULT_OPTIONS.escapeString;
+ };
+
+ var getConfig = function getConfig(options) {
+ return {
+ callToJSON: options && options.callToJSON !== undefined ? options.callToJSON : DEFAULT_OPTIONS.callToJSON,
+ colors: options && options.highlight ? getColorsHighlight(options) : getColorsEmpty(),
+ escapeRegex: getEscapeRegex(options),
+ escapeString: getEscapeString(options),
+ indent: options && options.min ? '' : createIndent(options && options.indent !== undefined ? options.indent : DEFAULT_OPTIONS.indent),
+ maxDepth: options && options.maxDepth !== undefined ? options.maxDepth : DEFAULT_OPTIONS.maxDepth,
+ min: options && options.min !== undefined ? options.min : DEFAULT_OPTIONS.min,
+ plugins: options && options.plugins !== undefined ? options.plugins : DEFAULT_OPTIONS.plugins,
+ printFunctionName: getPrintFunctionName(options),
+ spacingInner: options && options.min ? ' ' : '\n',
+ spacingOuter: options && options.min ? '' : '\n'
+ };
+ };
+
+ function createIndent(indent) {
+ return new Array(indent + 1).join(' ');
+ }
+
+ function prettyFormat(val, options) {
+ if (options) {
+ validateOptions(options);
+
+ if (options.plugins) {
+ var plugin = findPlugin(options.plugins, val);
+
+ if (plugin !== null) {
+ return printPlugin(plugin, val, getConfig(options), '', 0, []);
+ }
+ }
+ }
+
+ var basicResult = printBasicValue(val, getPrintFunctionName(options), getEscapeRegex(options), getEscapeString(options));
+
+ if (basicResult !== null) {
+ return basicResult;
+ }
+
+ return printComplexValue(val, getConfig(options), '', 0, []);
+ }
+
+ prettyFormat.plugins = {
+ AsymmetricMatcher: AsymmetricMatcher,
+ ConvertAnsi: ConvertAnsi,
+ DOMCollection: DOMCollection,
+ DOMElement: DOMElement,
+ Immutable: Immutable,
+ ReactElement: ReactElement,
+ ReactTestComponent: ReactTestComponent
+ };
+ module.exports = prettyFormat;
+ });
+},116,[14],"node_modules\\pretty-format\\build-es5\\index.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _require = _$$_REQUIRE(_dependencyMap[0], "PolyfillFunctions"),
+ polyfillGlobal = _require.polyfillGlobal;
+
+ polyfillGlobal('regeneratorRuntime', function () {
+ delete global.regeneratorRuntime;
+ return _$$_REQUIRE(_dependencyMap[1], "regenerator-runtime/runtime");
+ });
+},117,[89,103],"node_modules\\react-native\\Libraries\\Core\\setUpRegeneratorRuntime.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _require = _$$_REQUIRE(_dependencyMap[0], "PolyfillFunctions"),
+ polyfillGlobal = _require.polyfillGlobal;
+
+ var defineLazyTimer = function defineLazyTimer(name) {
+ polyfillGlobal(name, function () {
+ return _$$_REQUIRE(_dependencyMap[1], "JSTimers")[name];
+ });
+ };
+
+ defineLazyTimer('setTimeout');
+ defineLazyTimer('setInterval');
+ defineLazyTimer('setImmediate');
+ defineLazyTimer('clearTimeout');
+ defineLazyTimer('clearInterval');
+ defineLazyTimer('clearImmediate');
+ defineLazyTimer('requestAnimationFrame');
+ defineLazyTimer('cancelAnimationFrame');
+ defineLazyTimer('requestIdleCallback');
+ defineLazyTimer('cancelIdleCallback');
+},118,[89,119],"node_modules\\react-native\\Libraries\\Core\\setUpTimers.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var Platform = _$$_REQUIRE(_dependencyMap[0], "Platform");
+
+ var Systrace = _$$_REQUIRE(_dependencyMap[1], "Systrace");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[2], "invariant");
+
+ var _require = _$$_REQUIRE(_dependencyMap[3], "NativeModules"),
+ Timing = _require.Timing;
+
+ var BatchedBridge = _$$_REQUIRE(_dependencyMap[4], "BatchedBridge");
+
+ var _performanceNow = null;
+
+ function performanceNow() {
+ if (!_performanceNow) {
+ _performanceNow = _$$_REQUIRE(_dependencyMap[5], "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[6], "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[7], "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;
+ }
+
+ BatchedBridge.setImmediatesCallback(ExportedJSTimers.callImmediates.bind(ExportedJSTimers));
+ module.exports = ExportedJSTimers;
+},119,[35,48,19,36,41,120,99,21],"node_modules\\react-native\\Libraries\\Core\\Timers\\JSTimers.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ "use strict";
+
+ var performance = _$$_REQUIRE(_dependencyMap[0], "./performance");
+
+ var performanceNow;
+
+ if (performance.now) {
+ performanceNow = function performanceNow() {
+ return performance.now();
+ };
+ } else {
+ performanceNow = function performanceNow() {
+ return Date.now();
+ };
+ }
+
+ module.exports = performanceNow;
+},120,[121],"node_modules\\fbjs\\lib\\performanceNow.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var ExecutionEnvironment = _$$_REQUIRE(_dependencyMap[0], "./ExecutionEnvironment");
+
+ var performance;
+
+ if (ExecutionEnvironment.canUseDOM) {
+ performance = window.performance || window.msPerformance || window.webkitPerformance;
+ }
+
+ module.exports = performance || {};
+},121,[122],"node_modules\\fbjs\\lib\\performance.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var canUseDOM = !!(typeof window !== 'undefined' && window.document && window.document.createElement);
+ var ExecutionEnvironment = {
+ canUseDOM: canUseDOM,
+ canUseWorkers: typeof Worker !== 'undefined',
+ canUseEventListeners: canUseDOM && !!(window.addEventListener || window.attachEvent),
+ canUseViewport: canUseDOM && !!window.screen,
+ isInWorker: !canUseDOM
+ };
+ module.exports = ExecutionEnvironment;
+},122,[],"node_modules\\fbjs\\lib\\ExecutionEnvironment.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _require = _$$_REQUIRE(_dependencyMap[0], "PolyfillFunctions"),
+ polyfillGlobal = _require.polyfillGlobal;
+
+ polyfillGlobal('XMLHttpRequest', function () {
+ return _$$_REQUIRE(_dependencyMap[1], "XMLHttpRequest");
+ });
+ polyfillGlobal('FormData', function () {
+ return _$$_REQUIRE(_dependencyMap[2], "FormData");
+ });
+ polyfillGlobal('fetch', function () {
+ return _$$_REQUIRE(_dependencyMap[3], "fetch").fetch;
+ });
+ polyfillGlobal('Headers', function () {
+ return _$$_REQUIRE(_dependencyMap[3], "fetch").Headers;
+ });
+ polyfillGlobal('Request', function () {
+ return _$$_REQUIRE(_dependencyMap[3], "fetch").Request;
+ });
+ polyfillGlobal('Response', function () {
+ return _$$_REQUIRE(_dependencyMap[3], "fetch").Response;
+ });
+ polyfillGlobal('WebSocket', function () {
+ return _$$_REQUIRE(_dependencyMap[4], "WebSocket");
+ });
+ polyfillGlobal('Blob', function () {
+ return _$$_REQUIRE(_dependencyMap[5], "Blob");
+ });
+ polyfillGlobal('File', function () {
+ return _$$_REQUIRE(_dependencyMap[6], "File");
+ });
+ polyfillGlobal('FileReader', function () {
+ return _$$_REQUIRE(_dependencyMap[7], "FileReader");
+ });
+ polyfillGlobal('URL', function () {
+ return _$$_REQUIRE(_dependencyMap[8], "URL").URL;
+ });
+ polyfillGlobal('URLSearchParams', function () {
+ return _$$_REQUIRE(_dependencyMap[8], "URL").URLSearchParams;
+ });
+},123,[89,124,138,105,139,135,141,142,143],"node_modules\\react-native\\Libraries\\Core\\setUpXHR.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _toConsumableArray = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/toConsumableArray");
+
+ var _get = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/get");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/classCallCheck");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits");
+
+ var EventTarget = _$$_REQUIRE(_dependencyMap[7], "event-target-shim");
+
+ var RCTNetworking = _$$_REQUIRE(_dependencyMap[8], "RCTNetworking");
+
+ var base64 = _$$_REQUIRE(_dependencyMap[9], "base64-js");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[10], "invariant");
+
+ var warning = _$$_REQUIRE(_dependencyMap[11], "fbjs/lib/warning");
+
+ var BlobManager = _$$_REQUIRE(_dependencyMap[12], "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) {
+ _inherits(XMLHttpRequestEventTarget, _EventTarget);
+
+ function XMLHttpRequestEventTarget() {
+ _classCallCheck(this, XMLHttpRequestEventTarget);
+
+ return _possibleConstructorReturn(this, _getPrototypeOf(XMLHttpRequestEventTarget).apply(this, arguments));
+ }
+
+ return XMLHttpRequestEventTarget;
+ }(EventTarget.apply(void 0, REQUEST_EVENTS));
+
+ var XMLHttpRequest = function (_EventTarget2) {
+ _inherits(XMLHttpRequest, _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 if (this._response === '') {
+ this._cachedResponse = null;
+ } else {
+ throw new Error("Invalid response for blob: " + this._response);
+ }
+
+ break;
+
+ case 'json':
+ try {
+ this._cachedResponse = JSON.parse(this._response);
+ } catch (_) {
+ this._cachedResponse = null;
+ }
+
+ break;
+
+ default:
+ this._cachedResponse = null;
+ }
+
+ return this._cachedResponse;
+ }
+ }]);
+
+ return XMLHttpRequest;
+ }(EventTarget.apply(void 0, _toConsumableArray(XHR_EVENTS)));
+
+ XMLHttpRequest.UNSENT = UNSENT;
+ XMLHttpRequest.OPENED = OPENED;
+ XMLHttpRequest.HEADERS_RECEIVED = HEADERS_RECEIVED;
+ XMLHttpRequest.LOADING = LOADING;
+ XMLHttpRequest.DONE = DONE;
+ XMLHttpRequest._interceptor = null;
+ module.exports = XMLHttpRequest;
+},124,[43,25,4,3,5,8,9,125,129,134,19,21,136],"node_modules\\react-native\\Libraries\\Network\\XMLHttpRequest.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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
+ }
+ });
+},125,[126,127,128],"node_modules\\event-target-shim\\lib\\event-target.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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
+ };
+ };
+},126,[],"node_modules\\event-target-shim\\lib\\commons.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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;
+ };
+},127,[126],"node_modules\\event-target-shim\\lib\\custom-event-target.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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);
+ };
+},128,[126],"node_modules\\event-target-shim\\lib\\event-wrapper.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var MissingNativeEventEmitterShim = _$$_REQUIRE(_dependencyMap[6], "MissingNativeEventEmitterShim");
+
+ var NativeEventEmitter = _$$_REQUIRE(_dependencyMap[7], "NativeEventEmitter");
+
+ var RCTNetworkingNative = _$$_REQUIRE(_dependencyMap[8], "NativeModules").Networking;
+
+ var convertRequestBody = _$$_REQUIRE(_dependencyMap[9], "convertRequestBody");
+
+ var RCTNetworking = function (_NativeEventEmitter) {
+ _inherits(RCTNetworking, _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);
+ }
+ }]);
+
+ return RCTNetworking;
+ }(NativeEventEmitter);
+
+ if (__DEV__ && !RCTNetworkingNative) {
+ var MissingNativeRCTNetworkingShim = function (_MissingNativeEventEm) {
+ _inherits(MissingNativeRCTNetworkingShim, _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();
+ }
+ }]);
+
+ return MissingNativeRCTNetworkingShim;
+ }(MissingNativeEventEmitterShim);
+
+ RCTNetworking = new MissingNativeRCTNetworkingShim();
+ } else {
+ RCTNetworking = new RCTNetworking();
+ }
+
+ module.exports = RCTNetworking;
+},129,[32,3,4,5,8,9,130,131,36,132],"Libraries\\Networking\\RCTNetworking.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var EmitterSubscription = _$$_REQUIRE(_dependencyMap[5], "EmitterSubscription");
+
+ var EventEmitter = _$$_REQUIRE(_dependencyMap[6], "EventEmitter");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[7], "invariant");
+
+ var MissingNativeEventEmitterShim = function (_EventEmitter) {
+ _inherits(MissingNativeEventEmitterShim, _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();
+ }
+ }]);
+
+ return MissingNativeEventEmitterShim;
+ }(EventEmitter);
+
+ module.exports = MissingNativeEventEmitterShim;
+},130,[3,4,5,8,9,28,27,19],"node_modules\\react-native\\Libraries\\EventEmitter\\MissingNativeEventEmitterShim.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _get = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/get");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var EventEmitter = _$$_REQUIRE(_dependencyMap[6], "EventEmitter");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[7], "Platform");
+
+ var RCTDeviceEventEmitter = _$$_REQUIRE(_dependencyMap[8], "RCTDeviceEventEmitter");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[9], "invariant");
+
+ var NativeEventEmitter = function (_EventEmitter) {
+ _inherits(NativeEventEmitter, _EventEmitter);
+
+ function NativeEventEmitter(nativeModule) {
+ var _this;
+
+ _classCallCheck(this, NativeEventEmitter);
+
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(NativeEventEmitter).call(this, RCTDeviceEventEmitter.sharedSubscriber));
+
+ if (Platform.OS === 'ios' || Platform.OS === 'macos') {
+ invariant(nativeModule, 'Native module cannot be null.');
+ _this._nativeModule = nativeModule;
+ }
+
+ return _this;
+ }
+
+ _createClass(NativeEventEmitter, [{
+ key: "addListener",
+ value: function addListener(eventType, listener, context) {
+ if (this._nativeModule != null) {
+ this._nativeModule.addListener(eventType);
+ }
+
+ return _get(_getPrototypeOf(NativeEventEmitter.prototype), "addListener", this).call(this, eventType, listener, context);
+ }
+ }, {
+ key: "removeAllListeners",
+ value: function removeAllListeners(eventType) {
+ invariant(eventType, 'eventType argument is required.');
+ var count = this.listeners(eventType).length;
+
+ if (this._nativeModule != null) {
+ this._nativeModule.removeListeners(count);
+ }
+
+ _get(_getPrototypeOf(NativeEventEmitter.prototype), "removeAllListeners", this).call(this, eventType);
+ }
+ }, {
+ key: "removeSubscription",
+ value: function removeSubscription(subscription) {
+ if (this._nativeModule != null) {
+ this._nativeModule.removeListeners(1);
+ }
+
+ _get(_getPrototypeOf(NativeEventEmitter.prototype), "removeSubscription", this).call(this, subscription);
+ }
+ }]);
+
+ return NativeEventEmitter;
+ }(EventEmitter);
+
+ module.exports = NativeEventEmitter;
+},131,[3,4,5,8,25,9,27,35,24,19],"node_modules\\react-native\\Libraries\\EventEmitter\\NativeEventEmitter.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var binaryToBase64 = _$$_REQUIRE(_dependencyMap[0], "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;
+},132,[133,135,138],"node_modules\\react-native\\Libraries\\Network\\convertRequestBody.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var base64 = _$$_REQUIRE(_dependencyMap[0], "base64-js");
+
+ function binaryToBase64(data) {
+ if (data instanceof ArrayBuffer) {
+ data = new Uint8Array(data);
+ }
+
+ if (data instanceof Uint8Array) {
+ return base64.fromByteArray(data);
+ }
+
+ if (!ArrayBuffer.isView(data)) {
+ throw new Error('data must be ArrayBuffer or typed array');
+ }
+
+ var _data = data,
+ buffer = _data.buffer,
+ byteOffset = _data.byteOffset,
+ byteLength = _data.byteLength;
+ return base64.fromByteArray(new Uint8Array(buffer, byteOffset, byteLength));
+ }
+
+ module.exports = binaryToBase64;
+},133,[134],"node_modules\\react-native\\Libraries\\Utilities\\binaryToBase64.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ exports.byteLength = byteLength;
+ exports.toByteArray = toByteArray;
+ exports.fromByteArray = fromByteArray;
+ var lookup = [];
+ var revLookup = [];
+ var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array;
+ var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+
+ for (var i = 0, len = code.length; i < len; ++i) {
+ lookup[i] = code[i];
+ revLookup[code.charCodeAt(i)] = i;
+ }
+
+ revLookup['-'.charCodeAt(0)] = 62;
+ revLookup['_'.charCodeAt(0)] = 63;
+
+ function getLens(b64) {
+ var len = b64.length;
+
+ if (len % 4 > 0) {
+ throw new Error('Invalid string. Length must be a multiple of 4');
+ }
+
+ var validLen = b64.indexOf('=');
+ if (validLen === -1) validLen = len;
+ var placeHoldersLen = validLen === len ? 0 : 4 - validLen % 4;
+ return [validLen, placeHoldersLen];
+ }
+
+ function byteLength(b64) {
+ var lens = getLens(b64);
+ var validLen = lens[0];
+ var placeHoldersLen = lens[1];
+ return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+ }
+
+ function _byteLength(b64, validLen, placeHoldersLen) {
+ return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+ }
+
+ function toByteArray(b64) {
+ var tmp;
+ var lens = getLens(b64);
+ var validLen = lens[0];
+ var placeHoldersLen = lens[1];
+ var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));
+ var curByte = 0;
+ var len = placeHoldersLen > 0 ? validLen - 4 : validLen;
+
+ 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('');
+ }
+},134,[],"node_modules\\base64-js\\index.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var Blob = function () {
+ function Blob() {
+ var parts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+ var options = arguments.length > 1 ? arguments[1] : undefined;
+
+ _classCallCheck(this, Blob);
+
+ var BlobManager = _$$_REQUIRE(_dependencyMap[2], "BlobManager");
+
+ this.data = BlobManager.createFromParts(parts, options).data;
+ }
+
+ _createClass(Blob, [{
+ key: "slice",
+ value: function slice(start, end) {
+ var BlobManager = _$$_REQUIRE(_dependencyMap[2], "BlobManager");
+
+ var _this$data = this.data,
+ offset = _this$data.offset,
+ size = _this$data.size;
+
+ if (typeof start === 'number') {
+ if (start > size) {
+ start = size;
+ }
+
+ offset += start;
+ size -= start;
+
+ if (typeof end === 'number') {
+ if (end < 0) {
+ end = this.size + end;
+ }
+
+ size = end - start;
+ }
+ }
+
+ return BlobManager.createFromOptions({
+ blobId: this.data.blobId,
+ offset: offset,
+ size: size
+ });
+ }
+ }, {
+ key: "close",
+ value: function close() {
+ var BlobManager = _$$_REQUIRE(_dependencyMap[2], "BlobManager");
+
+ BlobManager.release(this.data.blobId);
+ this.data = null;
+ }
+ }, {
+ key: "data",
+ set: function set(data) {
+ this._data = data;
+ },
+ get: function get() {
+ if (!this._data) {
+ throw new Error('Blob has been closed and is no longer available');
+ }
+
+ return this._data;
+ }
+ }, {
+ key: "size",
+ get: function get() {
+ return this.data.size;
+ }
+ }, {
+ key: "type",
+ get: function get() {
+ return this.data.type || '';
+ }
+ }]);
+
+ return Blob;
+ }();
+
+ module.exports = Blob;
+},135,[3,4,136],"node_modules\\react-native\\Libraries\\Blob\\Blob.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ var Blob = _$$_REQUIRE(_dependencyMap[3], "Blob");
+
+ var BlobRegistry = _$$_REQUIRE(_dependencyMap[4], "BlobRegistry");
+
+ var _require = _$$_REQUIRE(_dependencyMap[5], "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;
+},136,[14,3,4,135,137,36],"node_modules\\react-native\\Libraries\\Blob\\BlobManager.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var registry = {};
+
+ var register = function register(id) {
+ if (registry[id]) {
+ registry[id]++;
+ } else {
+ registry[id] = 1;
+ }
+ };
+
+ var unregister = function unregister(id) {
+ if (registry[id]) {
+ registry[id]--;
+
+ if (registry[id] <= 0) {
+ delete registry[id];
+ }
+ }
+ };
+
+ var has = function has(id) {
+ return registry[id] && registry[id] > 0;
+ };
+
+ module.exports = {
+ register: register,
+ unregister: unregister,
+ has: has
+ };
+},137,[],"node_modules\\react-native\\Libraries\\Blob\\BlobRegistry.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ var _slicedToArray = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var FormData = function () {
+ function FormData() {
+ _classCallCheck(this, FormData);
+
+ this._parts = [];
+ }
+
+ _createClass(FormData, [{
+ key: "append",
+ value: function append(key, value) {
+ this._parts.push([key, value]);
+ }
+ }, {
+ key: "getParts",
+ value: function getParts() {
+ return this._parts.map(function (_ref) {
+ var _ref2 = _slicedToArray(_ref, 2),
+ name = _ref2[0],
+ value = _ref2[1];
+
+ var contentDisposition = 'form-data; name="' + name + '"';
+ var headers = {
+ 'content-disposition': contentDisposition
+ };
+
+ if (typeof value === 'object' && value) {
+ if (typeof value.name === 'string') {
+ headers['content-disposition'] += '; filename="' + value.name + '"';
+ }
+
+ if (typeof value.type === 'string') {
+ headers['content-type'] = value.type;
+ }
+
+ return _objectSpread({}, value, {
+ headers: headers,
+ fieldName: name
+ });
+ }
+
+ return {
+ string: String(value),
+ headers: headers,
+ fieldName: name
+ };
+ });
+ }
+ }]);
+
+ return FormData;
+ }();
+
+ module.exports = FormData;
+},138,[32,37,3,4],"node_modules\\react-native\\Libraries\\Network\\FormData.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _objectWithoutProperties = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/objectWithoutProperties");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var Blob = _$$_REQUIRE(_dependencyMap[6], "Blob");
+
+ var EventTarget = _$$_REQUIRE(_dependencyMap[7], "event-target-shim");
+
+ var NativeEventEmitter = _$$_REQUIRE(_dependencyMap[8], "NativeEventEmitter");
+
+ var BlobManager = _$$_REQUIRE(_dependencyMap[9], "BlobManager");
+
+ var NativeModules = _$$_REQUIRE(_dependencyMap[10], "NativeModules");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[11], "Platform");
+
+ var WebSocketEvent = _$$_REQUIRE(_dependencyMap[12], "WebSocketEvent");
+
+ var base64 = _$$_REQUIRE(_dependencyMap[13], "base64-js");
+
+ var binaryToBase64 = _$$_REQUIRE(_dependencyMap[14], "binaryToBase64");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[15], "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) {
+ _inherits(WebSocket, _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' || Platform.OS === 'win32' || Platform.OS === 'windesktop') {
+ 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;
+ }
+ }]);
+
+ 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;
+},139,[33,3,4,5,8,9,135,125,131,136,36,35,140,134,133,19],"node_modules\\react-native\\Libraries\\WebSocket\\WebSocket.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var WebSocketEvent = function WebSocketEvent(type, eventInitDict) {
+ _classCallCheck(this, WebSocketEvent);
+
+ this.type = type.toString();
+
+ _extends(this, eventInitDict);
+ };
+
+ module.exports = WebSocketEvent;
+},140,[14,3],"node_modules\\react-native\\Libraries\\WebSocket\\WebSocketEvent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var Blob = _$$_REQUIRE(_dependencyMap[5], "Blob");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[6], "invariant");
+
+ var File = function (_Blob) {
+ _inherits(File, _Blob);
+
+ function File(parts, name, options) {
+ var _this;
+
+ _classCallCheck(this, File);
+
+ invariant(parts != null && name != null, 'Failed to construct `File`: Must pass both `parts` and `name` arguments.');
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(File).call(this, parts, options));
+ _this.data.name = name;
+ return _this;
+ }
+
+ _createClass(File, [{
+ key: "name",
+ get: function get() {
+ invariant(this.data.name != null, 'Files must have a name set.');
+ return this.data.name;
+ }
+ }, {
+ key: "lastModified",
+ get: function get() {
+ return this.data.lastModified || 0;
+ }
+ }]);
+
+ return File;
+ }(Blob);
+
+ module.exports = File;
+},141,[3,4,5,8,9,135,19],"node_modules\\react-native\\Libraries\\Blob\\File.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var EventTarget = _$$_REQUIRE(_dependencyMap[5], "event-target-shim");
+
+ var Blob = _$$_REQUIRE(_dependencyMap[6], "Blob");
+
+ var _require = _$$_REQUIRE(_dependencyMap[7], "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) {
+ _inherits(FileReader, _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;
+ }
+ }]);
+
+ return FileReader;
+ }(EventTarget.apply(void 0, READER_EVENTS));
+
+ FileReader.EMPTY = EMPTY;
+ FileReader.LOADING = LOADING;
+ FileReader.DONE = DONE;
+ module.exports = FileReader;
+},142,[3,4,5,8,9,125,135,36],"node_modules\\react-native\\Libraries\\Blob\\FileReader.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+
+ Object.defineProperty(exports, "__esModule", {
+ value: true
+ });
+ exports.URL = exports.URLSearchParams = void 0;
+
+ var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+
+ var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+
+ var _Symbol$iterator;
+
+ var Blob = _$$_REQUIRE(_dependencyMap[3], "Blob");
+
+ var _require = _$$_REQUIRE(_dependencyMap[4], "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 + "/";
+ }
+ }
+
+ _Symbol$iterator = Symbol.iterator;
+
+ var URLSearchParams = function () {
+ function URLSearchParams(params) {
+ var _this = this;
+
+ (0, _classCallCheck2.default)(this, URLSearchParams);
+ this._searchParams = [];
+
+ if (typeof params === 'object') {
+ Object.keys(params).forEach(function (key) {
+ return _this.append(key, params[key]);
+ });
+ }
+ }
+
+ (0, _createClass2.default)(URLSearchParams, [{
+ key: "append",
+ value: function append(key, value) {
+ this._searchParams.push([key, value]);
+ }
+ }, {
+ key: "delete",
+ value: function _delete(name) {
+ throw new Error('not implemented');
+ }
+ }, {
+ key: "get",
+ value: function get(name) {
+ throw new Error('not implemented');
+ }
+ }, {
+ key: "getAll",
+ value: function getAll(name) {
+ throw new Error('not implemented');
+ }
+ }, {
+ key: "has",
+ value: function has(name) {
+ throw new Error('not implemented');
+ }
+ }, {
+ key: "set",
+ value: function set(name, value) {
+ throw new Error('not implemented');
+ }
+ }, {
+ key: "sort",
+ value: function sort() {
+ throw new Error('not implemented');
+ }
+ }, {
+ key: _Symbol$iterator,
+ value: function value() {
+ return this._searchParams[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();
+ }
+ }, {
+ key: "toString",
+ value: function toString() {
+ if (this._searchParams.length === 0) {
+ return '';
+ }
+
+ var last = this._searchParams.length - 1;
+ return this._searchParams.reduce(function (acc, curr, index) {
+ return acc + curr.join('=') + (index === last ? '' : '&');
+ }, '');
+ }
+ }]);
+ return URLSearchParams;
+ }();
+
+ exports.URLSearchParams = URLSearchParams;
+
+ function validateBaseUrl(url) {
+ return /^(?:(?:(?:https?|ftp):)?\/\/)(?:(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z\u00a1-\uffff0-9]-*)*[a-z\u00a1-\uffff0-9]+)(?:\.(?:[a-z\u00a1-\uffff0-9]-*)*[a-z\u00a1-\uffff0-9]+)*(?:\.(?:[a-z\u00a1-\uffff]{2,})))(?::\d{2,5})?(?:[/?#]\S*)?$/i.test(url);
+ }
+
+ var URL = function () {
+ (0, _createClass2.default)(URL, null, [{
+ key: "createObjectURL",
+ value: function createObjectURL(blob) {
+ if (BLOB_URL_PREFIX === null) {
+ throw new Error('Cannot create URL for blob!');
+ }
+
+ return "" + BLOB_URL_PREFIX + blob.data.blobId + "?offset=" + blob.data.offset + "&size=" + blob.size;
+ }
+ }, {
+ key: "revokeObjectURL",
+ value: function revokeObjectURL(url) {}
+ }]);
+
+ function URL(url, base) {
+ (0, _classCallCheck2.default)(this, URL);
+ this._searchParamsInstance = null;
+ var baseUrl = null;
+
+ if (base) {
+ if (typeof base === 'string') {
+ baseUrl = base;
+
+ if (!validateBaseUrl(baseUrl)) {
+ throw new TypeError("Invalid base URL: " + baseUrl);
+ }
+ } else if (typeof base === 'object') {
+ baseUrl = base.toString();
+ }
+
+ if (baseUrl.endsWith('/') && url.startsWith('/')) {
+ baseUrl = baseUrl.slice(0, baseUrl.length - 1);
+ }
+
+ if (baseUrl.endsWith(url)) {
+ url = '';
+ }
+
+ this._url = "" + baseUrl + url;
+ } else {
+ this._url = url;
+
+ if (!this._url.endsWith('/')) {
+ this._url += '/';
+ }
+ }
+ }
+
+ (0, _createClass2.default)(URL, [{
+ key: "toJSON",
+ value: function toJSON() {
+ return this.toString();
+ }
+ }, {
+ key: "toString",
+ value: function toString() {
+ if (this._searchParamsInstance === null) {
+ return this._url;
+ }
+
+ var separator = this._url.indexOf('?') > -1 ? '&' : '?';
+ return this._url + separator + this._searchParamsInstance.toString();
+ }
+ }, {
+ key: "hash",
+ get: function get() {
+ throw new Error('not implemented');
+ }
+ }, {
+ key: "host",
+ get: function get() {
+ throw new Error('not implemented');
+ }
+ }, {
+ key: "hostname",
+ get: function get() {
+ throw new Error('not implemented');
+ }
+ }, {
+ key: "href",
+ get: function get() {
+ return this.toString();
+ }
+ }, {
+ key: "origin",
+ get: function get() {
+ throw new Error('not implemented');
+ }
+ }, {
+ key: "password",
+ get: function get() {
+ throw new Error('not implemented');
+ }
+ }, {
+ key: "pathname",
+ get: function get() {
+ throw new Error('not implemented');
+ }
+ }, {
+ key: "port",
+ get: function get() {
+ throw new Error('not implemented');
+ }
+ }, {
+ key: "protocol",
+ get: function get() {
+ throw new Error('not implemented');
+ }
+ }, {
+ key: "search",
+ get: function get() {
+ throw new Error('not implemented');
+ }
+ }, {
+ key: "searchParams",
+ get: function get() {
+ if (this._searchParamsInstance == null) {
+ this._searchParamsInstance = new URLSearchParams();
+ }
+
+ return this._searchParamsInstance;
+ }
+ }, {
+ key: "username",
+ get: function get() {
+ throw new Error('not implemented');
+ }
+ }]);
+ return URL;
+ }();
+
+ exports.URL = URL;
+},143,[1,3,4,135,36],"node_modules\\react-native\\Libraries\\Blob\\URL.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ if (!global.alert) {
+ global.alert = function (text) {
+ _$$_REQUIRE(_dependencyMap[0], "Alert").alert('Alert', '' + text);
+ };
+ }
+},144,[145],"node_modules\\react-native\\Libraries\\Core\\setUpAlert.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var AlertMacOS = _$$_REQUIRE(_dependencyMap[3], "AlertMacOS");
+
+ var NativeModules = _$$_REQUIRE(_dependencyMap[4], "NativeModules");
+
+ var RCTAlertManager = NativeModules.AlertManager;
+
+ var Platform = _$$_REQUIRE(_dependencyMap[5], "Platform");
+
+ var Alert = function () {
+ function Alert() {
+ _classCallCheck(this, Alert);
+ }
+
+ _createClass(Alert, null, [{
+ key: "alert",
+ value: function alert(title, message, buttons, options) {
+ if (Platform.OS === 'ios') {
+ AlertIOS.alert(title, message, buttons);
+ } else if (Platform.OS === 'macos') {
+ AlertMacOS.alert(title, message, buttons);
+ } else if (Platform.OS === 'android') {
+ AlertAndroid.alert(title, message, buttons, options);
+ }
+ }
+ }, {
+ key: "prompt",
+ value: function prompt(title, message, callbackOrButtons) {
+ var type = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'plain-text';
+ var defaultValue = arguments.length > 4 ? arguments[4] : undefined;
+ var keyboardType = arguments.length > 5 ? arguments[5] : undefined;
+
+ if (Platform.OS === 'ios') {
+ AlertIOS.prompt(title, message, callbackOrButtons, type, defaultValue, keyboardType);
+ }
+ }
+ }]);
+
+ return Alert;
+ }();
+
+ var AlertIOS = function () {
+ function AlertIOS() {
+ _classCallCheck(this, AlertIOS);
+ }
+
+ _createClass(AlertIOS, null, [{
+ key: "alert",
+ value: function alert(title, message, callbackOrButtons) {
+ 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 Alert.prompt(). React Native is ' + 'assuming you want to use the deprecated Alert.prompt(title, defaultValue, buttons, callback) ' + 'signature. The current signature is Alert.prompt(title, message, callbackOrButtons, type, defaultValue, ' + 'keyboardType) and the old syntax will be removed in a future version.');
+ var callback = type;
+ RCTAlertManager.alertWithArgs({
+ title: title || '',
+ type: 'plain-text',
+ defaultValue: message
+ }, function (id, value) {
+ callback(value);
+ });
+ return;
+ }
+
+ var callbacks = [];
+ var buttons = [];
+ var cancelButtonKey;
+ var destructiveButtonKey;
+
+ if (typeof callbackOrButtons === 'function') {
+ callbacks = [callbackOrButtons];
+ } else if (Array.isArray(callbackOrButtons)) {
+ callbackOrButtons.forEach(function (btn, index) {
+ callbacks[index] = btn.onPress;
+
+ if (btn.style === 'cancel') {
+ cancelButtonKey = String(index);
+ } else if (btn.style === 'destructive') {
+ destructiveButtonKey = String(index);
+ }
+
+ if (btn.text || index < (callbackOrButtons || []).length - 1) {
+ var btnDef = {};
+ btnDef[index] = btn.text || '';
+ buttons.push(btnDef);
+ }
+ });
+ }
+
+ RCTAlertManager.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;
+ }();
+
+ 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;
+},145,[32,3,4,146,36,35],"node_modules\\react-native\\Libraries\\Alert\\Alert.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var RCTAlertManager = _$$_REQUIRE(_dependencyMap[2], "NativeModules").AlertManager;
+
+ var AlertMacOS = function () {
+ function AlertMacOS() {
+ _classCallCheck(this, AlertMacOS);
+ }
+
+ _createClass(AlertMacOS, null, [{
+ key: "alert",
+ value: function alert(title, message, callbackOrButtons) {
+ 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 defaultInputs = arguments.length > 4 ? arguments[4] : undefined;
+ var modal = arguments.length > 5 ? arguments[5] : undefined;
+ var critical = arguments.length > 6 ? arguments[6] : undefined;
+ var callbacks = [];
+ var buttons = [];
+
+ if (typeof callbackOrButtons === 'function') {
+ callbacks = [callbackOrButtons];
+ } else if (callbackOrButtons instanceof Array) {
+ callbackOrButtons.forEach(function (btn, index) {
+ callbacks[index] = btn.onPress;
+
+ if (btn.text || index < (callbackOrButtons || []).length - 1) {
+ var btnDef = {};
+ btnDef[index] = btn.text || '';
+ buttons.push(btnDef);
+ }
+ });
+ }
+
+ RCTAlertManager.alertWithArgs({
+ title: title || undefined,
+ message: message || undefined,
+ buttons: buttons,
+ type: type || undefined,
+ defaultInputs: defaultInputs,
+ modal: modal || undefined,
+ critical: critical || undefined
+ }, function (id, value) {
+ var cb = callbacks[id];
+ cb && cb(value);
+ });
+ }
+ }]);
+
+ return AlertMacOS;
+ }();
+
+ module.exports = AlertMacOS;
+},146,[3,4,36],"node_modules\\react-native\\Libraries\\Alert\\AlertMacOS.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _require = _$$_REQUIRE(_dependencyMap[0], "PolyfillFunctions"),
+ polyfillObjectProperty = _require.polyfillObjectProperty;
+
+ var navigator = global.navigator;
+
+ if (navigator === undefined) {
+ global.navigator = navigator = {};
+ }
+
+ polyfillObjectProperty(navigator, 'product', function () {
+ return 'ReactNative';
+ });
+ polyfillObjectProperty(navigator, 'geolocation', function () {
+ return _$$_REQUIRE(_dependencyMap[1], "Geolocation");
+ });
+},147,[89,148],"node_modules\\react-native\\Libraries\\Core\\setUpGeolocation.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _regeneratorRuntime = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/regenerator");
+
+ var NativeEventEmitter = _$$_REQUIRE(_dependencyMap[1], "NativeEventEmitter");
+
+ var RCTLocationObserver = _$$_REQUIRE(_dependencyMap[2], "NativeModules").LocationObserver;
+
+ var invariant = _$$_REQUIRE(_dependencyMap[3], "invariant");
+
+ var logError = _$$_REQUIRE(_dependencyMap[4], "logError");
+
+ var warning = _$$_REQUIRE(_dependencyMap[5], "fbjs/lib/warning");
+
+ var LocationEventEmitter = new NativeEventEmitter(RCTLocationObserver);
+
+ var Platform = _$$_REQUIRE(_dependencyMap[6], "Platform");
+
+ var PermissionsAndroid = _$$_REQUIRE(_dependencyMap[7], "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();
+ }
+ }
+ });
+ },
+ 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;
+},148,[102,131,36,19,149,21,35,150],"node_modules\\react-native\\Libraries\\Geolocation\\Geolocation.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var logError = function logError() {
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ if (args.length === 1 && args[0] instanceof Error) {
+ var err = args[0];
+ console.error('Error: "' + err.message + '". Stack:\n' + err.stack);
+ } else {
+ console.error.apply(console, args);
+ }
+ };
+
+ module.exports = logError;
+},149,[],"node_modules\\react-native\\Libraries\\Utilities\\logError.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _regeneratorRuntime = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/regenerator");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ var NativeModules = _$$_REQUIRE(_dependencyMap[3], "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();
+ }
+ }
+ });
+ }
+ }, {
+ key: "requestMultiple",
+ value: function requestMultiple(permissions) {
+ return NativeModules.PermissionsAndroid.requestMultiplePermissions(permissions);
+ }
+ }]);
+
+ return PermissionsAndroid;
+ }();
+
+ PermissionsAndroid = new PermissionsAndroid();
+ module.exports = PermissionsAndroid;
+},150,[102,3,4,36],"node_modules\\react-native\\Libraries\\PermissionsAndroid\\PermissionsAndroid.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var BatchedBridge = _$$_REQUIRE(_dependencyMap[0], "BatchedBridge");
+
+ BatchedBridge.registerLazyCallableModule('Systrace', function () {
+ return _$$_REQUIRE(_dependencyMap[1], "Systrace");
+ });
+ BatchedBridge.registerLazyCallableModule('JSTimers', function () {
+ return _$$_REQUIRE(_dependencyMap[2], "JSTimers");
+ });
+ BatchedBridge.registerLazyCallableModule('HeapCapture', function () {
+ return _$$_REQUIRE(_dependencyMap[3], "HeapCapture");
+ });
+ BatchedBridge.registerLazyCallableModule('SamplingProfiler', function () {
+ return _$$_REQUIRE(_dependencyMap[4], "SamplingProfiler");
+ });
+ BatchedBridge.registerLazyCallableModule('RCTLog', function () {
+ return _$$_REQUIRE(_dependencyMap[5], "RCTLog");
+ });
+ BatchedBridge.registerLazyCallableModule('RCTDeviceEventEmitter', function () {
+ return _$$_REQUIRE(_dependencyMap[6], "RCTDeviceEventEmitter");
+ });
+ BatchedBridge.registerLazyCallableModule('RCTNativeAppEventEmitter', function () {
+ return _$$_REQUIRE(_dependencyMap[7], "RCTNativeAppEventEmitter");
+ });
+ BatchedBridge.registerLazyCallableModule('PerformanceLogger', function () {
+ return _$$_REQUIRE(_dependencyMap[8], "PerformanceLogger");
+ });
+ BatchedBridge.registerLazyCallableModule('JSDevSupportModule', function () {
+ return _$$_REQUIRE(_dependencyMap[9], "JSDevSupportModule");
+ });
+
+ if (__DEV__ && !global.__RCTProfileIsProfiling) {
+ BatchedBridge.registerCallableModule('HMRClient', _$$_REQUIRE(_dependencyMap[10], "HMRClient"));
+ }
+},151,[41,48,119,152,153,154,24,155,156,158,159],"node_modules\\react-native\\Libraries\\Core\\setUpBatchedBridge.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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;
+},152,[36],"node_modules\\react-native\\Libraries\\Utilities\\HeapCapture.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var SamplingProfiler = {
+ poke: function poke(token) {
+ var error = null;
+ var result = null;
+
+ try {
+ result = global.pokeSamplingProfiler();
+
+ if (result === null) {
+ console.log('The JSC Sampling Profiler has started');
+ } else {
+ console.log('The JSC Sampling Profiler has stopped');
+ }
+ } catch (e) {
+ console.log('Error occurred when restarting Sampling Profiler: ' + e.toString());
+ error = e.toString();
+ }
+
+ var _require = _$$_REQUIRE(_dependencyMap[0], "NativeModules"),
+ JSCSamplingProfiler = _require.JSCSamplingProfiler;
+
+ JSCSamplingProfiler.operationComplete(token, result, error);
+ }
+ };
+ module.exports = SamplingProfiler;
+},153,[36],"node_modules\\react-native\\Libraries\\Performance\\SamplingProfiler.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var invariant = _$$_REQUIRE(_dependencyMap[0], "invariant");
+
+ var levelsMap = {
+ log: 'log',
+ info: 'info',
+ warn: 'warn',
+ error: 'error',
+ fatal: 'error'
+ };
+ var warningHandler = null;
+ var RCTLog = {
+ logIfNoNativeHook: function logIfNoNativeHook(level) {
+ for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+ args[_key - 1] = arguments[_key];
+ }
+
+ if (typeof global.nativeLoggingHook === 'undefined') {
+ RCTLog.logToConsole.apply(RCTLog, [level].concat(args));
+ } else {
+ if (warningHandler && level === 'warn') {
+ warningHandler.apply(void 0, args);
+ }
+ }
+ },
+ logToConsole: function logToConsole(level) {
+ var _console;
+
+ var logFn = levelsMap[level];
+ invariant(logFn, 'Level "' + level + '" not one of ' + Object.keys(levelsMap).toString());
+
+ for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+ args[_key2 - 1] = arguments[_key2];
+ }
+
+ (_console = console)[logFn].apply(_console, args);
+ },
+ setWarningHandler: function setWarningHandler(handler) {
+ warningHandler = handler;
+ }
+ };
+ module.exports = RCTLog;
+},154,[19],"node_modules\\react-native\\Libraries\\Utilities\\RCTLog.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var RCTDeviceEventEmitter = _$$_REQUIRE(_dependencyMap[0], "RCTDeviceEventEmitter");
+
+ var RCTNativeAppEventEmitter = RCTDeviceEventEmitter;
+ module.exports = RCTNativeAppEventEmitter;
+},155,[24],"node_modules\\react-native\\Libraries\\EventEmitter\\RCTNativeAppEventEmitter.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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 points = {};
+ 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 = {};
+ points = {};
+
+ if (PRINT_TO_CONSOLE) {
+ infoLog('PerformanceLogger.js', 'clear');
+ }
+ },
+ clearCompleted: function clearCompleted() {
+ for (var _key in timespans) {
+ if (timespans[_key].totalTime) {
+ delete timespans[_key];
+ }
+ }
+
+ extras = {};
+ points = {};
+
+ 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 = {};
+ points = {};
+
+ 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);
+ },
+ markPoint: function markPoint(key, timestamp) {
+ var _timestamp;
+
+ if (points[key]) {
+ if (__DEV__) {
+ infoLog('PerformanceLogger: Attempting to mark a point that has been already logged ', key);
+ }
+
+ return;
+ }
+
+ points[key] = (_timestamp = timestamp) != null ? _timestamp : performanceNow();
+ },
+ getPoints: function getPoints() {
+ return points;
+ },
+ logPoints: function logPoints() {
+ for (var _key3 in points) {
+ infoLog(_key3 + ': ' + points[_key3] + 'ms');
+ }
+ }
+ };
+ module.exports = PerformanceLogger;
+},156,[48,157,120],"node_modules\\react-native\\Libraries\\Utilities\\PerformanceLogger.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ function infoLog() {
+ var _console;
+
+ return (_console = console).log.apply(_console, arguments);
+ }
+
+ module.exports = infoLog;
+},157,[],"node_modules\\react-native\\Libraries\\Utilities\\infoLog.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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;
+},158,[36,84],"node_modules\\react-native\\Libraries\\Utilities\\JSDevSupportModule.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var Platform = _$$_REQUIRE(_dependencyMap[0], "Platform");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[1], "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' || Platform.OS === 'macos') {
+ 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();
+
+ if (data.type === 'GraphNotFoundError') {
+ hmrClient.disable();
+ throw new Error('The packager server has restarted since the last Hot update. Hot Reloading will be disabled until you reload the application.');
+ } else if (data.type === 'RevisionNotFoundError') {
+ hmrClient.disable();
+ throw new Error('The packager server and the client are out of sync. Hot Reloading will be disabled until you reload the application.');
+ } else {
+ throw new Error(data.type + " " + data.message);
+ }
+ });
+ hmrClient.on('close', function (data) {
+ HMRLoadingView.hide();
+ throw new Error('Disconnected from the packager server. Hot Reloading will be disabled until you reload the application.');
+ });
+ hmrClient.enable();
+ }
+ };
+ module.exports = HMRClient;
+},159,[35,19,160,164,36],"node_modules\\react-native\\Libraries\\Utilities\\HMRClient.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ "use strict";
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/inherits");
+
+ var WebSocketHMRClient = _$$_REQUIRE(_dependencyMap[4], "./WebSocketHMRClient");
+
+ var injectUpdate = _$$_REQUIRE(_dependencyMap[5], "./injectUpdate");
+
+ var HMRClient = function (_WebSocketHMRClient) {
+ _inherits(HMRClient, _WebSocketHMRClient);
+
+ function HMRClient(url) {
+ var _this;
+
+ _classCallCheck(this, HMRClient);
+
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(HMRClient).call(this, url));
+
+ _this.on("update", function (update) {
+ injectUpdate(update);
+ });
+
+ return _this;
+ }
+
+ return HMRClient;
+ }(WebSocketHMRClient);
+
+ module.exports = HMRClient;
+},160,[3,5,8,9,161,163],"node_modules\\react-native\\node_modules\\metro\\src\\lib\\bundle-modules\\HMRClient.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ "use strict";
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var EventEmitter = _$$_REQUIRE(_dependencyMap[5], "eventemitter3");
+
+ var WebSocketHMRClient = function (_EventEmitter) {
+ _inherits(WebSocketHMRClient, _EventEmitter);
+
+ function WebSocketHMRClient(url) {
+ var _this;
+
+ _classCallCheck(this, WebSocketHMRClient);
+
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(WebSocketHMRClient).call(this));
+ _this._url = url;
+ return _this;
+ }
+
+ _createClass(WebSocketHMRClient, [{
+ key: "enable",
+ value: function enable() {
+ var _this2 = this;
+
+ if (this._ws) {
+ this.disable();
+ }
+
+ this._ws = new global.WebSocket(this._url);
+
+ this._ws.onopen = function () {
+ _this2.emit("open");
+ };
+
+ 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":
+ _this2.emit("update", data.body);
+
+ 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;
+ }
+ }
+ }]);
+
+ return WebSocketHMRClient;
+ }(EventEmitter);
+
+ module.exports = WebSocketHMRClient;
+},161,[3,4,5,8,9,162],"node_modules\\react-native\\node_modules\\metro\\src\\lib\\bundle-modules\\WebSocketHMRClient.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var has = Object.prototype.hasOwnProperty,
+ prefix = '~';
+
+ function Events() {}
+
+ if (Object.create) {
+ Events.prototype = Object.create(null);
+ if (!new Events().__proto__) prefix = false;
+ }
+
+ function EE(fn, context, once) {
+ this.fn = fn;
+ this.context = context;
+ this.once = once || false;
+ }
+
+ function addListener(emitter, event, fn, context, once) {
+ if (typeof fn !== 'function') {
+ throw new TypeError('The listener must be a function');
+ }
+
+ var listener = new EE(fn, context || emitter, once),
+ evt = prefix ? prefix + event : event;
+ if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);else emitter._events[evt] = [emitter._events[evt], listener];
+ return emitter;
+ }
+
+ function clearEvent(emitter, evt) {
+ if (--emitter._eventsCount === 0) emitter._events = new Events();else delete emitter._events[evt];
+ }
+
+ function EventEmitter() {
+ this._events = new Events();
+ this._eventsCount = 0;
+ }
+
+ EventEmitter.prototype.eventNames = function eventNames() {
+ var names = [],
+ events,
+ name;
+ if (this._eventsCount === 0) return names;
+
+ for (name in events = this._events) {
+ if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
+ }
+
+ if (Object.getOwnPropertySymbols) {
+ return names.concat(Object.getOwnPropertySymbols(events));
+ }
+
+ return names;
+ };
+
+ EventEmitter.prototype.listeners = function listeners(event) {
+ var evt = prefix ? prefix + event : event,
+ handlers = this._events[evt];
+ if (!handlers) return [];
+ if (handlers.fn) return [handlers.fn];
+
+ for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
+ ee[i] = handlers[i].fn;
+ }
+
+ return ee;
+ };
+
+ EventEmitter.prototype.listenerCount = function listenerCount(event) {
+ var evt = prefix ? prefix + event : event,
+ listeners = this._events[evt];
+ if (!listeners) return 0;
+ if (listeners.fn) return 1;
+ return listeners.length;
+ };
+
+ EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+ var evt = prefix ? prefix + event : event;
+ if (!this._events[evt]) return false;
+ var listeners = this._events[evt],
+ len = arguments.length,
+ args,
+ i;
+
+ if (listeners.fn) {
+ if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);
+
+ switch (len) {
+ case 1:
+ return listeners.fn.call(listeners.context), true;
+
+ case 2:
+ return listeners.fn.call(listeners.context, a1), true;
+
+ case 3:
+ return listeners.fn.call(listeners.context, a1, a2), true;
+
+ case 4:
+ return listeners.fn.call(listeners.context, a1, a2, a3), true;
+
+ case 5:
+ return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+
+ case 6:
+ return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+ }
+
+ for (i = 1, args = new Array(len - 1); i < len; i++) {
+ args[i - 1] = arguments[i];
+ }
+
+ listeners.fn.apply(listeners.context, args);
+ } else {
+ var length = listeners.length,
+ j;
+
+ for (i = 0; i < length; i++) {
+ if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);
+
+ switch (len) {
+ case 1:
+ listeners[i].fn.call(listeners[i].context);
+ break;
+
+ case 2:
+ listeners[i].fn.call(listeners[i].context, a1);
+ break;
+
+ case 3:
+ listeners[i].fn.call(listeners[i].context, a1, a2);
+ break;
+
+ case 4:
+ listeners[i].fn.call(listeners[i].context, a1, a2, a3);
+ break;
+
+ default:
+ if (!args) for (j = 1, args = new Array(len - 1); j < len; j++) {
+ args[j - 1] = arguments[j];
+ }
+ listeners[i].fn.apply(listeners[i].context, args);
+ }
+ }
+ }
+
+ return true;
+ };
+
+ EventEmitter.prototype.on = function on(event, fn, context) {
+ return addListener(this, event, fn, context, false);
+ };
+
+ EventEmitter.prototype.once = function once(event, fn, context) {
+ return addListener(this, event, fn, context, true);
+ };
+
+ EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
+ var evt = prefix ? prefix + event : event;
+ if (!this._events[evt]) return this;
+
+ if (!fn) {
+ clearEvent(this, evt);
+ return this;
+ }
+
+ var listeners = this._events[evt];
+
+ if (listeners.fn) {
+ if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
+ clearEvent(this, evt);
+ }
+ } else {
+ for (var i = 0, events = [], length = listeners.length; i < length; i++) {
+ if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) {
+ events.push(listeners[i]);
+ }
+ }
+
+ if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;else clearEvent(this, evt);
+ }
+
+ return this;
+ };
+
+ EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
+ var evt;
+
+ if (event) {
+ evt = prefix ? prefix + event : event;
+ if (this._events[evt]) clearEvent(this, evt);
+ } else {
+ this._events = new Events();
+ this._eventsCount = 0;
+ }
+
+ return this;
+ };
+
+ EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+ EventEmitter.prototype.addListener = EventEmitter.prototype.on;
+ EventEmitter.prefixed = prefix;
+ EventEmitter.EventEmitter = EventEmitter;
+
+ if ('undefined' !== typeof module) {
+ module.exports = EventEmitter;
+ }
+},162,[],"node_modules\\eventemitter3\\index.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ "use strict";
+
+ function _slicedToArray(arr, i) {
+ return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest();
+ }
+
+ function _nonIterableRest() {
+ throw new TypeError("Invalid attempt to destructure non-iterable instance");
+ }
+
+ function _iterableToArrayLimit(arr, i) {
+ var _arr = [];
+ var _n = true;
+ var _d = false;
+ var _e = undefined;
+
+ try {
+ for (var _i = arr[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"](), _s; !(_n = (_s = _i.next()).done); _n = true) {
+ _arr.push(_s.value);
+
+ if (i && _arr.length === i) break;
+ }
+ } catch (err) {
+ _d = true;
+ _e = err;
+ } finally {
+ try {
+ if (!_n && _i["return"] != null) _i["return"]();
+ } finally {
+ if (_d) throw _e;
+ }
+ }
+
+ return _arr;
+ }
+
+ function _arrayWithHoles(arr) {
+ if (Array.isArray(arr)) return arr;
+ }
+
+ function injectModules(modules, sourceMappingURLs, sourceURLs) {
+ modules.forEach(function (_ref, i) {
+ var _ref2 = _slicedToArray(_ref, 2),
+ id = _ref2[0],
+ code = _ref2[1];
+
+ var injectFunction = typeof global.nativeInjectHMRUpdate === "function" ? global.nativeInjectHMRUpdate : eval;
+ var pragma = "sourceMappingURL";
+ injectFunction(code + ("\n//# " + pragma + "=" + sourceMappingURLs[i]), sourceURLs[i]);
+ });
+ }
+
+ function injectUpdate(update) {
+ injectModules(update.added, update.addedSourceMappingURLs, update.addedSourceURLs);
+ injectModules(update.modified, update.modifiedSourceMappingURLs, update.modifiedSourceURLs);
+ }
+
+ module.exports = injectUpdate;
+},163,[],"node_modules\\react-native\\node_modules\\metro\\src\\lib\\bundle-modules\\injectUpdate.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var HMRLoadingView = function () {
+ function HMRLoadingView() {
+ _classCallCheck(this, HMRLoadingView);
+ }
+
+ _createClass(HMRLoadingView, null, [{
+ key: "showMessage",
+ value: function showMessage(message) {}
+ }, {
+ key: "hide",
+ value: function hide() {}
+ }]);
+
+ return HMRLoadingView;
+ }();
+
+ module.exports = HMRLoadingView;
+},164,[3,4],"Libraries\\Utilities\\HMRLoadingView.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ global.__fetchSegment = function (segmentId, options, callback) {
+ var _require = _$$_REQUIRE(_dependencyMap[0], "NativeModules"),
+ SegmentFetcher = _require.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);
+ });
+ };
+},165,[36],"node_modules\\react-native\\Libraries\\Core\\setUpSegmentFetcher.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ if (__DEV__) {
+ if (!global.__RCTProfileIsProfiling) {
+ if (!window.document) {
+ _$$_REQUIRE(_dependencyMap[0], "setupDevtools");
+ }
+
+ var JSInspector = _$$_REQUIRE(_dependencyMap[1], "JSInspector");
+
+ JSInspector.registerAgent(_$$_REQUIRE(_dependencyMap[2], "NetworkAgent"));
+ }
+ }
+},166,[167,170,171],"node_modules\\react-native\\Libraries\\Core\\setUpDeveloperTools.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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.isAvailable || 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
+ };
+},167,[168,139,169,104,80],"node_modules\\react-native\\Libraries\\Core\\Devtools\\setupDevtools.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var MissingNativeEventEmitterShim = _$$_REQUIRE(_dependencyMap[5], "MissingNativeEventEmitterShim");
+
+ var NativeEventEmitter = _$$_REQUIRE(_dependencyMap[6], "NativeEventEmitter");
+
+ var NativeModules = _$$_REQUIRE(_dependencyMap[7], "NativeModules");
+
+ var RCTAppState = NativeModules.AppState;
+
+ var logError = _$$_REQUIRE(_dependencyMap[8], "logError");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[9], "invariant");
+
+ var AppState = function (_NativeEventEmitter) {
+ _inherits(AppState, _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);
+ }
+ }]);
+
+ return AppState;
+ }(NativeEventEmitter);
+
+ if (__DEV__ && !RCTAppState) {
+ var MissingNativeAppStateShim = function (_MissingNativeEventEm) {
+ _inherits(MissingNativeAppStateShim, _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();
+ }
+ }]);
+
+ return MissingNativeAppStateShim;
+ }(MissingNativeEventEmitterShim);
+
+ AppState = new MissingNativeAppStateShim();
+ } else {
+ AppState = new AppState();
+ }
+
+ module.exports = AppState;
+},168,[3,4,5,8,9,130,131,36,149,19],"node_modules\\react-native\\Libraries\\AppState\\AppState.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ !function (e, t) {
+ "object" == typeof exports && "object" == typeof module ? module.exports = t() : "function" == typeof define && define.amd ? define([], t) : "object" == typeof exports ? exports.ReactDevToolsBackend = t() : e.ReactDevToolsBackend = t();
+ }(window, function () {
+ return function (e) {
+ var t = {};
+
+ function n(r) {
+ if (t[r]) return t[r].exports;
+ var o = t[r] = {
+ i: r,
+ l: !1,
+ exports: {}
+ };
+ return e[r].call(o.exports, o, o.exports, n), o.l = !0, o.exports;
+ }
+
+ return n.m = e, n.c = t, n.d = function (e, t, r) {
+ n.o(e, t) || Object.defineProperty(e, t, {
+ enumerable: !0,
+ get: r
+ });
+ }, n.r = function (e) {
+ "undefined" != typeof Symbol && (typeof Symbol === "function" ? Symbol.toStringTag : "@@toStringTag") && Object.defineProperty(e, typeof Symbol === "function" ? Symbol.toStringTag : "@@toStringTag", {
+ value: "Module"
+ }), Object.defineProperty(e, "__esModule", {
+ value: !0
+ });
+ }, n.t = function (e, t) {
+ if (1 & t && (e = n(e)), 8 & t) return e;
+ if (4 & t && "object" == typeof e && e && e.__esModule) return e;
+ var r = Object.create(null);
+ if (n.r(r), Object.defineProperty(r, "default", {
+ enumerable: !0,
+ value: e
+ }), 2 & t && "string" != typeof e) for (var o in e) {
+ n.d(r, o, function (t) {
+ return e[t];
+ }.bind(null, o));
+ }
+ return r;
+ }, n.n = function (e) {
+ var t = e && e.__esModule ? function () {
+ return e.default;
+ } : function () {
+ return e;
+ };
+ return n.d(t, "a", t), t;
+ }, n.o = function (e, t) {
+ return Object.prototype.hasOwnProperty.call(e, t);
+ }, n.p = "", n(n.s = 8);
+ }([function (e, t, n) {
+ var r, o, i;
+ !function (a, s) {
+ "use strict";
+
+ o = [n(54)], void 0 === (i = "function" == typeof (r = function r(e) {
+ var t = /(^|@)\S+\:\d+/,
+ n = /^\s*at .*(\S+\:\d+|\(native\))/m,
+ r = /^(eval@)?(\[native code\])?$/;
+ return {
+ parse: function parse(e) {
+ if (void 0 !== e.stacktrace || void 0 !== e["opera#sourceloc"]) return this.parseOpera(e);
+ if (e.stack && e.stack.match(n)) return this.parseV8OrIE(e);
+ if (e.stack) return this.parseFFOrSafari(e);
+ throw new Error("Cannot parse given Error object");
+ },
+ extractLocation: function extractLocation(e) {
+ if (-1 === e.indexOf(":")) return [e];
+ var t = /(.+?)(?:\:(\d+))?(?:\:(\d+))?$/.exec(e.replace(/[\(\)]/g, ""));
+ return [t[1], t[2] || void 0, t[3] || void 0];
+ },
+ parseV8OrIE: function parseV8OrIE(t) {
+ var r = t.stack.split("\n").filter(function (e) {
+ return !!e.match(n);
+ }, this);
+ return r.map(function (t) {
+ t.indexOf("(eval ") > -1 && (t = t.replace(/eval code/g, "eval").replace(/(\(eval at [^\()]*)|(\)\,.*$)/g, ""));
+ var n = t.replace(/^\s+/, "").replace(/\(eval code/g, "(").split(/\s+/).slice(1),
+ r = this.extractLocation(n.pop()),
+ o = n.join(" ") || void 0,
+ i = ["eval", ""].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(//, "$2").replace(/\([^\)]*\)/g, "") || void 0;
+ i.match(/\(([^\)]*)\)/) && (n = i.replace(/^[^\(]+\(([^\)]*)\)$/, "$1"));
+ var s = void 0 === n || "[arguments not available]" === n ? void 0 : n.split(",");
+ return new e({
+ functionName: a,
+ args: s,
+ fileName: o[0],
+ lineNumber: o[1],
+ columnNumber: o[2],
+ source: t
+ });
+ }, this);
+ }
+ };
+ }) ? r.apply(t, o) : r) || (e.exports = i);
+ }();
+ }, function (e, t, n) {
+ "use strict";
+
+ var r = Object.prototype.hasOwnProperty,
+ o = Object.prototype.propertyIsEnumerable;
+
+ e.exports = Object.assign || function (e, t) {
+ for (var n, i, a = function (e) {
+ if (null == e) throw new TypeError("Object.assign cannot be called with null or undefined");
+ return Object(e);
+ }(e), s = 1; s < arguments.length; s++) {
+ for (var u in n = Object(arguments[s])) {
+ r.call(n, u) && (a[u] = n[u]);
+ }
+
+ if (Object.getOwnPropertySymbols) {
+ i = Object.getOwnPropertySymbols(n);
+
+ for (var c = 0; c < i.length; c++) {
+ o.call(n, i[c]) && (a[i[c]] = n[i[c]]);
+ }
+ }
+ }
+
+ return a;
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ function r(e, t, n) {
+ return t in e ? Object.defineProperty(e, t, {
+ value: n,
+ enumerable: !0,
+ configurable: !0,
+ writable: !0
+ }) : e[t] = n, e;
+ }
+
+ function o(e, t, n, i) {
+ if (n >= t.length) return i;
+ var a = t[n],
+ s = Array.isArray(e) ? e.slice() : function (e) {
+ for (var t = 1; t < arguments.length; t++) {
+ var n = null != arguments[t] ? arguments[t] : {},
+ o = Object.keys(n);
+ "function" == typeof Object.getOwnPropertySymbols && (o = o.concat(Object.getOwnPropertySymbols(n).filter(function (e) {
+ return Object.getOwnPropertyDescriptor(n, e).enumerable;
+ }))), o.forEach(function (t) {
+ r(e, t, n[t]);
+ });
+ }
+
+ return e;
+ }({}, e);
+ return s[a] = o(e[a], t, n + 1, i), s;
+ }
+
+ e.exports = function (e, t, n) {
+ return o(e, t, 0, n);
+ };
+ }, function (e, t) {
+ function n(e) {
+ return function (e) {
+ if (Array.isArray(e)) {
+ for (var t = 0, n = new Array(e.length); t < e.length; t++) {
+ n[t] = e[t];
+ }
+
+ return n;
+ }
+ }(e) || function (e) {
+ if ((typeof Symbol === "function" ? Symbol.iterator : "@@iterator") in Object(e) || "[object Arguments]" === Object.prototype.toString.call(e)) return Array.from(e);
+ }(e) || function () {
+ throw new TypeError("Invalid attempt to spread non-iterable instance");
+ }();
+ }
+
+ var r = Object.prototype.hasOwnProperty;
+
+ e.exports = function (e, t) {
+ return t.reduce(function (e, t) {
+ if (e) {
+ if (r.call(e, t)) return e[t];
+ if ("function" == typeof e[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]) return n(e)[t];
+ }
+
+ return null;
+ }, e);
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ var r = n(14);
+ e.exports = {
+ name: r("name"),
+ type: r("type"),
+ inspected: r("inspected"),
+ meta: r("meta"),
+ proto: r("proto")
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ var r = /^(.*) \[from (.*)\]$/,
+ o = new WeakMap();
+
+ e.exports = function (e) {
+ var t,
+ n = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : "Unknown",
+ i = o.get(e);
+ if (null != i) return i;
+ "string" == typeof e.displayName && (t = e.displayName), t || (t = e.name || n);
+ var a = t.match(r);
+
+ if (a) {
+ var s = a[1],
+ u = a[2];
+ s && u && (u === s || u.startsWith(s + ".")) && (t = s);
+ }
+
+ return o.set(e, t), t;
+ };
+ }, function (e, t) {
+ var n,
+ r,
+ o = e.exports = {};
+
+ function i() {
+ throw new Error("setTimeout has not been defined");
+ }
+
+ function a() {
+ throw new Error("clearTimeout has not been defined");
+ }
+
+ function s(e) {
+ if (n === setTimeout) return setTimeout(e, 0);
+ if ((n === i || !n) && setTimeout) return n = setTimeout, setTimeout(e, 0);
+
+ try {
+ return n(e, 0);
+ } catch (t) {
+ try {
+ return n.call(null, e, 0);
+ } catch (t) {
+ return n.call(this, e, 0);
+ }
+ }
+ }
+
+ !function () {
+ try {
+ n = "function" == typeof setTimeout ? setTimeout : i;
+ } catch (e) {
+ n = i;
+ }
+
+ try {
+ r = "function" == typeof clearTimeout ? clearTimeout : a;
+ } catch (e) {
+ r = a;
+ }
+ }();
+ var u,
+ c = [],
+ l = !1,
+ f = -1;
+
+ function p() {
+ l && u && (l = !1, u.length ? c = u.concat(c) : f = -1, c.length && d());
+ }
+
+ function d() {
+ if (!l) {
+ var e = s(p);
+ l = !0;
+
+ for (var t = c.length; t;) {
+ for (u = c, c = []; ++f < t;) {
+ u && u[f].run();
+ }
+
+ f = -1, t = c.length;
+ }
+
+ u = null, l = !1, function (e) {
+ if (r === clearTimeout) return clearTimeout(e);
+ if ((r === a || !r) && clearTimeout) return r = clearTimeout, clearTimeout(e);
+
+ try {
+ r(e);
+ } catch (t) {
+ try {
+ return r.call(null, e);
+ } catch (t) {
+ return r.call(this, e);
+ }
+ }
+ }(e);
+ }
+ }
+
+ function h(e, t) {
+ this.fun = e, this.array = t;
+ }
+
+ function m() {}
+
+ o.nextTick = function (e) {
+ var t = new Array(arguments.length - 1);
+ if (arguments.length > 1) for (var n = 1; n < arguments.length; n++) {
+ t[n - 1] = arguments[n];
+ }
+ c.push(new h(e, t)), 1 !== c.length || l || s(d);
+ }, h.prototype.run = function () {
+ this.fun.apply(null, this.array);
+ }, o.title = "browser", o.browser = !0, o.env = {}, o.argv = [], o.version = "", o.versions = {}, o.on = m, o.addListener = m, o.once = m, o.off = m, o.removeListener = m, o.removeAllListeners = m, o.emit = m, o.prependListener = m, o.prependOnceListener = m, o.listeners = function (e) {
+ return [];
+ }, o.binding = function (e) {
+ throw new Error("process.binding is not supported");
+ }, o.cwd = function () {
+ return "/";
+ }, o.chdir = function (e) {
+ throw new Error("process.chdir is not supported");
+ }, o.umask = function () {
+ return 0;
+ };
+ }, function (e, t) {
+ function n(e) {
+ return (n = "function" == typeof Symbol && "symbol" == typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") ? function (e) {
+ return typeof e;
+ } : function (e) {
+ return e && "function" == typeof Symbol && e.constructor === Symbol && e !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof e;
+ })(e);
+ }
+
+ var r;
+
+ r = function () {
+ return this;
+ }();
+
+ try {
+ r = r || Function("return this")() || (0, eval)("this");
+ } catch (e) {
+ "object" === ("undefined" == typeof window ? "undefined" : n(window)) && (r = window);
+ }
+
+ e.exports = r;
+ }, function (e, t, n) {
+ "use strict";
+
+ var r = n(9),
+ o = n(13),
+ i = n(37),
+ a = n(38),
+ s = n(39),
+ u = n(48),
+ c = n(52),
+ l = n(61).default,
+ f = n(55);
+ a(window), window.document && window.__REACT_DEVTOOLS_GLOBAL_HOOK__.on("react-devtools", function (e) {
+ n(56)(e);
+ }), e.exports = {
+ connectToDevTools: function e(t) {
+ var n = t || {},
+ a = n.host,
+ p = void 0 === a ? "localhost" : a,
+ d = n.port,
+ h = void 0 === d ? 8097 : d,
+ m = n.websocket,
+ y = n.resolveRNStyle,
+ v = void 0 === y ? null : y,
+ g = n.isAppActive;
+
+ function b() {
+ setTimeout(function () {
+ return e(t);
+ }, 2e3);
+ }
+
+ if ((void 0 === g ? function () {
+ return !0;
+ } : g)()) {
+ var _ = [],
+ w = [],
+ S = "ws://" + p + ":" + h,
+ E = m || new window.WebSocket(S);
+ E.onclose = function () {
+ O || (O = !0, b(), w.forEach(function (e) {
+ return e();
+ }));
+ }, E.onerror = function () {
+ O || (O = !0, w.forEach(function (e) {
+ return e();
+ }));
+ }, E.onmessage = function (e) {
+ var t;
+
+ try {
+ u("string" == typeof e.data), t = JSON.parse(e.data);
+ } catch (t) {
+ return void console.error("failed to parse json: " + String(e.data));
+ }
+
+ _.forEach(function (e) {
+ try {
+ e(t);
+ } catch (e) {
+ throw console.log(t), e;
+ }
+ });
+ }, E.onopen = function () {
+ !function (e, t) {
+ e.onClose(function () {
+ a && a.emit("shutdown"), window.__REACT_DEVTOOLS_GLOBAL_HOOK__.emit("shutdown"), n = null, a = null, console.log("closing devtools");
+ });
+ var n = new o(e),
+ a = new r(window, {
+ rnStyle: !!t,
+ rnStyleMeasure: !!t
+ });
+ a.addBridge(n), t && c(n, a, t), f(n, a, window.__REACT_DEVTOOLS_GLOBAL_HOOK__), l(n, a);
+ var u = setTimeout(function () {
+ console.warn("react-devtools agent got no connection");
+ }, 2e4);
+ a.once("connected", function () {
+ a && (s(window.__REACT_DEVTOOLS_GLOBAL_HOOK__, a), clearTimeout(u));
+ }), i.init(a);
+ }({
+ listen: function listen(e) {
+ _.push(e);
+ },
+ onClose: function onClose(e) {
+ w.push(e);
+ },
+ send: function send(e) {
+ E.send(JSON.stringify(e));
+ }
+ }, v);
+ };
+ var O = !1;
+ } else b();
+ }
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ function r(e) {
+ return (r = "function" == typeof Symbol && "symbol" == typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") ? function (e) {
+ return typeof e;
+ } : function (e) {
+ return e && "function" == typeof Symbol && e.constructor === Symbol && e !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof e;
+ })(e);
+ }
+
+ function o(e, t) {
+ for (var n = 0; n < t.length; n++) {
+ var r = t[n];
+ r.enumerable = r.enumerable || !1, r.configurable = !0, "value" in r && (r.writable = !0), Object.defineProperty(e, r.key, r);
+ }
+ }
+
+ function i(e) {
+ return (i = Object.setPrototypeOf ? Object.getPrototypeOf : function (e) {
+ return e.__proto__ || Object.getPrototypeOf(e);
+ })(e);
+ }
+
+ function a(e, t) {
+ return (a = Object.setPrototypeOf || function (e, t) {
+ return e.__proto__ = t, e;
+ })(e, t);
+ }
+
+ function s(e) {
+ if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+ return e;
+ }
+
+ var u = n(10).EventEmitter,
+ c = n(1),
+ l = n(11).default,
+ f = n(12),
+ p = n(3),
+ d = function (e) {
+ function t(e, n) {
+ var o, a, u, l;
+ !function (e, t) {
+ if (!(e instanceof t)) throw new TypeError("Cannot call a class as a function");
+ }(this, t), a = this, u = i(t).call(this), (o = !u || "object" !== r(u) && "function" != typeof u ? s(a) : u).global = e, o.internalInstancesById = new Map(), o.idsByInternalInstances = new WeakMap(), o.renderers = new Map(), o.elementData = new Map(), o.roots = new Set(), o.reactInternals = {}, o.on("selected", function (e) {
+ var t = o.elementData.get(e);
+ t && t.publicInstance && o.global.$r === l && (o.global.$r = t.publicInstance, l = t.publicInstance);
+ }), o._prevSelected = null, o._scrollUpdate = !1;
+ var f = window.document && "function" == typeof window.document.createElement;
+ return o.capabilities = c({
+ scroll: f && "function" == typeof window.document.body.scrollIntoView,
+ dom: f,
+ editTextContent: !1
+ }, n), f && (o._updateScroll = o._updateScroll.bind(s(s(o))), window.addEventListener("scroll", o._onScroll.bind(s(s(o))), !0), window.addEventListener("click", o._onClick.bind(s(s(o))), !0), window.addEventListener("mouseover", o._onMouseOver.bind(s(s(o))), !0), window.addEventListener("resize", o._onResize.bind(s(s(o))), !0)), o;
+ }
+
+ var n, d, h;
+ return function (e, t) {
+ if ("function" != typeof t && null !== t) throw new TypeError("Super expression must either be null or a function");
+ e.prototype = Object.create(t && t.prototype, {
+ constructor: {
+ value: e,
+ writable: !0,
+ configurable: !0
+ }
+ }), t && a(e, t);
+ }(t, u), n = t, (d = [{
+ key: "sub",
+ value: function value(e, t) {
+ var n = this;
+ return this.on(e, t), function () {
+ n.removeListener(e, t);
+ };
+ }
+ }, {
+ key: "setReactInternals",
+ value: function value(e, t) {
+ this.reactInternals[e] = t;
+ }
+ }, {
+ key: "addBridge",
+ value: function value(e) {
+ var t = this;
+ e.on("requestCapabilities", function () {
+ e.send("capabilities", t.capabilities), t.emit("connected");
+ }), e.on("setState", this._setState.bind(this)), e.on("setProps", this._setProps.bind(this)), e.on("setContext", this._setContext.bind(this)), e.on("makeGlobal", this._makeGlobal.bind(this)), e.on("highlight", function (e) {
+ return t.highlight(e);
+ }), e.on("highlightMany", function (e) {
+ return t.highlightMany(e);
+ }), e.on("hideHighlight", function () {
+ return t.emit("hideHighlight");
+ }), e.on("startInspecting", function () {
+ return t.emit("startInspecting");
+ }), e.on("stopInspecting", function () {
+ return t.emit("stopInspecting");
+ }), e.on("selected", function (e) {
+ return t.emit("selected", e);
+ }), e.on("isRecording", function (e) {
+ return t.emit("isRecording", e);
+ }), e.on("setInspectEnabled", function (e) {
+ t._inspectEnabled = e, t.emit("stopInspecting");
+ }), e.on("shutdown", function () {
+ return t.emit("shutdown");
+ }), e.on("changeTextContent", function (e) {
+ var n = e.id,
+ r = e.text,
+ o = t.getNodeForID(n);
+ o && (o.textContent = r);
+ }), e.on("putSelectedNode", function (e) {
+ window.__REACT_DEVTOOLS_GLOBAL_HOOK__.$node = t.getNodeForID(e);
+ }), e.on("putSelectedInstance", function (e) {
+ var n = t.elementData.get(e);
+ window.__REACT_DEVTOOLS_GLOBAL_HOOK__.$type = n ? n.type : null, n && n.publicInstance ? window.__REACT_DEVTOOLS_GLOBAL_HOOK__.$inst = n.publicInstance : window.__REACT_DEVTOOLS_GLOBAL_HOOK__.$inst = null;
+ }), e.on("checkSelection", function () {
+ var e = window.__REACT_DEVTOOLS_GLOBAL_HOOK__.$0;
+ e !== t._prevSelected && (t._prevSelected = e, e !== window.__REACT_DEVTOOLS_GLOBAL_HOOK__.$node && t.selectFromDOMNode(e, !0));
+ }), e.on("scrollToNode", function (e) {
+ return t.scrollToNode(e);
+ }), e.on("traceupdatesstatechange", function (e) {
+ return t.emit("traceupdatesstatechange", e);
+ }), e.on("colorizerchange", function (e) {
+ return t.emit("colorizerchange", e);
+ }), this.on("root", function (t) {
+ return e.send("root", t);
+ }), this.on("mount", function (t) {
+ return e.send("mount", t);
+ }), this.on("update", function (t) {
+ return e.send("update", t);
+ }), this.on("updateProfileTimes", function (t) {
+ return e.send("updateProfileTimes", t);
+ }), this.on("unmount", function (t) {
+ e.send("unmount", t), e.forget(t);
+ }), this.on("setSelection", function (t) {
+ return e.send("select", t);
+ }), this.on("setInspectEnabled", function (t) {
+ return e.send("setInspectEnabled", t);
+ }), this.on("isRecording", function (t) {
+ return e.send("isRecording", t);
+ }), this.on("storeSnapshot", function (t) {
+ return e.send("storeSnapshot", t);
+ }), this.on("clearSnapshots", function () {
+ return e.send("clearSnapshots");
+ });
+ }
+ }, {
+ key: "scrollToNode",
+ value: function value(e) {
+ var t = this.getNodeForID(e);
+
+ if (t) {
+ var n = t.nodeType === Node.ELEMENT_NODE ? t : t.parentElement;
+ n ? ("function" == typeof n.scrollIntoViewIfNeeded ? n.scrollIntoViewIfNeeded() : "function" == typeof n.scrollIntoView && n.scrollIntoView(), this.highlight(e)) : console.warn("unable to get the domElement for scrolling");
+ } else console.warn("unable to get the node for scrolling");
+ }
+ }, {
+ key: "highlight",
+ value: function value(e) {
+ var t = this.elementData.get(e),
+ n = this.getNodeForID(e);
+ t && n && this.emit("highlight", {
+ node: n,
+ name: t.name,
+ props: t.props
+ });
+ }
+ }, {
+ key: "highlightMany",
+ value: function value(e) {
+ var t = this,
+ n = [];
+ e.forEach(function (e) {
+ var r = t.getNodeForID(e);
+ r && n.push(r);
+ }), n.length && this.emit("highlightMany", n);
+ }
+ }, {
+ key: "getNodeForID",
+ value: function value(e) {
+ var t = this.internalInstancesById.get(e);
+ if (!t) return null;
+ var n = this.renderers.get(e);
+ return n && this.reactInternals[n].getNativeFromReactElement ? this.reactInternals[n].getNativeFromReactElement(t) : null;
+ }
+ }, {
+ key: "selectFromDOMNode",
+ value: function value(e, t) {
+ var n = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : 0,
+ r = this.getIDForNode(e);
+ r && this.emit("setSelection", {
+ id: r,
+ quiet: t,
+ offsetFromLeaf: n
+ });
+ }
+ }, {
+ key: "selectFromReactInstance",
+ value: function value(e, t) {
+ var n = this.getId(e);
+ n ? this.emit("setSelection", {
+ id: n,
+ quiet: t
+ }) : console.log("no instance id", e);
+ }
+ }, {
+ key: "getIDForNode",
+ value: function value(e) {
+ if (!this.reactInternals) return null;
+ var t;
+
+ for (var n in this.reactInternals) {
+ try {
+ t = this.reactInternals[n].getReactElementFromNative(e);
+ } catch (e) {}
+
+ if (t) return this.getId(t);
+ }
+
+ return null;
+ }
+ }, {
+ key: "_setProps",
+ value: function value(e) {
+ var t = e.id,
+ n = e.path,
+ r = e.value,
+ o = this.elementData.get(t);
+ o && o.updater && "function" == typeof o.updater.setInProps ? o.updater.setInProps(n, r) : console.warn("trying to set props on a component that doesn't support it");
+ }
+ }, {
+ key: "_setState",
+ value: function value(e) {
+ var t = e.id,
+ n = e.path,
+ r = e.value,
+ o = this.elementData.get(t);
+ o && o.updater && "function" == typeof o.updater.setInState ? o.updater.setInState(n, r) : console.warn("trying to set state on a component that doesn't support it");
+ }
+ }, {
+ key: "_setContext",
+ value: function value(e) {
+ var t = e.id,
+ n = e.path,
+ r = e.value,
+ o = this.elementData.get(t);
+ o && o.updater && "function" == typeof o.updater.setInContext ? o.updater.setInContext(n, r) : console.warn("trying to set context on a component that doesn't support it");
+ }
+ }, {
+ key: "_makeGlobal",
+ value: function value(e) {
+ var t,
+ n = e.id,
+ r = e.path,
+ o = this.elementData.get(n);
+ o && (t = "instance" === r ? o.publicInstance : p(o, r), this.global.$tmp = t, console.log("$tmp =", t));
+ }
+ }, {
+ key: "getId",
+ value: function value(e) {
+ return "object" === r(e) && e ? (this.idsByInternalInstances.has(e) || (this.idsByInternalInstances.set(e, f()), this.internalInstancesById.set(l(this.idsByInternalInstances.get(e)), e)), l(this.idsByInternalInstances.get(e))) : e;
+ }
+ }, {
+ key: "addRoot",
+ value: function value(e, t) {
+ var n = this.getId(t);
+ this.roots.add(n), this.emit("root", n);
+ }
+ }, {
+ key: "rootCommitted",
+ value: function value(e, t, n) {
+ var r = this.getId(t);
+ this.emit("rootCommitted", r, t, n);
+ }
+ }, {
+ key: "onMounted",
+ value: function value(e, t, n) {
+ var r = this,
+ o = this.getId(t);
+ this.renderers.set(o, e), this.elementData.set(o, n);
+ var i = c({}, n);
+ i.children && i.children.map && (i.children = i.children.map(function (e) {
+ return r.getId(e);
+ })), i.id = o, i.canUpdate = i.updater && i.updater.canUpdate, delete i.type, delete i.updater, this.emit("mount", i);
+ }
+ }, {
+ key: "onUpdated",
+ value: function value(e, t) {
+ var n = this,
+ r = this.getId(e);
+ this.elementData.set(r, t);
+ var o = c({}, t);
+ o.children && o.children.map && (o.children = o.children.map(function (e) {
+ return n.getId(e);
+ })), o.id = r, o.canUpdate = o.updater && o.updater.canUpdate, delete o.type, delete o.updater, this.emit("update", o);
+ }
+ }, {
+ key: "onUpdatedProfileTimes",
+ value: function value(e, t) {
+ var n = this,
+ r = this.getId(e);
+ this.elementData.set(r, t);
+ var o = c({}, t);
+ o.children && o.children.map && (o.children = o.children.map(function (e) {
+ return n.getId(e);
+ })), o.id = r, o.canUpdate = o.updater && o.updater.canUpdate, delete o.type, delete o.updater, this.emit("updateProfileTimes", o);
+ }
+ }, {
+ key: "onUnmounted",
+ value: function value(e) {
+ var t = this.getId(e);
+ this.elementData.delete(t), this.roots.has(t) && (this.roots.delete(t), this.emit("rootUnmounted", t)), this.renderers.delete(t), this.emit("unmount", t), this.idsByInternalInstances.delete(e);
+ }
+ }, {
+ key: "_onScroll",
+ value: function value() {
+ this._scrollUpdate || (this._scrollUpdate = !0, window.requestAnimationFrame(this._updateScroll));
+ }
+ }, {
+ key: "_updateScroll",
+ value: function value() {
+ this.emit("refreshMultiOverlay"), this.emit("stopInspecting"), this._scrollUpdate = !1;
+ }
+ }, {
+ key: "_onClick",
+ value: function value(e) {
+ if (this._inspectEnabled) {
+ var t = this.getIDForNode(e.target);
+ t && (e.stopPropagation(), e.preventDefault(), this.emit("setSelection", {
+ id: t
+ }), this.emit("setInspectEnabled", !1));
+ }
+ }
+ }, {
+ key: "_onMouseOver",
+ value: function value(e) {
+ if (this._inspectEnabled) {
+ var t = this.getIDForNode(e.target);
+ if (!t) return;
+ this.highlight(t);
+ }
+ }
+ }, {
+ key: "_onResize",
+ value: function value(e) {
+ this.emit("stopInspecting");
+ }
+ }]) && o(n.prototype, d), h && o(n, h), t;
+ }();
+
+ e.exports = d;
+ }, function (e, t) {
+ function n(e) {
+ return (n = "function" == typeof Symbol && "symbol" == typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") ? function (e) {
+ return typeof e;
+ } : function (e) {
+ return e && "function" == typeof Symbol && e.constructor === Symbol && e !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof e;
+ })(e);
+ }
+
+ function r() {
+ this._events = this._events || {}, this._maxListeners = this._maxListeners || void 0;
+ }
+
+ function o(e) {
+ return "function" == typeof e;
+ }
+
+ function i(e) {
+ return "object" === n(e) && null !== e;
+ }
+
+ function a(e) {
+ return void 0 === e;
+ }
+
+ e.exports = r, r.EventEmitter = r, r.prototype._events = void 0, r.prototype._maxListeners = void 0, r.defaultMaxListeners = 10, r.prototype.setMaxListeners = function (e) {
+ if ("number" != typeof e || e < 0 || isNaN(e)) throw TypeError("n must be a positive number");
+ return this._maxListeners = e, this;
+ }, r.prototype.emit = function (e) {
+ var t, n, r, s, u, c;
+
+ if (this._events || (this._events = {}), "error" === e && (!this._events.error || i(this._events.error) && !this._events.error.length)) {
+ if ((t = arguments[1]) instanceof Error) throw t;
+ var l = new Error('Uncaught, unspecified "error" event. (' + t + ")");
+ throw l.context = t, l;
+ }
+
+ if (a(n = this._events[e])) return !1;
+ if (o(n)) switch (arguments.length) {
+ case 1:
+ n.call(this);
+ break;
+
+ case 2:
+ n.call(this, arguments[1]);
+ break;
+
+ case 3:
+ n.call(this, arguments[1], arguments[2]);
+ break;
+
+ default:
+ s = Array.prototype.slice.call(arguments, 1), n.apply(this, s);
+ } else if (i(n)) for (s = Array.prototype.slice.call(arguments, 1), r = (c = n.slice()).length, u = 0; u < r; u++) {
+ c[u].apply(this, s);
+ }
+ return !0;
+ }, r.prototype.addListener = function (e, t) {
+ var n;
+ if (!o(t)) throw TypeError("listener must be a function");
+ return this._events || (this._events = {}), this._events.newListener && this.emit("newListener", e, o(t.listener) ? t.listener : t), this._events[e] ? i(this._events[e]) ? this._events[e].push(t) : this._events[e] = [this._events[e], t] : this._events[e] = t, i(this._events[e]) && !this._events[e].warned && (n = a(this._maxListeners) ? r.defaultMaxListeners : this._maxListeners) && n > 0 && this._events[e].length > n && (this._events[e].warned = !0, console.error("(node) warning: possible EventEmitter memory leak detected. %d listeners added. Use emitter.setMaxListeners() to increase limit.", this._events[e].length), "function" == typeof console.trace && console.trace()), this;
+ }, r.prototype.on = r.prototype.addListener, r.prototype.once = function (e, t) {
+ if (!o(t)) throw TypeError("listener must be a function");
+ var n = !1;
+
+ function r() {
+ this.removeListener(e, r), n || (n = !0, t.apply(this, arguments));
+ }
+
+ return r.listener = t, this.on(e, r), this;
+ }, r.prototype.removeListener = function (e, t) {
+ var n, r, a, s;
+ if (!o(t)) throw TypeError("listener must be a function");
+ if (!this._events || !this._events[e]) return this;
+ if (a = (n = this._events[e]).length, r = -1, n === t || o(n.listener) && n.listener === t) delete this._events[e], this._events.removeListener && this.emit("removeListener", e, t);else if (i(n)) {
+ for (s = a; s-- > 0;) {
+ if (n[s] === t || n[s].listener && n[s].listener === t) {
+ r = s;
+ break;
+ }
+ }
+
+ if (r < 0) return this;
+ 1 === n.length ? (n.length = 0, delete this._events[e]) : n.splice(r, 1), this._events.removeListener && this.emit("removeListener", e, t);
+ }
+ return this;
+ }, r.prototype.removeAllListeners = function (e) {
+ var t, n;
+ if (!this._events) return this;
+ if (!this._events.removeListener) return 0 === arguments.length ? this._events = {} : this._events[e] && delete this._events[e], this;
+
+ if (0 === arguments.length) {
+ for (t in this._events) {
+ "removeListener" !== t && this.removeAllListeners(t);
+ }
+
+ return this.removeAllListeners("removeListener"), this._events = {}, this;
+ }
+
+ if (o(n = this._events[e])) this.removeListener(e, n);else if (n) for (; n.length;) {
+ this.removeListener(e, n[n.length - 1]);
+ }
+ return delete this._events[e], this;
+ }, r.prototype.listeners = function (e) {
+ return this._events && this._events[e] ? o(this._events[e]) ? [this._events[e]] : this._events[e].slice() : [];
+ }, r.prototype.listenerCount = function (e) {
+ if (this._events) {
+ var t = this._events[e];
+ if (o(t)) return 1;
+ if (t) return t.length;
+ }
+
+ return 0;
+ }, r.listenerCount = function (e, t) {
+ return e.listenerCount(t);
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ Object.defineProperty(t, "__esModule", {
+ value: !0
+ }), t.default = function (e) {
+ if (null != e) return e;
+ throw new Error("Got unexpected null or undefined");
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ e.exports = function () {
+ return "g" + Math.random().toString(16).substr(2);
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ function r(e) {
+ return function (e) {
+ if (Array.isArray(e)) {
+ for (var t = 0, n = new Array(e.length); t < e.length; t++) {
+ n[t] = e[t];
+ }
+
+ return n;
+ }
+ }(e) || function (e) {
+ if ((typeof Symbol === "function" ? Symbol.iterator : "@@iterator") in Object(e) || "[object Arguments]" === Object.prototype.toString.call(e)) return Array.from(e);
+ }(e) || function () {
+ throw new TypeError("Invalid attempt to spread non-iterable instance");
+ }();
+ }
+
+ function o(e, t, n) {
+ return t in e ? Object.defineProperty(e, t, {
+ value: n,
+ enumerable: !0,
+ configurable: !0,
+ writable: !0
+ }) : e[t] = n, e;
+ }
+
+ function i(e, t) {
+ for (var n = 0; n < t.length; n++) {
+ var r = t[n];
+ r.enumerable = r.enumerable || !1, r.configurable = !0, "value" in r && (r.writable = !0), Object.defineProperty(e, r.key, r);
+ }
+ }
+
+ var a = n(4),
+ s = n(32),
+ u = n(33),
+ c = n(3),
+ l = n(34);
+
+ function f(e, t) {
+ return -1 === String(window[e]).indexOf("[native code]") ? t : window[e];
+ }
+
+ var p = 5,
+ d = f("cancelIdleCallback", clearTimeout),
+ h = f("requestIdleCallback", function (e, t) {
+ var n = 3e3 * p;
+ return n > 500 && (n = 500), setTimeout(function () {
+ var t = l();
+ e({
+ didTimeout: !1,
+ timeRemaining: function timeRemaining() {
+ return 1 / 0;
+ }
+ });
+ var n = l();
+ p = (n - t) / 1e3;
+ }, n);
+ }),
+ m = function () {
+ function e(t) {
+ !function (e, t) {
+ if (!(e instanceof t)) throw new TypeError("Cannot call a class as a function");
+ }(this, e), this._cbs = new Map(), this._inspectables = new Map(), this._cid = 0, this._listeners = {}, this._buffer = [], this._flushHandle = null, this._callers = {}, this._paused = !1, this._wall = t, t.listen(this._handleMessage.bind(this));
+ }
+
+ var t, n, l;
+ return t = e, (n = [{
+ key: "inspect",
+ value: function value(e, t, n) {
+ var r = this._cid++;
+ this._cbs.set(r, function (e, t, r, o) {
+ t.length && s(e, t), r && o.length && s(r, o), r && (e[a.proto] = r), n(e);
+ }), this._wall.send({
+ type: "inspect",
+ callback: r,
+ path: t,
+ id: e
+ });
+ }
+ }, {
+ key: "call",
+ value: function value(e, t, n) {
+ var r = this._cid++;
+ this._cbs.set(r, n), this._wall.send({
+ type: "call",
+ callback: r,
+ args: t,
+ name: e
+ });
+ }
+ }, {
+ key: "onCall",
+ value: function value(e, t) {
+ if (this._callers[e]) throw new Error("only one call handler per call name allowed");
+ this._callers[e] = t;
+ }
+ }, {
+ key: "pause",
+ value: function value() {
+ this._wall.send({
+ type: "pause"
+ });
+ }
+ }, {
+ key: "resume",
+ value: function value() {
+ this._wall.send({
+ type: "resume"
+ });
+ }
+ }, {
+ key: "setInspectable",
+ value: function value(e, t) {
+ var n = this._inspectables.get(e);
+
+ n ? this._inspectables.set(e, function (e) {
+ for (var t = 1; t < arguments.length; t++) {
+ var n = null != arguments[t] ? arguments[t] : {},
+ r = Object.keys(n);
+ "function" == typeof Object.getOwnPropertySymbols && (r = r.concat(Object.getOwnPropertySymbols(n).filter(function (e) {
+ return Object.getOwnPropertyDescriptor(n, e).enumerable;
+ }))), r.forEach(function (t) {
+ o(e, t, n[t]);
+ });
+ }
+
+ return e;
+ }({}, n, t)) : this._inspectables.set(e, t);
+ }
+ }, {
+ key: "send",
+ value: function value(e, t) {
+ this._buffer.push({
+ evt: e,
+ data: t
+ }), this.scheduleFlush();
+ }
+ }, {
+ key: "scheduleFlush",
+ value: function value() {
+ if (!this._flushHandle && this._buffer.length) {
+ var e = this._paused ? 5e3 : 500;
+ this._flushHandle = h(this.flushBufferWhileIdle.bind(this), {
+ timeout: e
+ });
+ }
+ }
+ }, {
+ key: "cancelFlush",
+ value: function value() {
+ this._flushHandle && (d(this._flushHandle), this._flushHandle = null);
+ }
+ }, {
+ key: "flushBufferWhileIdle",
+ value: function value(e) {
+ this._flushHandle = null;
+
+ for (var t = this._paused ? 20 : 10, n = Math.round(this._buffer.length / t), r = this._paused ? 50 : 100; this._buffer.length && (e.timeRemaining() > 0 || e.didTimeout);) {
+ var o = Math.min(this._buffer.length, Math.max(r, n)),
+ i = this._buffer.splice(0, o);
+
+ this.flushBufferSlice(i);
+ }
+
+ this._buffer.length && this.scheduleFlush();
+ }
+ }, {
+ key: "flushBufferSlice",
+ value: function value(e) {
+ var t = this,
+ n = e.map(function (e) {
+ var n = e.evt,
+ r = e.data,
+ o = [],
+ i = u(r, o);
+ return o.length && t.setInspectable(r.id, r), {
+ type: "event",
+ evt: n,
+ data: i,
+ cleaned: o
+ };
+ });
+
+ this._wall.send({
+ type: "many-events",
+ events: n
+ });
+ }
+ }, {
+ key: "forget",
+ value: function value(e) {
+ this._inspectables.delete(e);
+ }
+ }, {
+ key: "on",
+ value: function value(e, t) {
+ this._listeners[e] ? this._listeners[e].push(t) : this._listeners[e] = [t];
+ }
+ }, {
+ key: "off",
+ value: function value(e, t) {
+ if (this._listeners[e]) {
+ var n = this._listeners[e].indexOf(t);
+
+ -1 !== n && this._listeners[e].splice(n, 1);
+ }
+ }
+ }, {
+ key: "once",
+ value: function value(e, t) {
+ var n = this;
+ this.on(e, function r() {
+ t.apply(this, arguments), n.off(e, r);
+ });
+ }
+ }, {
+ key: "_handleMessage",
+ value: function value(e) {
+ var t = this;
+ if ("resume" === e.type) return this._paused = !1, void this.scheduleFlush();
+ if ("pause" === e.type) return this._paused = !0, void this.cancelFlush();
+ if ("callback" !== e.type) {
+ if ("call" !== e.type) {
+ if ("inspect" !== e.type) {
+ if ("event" === e.type) {
+ e.cleaned && s(e.data, e.cleaned);
+ var n = this._listeners[e.evt],
+ o = e.data;
+ n && n.forEach(function (e) {
+ return e(o);
+ });
+ }
+
+ "many-events" === e.type && e.events.forEach(function (e) {
+ e.cleaned && s(e.data, e.cleaned);
+ var n = t._listeners[e.evt];
+ n && n.forEach(function (t) {
+ return t(e.data);
+ });
+ });
+ } else this._inspectResponse(e.id, e.path, e.callback);
+ } else this._handleCall(e.name, e.args, e.callback);
+ } else {
+ var i = this._cbs.get(e.id);
+
+ i && (i.apply(void 0, r(e.args)), this._cbs.delete(e.id));
+ }
+ }
+ }, {
+ key: "_handleCall",
+ value: function value(e, t, n) {
+ if (this._callers[e]) {
+ var r;
+ t = Array.isArray(t) ? t : [t];
+
+ try {
+ r = this._callers[e].apply(null, t);
+ } catch (e) {
+ return void console.error("Failed to call", e);
+ }
+
+ this._wall.send({
+ type: "callback",
+ id: n,
+ args: [r]
+ });
+ } else console.warn('unknown call: "' + e + '"');
+ }
+ }, {
+ key: "_inspectResponse",
+ value: function value(e, t, n) {
+ var r = this._inspectables.get(e),
+ o = {},
+ i = [],
+ a = null,
+ s = [];
+
+ if (r) {
+ var l = c(r, t),
+ f = !1,
+ p = "function" == typeof l;
+
+ if (l && "function" == typeof l[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]) {
+ var d = Object.create({}),
+ h = 0,
+ m = !0,
+ y = !1,
+ v = void 0;
+
+ try {
+ for (var g, b = l[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"](); !(m = (g = b.next()).done); m = !0) {
+ var _ = g.value;
+ if (h > 100) break;
+ d[h] = _, h++;
+ }
+ } catch (e) {
+ y = !0, v = e;
+ } finally {
+ try {
+ m || null == b.return || b.return();
+ } finally {
+ if (y) throw v;
+ }
+ }
+
+ l = d;
+ }
+
+ if (Object.getOwnPropertyNames(l).forEach(function (e) {
+ "__proto__" === e && (f = !0), (!p || "arguments" !== e && "callee" !== e && "caller" !== e) && (o[e] = u(l[e], i, [e]));
+ }), !f && l.__proto__ && "Object" !== l.constructor.name) {
+ var w = {},
+ S = "function" == typeof l.__proto__;
+ Object.getOwnPropertyNames(l.__proto__).forEach(function (e) {
+ (!S || "arguments" !== e && "callee" !== e && "caller" !== e) && (w[e] = u(l.__proto__[e], s, [e]));
+ }), a = w;
+ }
+ }
+
+ this._wall.send({
+ type: "callback",
+ id: n,
+ args: [o, i, a, s]
+ });
+ }
+ }]) && i(t.prototype, n), l && i(t, l), e;
+ }();
+
+ e.exports = m;
+ }, function (e, t, n) {
+ "use strict";
+
+ e.exports = n(15)() ? Symbol : n(16);
+ }, function (e, t, n) {
+ "use strict";
+
+ function r(e) {
+ return (r = "function" == typeof Symbol && "symbol" == typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") ? function (e) {
+ return typeof e;
+ } : function (e) {
+ return e && "function" == typeof Symbol && e.constructor === Symbol && e !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof e;
+ })(e);
+ }
+
+ e.exports = function () {
+ var e;
+ if ("function" != typeof Symbol) return !1;
+ e = Symbol("test symbol");
+
+ try {
+ String(e);
+ } catch (e) {
+ return !1;
+ }
+
+ return "symbol" === r(typeof Symbol === "function" ? Symbol.iterator : "@@iterator") || "object" === r(typeof Symbol === "function" ? Symbol.isConcatSpreadable : "@@isConcatSpreadable") && "object" === r(typeof Symbol === "function" ? Symbol.iterator : "@@iterator") && "object" === r(typeof Symbol === "function" ? Symbol.toPrimitive : "@@toPrimitive") && "object" === r(typeof Symbol === "function" ? Symbol.toStringTag : "@@toStringTag") && "object" === r(typeof Symbol === "function" ? Symbol.unscopables : "@@unscopables");
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ var r,
+ o,
+ _i,
+ a = n(17),
+ s = n(30),
+ u = Object.create,
+ c = Object.defineProperties,
+ l = Object.defineProperty,
+ f = Object.prototype,
+ p = u(null);
+
+ "function" == typeof Symbol && (r = Symbol);
+ var d,
+ h = (d = u(null), function (e) {
+ for (var t, n, r = 0; d[e + (r || "")];) {
+ ++r;
+ }
+
+ return d[e += r || ""] = !0, l(f, t = "@@" + e, a.gs(null, function (e) {
+ n || (n = !0, l(this, t, a(e)), n = !1);
+ })), t;
+ });
+ _i = function i(e) {
+ if (this instanceof _i) throw new TypeError("TypeError: Symbol is not a constructor");
+ return o(e);
+ }, e.exports = o = function e(t) {
+ var n;
+ if (this instanceof e) throw new TypeError("TypeError: Symbol is not a constructor");
+ return n = u(_i.prototype), t = void 0 === t ? "" : String(t), c(n, {
+ __description__: a("", t),
+ __name__: a("", h(t))
+ });
+ }, c(o, {
+ for: a(function (e) {
+ return p[e] ? p[e] : p[e] = o(String(e));
+ }),
+ keyFor: a(function (e) {
+ var t;
+
+ for (t in s(e), p) {
+ if (p[t] === e) return t;
+ }
+ }),
+ hasInstance: a("", r && r.hasInstance || o("hasInstance")),
+ isConcatSpreadable: a("", r && r.isConcatSpreadable || o("isConcatSpreadable")),
+ iterator: a("", r && r.iterator || o("iterator")),
+ match: a("", r && r.match || o("match")),
+ replace: a("", r && r.replace || o("replace")),
+ search: a("", r && r.search || o("search")),
+ species: a("", r && r.species || o("species")),
+ split: a("", r && r.split || o("split")),
+ toPrimitive: a("", r && r.toPrimitive || o("toPrimitive")),
+ toStringTag: a("", r && r.toStringTag || o("toStringTag")),
+ unscopables: a("", r && r.unscopables || o("unscopables"))
+ }), c(_i.prototype, {
+ constructor: a(o),
+ toString: a("", function () {
+ return this.__name__;
+ })
+ }), c(o.prototype, {
+ toString: a(function () {
+ return "Symbol (" + s(this).__description__ + ")";
+ }),
+ valueOf: a(function () {
+ return s(this);
+ })
+ }), l(o.prototype, o.toPrimitive, a("", function () {
+ return s(this);
+ })), l(o.prototype, o.toStringTag, a("c", "Symbol")), l(_i.prototype, o.toStringTag, a("c", o.prototype[o.toStringTag])), l(_i.prototype, o.toPrimitive, a("c", o.prototype[o.toPrimitive]));
+ }, function (e, t, n) {
+ "use strict";
+
+ var r = n(18),
+ o = n(25),
+ i = n(26),
+ a = n(27);
+
+ (e.exports = function (e, t) {
+ var n, i, s, u, c;
+ return arguments.length < 2 || "string" != typeof e ? (u = t, t = e, e = null) : u = arguments[2], null == e ? (n = s = !0, i = !1) : (n = a.call(e, "c"), i = a.call(e, "e"), s = a.call(e, "w")), c = {
+ value: t,
+ configurable: n,
+ enumerable: i,
+ writable: s
+ }, u ? r(o(u), c) : c;
+ }).gs = function (e, t, n) {
+ var s, u, c, l;
+ return "string" != typeof e ? (c = n, n = t, t = e, e = null) : c = arguments[3], null == t ? t = void 0 : i(t) ? null == n ? n = void 0 : i(n) || (c = n, n = void 0) : (c = t, t = n = void 0), null == e ? (s = !0, u = !1) : (s = a.call(e, "c"), u = a.call(e, "e")), l = {
+ get: t,
+ set: n,
+ configurable: s,
+ enumerable: u
+ }, c ? r(o(c), l) : l;
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ e.exports = n(19)() ? Object.assign : n(20);
+ }, function (e, t, n) {
+ "use strict";
+
+ e.exports = function () {
+ var e,
+ t = Object.assign;
+ return "function" == typeof t && (t(e = {
+ foo: "raz"
+ }, {
+ bar: "dwa"
+ }, {
+ trzy: "trzy"
+ }), e.foo + e.bar + e.trzy === "razdwatrzy");
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ var r = n(21),
+ o = n(24),
+ i = Math.max;
+
+ e.exports = function (e, t) {
+ var n,
+ a,
+ s,
+ u = i(arguments.length, 2);
+
+ for (e = Object(o(e)), s = function s(r) {
+ try {
+ e[r] = t[r];
+ } catch (e) {
+ n || (n = e);
+ }
+ }, a = 1; a < u; ++a) {
+ t = arguments[a], r(t).forEach(s);
+ }
+
+ if (void 0 !== n) throw n;
+ return e;
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ e.exports = n(22)() ? Object.keys : n(23);
+ }, function (e, t, n) {
+ "use strict";
+
+ e.exports = function () {
+ try {
+ return Object.keys("primitive"), !0;
+ } catch (e) {
+ return !1;
+ }
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ var r = Object.keys;
+
+ e.exports = function (e) {
+ return r(null == e ? e : Object(e));
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ e.exports = function (e) {
+ if (null == e) throw new TypeError("Cannot use null or undefined");
+ return e;
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ var r = Array.prototype.forEach,
+ o = Object.create;
+
+ e.exports = function (e) {
+ var t = o(null);
+ return r.call(arguments, function (e) {
+ null != e && function (e, t) {
+ var n;
+
+ for (n in e) {
+ t[n] = e[n];
+ }
+ }(Object(e), t);
+ }), t;
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ e.exports = function (e) {
+ return "function" == typeof e;
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ e.exports = n(28)() ? String.prototype.contains : n(29);
+ }, function (e, t, n) {
+ "use strict";
+
+ var r = "razdwatrzy";
+
+ e.exports = function () {
+ return "function" == typeof r.contains && !0 === r.contains("dwa") && !1 === r.contains("foo");
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ var r = String.prototype.indexOf;
+
+ e.exports = function (e) {
+ return r.call(this, e, arguments[1]) > -1;
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ var r = n(31);
+
+ e.exports = function (e) {
+ if (!r(e)) throw new TypeError(e + " is not a symbol");
+ return e;
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ function r(e) {
+ return (r = "function" == typeof Symbol && "symbol" == typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") ? function (e) {
+ return typeof e;
+ } : function (e) {
+ return e && "function" == typeof Symbol && e.constructor === Symbol && e !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof e;
+ })(e);
+ }
+
+ e.exports = function (e) {
+ return e && ("symbol" === r(e) || "Symbol" === e["@@toStringTag"]) || !1;
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ var r = n(4);
+
+ e.exports = function (e, t) {
+ t.forEach(function (t) {
+ var n = t.pop(),
+ o = t.reduce(function (e, t) {
+ return e ? e[t] : null;
+ }, e);
+
+ if (o && o[n]) {
+ var i = {};
+ i[r.name] = o[n].name, i[r.type] = o[n].type, i[r.meta] = o[n].meta, i[r.inspected] = !1, o[n] = i;
+ }
+ });
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ function r(e) {
+ return (r = "function" == typeof Symbol && "symbol" == typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") ? function (e) {
+ return typeof e;
+ } : function (e) {
+ return e && "function" == typeof Symbol && e.constructor === Symbol && e !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof e;
+ })(e);
+ }
+
+ var o = 2;
+
+ function i(e, t, n, r) {
+ var o = {};
+ return "array" !== e && "typed_array" !== e || (o.length = t.length), "iterator" !== e && "typed_array" !== e || (o.readOnly = !0), n.push(r), {
+ type: e,
+ meta: o,
+ name: t.constructor && "Object" !== t.constructor.name ? t.constructor.name : ""
+ };
+ }
+
+ e.exports = function e(t, n) {
+ var a = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : [],
+ s = arguments.length > 3 && void 0 !== arguments[3] ? arguments[3] : 0,
+ u = function (e) {
+ if (!e) return null;
+ var t = r(e);
+
+ if ("object" === t) {
+ if (e._reactFragment) return "react_fragment";
+ if (Array.isArray(e)) return "array";
+ if (ArrayBuffer.isView(e)) return e instanceof DataView ? "data_view" : "typed_array";
+ if (e instanceof ArrayBuffer) return "array_buffer";
+ if ("function" == typeof e[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]) return "iterator";
+ if ("[object Date]" === Object.prototype.toString.call(e)) return "date";
+ }
+
+ return t;
+ }(t);
+
+ switch (u) {
+ case "function":
+ return n.push(a), {
+ name: t.name,
+ type: "function"
+ };
+
+ case "string":
+ return t.length <= 500 ? t : t.slice(0, 500) + "...";
+
+ case "symbol":
+ return n.push(a), {
+ type: "symbol",
+ name: t.toString()
+ };
+
+ case "react_fragment":
+ return "A React Fragment";
+
+ case "array_buffer":
+ case "data_view":
+ return n.push(a), {
+ type: u,
+ name: "data_view" === u ? "DataView" : "ArrayBuffer",
+ meta: {
+ length: t.byteLength,
+ uninspectable: !0
+ }
+ };
+
+ case "array":
+ return s > o ? i(u, t, n, a) : t.map(function (t, r) {
+ return e(t, n, a.concat([r]), s + 1);
+ });
+
+ case "typed_array":
+ case "iterator":
+ return i(u, t, n, a);
+
+ case "date":
+ return n.push(a), {
+ name: t.toString(),
+ type: "date",
+ meta: {
+ uninspectable: !0
+ }
+ };
+
+ case "object":
+ if (s > o || t.constructor && "function" == typeof t.constructor && "Object" !== t.constructor.name) return i(u, t, n, a);
+ var c = {};
+
+ for (var l in t) {
+ c[l] = e(t[l], n, a.concat([l]), s + 1);
+ }
+
+ return c;
+
+ default:
+ return t;
+ }
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ var r,
+ o = n(35);
+ r = o.now ? function () {
+ return o.now();
+ } : function () {
+ return Date.now();
+ }, e.exports = r;
+ }, function (e, t, n) {
+ "use strict";
+
+ var r;
+ n(36).canUseDOM && (r = window.performance || window.msPerformance || window.webkitPerformance), e.exports = r || {};
+ }, function (e, t, n) {
+ "use strict";
+
+ var r = !("undefined" == typeof window || !window.document || !window.document.createElement),
+ o = {
+ canUseDOM: r,
+ canUseWorkers: "undefined" != typeof Worker,
+ canUseEventListeners: r && !(!window.addEventListener && !window.attachEvent),
+ canUseViewport: r && !!window.screen,
+ isInWorker: !r
+ };
+ e.exports = o;
+ }, function (e, t, n) {
+ "use strict";
+
+ function r(e, t) {
+ for (var n = 0; n < t.length; n++) {
+ var r = t[n];
+ r.enumerable = r.enumerable || !1, r.configurable = !0, "value" in r && (r.writable = !0), Object.defineProperty(e, r.key, r);
+ }
+ }
+
+ function o(e, t, n) {
+ return t in e ? Object.defineProperty(e, t, {
+ value: n,
+ enumerable: !0,
+ configurable: !0,
+ writable: !0
+ }) : e[t] = n, e;
+ }
+
+ function i(e) {
+ return (i = "function" == typeof Symbol && "symbol" == typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") ? function (e) {
+ return typeof e;
+ } : function (e) {
+ return e && "function" == typeof Symbol && e.constructor === Symbol && e !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof e;
+ })(e);
+ }
+
+ var a = "object" === ("undefined" == typeof performance ? "undefined" : i(performance)) && "function" == typeof performance.now ? function () {
+ return performance.now();
+ } : function () {
+ return Date.now();
+ },
+ s = function () {
+ function e(t) {
+ var n = this;
+ !function (e, t) {
+ if (!(e instanceof t)) throw new TypeError("Cannot call a class as a function");
+ }(this, e), o(this, "_committedNodes", new Set()), o(this, "_isRecording", !1), o(this, "_maxActualDuration", 0), o(this, "_recordingStartTime", 0), o(this, "_onIsRecording", function (e) {
+ n._committedNodes = new Set(), n._isRecording = e, n._recordingStartTime = e ? a() : 0, e && n._agent.emit("clearSnapshots");
+ }), o(this, "_onMountOrUpdate", function (e) {
+ n._isRecording && void 0 !== e.actualDuration && (n._committedNodes.add(e.id), n._maxActualDuration = Math.max(n._maxActualDuration, e.actualDuration));
+ }), o(this, "_onRootCommitted", function (e, t, r) {
+ n._isRecording && (n._takeCommitSnapshotForRoot(e, r), n._committedNodes = new Set(), n._maxActualDuration = 0);
+ }), o(this, "_onUnmount", function (e) {
+ n._committedNodes.delete(e);
+ }), this._agent = t, t.on("isRecording", this._onIsRecording), t.on("mount", this._onMountOrUpdate), t.on("rootCommitted", this._onRootCommitted), t.on("unmount", this._onUnmount), t.on("update", this._onMountOrUpdate);
+ }
+
+ var t, n, i;
+ return t = e, (n = [{
+ key: "_takeCommitSnapshotForRoot",
+ value: function value(e, t) {
+ var n = this,
+ r = {
+ memoizedInteractions: (null != t.memoizedInteractions ? Array.from(t.memoizedInteractions) : []).map(function (e) {
+ return {
+ name: e.name,
+ timestamp: e.timestamp - n._recordingStartTime
+ };
+ }),
+ committedNodes: Array.from(this._committedNodes),
+ commitTime: a() - this._recordingStartTime,
+ duration: this._maxActualDuration,
+ root: e
+ };
+
+ this._agent.emit("storeSnapshot", r);
+ }
+ }]) && r(t.prototype, n), i && r(t, i), e;
+ }();
+
+ e.exports = {
+ init: function init(e) {
+ return new s(e);
+ }
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ e.exports = function (e) {
+ if (!e.__REACT_DEVTOOLS_GLOBAL_HOOK__) {
+ var t = !1,
+ n = {
+ _renderers: {},
+ helpers: {},
+ checkDCE: function checkDCE(e) {
+ try {
+ Function.prototype.toString.call(e).indexOf("^_^") > -1 && (t = !0, setTimeout(function () {
+ throw new Error("React is running in production mode, but dead code elimination has not been applied. Read how to correctly configure React for production: https://fb.me/react-perf-use-the-production-build");
+ }));
+ } catch (e) {}
+ },
+ inject: function inject(e) {
+ var r = Math.random().toString(16).slice(2);
+ n._renderers[r] = e;
+ var o = t ? "deadcode" : function (e) {
+ try {
+ if ("string" == typeof e.version) return e.bundleType > 0 ? "development" : "production";
+ var t = Function.prototype.toString;
+
+ if (e.Mount && e.Mount._renderNewRootComponent) {
+ var n = t.call(e.Mount._renderNewRootComponent);
+ return 0 !== n.indexOf("function") ? "production" : -1 !== n.indexOf("storedMeasure") ? "development" : -1 !== n.indexOf("should be a pure function") ? -1 !== n.indexOf("NODE_ENV") ? "development" : -1 !== n.indexOf("development") ? "development" : -1 !== n.indexOf("true") ? "development" : -1 !== n.indexOf("nextElement") || -1 !== n.indexOf("nextComponent") ? "unminified" : "development" : -1 !== n.indexOf("nextElement") || -1 !== n.indexOf("nextComponent") ? "unminified" : "outdated";
+ }
+ } catch (e) {}
+
+ return "production";
+ }(e);
+ return n.emit("renderer", {
+ id: r,
+ renderer: e,
+ reactBuildType: o
+ }), r;
+ },
+ _listeners: {},
+ sub: function sub(e, t) {
+ return n.on(e, t), function () {
+ return n.off(e, t);
+ };
+ },
+ on: function on(e, t) {
+ n._listeners[e] || (n._listeners[e] = []), n._listeners[e].push(t);
+ },
+ off: function off(e, t) {
+ if (n._listeners[e]) {
+ var r = n._listeners[e].indexOf(t);
+
+ -1 !== r && n._listeners[e].splice(r, 1), n._listeners[e].length || (n._listeners[e] = null);
+ }
+ },
+ emit: function emit(e, t) {
+ n._listeners[e] && n._listeners[e].map(function (e) {
+ return e(t);
+ });
+ },
+ supportsFiber: !0,
+ _fiberRoots: {},
+ getFiberRoots: function getFiberRoots(e) {
+ var t = n._fiberRoots;
+ return t[e] || (t[e] = new Set()), t[e];
+ },
+ onCommitFiberUnmount: function onCommitFiberUnmount(e, t) {
+ n.helpers[e] && n.helpers[e].handleCommitFiberUnmount(t);
+ },
+ onCommitFiberRoot: function onCommitFiberRoot(e, t) {
+ var r = n.getFiberRoots(e),
+ o = t.current,
+ i = r.has(t),
+ a = null == o.memoizedState || null == o.memoizedState.element;
+ i || a ? i && a && r.delete(t) : r.add(t), n.helpers[e] && n.helpers[e].handleCommitFiberRoot(t);
+ }
+ };
+ Object.defineProperty(e, "__REACT_DEVTOOLS_GLOBAL_HOOK__", {
+ value: n
+ });
+ }
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ var r = n(40);
+
+ e.exports = function (e, t) {
+ var n = [e.sub("renderer-attached", function (e) {
+ var n = e.id,
+ r = (e.renderer, e.helpers);
+ t.setReactInternals(n, r), r.walkTree(t.onMounted.bind(t, n), t.addRoot.bind(t, n));
+ }), e.sub("mount", function (e) {
+ var n = e.renderer,
+ r = e.internalInstance,
+ o = e.data;
+ return t.onMounted(n, r, o);
+ }), e.sub("unmount", function (e) {
+ e.renderer;
+ var n = e.internalInstance;
+ return t.onUnmounted(n);
+ }), e.sub("update", function (e) {
+ e.renderer;
+ var n = e.internalInstance,
+ r = e.data;
+ return t.onUpdated(n, r);
+ }), e.sub("root", function (e) {
+ var n = e.renderer,
+ r = e.internalInstance;
+ return t.addRoot(n, r);
+ }), e.sub("rootCommitted", function (e) {
+ var n = e.renderer,
+ r = e.internalInstance,
+ o = e.data;
+ return t.rootCommitted(n, r, o);
+ }), e.sub("updateProfileTimes", function (e) {
+ e.renderer;
+ var n = e.internalInstance,
+ r = e.data;
+ return t.onUpdatedProfileTimes(n, r);
+ })];
+ r(e) && (e.emit("react-devtools", t), e.reactDevtoolsAgent = t, t.on("shutdown", function () {
+ n.forEach(function (e) {
+ return e();
+ }), e.reactDevtoolsAgent = null;
+ }));
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ var r = n(41);
+
+ e.exports = function (e) {
+ var t = window.React && window.React.__internals;
+
+ for (var n in t && 0 === Object.keys(e._renderers).length && e.inject(t), e._renderers) {
+ e.helpers[n] = r(e, n, e._renderers[n]), e.emit("renderer-attached", {
+ id: n,
+ renderer: e._renderers[n],
+ helpers: e.helpers[n]
+ });
+ }
+
+ e.on("renderer", function (t) {
+ var n = t.id,
+ o = t.renderer;
+ e.helpers[n] = r(e, n, o), e.emit("renderer-attached", {
+ id: n,
+ renderer: o,
+ helpers: e.helpers[n]
+ });
+ });
+ return e.on("shutdown", function t() {
+ for (var n in e.helpers) {
+ e.helpers[n].cleanup();
+ }
+
+ e.off("shutdown", t);
+ }), !0;
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ var r = n(42),
+ o = n(45),
+ i = n(46);
+
+ function a(e, t, n) {
+ var i = n ? o(e) : r(e);
+ i.children && Array.isArray(i.children) && i.children.forEach(function (e) {
+ return a(e, t, n);
+ }), t(e, i);
+ }
+
+ function s(e, t, n) {
+ var r = e[t];
+ return e[t] = function (e) {
+ var t = r.apply(this, arguments);
+ return n(t), t;
+ }, r;
+ }
+
+ function u(e, t, n) {
+ var r = e[t];
+ return e[t] = function (e) {
+ var t = r.apply(this, arguments);
+ return n.apply(this, arguments), t;
+ }, r;
+ }
+
+ function c(e, t) {
+ var n = {};
+
+ for (var r in t) {
+ n[r] = u(e, r, t[r]);
+ }
+
+ return n;
+ }
+
+ function l(e, t) {
+ for (var n in t) {
+ e[n] = t[n];
+ }
+ }
+
+ e.exports = function (e, t, n) {
+ var u,
+ f,
+ p,
+ d = new Map(),
+ h = {},
+ m = !n.Reconciler;
+ return "function" == typeof n.findFiberByHostInstance ? i(e, t, n) : (n.Mount.findNodeHandle && n.Mount.nativeTagToRootNodeID ? (h.getNativeFromReactElement = function (e) {
+ return n.Mount.findNodeHandle(e);
+ }, h.getReactElementFromNative = function (e) {
+ var t = n.Mount.nativeTagToRootNodeID(e);
+ return d.get(t);
+ }) : n.ComponentTree ? (h.getNativeFromReactElement = function (e) {
+ return n.ComponentTree.getNodeFromInstance(e);
+ }, h.getReactElementFromNative = function (e) {
+ return n.ComponentTree.getClosestInstanceFromNode(e);
+ }) : n.Mount.getID && n.Mount.getNode ? (h.getNativeFromReactElement = function (e) {
+ try {
+ return n.Mount.getNode(e._rootNodeID);
+ } catch (e) {
+ return;
+ }
+ }, h.getReactElementFromNative = function (e) {
+ for (var t = n.Mount.getID(e); e && e.parentNode && !t;) {
+ e = e.parentNode, t = n.Mount.getID(e);
+ }
+
+ return d.get(t);
+ }) : console.warn("Unknown react version (does not have getID), probably an unshimmed React Native"), n.Mount._renderNewRootComponent ? p = s(n.Mount, "_renderNewRootComponent", function (n) {
+ e.emit("root", {
+ renderer: t,
+ internalInstance: n
+ });
+ }) : n.Mount.renderComponent && (f = s(n.Mount, "renderComponent", function (n) {
+ e.emit("root", {
+ renderer: t,
+ internalInstance: n._reactInternalInstance
+ });
+ })), n.Component ? (console.error("You are using a version of React with limited support in this version of the devtools.\nPlease upgrade to use at least 0.13, or you can downgrade to use the old version of the devtools:\ninstructions here https://github.com/facebook/react-devtools/tree/devtools-next#how-do-i-use-this-for-react--013"), u = c(n.Component.Mixin, {
+ mountComponent: function mountComponent() {
+ var n = this;
+ d.set(this._rootNodeID, this), setTimeout(function () {
+ e.emit("mount", {
+ internalInstance: n,
+ data: o(n),
+ renderer: t
+ });
+ }, 0);
+ },
+ updateComponent: function updateComponent() {
+ var n = this;
+ setTimeout(function () {
+ e.emit("update", {
+ internalInstance: n,
+ data: o(n),
+ renderer: t
+ });
+ }, 0);
+ },
+ unmountComponent: function unmountComponent() {
+ e.emit("unmount", {
+ internalInstance: this,
+ renderer: t
+ }), d.delete(this._rootNodeID);
+ }
+ })) : n.Reconciler && (u = c(n.Reconciler, {
+ mountComponent: function mountComponent(n, o, i, a) {
+ var s = r(n);
+ d.set(n._rootNodeID, n), e.emit("mount", {
+ internalInstance: n,
+ data: s,
+ renderer: t
+ });
+ },
+ performUpdateIfNecessary: function performUpdateIfNecessary(n, o, i, a) {
+ e.emit("update", {
+ internalInstance: n,
+ data: r(n),
+ renderer: t
+ });
+ },
+ receiveComponent: function receiveComponent(n, o, i, a) {
+ e.emit("update", {
+ internalInstance: n,
+ data: r(n),
+ renderer: t
+ });
+ },
+ unmountComponent: function unmountComponent(n) {
+ e.emit("unmount", {
+ internalInstance: n,
+ renderer: t
+ }), d.delete(n._rootNodeID);
+ }
+ })), h.walkTree = function (e, t) {
+ !function (e, t, n, r) {
+ for (var o in e) {
+ a(e[o], t, r), n(e[o]);
+ }
+ }(n.Mount._instancesByReactRootID || n.Mount._instancesByContainerID, function (t, n) {
+ d.set(t._rootNodeID, t), e(t, n);
+ }, t, m);
+ }, h.cleanup = function () {
+ u && (n.Component ? l(n.Component.Mixin, u) : l(n.Reconciler, u)), p && (n.Mount._renderNewRootComponent = p), f && (n.Mount.renderComponent = f), u = null, p = null, f = null;
+ }, h.renderer = null, h);
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ function r(e, t, n) {
+ return t in e ? Object.defineProperty(e, t, {
+ value: n,
+ enumerable: !0,
+ configurable: !0,
+ writable: !0
+ }) : e[t] = n, e;
+ }
+
+ function o(e) {
+ return (o = "function" == typeof Symbol && "symbol" == typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") ? function (e) {
+ return typeof e;
+ } : function (e) {
+ return e && "function" == typeof Symbol && e.constructor === Symbol && e !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof e;
+ })(e);
+ }
+
+ var i = n(2),
+ a = n(5),
+ s = n(43);
+
+ function u(e, t, n) {
+ var r = t.pop(),
+ o = t.reduce(function (e, t) {
+ return e ? e[t] : null;
+ }, e);
+ o && (o[r] = n);
+ }
+
+ function c(e) {
+ var t = [];
+
+ for (var n in e) {
+ t.push(e[n]);
+ }
+
+ return t;
+ }
+
+ e.exports = function (e) {
+ var t = null,
+ n = null,
+ l = null,
+ f = null,
+ p = null,
+ d = null,
+ h = null,
+ m = null,
+ y = null,
+ v = null,
+ g = null,
+ b = null,
+ _ = "Native";
+ if ("object" !== o(e)) _ = "Text", g = e + "";else if (null === e._currentElement || !1 === e._currentElement) _ = "Empty";else if (e._renderedComponent) _ = "NativeWrapper", t = [e._renderedComponent], n = e._instance.props, l = e._instance.state, (f = e._instance.context) && 0 === Object.keys(f).length && (f = null);else if (e._renderedChildren) t = c(e._renderedChildren);else if (e._currentElement && e._currentElement.props) {
+ var w = e._currentElement.props.children,
+ S = [];
+ s(w, "", function (e, t) {
+ var n = o(t);
+ "string" !== n && "number" !== n || S.push(t);
+ }), t = S.length <= 1 ? S.length ? String(S[0]) : void 0 : S;
+ }
+
+ if (!n && e._currentElement && e._currentElement.props && (n = e._currentElement.props), null != e._currentElement && (h = e._currentElement.type, e._currentElement.key && (m = String(e._currentElement.key)), v = e._currentElement._source, y = e._currentElement.ref, "string" == typeof h ? (d = h, null != e._nativeNode && (b = e._nativeNode), null != e._hostNode && (b = e._hostNode)) : "function" == typeof h ? (_ = "Composite", d = a(h), e._renderedComponent && (e._currentElement.props === e._renderedComponent._currentElement || e._currentElement.type.isReactTopLevelWrapper) && (_ = "Wrapper"), null === d && (d = "No display name")) : "string" == typeof e._stringText ? (_ = "Text", g = e._stringText) : d = a(h)), e._instance) {
+ var E = e._instance,
+ O = E.forceUpdate || E.updater && E.updater.enqueueForceUpdate && function (e) {
+ E.updater.enqueueForceUpdate(this, e, "forceUpdate");
+ };
+
+ p = {
+ canUpdate: !0,
+ setState: E.setState && E.setState.bind(E),
+ setInProps: O && function (e, t, n, o) {
+ var a = e._currentElement;
+ e._currentElement = function (e) {
+ for (var t = 1; t < arguments.length; t++) {
+ var n = null != arguments[t] ? arguments[t] : {},
+ o = Object.keys(n);
+ "function" == typeof Object.getOwnPropertySymbols && (o = o.concat(Object.getOwnPropertySymbols(n).filter(function (e) {
+ return Object.getOwnPropertyDescriptor(n, e).enumerable;
+ }))), o.forEach(function (t) {
+ r(e, t, n[t]);
+ });
+ }
+
+ return e;
+ }({}, a, {
+ props: i(a.props, n, o)
+ }), t.call(e._instance);
+ }.bind(null, e, O),
+ setInState: E.forceUpdate && function (e, t, n) {
+ u(e.state, t, n), e.forceUpdate();
+ }.bind(null, E),
+ setInContext: O && function (e, t, n, r) {
+ u(e.context, n, r), t.call(e);
+ }.bind(null, E, O)
+ }, "function" == typeof h && (b = E), E._renderedChildren && (t = c(E._renderedChildren));
+ }
+
+ return "function" == typeof e.setNativeProps && (p = {
+ setNativeProps: function setNativeProps(t) {
+ e.setNativeProps(t);
+ }
+ }), {
+ nodeType: _,
+ type: h,
+ key: m,
+ ref: y,
+ source: v,
+ name: d,
+ props: n,
+ state: l,
+ context: f,
+ children: t,
+ text: g,
+ updater: p,
+ publicInstance: b
+ };
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ function r(e) {
+ return (r = "function" == typeof Symbol && "symbol" == typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") ? function (e) {
+ return typeof e;
+ } : function (e) {
+ return e && "function" == typeof Symbol && e.constructor === Symbol && e !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof e;
+ })(e);
+ }
+
+ var o = n(44),
+ i = ".",
+ a = ":",
+ s = "@@iterator",
+ u = "function" == typeof Symbol && (typeof Symbol === "function" ? Symbol.iterator : "@@iterator"),
+ c = "function" == typeof Symbol && (typeof Symbol === "function" ? Symbol.for : "@@for") && (typeof Symbol === "function" ? Symbol.for : "@@for")("react.element") || 60103;
+
+ function l(e, t) {
+ return "object" === r(e) && null !== e && null != e.key ? (n = e.key, o = {
+ "=": "=0",
+ ":": "=2"
+ }, "$" + ("" + n).replace(/[=:]/g, function (e) {
+ return o[e];
+ })) : t.toString(36);
+ var n, o;
+ }
+
+ e.exports = function e(t, n, f, p) {
+ var d,
+ h = r(t);
+ if ("undefined" !== h && "boolean" !== h || (t = null), null === t || "string" === h || "number" === h || "object" === h && t.$$typeof === c) return f(p, t, "" === n ? i + l(t, 0) : n), 1;
+ var m = 0,
+ y = "" === n ? i : n + a;
+ if (Array.isArray(t)) for (var v = 0; v < t.length; v++) {
+ m += e(d = t[v], y + l(d, v), f, p);
+ } else {
+ var g = u && t[u] || t[s];
+ if ("function" == typeof g) for (var b, _ = g.call(t), w = 0; !(b = _.next()).done;) {
+ m += e(d = b.value, y + l(d, w++), f, p);
+ } else if ("object" === h) {
+ var S = "" + t;
+ o(!1, "The React Devtools cannot render an object as a child. (found: %s).%s", "[object Object]" === S ? "object with keys {" + Object.keys(t).join(", ") + "}" : S, " If you meant to render a collection of children, use an array instead.");
+ }
+ }
+ return m;
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ e.exports = function (e, t, n, r, o, i, a, s) {
+ if (!e) {
+ var u;
+ if (void 0 === t) u = new Error("Minified exception occurred; use the non-minified dev environment for the full error message and additional helpful warnings.");else {
+ var c = [n, r, o, i, a, s],
+ l = 0;
+ (u = new Error(t.replace(/%s/g, function () {
+ return c[l++];
+ }))).name = "Invariant Violation";
+ }
+ throw u.framesToPop = 1, u;
+ }
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ var r = n(2);
+
+ function o(e, t, n) {
+ var r = t.pop(),
+ o = t.reduce(function (e, t) {
+ return e ? e[t] : null;
+ }, e);
+ o && (o[r] = n);
+ }
+
+ e.exports = function (e) {
+ var t = null,
+ n = e.props,
+ i = e.state,
+ a = e.context,
+ s = null,
+ u = null,
+ c = null,
+ l = null,
+ f = null,
+ p = null,
+ d = null,
+ h = "Native";
+ return e._renderedComponent ? (h = "Wrapper", t = [e._renderedComponent], a && 0 === Object.keys(a).length && (a = null)) : e._renderedChildren ? (u = e.constructor.displayName, t = function (e) {
+ var t = [];
+
+ for (var n in e) {
+ t.push(e[n]);
+ }
+
+ return t;
+ }(e._renderedChildren)) : "string" == typeof n.children && (u = e.constructor.displayName, t = n.children, h = "Native"), !n && e._currentElement && e._currentElement.props && (n = e._currentElement.props), e._currentElement && (c = e._currentElement.type, e._currentElement.key && (l = String(e._currentElement.key)), f = e._currentElement.ref, "string" == typeof c ? u = c : (h = "Composite", (u = c.displayName) || (u = "No display name"))), u || (u = e.constructor.displayName || "No display name", h = "Composite"), "string" == typeof n && (h = "Text", p = n, n = null, u = null), e.forceUpdate && (s = {
+ canUpdate: !0,
+ setState: e.setState.bind(e),
+ setInProps: e.forceUpdate && function (e, t, n) {
+ e.props = r(e.props, t, n), e.forceUpdate();
+ }.bind(null, e),
+ setInState: e.forceUpdate && function (e, t, n) {
+ o(e.state, t, n), e.forceUpdate();
+ }.bind(null, e),
+ setInContext: e.forceUpdate && function (e, t, n) {
+ o(e.context, t, n), e.forceUpdate();
+ }.bind(null, e)
+ }, d = e), {
+ nodeType: h,
+ type: c,
+ key: l,
+ ref: f,
+ source: null,
+ name: u,
+ props: n,
+ state: i,
+ context: a,
+ children: t,
+ text: p,
+ updater: s,
+ publicInstance: d
+ };
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ function r(e) {
+ return (r = "function" == typeof Symbol && "symbol" == typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") ? function (e) {
+ return typeof e;
+ } : function (e) {
+ return e && "function" == typeof Symbol && e.constructor === Symbol && e !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof e;
+ })(e);
+ }
+
+ var o = n(47),
+ i = n(2),
+ a = n(5);
+
+ e.exports = function (e, t, n) {
+ var s,
+ u = n.overrideProps,
+ c = (s = n.version, {
+ ReactTypeOfWork: o.gte(s, "16.6.0-beta.0") ? {
+ ClassComponent: 1,
+ ContextConsumer: 9,
+ ContextProvider: 10,
+ CoroutineComponent: -1,
+ CoroutineHandlerPhase: -1,
+ ForwardRef: 11,
+ Fragment: 7,
+ FunctionComponent: 0,
+ HostComponent: 5,
+ HostPortal: 4,
+ HostRoot: 3,
+ HostText: 6,
+ IncompleteClassComponent: 17,
+ IndeterminateComponent: 2,
+ LazyComponent: 16,
+ MemoComponent: 14,
+ Mode: 8,
+ Profiler: 12,
+ SimpleMemoComponent: 15,
+ SuspenseComponent: 13,
+ YieldComponent: -1
+ } : o.gte(s, "16.4.3-alpha") ? {
+ ClassComponent: 2,
+ ContextConsumer: 11,
+ ContextProvider: 12,
+ CoroutineComponent: -1,
+ CoroutineHandlerPhase: -1,
+ ForwardRef: 13,
+ Fragment: 9,
+ FunctionComponent: 0,
+ HostComponent: 7,
+ HostPortal: 6,
+ HostRoot: 5,
+ HostText: 8,
+ IncompleteClassComponent: -1,
+ IndeterminateComponent: 4,
+ LazyComponent: -1,
+ MemoComponent: -1,
+ Mode: 10,
+ Profiler: 15,
+ SimpleMemoComponent: -1,
+ SuspenseComponent: 16,
+ YieldComponent: -1
+ } : {
+ ClassComponent: 2,
+ ContextConsumer: 12,
+ ContextProvider: 13,
+ CoroutineComponent: 7,
+ CoroutineHandlerPhase: 8,
+ ForwardRef: 14,
+ Fragment: 10,
+ FunctionComponent: 1,
+ HostComponent: 5,
+ HostPortal: 4,
+ HostRoot: 3,
+ HostText: 6,
+ IncompleteClassComponent: -1,
+ IndeterminateComponent: 0,
+ LazyComponent: -1,
+ MemoComponent: -1,
+ Mode: 11,
+ Profiler: 15,
+ SimpleMemoComponent: -1,
+ SuspenseComponent: 16,
+ YieldComponent: 9
+ },
+ ReactSymbols: {
+ CONCURRENT_MODE_NUMBER: 60111,
+ CONCURRENT_MODE_SYMBOL_STRING: "Symbol(react.concurrent_mode)",
+ DEPRECATED_ASYNC_MODE_SYMBOL_STRING: "Symbol(react.async_mode)",
+ CONTEXT_CONSUMER_NUMBER: 60110,
+ CONTEXT_CONSUMER_SYMBOL_STRING: "Symbol(react.context)",
+ CONTEXT_PROVIDER_NUMBER: 60109,
+ CONTEXT_PROVIDER_SYMBOL_STRING: "Symbol(react.provider)",
+ FORWARD_REF_NUMBER: 60112,
+ FORWARD_REF_SYMBOL_STRING: "Symbol(react.forward_ref)",
+ MEMO_NUMBER: 60115,
+ MEMO_SYMBOL_STRING: "Symbol(react.memo)",
+ PROFILER_NUMBER: 60114,
+ PROFILER_SYMBOL_STRING: "Symbol(react.profiler)",
+ STRICT_MODE_NUMBER: 60108,
+ STRICT_MODE_SYMBOL_STRING: "Symbol(react.strict_mode)",
+ SUSPENSE_NUMBER: 60113,
+ SUSPENSE_SYMBOL_STRING: "Symbol(react.suspense)",
+ DEPRECATED_PLACEHOLDER_SYMBOL_STRING: "Symbol(react.placeholder)"
+ },
+ ReactTypeOfSideEffect: {
+ PerformedWork: 1
+ }
+ }),
+ l = c.ReactTypeOfWork,
+ f = c.ReactSymbols,
+ p = c.ReactTypeOfSideEffect.PerformedWork,
+ d = l.FunctionComponent,
+ h = l.ClassComponent,
+ m = l.ContextConsumer,
+ y = l.Fragment,
+ v = l.ForwardRef,
+ g = l.HostRoot,
+ b = l.HostPortal,
+ _ = l.HostComponent,
+ w = l.HostText,
+ S = l.IncompleteClassComponent,
+ E = l.IndeterminateComponent,
+ O = l.MemoComponent,
+ x = l.SimpleMemoComponent,
+ C = f.CONCURRENT_MODE_NUMBER,
+ I = f.CONCURRENT_MODE_SYMBOL_STRING,
+ N = f.DEPRECATED_ASYNC_MODE_SYMBOL_STRING,
+ T = f.CONTEXT_CONSUMER_NUMBER,
+ k = f.CONTEXT_CONSUMER_SYMBOL_STRING,
+ R = f.CONTEXT_PROVIDER_NUMBER,
+ j = f.CONTEXT_PROVIDER_SYMBOL_STRING,
+ M = f.PROFILER_NUMBER,
+ D = f.PROFILER_SYMBOL_STRING,
+ P = f.STRICT_MODE_NUMBER,
+ L = f.STRICT_MODE_SYMBOL_STRING,
+ A = f.SUSPENSE_NUMBER,
+ B = f.SUSPENSE_SYMBOL_STRING,
+ F = f.DEPRECATED_PLACEHOLDER_SYMBOL_STRING;
+
+ function U(e) {
+ var t = e.elementType,
+ n = e.type,
+ o = e.key,
+ s = e.ref,
+ c = e.tag,
+ l = e._debugSource,
+ f = null,
+ p = null,
+ m = null,
+ U = null,
+ H = null,
+ $ = null,
+ G = null,
+ W = null,
+ q = null,
+ Y = null,
+ K = null,
+ X = null,
+ J = null,
+ Z = null,
+ Q = !1,
+ ee = (c === d || c === x || c === v) && !!e.memoizedState,
+ te = n;
+
+ switch ("object" === r(n) && null !== n && "function" == typeof n.then && (te = n._reactResult), "function" == typeof u && ($ = {
+ canUpdate: !0,
+ setState: null,
+ setInProps: u.bind(null, e),
+ setInState: null,
+ setInContext: null
+ }), c) {
+ case h:
+ case d:
+ case S:
+ case E:
+ G = "Composite", W = a(te), f = e.stateNode, p = e.memoizedProps, m = e.memoizedState, null != f && (H = f.context) && 0 === Object.keys(H).length && (H = null);
+ var ne = f;
+ ne && ($ = {
+ canUpdate: !0,
+ setState: ne.setState && ne.setState.bind(ne),
+ setInProps: ne.forceUpdate && function (e, t, n) {
+ var r = e.stateNode;
+ e.pendingProps = i(r.props, t, n), e.alternate && (e.alternate.pendingProps = e.pendingProps), e.stateNode.forceUpdate();
+ }.bind(null, e),
+ setInState: ne.forceUpdate && function (e, t, n) {
+ z(e.state, t, n), e.forceUpdate();
+ }.bind(null, ne),
+ setInContext: ne.forceUpdate && function (e, t, n) {
+ z(e.context, t, n), e.forceUpdate();
+ }.bind(null, ne)
+ }), U = [];
+ break;
+
+ case v:
+ var re = a(te.render, "");
+ G = "Special", W = te.displayName || ("" !== re ? "ForwardRef(".concat(re, ")") : "ForwardRef"), p = e.memoizedProps, m = e.memoizedState, U = [];
+ break;
+
+ case g:
+ G = "Wrapper", U = [], K = e.stateNode.memoizedInteractions;
+ break;
+
+ case b:
+ G = "Portal", W = "ReactPortal", p = {
+ target: e.stateNode.containerInfo
+ }, U = [];
+ break;
+
+ case _:
+ G = "Native", W = (W = e.type).replace("topsecret-", ""), f = e.stateNode, U = "string" == typeof (p = e.memoizedProps).children || "number" == typeof p.children ? p.children.toString() : [], "function" == typeof e.stateNode.setNativeProps && ($ = {
+ setNativeProps: function setNativeProps(t) {
+ e.stateNode.setNativeProps(t);
+ }
+ });
+ break;
+
+ case w:
+ G = "Text", f = e.stateNode, q = e.memoizedProps;
+ break;
+
+ case y:
+ G = "Wrapper", U = [];
+ break;
+
+ case O:
+ case x:
+ if (G = "Composite", t.displayName) W = t.displayName;else {
+ var oe = n.displayName || n.name;
+ W = oe ? "Memo(".concat(oe, ")") : "Memo";
+ }
+ p = e.memoizedProps, m = e.memoizedState, U = [];
+ break;
+
+ default:
+ var ie = "object" === r(n) && null !== n ? n.$$typeof : n;
+
+ switch ("symbol" === r(ie) ? ie.toString() : ie) {
+ case C:
+ case I:
+ case N:
+ G = "Special", W = "ConcurrentMode", U = [];
+ break;
+
+ case R:
+ case j:
+ G = "Special", p = e.memoizedProps, Y = e.type._context || e.type.context, W = "".concat(Y.displayName || "Context", ".Provider"), U = [];
+ break;
+
+ case T:
+ case k:
+ G = "Special", p = e.memoizedProps, Y = e.type._context || e.type, W = "".concat(Y.displayName || "Context", ".Consumer"), U = [];
+ break;
+
+ case P:
+ case L:
+ G = "Special", W = "StrictMode", U = [];
+ break;
+
+ case A:
+ case B:
+ case F:
+ G = "Special", W = "Suspense", p = e.memoizedProps, U = [], Q = null !== e.memoizedState;
+ break;
+
+ case M:
+ case D:
+ G = "Special", p = e.memoizedProps, W = "Profiler(".concat(e.memoizedProps.id, ")"), U = [];
+ break;
+
+ default:
+ G = "Native", p = e.memoizedProps, W = "TODO_NOT_IMPLEMENTED_YET", U = [];
+ }
+
+ }
+
+ if (null !== p && void 0 !== r(e.elementType) && e.type !== e.elementType && (p = function (e, t) {
+ if (e && e.defaultProps) {
+ var n = _extends({}, t),
+ r = e.defaultProps;
+
+ for (var o in r) {
+ void 0 === n[o] && (n[o] = r[o]);
+ }
+
+ return n;
+ }
+
+ return t;
+ }(e.type, p)), Array.isArray(U)) if (Q) {
+ var ae = e.child,
+ se = ae.child,
+ ue = ae.sibling.child;
+ U.push(se), U.push(ue);
+ } else for (var ce = e.child; ce;) {
+ U.push(V(ce)), ce = ce.sibling;
+ }
+ return void 0 !== e.actualDuration && (X = e.actualDuration, J = e.actualStartTime, Z = e.treeBaseDuration), null === f && (f = {
+ props: p,
+ state: m,
+ type: n
+ }), {
+ nodeType: G,
+ type: n,
+ key: o,
+ ref: s,
+ source: l,
+ name: W,
+ props: p,
+ state: m,
+ context: H,
+ children: U,
+ text: q,
+ updater: $,
+ publicInstance: f,
+ memoizedInteractions: K,
+ actualDuration: X,
+ actualStartTime: J,
+ treeBaseDuration: Z,
+ containsHooks: ee
+ };
+ }
+
+ function z(e, t, n) {
+ var r = t.pop(),
+ o = t.reduce(function (e, t) {
+ return e ? e[t] : null;
+ }, e);
+ o && (o[r] = n);
+ }
+
+ var H = new Set();
+
+ function V(e) {
+ if (H.has(e)) return e;
+ var t = e.alternate;
+ return null != t && H.has(t) ? t : (H.add(e), e);
+ }
+
+ var $ = [];
+
+ function G() {
+ var t = $;
+ $ = [];
+
+ for (var n = 0; n < t.length; n++) {
+ var r = t[n];
+ e.emit(r.type, r);
+ }
+ }
+
+ function W(e) {
+ $.push({
+ internalInstance: V(e),
+ data: U(e),
+ renderer: t,
+ type: "mount"
+ }), e.tag === g && $.push({
+ internalInstance: V(e),
+ renderer: t,
+ type: "root"
+ });
+ }
+
+ function q(e, n) {
+ var r,
+ o,
+ i = U(e);
+ if (!n && !function (e, t) {
+ switch (t.tag) {
+ case h:
+ case d:
+ case m:
+ case O:
+ case x:
+ return (t.effectTag & p) === p;
+
+ default:
+ return e.memoizedProps !== t.memoizedProps || e.memoizedState !== t.memoizedState || e.ref !== t.ref;
+ }
+ }(e.alternate, e)) return r = e.alternate, o = e, void (void 0 === r.actualDuration || r.actualDuration === o.actualDuration && r.actualStartTime === o.actualStartTime && r.treeBaseDuration === o.treeBaseDuration || $.push({
+ internalInstance: V(e),
+ data: i,
+ renderer: t,
+ type: "updateProfileTimes"
+ }));
+ $.push({
+ internalInstance: V(e),
+ data: i,
+ renderer: t,
+ type: "update"
+ });
+ }
+
+ function Y(e) {
+ var n = e.tag === g,
+ r = V(e),
+ o = {
+ internalInstance: r,
+ renderer: t,
+ type: "unmount"
+ };
+ n ? $.push(o) : $.unshift(o), H.delete(r);
+ }
+
+ function K(e) {
+ $.push({
+ internalInstance: V(e),
+ data: U(e),
+ renderer: t,
+ type: "rootCommitted"
+ });
+ }
+
+ function X(e) {
+ var t = e;
+
+ e: for (;;) {
+ if (t.child) t.child.return = t, t = t.child;else {
+ if (W(t), t == e) return;
+
+ if (!t.sibling) {
+ for (; t.return;) {
+ if (W(t = t.return), t == e) return;
+
+ if (t.sibling) {
+ t.sibling.return = t.return, t = t.sibling;
+ continue e;
+ }
+ }
+
+ return;
+ }
+
+ t.sibling.return = t.return, t = t.sibling;
+ }
+ }
+ }
+
+ return {
+ getNativeFromReactElement: function getNativeFromReactElement(e) {
+ try {
+ var t = e;
+ return n.findHostInstanceByFiber(t);
+ } catch (e) {
+ return null;
+ }
+ },
+ getReactElementFromNative: function getReactElementFromNative(e) {
+ var t = n.findFiberByHostInstance(e);
+ return null != t ? V(t) : null;
+ },
+ handleCommitFiberRoot: function handleCommitFiberRoot(e) {
+ var t = e.current,
+ n = t.alternate;
+
+ if (n) {
+ var r = null != n.memoizedState && null != n.memoizedState.element,
+ o = null != t.memoizedState && null != t.memoizedState.element;
+ !r && o ? X(t) : r && o ? function e(t, n) {
+ if (t.tag === l.SuspenseComponent && null !== t.memoizedState) {
+ var r = t.child.sibling.child;
+ r.alternate ? e(r, r.alternate) : X(r), q(t, !1);
+ } else {
+ var o = !1;
+
+ if (t.child !== n.child) {
+ for (var i = t.child, a = n.child; i;) {
+ if (i.alternate) {
+ var s = i.alternate;
+ e(i, s), o || s === a || (o = !0);
+ } else X(i), o || (o = !0);
+
+ i = i.sibling, o || null == a || (a = a.sibling);
+ }
+
+ o || null == a || (o = !0);
+ }
+
+ q(t, o);
+ }
+ }(t, n) : r && !o && Y(t);
+ } else X(t);
+
+ K(t), G();
+ },
+ handleCommitFiberUnmount: function handleCommitFiberUnmount(e) {
+ Y(e);
+ },
+ cleanup: function cleanup() {},
+ walkTree: function walkTree() {
+ e.getFiberRoots(t).forEach(function (e) {
+ X(e.current), K(e.current);
+ }), G();
+ },
+ renderer: n
+ };
+ };
+ }, function (e, t, n) {
+ (function (n) {
+ function r(e) {
+ return (r = "function" == typeof Symbol && "symbol" == typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") ? function (e) {
+ return typeof e;
+ } : function (e) {
+ return e && "function" == typeof Symbol && e.constructor === Symbol && e !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof e;
+ })(e);
+ }
+
+ var o;
+ t = e.exports = K, o = "object" === (void 0 === n ? "undefined" : r(n)) && n.env && n.env.NODE_DEBUG && /\bsemver\b/i.test(n.env.NODE_DEBUG) ? function () {
+ var e = Array.prototype.slice.call(arguments, 0);
+ e.unshift("SEMVER"), console.log.apply(console, e);
+ } : function () {}, t.SEMVER_SPEC_VERSION = "2.0.0";
+ var i = 256,
+ a = Number.MAX_SAFE_INTEGER || 9007199254740991,
+ s = t.re = [],
+ u = t.src = [],
+ c = 0,
+ l = c++;
+ u[l] = "0|[1-9]\\d*";
+ var f = c++;
+ u[f] = "[0-9]+";
+ var p = c++;
+ u[p] = "\\d*[a-zA-Z-][a-zA-Z0-9-]*";
+ var d = c++;
+ u[d] = "(" + u[l] + ")\\.(" + u[l] + ")\\.(" + u[l] + ")";
+ var h = c++;
+ u[h] = "(" + u[f] + ")\\.(" + u[f] + ")\\.(" + u[f] + ")";
+ var m = c++;
+ u[m] = "(?:" + u[l] + "|" + u[p] + ")";
+ var y = c++;
+ u[y] = "(?:" + u[f] + "|" + u[p] + ")";
+ var v = c++;
+ u[v] = "(?:-(" + u[m] + "(?:\\." + u[m] + ")*))";
+ var g = c++;
+ u[g] = "(?:-?(" + u[y] + "(?:\\." + u[y] + ")*))";
+ var b = c++;
+ u[b] = "[0-9A-Za-z-]+";
+
+ var _ = c++;
+
+ u[_] = "(?:\\+(" + u[b] + "(?:\\." + u[b] + ")*))";
+ var w = c++,
+ S = "v?" + u[d] + u[v] + "?" + u[_] + "?";
+ u[w] = "^" + S + "$";
+ var E = "[v=\\s]*" + u[h] + u[g] + "?" + u[_] + "?",
+ O = c++;
+ u[O] = "^" + E + "$";
+ var x = c++;
+ u[x] = "((?:<|>)?=?)";
+ var C = c++;
+ u[C] = u[f] + "|x|X|\\*";
+ var I = c++;
+ u[I] = u[l] + "|x|X|\\*";
+ var N = c++;
+ u[N] = "[v=\\s]*(" + u[I] + ")(?:\\.(" + u[I] + ")(?:\\.(" + u[I] + ")(?:" + u[v] + ")?" + u[_] + "?)?)?";
+ var T = c++;
+ u[T] = "[v=\\s]*(" + u[C] + ")(?:\\.(" + u[C] + ")(?:\\.(" + u[C] + ")(?:" + u[g] + ")?" + u[_] + "?)?)?";
+ var k = c++;
+ u[k] = "^" + u[x] + "\\s*" + u[N] + "$";
+ var R = c++;
+ u[R] = "^" + u[x] + "\\s*" + u[T] + "$";
+ var j = c++;
+ u[j] = "(?:^|[^\\d])(\\d{1,16})(?:\\.(\\d{1,16}))?(?:\\.(\\d{1,16}))?(?:$|[^\\d])";
+ var M = c++;
+ u[M] = "(?:~>?)";
+ var D = c++;
+ u[D] = "(\\s*)" + u[M] + "\\s+", s[D] = new RegExp(u[D], "g");
+ var P = c++;
+ u[P] = "^" + u[M] + u[N] + "$";
+ var L = c++;
+ u[L] = "^" + u[M] + u[T] + "$";
+ var A = c++;
+ u[A] = "(?:\\^)";
+ var B = c++;
+ u[B] = "(\\s*)" + u[A] + "\\s+", s[B] = new RegExp(u[B], "g");
+ var F = c++;
+ u[F] = "^" + u[A] + u[N] + "$";
+ var U = c++;
+ u[U] = "^" + u[A] + u[T] + "$";
+ var z = c++;
+ u[z] = "^" + u[x] + "\\s*(" + E + ")$|^$";
+ var H = c++;
+ u[H] = "^" + u[x] + "\\s*(" + S + ")$|^$";
+ var V = c++;
+ u[V] = "(\\s*)" + u[x] + "\\s*(" + E + "|" + u[N] + ")", s[V] = new RegExp(u[V], "g");
+ var $ = c++;
+ u[$] = "^\\s*(" + u[N] + ")\\s+-\\s+(" + u[N] + ")\\s*$";
+ var G = c++;
+ u[G] = "^\\s*(" + u[T] + ")\\s+-\\s+(" + u[T] + ")\\s*$";
+ var W = c++;
+ u[W] = "(<|>)?=?\\s*\\*";
+
+ for (var q = 0; q < 35; q++) {
+ o(q, u[q]), s[q] || (s[q] = new RegExp(u[q]));
+ }
+
+ function Y(e, t) {
+ if (e instanceof K) return e;
+ if ("string" != typeof e) return null;
+ if (e.length > i) return null;
+ if (!(t ? s[O] : s[w]).test(e)) return null;
+
+ try {
+ return new K(e, t);
+ } catch (e) {
+ return null;
+ }
+ }
+
+ function K(e, t) {
+ if (e instanceof K) {
+ if (e.loose === t) return e;
+ e = e.version;
+ } else if ("string" != typeof e) throw new TypeError("Invalid Version: " + e);
+
+ if (e.length > i) throw new TypeError("version is longer than " + i + " characters");
+ if (!(this instanceof K)) return new K(e, t);
+ o("SemVer", e, t), this.loose = t;
+ var n = e.trim().match(t ? s[O] : s[w]);
+ if (!n) throw new TypeError("Invalid Version: " + e);
+ if (this.raw = e, this.major = +n[1], this.minor = +n[2], this.patch = +n[3], this.major > a || this.major < 0) throw new TypeError("Invalid major version");
+ if (this.minor > a || this.minor < 0) throw new TypeError("Invalid minor version");
+ if (this.patch > a || this.patch < 0) throw new TypeError("Invalid patch version");
+ n[4] ? this.prerelease = n[4].split(".").map(function (e) {
+ if (/^[0-9]+$/.test(e)) {
+ var t = +e;
+ if (t >= 0 && t < a) return t;
+ }
+
+ return e;
+ }) : this.prerelease = [], this.build = n[5] ? n[5].split(".") : [], this.format();
+ }
+
+ t.parse = Y, t.valid = function (e, t) {
+ var n = Y(e, t);
+ return n ? n.version : null;
+ }, t.clean = function (e, t) {
+ var n = Y(e.trim().replace(/^[=v]+/, ""), t);
+ return n ? n.version : null;
+ }, t.SemVer = K, K.prototype.format = function () {
+ return this.version = this.major + "." + this.minor + "." + this.patch, this.prerelease.length && (this.version += "-" + this.prerelease.join(".")), this.version;
+ }, K.prototype.toString = function () {
+ return this.version;
+ }, K.prototype.compare = function (e) {
+ return o("SemVer.compare", this.version, this.loose, e), e instanceof K || (e = new K(e, this.loose)), this.compareMain(e) || this.comparePre(e);
+ }, K.prototype.compareMain = function (e) {
+ return e instanceof K || (e = new K(e, this.loose)), J(this.major, e.major) || J(this.minor, e.minor) || J(this.patch, e.patch);
+ }, K.prototype.comparePre = function (e) {
+ if (e instanceof K || (e = new K(e, this.loose)), this.prerelease.length && !e.prerelease.length) return -1;
+ if (!this.prerelease.length && e.prerelease.length) return 1;
+ if (!this.prerelease.length && !e.prerelease.length) return 0;
+ var t = 0;
+
+ do {
+ var n = this.prerelease[t],
+ r = e.prerelease[t];
+ if (o("prerelease compare", t, n, r), void 0 === n && void 0 === r) return 0;
+ if (void 0 === r) return 1;
+ if (void 0 === n) return -1;
+ if (n !== r) return J(n, r);
+ } while (++t);
+ }, K.prototype.inc = function (e, t) {
+ switch (e) {
+ case "premajor":
+ this.prerelease.length = 0, this.patch = 0, this.minor = 0, this.major++, this.inc("pre", t);
+ break;
+
+ case "preminor":
+ this.prerelease.length = 0, this.patch = 0, this.minor++, this.inc("pre", t);
+ break;
+
+ case "prepatch":
+ this.prerelease.length = 0, this.inc("patch", t), this.inc("pre", t);
+ break;
+
+ case "prerelease":
+ 0 === this.prerelease.length && this.inc("patch", t), this.inc("pre", t);
+ break;
+
+ case "major":
+ 0 === this.minor && 0 === this.patch && 0 !== this.prerelease.length || this.major++, this.minor = 0, this.patch = 0, this.prerelease = [];
+ break;
+
+ case "minor":
+ 0 === this.patch && 0 !== this.prerelease.length || this.minor++, this.patch = 0, this.prerelease = [];
+ break;
+
+ case "patch":
+ 0 === this.prerelease.length && this.patch++, this.prerelease = [];
+ break;
+
+ case "pre":
+ if (0 === this.prerelease.length) this.prerelease = [0];else {
+ for (var n = this.prerelease.length; --n >= 0;) {
+ "number" == typeof this.prerelease[n] && (this.prerelease[n]++, n = -2);
+ }
+
+ -1 === n && this.prerelease.push(0);
+ }
+ t && (this.prerelease[0] === t ? isNaN(this.prerelease[1]) && (this.prerelease = [t, 0]) : this.prerelease = [t, 0]);
+ break;
+
+ default:
+ throw new Error("invalid increment argument: " + e);
+ }
+
+ return this.format(), this.raw = this.version, this;
+ }, t.inc = function (e, t, n, r) {
+ "string" == typeof n && (r = n, n = void 0);
+
+ try {
+ return new K(e, n).inc(t, r).version;
+ } catch (e) {
+ return null;
+ }
+ }, t.diff = function (e, t) {
+ if (te(e, t)) return null;
+ var n = Y(e),
+ r = Y(t);
+
+ if (n.prerelease.length || r.prerelease.length) {
+ for (var o in n) {
+ if (("major" === o || "minor" === o || "patch" === o) && n[o] !== r[o]) return "pre" + o;
+ }
+
+ return "prerelease";
+ }
+
+ for (var o in n) {
+ if (("major" === o || "minor" === o || "patch" === o) && n[o] !== r[o]) return o;
+ }
+ }, t.compareIdentifiers = J;
+ var X = /^[0-9]+$/;
+
+ function J(e, t) {
+ var n = X.test(e),
+ r = X.test(t);
+ return n && r && (e = +e, t = +t), n && !r ? -1 : r && !n ? 1 : e < t ? -1 : e > t ? 1 : 0;
+ }
+
+ function Z(e, t, n) {
+ return new K(e, n).compare(new K(t, n));
+ }
+
+ function Q(e, t, n) {
+ return Z(e, t, n) > 0;
+ }
+
+ function ee(e, t, n) {
+ return Z(e, t, n) < 0;
+ }
+
+ function te(e, t, n) {
+ return 0 === Z(e, t, n);
+ }
+
+ function ne(e, t, n) {
+ return 0 !== Z(e, t, n);
+ }
+
+ function re(e, t, n) {
+ return Z(e, t, n) >= 0;
+ }
+
+ function oe(e, t, n) {
+ return Z(e, t, n) <= 0;
+ }
+
+ function ie(e, t, n, o) {
+ var i;
+
+ switch (t) {
+ case "===":
+ "object" === r(e) && (e = e.version), "object" === r(n) && (n = n.version), i = e === n;
+ break;
+
+ case "!==":
+ "object" === r(e) && (e = e.version), "object" === r(n) && (n = n.version), i = e !== n;
+ break;
+
+ case "":
+ case "=":
+ case "==":
+ i = te(e, n, o);
+ break;
+
+ case "!=":
+ i = ne(e, n, o);
+ break;
+
+ case ">":
+ i = Q(e, n, o);
+ break;
+
+ case ">=":
+ i = re(e, n, o);
+ break;
+
+ case "<":
+ i = ee(e, n, o);
+ break;
+
+ case "<=":
+ i = oe(e, n, o);
+ break;
+
+ default:
+ throw new TypeError("Invalid operator: " + t);
+ }
+
+ return i;
+ }
+
+ function ae(e, t) {
+ if (e instanceof ae) {
+ if (e.loose === t) return e;
+ e = e.value;
+ }
+
+ if (!(this instanceof ae)) return new ae(e, t);
+ o("comparator", e, t), this.loose = t, this.parse(e), this.semver === se ? this.value = "" : this.value = this.operator + this.semver.version, o("comp", this);
+ }
+
+ t.rcompareIdentifiers = function (e, t) {
+ return J(t, e);
+ }, t.major = function (e, t) {
+ return new K(e, t).major;
+ }, t.minor = function (e, t) {
+ return new K(e, t).minor;
+ }, t.patch = function (e, t) {
+ return new K(e, t).patch;
+ }, t.compare = Z, t.compareLoose = function (e, t) {
+ return Z(e, t, !0);
+ }, t.rcompare = function (e, t, n) {
+ return Z(t, e, n);
+ }, t.sort = function (e, n) {
+ return e.sort(function (e, r) {
+ return t.compare(e, r, n);
+ });
+ }, t.rsort = function (e, n) {
+ return e.sort(function (e, r) {
+ return t.rcompare(e, r, n);
+ });
+ }, t.gt = Q, t.lt = ee, t.eq = te, t.neq = ne, t.gte = re, t.lte = oe, t.cmp = ie, t.Comparator = ae;
+ var se = {};
+
+ function ue(e, t) {
+ if (e instanceof ue) return e.loose === t ? e : new ue(e.raw, t);
+ if (e instanceof ae) return new ue(e.value, t);
+ if (!(this instanceof ue)) return new ue(e, t);
+ if (this.loose = t, this.raw = e, this.set = e.split(/\s*\|\|\s*/).map(function (e) {
+ return this.parseRange(e.trim());
+ }, this).filter(function (e) {
+ return e.length;
+ }), !this.set.length) throw new TypeError("Invalid SemVer Range: " + e);
+ this.format();
+ }
+
+ function ce(e) {
+ return !e || "x" === e.toLowerCase() || "*" === e;
+ }
+
+ function le(e, t, n, r, o, i, a, s, u, c, l, f, p) {
+ return ((t = ce(n) ? "" : ce(r) ? ">=" + n + ".0.0" : ce(o) ? ">=" + n + "." + r + ".0" : ">=" + t) + " " + (s = ce(u) ? "" : ce(c) ? "<" + (+u + 1) + ".0.0" : ce(l) ? "<" + u + "." + (+c + 1) + ".0" : f ? "<=" + u + "." + c + "." + l + "-" + f : "<=" + s)).trim();
+ }
+
+ function fe(e, t) {
+ for (var n = 0; n < e.length; n++) {
+ if (!e[n].test(t)) return !1;
+ }
+
+ if (t.prerelease.length) {
+ for (n = 0; n < e.length; n++) {
+ if (o(e[n].semver), e[n].semver !== se && e[n].semver.prerelease.length > 0) {
+ var r = e[n].semver;
+ if (r.major === t.major && r.minor === t.minor && r.patch === t.patch) return !0;
+ }
+ }
+
+ return !1;
+ }
+
+ return !0;
+ }
+
+ function pe(e, t, n) {
+ try {
+ t = new ue(t, n);
+ } catch (e) {
+ return !1;
+ }
+
+ return t.test(e);
+ }
+
+ function de(e, t, n, r) {
+ var o, i, a, s, u;
+
+ switch (e = new K(e, r), t = new ue(t, r), n) {
+ case ">":
+ o = Q, i = oe, a = ee, s = ">", u = ">=";
+ break;
+
+ case "<":
+ o = ee, i = re, a = Q, s = "<", u = "<=";
+ break;
+
+ default:
+ throw new TypeError('Must provide a hilo val of "<" or ">"');
+ }
+
+ if (pe(e, t, r)) return !1;
+
+ for (var c = 0; c < t.set.length; ++c) {
+ var l = t.set[c],
+ f = null,
+ p = null;
+ if (l.forEach(function (e) {
+ e.semver === se && (e = new ae(">=0.0.0")), f = f || e, p = p || e, o(e.semver, f.semver, r) ? f = e : a(e.semver, p.semver, r) && (p = e);
+ }), f.operator === s || f.operator === u) return !1;
+ if ((!p.operator || p.operator === s) && i(e, p.semver)) return !1;
+ if (p.operator === u && a(e, p.semver)) return !1;
+ }
+
+ return !0;
+ }
+
+ ae.prototype.parse = function (e) {
+ var t = this.loose ? s[z] : s[H],
+ n = e.match(t);
+ if (!n) throw new TypeError("Invalid comparator: " + e);
+ this.operator = n[1], "=" === this.operator && (this.operator = ""), n[2] ? this.semver = new K(n[2], this.loose) : this.semver = se;
+ }, ae.prototype.toString = function () {
+ return this.value;
+ }, ae.prototype.test = function (e) {
+ return o("Comparator.test", e, this.loose), this.semver === se || ("string" == typeof e && (e = new K(e, this.loose)), ie(e, this.operator, this.semver, this.loose));
+ }, ae.prototype.intersects = function (e, t) {
+ if (!(e instanceof ae)) throw new TypeError("a Comparator is required");
+ var n;
+ if ("" === this.operator) return n = new ue(e.value, t), pe(this.value, n, t);
+ if ("" === e.operator) return n = new ue(this.value, t), pe(e.semver, n, t);
+ var r = !(">=" !== this.operator && ">" !== this.operator || ">=" !== e.operator && ">" !== e.operator),
+ o = !("<=" !== this.operator && "<" !== this.operator || "<=" !== e.operator && "<" !== e.operator),
+ i = this.semver.version === e.semver.version,
+ a = !(">=" !== this.operator && "<=" !== this.operator || ">=" !== e.operator && "<=" !== e.operator),
+ s = ie(this.semver, "<", e.semver, t) && (">=" === this.operator || ">" === this.operator) && ("<=" === e.operator || "<" === e.operator),
+ u = ie(this.semver, ">", e.semver, t) && ("<=" === this.operator || "<" === this.operator) && (">=" === e.operator || ">" === e.operator);
+ return r || o || i && a || s || u;
+ }, t.Range = ue, ue.prototype.format = function () {
+ return this.range = this.set.map(function (e) {
+ return e.join(" ").trim();
+ }).join("||").trim(), this.range;
+ }, ue.prototype.toString = function () {
+ return this.range;
+ }, ue.prototype.parseRange = function (e) {
+ var t = this.loose;
+ e = e.trim(), o("range", e, t);
+ var n = t ? s[G] : s[$];
+ e = e.replace(n, le), o("hyphen replace", e), e = e.replace(s[V], "$1$2$3"), o("comparator trim", e, s[V]), e = (e = (e = e.replace(s[D], "$1~")).replace(s[B], "$1^")).split(/\s+/).join(" ");
+ var r = t ? s[z] : s[H],
+ i = e.split(" ").map(function (e) {
+ return function (e, t) {
+ return o("comp", e), e = function (e, t) {
+ return e.trim().split(/\s+/).map(function (e) {
+ return function (e, t) {
+ o("caret", e, t);
+ var n = t ? s[U] : s[F];
+ return e.replace(n, function (t, n, r, i, a) {
+ var s;
+ return o("caret", e, t, n, r, i, a), ce(n) ? s = "" : ce(r) ? s = ">=" + n + ".0.0 <" + (+n + 1) + ".0.0" : ce(i) ? s = "0" === n ? ">=" + n + "." + r + ".0 <" + n + "." + (+r + 1) + ".0" : ">=" + n + "." + r + ".0 <" + (+n + 1) + ".0.0" : a ? (o("replaceCaret pr", a), "-" !== a.charAt(0) && (a = "-" + a), s = "0" === n ? "0" === r ? ">=" + n + "." + r + "." + i + a + " <" + n + "." + r + "." + (+i + 1) : ">=" + n + "." + r + "." + i + a + " <" + n + "." + (+r + 1) + ".0" : ">=" + n + "." + r + "." + i + a + " <" + (+n + 1) + ".0.0") : (o("no pr"), s = "0" === n ? "0" === r ? ">=" + n + "." + r + "." + i + " <" + n + "." + r + "." + (+i + 1) : ">=" + n + "." + r + "." + i + " <" + n + "." + (+r + 1) + ".0" : ">=" + n + "." + r + "." + i + " <" + (+n + 1) + ".0.0"), o("caret return", s), s;
+ });
+ }(e, t);
+ }).join(" ");
+ }(e, t), o("caret", e), e = function (e, t) {
+ return e.trim().split(/\s+/).map(function (e) {
+ return function (e, t) {
+ var n = t ? s[L] : s[P];
+ return e.replace(n, function (t, n, r, i, a) {
+ var s;
+ return o("tilde", e, t, n, r, i, a), ce(n) ? s = "" : ce(r) ? s = ">=" + n + ".0.0 <" + (+n + 1) + ".0.0" : ce(i) ? s = ">=" + n + "." + r + ".0 <" + n + "." + (+r + 1) + ".0" : a ? (o("replaceTilde pr", a), "-" !== a.charAt(0) && (a = "-" + a), s = ">=" + n + "." + r + "." + i + a + " <" + n + "." + (+r + 1) + ".0") : s = ">=" + n + "." + r + "." + i + " <" + n + "." + (+r + 1) + ".0", o("tilde return", s), s;
+ });
+ }(e, t);
+ }).join(" ");
+ }(e, t), o("tildes", e), e = function (e, t) {
+ return o("replaceXRanges", e, t), e.split(/\s+/).map(function (e) {
+ return function (e, t) {
+ e = e.trim();
+ var n = t ? s[R] : s[k];
+ return e.replace(n, function (t, n, r, i, a, s) {
+ o("xRange", e, t, n, r, i, a, s);
+ var u = ce(r),
+ c = u || ce(i),
+ l = c || ce(a),
+ f = l;
+ return "=" === n && f && (n = ""), u ? t = ">" === n || "<" === n ? "<0.0.0" : "*" : n && f ? (c && (i = 0), l && (a = 0), ">" === n ? (n = ">=", c ? (r = +r + 1, i = 0, a = 0) : l && (i = +i + 1, a = 0)) : "<=" === n && (n = "<", c ? r = +r + 1 : i = +i + 1), t = n + r + "." + i + "." + a) : c ? t = ">=" + r + ".0.0 <" + (+r + 1) + ".0.0" : l && (t = ">=" + r + "." + i + ".0 <" + r + "." + (+i + 1) + ".0"), o("xRange return", t), t;
+ });
+ }(e, t);
+ }).join(" ");
+ }(e, t), o("xrange", e), e = function (e, t) {
+ return o("replaceStars", e, t), e.trim().replace(s[W], "");
+ }(e, t), o("stars", e), e;
+ }(e, t);
+ }).join(" ").split(/\s+/);
+ return this.loose && (i = i.filter(function (e) {
+ return !!e.match(r);
+ })), i = i.map(function (e) {
+ return new ae(e, t);
+ });
+ }, ue.prototype.intersects = function (e, t) {
+ if (!(e instanceof ue)) throw new TypeError("a Range is required");
+ return this.set.some(function (n) {
+ return n.every(function (n) {
+ return e.set.some(function (e) {
+ return e.every(function (e) {
+ return n.intersects(e, t);
+ });
+ });
+ });
+ });
+ }, t.toComparators = function (e, t) {
+ return new ue(e, t).set.map(function (e) {
+ return e.map(function (e) {
+ return e.value;
+ }).join(" ").trim().split(" ");
+ });
+ }, ue.prototype.test = function (e) {
+ if (!e) return !1;
+ "string" == typeof e && (e = new K(e, this.loose));
+
+ for (var t = 0; t < this.set.length; t++) {
+ if (fe(this.set[t], e)) return !0;
+ }
+
+ return !1;
+ }, t.satisfies = pe, t.maxSatisfying = function (e, t, n) {
+ var r = null,
+ o = null;
+
+ try {
+ var i = new ue(t, n);
+ } catch (e) {
+ return null;
+ }
+
+ return e.forEach(function (e) {
+ i.test(e) && (r && -1 !== o.compare(e) || (o = new K(r = e, n)));
+ }), r;
+ }, t.minSatisfying = function (e, t, n) {
+ var r = null,
+ o = null;
+
+ try {
+ var i = new ue(t, n);
+ } catch (e) {
+ return null;
+ }
+
+ return e.forEach(function (e) {
+ i.test(e) && (r && 1 !== o.compare(e) || (o = new K(r = e, n)));
+ }), r;
+ }, t.validRange = function (e, t) {
+ try {
+ return new ue(e, t).range || "*";
+ } catch (e) {
+ return null;
+ }
+ }, t.ltr = function (e, t, n) {
+ return de(e, t, "<", n);
+ }, t.gtr = function (e, t, n) {
+ return de(e, t, ">", n);
+ }, t.outside = de, t.prerelease = function (e, t) {
+ var n = Y(e, t);
+ return n && n.prerelease.length ? n.prerelease : null;
+ }, t.intersects = function (e, t, n) {
+ return e = new ue(e, n), t = new ue(t, n), e.intersects(t);
+ }, t.coerce = function (e) {
+ if (e instanceof K) return e;
+ if ("string" != typeof e) return null;
+ var t = e.match(s[j]);
+ return null == t ? null : Y((t[1] || "0") + "." + (t[2] || "0") + "." + (t[3] || "0"));
+ };
+ }).call(this, n(6));
+ }, function (e, t, n) {
+ "use strict";
+
+ (function (t) {
+ /*!
+ * The buffer module from node.js, for the browser.
+ *
+ * @author Feross Aboukhadijeh
+ * @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 = "🔍", 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;
+ });
+ }]);
+ });
+},169,[14],"node_modules\\react-devtools-core\\build\\backend.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var JSInspector = {
+ registerAgent: function registerAgent(type) {
+ if (global.__registerInspectorAgent) {
+ global.__registerInspectorAgent(type);
+ }
+ },
+ getTimestamp: function getTimestamp() {
+ return global.__inspectorTimestamp();
+ }
+ };
+ module.exports = JSInspector;
+},170,[],"node_modules\\react-native\\Libraries\\JSInspector\\JSInspector.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/inherits");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/createClass");
+
+ var InspectorAgent = _$$_REQUIRE(_dependencyMap[5], "InspectorAgent");
+
+ var JSInspector = _$$_REQUIRE(_dependencyMap[6], "JSInspector");
+
+ var XMLHttpRequest = _$$_REQUIRE(_dependencyMap[7], "XMLHttpRequest");
+
+ var Interceptor = function () {
+ function Interceptor(agent) {
+ _classCallCheck(this, Interceptor);
+
+ this._agent = agent;
+ this._requests = new Map();
+ }
+
+ _createClass(Interceptor, [{
+ key: "getData",
+ value: function getData(requestId) {
+ return this._requests.get(requestId);
+ }
+ }, {
+ key: "requestSent",
+ value: function requestSent(id, url, method, headers) {
+ var requestId = String(id);
+
+ this._requests.set(requestId, '');
+
+ var request = {
+ url: url,
+ method: method,
+ headers: headers,
+ initialPriority: 'Medium'
+ };
+ var event = {
+ requestId: requestId,
+ documentURL: '',
+ frameId: '1',
+ loaderId: '1',
+ request: request,
+ timestamp: JSInspector.getTimestamp(),
+ initiator: {
+ type: 'other'
+ },
+ type: 'Other'
+ };
+
+ this._agent.sendEvent('requestWillBeSent', event);
+ }
+ }, {
+ key: "responseReceived",
+ value: function responseReceived(id, url, status, headers) {
+ var requestId = String(id);
+ var response = {
+ url: url,
+ status: status,
+ statusText: String(status),
+ headers: headers,
+ requestHeaders: {},
+ mimeType: this._getMimeType(headers),
+ connectionReused: false,
+ connectionId: -1,
+ encodedDataLength: 0,
+ securityState: 'unknown'
+ };
+ var event = {
+ requestId: requestId,
+ frameId: '1',
+ loaderId: '1',
+ timestamp: JSInspector.getTimestamp(),
+ type: 'Other',
+ response: response
+ };
+
+ this._agent.sendEvent('responseReceived', event);
+ }
+ }, {
+ key: "dataReceived",
+ value: function dataReceived(id, data) {
+ var requestId = String(id);
+ var existingData = this._requests.get(requestId) || '';
+
+ this._requests.set(requestId, existingData.concat(data));
+
+ var event = {
+ requestId: requestId,
+ timestamp: JSInspector.getTimestamp(),
+ dataLength: data.length,
+ encodedDataLength: data.length
+ };
+
+ this._agent.sendEvent('dataReceived', event);
+ }
+ }, {
+ key: "loadingFinished",
+ value: function loadingFinished(id, encodedDataLength) {
+ var event = {
+ requestId: String(id),
+ timestamp: JSInspector.getTimestamp(),
+ encodedDataLength: encodedDataLength
+ };
+
+ this._agent.sendEvent('loadingFinished', event);
+ }
+ }, {
+ key: "loadingFailed",
+ value: function loadingFailed(id, error) {
+ var event = {
+ requestId: String(id),
+ timestamp: JSInspector.getTimestamp(),
+ type: 'Other',
+ errorText: error
+ };
+
+ this._agent.sendEvent('loadingFailed', event);
+ }
+ }, {
+ key: "_getMimeType",
+ value: function _getMimeType(headers) {
+ var contentType = headers['Content-Type'] || '';
+ return contentType.split(';')[0];
+ }
+ }]);
+
+ return Interceptor;
+ }();
+
+ var NetworkAgent = function (_InspectorAgent) {
+ _inherits(NetworkAgent, _InspectorAgent);
+
+ function NetworkAgent() {
+ _classCallCheck(this, NetworkAgent);
+
+ return _possibleConstructorReturn(this, _getPrototypeOf(NetworkAgent).apply(this, arguments));
+ }
+
+ _createClass(NetworkAgent, [{
+ key: "enable",
+ value: function enable(_ref) {
+ var maxResourceBufferSize = _ref.maxResourceBufferSize,
+ maxTotalBufferSize = _ref.maxTotalBufferSize;
+ this._interceptor = new Interceptor(this);
+ XMLHttpRequest.setInterceptor(this._interceptor);
+ }
+ }, {
+ key: "disable",
+ value: function disable() {
+ XMLHttpRequest.setInterceptor(null);
+ this._interceptor = null;
+ }
+ }, {
+ key: "getResponseBody",
+ value: function getResponseBody(_ref2) {
+ var requestId = _ref2.requestId;
+ return {
+ body: this.interceptor().getData(requestId),
+ base64Encoded: false
+ };
+ }
+ }, {
+ key: "interceptor",
+ value: function interceptor() {
+ if (this._interceptor) {
+ return this._interceptor;
+ } else {
+ throw Error('_interceptor can not be null');
+ }
+ }
+ }]);
+
+ return NetworkAgent;
+ }(InspectorAgent);
+
+ NetworkAgent.DOMAIN = 'Network';
+ module.exports = NetworkAgent;
+},171,[5,8,9,3,4,172,170,124],"node_modules\\react-native\\Libraries\\JSInspector\\NetworkAgent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var InspectorAgent = function () {
+ function InspectorAgent(eventSender) {
+ _classCallCheck(this, InspectorAgent);
+
+ this._eventSender = eventSender;
+ }
+
+ _createClass(InspectorAgent, [{
+ key: "sendEvent",
+ value: function sendEvent(name, params) {
+ this._eventSender(name, params);
+ }
+ }]);
+
+ return InspectorAgent;
+ }();
+
+ module.exports = InspectorAgent;
+},172,[3,4],"node_modules\\react-native\\Libraries\\JSInspector\\InspectorAgent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var invariant = _$$_REQUIRE(_dependencyMap[0], "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);
+
+ if (typeof callback !== 'function') {
+ invariant(false, 'View config not found for name %s.%s', name, typeof name[0] === 'string' && /[a-z]/.test(name[0]) ? ' Make sure to start component names with a capital letter.' : '');
+ }
+
+ viewConfigCallbacks.set(name, null);
+ viewConfig = callback();
+ processEventTypes(viewConfig);
+ viewConfigs.set(name, viewConfig);
+ } else {
+ viewConfig = viewConfigs.get(name);
+ }
+
+ invariant(viewConfig, 'View config not found for name %s', name);
+ return viewConfig;
+ };
+},173,[19],"node_modules\\react-native\\Libraries\\Renderer\\shims\\ReactNativeViewConfigRegistry.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var BatchedBridge = _$$_REQUIRE(_dependencyMap[0], "BatchedBridge");
+
+ var RCTEventEmitter = {
+ register: function register(eventEmitter) {
+ BatchedBridge.registerCallableModule('RCTEventEmitter', eventEmitter);
+ }
+ };
+ module.exports = RCTEventEmitter;
+},174,[41],"node_modules\\react-native\\Libraries\\EventEmitter\\RCTEventEmitter.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var deepDiffer = function deepDiffer(one, two) {
+ var maxDepth = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1;
+
+ if (maxDepth === 0) {
+ return true;
+ }
+
+ if (one === two) {
+ return false;
+ }
+
+ if (typeof one === 'function' && typeof two === 'function') {
+ return false;
+ }
+
+ if (typeof one !== 'object' || one === null) {
+ return one !== two;
+ }
+
+ if (typeof two !== 'object' || two === null) {
+ return true;
+ }
+
+ if (one.constructor !== two.constructor) {
+ return true;
+ }
+
+ if (Array.isArray(one)) {
+ var len = one.length;
+
+ if (two.length !== len) {
+ return true;
+ }
+
+ for (var ii = 0; ii < len; ii++) {
+ if (deepDiffer(one[ii], two[ii], maxDepth - 1)) {
+ return true;
+ }
+ }
+ } else {
+ for (var key in one) {
+ if (deepDiffer(one[key], two[key], maxDepth - 1)) {
+ return true;
+ }
+ }
+
+ for (var twoKey in two) {
+ if (one[twoKey] === undefined && two[twoKey] !== undefined) {
+ return true;
+ }
+ }
+ }
+
+ return false;
+ };
+
+ module.exports = deepDiffer;
+},175,[],"node_modules\\react-native\\Libraries\\Utilities\\differ\\deepDiffer.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var UIManager = _$$_REQUIRE(_dependencyMap[0], "UIManager");
+
+ var currentlyFocusedID = null;
+ var inputs = new Set();
+
+ function currentlyFocusedField() {
+ return currentlyFocusedID;
+ }
+
+ function focusTextInput(textFieldID) {
+ if (currentlyFocusedID !== textFieldID && textFieldID !== null) {
+ UIManager.focus(textFieldID);
+ }
+ }
+
+ function blurTextInput(textFieldID) {
+ if (currentlyFocusedID === textFieldID && textFieldID !== null) {
+ currentlyFocusedID = null;
+ UIManager.blur(textFieldID);
+ }
+ }
+
+ function setFocusedTextInput(textFieldID) {
+ if (currentlyFocusedID !== textFieldID && textFieldID !== null) {
+ currentlyFocusedID = textFieldID;
+ }
+ }
+
+ function clearFocusedTextInput(textFieldID) {
+ if (currentlyFocusedID === textFieldID && textFieldID !== null) {
+ currentlyFocusedID = null;
+ }
+ }
+
+ function registerInput(textFieldID) {
+ inputs.add(textFieldID);
+ }
+
+ function unregisterInput(textFieldID) {
+ inputs.delete(textFieldID);
+ }
+
+ function isTextInput(textFieldID) {
+ return inputs.has(textFieldID);
+ }
+
+ module.exports = {
+ currentlyFocusedField: currentlyFocusedField,
+ setFocusedTextInput: setFocusedTextInput,
+ clearFocusedTextInput: clearFocusedTextInput,
+ focusTextInput: focusTextInput,
+ blurTextInput: blurTextInput,
+ registerInput: registerInput,
+ unregisterInput: unregisterInput,
+ isTextInput: isTextInput
+ };
+},176,[71],"Libraries\\Components\\TextInput\\TextInputState.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ if (process.env.NODE_ENV === 'production') {
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "./cjs/scheduler-tracing.production.min.js");
+ } else {
+ module.exports = _$$_REQUIRE(_dependencyMap[1], "./cjs/scheduler-tracing.development.js");
+ }
+},177,[178,179],"node_modules\\react-native\\node_modules\\scheduler\\tracing.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ /** @license React v0.11.3
+ * scheduler-tracing.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+ 'use strict';
+
+ Object.defineProperty(exports, "__esModule", {
+ value: !0
+ });
+ var b = 0;
+ exports.__interactionsRef = null;
+ exports.__subscriberRef = null;
+
+ exports.unstable_clear = function (a) {
+ return a();
+ };
+
+ exports.unstable_getCurrent = function () {
+ return null;
+ };
+
+ exports.unstable_getThreadID = function () {
+ return ++b;
+ };
+
+ exports.unstable_trace = function (a, d, c) {
+ return c();
+ };
+
+ exports.unstable_wrap = function (a) {
+ return a;
+ };
+
+ exports.unstable_subscribe = function () {};
+
+ exports.unstable_unsubscribe = function () {};
+},178,[],"node_modules\\react-native\\node_modules\\scheduler\\cjs\\scheduler-tracing.production.min.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ /** @license React v0.11.3
+ * scheduler-tracing.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+ 'use strict';
+
+ if (process.env.NODE_ENV !== "production") {
+ (function () {
+ 'use strict';
+
+ Object.defineProperty(exports, '__esModule', {
+ value: true
+ });
+ var enableSchedulerTracing = true;
+ var DEFAULT_THREAD_ID = 0;
+ var interactionIDCounter = 0;
+ var threadIDCounter = 0;
+ exports.__interactionsRef = null;
+ exports.__subscriberRef = null;
+
+ if (enableSchedulerTracing) {
+ exports.__interactionsRef = {
+ current: new Set()
+ };
+ exports.__subscriberRef = {
+ current: null
+ };
+ }
+
+ function unstable_clear(callback) {
+ if (!enableSchedulerTracing) {
+ return callback();
+ }
+
+ var prevInteractions = exports.__interactionsRef.current;
+ exports.__interactionsRef.current = new Set();
+
+ try {
+ return callback();
+ } finally {
+ exports.__interactionsRef.current = prevInteractions;
+ }
+ }
+
+ function unstable_getCurrent() {
+ if (!enableSchedulerTracing) {
+ return null;
+ } else {
+ return exports.__interactionsRef.current;
+ }
+ }
+
+ function unstable_getThreadID() {
+ return ++threadIDCounter;
+ }
+
+ function unstable_trace(name, timestamp, callback) {
+ var threadID = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : DEFAULT_THREAD_ID;
+
+ if (!enableSchedulerTracing) {
+ return callback();
+ }
+
+ var interaction = {
+ __count: 1,
+ id: interactionIDCounter++,
+ name: name,
+ timestamp: timestamp
+ };
+ var prevInteractions = exports.__interactionsRef.current;
+ var interactions = new Set(prevInteractions);
+ interactions.add(interaction);
+ exports.__interactionsRef.current = interactions;
+ var subscriber = exports.__subscriberRef.current;
+ var returnValue = void 0;
+
+ try {
+ if (subscriber !== null) {
+ subscriber.onInteractionTraced(interaction);
+ }
+ } finally {
+ try {
+ if (subscriber !== null) {
+ subscriber.onWorkStarted(interactions, threadID);
+ }
+ } finally {
+ try {
+ returnValue = callback();
+ } finally {
+ exports.__interactionsRef.current = prevInteractions;
+
+ try {
+ if (subscriber !== null) {
+ subscriber.onWorkStopped(interactions, threadID);
+ }
+ } finally {
+ interaction.__count--;
+
+ if (subscriber !== null && interaction.__count === 0) {
+ subscriber.onInteractionScheduledWorkCompleted(interaction);
+ }
+ }
+ }
+ }
+ }
+
+ return returnValue;
+ }
+
+ function unstable_wrap(callback) {
+ var threadID = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : DEFAULT_THREAD_ID;
+
+ if (!enableSchedulerTracing) {
+ return callback;
+ }
+
+ var wrappedInteractions = exports.__interactionsRef.current;
+ var subscriber = exports.__subscriberRef.current;
+
+ if (subscriber !== null) {
+ subscriber.onWorkScheduled(wrappedInteractions, threadID);
+ }
+
+ wrappedInteractions.forEach(function (interaction) {
+ interaction.__count++;
+ });
+ var hasRun = false;
+
+ function wrapped() {
+ var prevInteractions = exports.__interactionsRef.current;
+ exports.__interactionsRef.current = wrappedInteractions;
+ subscriber = exports.__subscriberRef.current;
+
+ try {
+ var returnValue = void 0;
+
+ try {
+ if (subscriber !== null) {
+ subscriber.onWorkStarted(wrappedInteractions, threadID);
+ }
+ } finally {
+ try {
+ returnValue = callback.apply(undefined, arguments);
+ } finally {
+ exports.__interactionsRef.current = prevInteractions;
+
+ if (subscriber !== null) {
+ subscriber.onWorkStopped(wrappedInteractions, threadID);
+ }
+ }
+ }
+
+ return returnValue;
+ } finally {
+ if (!hasRun) {
+ hasRun = true;
+ wrappedInteractions.forEach(function (interaction) {
+ interaction.__count--;
+
+ if (subscriber !== null && interaction.__count === 0) {
+ subscriber.onInteractionScheduledWorkCompleted(interaction);
+ }
+ });
+ }
+ }
+ }
+
+ wrapped.cancel = function cancel() {
+ subscriber = exports.__subscriberRef.current;
+
+ try {
+ if (subscriber !== null) {
+ subscriber.onWorkCanceled(wrappedInteractions, threadID);
+ }
+ } finally {
+ wrappedInteractions.forEach(function (interaction) {
+ interaction.__count--;
+
+ if (subscriber && interaction.__count === 0) {
+ subscriber.onInteractionScheduledWorkCompleted(interaction);
+ }
+ });
+ }
+ };
+
+ return wrapped;
+ }
+
+ var subscribers = null;
+
+ if (enableSchedulerTracing) {
+ subscribers = new Set();
+ }
+
+ function unstable_subscribe(subscriber) {
+ if (enableSchedulerTracing) {
+ subscribers.add(subscriber);
+
+ if (subscribers.size === 1) {
+ exports.__subscriberRef.current = {
+ onInteractionScheduledWorkCompleted: onInteractionScheduledWorkCompleted,
+ onInteractionTraced: onInteractionTraced,
+ onWorkCanceled: onWorkCanceled,
+ onWorkScheduled: onWorkScheduled,
+ onWorkStarted: onWorkStarted,
+ onWorkStopped: onWorkStopped
+ };
+ }
+ }
+ }
+
+ function unstable_unsubscribe(subscriber) {
+ if (enableSchedulerTracing) {
+ subscribers.delete(subscriber);
+
+ if (subscribers.size === 0) {
+ exports.__subscriberRef.current = null;
+ }
+ }
+ }
+
+ function onInteractionTraced(interaction) {
+ var didCatchError = false;
+ var caughtError = null;
+ subscribers.forEach(function (subscriber) {
+ try {
+ subscriber.onInteractionTraced(interaction);
+ } catch (error) {
+ if (!didCatchError) {
+ didCatchError = true;
+ caughtError = error;
+ }
+ }
+ });
+
+ if (didCatchError) {
+ throw caughtError;
+ }
+ }
+
+ function onInteractionScheduledWorkCompleted(interaction) {
+ var didCatchError = false;
+ var caughtError = null;
+ subscribers.forEach(function (subscriber) {
+ try {
+ subscriber.onInteractionScheduledWorkCompleted(interaction);
+ } catch (error) {
+ if (!didCatchError) {
+ didCatchError = true;
+ caughtError = error;
+ }
+ }
+ });
+
+ if (didCatchError) {
+ throw caughtError;
+ }
+ }
+
+ function onWorkScheduled(interactions, threadID) {
+ var didCatchError = false;
+ var caughtError = null;
+ subscribers.forEach(function (subscriber) {
+ try {
+ subscriber.onWorkScheduled(interactions, threadID);
+ } catch (error) {
+ if (!didCatchError) {
+ didCatchError = true;
+ caughtError = error;
+ }
+ }
+ });
+
+ if (didCatchError) {
+ throw caughtError;
+ }
+ }
+
+ function onWorkStarted(interactions, threadID) {
+ var didCatchError = false;
+ var caughtError = null;
+ subscribers.forEach(function (subscriber) {
+ try {
+ subscriber.onWorkStarted(interactions, threadID);
+ } catch (error) {
+ if (!didCatchError) {
+ didCatchError = true;
+ caughtError = error;
+ }
+ }
+ });
+
+ if (didCatchError) {
+ throw caughtError;
+ }
+ }
+
+ function onWorkStopped(interactions, threadID) {
+ var didCatchError = false;
+ var caughtError = null;
+ subscribers.forEach(function (subscriber) {
+ try {
+ subscriber.onWorkStopped(interactions, threadID);
+ } catch (error) {
+ if (!didCatchError) {
+ didCatchError = true;
+ caughtError = error;
+ }
+ }
+ });
+
+ if (didCatchError) {
+ throw caughtError;
+ }
+ }
+
+ function onWorkCanceled(interactions, threadID) {
+ var didCatchError = false;
+ var caughtError = null;
+ subscribers.forEach(function (subscriber) {
+ try {
+ subscriber.onWorkCanceled(interactions, threadID);
+ } catch (error) {
+ if (!didCatchError) {
+ didCatchError = true;
+ caughtError = error;
+ }
+ }
+ });
+
+ if (didCatchError) {
+ throw caughtError;
+ }
+ }
+
+ exports.unstable_clear = unstable_clear;
+ exports.unstable_getCurrent = unstable_getCurrent;
+ exports.unstable_getThreadID = unstable_getThreadID;
+ exports.unstable_trace = unstable_trace;
+ exports.unstable_wrap = unstable_wrap;
+ exports.unstable_subscribe = unstable_subscribe;
+ exports.unstable_unsubscribe = unstable_unsubscribe;
+ })();
+ }
+},179,[],"node_modules\\react-native\\node_modules\\scheduler\\cjs\\scheduler-tracing.development.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ if (process.env.NODE_ENV === 'production') {
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "./cjs/scheduler.production.min.js");
+ } else {
+ module.exports = _$$_REQUIRE(_dependencyMap[1], "./cjs/scheduler.development.js");
+ }
+},180,[181,182],"node_modules\\react-native\\node_modules\\scheduler\\index.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ /** @license React v0.11.3
+ * scheduler.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+ 'use strict';
+
+ Object.defineProperty(exports, "__esModule", {
+ value: !0
+ });
+ var d = null,
+ f = !1,
+ h = 3,
+ k = -1,
+ l = -1,
+ m = !1,
+ n = !1;
+
+ function p() {
+ if (!m) {
+ var a = d.expirationTime;
+ n ? q() : n = !0;
+
+ _r(t, a);
+ }
+ }
+
+ function u() {
+ var a = d,
+ b = d.next;
+ if (d === b) d = null;else {
+ var c = d.previous;
+ d = c.next = b;
+ b.previous = c;
+ }
+ a.next = a.previous = null;
+ c = a.callback;
+ b = a.expirationTime;
+ a = a.priorityLevel;
+ var e = h,
+ Q = l;
+ h = a;
+ l = b;
+
+ try {
+ var g = c();
+ } finally {
+ h = e, l = Q;
+ }
+
+ if ("function" === typeof g) if (g = {
+ callback: g,
+ priorityLevel: a,
+ expirationTime: b,
+ next: null,
+ previous: null
+ }, null === d) d = g.next = g.previous = g;else {
+ c = null;
+ a = d;
+
+ do {
+ if (a.expirationTime >= b) {
+ c = a;
+ break;
+ }
+
+ a = a.next;
+ } while (a !== d);
+
+ null === c ? c = d : c === d && (d = g, p());
+ b = c.previous;
+ b.next = c.previous = g;
+ g.next = c;
+ g.previous = b;
+ }
+ }
+
+ function v() {
+ if (-1 === k && null !== d && 1 === d.priorityLevel) {
+ m = !0;
+
+ try {
+ do {
+ u();
+ } while (null !== d && 1 === d.priorityLevel);
+ } finally {
+ m = !1, null !== d ? p() : n = !1;
+ }
+ }
+ }
+
+ function t(a) {
+ m = !0;
+ var b = f;
+ f = a;
+
+ try {
+ if (a) for (; null !== d;) {
+ var c = exports.unstable_now();
+
+ if (d.expirationTime <= c) {
+ do {
+ u();
+ } while (null !== d && d.expirationTime <= c);
+ } else break;
+ } else if (null !== d) {
+ do {
+ u();
+ } while (null !== d && !w());
+ }
+ } finally {
+ m = !1, f = b, null !== d ? p() : n = !1, v();
+ }
+ }
+
+ var x = Date,
+ y = "function" === typeof setTimeout ? setTimeout : void 0,
+ z = "function" === typeof clearTimeout ? clearTimeout : void 0,
+ A = "function" === typeof requestAnimationFrame ? requestAnimationFrame : void 0,
+ B = "function" === typeof cancelAnimationFrame ? cancelAnimationFrame : void 0,
+ C,
+ D;
+
+ function E(a) {
+ C = A(function (b) {
+ z(D);
+ a(b);
+ });
+ D = y(function () {
+ B(C);
+ a(exports.unstable_now());
+ }, 100);
+ }
+
+ if ("object" === typeof performance && "function" === typeof performance.now) {
+ var F = performance;
+
+ exports.unstable_now = function () {
+ return F.now();
+ };
+ } else exports.unstable_now = function () {
+ return x.now();
+ };
+
+ var _r,
+ q,
+ w,
+ G = null;
+
+ "undefined" !== typeof window ? G = window : "undefined" !== typeof global && (G = global);
+
+ if (G && G._schedMock) {
+ var H = G._schedMock;
+ _r = H[0];
+ q = H[1];
+ w = H[2];
+ exports.unstable_now = H[3];
+ } else if ("undefined" === typeof window || "function" !== typeof MessageChannel) {
+ var I = null,
+ J = function J(a) {
+ if (null !== I) try {
+ I(a);
+ } finally {
+ I = null;
+ }
+ };
+
+ _r = function r(a) {
+ null !== I ? setTimeout(_r, 0, a) : (I = a, setTimeout(J, 0, !1));
+ };
+
+ q = function q() {
+ I = null;
+ };
+
+ w = function w() {
+ return !1;
+ };
+ } else {
+ "undefined" !== typeof console && ("function" !== typeof A && console.error("This browser doesn't support requestAnimationFrame. Make sure that you load a polyfill in older browsers. https://fb.me/react-polyfills"), "function" !== typeof B && console.error("This browser doesn't support cancelAnimationFrame. Make sure that you load a polyfill in older browsers. https://fb.me/react-polyfills"));
+ var K = null,
+ L = !1,
+ M = -1,
+ N = !1,
+ O = !1,
+ P = 0,
+ R = 33,
+ S = 33;
+
+ w = function w() {
+ return P <= exports.unstable_now();
+ };
+
+ var T = new MessageChannel(),
+ U = T.port2;
+
+ T.port1.onmessage = function () {
+ L = !1;
+ var a = K,
+ b = M;
+ K = null;
+ M = -1;
+ var c = exports.unstable_now(),
+ e = !1;
+ if (0 >= P - c) if (-1 !== b && b <= c) e = !0;else {
+ N || (N = !0, E(V));
+ K = a;
+ M = b;
+ return;
+ }
+
+ if (null !== a) {
+ O = !0;
+
+ try {
+ a(e);
+ } finally {
+ O = !1;
+ }
+ }
+ };
+
+ var V = function V(a) {
+ if (null !== K) {
+ E(V);
+ var b = a - P + S;
+ b < S && R < S ? (8 > b && (b = 8), S = b < R ? R : b) : R = b;
+ P = a + S;
+ L || (L = !0, U.postMessage(void 0));
+ } else N = !1;
+ };
+
+ _r = function _r(a, b) {
+ K = a;
+ M = b;
+ O || 0 > b ? U.postMessage(void 0) : N || (N = !0, E(V));
+ };
+
+ q = function q() {
+ K = null;
+ L = !1;
+ M = -1;
+ };
+ }
+
+ exports.unstable_ImmediatePriority = 1;
+ exports.unstable_UserBlockingPriority = 2;
+ exports.unstable_NormalPriority = 3;
+ exports.unstable_IdlePriority = 5;
+ exports.unstable_LowPriority = 4;
+
+ exports.unstable_runWithPriority = function (a, b) {
+ switch (a) {
+ case 1:
+ case 2:
+ case 3:
+ case 4:
+ case 5:
+ break;
+
+ default:
+ a = 3;
+ }
+
+ var c = h,
+ e = k;
+ h = a;
+ k = exports.unstable_now();
+
+ try {
+ return b();
+ } finally {
+ h = c, k = e, v();
+ }
+ };
+
+ exports.unstable_scheduleCallback = function (a, b) {
+ var c = -1 !== k ? k : exports.unstable_now();
+ if ("object" === typeof b && null !== b && "number" === typeof b.timeout) b = c + b.timeout;else switch (h) {
+ case 1:
+ b = c + -1;
+ break;
+
+ case 2:
+ b = c + 250;
+ break;
+
+ case 5:
+ b = c + 1073741823;
+ break;
+
+ case 4:
+ b = c + 1E4;
+ break;
+
+ default:
+ b = c + 5E3;
+ }
+ a = {
+ callback: a,
+ priorityLevel: h,
+ expirationTime: b,
+ next: null,
+ previous: null
+ };
+ if (null === d) d = a.next = a.previous = a, p();else {
+ c = null;
+ var e = d;
+
+ do {
+ if (e.expirationTime > b) {
+ c = e;
+ break;
+ }
+
+ e = e.next;
+ } while (e !== d);
+
+ null === c ? c = d : c === d && (d = a, p());
+ b = c.previous;
+ b.next = c.previous = a;
+ a.next = c;
+ a.previous = b;
+ }
+ return a;
+ };
+
+ exports.unstable_cancelCallback = function (a) {
+ var b = a.next;
+
+ if (null !== b) {
+ if (b === a) d = null;else {
+ a === d && (d = b);
+ var c = a.previous;
+ c.next = b;
+ b.previous = c;
+ }
+ a.next = a.previous = null;
+ }
+ };
+
+ exports.unstable_wrapCallback = function (a) {
+ var b = h;
+ return function () {
+ var c = h,
+ e = k;
+ h = b;
+ k = exports.unstable_now();
+
+ try {
+ return a.apply(this, arguments);
+ } finally {
+ h = c, k = e, v();
+ }
+ };
+ };
+
+ exports.unstable_getCurrentPriorityLevel = function () {
+ return h;
+ };
+
+ exports.unstable_shouldYield = function () {
+ return !f && (null !== d && d.expirationTime < l || w());
+ };
+},181,[],"node_modules\\react-native\\node_modules\\scheduler\\cjs\\scheduler.production.min.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ /** @license React v0.11.3
+ * scheduler.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+ 'use strict';
+
+ if (process.env.NODE_ENV !== "production") {
+ (function () {
+ 'use strict';
+
+ Object.defineProperty(exports, '__esModule', {
+ value: true
+ });
+ var ImmediatePriority = 1;
+ var UserBlockingPriority = 2;
+ var NormalPriority = 3;
+ var LowPriority = 4;
+ var IdlePriority = 5;
+ var maxSigned31BitInt = 1073741823;
+ var IMMEDIATE_PRIORITY_TIMEOUT = -1;
+ var USER_BLOCKING_PRIORITY = 250;
+ var NORMAL_PRIORITY_TIMEOUT = 5000;
+ var LOW_PRIORITY_TIMEOUT = 10000;
+ var IDLE_PRIORITY = maxSigned31BitInt;
+ var firstCallbackNode = null;
+ var currentDidTimeout = false;
+ var currentPriorityLevel = NormalPriority;
+ var currentEventStartTime = -1;
+ var currentExpirationTime = -1;
+ var isExecutingCallback = false;
+ var isHostCallbackScheduled = false;
+ var hasNativePerformanceNow = typeof performance === 'object' && typeof performance.now === 'function';
+
+ function ensureHostCallbackIsScheduled() {
+ if (isExecutingCallback) {
+ return;
+ }
+
+ var expirationTime = firstCallbackNode.expirationTime;
+
+ if (!isHostCallbackScheduled) {
+ isHostCallbackScheduled = true;
+ } else {
+ cancelHostCallback();
+ }
+
+ _requestHostCallback(flushWork, expirationTime);
+ }
+
+ function flushFirstCallback() {
+ var flushedNode = firstCallbackNode;
+ var next = firstCallbackNode.next;
+
+ if (firstCallbackNode === next) {
+ firstCallbackNode = null;
+ next = null;
+ } else {
+ var lastCallbackNode = firstCallbackNode.previous;
+ firstCallbackNode = lastCallbackNode.next = next;
+ next.previous = lastCallbackNode;
+ }
+
+ flushedNode.next = flushedNode.previous = null;
+ var callback = flushedNode.callback;
+ var expirationTime = flushedNode.expirationTime;
+ var priorityLevel = flushedNode.priorityLevel;
+ var previousPriorityLevel = currentPriorityLevel;
+ var previousExpirationTime = currentExpirationTime;
+ currentPriorityLevel = priorityLevel;
+ currentExpirationTime = expirationTime;
+ var continuationCallback;
+
+ try {
+ continuationCallback = callback();
+ } finally {
+ currentPriorityLevel = previousPriorityLevel;
+ currentExpirationTime = previousExpirationTime;
+ }
+
+ if (typeof continuationCallback === 'function') {
+ var continuationNode = {
+ callback: continuationCallback,
+ priorityLevel: priorityLevel,
+ expirationTime: expirationTime,
+ next: null,
+ previous: null
+ };
+
+ if (firstCallbackNode === null) {
+ firstCallbackNode = continuationNode.next = continuationNode.previous = continuationNode;
+ } else {
+ var nextAfterContinuation = null;
+ var node = firstCallbackNode;
+
+ do {
+ if (node.expirationTime >= expirationTime) {
+ nextAfterContinuation = node;
+ break;
+ }
+
+ node = node.next;
+ } while (node !== firstCallbackNode);
+
+ if (nextAfterContinuation === null) {
+ nextAfterContinuation = firstCallbackNode;
+ } else if (nextAfterContinuation === firstCallbackNode) {
+ firstCallbackNode = continuationNode;
+ ensureHostCallbackIsScheduled();
+ }
+
+ var previous = nextAfterContinuation.previous;
+ previous.next = nextAfterContinuation.previous = continuationNode;
+ continuationNode.next = nextAfterContinuation;
+ continuationNode.previous = previous;
+ }
+ }
+ }
+
+ function flushImmediateWork() {
+ if (currentEventStartTime === -1 && firstCallbackNode !== null && firstCallbackNode.priorityLevel === ImmediatePriority) {
+ isExecutingCallback = true;
+
+ try {
+ do {
+ flushFirstCallback();
+ } while (firstCallbackNode !== null && firstCallbackNode.priorityLevel === ImmediatePriority);
+ } finally {
+ isExecutingCallback = false;
+
+ if (firstCallbackNode !== null) {
+ ensureHostCallbackIsScheduled();
+ } else {
+ isHostCallbackScheduled = false;
+ }
+ }
+ }
+ }
+
+ function flushWork(didTimeout) {
+ isExecutingCallback = true;
+ var previousDidTimeout = currentDidTimeout;
+ currentDidTimeout = didTimeout;
+
+ try {
+ if (didTimeout) {
+ while (firstCallbackNode !== null) {
+ var currentTime = exports.unstable_now();
+
+ if (firstCallbackNode.expirationTime <= currentTime) {
+ do {
+ flushFirstCallback();
+ } while (firstCallbackNode !== null && firstCallbackNode.expirationTime <= currentTime);
+
+ continue;
+ }
+
+ break;
+ }
+ } else {
+ if (firstCallbackNode !== null) {
+ do {
+ flushFirstCallback();
+ } while (firstCallbackNode !== null && !shouldYieldToHost());
+ }
+ }
+ } finally {
+ isExecutingCallback = false;
+ currentDidTimeout = previousDidTimeout;
+
+ if (firstCallbackNode !== null) {
+ ensureHostCallbackIsScheduled();
+ } else {
+ isHostCallbackScheduled = false;
+ }
+
+ flushImmediateWork();
+ }
+ }
+
+ function unstable_runWithPriority(priorityLevel, eventHandler) {
+ switch (priorityLevel) {
+ case ImmediatePriority:
+ case UserBlockingPriority:
+ case NormalPriority:
+ case LowPriority:
+ case IdlePriority:
+ break;
+
+ default:
+ priorityLevel = NormalPriority;
+ }
+
+ var previousPriorityLevel = currentPriorityLevel;
+ var previousEventStartTime = currentEventStartTime;
+ currentPriorityLevel = priorityLevel;
+ currentEventStartTime = exports.unstable_now();
+
+ try {
+ return eventHandler();
+ } finally {
+ currentPriorityLevel = previousPriorityLevel;
+ currentEventStartTime = previousEventStartTime;
+ flushImmediateWork();
+ }
+ }
+
+ function unstable_wrapCallback(callback) {
+ var parentPriorityLevel = currentPriorityLevel;
+ return function () {
+ var previousPriorityLevel = currentPriorityLevel;
+ var previousEventStartTime = currentEventStartTime;
+ currentPriorityLevel = parentPriorityLevel;
+ currentEventStartTime = exports.unstable_now();
+
+ try {
+ return callback.apply(this, arguments);
+ } finally {
+ currentPriorityLevel = previousPriorityLevel;
+ currentEventStartTime = previousEventStartTime;
+ flushImmediateWork();
+ }
+ };
+ }
+
+ function unstable_scheduleCallback(callback, deprecated_options) {
+ var startTime = currentEventStartTime !== -1 ? currentEventStartTime : exports.unstable_now();
+ var expirationTime;
+
+ if (typeof deprecated_options === 'object' && deprecated_options !== null && typeof deprecated_options.timeout === 'number') {
+ expirationTime = startTime + deprecated_options.timeout;
+ } else {
+ switch (currentPriorityLevel) {
+ case ImmediatePriority:
+ expirationTime = startTime + IMMEDIATE_PRIORITY_TIMEOUT;
+ break;
+
+ case UserBlockingPriority:
+ expirationTime = startTime + USER_BLOCKING_PRIORITY;
+ break;
+
+ case IdlePriority:
+ expirationTime = startTime + IDLE_PRIORITY;
+ break;
+
+ case LowPriority:
+ expirationTime = startTime + LOW_PRIORITY_TIMEOUT;
+ break;
+
+ case NormalPriority:
+ default:
+ expirationTime = startTime + NORMAL_PRIORITY_TIMEOUT;
+ }
+ }
+
+ var newNode = {
+ callback: callback,
+ priorityLevel: currentPriorityLevel,
+ expirationTime: expirationTime,
+ next: null,
+ previous: null
+ };
+
+ if (firstCallbackNode === null) {
+ firstCallbackNode = newNode.next = newNode.previous = newNode;
+ ensureHostCallbackIsScheduled();
+ } else {
+ var next = null;
+ var node = firstCallbackNode;
+
+ do {
+ if (node.expirationTime > expirationTime) {
+ next = node;
+ break;
+ }
+
+ node = node.next;
+ } while (node !== firstCallbackNode);
+
+ if (next === null) {
+ next = firstCallbackNode;
+ } else if (next === firstCallbackNode) {
+ firstCallbackNode = newNode;
+ ensureHostCallbackIsScheduled();
+ }
+
+ var previous = next.previous;
+ previous.next = next.previous = newNode;
+ newNode.next = next;
+ newNode.previous = previous;
+ }
+
+ return newNode;
+ }
+
+ function unstable_cancelCallback(callbackNode) {
+ var next = callbackNode.next;
+
+ if (next === null) {
+ return;
+ }
+
+ if (next === callbackNode) {
+ firstCallbackNode = null;
+ } else {
+ if (callbackNode === firstCallbackNode) {
+ firstCallbackNode = next;
+ }
+
+ var previous = callbackNode.previous;
+ previous.next = next;
+ next.previous = previous;
+ }
+
+ callbackNode.next = callbackNode.previous = null;
+ }
+
+ function unstable_getCurrentPriorityLevel() {
+ return currentPriorityLevel;
+ }
+
+ function unstable_shouldYield() {
+ return !currentDidTimeout && (firstCallbackNode !== null && firstCallbackNode.expirationTime < currentExpirationTime || shouldYieldToHost());
+ }
+
+ var localDate = Date;
+ var localSetTimeout = typeof setTimeout === 'function' ? setTimeout : undefined;
+ var localClearTimeout = typeof clearTimeout === 'function' ? clearTimeout : undefined;
+ var localRequestAnimationFrame = typeof requestAnimationFrame === 'function' ? requestAnimationFrame : undefined;
+ var localCancelAnimationFrame = typeof cancelAnimationFrame === 'function' ? cancelAnimationFrame : undefined;
+ var ANIMATION_FRAME_TIMEOUT = 100;
+ var rAFID;
+ var rAFTimeoutID;
+
+ var requestAnimationFrameWithTimeout = function requestAnimationFrameWithTimeout(callback) {
+ rAFID = localRequestAnimationFrame(function (timestamp) {
+ localClearTimeout(rAFTimeoutID);
+ callback(timestamp);
+ });
+ rAFTimeoutID = localSetTimeout(function () {
+ localCancelAnimationFrame(rAFID);
+ callback(exports.unstable_now());
+ }, ANIMATION_FRAME_TIMEOUT);
+ };
+
+ if (hasNativePerformanceNow) {
+ var Performance = performance;
+
+ exports.unstable_now = function () {
+ return Performance.now();
+ };
+ } else {
+ exports.unstable_now = function () {
+ return localDate.now();
+ };
+ }
+
+ var _requestHostCallback;
+
+ var cancelHostCallback;
+ var shouldYieldToHost;
+ var globalValue = null;
+
+ if (typeof window !== 'undefined') {
+ globalValue = window;
+ } else if (typeof global !== 'undefined') {
+ globalValue = global;
+ }
+
+ if (globalValue && globalValue._schedMock) {
+ var globalImpl = globalValue._schedMock;
+ _requestHostCallback = globalImpl[0];
+ cancelHostCallback = globalImpl[1];
+ shouldYieldToHost = globalImpl[2];
+ exports.unstable_now = globalImpl[3];
+ } else if (typeof window === 'undefined' || typeof MessageChannel !== 'function') {
+ var _callback = null;
+
+ var _flushCallback = function _flushCallback(didTimeout) {
+ if (_callback !== null) {
+ try {
+ _callback(didTimeout);
+ } finally {
+ _callback = null;
+ }
+ }
+ };
+
+ _requestHostCallback = function requestHostCallback(cb, ms) {
+ if (_callback !== null) {
+ setTimeout(_requestHostCallback, 0, cb);
+ } else {
+ _callback = cb;
+ setTimeout(_flushCallback, 0, false);
+ }
+ };
+
+ cancelHostCallback = function cancelHostCallback() {
+ _callback = null;
+ };
+
+ shouldYieldToHost = function shouldYieldToHost() {
+ return false;
+ };
+ } else {
+ if (typeof console !== 'undefined') {
+ if (typeof localRequestAnimationFrame !== 'function') {
+ console.error("This browser doesn't support requestAnimationFrame. " + 'Make sure that you load a ' + 'polyfill in older browsers. https://fb.me/react-polyfills');
+ }
+
+ if (typeof localCancelAnimationFrame !== 'function') {
+ console.error("This browser doesn't support cancelAnimationFrame. " + 'Make sure that you load a ' + 'polyfill in older browsers. https://fb.me/react-polyfills');
+ }
+ }
+
+ var scheduledHostCallback = null;
+ var isMessageEventScheduled = false;
+ var timeoutTime = -1;
+ var isAnimationFrameScheduled = false;
+ var isFlushingHostCallback = false;
+ var frameDeadline = 0;
+ var previousFrameTime = 33;
+ var activeFrameTime = 33;
+
+ shouldYieldToHost = function shouldYieldToHost() {
+ return frameDeadline <= exports.unstable_now();
+ };
+
+ var channel = new MessageChannel();
+ var port = channel.port2;
+
+ channel.port1.onmessage = function (event) {
+ isMessageEventScheduled = false;
+ var prevScheduledCallback = scheduledHostCallback;
+ var prevTimeoutTime = timeoutTime;
+ scheduledHostCallback = null;
+ timeoutTime = -1;
+ var currentTime = exports.unstable_now();
+ var didTimeout = false;
+
+ if (frameDeadline - currentTime <= 0) {
+ if (prevTimeoutTime !== -1 && prevTimeoutTime <= currentTime) {
+ didTimeout = true;
+ } else {
+ if (!isAnimationFrameScheduled) {
+ isAnimationFrameScheduled = true;
+ requestAnimationFrameWithTimeout(animationTick);
+ }
+
+ scheduledHostCallback = prevScheduledCallback;
+ timeoutTime = prevTimeoutTime;
+ return;
+ }
+ }
+
+ if (prevScheduledCallback !== null) {
+ isFlushingHostCallback = true;
+
+ try {
+ prevScheduledCallback(didTimeout);
+ } finally {
+ isFlushingHostCallback = false;
+ }
+ }
+ };
+
+ var animationTick = function animationTick(rafTime) {
+ if (scheduledHostCallback !== null) {
+ requestAnimationFrameWithTimeout(animationTick);
+ } else {
+ isAnimationFrameScheduled = false;
+ return;
+ }
+
+ var nextFrameTime = rafTime - frameDeadline + activeFrameTime;
+
+ if (nextFrameTime < activeFrameTime && previousFrameTime < activeFrameTime) {
+ if (nextFrameTime < 8) {
+ nextFrameTime = 8;
+ }
+
+ activeFrameTime = nextFrameTime < previousFrameTime ? previousFrameTime : nextFrameTime;
+ } else {
+ previousFrameTime = nextFrameTime;
+ }
+
+ frameDeadline = rafTime + activeFrameTime;
+
+ if (!isMessageEventScheduled) {
+ isMessageEventScheduled = true;
+ port.postMessage(undefined);
+ }
+ };
+
+ _requestHostCallback = function _requestHostCallback(callback, absoluteTimeout) {
+ scheduledHostCallback = callback;
+ timeoutTime = absoluteTimeout;
+
+ if (isFlushingHostCallback || absoluteTimeout < 0) {
+ port.postMessage(undefined);
+ } else if (!isAnimationFrameScheduled) {
+ isAnimationFrameScheduled = true;
+ requestAnimationFrameWithTimeout(animationTick);
+ }
+ };
+
+ cancelHostCallback = function cancelHostCallback() {
+ scheduledHostCallback = null;
+ isMessageEventScheduled = false;
+ timeoutTime = -1;
+ };
+ }
+
+ exports.unstable_ImmediatePriority = ImmediatePriority;
+ exports.unstable_UserBlockingPriority = UserBlockingPriority;
+ exports.unstable_NormalPriority = NormalPriority;
+ exports.unstable_IdlePriority = IdlePriority;
+ exports.unstable_LowPriority = LowPriority;
+ exports.unstable_runWithPriority = unstable_runWithPriority;
+ exports.unstable_scheduleCallback = unstable_scheduleCallback;
+ exports.unstable_cancelCallback = unstable_cancelCallback;
+ exports.unstable_wrapCallback = unstable_wrapCallback;
+ exports.unstable_getCurrentPriorityLevel = unstable_getCurrentPriorityLevel;
+ exports.unstable_shouldYield = unstable_shouldYield;
+ })();
+ }
+},182,[],"node_modules\\react-native\\node_modules\\scheduler\\cjs\\scheduler.development.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ "use strict";
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ _$$_REQUIRE(_dependencyMap[1], "InitializeCore");
+
+ var ReactNativeViewConfigRegistry = _$$_REQUIRE(_dependencyMap[2], "ReactNativeViewConfigRegistry"),
+ UIManager = _$$_REQUIRE(_dependencyMap[3], "UIManager"),
+ RCTEventEmitter = _$$_REQUIRE(_dependencyMap[4], "RCTEventEmitter"),
+ React = _$$_REQUIRE(_dependencyMap[5], "react"),
+ deepDiffer = _$$_REQUIRE(_dependencyMap[6], "deepDiffer"),
+ flattenStyle = _$$_REQUIRE(_dependencyMap[7], "flattenStyle"),
+ TextInputState = _$$_REQUIRE(_dependencyMap[8], "TextInputState");
+
+ var scheduler = _$$_REQUIRE(_dependencyMap[9], "scheduler"),
+ ExceptionsManager = _$$_REQUIRE(_dependencyMap[10], "ExceptionsManager");
+
+ function invariant(condition, format, a, b, c, d, e, f) {
+ if (!condition) {
+ condition = void 0;
+ if (void 0 === format) condition = 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],
+ argIndex = 0;
+ condition = Error(format.replace(/%s/g, function () {
+ return args[argIndex++];
+ }));
+ condition.name = "Invariant Violation";
+ }
+ condition.framesToPop = 1;
+ throw condition;
+ }
+ }
+
+ function invokeGuardedCallbackImpl(name, func, context, a, b, c, d, e, f) {
+ var funcArgs = Array.prototype.slice.call(arguments, 3);
+
+ try {
+ func.apply(context, funcArgs);
+ } catch (error) {
+ this.onError(error);
+ }
+ }
+
+ var hasError = !1,
+ caughtError = null,
+ hasRethrowError = !1,
+ rethrowError = null,
+ reporter = {
+ onError: function onError(error) {
+ hasError = !0;
+ caughtError = error;
+ }
+ };
+
+ function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
+ hasError = !1;
+ caughtError = null;
+ invokeGuardedCallbackImpl.apply(reporter, arguments);
+ }
+
+ function invokeGuardedCallbackAndCatchFirstError(name, func, context, a, b, c, d, e, f) {
+ invokeGuardedCallback.apply(this, arguments);
+
+ if (hasError) {
+ if (hasError) {
+ var error = caughtError;
+ hasError = !1;
+ caughtError = null;
+ } else invariant(!1, "clearCaughtError was called but no error was captured. This error is likely caused by a bug in React. Please file an issue."), error = void 0;
+
+ hasRethrowError || (hasRethrowError = !0, rethrowError = 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, listener, inst) {
+ var type = event.type || "unknown-event";
+ event.currentTarget = getNodeFromInstance(inst);
+ invokeGuardedCallbackAndCatchFirstError(type, listener, void 0, event);
+ event.currentTarget = null;
+ }
+
+ function executeDirectDispatch(event) {
+ var dispatchListener = event._dispatchListeners,
+ dispatchInstance = event._dispatchInstances;
+ 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, dispatchListeners[i], dispatchInstances[i]);
+ } else dispatchListeners && executeDispatch(e, dispatchListeners, dispatchInstances);
+ e._dispatchListeners = null;
+ e._dispatchInstances = null;
+ e.isPersistent() || e.constructor.release(e);
+ }
+ }
+
+ var injection = {
+ injectEventPluginOrder: function injectEventPluginOrder(injectedEventPluginOrder) {
+ 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));
+ }
+ }
+ }
+
+ function functionThatReturnsTrue() {
+ return !0;
+ }
+
+ function functionThatReturnsFalse() {
+ return !1;
+ }
+
+ function SyntheticEvent(dispatchConfig, targetInst, nativeEvent, nativeEventTarget) {
+ this.dispatchConfig = dispatchConfig;
+ this._targetInst = targetInst;
+ this.nativeEvent = nativeEvent;
+ dispatchConfig = this.constructor.Interface;
+
+ for (var propName in dispatchConfig) {
+ dispatchConfig.hasOwnProperty(propName) && ((targetInst = dispatchConfig[propName]) ? this[propName] = targetInst(nativeEvent) : "target" === propName ? this.target = nativeEventTarget : this[propName] = nativeEvent[propName]);
+ }
+
+ this.isDefaultPrevented = (null != nativeEvent.defaultPrevented ? nativeEvent.defaultPrevented : !1 === nativeEvent.returnValue) ? functionThatReturnsTrue : functionThatReturnsFalse;
+ this.isPropagationStopped = functionThatReturnsFalse;
+ return this;
+ }
+
+ _extends(SyntheticEvent.prototype, {
+ preventDefault: function preventDefault() {
+ this.defaultPrevented = !0;
+ var event = this.nativeEvent;
+ event && (event.preventDefault ? event.preventDefault() : "unknown" !== typeof event.returnValue && (event.returnValue = !1), this.isDefaultPrevented = functionThatReturnsTrue);
+ },
+ stopPropagation: function stopPropagation() {
+ var event = this.nativeEvent;
+ event && (event.stopPropagation ? event.stopPropagation() : "unknown" !== typeof event.cancelBubble && (event.cancelBubble = !0), this.isPropagationStopped = functionThatReturnsTrue);
+ },
+ persist: function persist() {
+ this.isPersistent = functionThatReturnsTrue;
+ },
+ isPersistent: functionThatReturnsFalse,
+ destructor: function destructor() {
+ var Interface = this.constructor.Interface,
+ propName;
+
+ for (propName in Interface) {
+ this[propName] = null;
+ }
+
+ this.nativeEvent = this._targetInst = this.dispatchConfig = null;
+ this.isPropagationStopped = this.isDefaultPrevented = functionThatReturnsFalse;
+ this._dispatchInstances = this._dispatchListeners = null;
+ }
+ });
+
+ SyntheticEvent.Interface = {
+ type: null,
+ target: null,
+ currentTarget: function currentTarget() {
+ return null;
+ },
+ eventPhase: null,
+ bubbles: null,
+ cancelable: null,
+ timeStamp: function timeStamp(event) {
+ return event.timeStamp || Date.now();
+ },
+ defaultPrevented: null,
+ isTrusted: null
+ };
+
+ SyntheticEvent.extend = function (Interface) {
+ function E() {}
+
+ function Class() {
+ return Super.apply(this, arguments);
+ }
+
+ var Super = this;
+ E.prototype = Super.prototype;
+ var prototype = new E();
+
+ _extends(prototype, Class.prototype);
+
+ Class.prototype = prototype;
+ Class.prototype.constructor = Class;
+ Class.Interface = _extends({}, Super.Interface, Interface);
+ Class.extend = Super.extend;
+ addEventPoolingTo(Class);
+ return Class;
+ };
+
+ addEventPoolingTo(SyntheticEvent);
+
+ function getPooledEvent(dispatchConfig, targetInst, nativeEvent, nativeInst) {
+ if (this.eventPool.length) {
+ var instance = this.eventPool.pop();
+ this.call(instance, dispatchConfig, targetInst, nativeEvent, nativeInst);
+ return instance;
+ }
+
+ return new this(dispatchConfig, targetInst, nativeEvent, nativeInst);
+ }
+
+ function releasePooledEvent(event) {
+ 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;
+ }
+ }
+ },
+ ReactNativeBridgeEventPlugin = {
+ eventTypes: ReactNativeViewConfigRegistry.eventTypes,
+ extractEvents: function extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+ if (null == targetInst) return null;
+ var bubbleDispatchConfig = ReactNativeViewConfigRegistry.customBubblingEventTypes[topLevelType],
+ directDispatchConfig = ReactNativeViewConfigRegistry.customDirectEventTypes[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 getInstanceFromTag(tag) {
+ return instanceCache[tag] || null;
+ }
+
+ var restoreTarget = null,
+ restoreQueue = null;
+
+ function restoreStateOfTarget(target) {
+ if (target = getInstanceFromNode(target)) {
+ invariant(!1, "setRestoreImplementation() needs to be called to handle a target for controlled events. This error is likely caused by a bug in React. Please file an issue.");
+ var props = getFiberCurrentPropsFromNode(target.stateNode);
+ null(target.stateNode, target.type, props);
+ }
+ }
+
+ function _batchedUpdatesImpl(fn, bookkeeping) {
+ return fn(bookkeeping);
+ }
+
+ function _flushInteractiveUpdatesImpl() {}
+
+ var isBatching = !1;
+
+ function batchedUpdates(fn, bookkeeping) {
+ if (isBatching) return fn(bookkeeping);
+ isBatching = !0;
+
+ try {
+ return _batchedUpdatesImpl(fn, bookkeeping);
+ } finally {
+ if (isBatching = !1, null !== restoreTarget || null !== restoreQueue) if (_flushInteractiveUpdatesImpl(), restoreTarget && (bookkeeping = restoreTarget, fn = restoreQueue, restoreQueue = restoreTarget = null, restoreStateOfTarget(bookkeeping), fn)) for (bookkeeping = 0; bookkeeping < fn.length; bookkeeping++) {
+ restoreStateOfTarget(fn[bookkeeping]);
+ }
+ }
+ }
+
+ var EMPTY_NATIVE_EVENT = {};
+
+ function _receiveRootNodeIDEvent(rootNodeID, topLevelType, nativeEventParam) {
+ var nativeEvent = nativeEventParam || EMPTY_NATIVE_EVENT,
+ inst = getInstanceFromTag(rootNodeID);
+ batchedUpdates(function () {
+ var events = nativeEvent.target;
+
+ for (var events$jscomp$0 = null, i = 0; i < plugins.length; i++) {
+ var possiblePlugin = plugins[i];
+ possiblePlugin && (possiblePlugin = possiblePlugin.extractEvents(topLevelType, inst, nativeEvent, events)) && (events$jscomp$0 = accumulateInto(events$jscomp$0, possiblePlugin));
+ }
+
+ events = events$jscomp$0;
+ null !== events && (eventQueue = accumulateInto(eventQueue, events));
+ events = eventQueue;
+ eventQueue = null;
+ if (events && (forEachAccumulated(events, executeDispatchesAndReleaseTopLevel), invariant(!eventQueue, "processEventQueue(): Additional events were enqueued while processing an event queue. Support for this has not yet been implemented."), hasRethrowError)) throw events = rethrowError, hasRethrowError = !1, rethrowError = null, events;
+ });
+ }
+
+ RCTEventEmitter.register({
+ receiveEvent: function receiveEvent(rootNodeID, topLevelType, nativeEventParam) {
+ _receiveRootNodeIDEvent(rootNodeID, topLevelType, nativeEventParam);
+ },
+ receiveTouches: function receiveTouches(eventTopLevelType, touches, changedIndices) {
+ if ("topTouchEnd" === eventTopLevelType || "topTouchCancel" === eventTopLevelType) {
+ var JSCompiler_temp = [];
+
+ for (var i = 0; i < changedIndices.length; i++) {
+ var index = changedIndices[i];
+ JSCompiler_temp.push(touches[index]);
+ touches[index] = null;
+ }
+
+ for (i = changedIndices = 0; i < touches.length; i++) {
+ index = touches[i], null !== index && (touches[changedIndices++] = index);
+ }
+
+ touches.length = changedIndices;
+ } else for (JSCompiler_temp = [], i = 0; i < changedIndices.length; i++) {
+ JSCompiler_temp.push(touches[changedIndices[i]]);
+ }
+
+ for (changedIndices = 0; changedIndices < JSCompiler_temp.length; changedIndices++) {
+ i = JSCompiler_temp[changedIndices];
+ i.changedTouches = JSCompiler_temp;
+ i.touches = touches;
+ index = null;
+ var target = i.target;
+ null === target || void 0 === target || 1 > target || (index = target);
+
+ _receiveRootNodeIDEvent(index, eventTopLevelType, i);
+ }
+ }
+ });
+
+ getFiberCurrentPropsFromNode = function getFiberCurrentPropsFromNode(stateNode) {
+ return instanceProps[stateNode._nativeTag] || null;
+ };
+
+ 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;
+ };
+
+ ResponderEventPlugin.injection.injectGlobalResponderHandler({
+ onChange: function onChange(from, to, blockNativeResponder) {
+ null !== to ? UIManager.setJSResponder(to.stateNode._nativeTag, blockNativeResponder) : UIManager.clearJSResponder();
+ }
+ });
+ var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+ ReactSharedInternals.hasOwnProperty("ReactCurrentDispatcher") || (ReactSharedInternals.ReactCurrentDispatcher = {
+ current: null
+ });
+ var hasSymbol = "function" === typeof Symbol && (typeof Symbol === "function" ? Symbol.for : "@@for"),
+ REACT_ELEMENT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.element") : 60103,
+ REACT_PORTAL_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.portal") : 60106,
+ REACT_FRAGMENT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.fragment") : 60107,
+ REACT_STRICT_MODE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.strict_mode") : 60108,
+ REACT_PROFILER_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.profiler") : 60114,
+ REACT_PROVIDER_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.provider") : 60109,
+ REACT_CONTEXT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.context") : 60110,
+ REACT_CONCURRENT_MODE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.concurrent_mode") : 60111,
+ REACT_FORWARD_REF_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.forward_ref") : 60112,
+ REACT_SUSPENSE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.suspense") : 60113,
+ REACT_MEMO_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.memo") : 60115,
+ REACT_LAZY_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.lazy") : 60116,
+ MAYBE_ITERATOR_SYMBOL = "function" === typeof Symbol && (typeof Symbol === "function" ? Symbol.iterator : "@@iterator");
+
+ function getIteratorFn(maybeIterable) {
+ if (null === maybeIterable || "object" !== typeof maybeIterable) return null;
+ maybeIterable = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable["@@iterator"];
+ return "function" === typeof maybeIterable ? maybeIterable : null;
+ }
+
+ function getComponentName(type) {
+ if (null == type) return null;
+ if ("function" === typeof type) return type.displayName || type.name || null;
+ if ("string" === typeof type) return type;
+
+ switch (type) {
+ case REACT_CONCURRENT_MODE_TYPE:
+ return "ConcurrentMode";
+
+ case REACT_FRAGMENT_TYPE:
+ return "Fragment";
+
+ case REACT_PORTAL_TYPE:
+ return "Portal";
+
+ case REACT_PROFILER_TYPE:
+ return "Profiler";
+
+ case REACT_STRICT_MODE_TYPE:
+ return "StrictMode";
+
+ case REACT_SUSPENSE_TYPE:
+ return "Suspense";
+ }
+
+ if ("object" === typeof type) switch (type.$$typeof) {
+ case REACT_CONTEXT_TYPE:
+ return "Context.Consumer";
+
+ case REACT_PROVIDER_TYPE:
+ return "Context.Provider";
+
+ case REACT_FORWARD_REF_TYPE:
+ var innerType = type.render;
+ innerType = innerType.displayName || innerType.name || "";
+ return type.displayName || ("" !== innerType ? "ForwardRef(" + innerType + ")" : "ForwardRef");
+
+ case REACT_MEMO_TYPE:
+ return getComponentName(type.type);
+
+ case REACT_LAZY_TYPE:
+ if (type = 1 === type._status ? type._result : null) return getComponentName(type);
+ }
+ return null;
+ }
+
+ function isFiberMountedImpl(fiber) {
+ var node = fiber;
+ if (fiber.alternate) for (; node.return;) {
+ node = node.return;
+ } else {
+ if (0 !== (node.effectTag & 2)) return 1;
+
+ for (; node.return;) {
+ if (node = node.return, 0 !== (node.effectTag & 2)) return 1;
+ }
+ }
+ return 3 === node.tag ? 2 : 3;
+ }
+
+ function assertIsMounted(fiber) {
+ 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;
+ }
+
+ var emptyObject = {},
+ removedKeys = null,
+ removedKeyCount = 0;
+
+ function restoreDeletedValuesInNestedArray(updatePayload, node, validAttributes) {
+ if (Array.isArray(node)) for (var i = node.length; i-- && 0 < removedKeyCount;) {
+ restoreDeletedValuesInNestedArray(updatePayload, node[i], validAttributes);
+ } else if (node && 0 < removedKeyCount) for (i in removedKeys) {
+ if (removedKeys[i]) {
+ var nextProp = node[i];
+
+ if (void 0 !== nextProp) {
+ var attributeConfig = validAttributes[i];
+
+ if (attributeConfig) {
+ "function" === typeof nextProp && (nextProp = !0);
+ "undefined" === typeof nextProp && (nextProp = null);
+ if ("object" !== typeof attributeConfig) updatePayload[i] = nextProp;else if ("function" === typeof attributeConfig.diff || "function" === typeof attributeConfig.process) nextProp = "function" === typeof attributeConfig.process ? attributeConfig.process(nextProp) : nextProp, updatePayload[i] = nextProp;
+ removedKeys[i] = !1;
+ removedKeyCount--;
+ }
+ }
+ }
+ }
+ }
+
+ function diffNestedProperty(updatePayload, prevProp, nextProp, validAttributes) {
+ if (!updatePayload && prevProp === nextProp) return updatePayload;
+ if (!prevProp || !nextProp) return nextProp ? addNestedProperty(updatePayload, nextProp, validAttributes) : prevProp ? clearNestedProperty(updatePayload, prevProp, validAttributes) : updatePayload;
+ if (!Array.isArray(prevProp) && !Array.isArray(nextProp)) return diffProperties(updatePayload, prevProp, nextProp, validAttributes);
+
+ if (Array.isArray(prevProp) && Array.isArray(nextProp)) {
+ var minLength = prevProp.length < nextProp.length ? prevProp.length : nextProp.length,
+ i;
+
+ for (i = 0; i < minLength; i++) {
+ updatePayload = diffNestedProperty(updatePayload, prevProp[i], nextProp[i], validAttributes);
+ }
+
+ for (; i < prevProp.length; i++) {
+ updatePayload = clearNestedProperty(updatePayload, prevProp[i], validAttributes);
+ }
+
+ for (; i < nextProp.length; i++) {
+ updatePayload = addNestedProperty(updatePayload, nextProp[i], validAttributes);
+ }
+
+ return updatePayload;
+ }
+
+ return Array.isArray(prevProp) ? diffProperties(updatePayload, 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, nextProp, validAttributes);
+
+ for (var i = 0; i < nextProp.length; i++) {
+ updatePayload = addNestedProperty(updatePayload, nextProp[i], validAttributes);
+ }
+
+ return updatePayload;
+ }
+
+ function clearNestedProperty(updatePayload, prevProp, validAttributes) {
+ if (!prevProp) return updatePayload;
+ if (!Array.isArray(prevProp)) return diffProperties(updatePayload, prevProp, emptyObject, validAttributes);
+
+ for (var i = 0; i < prevProp.length; i++) {
+ updatePayload = clearNestedProperty(updatePayload, prevProp[i], validAttributes);
+ }
+
+ return updatePayload;
+ }
+
+ function diffProperties(updatePayload, prevProps, nextProps, validAttributes) {
+ var attributeConfig, propKey;
+
+ for (propKey in nextProps) {
+ if (attributeConfig = validAttributes[propKey]) {
+ var prevProp = prevProps[propKey];
+ var nextProp = nextProps[propKey];
+ "function" === typeof nextProp && (nextProp = !0, "function" === typeof prevProp && (prevProp = !0));
+ "undefined" === typeof nextProp && (nextProp = null, "undefined" === typeof prevProp && (prevProp = null));
+ removedKeys && (removedKeys[propKey] = !1);
+ if (updatePayload && void 0 !== updatePayload[propKey]) {
+ if ("object" !== typeof attributeConfig) updatePayload[propKey] = nextProp;else {
+ if ("function" === typeof attributeConfig.diff || "function" === typeof attributeConfig.process) attributeConfig = "function" === typeof attributeConfig.process ? attributeConfig.process(nextProp) : nextProp, updatePayload[propKey] = attributeConfig;
+ }
+ } else if (prevProp !== nextProp) if ("object" !== typeof attributeConfig) ("object" !== typeof nextProp || null === nextProp || 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_NOT_REALLY_SAFE(context, callback) {
+ return function () {
+ if (callback && ("boolean" !== typeof context.__isMounted || context.__isMounted)) return callback.apply(context, arguments);
+ };
+ }
+
+ var ReactNativeFiberHostComponent = function () {
+ function ReactNativeFiberHostComponent(tag, viewConfig) {
+ if (!(this instanceof ReactNativeFiberHostComponent)) throw new TypeError("Cannot call a class as a function");
+ this._nativeTag = tag;
+ this._children = [];
+ this.viewConfig = viewConfig;
+ }
+
+ ReactNativeFiberHostComponent.prototype.blur = function () {
+ TextInputState.blurTextInput(this._nativeTag);
+ };
+
+ ReactNativeFiberHostComponent.prototype.focus = function () {
+ TextInputState.focusTextInput(this._nativeTag);
+ };
+
+ ReactNativeFiberHostComponent.prototype.measure = function (callback) {
+ UIManager.measure(this._nativeTag, mountSafeCallback_NOT_REALLY_SAFE(this, callback));
+ };
+
+ ReactNativeFiberHostComponent.prototype.measureInWindow = function (callback) {
+ UIManager.measureInWindow(this._nativeTag, mountSafeCallback_NOT_REALLY_SAFE(this, callback));
+ };
+
+ ReactNativeFiberHostComponent.prototype.measureLayout = function (relativeToNativeNode, onSuccess, onFail) {
+ UIManager.measureLayout(this._nativeTag, relativeToNativeNode, mountSafeCallback_NOT_REALLY_SAFE(this, onFail), mountSafeCallback_NOT_REALLY_SAFE(this, onSuccess));
+ };
+
+ ReactNativeFiberHostComponent.prototype.setNativeProps = function (nativeProps) {
+ nativeProps = diffProperties(null, emptyObject, nativeProps, this.viewConfig.validAttributes);
+ null != nativeProps && 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;
+
+ function setTimeoutCallback() {
+ frameDeadline = now$1() + 5;
+ var callback = scheduledCallback;
+ scheduledCallback = null;
+ null !== callback && callback();
+ }
+
+ function scheduleDeferredCallback$1(callback) {
+ scheduledCallback = callback;
+ return setTimeout(setTimeoutCallback, 1);
+ }
+
+ function shim$1() {
+ invariant(!1, "The current renderer does not support hydration. This error is likely caused by a bug in React. Please file an issue.");
+ }
+
+ var UPDATE_SIGNAL = {},
+ nextReactTag = 3;
+
+ function allocateTag() {
+ var tag = nextReactTag;
+ 1 === tag % 10 && (tag += 2);
+ nextReactTag = tag + 2;
+ return tag;
+ }
+
+ function recursivelyUncacheFiberNode(node) {
+ if ("number" === typeof node) delete instanceCache[node], delete instanceProps[node];else {
+ var tag = node._nativeTag;
+ delete instanceCache[tag];
+ delete instanceProps[tag];
+
+ node._children.forEach(recursivelyUncacheFiberNode);
+ }
+ }
+
+ function finalizeInitialChildren(parentInstance) {
+ if (0 === parentInstance._children.length) return !1;
+
+ var nativeTags = parentInstance._children.map(function (child) {
+ return "number" === typeof child ? child : child._nativeTag;
+ });
+
+ UIManager.setChildren(parentInstance._nativeTag, nativeTags);
+ return !1;
+ }
+
+ var scheduleTimeout = setTimeout,
+ cancelTimeout = clearTimeout;
+
+ function commitUpdate(instance, updatePayloadTODO, type, oldProps, newProps) {
+ updatePayloadTODO = instance.viewConfig;
+ instanceProps[instance._nativeTag] = newProps;
+ oldProps = diffProperties(null, oldProps, newProps, updatePayloadTODO.validAttributes);
+ null != oldProps && UIManager.updateView(instance._nativeTag, updatePayloadTODO.uiViewClassName, oldProps);
+ }
+
+ var BEFORE_SLASH_RE = /^(.*)[\\\/]/;
+
+ function getStackByFiberInDevAndProd(workInProgress) {
+ var info = "";
+
+ do {
+ a: switch (workInProgress.tag) {
+ case 3:
+ case 4:
+ case 6:
+ case 7:
+ case 10:
+ case 9:
+ var JSCompiler_inline_result = "";
+ break a;
+
+ default:
+ var owner = workInProgress._debugOwner,
+ source = workInProgress._debugSource,
+ name = getComponentName(workInProgress.type);
+ JSCompiler_inline_result = null;
+ owner && (JSCompiler_inline_result = getComponentName(owner.type));
+ owner = name;
+ name = "";
+ source ? name = " (at " + source.fileName.replace(BEFORE_SLASH_RE, "") + ":" + source.lineNumber + ")" : JSCompiler_inline_result && (name = " (created by " + JSCompiler_inline_result + ")");
+ JSCompiler_inline_result = "\n in " + (owner || "Unknown") + name;
+ }
+
+ info += JSCompiler_inline_result;
+ workInProgress = workInProgress.return;
+ } while (workInProgress);
+
+ return info;
+ }
+
+ new Set();
+ var valueStack = [],
+ index = -1;
+
+ function pop(cursor) {
+ 0 > index || (cursor.current = valueStack[index], valueStack[index] = null, index--);
+ }
+
+ function push(cursor, value) {
+ index++;
+ valueStack[index] = cursor.current;
+ cursor.current = value;
+ }
+
+ var emptyContextObject = {},
+ contextStackCursor = {
+ current: emptyContextObject
+ },
+ didPerformWorkStackCursor = {
+ current: !1
+ },
+ previousContext = emptyContextObject;
+
+ function getMaskedContext(workInProgress, unmaskedContext) {
+ var contextTypes = workInProgress.type.contextTypes;
+ if (!contextTypes) return emptyContextObject;
+ var instance = workInProgress.stateNode;
+ if (instance && instance.__reactInternalMemoizedUnmaskedChildContext === unmaskedContext) return instance.__reactInternalMemoizedMaskedChildContext;
+ var context = {},
+ key;
+
+ for (key in contextTypes) {
+ context[key] = unmaskedContext[key];
+ }
+
+ instance && (workInProgress = workInProgress.stateNode, workInProgress.__reactInternalMemoizedUnmaskedChildContext = unmaskedContext, workInProgress.__reactInternalMemoizedMaskedChildContext = context);
+ return context;
+ }
+
+ function isContextProvider(type) {
+ type = type.childContextTypes;
+ return null !== type && void 0 !== type;
+ }
+
+ function popContext(fiber) {
+ pop(didPerformWorkStackCursor, fiber);
+ pop(contextStackCursor, fiber);
+ }
+
+ function popTopLevelContextObject(fiber) {
+ pop(didPerformWorkStackCursor, fiber);
+ pop(contextStackCursor, fiber);
+ }
+
+ function pushTopLevelContextObject(fiber, context, didChange) {
+ invariant(contextStackCursor.current === emptyContextObject, "Unexpected context found on stack. This error is likely caused by a bug in React. Please file an issue.");
+ push(contextStackCursor, context, fiber);
+ push(didPerformWorkStackCursor, didChange, fiber);
+ }
+
+ function processChildContext(fiber, type, parentContext) {
+ var instance = fiber.stateNode;
+ fiber = type.childContextTypes;
+ if ("function" !== typeof instance.getChildContext) return parentContext;
+ instance = instance.getChildContext();
+
+ for (var contextKey in instance) {
+ invariant(contextKey in fiber, '%s.getChildContext(): key "%s" is not defined in childContextTypes.', getComponentName(type) || "Unknown", contextKey);
+ }
+
+ return _extends({}, parentContext, instance);
+ }
+
+ function pushContextProvider(workInProgress) {
+ var instance = workInProgress.stateNode;
+ instance = instance && instance.__reactInternalMemoizedMergedChildContext || emptyContextObject;
+ previousContext = contextStackCursor.current;
+ push(contextStackCursor, instance, workInProgress);
+ push(didPerformWorkStackCursor, didPerformWorkStackCursor.current, workInProgress);
+ return !0;
+ }
+
+ function invalidateContextProvider(workInProgress, type, didChange) {
+ var instance = workInProgress.stateNode;
+ invariant(instance, "Expected to have an instance by this point. This error is likely caused by a bug in React. Please file an issue.");
+ didChange ? (type = processChildContext(workInProgress, type, previousContext), instance.__reactInternalMemoizedMergedChildContext = type, pop(didPerformWorkStackCursor, workInProgress), pop(contextStackCursor, workInProgress), push(contextStackCursor, type, workInProgress)) : pop(didPerformWorkStackCursor, workInProgress);
+ push(didPerformWorkStackCursor, didChange, workInProgress);
+ }
+
+ var 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 FiberNode(tag, pendingProps, key, mode) {
+ this.tag = tag;
+ this.key = key;
+ this.sibling = this.child = this.return = this.stateNode = this.type = this.elementType = null;
+ this.index = 0;
+ this.ref = null;
+ this.pendingProps = pendingProps;
+ this.contextDependencies = this.memoizedState = this.updateQueue = this.memoizedProps = null;
+ this.mode = mode;
+ this.effectTag = 0;
+ this.lastEffect = this.firstEffect = this.nextEffect = null;
+ this.childExpirationTime = this.expirationTime = 0;
+ this.alternate = null;
+ }
+
+ function createFiber(tag, pendingProps, key, mode) {
+ return new FiberNode(tag, pendingProps, key, mode);
+ }
+
+ function shouldConstruct(Component) {
+ Component = Component.prototype;
+ return !(!Component || !Component.isReactComponent);
+ }
+
+ function resolveLazyComponentTag(Component) {
+ if ("function" === typeof Component) return shouldConstruct(Component) ? 1 : 0;
+
+ if (void 0 !== Component && null !== Component) {
+ Component = Component.$$typeof;
+ if (Component === REACT_FORWARD_REF_TYPE) return 11;
+ if (Component === REACT_MEMO_TYPE) return 14;
+ }
+
+ return 2;
+ }
+
+ function createWorkInProgress(current, pendingProps) {
+ var workInProgress = current.alternate;
+ null === workInProgress ? (workInProgress = createFiber(current.tag, pendingProps, current.key, current.mode), workInProgress.elementType = current.elementType, workInProgress.type = current.type, workInProgress.stateNode = current.stateNode, workInProgress.alternate = current, current.alternate = workInProgress) : (workInProgress.pendingProps = pendingProps, workInProgress.effectTag = 0, workInProgress.nextEffect = null, workInProgress.firstEffect = null, workInProgress.lastEffect = null);
+ workInProgress.childExpirationTime = current.childExpirationTime;
+ workInProgress.expirationTime = current.expirationTime;
+ workInProgress.child = current.child;
+ workInProgress.memoizedProps = current.memoizedProps;
+ workInProgress.memoizedState = current.memoizedState;
+ workInProgress.updateQueue = current.updateQueue;
+ workInProgress.contextDependencies = current.contextDependencies;
+ workInProgress.sibling = current.sibling;
+ workInProgress.index = current.index;
+ workInProgress.ref = current.ref;
+ return workInProgress;
+ }
+
+ function createFiberFromTypeAndProps(type, key, pendingProps, owner, mode, expirationTime) {
+ var fiberTag = 2;
+ owner = type;
+ if ("function" === typeof type) shouldConstruct(type) && (fiberTag = 1);else if ("string" === typeof type) fiberTag = 5;else a: switch (type) {
+ case REACT_FRAGMENT_TYPE:
+ return createFiberFromFragment(pendingProps.children, mode, expirationTime, key);
+
+ case REACT_CONCURRENT_MODE_TYPE:
+ return createFiberFromMode(pendingProps, mode | 3, expirationTime, key);
+
+ case REACT_STRICT_MODE_TYPE:
+ return createFiberFromMode(pendingProps, mode | 2, expirationTime, key);
+
+ case REACT_PROFILER_TYPE:
+ return type = createFiber(12, pendingProps, key, mode | 4), type.elementType = REACT_PROFILER_TYPE, type.type = REACT_PROFILER_TYPE, type.expirationTime = expirationTime, type;
+
+ case REACT_SUSPENSE_TYPE:
+ return type = createFiber(13, pendingProps, key, mode), type.elementType = REACT_SUSPENSE_TYPE, type.type = REACT_SUSPENSE_TYPE, type.expirationTime = expirationTime, type;
+
+ default:
+ if ("object" === typeof type && null !== type) switch (type.$$typeof) {
+ case REACT_PROVIDER_TYPE:
+ fiberTag = 10;
+ break a;
+
+ case REACT_CONTEXT_TYPE:
+ fiberTag = 9;
+ break a;
+
+ case REACT_FORWARD_REF_TYPE:
+ fiberTag = 11;
+ break a;
+
+ case REACT_MEMO_TYPE:
+ fiberTag = 14;
+ break a;
+
+ case REACT_LAZY_TYPE:
+ fiberTag = 16;
+ owner = null;
+ break a;
+ }
+ 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, "");
+ }
+ key = createFiber(fiberTag, pendingProps, key, mode);
+ key.elementType = type;
+ key.type = owner;
+ key.expirationTime = expirationTime;
+ return key;
+ }
+
+ function createFiberFromFragment(elements, mode, expirationTime, key) {
+ elements = createFiber(7, elements, key, mode);
+ elements.expirationTime = expirationTime;
+ return elements;
+ }
+
+ function createFiberFromMode(pendingProps, mode, expirationTime, key) {
+ pendingProps = createFiber(8, pendingProps, key, mode);
+ mode = 0 === (mode & 1) ? REACT_STRICT_MODE_TYPE : REACT_CONCURRENT_MODE_TYPE;
+ pendingProps.elementType = mode;
+ pendingProps.type = mode;
+ pendingProps.expirationTime = expirationTime;
+ return pendingProps;
+ }
+
+ function createFiberFromText(content, mode, expirationTime) {
+ content = createFiber(6, content, null, mode);
+ content.expirationTime = expirationTime;
+ return content;
+ }
+
+ function createFiberFromPortal(portal, mode, expirationTime) {
+ mode = createFiber(4, null !== portal.children ? portal.children : [], portal.key, mode);
+ mode.expirationTime = expirationTime;
+ mode.stateNode = {
+ containerInfo: portal.containerInfo,
+ pendingChildren: null,
+ implementation: portal.implementation
+ };
+ return mode;
+ }
+
+ function 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);
+ findNextExpirationTimeToWorkOn(expirationTime, root);
+ }
+
+ function markCommittedPriorityLevels(root, earliestRemainingTime) {
+ root.didError = !1;
+ if (0 === earliestRemainingTime) root.earliestPendingTime = 0, root.latestPendingTime = 0, root.earliestSuspendedTime = 0, root.latestSuspendedTime = 0, root.latestPingedTime = 0;else {
+ earliestRemainingTime < root.latestPingedTime && (root.latestPingedTime = 0);
+ var latestPendingTime = root.latestPendingTime;
+ 0 !== latestPendingTime && (latestPendingTime > earliestRemainingTime ? root.earliestPendingTime = root.latestPendingTime = 0 : root.earliestPendingTime > earliestRemainingTime && (root.earliestPendingTime = root.latestPendingTime));
+ latestPendingTime = root.earliestSuspendedTime;
+ 0 === latestPendingTime ? markPendingPriorityLevel(root, earliestRemainingTime) : earliestRemainingTime < root.latestSuspendedTime ? (root.earliestSuspendedTime = 0, root.latestSuspendedTime = 0, root.latestPingedTime = 0, markPendingPriorityLevel(root, earliestRemainingTime)) : earliestRemainingTime > latestPendingTime && markPendingPriorityLevel(root, earliestRemainingTime);
+ }
+ findNextExpirationTimeToWorkOn(0, root);
+ }
+
+ function markSuspendedPriorityLevel(root, suspendedTime) {
+ root.didError = !1;
+ root.latestPingedTime >= suspendedTime && (root.latestPingedTime = 0);
+ var earliestPendingTime = root.earliestPendingTime,
+ latestPendingTime = root.latestPendingTime;
+ earliestPendingTime === suspendedTime ? root.earliestPendingTime = latestPendingTime === suspendedTime ? root.latestPendingTime = 0 : latestPendingTime : latestPendingTime === suspendedTime && (root.latestPendingTime = earliestPendingTime);
+ earliestPendingTime = root.earliestSuspendedTime;
+ latestPendingTime = root.latestSuspendedTime;
+ 0 === earliestPendingTime ? root.earliestSuspendedTime = root.latestSuspendedTime = suspendedTime : earliestPendingTime < suspendedTime ? root.earliestSuspendedTime = suspendedTime : latestPendingTime > suspendedTime && (root.latestSuspendedTime = suspendedTime);
+ findNextExpirationTimeToWorkOn(suspendedTime, root);
+ }
+
+ function findEarliestOutstandingPriorityLevel(root, renderExpirationTime) {
+ var earliestPendingTime = root.earliestPendingTime;
+ root = root.earliestSuspendedTime;
+ earliestPendingTime > renderExpirationTime && (renderExpirationTime = earliestPendingTime);
+ root > renderExpirationTime && (renderExpirationTime = root);
+ return renderExpirationTime;
+ }
+
+ function findNextExpirationTimeToWorkOn(completedExpirationTime, root) {
+ var earliestSuspendedTime = root.earliestSuspendedTime,
+ latestSuspendedTime = root.latestSuspendedTime,
+ earliestPendingTime = root.earliestPendingTime,
+ latestPingedTime = root.latestPingedTime;
+ earliestPendingTime = 0 !== earliestPendingTime ? earliestPendingTime : latestPingedTime;
+ 0 === earliestPendingTime && (0 === completedExpirationTime || latestSuspendedTime < completedExpirationTime) && (earliestPendingTime = latestSuspendedTime);
+ completedExpirationTime = earliestPendingTime;
+ 0 !== completedExpirationTime && earliestSuspendedTime > completedExpirationTime && (completedExpirationTime = earliestSuspendedTime);
+ root.nextExpirationTimeToWorkOn = earliestPendingTime;
+ root.expirationTime = completedExpirationTime;
+ }
+
+ function is(x, y) {
+ return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
+ }
+
+ var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+ function shallowEqual(objA, objB) {
+ if (is(objA, objB)) return !0;
+ if ("object" !== typeof objA || null === objA || "object" !== typeof objB || null === objB) return !1;
+ var keysA = Object.keys(objA),
+ keysB = Object.keys(objB);
+ if (keysA.length !== keysB.length) return !1;
+
+ for (keysB = 0; keysB < keysA.length; keysB++) {
+ if (!hasOwnProperty.call(objB, keysA[keysB]) || !is(objA[keysA[keysB]], objB[keysA[keysB]])) return !1;
+ }
+
+ return !0;
+ }
+
+ function resolveDefaultProps(Component, baseProps) {
+ if (Component && Component.defaultProps) {
+ baseProps = _extends({}, baseProps);
+ Component = Component.defaultProps;
+
+ for (var propName in Component) {
+ void 0 === baseProps[propName] && (baseProps[propName] = Component[propName]);
+ }
+ }
+
+ return baseProps;
+ }
+
+ function readLazyComponentType(lazyComponent) {
+ var result = lazyComponent._result;
+
+ switch (lazyComponent._status) {
+ case 1:
+ return result;
+
+ case 2:
+ throw result;
+
+ case 0:
+ throw result;
+
+ default:
+ lazyComponent._status = 0;
+ result = lazyComponent._ctor;
+ result = result();
+ result.then(function (moduleObject) {
+ 0 === lazyComponent._status && (moduleObject = moduleObject.default, lazyComponent._status = 1, lazyComponent._result = moduleObject);
+ }, function (error) {
+ 0 === lazyComponent._status && (lazyComponent._status = 2, lazyComponent._result = error);
+ });
+
+ switch (lazyComponent._status) {
+ case 1:
+ return lazyComponent._result;
+
+ case 2:
+ throw lazyComponent._result;
+ }
+
+ lazyComponent._result = result;
+ throw result;
+ }
+ }
+
+ var emptyRefsObject = new React.Component().refs;
+
+ function applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, nextProps) {
+ ctor = workInProgress.memoizedState;
+ getDerivedStateFromProps = getDerivedStateFromProps(nextProps, ctor);
+ getDerivedStateFromProps = null === getDerivedStateFromProps || void 0 === getDerivedStateFromProps ? ctor : _extends({}, ctor, getDerivedStateFromProps);
+ workInProgress.memoizedState = getDerivedStateFromProps;
+ nextProps = workInProgress.updateQueue;
+ null !== nextProps && 0 === workInProgress.expirationTime && (nextProps.baseState = getDerivedStateFromProps);
+ }
+
+ var classComponentUpdater = {
+ isMounted: function isMounted(component) {
+ return (component = component._reactInternalFiber) ? 2 === isFiberMountedImpl(component) : !1;
+ },
+ enqueueSetState: function enqueueSetState(inst, payload, callback) {
+ inst = inst._reactInternalFiber;
+ var currentTime = requestCurrentTime();
+ currentTime = computeExpirationForFiber(currentTime, inst);
+ var update = createUpdate(currentTime);
+ update.payload = payload;
+ void 0 !== callback && null !== callback && (update.callback = callback);
+ flushPassiveEffects();
+ enqueueUpdate(inst, update);
+ scheduleWork(inst, currentTime);
+ },
+ enqueueReplaceState: function enqueueReplaceState(inst, payload, callback) {
+ inst = inst._reactInternalFiber;
+ var currentTime = requestCurrentTime();
+ currentTime = computeExpirationForFiber(currentTime, inst);
+ var update = createUpdate(currentTime);
+ update.tag = ReplaceState;
+ update.payload = payload;
+ void 0 !== callback && null !== callback && (update.callback = callback);
+ flushPassiveEffects();
+ enqueueUpdate(inst, update);
+ scheduleWork(inst, currentTime);
+ },
+ enqueueForceUpdate: function enqueueForceUpdate(inst, callback) {
+ inst = inst._reactInternalFiber;
+ var currentTime = requestCurrentTime();
+ currentTime = computeExpirationForFiber(currentTime, inst);
+ var update = createUpdate(currentTime);
+ update.tag = ForceUpdate;
+ void 0 !== callback && null !== callback && (update.callback = callback);
+ flushPassiveEffects();
+ enqueueUpdate(inst, update);
+ scheduleWork(inst, currentTime);
+ }
+ };
+
+ function checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext) {
+ workInProgress = workInProgress.stateNode;
+ return "function" === typeof workInProgress.shouldComponentUpdate ? workInProgress.shouldComponentUpdate(newProps, newState, nextContext) : ctor.prototype && ctor.prototype.isPureReactComponent ? !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState) : !0;
+ }
+
+ function constructClassInstance(workInProgress, ctor, props) {
+ var isLegacyContextConsumer = !1,
+ unmaskedContext = emptyContextObject;
+ var context = ctor.contextType;
+ "object" === typeof context && null !== context ? context = readContext(context) : (unmaskedContext = isContextProvider(ctor) ? previousContext : contextStackCursor.current, isLegacyContextConsumer = ctor.contextTypes, context = (isLegacyContextConsumer = null !== isLegacyContextConsumer && void 0 !== isLegacyContextConsumer) ? getMaskedContext(workInProgress, unmaskedContext) : emptyContextObject);
+ ctor = new ctor(props, context);
+ workInProgress.memoizedState = null !== ctor.state && void 0 !== ctor.state ? ctor.state : null;
+ ctor.updater = classComponentUpdater;
+ workInProgress.stateNode = ctor;
+ ctor._reactInternalFiber = workInProgress;
+ isLegacyContextConsumer && (workInProgress = workInProgress.stateNode, workInProgress.__reactInternalMemoizedUnmaskedChildContext = unmaskedContext, workInProgress.__reactInternalMemoizedMaskedChildContext = context);
+ return ctor;
+ }
+
+ function callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext) {
+ workInProgress = instance.state;
+ "function" === typeof instance.componentWillReceiveProps && instance.componentWillReceiveProps(newProps, nextContext);
+ "function" === typeof instance.UNSAFE_componentWillReceiveProps && instance.UNSAFE_componentWillReceiveProps(newProps, nextContext);
+ instance.state !== workInProgress && classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
+ }
+
+ function mountClassInstance(workInProgress, ctor, newProps, renderExpirationTime) {
+ var instance = workInProgress.stateNode;
+ instance.props = newProps;
+ instance.state = workInProgress.memoizedState;
+ instance.refs = emptyRefsObject;
+ var contextType = ctor.contextType;
+ "object" === typeof contextType && null !== contextType ? instance.context = readContext(contextType) : (contextType = isContextProvider(ctor) ? previousContext : contextStackCursor.current, instance.context = getMaskedContext(workInProgress, contextType));
+ contextType = workInProgress.updateQueue;
+ null !== contextType && (processUpdateQueue(workInProgress, contextType, newProps, instance, renderExpirationTime), instance.state = workInProgress.memoizedState);
+ contextType = ctor.getDerivedStateFromProps;
+ "function" === typeof contextType && (applyDerivedStateFromProps(workInProgress, ctor, contextType, newProps), instance.state = workInProgress.memoizedState);
+ "function" === typeof ctor.getDerivedStateFromProps || "function" === typeof instance.getSnapshotBeforeUpdate || "function" !== typeof instance.UNSAFE_componentWillMount && "function" !== typeof instance.componentWillMount || (ctor = instance.state, "function" === typeof instance.componentWillMount && instance.componentWillMount(), "function" === typeof instance.UNSAFE_componentWillMount && instance.UNSAFE_componentWillMount(), ctor !== instance.state && classComponentUpdater.enqueueReplaceState(instance, instance.state, null), contextType = workInProgress.updateQueue, null !== contextType && (processUpdateQueue(workInProgress, contextType, newProps, instance, renderExpirationTime), instance.state = workInProgress.memoizedState));
+ "function" === typeof instance.componentDidMount && (workInProgress.effectTag |= 4);
+ }
+
+ var isArray = Array.isArray;
+
+ function coerceRef(returnFiber, current$$1, element) {
+ returnFiber = element.ref;
+
+ if (null !== returnFiber && "function" !== typeof returnFiber && "object" !== typeof returnFiber) {
+ if (element._owner) {
+ element = element._owner;
+ var inst = void 0;
+ element && (invariant(1 === element.tag, "Function components cannot have refs. Did you mean to use React.forwardRef()?"), 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$$1 && null !== current$$1.ref && "function" === typeof current$$1.ref && current$$1.ref._stringRef === stringRef) return current$$1.ref;
+
+ current$$1 = function current$$1(value) {
+ var refs = inst.refs;
+ refs === emptyRefsObject && (refs = inst.refs = {});
+ null === value ? delete refs[stringRef] : refs[stringRef] = value;
+ };
+
+ current$$1._stringRef = stringRef;
+ return current$$1;
+ }
+
+ invariant("string" === typeof returnFiber, "Expected ref to be a function, a string, an object returned by React.createRef(), or null.");
+ 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 function component\n2. You may be adding a ref to a component that was not created inside a component's render method\n3. You have multiple copies of React loaded\nSee https://fb.me/react-refs-must-have-owner for more information.", 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$$1, textContent, expirationTime) {
+ if (null === current$$1 || 6 !== current$$1.tag) return current$$1 = createFiberFromText(textContent, returnFiber.mode, expirationTime), current$$1.return = returnFiber, current$$1;
+ current$$1 = useFiber(current$$1, textContent, expirationTime);
+ current$$1.return = returnFiber;
+ return current$$1;
+ }
+
+ function updateElement(returnFiber, current$$1, element, expirationTime) {
+ if (null !== current$$1 && current$$1.elementType === element.type) return expirationTime = useFiber(current$$1, element.props, expirationTime), expirationTime.ref = coerceRef(returnFiber, current$$1, element), expirationTime.return = returnFiber, expirationTime;
+ expirationTime = createFiberFromTypeAndProps(element.type, element.key, element.props, null, returnFiber.mode, expirationTime);
+ expirationTime.ref = coerceRef(returnFiber, current$$1, element);
+ expirationTime.return = returnFiber;
+ return expirationTime;
+ }
+
+ function updatePortal(returnFiber, current$$1, portal, expirationTime) {
+ if (null === current$$1 || 4 !== current$$1.tag || current$$1.stateNode.containerInfo !== portal.containerInfo || current$$1.stateNode.implementation !== portal.implementation) return current$$1 = createFiberFromPortal(portal, returnFiber.mode, expirationTime), current$$1.return = returnFiber, current$$1;
+ current$$1 = useFiber(current$$1, portal.children || [], expirationTime);
+ current$$1.return = returnFiber;
+ return current$$1;
+ }
+
+ function updateFragment(returnFiber, current$$1, fragment, expirationTime, key) {
+ if (null === current$$1 || 7 !== current$$1.tag) return current$$1 = createFiberFromFragment(fragment, returnFiber.mode, expirationTime, key), current$$1.return = returnFiber, current$$1;
+ current$$1 = useFiber(current$$1, fragment, expirationTime);
+ current$$1.return = returnFiber;
+ return current$$1;
+ }
+
+ function createChild(returnFiber, newChild, expirationTime) {
+ if ("string" === typeof newChild || "number" === typeof newChild) return newChild = createFiberFromText("" + newChild, returnFiber.mode, expirationTime), newChild.return = returnFiber, newChild;
+
+ if ("object" === typeof newChild && null !== newChild) {
+ switch (newChild.$$typeof) {
+ case REACT_ELEMENT_TYPE:
+ return expirationTime = createFiberFromTypeAndProps(newChild.type, newChild.key, newChild.props, null, returnFiber.mode, expirationTime), expirationTime.ref = coerceRef(returnFiber, null, newChild), expirationTime.return = returnFiber, expirationTime;
+
+ case REACT_PORTAL_TYPE:
+ return newChild = createFiberFromPortal(newChild, returnFiber.mode, expirationTime), newChild.return = returnFiber, newChild;
+ }
+
+ if (isArray(newChild) || getIteratorFn(newChild)) return newChild = createFiberFromFragment(newChild, returnFiber.mode, expirationTime, null), newChild.return = returnFiber, newChild;
+ throwOnInvalidObjectType(returnFiber, newChild);
+ }
+
+ return null;
+ }
+
+ function updateSlot(returnFiber, oldFiber, newChild, expirationTime) {
+ var key = null !== oldFiber ? oldFiber.key : null;
+ if ("string" === typeof newChild || "number" === typeof newChild) return null !== key ? null : updateTextNode(returnFiber, oldFiber, "" + newChild, expirationTime);
+
+ if ("object" === typeof newChild && null !== newChild) {
+ switch (newChild.$$typeof) {
+ case REACT_ELEMENT_TYPE:
+ return newChild.key === key ? newChild.type === REACT_FRAGMENT_TYPE ? updateFragment(returnFiber, oldFiber, newChild.props.children, expirationTime, key) : updateElement(returnFiber, oldFiber, newChild, expirationTime) : null;
+
+ case REACT_PORTAL_TYPE:
+ return newChild.key === key ? updatePortal(returnFiber, oldFiber, newChild, expirationTime) : null;
+ }
+
+ if (isArray(newChild) || getIteratorFn(newChild)) return null !== key ? null : updateFragment(returnFiber, oldFiber, newChild, expirationTime, null);
+ throwOnInvalidObjectType(returnFiber, newChild);
+ }
+
+ return null;
+ }
+
+ function updateFromMap(existingChildren, returnFiber, newIdx, newChild, expirationTime) {
+ if ("string" === typeof newChild || "number" === typeof newChild) return existingChildren = existingChildren.get(newIdx) || null, updateTextNode(returnFiber, existingChildren, "" + newChild, expirationTime);
+
+ if ("object" === typeof newChild && null !== newChild) {
+ switch (newChild.$$typeof) {
+ case REACT_ELEMENT_TYPE:
+ return existingChildren = existingChildren.get(null === newChild.key ? newIdx : newChild.key) || null, newChild.type === REACT_FRAGMENT_TYPE ? updateFragment(returnFiber, existingChildren, newChild.props.children, expirationTime, newChild.key) : updateElement(returnFiber, existingChildren, newChild, expirationTime);
+
+ case REACT_PORTAL_TYPE:
+ return existingChildren = existingChildren.get(null === newChild.key ? newIdx : newChild.key) || null, updatePortal(returnFiber, existingChildren, newChild, expirationTime);
+ }
+
+ if (isArray(newChild) || getIteratorFn(newChild)) return existingChildren = existingChildren.get(newIdx) || null, updateFragment(returnFiber, existingChildren, newChild, expirationTime, null);
+ throwOnInvalidObjectType(returnFiber, newChild);
+ }
+
+ return null;
+ }
+
+ function reconcileChildrenArray(returnFiber, currentFirstChild, newChildren, expirationTime) {
+ for (var resultingFirstChild = null, previousNewFiber = null, oldFiber = currentFirstChild, newIdx = currentFirstChild = 0, nextOldFiber = null; null !== oldFiber && newIdx < newChildren.length; newIdx++) {
+ oldFiber.index > newIdx ? (nextOldFiber = oldFiber, oldFiber = null) : nextOldFiber = oldFiber.sibling;
+ var newFiber = updateSlot(returnFiber, oldFiber, newChildren[newIdx], expirationTime);
+
+ if (null === newFiber) {
+ null === oldFiber && (oldFiber = nextOldFiber);
+ break;
+ }
+
+ shouldTrackSideEffects && oldFiber && null === newFiber.alternate && deleteChild(returnFiber, oldFiber);
+ currentFirstChild = placeChild(newFiber, currentFirstChild, newIdx);
+ null === previousNewFiber ? resultingFirstChild = newFiber : previousNewFiber.sibling = newFiber;
+ previousNewFiber = newFiber;
+ oldFiber = nextOldFiber;
+ }
+
+ if (newIdx === newChildren.length) return deleteRemainingChildren(returnFiber, oldFiber), resultingFirstChild;
+
+ if (null === oldFiber) {
+ for (; newIdx < newChildren.length; newIdx++) {
+ 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 (7 === isUnkeyedTopLevelFragment.tag ? newChild.type === REACT_FRAGMENT_TYPE : isUnkeyedTopLevelFragment.elementType === newChild.type) {
+ deleteRemainingChildren(returnFiber, isUnkeyedTopLevelFragment.sibling);
+ currentFirstChild = useFiber(isUnkeyedTopLevelFragment, newChild.type === REACT_FRAGMENT_TYPE ? newChild.props.children : newChild.props, expirationTime);
+ currentFirstChild.ref = coerceRef(returnFiber, isUnkeyedTopLevelFragment, newChild);
+ currentFirstChild.return = returnFiber;
+ returnFiber = currentFirstChild;
+ break a;
+ } 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 = createFiberFromTypeAndProps(newChild.type, newChild.key, newChild.props, null, returnFiber.mode, expirationTime), expirationTime.ref = coerceRef(returnFiber, currentFirstChild, newChild), expirationTime.return = returnFiber, returnFiber = expirationTime);
+ }
+
+ return placeSingleChild(returnFiber);
+
+ case REACT_PORTAL_TYPE:
+ a: {
+ for (isUnkeyedTopLevelFragment = newChild.key; null !== currentFirstChild;) {
+ if (currentFirstChild.key === isUnkeyedTopLevelFragment) {
+ if (4 === currentFirstChild.tag && currentFirstChild.stateNode.containerInfo === newChild.containerInfo && currentFirstChild.stateNode.implementation === newChild.implementation) {
+ deleteRemainingChildren(returnFiber, currentFirstChild.sibling);
+ currentFirstChild = useFiber(currentFirstChild, newChild.children || [], expirationTime);
+ currentFirstChild.return = returnFiber;
+ returnFiber = currentFirstChild;
+ break a;
+ } 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(newChild)) return reconcileChildrenArray(returnFiber, currentFirstChild, newChild, expirationTime);
+ if (getIteratorFn(newChild)) return reconcileChildrenIterator(returnFiber, currentFirstChild, newChild, expirationTime);
+ isObject && throwOnInvalidObjectType(returnFiber, newChild);
+ if ("undefined" === typeof newChild && !isUnkeyedTopLevelFragment) switch (returnFiber.tag) {
+ case 1:
+ case 0:
+ 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),
+ NO_CONTEXT = {},
+ contextStackCursor$1 = {
+ current: NO_CONTEXT
+ },
+ contextFiberStackCursor = {
+ current: NO_CONTEXT
+ },
+ rootInstanceStackCursor = {
+ current: 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 pushHostContext(fiber) {
+ requiredContext(rootInstanceStackCursor.current);
+ var context = requiredContext(contextStackCursor$1.current);
+ var nextContext = fiber.type;
+ nextContext = "AndroidTextInput" === nextContext || "RCTMultilineTextInputView" === nextContext || "RCTSinglelineTextInputView" === nextContext || "RCTText" === nextContext || "RCTVirtualText" === nextContext;
+ nextContext = context.isInAParentText !== nextContext ? {
+ isInAParentText: nextContext
+ } : context;
+ context !== nextContext && (push(contextFiberStackCursor, fiber, fiber), push(contextStackCursor$1, nextContext, fiber));
+ }
+
+ function popHostContext(fiber) {
+ contextFiberStackCursor.current === fiber && (pop(contextStackCursor$1, fiber), pop(contextFiberStackCursor, fiber));
+ }
+
+ var NoEffect$1 = 0,
+ UnmountSnapshot = 2,
+ UnmountMutation = 4,
+ MountMutation = 8,
+ UnmountLayout = 16,
+ MountLayout = 32,
+ MountPassive = 64,
+ UnmountPassive = 128,
+ ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher,
+ renderExpirationTime = 0,
+ currentlyRenderingFiber$1 = null,
+ currentHook = null,
+ nextCurrentHook = null,
+ firstWorkInProgressHook = null,
+ workInProgressHook = null,
+ nextWorkInProgressHook = null,
+ remainingExpirationTime = 0,
+ componentUpdateQueue = null,
+ sideEffectTag = 0,
+ didScheduleRenderPhaseUpdate = !1,
+ renderPhaseUpdates = null,
+ numberOfReRenders = 0;
+
+ function throwInvalidHookError() {
+ invariant(!1, "Hooks can only be called inside the body of a function component. (https://fb.me/react-invalid-hook-call)");
+ }
+
+ function areHookInputsEqual(nextDeps, prevDeps) {
+ if (null === prevDeps) return !1;
+
+ for (var i = 0; i < prevDeps.length && i < nextDeps.length; i++) {
+ if (!is(nextDeps[i], prevDeps[i])) return !1;
+ }
+
+ return !0;
+ }
+
+ function renderWithHooks(current, workInProgress, Component, props, refOrContext, nextRenderExpirationTime) {
+ renderExpirationTime = nextRenderExpirationTime;
+ currentlyRenderingFiber$1 = workInProgress;
+ nextCurrentHook = null !== current ? current.memoizedState : null;
+ ReactCurrentDispatcher$1.current = null === nextCurrentHook ? HooksDispatcherOnMount : HooksDispatcherOnUpdate;
+ workInProgress = Component(props, refOrContext);
+
+ if (didScheduleRenderPhaseUpdate) {
+ do {
+ didScheduleRenderPhaseUpdate = !1, numberOfReRenders += 1, nextCurrentHook = null !== current ? current.memoizedState : null, nextWorkInProgressHook = firstWorkInProgressHook, componentUpdateQueue = workInProgressHook = currentHook = null, ReactCurrentDispatcher$1.current = HooksDispatcherOnUpdate, workInProgress = Component(props, refOrContext);
+ } while (didScheduleRenderPhaseUpdate);
+
+ renderPhaseUpdates = null;
+ numberOfReRenders = 0;
+ }
+
+ ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
+ current = currentlyRenderingFiber$1;
+ current.memoizedState = firstWorkInProgressHook;
+ current.expirationTime = remainingExpirationTime;
+ current.updateQueue = componentUpdateQueue;
+ current.effectTag |= sideEffectTag;
+ current = null !== currentHook && null !== currentHook.next;
+ renderExpirationTime = 0;
+ nextWorkInProgressHook = workInProgressHook = firstWorkInProgressHook = nextCurrentHook = currentHook = currentlyRenderingFiber$1 = null;
+ remainingExpirationTime = 0;
+ componentUpdateQueue = null;
+ sideEffectTag = 0;
+ invariant(!current, "Rendered fewer hooks than expected. This may be caused by an accidental early return statement.");
+ return workInProgress;
+ }
+
+ function resetHooks() {
+ ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
+ renderExpirationTime = 0;
+ nextWorkInProgressHook = workInProgressHook = firstWorkInProgressHook = nextCurrentHook = currentHook = currentlyRenderingFiber$1 = null;
+ remainingExpirationTime = 0;
+ componentUpdateQueue = null;
+ sideEffectTag = 0;
+ didScheduleRenderPhaseUpdate = !1;
+ renderPhaseUpdates = null;
+ numberOfReRenders = 0;
+ }
+
+ function mountWorkInProgressHook() {
+ var hook = {
+ memoizedState: null,
+ baseState: null,
+ queue: null,
+ baseUpdate: null,
+ next: null
+ };
+ null === workInProgressHook ? firstWorkInProgressHook = workInProgressHook = hook : workInProgressHook = workInProgressHook.next = hook;
+ return workInProgressHook;
+ }
+
+ function updateWorkInProgressHook() {
+ if (null !== nextWorkInProgressHook) workInProgressHook = nextWorkInProgressHook, nextWorkInProgressHook = workInProgressHook.next, currentHook = nextCurrentHook, nextCurrentHook = null !== currentHook ? currentHook.next : null;else {
+ invariant(null !== nextCurrentHook, "Rendered more hooks than during the previous render.");
+ currentHook = nextCurrentHook;
+ var newHook = {
+ memoizedState: currentHook.memoizedState,
+ baseState: currentHook.baseState,
+ queue: currentHook.queue,
+ baseUpdate: currentHook.baseUpdate,
+ next: null
+ };
+ workInProgressHook = null === workInProgressHook ? firstWorkInProgressHook = newHook : workInProgressHook.next = newHook;
+ nextCurrentHook = currentHook.next;
+ }
+ return workInProgressHook;
+ }
+
+ function basicStateReducer(state, action) {
+ return "function" === typeof action ? action(state) : action;
+ }
+
+ function updateReducer(reducer) {
+ var hook = updateWorkInProgressHook(),
+ queue = hook.queue;
+ invariant(null !== queue, "Should have a queue. This is likely a bug in React. Please file an issue.");
+
+ if (0 < numberOfReRenders) {
+ var _dispatch = queue.dispatch;
+
+ if (null !== renderPhaseUpdates) {
+ var firstRenderPhaseUpdate = renderPhaseUpdates.get(queue);
+
+ if (void 0 !== firstRenderPhaseUpdate) {
+ renderPhaseUpdates.delete(queue);
+ var newState = hook.memoizedState;
+
+ do {
+ newState = reducer(newState, firstRenderPhaseUpdate.action), firstRenderPhaseUpdate = firstRenderPhaseUpdate.next;
+ } while (null !== firstRenderPhaseUpdate);
+
+ is(newState, hook.memoizedState) || (didReceiveUpdate = !0);
+ hook.memoizedState = newState;
+ hook.baseUpdate === queue.last && (hook.baseState = newState);
+ queue.eagerReducer = reducer;
+ queue.eagerState = newState;
+ return [newState, _dispatch];
+ }
+ }
+
+ return [hook.memoizedState, _dispatch];
+ }
+
+ _dispatch = queue.last;
+ var baseUpdate = hook.baseUpdate;
+ newState = hook.baseState;
+ null !== baseUpdate ? (null !== _dispatch && (_dispatch.next = null), _dispatch = baseUpdate.next) : _dispatch = null !== _dispatch ? _dispatch.next : null;
+
+ if (null !== _dispatch) {
+ var newBaseUpdate = firstRenderPhaseUpdate = null,
+ _update = _dispatch,
+ didSkip = !1;
+
+ do {
+ var updateExpirationTime = _update.expirationTime;
+ updateExpirationTime < renderExpirationTime ? (didSkip || (didSkip = !0, newBaseUpdate = baseUpdate, firstRenderPhaseUpdate = newState), updateExpirationTime > remainingExpirationTime && (remainingExpirationTime = updateExpirationTime)) : newState = _update.eagerReducer === reducer ? _update.eagerState : reducer(newState, _update.action);
+ baseUpdate = _update;
+ _update = _update.next;
+ } while (null !== _update && _update !== _dispatch);
+
+ didSkip || (newBaseUpdate = baseUpdate, firstRenderPhaseUpdate = newState);
+ is(newState, hook.memoizedState) || (didReceiveUpdate = !0);
+ hook.memoizedState = newState;
+ hook.baseUpdate = newBaseUpdate;
+ hook.baseState = firstRenderPhaseUpdate;
+ queue.eagerReducer = reducer;
+ queue.eagerState = newState;
+ }
+
+ return [hook.memoizedState, queue.dispatch];
+ }
+
+ function pushEffect(tag, create, destroy, deps) {
+ tag = {
+ tag: tag,
+ create: create,
+ destroy: destroy,
+ deps: deps,
+ next: null
+ };
+ null === componentUpdateQueue ? (componentUpdateQueue = {
+ lastEffect: null
+ }, componentUpdateQueue.lastEffect = tag.next = tag) : (create = componentUpdateQueue.lastEffect, null === create ? componentUpdateQueue.lastEffect = tag.next = tag : (destroy = create.next, create.next = tag, tag.next = destroy, componentUpdateQueue.lastEffect = tag));
+ return tag;
+ }
+
+ function mountEffectImpl(fiberEffectTag, hookEffectTag, create, deps) {
+ var hook = mountWorkInProgressHook();
+ sideEffectTag |= fiberEffectTag;
+ hook.memoizedState = pushEffect(hookEffectTag, create, void 0, void 0 === deps ? null : deps);
+ }
+
+ function updateEffectImpl(fiberEffectTag, hookEffectTag, create, deps) {
+ var hook = updateWorkInProgressHook();
+ deps = void 0 === deps ? null : deps;
+ var destroy = void 0;
+
+ if (null !== currentHook) {
+ var prevEffect = currentHook.memoizedState;
+ destroy = prevEffect.destroy;
+
+ if (null !== deps && areHookInputsEqual(deps, prevEffect.deps)) {
+ pushEffect(NoEffect$1, create, destroy, deps);
+ return;
+ }
+ }
+
+ sideEffectTag |= fiberEffectTag;
+ hook.memoizedState = pushEffect(hookEffectTag, create, destroy, deps);
+ }
+
+ function imperativeHandleEffect(create, ref) {
+ if ("function" === typeof ref) return create = create(), ref(create), function () {
+ ref(null);
+ };
+ if (null !== ref && void 0 !== ref) return create = create(), ref.current = create, function () {
+ ref.current = null;
+ };
+ }
+
+ function mountDebugValue() {}
+
+ function dispatchAction(fiber, queue, action) {
+ invariant(25 > numberOfReRenders, "Too many re-renders. React limits the number of renders to prevent an infinite loop.");
+ var alternate = fiber.alternate;
+ if (fiber === currentlyRenderingFiber$1 || null !== alternate && alternate === currentlyRenderingFiber$1) {
+ if (didScheduleRenderPhaseUpdate = !0, fiber = {
+ expirationTime: renderExpirationTime,
+ action: action,
+ eagerReducer: null,
+ eagerState: null,
+ next: null
+ }, null === renderPhaseUpdates && (renderPhaseUpdates = new Map()), action = renderPhaseUpdates.get(queue), void 0 === action) renderPhaseUpdates.set(queue, fiber);else {
+ for (queue = action; null !== queue.next;) {
+ queue = queue.next;
+ }
+
+ queue.next = fiber;
+ }
+ } else {
+ flushPassiveEffects();
+ var currentTime = requestCurrentTime();
+ currentTime = computeExpirationForFiber(currentTime, fiber);
+ var _update2 = {
+ expirationTime: currentTime,
+ action: action,
+ eagerReducer: null,
+ eagerState: null,
+ next: null
+ },
+ _last = queue.last;
+ if (null === _last) _update2.next = _update2;else {
+ var first = _last.next;
+ null !== first && (_update2.next = first);
+ _last.next = _update2;
+ }
+ queue.last = _update2;
+ if (0 === fiber.expirationTime && (null === alternate || 0 === alternate.expirationTime) && (alternate = queue.eagerReducer, null !== alternate)) try {
+ var currentState = queue.eagerState,
+ _eagerState = alternate(currentState, action);
+
+ _update2.eagerReducer = alternate;
+ _update2.eagerState = _eagerState;
+ if (is(_eagerState, currentState)) return;
+ } catch (error) {} finally {}
+ scheduleWork(fiber, currentTime);
+ }
+ }
+
+ var ContextOnlyDispatcher = {
+ readContext: readContext,
+ useCallback: throwInvalidHookError,
+ useContext: throwInvalidHookError,
+ useEffect: throwInvalidHookError,
+ useImperativeHandle: throwInvalidHookError,
+ useLayoutEffect: throwInvalidHookError,
+ useMemo: throwInvalidHookError,
+ useReducer: throwInvalidHookError,
+ useRef: throwInvalidHookError,
+ useState: throwInvalidHookError,
+ useDebugValue: throwInvalidHookError
+ },
+ HooksDispatcherOnMount = {
+ readContext: readContext,
+ useCallback: function useCallback(callback, deps) {
+ mountWorkInProgressHook().memoizedState = [callback, void 0 === deps ? null : deps];
+ return callback;
+ },
+ useContext: readContext,
+ useEffect: function useEffect(create, deps) {
+ return mountEffectImpl(516, UnmountPassive | MountPassive, create, deps);
+ },
+ useImperativeHandle: function useImperativeHandle(ref, create, deps) {
+ deps = null !== deps && void 0 !== deps ? deps.concat([ref]) : null;
+ return mountEffectImpl(4, UnmountMutation | MountLayout, imperativeHandleEffect.bind(null, create, ref), deps);
+ },
+ useLayoutEffect: function useLayoutEffect(create, deps) {
+ return mountEffectImpl(4, UnmountMutation | MountLayout, create, deps);
+ },
+ useMemo: function useMemo(nextCreate, deps) {
+ var hook = mountWorkInProgressHook();
+ deps = void 0 === deps ? null : deps;
+ nextCreate = nextCreate();
+ hook.memoizedState = [nextCreate, deps];
+ return nextCreate;
+ },
+ useReducer: function useReducer(reducer, initialArg, init) {
+ var hook = mountWorkInProgressHook();
+ initialArg = void 0 !== init ? init(initialArg) : initialArg;
+ hook.memoizedState = hook.baseState = initialArg;
+ reducer = hook.queue = {
+ last: null,
+ dispatch: null,
+ eagerReducer: reducer,
+ eagerState: initialArg
+ };
+ reducer = reducer.dispatch = dispatchAction.bind(null, currentlyRenderingFiber$1, reducer);
+ return [hook.memoizedState, reducer];
+ },
+ useRef: function useRef(initialValue) {
+ var hook = mountWorkInProgressHook();
+ initialValue = {
+ current: initialValue
+ };
+ return hook.memoizedState = initialValue;
+ },
+ useState: function useState(initialState) {
+ var hook = mountWorkInProgressHook();
+ "function" === typeof initialState && (initialState = initialState());
+ hook.memoizedState = hook.baseState = initialState;
+ initialState = hook.queue = {
+ last: null,
+ dispatch: null,
+ eagerReducer: basicStateReducer,
+ eagerState: initialState
+ };
+ initialState = initialState.dispatch = dispatchAction.bind(null, currentlyRenderingFiber$1, initialState);
+ return [hook.memoizedState, initialState];
+ },
+ useDebugValue: mountDebugValue
+ },
+ HooksDispatcherOnUpdate = {
+ readContext: readContext,
+ useCallback: function useCallback(callback, deps) {
+ var hook = updateWorkInProgressHook();
+ deps = void 0 === deps ? null : deps;
+ var prevState = hook.memoizedState;
+ if (null !== prevState && null !== deps && areHookInputsEqual(deps, prevState[1])) return prevState[0];
+ hook.memoizedState = [callback, deps];
+ return callback;
+ },
+ useContext: readContext,
+ useEffect: function useEffect(create, deps) {
+ return updateEffectImpl(516, UnmountPassive | MountPassive, create, deps);
+ },
+ useImperativeHandle: function useImperativeHandle(ref, create, deps) {
+ deps = null !== deps && void 0 !== deps ? deps.concat([ref]) : null;
+ return updateEffectImpl(4, UnmountMutation | MountLayout, imperativeHandleEffect.bind(null, create, ref), deps);
+ },
+ useLayoutEffect: function useLayoutEffect(create, deps) {
+ return updateEffectImpl(4, UnmountMutation | MountLayout, create, deps);
+ },
+ useMemo: function useMemo(nextCreate, deps) {
+ var hook = updateWorkInProgressHook();
+ deps = void 0 === deps ? null : deps;
+ var prevState = hook.memoizedState;
+ if (null !== prevState && null !== deps && areHookInputsEqual(deps, prevState[1])) return prevState[0];
+ nextCreate = nextCreate();
+ hook.memoizedState = [nextCreate, deps];
+ return nextCreate;
+ },
+ useReducer: updateReducer,
+ useRef: function useRef() {
+ return updateWorkInProgressHook().memoizedState;
+ },
+ useState: function useState(initialState) {
+ return updateReducer(basicStateReducer, initialState);
+ },
+ useDebugValue: mountDebugValue
+ },
+ hydrationParentFiber = null,
+ nextHydratableInstance = null,
+ isHydrating = !1;
+
+ function tryHydrate(fiber, nextInstance) {
+ switch (fiber.tag) {
+ case 5:
+ return nextInstance = shim$1(nextInstance, fiber.type, fiber.pendingProps), null !== nextInstance ? (fiber.stateNode = nextInstance, !0) : !1;
+
+ case 6:
+ return nextInstance = shim$1(nextInstance, fiber.pendingProps), null !== nextInstance ? (fiber.stateNode = nextInstance, !0) : !1;
+
+ case 13:
+ return !1;
+
+ default:
+ return !1;
+ }
+ }
+
+ function tryToClaimNextHydratableInstance(fiber$jscomp$0) {
+ if (isHydrating) {
+ var nextInstance = nextHydratableInstance;
+
+ if (nextInstance) {
+ var firstAttemptedInstance = nextInstance;
+
+ if (!tryHydrate(fiber$jscomp$0, nextInstance)) {
+ nextInstance = shim$1(firstAttemptedInstance);
+
+ if (!nextInstance || !tryHydrate(fiber$jscomp$0, nextInstance)) {
+ fiber$jscomp$0.effectTag |= 2;
+ isHydrating = !1;
+ hydrationParentFiber = fiber$jscomp$0;
+ return;
+ }
+
+ var returnFiber = hydrationParentFiber,
+ fiber = createFiber(5, null, null, 0);
+ fiber.elementType = "DELETED";
+ fiber.type = "DELETED";
+ fiber.stateNode = firstAttemptedInstance;
+ fiber.return = returnFiber;
+ fiber.effectTag = 8;
+ null !== returnFiber.lastEffect ? (returnFiber.lastEffect.nextEffect = fiber, returnFiber.lastEffect = fiber) : returnFiber.firstEffect = returnFiber.lastEffect = fiber;
+ }
+
+ hydrationParentFiber = fiber$jscomp$0;
+ nextHydratableInstance = shim$1(nextInstance);
+ } else fiber$jscomp$0.effectTag |= 2, isHydrating = !1, hydrationParentFiber = fiber$jscomp$0;
+ }
+ }
+
+ var ReactCurrentOwner$3 = ReactSharedInternals.ReactCurrentOwner,
+ didReceiveUpdate = !1;
+
+ function reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime) {
+ workInProgress.child = null === current$$1 ? mountChildFibers(workInProgress, null, nextChildren, renderExpirationTime) : reconcileChildFibers(workInProgress, current$$1.child, nextChildren, renderExpirationTime);
+ }
+
+ function updateForwardRef(current$$1, workInProgress, Component, nextProps, renderExpirationTime) {
+ Component = Component.render;
+ var ref = workInProgress.ref;
+ prepareToReadContext(workInProgress, renderExpirationTime);
+ nextProps = renderWithHooks(current$$1, workInProgress, Component, nextProps, ref, renderExpirationTime);
+ if (null !== current$$1 && !didReceiveUpdate) return workInProgress.updateQueue = current$$1.updateQueue, workInProgress.effectTag &= -517, current$$1.expirationTime <= renderExpirationTime && (current$$1.expirationTime = 0), bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ workInProgress.effectTag |= 1;
+ reconcileChildren(current$$1, workInProgress, nextProps, renderExpirationTime);
+ return workInProgress.child;
+ }
+
+ function updateMemoComponent(current$$1, workInProgress, Component, nextProps, updateExpirationTime, renderExpirationTime) {
+ if (null === current$$1) {
+ var type = Component.type;
+ if ("function" === typeof type && !shouldConstruct(type) && void 0 === type.defaultProps && null === Component.compare && void 0 === Component.defaultProps) return workInProgress.tag = 15, workInProgress.type = type, updateSimpleMemoComponent(current$$1, workInProgress, type, nextProps, updateExpirationTime, renderExpirationTime);
+ current$$1 = createFiberFromTypeAndProps(Component.type, null, nextProps, null, workInProgress.mode, renderExpirationTime);
+ current$$1.ref = workInProgress.ref;
+ current$$1.return = workInProgress;
+ return workInProgress.child = current$$1;
+ }
+
+ type = current$$1.child;
+ if (updateExpirationTime < renderExpirationTime && (updateExpirationTime = type.memoizedProps, Component = Component.compare, Component = null !== Component ? Component : shallowEqual, Component(updateExpirationTime, nextProps) && current$$1.ref === workInProgress.ref)) return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ workInProgress.effectTag |= 1;
+ current$$1 = createWorkInProgress(type, nextProps, renderExpirationTime);
+ current$$1.ref = workInProgress.ref;
+ current$$1.return = workInProgress;
+ return workInProgress.child = current$$1;
+ }
+
+ function updateSimpleMemoComponent(current$$1, workInProgress, Component, nextProps, updateExpirationTime, renderExpirationTime) {
+ return null !== current$$1 && shallowEqual(current$$1.memoizedProps, nextProps) && current$$1.ref === workInProgress.ref && (didReceiveUpdate = !1, updateExpirationTime < renderExpirationTime) ? bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime) : updateFunctionComponent(current$$1, workInProgress, Component, nextProps, renderExpirationTime);
+ }
+
+ function markRef(current$$1, workInProgress) {
+ var ref = workInProgress.ref;
+ if (null === current$$1 && null !== ref || null !== current$$1 && current$$1.ref !== ref) workInProgress.effectTag |= 128;
+ }
+
+ function updateFunctionComponent(current$$1, workInProgress, Component, nextProps, renderExpirationTime) {
+ var unmaskedContext = isContextProvider(Component) ? previousContext : contextStackCursor.current;
+ unmaskedContext = getMaskedContext(workInProgress, unmaskedContext);
+ prepareToReadContext(workInProgress, renderExpirationTime);
+ Component = renderWithHooks(current$$1, workInProgress, Component, nextProps, unmaskedContext, renderExpirationTime);
+ if (null !== current$$1 && !didReceiveUpdate) return workInProgress.updateQueue = current$$1.updateQueue, workInProgress.effectTag &= -517, current$$1.expirationTime <= renderExpirationTime && (current$$1.expirationTime = 0), bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ workInProgress.effectTag |= 1;
+ reconcileChildren(current$$1, workInProgress, Component, renderExpirationTime);
+ return workInProgress.child;
+ }
+
+ function updateClassComponent(current$$1, workInProgress, Component, nextProps, renderExpirationTime) {
+ if (isContextProvider(Component)) {
+ var hasContext = !0;
+ pushContextProvider(workInProgress);
+ } else hasContext = !1;
+
+ prepareToReadContext(workInProgress, renderExpirationTime);
+ if (null === workInProgress.stateNode) null !== current$$1 && (current$$1.alternate = null, workInProgress.alternate = null, workInProgress.effectTag |= 2), constructClassInstance(workInProgress, Component, nextProps, renderExpirationTime), mountClassInstance(workInProgress, Component, nextProps, renderExpirationTime), nextProps = !0;else if (null === current$$1) {
+ var instance = workInProgress.stateNode,
+ oldProps = workInProgress.memoizedProps;
+ instance.props = oldProps;
+ var oldContext = instance.context,
+ contextType = Component.contextType;
+ "object" === typeof contextType && null !== contextType ? contextType = readContext(contextType) : (contextType = isContextProvider(Component) ? previousContext : contextStackCursor.current, contextType = getMaskedContext(workInProgress, contextType));
+ var getDerivedStateFromProps = Component.getDerivedStateFromProps,
+ hasNewLifecycles = "function" === typeof getDerivedStateFromProps || "function" === typeof instance.getSnapshotBeforeUpdate;
+ hasNewLifecycles || "function" !== typeof instance.UNSAFE_componentWillReceiveProps && "function" !== typeof instance.componentWillReceiveProps || (oldProps !== nextProps || oldContext !== contextType) && callComponentWillReceiveProps(workInProgress, instance, nextProps, contextType);
+ hasForceUpdate = !1;
+ var oldState = workInProgress.memoizedState;
+ oldContext = instance.state = oldState;
+ var updateQueue = workInProgress.updateQueue;
+ null !== updateQueue && (processUpdateQueue(workInProgress, updateQueue, nextProps, instance, renderExpirationTime), oldContext = workInProgress.memoizedState);
+ oldProps !== nextProps || oldState !== oldContext || didPerformWorkStackCursor.current || hasForceUpdate ? ("function" === typeof getDerivedStateFromProps && (applyDerivedStateFromProps(workInProgress, Component, getDerivedStateFromProps, nextProps), oldContext = workInProgress.memoizedState), (oldProps = hasForceUpdate || checkShouldComponentUpdate(workInProgress, Component, oldProps, nextProps, oldState, oldContext, contextType)) ? (hasNewLifecycles || "function" !== typeof instance.UNSAFE_componentWillMount && "function" !== typeof instance.componentWillMount || ("function" === typeof instance.componentWillMount && instance.componentWillMount(), "function" === typeof instance.UNSAFE_componentWillMount && instance.UNSAFE_componentWillMount()), "function" === typeof instance.componentDidMount && (workInProgress.effectTag |= 4)) : ("function" === typeof instance.componentDidMount && (workInProgress.effectTag |= 4), workInProgress.memoizedProps = nextProps, workInProgress.memoizedState = oldContext), instance.props = nextProps, instance.state = oldContext, instance.context = contextType, nextProps = oldProps) : ("function" === typeof instance.componentDidMount && (workInProgress.effectTag |= 4), nextProps = !1);
+ } else instance = workInProgress.stateNode, oldProps = workInProgress.memoizedProps, instance.props = workInProgress.type === workInProgress.elementType ? oldProps : resolveDefaultProps(workInProgress.type, oldProps), oldContext = instance.context, contextType = Component.contextType, "object" === typeof contextType && null !== contextType ? contextType = readContext(contextType) : (contextType = isContextProvider(Component) ? previousContext : contextStackCursor.current, contextType = getMaskedContext(workInProgress, contextType)), getDerivedStateFromProps = Component.getDerivedStateFromProps, (hasNewLifecycles = "function" === typeof getDerivedStateFromProps || "function" === typeof instance.getSnapshotBeforeUpdate) || "function" !== typeof instance.UNSAFE_componentWillReceiveProps && "function" !== typeof instance.componentWillReceiveProps || (oldProps !== nextProps || oldContext !== contextType) && callComponentWillReceiveProps(workInProgress, instance, nextProps, contextType), hasForceUpdate = !1, oldContext = workInProgress.memoizedState, oldState = instance.state = oldContext, updateQueue = workInProgress.updateQueue, null !== updateQueue && (processUpdateQueue(workInProgress, updateQueue, nextProps, instance, renderExpirationTime), oldState = workInProgress.memoizedState), oldProps !== nextProps || oldContext !== oldState || didPerformWorkStackCursor.current || hasForceUpdate ? ("function" === typeof getDerivedStateFromProps && (applyDerivedStateFromProps(workInProgress, Component, getDerivedStateFromProps, nextProps), oldState = workInProgress.memoizedState), (getDerivedStateFromProps = hasForceUpdate || checkShouldComponentUpdate(workInProgress, Component, oldProps, nextProps, oldContext, oldState, contextType)) ? (hasNewLifecycles || "function" !== typeof instance.UNSAFE_componentWillUpdate && "function" !== typeof instance.componentWillUpdate || ("function" === typeof instance.componentWillUpdate && instance.componentWillUpdate(nextProps, oldState, contextType), "function" === typeof instance.UNSAFE_componentWillUpdate && instance.UNSAFE_componentWillUpdate(nextProps, oldState, contextType)), "function" === typeof instance.componentDidUpdate && (workInProgress.effectTag |= 4), "function" === typeof instance.getSnapshotBeforeUpdate && (workInProgress.effectTag |= 256)) : ("function" !== typeof instance.componentDidUpdate || oldProps === current$$1.memoizedProps && oldContext === current$$1.memoizedState || (workInProgress.effectTag |= 4), "function" !== typeof instance.getSnapshotBeforeUpdate || oldProps === current$$1.memoizedProps && oldContext === current$$1.memoizedState || (workInProgress.effectTag |= 256), workInProgress.memoizedProps = nextProps, workInProgress.memoizedState = oldState), instance.props = nextProps, instance.state = oldState, instance.context = contextType, nextProps = getDerivedStateFromProps) : ("function" !== typeof instance.componentDidUpdate || oldProps === current$$1.memoizedProps && oldContext === current$$1.memoizedState || (workInProgress.effectTag |= 4), "function" !== typeof instance.getSnapshotBeforeUpdate || oldProps === current$$1.memoizedProps && oldContext === current$$1.memoizedState || (workInProgress.effectTag |= 256), nextProps = !1);
+ return finishClassComponent(current$$1, workInProgress, Component, nextProps, hasContext, renderExpirationTime);
+ }
+
+ function finishClassComponent(current$$1, workInProgress, Component, shouldUpdate, hasContext, renderExpirationTime) {
+ markRef(current$$1, workInProgress);
+ var didCaptureError = 0 !== (workInProgress.effectTag & 64);
+ if (!shouldUpdate && !didCaptureError) return hasContext && invalidateContextProvider(workInProgress, Component, !1), bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ shouldUpdate = workInProgress.stateNode;
+ ReactCurrentOwner$3.current = workInProgress;
+ var nextChildren = didCaptureError && "function" !== typeof Component.getDerivedStateFromError ? null : shouldUpdate.render();
+ workInProgress.effectTag |= 1;
+ null !== current$$1 && didCaptureError ? (workInProgress.child = reconcileChildFibers(workInProgress, current$$1.child, null, renderExpirationTime), workInProgress.child = reconcileChildFibers(workInProgress, null, nextChildren, renderExpirationTime)) : reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
+ workInProgress.memoizedState = shouldUpdate.state;
+ hasContext && invalidateContextProvider(workInProgress, Component, !0);
+ return workInProgress.child;
+ }
+
+ function pushHostRootContext(workInProgress) {
+ var root = workInProgress.stateNode;
+ root.pendingContext ? pushTopLevelContextObject(workInProgress, root.pendingContext, root.pendingContext !== root.context) : root.context && pushTopLevelContextObject(workInProgress, root.context, !1);
+ pushHostContainer(workInProgress, root.containerInfo);
+ }
+
+ function updateSuspenseComponent(current$$1, workInProgress, renderExpirationTime) {
+ var mode = workInProgress.mode,
+ nextProps = workInProgress.pendingProps,
+ nextState = workInProgress.memoizedState;
+
+ if (0 === (workInProgress.effectTag & 64)) {
+ nextState = null;
+ var nextDidTimeout = !1;
+ } else nextState = {
+ timedOutAt: null !== nextState ? nextState.timedOutAt : 0
+ }, nextDidTimeout = !0, workInProgress.effectTag &= -65;
+
+ if (null === current$$1) {
+ if (nextDidTimeout) {
+ var nextFallbackChildren = nextProps.fallback;
+ current$$1 = createFiberFromFragment(null, mode, 0, null);
+ 0 === (workInProgress.mode & 1) && (current$$1.child = null !== workInProgress.memoizedState ? workInProgress.child.child : workInProgress.child);
+ mode = createFiberFromFragment(nextFallbackChildren, mode, renderExpirationTime, null);
+ current$$1.sibling = mode;
+ renderExpirationTime = current$$1;
+ renderExpirationTime.return = mode.return = workInProgress;
+ } else renderExpirationTime = mode = mountChildFibers(workInProgress, null, nextProps.children, renderExpirationTime);
+ } else null !== current$$1.memoizedState ? (mode = current$$1.child, nextFallbackChildren = mode.sibling, nextDidTimeout ? (renderExpirationTime = nextProps.fallback, nextProps = createWorkInProgress(mode, mode.pendingProps, 0), 0 === (workInProgress.mode & 1) && (nextDidTimeout = null !== workInProgress.memoizedState ? workInProgress.child.child : workInProgress.child, nextDidTimeout !== mode.child && (nextProps.child = nextDidTimeout)), mode = nextProps.sibling = createWorkInProgress(nextFallbackChildren, renderExpirationTime, nextFallbackChildren.expirationTime), renderExpirationTime = nextProps, nextProps.childExpirationTime = 0, renderExpirationTime.return = mode.return = workInProgress) : renderExpirationTime = mode = reconcileChildFibers(workInProgress, mode.child, nextProps.children, renderExpirationTime)) : (nextFallbackChildren = current$$1.child, nextDidTimeout ? (nextDidTimeout = nextProps.fallback, nextProps = createFiberFromFragment(null, mode, 0, null), nextProps.child = nextFallbackChildren, 0 === (workInProgress.mode & 1) && (nextProps.child = null !== workInProgress.memoizedState ? workInProgress.child.child : workInProgress.child), mode = nextProps.sibling = createFiberFromFragment(nextDidTimeout, mode, renderExpirationTime, null), mode.effectTag |= 2, renderExpirationTime = nextProps, nextProps.childExpirationTime = 0, renderExpirationTime.return = mode.return = workInProgress) : mode = renderExpirationTime = reconcileChildFibers(workInProgress, nextFallbackChildren, nextProps.children, renderExpirationTime)), workInProgress.stateNode = current$$1.stateNode;
+ workInProgress.memoizedState = nextState;
+ workInProgress.child = renderExpirationTime;
+ return mode;
+ }
+
+ function bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime) {
+ null !== current$$1 && (workInProgress.contextDependencies = current$$1.contextDependencies);
+ if (workInProgress.childExpirationTime < renderExpirationTime) return null;
+ invariant(null === current$$1 || workInProgress.child === current$$1.child, "Resuming work not yet implemented.");
+
+ if (null !== workInProgress.child) {
+ current$$1 = workInProgress.child;
+ renderExpirationTime = createWorkInProgress(current$$1, current$$1.pendingProps, current$$1.expirationTime);
+ workInProgress.child = renderExpirationTime;
+
+ for (renderExpirationTime.return = workInProgress; null !== current$$1.sibling;) {
+ current$$1 = current$$1.sibling, renderExpirationTime = renderExpirationTime.sibling = createWorkInProgress(current$$1, current$$1.pendingProps, current$$1.expirationTime), renderExpirationTime.return = workInProgress;
+ }
+
+ renderExpirationTime.sibling = null;
+ }
+
+ return workInProgress.child;
+ }
+
+ function beginWork(current$$1, workInProgress, renderExpirationTime) {
+ var updateExpirationTime = workInProgress.expirationTime;
+ if (null !== current$$1) {
+ if (current$$1.memoizedProps !== workInProgress.pendingProps || didPerformWorkStackCursor.current) didReceiveUpdate = !0;else {
+ if (updateExpirationTime < renderExpirationTime) {
+ didReceiveUpdate = !1;
+
+ switch (workInProgress.tag) {
+ case 3:
+ pushHostRootContext(workInProgress);
+ break;
+
+ case 5:
+ pushHostContext(workInProgress);
+ break;
+
+ case 1:
+ isContextProvider(workInProgress.type) && pushContextProvider(workInProgress);
+ break;
+
+ case 4:
+ pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+ break;
+
+ case 10:
+ pushProvider(workInProgress, workInProgress.memoizedProps.value);
+ break;
+
+ case 13:
+ if (null !== workInProgress.memoizedState) {
+ updateExpirationTime = workInProgress.child.childExpirationTime;
+ if (0 !== updateExpirationTime && updateExpirationTime >= renderExpirationTime) return updateSuspenseComponent(current$$1, workInProgress, renderExpirationTime);
+ workInProgress = bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ return null !== workInProgress ? workInProgress.sibling : null;
+ }
+
+ }
+
+ return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ }
+ }
+ } else didReceiveUpdate = !1;
+ workInProgress.expirationTime = 0;
+
+ switch (workInProgress.tag) {
+ case 2:
+ updateExpirationTime = workInProgress.elementType;
+ null !== current$$1 && (current$$1.alternate = null, workInProgress.alternate = null, workInProgress.effectTag |= 2);
+ current$$1 = workInProgress.pendingProps;
+ var context = getMaskedContext(workInProgress, contextStackCursor.current);
+ prepareToReadContext(workInProgress, renderExpirationTime);
+ context = renderWithHooks(null, workInProgress, updateExpirationTime, current$$1, context, renderExpirationTime);
+ workInProgress.effectTag |= 1;
+
+ if ("object" === typeof context && null !== context && "function" === typeof context.render && void 0 === context.$$typeof) {
+ workInProgress.tag = 1;
+ resetHooks();
+
+ if (isContextProvider(updateExpirationTime)) {
+ var hasContext = !0;
+ pushContextProvider(workInProgress);
+ } else hasContext = !1;
+
+ workInProgress.memoizedState = null !== context.state && void 0 !== context.state ? context.state : null;
+ var getDerivedStateFromProps = updateExpirationTime.getDerivedStateFromProps;
+ "function" === typeof getDerivedStateFromProps && applyDerivedStateFromProps(workInProgress, updateExpirationTime, getDerivedStateFromProps, current$$1);
+ context.updater = classComponentUpdater;
+ workInProgress.stateNode = context;
+ context._reactInternalFiber = workInProgress;
+ mountClassInstance(workInProgress, updateExpirationTime, current$$1, renderExpirationTime);
+ workInProgress = finishClassComponent(null, workInProgress, updateExpirationTime, !0, hasContext, renderExpirationTime);
+ } else workInProgress.tag = 0, reconcileChildren(null, workInProgress, context, renderExpirationTime), workInProgress = workInProgress.child;
+
+ return workInProgress;
+
+ case 16:
+ context = workInProgress.elementType;
+ null !== current$$1 && (current$$1.alternate = null, workInProgress.alternate = null, workInProgress.effectTag |= 2);
+ hasContext = workInProgress.pendingProps;
+ current$$1 = readLazyComponentType(context);
+ workInProgress.type = current$$1;
+ context = workInProgress.tag = resolveLazyComponentTag(current$$1);
+ hasContext = resolveDefaultProps(current$$1, hasContext);
+ getDerivedStateFromProps = void 0;
+
+ switch (context) {
+ case 0:
+ getDerivedStateFromProps = updateFunctionComponent(null, workInProgress, current$$1, hasContext, renderExpirationTime);
+ break;
+
+ case 1:
+ getDerivedStateFromProps = updateClassComponent(null, workInProgress, current$$1, hasContext, renderExpirationTime);
+ break;
+
+ case 11:
+ getDerivedStateFromProps = updateForwardRef(null, workInProgress, current$$1, hasContext, renderExpirationTime);
+ break;
+
+ case 14:
+ getDerivedStateFromProps = updateMemoComponent(null, workInProgress, current$$1, resolveDefaultProps(current$$1.type, hasContext), updateExpirationTime, renderExpirationTime);
+ break;
+
+ default:
+ invariant(!1, "Element type is invalid. Received a promise that resolves to: %s. Lazy element type must resolve to a class or function.%s", current$$1, "");
+ }
+
+ return getDerivedStateFromProps;
+
+ case 0:
+ return updateExpirationTime = workInProgress.type, context = workInProgress.pendingProps, context = workInProgress.elementType === updateExpirationTime ? context : resolveDefaultProps(updateExpirationTime, context), updateFunctionComponent(current$$1, workInProgress, updateExpirationTime, context, renderExpirationTime);
+
+ case 1:
+ return updateExpirationTime = workInProgress.type, context = workInProgress.pendingProps, context = workInProgress.elementType === updateExpirationTime ? context : resolveDefaultProps(updateExpirationTime, context), updateClassComponent(current$$1, workInProgress, updateExpirationTime, context, renderExpirationTime);
+
+ case 3:
+ return pushHostRootContext(workInProgress), updateExpirationTime = workInProgress.updateQueue, invariant(null !== updateExpirationTime, "If the root does not have an updateQueue, we should have already bailed out. This error is likely caused by a bug in React. Please file an issue."), context = workInProgress.memoizedState, context = null !== context ? context.element : null, processUpdateQueue(workInProgress, updateExpirationTime, workInProgress.pendingProps, null, renderExpirationTime), updateExpirationTime = workInProgress.memoizedState.element, updateExpirationTime === context ? workInProgress = bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime) : (reconcileChildren(current$$1, workInProgress, updateExpirationTime, renderExpirationTime), workInProgress = workInProgress.child), workInProgress;
+
+ case 5:
+ return pushHostContext(workInProgress), null === current$$1 && tryToClaimNextHydratableInstance(workInProgress), updateExpirationTime = workInProgress.pendingProps.children, markRef(current$$1, workInProgress), reconcileChildren(current$$1, workInProgress, updateExpirationTime, renderExpirationTime), workInProgress = workInProgress.child, workInProgress;
+
+ case 6:
+ return null === current$$1 && tryToClaimNextHydratableInstance(workInProgress), null;
+
+ case 13:
+ return updateSuspenseComponent(current$$1, workInProgress, renderExpirationTime);
+
+ case 4:
+ return pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo), updateExpirationTime = workInProgress.pendingProps, null === current$$1 ? workInProgress.child = reconcileChildFibers(workInProgress, null, updateExpirationTime, renderExpirationTime) : reconcileChildren(current$$1, workInProgress, updateExpirationTime, renderExpirationTime), workInProgress.child;
+
+ case 11:
+ return updateExpirationTime = workInProgress.type, context = workInProgress.pendingProps, context = workInProgress.elementType === updateExpirationTime ? context : resolveDefaultProps(updateExpirationTime, context), updateForwardRef(current$$1, workInProgress, updateExpirationTime, context, renderExpirationTime);
+
+ case 7:
+ return reconcileChildren(current$$1, workInProgress, workInProgress.pendingProps, renderExpirationTime), workInProgress.child;
+
+ case 8:
+ return reconcileChildren(current$$1, workInProgress, workInProgress.pendingProps.children, renderExpirationTime), workInProgress.child;
+
+ case 12:
+ return reconcileChildren(current$$1, workInProgress, workInProgress.pendingProps.children, renderExpirationTime), workInProgress.child;
+
+ case 10:
+ a: {
+ updateExpirationTime = workInProgress.type._context;
+ context = workInProgress.pendingProps;
+ getDerivedStateFromProps = workInProgress.memoizedProps;
+ hasContext = context.value;
+ pushProvider(workInProgress, hasContext);
+
+ if (null !== getDerivedStateFromProps) {
+ var oldValue = getDerivedStateFromProps.value;
+ hasContext = is(oldValue, hasContext) ? 0 : ("function" === typeof updateExpirationTime._calculateChangedBits ? updateExpirationTime._calculateChangedBits(oldValue, hasContext) : 1073741823) | 0;
+
+ if (0 === hasContext) {
+ if (getDerivedStateFromProps.children === context.children && !didPerformWorkStackCursor.current) {
+ workInProgress = bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ break a;
+ }
+ } else for (oldValue = workInProgress.child, null !== oldValue && (oldValue.return = workInProgress); null !== oldValue;) {
+ var list = oldValue.contextDependencies;
+
+ if (null !== list) {
+ getDerivedStateFromProps = oldValue.child;
+
+ for (var dependency = list.first; null !== dependency;) {
+ if (dependency.context === updateExpirationTime && 0 !== (dependency.observedBits & hasContext)) {
+ 1 === oldValue.tag && (dependency = createUpdate(renderExpirationTime), dependency.tag = ForceUpdate, enqueueUpdate(oldValue, dependency));
+ oldValue.expirationTime < renderExpirationTime && (oldValue.expirationTime = renderExpirationTime);
+ dependency = oldValue.alternate;
+ null !== dependency && dependency.expirationTime < renderExpirationTime && (dependency.expirationTime = renderExpirationTime);
+ dependency = renderExpirationTime;
+
+ for (var node = oldValue.return; null !== node;) {
+ var alternate = node.alternate;
+ if (node.childExpirationTime < dependency) node.childExpirationTime = dependency, null !== alternate && alternate.childExpirationTime < dependency && (alternate.childExpirationTime = dependency);else if (null !== alternate && alternate.childExpirationTime < dependency) alternate.childExpirationTime = dependency;else break;
+ node = node.return;
+ }
+
+ list.expirationTime < renderExpirationTime && (list.expirationTime = renderExpirationTime);
+ break;
+ }
+
+ dependency = dependency.next;
+ }
+ } else getDerivedStateFromProps = 10 === oldValue.tag ? oldValue.type === workInProgress.type ? null : oldValue.child : oldValue.child;
+
+ if (null !== getDerivedStateFromProps) getDerivedStateFromProps.return = oldValue;else for (getDerivedStateFromProps = oldValue; null !== getDerivedStateFromProps;) {
+ if (getDerivedStateFromProps === workInProgress) {
+ getDerivedStateFromProps = null;
+ break;
+ }
+
+ oldValue = getDerivedStateFromProps.sibling;
+
+ if (null !== oldValue) {
+ oldValue.return = getDerivedStateFromProps.return;
+ getDerivedStateFromProps = oldValue;
+ break;
+ }
+
+ getDerivedStateFromProps = getDerivedStateFromProps.return;
+ }
+ oldValue = getDerivedStateFromProps;
+ }
+ }
+
+ reconcileChildren(current$$1, workInProgress, context.children, renderExpirationTime);
+ workInProgress = workInProgress.child;
+ }
+
+ return workInProgress;
+
+ case 9:
+ return context = workInProgress.type, hasContext = workInProgress.pendingProps, updateExpirationTime = hasContext.children, prepareToReadContext(workInProgress, renderExpirationTime), context = readContext(context, hasContext.unstable_observedBits), updateExpirationTime = updateExpirationTime(context), workInProgress.effectTag |= 1, reconcileChildren(current$$1, workInProgress, updateExpirationTime, renderExpirationTime), workInProgress.child;
+
+ case 14:
+ return context = workInProgress.type, hasContext = resolveDefaultProps(context, workInProgress.pendingProps), hasContext = resolveDefaultProps(context.type, hasContext), updateMemoComponent(current$$1, workInProgress, context, hasContext, updateExpirationTime, renderExpirationTime);
+
+ case 15:
+ return updateSimpleMemoComponent(current$$1, workInProgress, workInProgress.type, workInProgress.pendingProps, updateExpirationTime, renderExpirationTime);
+
+ case 17:
+ return updateExpirationTime = workInProgress.type, context = workInProgress.pendingProps, context = workInProgress.elementType === updateExpirationTime ? context : resolveDefaultProps(updateExpirationTime, context), null !== current$$1 && (current$$1.alternate = null, workInProgress.alternate = null, workInProgress.effectTag |= 2), workInProgress.tag = 1, isContextProvider(updateExpirationTime) ? (current$$1 = !0, pushContextProvider(workInProgress)) : current$$1 = !1, prepareToReadContext(workInProgress, renderExpirationTime), constructClassInstance(workInProgress, updateExpirationTime, context, renderExpirationTime), mountClassInstance(workInProgress, updateExpirationTime, context, renderExpirationTime), finishClassComponent(null, workInProgress, updateExpirationTime, !0, current$$1, renderExpirationTime);
+ }
+
+ invariant(!1, "Unknown unit of work tag. This error is likely caused by a bug in React. Please file an issue.");
+ }
+
+ var valueCursor = {
+ current: null
+ },
+ currentlyRenderingFiber = null,
+ lastContextDependency = null,
+ lastContextWithAllBitsObserved = null;
+
+ function pushProvider(providerFiber, nextValue) {
+ var context = providerFiber.type._context;
+ push(valueCursor, context._currentValue, providerFiber);
+ context._currentValue = nextValue;
+ }
+
+ function popProvider(providerFiber) {
+ var currentValue = valueCursor.current;
+ pop(valueCursor, providerFiber);
+ providerFiber.type._context._currentValue = currentValue;
+ }
+
+ function prepareToReadContext(workInProgress, renderExpirationTime) {
+ currentlyRenderingFiber = workInProgress;
+ lastContextWithAllBitsObserved = lastContextDependency = null;
+ var currentDependencies = workInProgress.contextDependencies;
+ null !== currentDependencies && currentDependencies.expirationTime >= renderExpirationTime && (didReceiveUpdate = !0);
+ workInProgress.contextDependencies = null;
+ }
+
+ function readContext(context, observedBits) {
+ if (lastContextWithAllBitsObserved !== context && !1 !== observedBits && 0 !== observedBits) {
+ if ("number" !== typeof observedBits || 1073741823 === observedBits) lastContextWithAllBitsObserved = context, observedBits = 1073741823;
+ observedBits = {
+ context: context,
+ observedBits: observedBits,
+ next: null
+ };
+ null === lastContextDependency ? (invariant(null !== currentlyRenderingFiber, "Context can only be read while React is rendering. In classes, you can read it in the render method or getDerivedStateFromProps. In function components, you can read it directly in the function body, but not inside Hooks like useReducer() or useMemo()."), lastContextDependency = observedBits, currentlyRenderingFiber.contextDependencies = {
+ first: observedBits,
+ expirationTime: 0
+ }) : lastContextDependency = lastContextDependency.next = observedBits;
+ }
+
+ return context._currentValue;
+ }
+
+ var UpdateState = 0,
+ ReplaceState = 1,
+ ForceUpdate = 2,
+ CaptureUpdate = 3,
+ hasForceUpdate = !1;
+
+ function createUpdateQueue(baseState) {
+ return {
+ baseState: baseState,
+ firstUpdate: null,
+ lastUpdate: null,
+ firstCapturedUpdate: null,
+ lastCapturedUpdate: null,
+ firstEffect: null,
+ lastEffect: null,
+ firstCapturedEffect: null,
+ lastCapturedEffect: null
+ };
+ }
+
+ function cloneUpdateQueue(currentQueue) {
+ return {
+ baseState: currentQueue.baseState,
+ firstUpdate: currentQueue.firstUpdate,
+ lastUpdate: currentQueue.lastUpdate,
+ firstCapturedUpdate: null,
+ lastCapturedUpdate: null,
+ firstEffect: null,
+ lastEffect: null,
+ firstCapturedEffect: null,
+ lastCapturedEffect: null
+ };
+ }
+
+ function createUpdate(expirationTime) {
+ return {
+ expirationTime: expirationTime,
+ tag: UpdateState,
+ payload: null,
+ callback: null,
+ next: null,
+ nextEffect: null
+ };
+ }
+
+ function appendUpdateToQueue(queue, update) {
+ null === queue.lastUpdate ? queue.firstUpdate = queue.lastUpdate = update : (queue.lastUpdate.next = update, queue.lastUpdate = update);
+ }
+
+ function enqueueUpdate(fiber, update) {
+ var alternate = fiber.alternate;
+
+ if (null === alternate) {
+ var queue1 = fiber.updateQueue;
+ var queue2 = null;
+ null === queue1 && (queue1 = fiber.updateQueue = createUpdateQueue(fiber.memoizedState));
+ } else queue1 = fiber.updateQueue, queue2 = alternate.updateQueue, null === queue1 ? null === queue2 ? (queue1 = fiber.updateQueue = createUpdateQueue(fiber.memoizedState), queue2 = alternate.updateQueue = createUpdateQueue(alternate.memoizedState)) : queue1 = fiber.updateQueue = cloneUpdateQueue(queue2) : null === queue2 && (queue2 = alternate.updateQueue = cloneUpdateQueue(queue1));
+
+ null === queue2 || queue1 === queue2 ? appendUpdateToQueue(queue1, update) : null === queue1.lastUpdate || null === queue2.lastUpdate ? (appendUpdateToQueue(queue1, update), appendUpdateToQueue(queue2, update)) : (appendUpdateToQueue(queue1, update), queue2.lastUpdate = update);
+ }
+
+ function enqueueCapturedUpdate(workInProgress, update) {
+ var workInProgressQueue = workInProgress.updateQueue;
+ workInProgressQueue = null === workInProgressQueue ? workInProgress.updateQueue = createUpdateQueue(workInProgress.memoizedState) : ensureWorkInProgressQueueIsAClone(workInProgress, workInProgressQueue);
+ null === workInProgressQueue.lastCapturedUpdate ? workInProgressQueue.firstCapturedUpdate = workInProgressQueue.lastCapturedUpdate = update : (workInProgressQueue.lastCapturedUpdate.next = update, workInProgressQueue.lastCapturedUpdate = update);
+ }
+
+ function ensureWorkInProgressQueueIsAClone(workInProgress, queue) {
+ var current = workInProgress.alternate;
+ null !== current && queue === current.updateQueue && (queue = workInProgress.updateQueue = cloneUpdateQueue(queue));
+ return queue;
+ }
+
+ function getStateFromUpdate(workInProgress, queue, update, prevState, nextProps, instance) {
+ switch (update.tag) {
+ case ReplaceState:
+ return workInProgress = update.payload, "function" === typeof workInProgress ? workInProgress.call(instance, prevState, nextProps) : workInProgress;
+
+ case CaptureUpdate:
+ workInProgress.effectTag = workInProgress.effectTag & -2049 | 64;
+
+ case UpdateState:
+ 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 ForceUpdate:
+ hasForceUpdate = !0;
+ }
+
+ return prevState;
+ }
+
+ function processUpdateQueue(workInProgress, queue, props, instance, renderExpirationTime) {
+ hasForceUpdate = !1;
+ queue = ensureWorkInProgressQueueIsAClone(workInProgress, queue);
+
+ for (var newBaseState = queue.baseState, newFirstUpdate = null, newExpirationTime = 0, update = queue.firstUpdate, resultState = newBaseState; null !== update;) {
+ var updateExpirationTime = update.expirationTime;
+ updateExpirationTime < renderExpirationTime ? (null === newFirstUpdate && (newFirstUpdate = update, newBaseState = resultState), newExpirationTime < updateExpirationTime && (newExpirationTime = updateExpirationTime)) : (resultState = getStateFromUpdate(workInProgress, queue, update, resultState, props, instance), null !== update.callback && (workInProgress.effectTag |= 32, update.nextEffect = null, null === queue.lastEffect ? queue.firstEffect = queue.lastEffect = update : (queue.lastEffect.nextEffect = update, queue.lastEffect = update)));
+ update = update.next;
+ }
+
+ updateExpirationTime = null;
+
+ for (update = queue.firstCapturedUpdate; null !== update;) {
+ var _updateExpirationTime = update.expirationTime;
+ _updateExpirationTime < renderExpirationTime ? (null === updateExpirationTime && (updateExpirationTime = update, null === newFirstUpdate && (newBaseState = resultState)), newExpirationTime < _updateExpirationTime && (newExpirationTime = _updateExpirationTime)) : (resultState = getStateFromUpdate(workInProgress, queue, update, resultState, props, instance), null !== update.callback && (workInProgress.effectTag |= 32, update.nextEffect = null, null === queue.lastCapturedEffect ? queue.firstCapturedEffect = queue.lastCapturedEffect = update : (queue.lastCapturedEffect.nextEffect = update, queue.lastCapturedEffect = update)));
+ update = update.next;
+ }
+
+ null === newFirstUpdate && (queue.lastUpdate = null);
+ null === updateExpirationTime ? queue.lastCapturedUpdate = null : workInProgress.effectTag |= 32;
+ null === newFirstUpdate && null === updateExpirationTime && (newBaseState = resultState);
+ queue.baseState = newBaseState;
+ queue.firstUpdate = newFirstUpdate;
+ queue.firstCapturedUpdate = updateExpirationTime;
+ workInProgress.expirationTime = newExpirationTime;
+ workInProgress.memoizedState = resultState;
+ }
+
+ function commitUpdateQueue(finishedWork, finishedQueue, instance) {
+ null !== finishedQueue.firstCapturedUpdate && (null !== finishedQueue.lastUpdate && (finishedQueue.lastUpdate.next = finishedQueue.firstCapturedUpdate, finishedQueue.lastUpdate = finishedQueue.lastCapturedUpdate), finishedQueue.firstCapturedUpdate = finishedQueue.lastCapturedUpdate = null);
+ commitUpdateEffects(finishedQueue.firstEffect, instance);
+ finishedQueue.firstEffect = finishedQueue.lastEffect = null;
+ commitUpdateEffects(finishedQueue.firstCapturedEffect, instance);
+ finishedQueue.firstCapturedEffect = finishedQueue.lastCapturedEffect = null;
+ }
+
+ function commitUpdateEffects(effect, instance) {
+ for (; null !== effect;) {
+ var _callback3 = effect.callback;
+
+ if (null !== _callback3) {
+ effect.callback = null;
+ var context = instance;
+ invariant("function" === typeof _callback3, "Invalid argument passed as callback. Expected a function. Instead received: %s", _callback3);
+
+ _callback3.call(context);
+ }
+
+ effect = effect.nextEffect;
+ }
+ }
+
+ function createCapturedValue(value, source) {
+ return {
+ value: value,
+ source: source,
+ stack: getStackByFiberInDevAndProd(source)
+ };
+ }
+
+ var appendAllChildren = void 0,
+ updateHostContainer = void 0,
+ updateHostComponent$1 = void 0,
+ updateHostText$1 = void 0;
+
+ appendAllChildren = function appendAllChildren(parent, workInProgress) {
+ for (var node = workInProgress.child; null !== node;) {
+ if (5 === node.tag || 6 === node.tag) parent._children.push(node.stateNode);else if (4 !== node.tag && null !== node.child) {
+ node.child.return = node;
+ node = node.child;
+ continue;
+ }
+ if (node === workInProgress) break;
+
+ for (; null === node.sibling;) {
+ if (null === node.return || node.return === workInProgress) return;
+ node = node.return;
+ }
+
+ node.sibling.return = node.return;
+ node = node.sibling;
+ }
+ };
+
+ updateHostContainer = function updateHostContainer() {};
+
+ updateHostComponent$1 = function updateHostComponent$1(current, workInProgress, type, newProps) {
+ current.memoizedProps !== newProps && (requiredContext(contextStackCursor$1.current), workInProgress.updateQueue = UPDATE_SIGNAL) && (workInProgress.effectTag |= 4);
+ };
+
+ updateHostText$1 = function updateHostText$1(current, workInProgress, oldText, newText) {
+ oldText !== newText && (workInProgress.effectTag |= 4);
+ };
+
+ function logCapturedError(capturedError) {
+ var componentStack = capturedError.componentStack,
+ error = capturedError.error;
+
+ if (error instanceof Error) {
+ capturedError = error.message;
+ var name = error.name;
+
+ try {
+ error.message = (capturedError ? name + ": " + capturedError : name) + "\n\nThis error is located at:" + componentStack;
+ } catch (e) {}
+ } else error = "string" === typeof error ? Error(error + "\n\nThis error is located at:" + componentStack) : Error("Unspecified error at:" + componentStack);
+
+ ExceptionsManager.handleException(error, !1);
+ }
+
+ var PossiblyWeakSet$1 = "function" === typeof WeakSet ? WeakSet : Set;
+
+ function logError(boundary, errorInfo) {
+ var source = errorInfo.source,
+ stack = errorInfo.stack;
+ null === stack && null !== source && (stack = getStackByFiberInDevAndProd(source));
+ errorInfo = {
+ componentName: null !== source ? getComponentName(source.type) : null,
+ componentStack: null !== stack ? stack : "",
+ error: errorInfo.value,
+ errorBoundary: null,
+ errorBoundaryName: null,
+ errorBoundaryFound: !1,
+ willRetry: !1
+ };
+ null !== boundary && 1 === boundary.tag && (errorInfo.errorBoundary = boundary.stateNode, errorInfo.errorBoundaryName = getComponentName(boundary.type), errorInfo.errorBoundaryFound = !0, errorInfo.willRetry = !0);
+
+ try {
+ logCapturedError(errorInfo);
+ } catch (e) {
+ setTimeout(function () {
+ throw e;
+ });
+ }
+ }
+
+ function safelyDetachRef(current$$1) {
+ var ref = current$$1.ref;
+ if (null !== ref) if ("function" === typeof ref) try {
+ ref(null);
+ } catch (refError) {
+ captureCommitPhaseError(current$$1, refError);
+ } else ref.current = null;
+ }
+
+ function commitHookEffectList(unmountTag, mountTag, finishedWork) {
+ finishedWork = finishedWork.updateQueue;
+ finishedWork = null !== finishedWork ? finishedWork.lastEffect : null;
+
+ if (null !== finishedWork) {
+ var effect = finishedWork = finishedWork.next;
+
+ do {
+ if ((effect.tag & unmountTag) !== NoEffect$1) {
+ var destroy = effect.destroy;
+ effect.destroy = void 0;
+ void 0 !== destroy && destroy();
+ }
+
+ (effect.tag & mountTag) !== NoEffect$1 && (destroy = effect.create, effect.destroy = destroy());
+ effect = effect.next;
+ } while (effect !== finishedWork);
+ }
+ }
+
+ function hideOrUnhideAllChildren(finishedWork, isHidden) {
+ for (var node = finishedWork;;) {
+ if (5 === node.tag) {
+ var instance = node.stateNode;
+
+ if (isHidden) {
+ var viewConfig = instance.viewConfig;
+ var updatePayload = diffProperties(null, emptyObject, {
+ style: {
+ display: "none"
+ }
+ }, viewConfig.validAttributes);
+ UIManager.updateView(instance._nativeTag, viewConfig.uiViewClassName, updatePayload);
+ } else {
+ instance = node.stateNode;
+ updatePayload = node.memoizedProps;
+ viewConfig = instance.viewConfig;
+
+ var prevProps = _extends({}, updatePayload, {
+ style: [updatePayload.style, {
+ display: "none"
+ }]
+ });
+
+ updatePayload = diffProperties(null, prevProps, updatePayload, viewConfig.validAttributes);
+ UIManager.updateView(instance._nativeTag, viewConfig.uiViewClassName, updatePayload);
+ }
+ } else {
+ if (6 === node.tag) throw Error("Not yet implemented.");
+
+ if (13 === node.tag && null !== node.memoizedState) {
+ instance = node.child.sibling;
+ instance.return = node;
+ node = instance;
+ continue;
+ } else if (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 commitUnmount(current$$1$jscomp$0) {
+ "function" === typeof onCommitFiberUnmount && onCommitFiberUnmount(current$$1$jscomp$0);
+
+ switch (current$$1$jscomp$0.tag) {
+ case 0:
+ case 11:
+ case 14:
+ case 15:
+ var updateQueue = current$$1$jscomp$0.updateQueue;
+
+ if (null !== updateQueue && (updateQueue = updateQueue.lastEffect, null !== updateQueue)) {
+ var effect = updateQueue = updateQueue.next;
+
+ do {
+ var destroy = effect.destroy;
+
+ if (void 0 !== destroy) {
+ var current$$1 = current$$1$jscomp$0;
+
+ try {
+ destroy();
+ } catch (error) {
+ captureCommitPhaseError(current$$1, error);
+ }
+ }
+
+ effect = effect.next;
+ } while (effect !== updateQueue);
+ }
+
+ break;
+
+ case 1:
+ safelyDetachRef(current$$1$jscomp$0);
+ updateQueue = current$$1$jscomp$0.stateNode;
+ if ("function" === typeof updateQueue.componentWillUnmount) try {
+ updateQueue.props = current$$1$jscomp$0.memoizedProps, updateQueue.state = current$$1$jscomp$0.memoizedState, updateQueue.componentWillUnmount();
+ } catch (unmountError) {
+ captureCommitPhaseError(current$$1$jscomp$0, unmountError);
+ }
+ break;
+
+ case 5:
+ safelyDetachRef(current$$1$jscomp$0);
+ break;
+
+ case 4:
+ unmountHostComponents(current$$1$jscomp$0);
+ }
+ }
+
+ 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 && 18 !== parentFiber.tag;) {
+ if (parentFiber.effectTag & 2) continue b;
+ if (null === parentFiber.child || 4 === parentFiber.tag) continue b;else parentFiber.child.return = parentFiber, parentFiber = parentFiber.child;
+ }
+
+ if (!(parentFiber.effectTag & 2)) {
+ parentFiber = parentFiber.stateNode;
+ break a;
+ }
+ }
+
+ for (var node = finishedWork;;) {
+ 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$$1) {
+ for (var node = current$$1, 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) {
+ if (null !== node.child) {
+ currentParent = node.stateNode.containerInfo;
+ currentParentIsContainer = !0;
+ node.child.return = node;
+ node = node.child;
+ continue;
+ }
+ } else if (commitUnmount(node), null !== node.child) {
+ node.child.return = node;
+ node = node.child;
+ continue;
+ }
+
+ if (node === current$$1) break;
+
+ for (; null === node.sibling;) {
+ if (null === node.return || node.return === current$$1) return;
+ node = node.return;
+ 4 === node.tag && (currentParentIsValid = !1);
+ }
+
+ node.sibling.return = node.return;
+ node = node.sibling;
+ }
+ }
+
+ function commitWork(current$$1, finishedWork) {
+ switch (finishedWork.tag) {
+ case 0:
+ case 11:
+ case 14:
+ case 15:
+ commitHookEffectList(UnmountMutation, MountMutation, finishedWork);
+ break;
+
+ case 1:
+ break;
+
+ case 5:
+ var instance = finishedWork.stateNode;
+
+ if (null != instance) {
+ var newProps = finishedWork.memoizedProps;
+ current$$1 = null !== current$$1 ? current$$1.memoizedProps : newProps;
+ var type = finishedWork.type,
+ updatePayload = finishedWork.updateQueue;
+ finishedWork.updateQueue = null;
+ null !== updatePayload && commitUpdate(instance, updatePayload, type, current$$1, newProps, finishedWork);
+ }
+
+ 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 12:
+ break;
+
+ case 13:
+ instance = finishedWork.memoizedState;
+ newProps = void 0;
+ current$$1 = finishedWork;
+ null === instance ? newProps = !1 : (newProps = !0, current$$1 = finishedWork.child, 0 === instance.timedOutAt && (instance.timedOutAt = requestCurrentTime()));
+ null !== current$$1 && hideOrUnhideAllChildren(current$$1, newProps);
+ instance = finishedWork.updateQueue;
+
+ if (null !== instance) {
+ finishedWork.updateQueue = null;
+ var retryCache = finishedWork.stateNode;
+ null === retryCache && (retryCache = finishedWork.stateNode = new PossiblyWeakSet$1());
+ instance.forEach(function (thenable) {
+ var retry = resolveRetryThenable.bind(null, finishedWork, thenable);
+ retryCache.has(thenable) || (retryCache.add(thenable), thenable.then(retry, retry));
+ });
+ }
+
+ break;
+
+ case 17:
+ 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.");
+ }
+ }
+
+ var PossiblyWeakMap = "function" === typeof WeakMap ? WeakMap : Map;
+
+ function createRootErrorUpdate(fiber, errorInfo, expirationTime) {
+ expirationTime = createUpdate(expirationTime);
+ expirationTime.tag = CaptureUpdate;
+ 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 = CaptureUpdate;
+ var getDerivedStateFromError = fiber.type.getDerivedStateFromError;
+
+ if ("function" === typeof getDerivedStateFromError) {
+ var error$jscomp$0 = errorInfo.value;
+
+ expirationTime.payload = function () {
+ return getDerivedStateFromError(error$jscomp$0);
+ };
+ }
+
+ var inst = fiber.stateNode;
+ null !== inst && "function" === typeof inst.componentDidCatch && (expirationTime.callback = function () {
+ "function" !== typeof getDerivedStateFromError && (null === legacyErrorBoundariesThatAlreadyFailed ? legacyErrorBoundariesThatAlreadyFailed = new Set([this]) : legacyErrorBoundariesThatAlreadyFailed.add(this));
+ 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 1:
+ isContextProvider(workInProgress.type) && popContext(workInProgress);
+ var effectTag = workInProgress.effectTag;
+ return effectTag & 2048 ? (workInProgress.effectTag = effectTag & -2049 | 64, workInProgress) : null;
+
+ case 3:
+ return popHostContainer(workInProgress), popTopLevelContextObject(workInProgress), effectTag = workInProgress.effectTag, invariant(0 === (effectTag & 64), "The root failed to unmount after an error. This is likely a bug in React. Please file an issue."), workInProgress.effectTag = effectTag & -2049 | 64, workInProgress;
+
+ case 5:
+ return popHostContext(workInProgress), null;
+
+ case 13:
+ return effectTag = workInProgress.effectTag, effectTag & 2048 ? (workInProgress.effectTag = effectTag & -2049 | 64, workInProgress) : null;
+
+ case 18:
+ return null;
+
+ case 4:
+ return popHostContainer(workInProgress), null;
+
+ case 10:
+ return popProvider(workInProgress), null;
+
+ default:
+ return null;
+ }
+ }
+
+ var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher,
+ ReactCurrentOwner$2 = ReactSharedInternals.ReactCurrentOwner,
+ isWorking = !1,
+ nextUnitOfWork = null,
+ nextRoot = null,
+ nextRenderExpirationTime = 0,
+ nextLatestAbsoluteTimeoutMs = -1,
+ nextRenderDidError = !1,
+ nextEffect = null,
+ isCommitting$1 = !1,
+ rootWithPendingPassiveEffects = null,
+ passiveEffectCallbackHandle = null,
+ passiveEffectCallback = null,
+ 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 1:
+ var childContextTypes = interruptedWork$jscomp$0.type.childContextTypes;
+ null !== childContextTypes && void 0 !== childContextTypes && popContext(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 10:
+ popProvider(interruptedWork$jscomp$0);
+ }
+
+ interruptedWork = interruptedWork.return;
+ }
+ nextRoot = null;
+ nextRenderExpirationTime = 0;
+ nextLatestAbsoluteTimeoutMs = -1;
+ nextRenderDidError = !1;
+ nextUnitOfWork = null;
+ }
+
+ function commitAllHostEffects() {
+ for (; null !== nextEffect;) {
+ var effectTag = nextEffect.effectTag;
+
+ if (effectTag & 128) {
+ var current$$1 = nextEffect.alternate;
+ null !== current$$1 && (current$$1 = current$$1.ref, null !== current$$1 && ("function" === typeof current$$1 ? current$$1(null) : current$$1.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:
+ effectTag = nextEffect, unmountHostComponents(effectTag), effectTag.return = null, effectTag.child = null, effectTag.memoizedState = null, effectTag.updateQueue = null, effectTag = effectTag.alternate, null !== effectTag && (effectTag.return = null, effectTag.child = null, effectTag.memoizedState = null, effectTag.updateQueue = null);
+ }
+
+ nextEffect = nextEffect.nextEffect;
+ }
+ }
+
+ function commitBeforeMutationLifecycles() {
+ for (; null !== nextEffect;) {
+ if (nextEffect.effectTag & 256) a: {
+ var current$$1 = nextEffect.alternate,
+ finishedWork = nextEffect;
+
+ switch (finishedWork.tag) {
+ case 0:
+ case 11:
+ case 15:
+ commitHookEffectList(UnmountSnapshot, NoEffect$1, finishedWork);
+ break a;
+
+ case 1:
+ if (finishedWork.effectTag & 256 && null !== current$$1) {
+ var prevProps = current$$1.memoizedProps,
+ prevState = current$$1.memoizedState;
+ current$$1 = finishedWork.stateNode;
+ finishedWork = current$$1.getSnapshotBeforeUpdate(finishedWork.elementType === finishedWork.type ? prevProps : resolveDefaultProps(finishedWork.type, prevProps), prevState);
+ current$$1.__reactInternalSnapshotBeforeUpdate = finishedWork;
+ }
+
+ break a;
+
+ case 3:
+ case 5:
+ case 6:
+ case 4:
+ case 17:
+ break a;
+
+ 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;
+ }
+ }
+
+ function commitAllLifeCycles(finishedRoot, committedExpirationTime$jscomp$0) {
+ for (; null !== nextEffect;) {
+ var effectTag = nextEffect.effectTag;
+
+ if (effectTag & 36) {
+ var current$$1 = nextEffect.alternate,
+ finishedWork = nextEffect,
+ committedExpirationTime = committedExpirationTime$jscomp$0;
+
+ switch (finishedWork.tag) {
+ case 0:
+ case 11:
+ case 15:
+ commitHookEffectList(UnmountLayout, MountLayout, finishedWork);
+ break;
+
+ case 1:
+ var instance = finishedWork.stateNode;
+ if (finishedWork.effectTag & 4) if (null === current$$1) instance.componentDidMount();else {
+ var prevProps = finishedWork.elementType === finishedWork.type ? current$$1.memoizedProps : resolveDefaultProps(finishedWork.type, current$$1.memoizedProps);
+ instance.componentDidUpdate(prevProps, current$$1.memoizedState, instance.__reactInternalSnapshotBeforeUpdate);
+ }
+ current$$1 = finishedWork.updateQueue;
+ null !== current$$1 && commitUpdateQueue(finishedWork, current$$1, instance, committedExpirationTime);
+ break;
+
+ case 3:
+ instance = finishedWork.updateQueue;
+
+ if (null !== instance) {
+ current$$1 = null;
+ if (null !== finishedWork.child) switch (finishedWork.child.tag) {
+ case 5:
+ current$$1 = finishedWork.child.stateNode;
+ break;
+
+ case 1:
+ current$$1 = finishedWork.child.stateNode;
+ }
+ commitUpdateQueue(finishedWork, instance, current$$1, committedExpirationTime);
+ }
+
+ break;
+
+ case 5:
+ break;
+
+ case 6:
+ break;
+
+ case 4:
+ break;
+
+ case 12:
+ break;
+
+ case 13:
+ break;
+
+ case 17:
+ 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.");
+ }
+ }
+
+ effectTag & 128 && (finishedWork = nextEffect.ref, null !== finishedWork && (committedExpirationTime = nextEffect.stateNode, "function" === typeof finishedWork ? finishedWork(committedExpirationTime) : finishedWork.current = committedExpirationTime));
+ effectTag & 512 && (rootWithPendingPassiveEffects = finishedRoot);
+ nextEffect = nextEffect.nextEffect;
+ }
+ }
+
+ function commitPassiveEffects(root, firstEffect) {
+ passiveEffectCallback = passiveEffectCallbackHandle = rootWithPendingPassiveEffects = null;
+ var previousIsRendering = isRendering;
+ isRendering = !0;
+
+ do {
+ if (firstEffect.effectTag & 512) {
+ var didError = !1,
+ error = void 0;
+
+ try {
+ var finishedWork = firstEffect;
+ commitHookEffectList(UnmountPassive, NoEffect$1, finishedWork);
+ commitHookEffectList(NoEffect$1, MountPassive, finishedWork);
+ } catch (e) {
+ didError = !0, error = e;
+ }
+
+ didError && captureCommitPhaseError(firstEffect, error);
+ }
+
+ firstEffect = firstEffect.nextEffect;
+ } while (null !== firstEffect);
+
+ isRendering = previousIsRendering;
+ previousIsRendering = root.expirationTime;
+ 0 !== previousIsRendering && requestWork(root, previousIsRendering);
+ isBatchingUpdates || isRendering || performWork(1073741823, !1);
+ }
+
+ function flushPassiveEffects() {
+ if (null !== passiveEffectCallbackHandle) {
+ var callbackID = passiveEffectCallbackHandle;
+ scheduledCallback = null;
+ clearTimeout(callbackID);
+ }
+
+ null !== passiveEffectCallback && passiveEffectCallback();
+ }
+
+ function commitRoot(root, finishedWork) {
+ isCommitting$1 = isWorking = !0;
+ 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(0 !== committedExpirationTime, "Cannot commit an incomplete root. This error is likely caused by a bug in React. Please file an issue.");
+ root.pendingCommitExpirationTime = 0;
+ var updateExpirationTimeBeforeCommit = finishedWork.expirationTime,
+ childExpirationTimeBeforeCommit = finishedWork.childExpirationTime;
+ markCommittedPriorityLevels(root, childExpirationTimeBeforeCommit > updateExpirationTimeBeforeCommit ? childExpirationTimeBeforeCommit : updateExpirationTimeBeforeCommit);
+ ReactCurrentOwner$2.current = null;
+ updateExpirationTimeBeforeCommit = void 0;
+ 1 < finishedWork.effectTag ? null !== finishedWork.lastEffect ? (finishedWork.lastEffect.nextEffect = finishedWork, updateExpirationTimeBeforeCommit = finishedWork.firstEffect) : updateExpirationTimeBeforeCommit = finishedWork : updateExpirationTimeBeforeCommit = finishedWork.firstEffect;
+
+ for (nextEffect = updateExpirationTimeBeforeCommit; null !== nextEffect;) {
+ childExpirationTimeBeforeCommit = !1;
+ var error = void 0;
+
+ try {
+ commitBeforeMutationLifecycles();
+ } catch (e) {
+ childExpirationTimeBeforeCommit = !0, error = e;
+ }
+
+ childExpirationTimeBeforeCommit && (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 = updateExpirationTimeBeforeCommit; null !== nextEffect;) {
+ childExpirationTimeBeforeCommit = !1;
+ error = void 0;
+
+ try {
+ commitAllHostEffects();
+ } catch (e) {
+ childExpirationTimeBeforeCommit = !0, error = e;
+ }
+
+ childExpirationTimeBeforeCommit && (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));
+ }
+
+ root.current = finishedWork;
+
+ for (nextEffect = updateExpirationTimeBeforeCommit; null !== nextEffect;) {
+ childExpirationTimeBeforeCommit = !1;
+ error = void 0;
+
+ try {
+ commitAllLifeCycles(root, committedExpirationTime);
+ } catch (e) {
+ childExpirationTimeBeforeCommit = !0, error = e;
+ }
+
+ childExpirationTimeBeforeCommit && (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));
+ }
+
+ if (null !== updateExpirationTimeBeforeCommit && null !== rootWithPendingPassiveEffects) {
+ var callback = commitPassiveEffects.bind(null, root, updateExpirationTimeBeforeCommit);
+ passiveEffectCallbackHandle = scheduler.unstable_runWithPriority(scheduler.unstable_NormalPriority, function () {
+ return scheduleDeferredCallback$1(callback);
+ });
+ passiveEffectCallback = callback;
+ }
+
+ isWorking = isCommitting$1 = !1;
+ "function" === typeof onCommitFiberRoot && onCommitFiberRoot(finishedWork.stateNode);
+ committedExpirationTime = finishedWork.expirationTime;
+ finishedWork = finishedWork.childExpirationTime;
+ finishedWork = finishedWork > committedExpirationTime ? finishedWork : committedExpirationTime;
+ 0 === finishedWork && (legacyErrorBoundariesThatAlreadyFailed = null);
+ onCommit(root, finishedWork);
+ }
+
+ function completeUnitOfWork(workInProgress) {
+ for (;;) {
+ var current$$1 = workInProgress.alternate,
+ returnFiber = workInProgress.return,
+ siblingFiber = workInProgress.sibling;
+
+ if (0 === (workInProgress.effectTag & 1024)) {
+ nextUnitOfWork = workInProgress;
+
+ a: {
+ var current = current$$1;
+ current$$1 = workInProgress;
+ var renderExpirationTime = nextRenderExpirationTime,
+ newProps = current$$1.pendingProps;
+
+ switch (current$$1.tag) {
+ case 2:
+ break;
+
+ case 16:
+ break;
+
+ case 15:
+ case 0:
+ break;
+
+ case 1:
+ isContextProvider(current$$1.type) && popContext(current$$1);
+ break;
+
+ case 3:
+ popHostContainer(current$$1);
+ popTopLevelContextObject(current$$1);
+ newProps = current$$1.stateNode;
+ newProps.pendingContext && (newProps.context = newProps.pendingContext, newProps.pendingContext = null);
+ if (null === current || null === current.child) current$$1.effectTag &= -3;
+ updateHostContainer(current$$1);
+ break;
+
+ case 5:
+ popHostContext(current$$1);
+ renderExpirationTime = requiredContext(rootInstanceStackCursor.current);
+ var type = current$$1.type;
+ if (null !== current && null != current$$1.stateNode) updateHostComponent$1(current, current$$1, type, newProps, renderExpirationTime), current.ref !== current$$1.ref && (current$$1.effectTag |= 128);else if (newProps) {
+ current = requiredContext(contextStackCursor$1.current);
+ var internalInstanceHandle = current$$1,
+ tag = allocateTag(),
+ viewConfig = ReactNativeViewConfigRegistry.get(type);
+ invariant("RCTView" !== type || !current.isInAParentText, "Nesting of within is not currently supported.");
+ var updatePayload = diffProperties(null, emptyObject, newProps, viewConfig.validAttributes);
+ UIManager.createView(tag, viewConfig.uiViewClassName, renderExpirationTime, updatePayload);
+ viewConfig = new ReactNativeFiberHostComponent(tag, viewConfig);
+ instanceCache[tag] = internalInstanceHandle;
+ instanceProps[tag] = newProps;
+ appendAllChildren(viewConfig, current$$1, !1, !1);
+ finalizeInitialChildren(viewConfig, type, newProps, renderExpirationTime, current) && (current$$1.effectTag |= 4);
+ current$$1.stateNode = viewConfig;
+ null !== current$$1.ref && (current$$1.effectTag |= 128);
+ } else invariant(null !== current$$1.stateNode, "We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue.");
+ break;
+
+ case 6:
+ current && null != current$$1.stateNode ? updateHostText$1(current, current$$1, current.memoizedProps, newProps) : ("string" !== typeof newProps && invariant(null !== current$$1.stateNode, "We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue."), current = requiredContext(rootInstanceStackCursor.current), type = requiredContext(contextStackCursor$1.current), renderExpirationTime = current$$1, invariant(type.isInAParentText, "Text strings must be rendered within a component."), type = allocateTag(), UIManager.createView(type, "RCTRawText", current, {
+ text: newProps
+ }), instanceCache[type] = current$$1, renderExpirationTime.stateNode = type);
+ break;
+
+ case 11:
+ break;
+
+ case 13:
+ newProps = current$$1.memoizedState;
+
+ if (0 !== (current$$1.effectTag & 64)) {
+ current$$1.expirationTime = renderExpirationTime;
+ nextUnitOfWork = current$$1;
+ break a;
+ }
+
+ newProps = null !== newProps;
+ renderExpirationTime = null !== current && null !== current.memoizedState;
+ null !== current && !newProps && renderExpirationTime && (type = current.child.sibling, null !== type && (current = current$$1.firstEffect, null !== current ? (current$$1.firstEffect = type, type.nextEffect = current) : (current$$1.firstEffect = current$$1.lastEffect = type, type.nextEffect = null), type.effectTag = 8));
+ if (newProps || renderExpirationTime) current$$1.effectTag |= 4;
+ break;
+
+ case 7:
+ break;
+
+ case 8:
+ break;
+
+ case 12:
+ break;
+
+ case 4:
+ popHostContainer(current$$1);
+ updateHostContainer(current$$1);
+ break;
+
+ case 10:
+ popProvider(current$$1);
+ break;
+
+ case 9:
+ break;
+
+ case 14:
+ break;
+
+ case 17:
+ isContextProvider(current$$1.type) && popContext(current$$1);
+ break;
+
+ case 18:
+ break;
+
+ default:
+ invariant(!1, "Unknown unit of work tag. This error is likely caused by a bug in React. Please file an issue.");
+ }
+
+ nextUnitOfWork = null;
+ }
+
+ current$$1 = workInProgress;
+
+ if (1 === nextRenderExpirationTime || 1 !== current$$1.childExpirationTime) {
+ newProps = 0;
+
+ for (renderExpirationTime = current$$1.child; null !== renderExpirationTime;) {
+ type = renderExpirationTime.expirationTime, current = renderExpirationTime.childExpirationTime, type > newProps && (newProps = type), current > newProps && (newProps = current), renderExpirationTime = renderExpirationTime.sibling;
+ }
+
+ current$$1.childExpirationTime = newProps;
+ }
+
+ if (null !== nextUnitOfWork) return nextUnitOfWork;
+ null !== returnFiber && 0 === (returnFiber.effectTag & 1024) && (null === returnFiber.firstEffect && (returnFiber.firstEffect = workInProgress.firstEffect), null !== workInProgress.lastEffect && (null !== returnFiber.lastEffect && (returnFiber.lastEffect.nextEffect = workInProgress.firstEffect), returnFiber.lastEffect = workInProgress.lastEffect), 1 < workInProgress.effectTag && (null !== returnFiber.lastEffect ? returnFiber.lastEffect.nextEffect = workInProgress : returnFiber.firstEffect = workInProgress, returnFiber.lastEffect = workInProgress));
+ } else {
+ workInProgress = unwindWork(workInProgress, nextRenderExpirationTime);
+ if (null !== workInProgress) return workInProgress.effectTag &= 1023, workInProgress;
+ null !== returnFiber && (returnFiber.firstEffect = returnFiber.lastEffect = null, returnFiber.effectTag |= 1024);
+ }
+
+ if (null !== siblingFiber) return siblingFiber;
+ if (null !== returnFiber) workInProgress = returnFiber;else break;
+ }
+
+ return null;
+ }
+
+ function performUnitOfWork(workInProgress) {
+ var next = beginWork(workInProgress.alternate, workInProgress, nextRenderExpirationTime);
+ workInProgress.memoizedProps = workInProgress.pendingProps;
+ null === next && (next = completeUnitOfWork(workInProgress));
+ ReactCurrentOwner$2.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.");
+ flushPassiveEffects();
+ isWorking = !0;
+ var previousDispatcher = ReactCurrentDispatcher.current;
+ ReactCurrentDispatcher.current = ContextOnlyDispatcher;
+ var expirationTime = root$jscomp$0.nextExpirationTimeToWorkOn;
+ if (expirationTime !== nextRenderExpirationTime || root$jscomp$0 !== nextRoot || null === nextUnitOfWork) resetStack(), nextRoot = root$jscomp$0, nextRenderExpirationTime = expirationTime, nextUnitOfWork = createWorkInProgress(nextRoot.current, null, nextRenderExpirationTime), root$jscomp$0.pendingCommitExpirationTime = 0;
+ var didFatal = !1;
+
+ do {
+ try {
+ if (isYieldy) for (; null !== nextUnitOfWork && !(frameDeadline <= now$1());) {
+ nextUnitOfWork = performUnitOfWork(nextUnitOfWork);
+ } else for (; null !== nextUnitOfWork;) {
+ nextUnitOfWork = performUnitOfWork(nextUnitOfWork);
+ }
+ } catch (thrownValue) {
+ if (lastContextWithAllBitsObserved = lastContextDependency = currentlyRenderingFiber = null, resetHooks(), 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.");
+ var sourceFiber = nextUnitOfWork,
+ returnFiber = sourceFiber.return;
+ if (null === returnFiber) didFatal = !0, onUncaughtError(thrownValue);else {
+ a: {
+ var root = root$jscomp$0,
+ returnFiber$jscomp$0 = returnFiber,
+ sourceFiber$jscomp$0 = sourceFiber,
+ value = thrownValue;
+ returnFiber = nextRenderExpirationTime;
+ sourceFiber$jscomp$0.effectTag |= 1024;
+ sourceFiber$jscomp$0.firstEffect = sourceFiber$jscomp$0.lastEffect = null;
+
+ if (null !== value && "object" === typeof value && "function" === typeof value.then) {
+ var thenable = value;
+ value = returnFiber$jscomp$0;
+ var earliestTimeoutMs = -1,
+ startTimeMs = -1;
+
+ do {
+ if (13 === value.tag) {
+ var current$$1 = value.alternate;
+
+ if (null !== current$$1 && (current$$1 = current$$1.memoizedState, null !== current$$1)) {
+ startTimeMs = 10 * (1073741822 - current$$1.timedOutAt);
+ break;
+ }
+
+ current$$1 = value.pendingProps.maxDuration;
+ if ("number" === typeof current$$1) if (0 >= current$$1) earliestTimeoutMs = 0;else if (-1 === earliestTimeoutMs || current$$1 < earliestTimeoutMs) earliestTimeoutMs = current$$1;
+ }
+
+ value = value.return;
+ } while (null !== value);
+
+ value = returnFiber$jscomp$0;
+
+ do {
+ if (current$$1 = 13 === value.tag) current$$1 = void 0 === value.memoizedProps.fallback ? !1 : null === value.memoizedState;
+
+ if (current$$1) {
+ returnFiber$jscomp$0 = value.updateQueue;
+ null === returnFiber$jscomp$0 ? (returnFiber$jscomp$0 = new Set(), returnFiber$jscomp$0.add(thenable), value.updateQueue = returnFiber$jscomp$0) : returnFiber$jscomp$0.add(thenable);
+
+ if (0 === (value.mode & 1)) {
+ value.effectTag |= 64;
+ sourceFiber$jscomp$0.effectTag &= -1957;
+ 1 === sourceFiber$jscomp$0.tag && (null === sourceFiber$jscomp$0.alternate ? sourceFiber$jscomp$0.tag = 17 : (returnFiber = createUpdate(1073741823), returnFiber.tag = ForceUpdate, enqueueUpdate(sourceFiber$jscomp$0, returnFiber)));
+ sourceFiber$jscomp$0.expirationTime = 1073741823;
+ break a;
+ }
+
+ sourceFiber$jscomp$0 = root;
+ returnFiber$jscomp$0 = returnFiber;
+ var pingCache = sourceFiber$jscomp$0.pingCache;
+ null === pingCache ? (pingCache = sourceFiber$jscomp$0.pingCache = new PossiblyWeakMap(), current$$1 = new Set(), pingCache.set(thenable, current$$1)) : (current$$1 = pingCache.get(thenable), void 0 === current$$1 && (current$$1 = new Set(), pingCache.set(thenable, current$$1)));
+ current$$1.has(returnFiber$jscomp$0) || (current$$1.add(returnFiber$jscomp$0), sourceFiber$jscomp$0 = pingSuspendedRoot.bind(null, sourceFiber$jscomp$0, thenable, returnFiber$jscomp$0), thenable.then(sourceFiber$jscomp$0, sourceFiber$jscomp$0));
+ -1 === earliestTimeoutMs ? root = 1073741823 : (-1 === startTimeMs && (startTimeMs = 10 * (1073741822 - findEarliestOutstandingPriorityLevel(root, returnFiber)) - 5e3), root = startTimeMs + earliestTimeoutMs);
+ 0 <= root && nextLatestAbsoluteTimeoutMs < root && (nextLatestAbsoluteTimeoutMs = root);
+ value.effectTag |= 2048;
+ value.expirationTime = returnFiber;
+ break a;
+ }
+
+ value = value.return;
+ } while (null !== value);
+
+ value = Error((getComponentName(sourceFiber$jscomp$0.type) || "A React component") + " suspended while rendering, but no fallback UI was specified.\n\nAdd a component higher in the tree to provide a loading indicator or placeholder to display." + getStackByFiberInDevAndProd(sourceFiber$jscomp$0));
+ }
+
+ nextRenderDidError = !0;
+ value = createCapturedValue(value, sourceFiber$jscomp$0);
+ root = returnFiber$jscomp$0;
+
+ do {
+ switch (root.tag) {
+ case 3:
+ root.effectTag |= 2048;
+ root.expirationTime = returnFiber;
+ returnFiber = createRootErrorUpdate(root, value, returnFiber);
+ enqueueCapturedUpdate(root, returnFiber);
+ break a;
+
+ case 1:
+ if (earliestTimeoutMs = value, startTimeMs = root.type, sourceFiber$jscomp$0 = root.stateNode, 0 === (root.effectTag & 64) && ("function" === typeof startTimeMs.getDerivedStateFromError || null !== sourceFiber$jscomp$0 && "function" === typeof sourceFiber$jscomp$0.componentDidCatch && (null === legacyErrorBoundariesThatAlreadyFailed || !legacyErrorBoundariesThatAlreadyFailed.has(sourceFiber$jscomp$0)))) {
+ root.effectTag |= 2048;
+ root.expirationTime = returnFiber;
+ returnFiber = createClassErrorUpdate(root, earliestTimeoutMs, returnFiber);
+ enqueueCapturedUpdate(root, returnFiber);
+ break a;
+ }
+
+ }
+
+ root = root.return;
+ } while (null !== root);
+ }
+
+ nextUnitOfWork = completeUnitOfWork(sourceFiber);
+ continue;
+ }
+ }
+ }
+
+ break;
+ } while (1);
+
+ isWorking = !1;
+ ReactCurrentDispatcher.current = previousDispatcher;
+ lastContextWithAllBitsObserved = lastContextDependency = currentlyRenderingFiber = null;
+ resetHooks();
+ if (didFatal) nextRoot = null, root$jscomp$0.finishedWork = null;else if (null !== nextUnitOfWork) root$jscomp$0.finishedWork = null;else {
+ previousDispatcher = root$jscomp$0.current.alternate;
+ invariant(null !== previousDispatcher, "Finished root should have a work-in-progress. This error is likely caused by a bug in React. Please file an issue.");
+ nextRoot = null;
+
+ if (nextRenderDidError) {
+ didFatal = root$jscomp$0.latestPendingTime;
+ sourceFiber = root$jscomp$0.latestSuspendedTime;
+ returnFiber = root$jscomp$0.latestPingedTime;
+
+ if (0 !== didFatal && didFatal < expirationTime || 0 !== sourceFiber && sourceFiber < expirationTime || 0 !== returnFiber && returnFiber < expirationTime) {
+ markSuspendedPriorityLevel(root$jscomp$0, expirationTime);
+ onSuspend(root$jscomp$0, previousDispatcher, expirationTime, root$jscomp$0.expirationTime, -1);
+ return;
+ }
+
+ if (!root$jscomp$0.didError && isYieldy) {
+ root$jscomp$0.didError = !0;
+ expirationTime = root$jscomp$0.nextExpirationTimeToWorkOn = expirationTime;
+ isYieldy = root$jscomp$0.expirationTime = 1073741823;
+ onSuspend(root$jscomp$0, previousDispatcher, expirationTime, isYieldy, -1);
+ return;
+ }
+ }
+
+ isYieldy && -1 !== nextLatestAbsoluteTimeoutMs ? (markSuspendedPriorityLevel(root$jscomp$0, expirationTime), isYieldy = 10 * (1073741822 - findEarliestOutstandingPriorityLevel(root$jscomp$0, expirationTime)), isYieldy < nextLatestAbsoluteTimeoutMs && (nextLatestAbsoluteTimeoutMs = isYieldy), isYieldy = 10 * (1073741822 - requestCurrentTime()), isYieldy = nextLatestAbsoluteTimeoutMs - isYieldy, onSuspend(root$jscomp$0, previousDispatcher, expirationTime, root$jscomp$0.expirationTime, 0 > isYieldy ? 0 : isYieldy)) : (root$jscomp$0.pendingCommitExpirationTime = expirationTime, root$jscomp$0.finishedWork = previousDispatcher);
+ }
+ }
+
+ function captureCommitPhaseError(sourceFiber, value) {
+ for (var fiber = sourceFiber.return; null !== fiber;) {
+ switch (fiber.tag) {
+ case 1:
+ var instance = fiber.stateNode;
+
+ if ("function" === typeof fiber.type.getDerivedStateFromError || "function" === typeof instance.componentDidCatch && (null === legacyErrorBoundariesThatAlreadyFailed || !legacyErrorBoundariesThatAlreadyFailed.has(instance))) {
+ sourceFiber = createCapturedValue(value, sourceFiber);
+ sourceFiber = createClassErrorUpdate(fiber, sourceFiber, 1073741823);
+ enqueueUpdate(fiber, sourceFiber);
+ scheduleWork(fiber, 1073741823);
+ return;
+ }
+
+ break;
+
+ case 3:
+ sourceFiber = createCapturedValue(value, sourceFiber);
+ sourceFiber = createRootErrorUpdate(fiber, sourceFiber, 1073741823);
+ enqueueUpdate(fiber, sourceFiber);
+ scheduleWork(fiber, 1073741823);
+ return;
+ }
+
+ fiber = fiber.return;
+ }
+
+ 3 === sourceFiber.tag && (fiber = createCapturedValue(value, sourceFiber), fiber = createRootErrorUpdate(sourceFiber, fiber, 1073741823), enqueueUpdate(sourceFiber, fiber), scheduleWork(sourceFiber, 1073741823));
+ }
+
+ function computeExpirationForFiber(currentTime, fiber) {
+ var priorityLevel = scheduler.unstable_getCurrentPriorityLevel(),
+ expirationTime = void 0;
+ if (0 === (fiber.mode & 1)) expirationTime = 1073741823;else if (isWorking && !isCommitting$1) expirationTime = nextRenderExpirationTime;else {
+ switch (priorityLevel) {
+ case scheduler.unstable_ImmediatePriority:
+ expirationTime = 1073741823;
+ break;
+
+ case scheduler.unstable_UserBlockingPriority:
+ expirationTime = 1073741822 - 10 * (((1073741822 - currentTime + 15) / 10 | 0) + 1);
+ break;
+
+ case scheduler.unstable_NormalPriority:
+ expirationTime = 1073741822 - 25 * (((1073741822 - currentTime + 500) / 25 | 0) + 1);
+ break;
+
+ case scheduler.unstable_LowPriority:
+ case scheduler.unstable_IdlePriority:
+ expirationTime = 1;
+ break;
+
+ default:
+ invariant(!1, "Unknown priority level. This error is likely caused by a bug in React. Please file an issue.");
+ }
+
+ null !== nextRoot && expirationTime === nextRenderExpirationTime && --expirationTime;
+ }
+ priorityLevel === scheduler.unstable_UserBlockingPriority && (0 === lowestPriorityPendingInteractiveExpirationTime || expirationTime < lowestPriorityPendingInteractiveExpirationTime) && (lowestPriorityPendingInteractiveExpirationTime = expirationTime);
+ return expirationTime;
+ }
+
+ function pingSuspendedRoot(root, thenable, pingTime) {
+ var pingCache = root.pingCache;
+ null !== pingCache && pingCache.delete(thenable);
+ if (null !== nextRoot && nextRenderExpirationTime === pingTime) nextRoot = null;else if (thenable = root.earliestSuspendedTime, pingCache = root.latestSuspendedTime, 0 !== thenable && pingTime <= thenable && pingTime >= pingCache) {
+ root.didError = !1;
+ thenable = root.latestPingedTime;
+ if (0 === thenable || thenable > pingTime) root.latestPingedTime = pingTime;
+ findNextExpirationTimeToWorkOn(pingTime, root);
+ pingTime = root.expirationTime;
+ 0 !== pingTime && requestWork(root, pingTime);
+ }
+ }
+
+ function resolveRetryThenable(boundaryFiber, thenable) {
+ var retryCache = boundaryFiber.stateNode;
+ null !== retryCache && retryCache.delete(thenable);
+ thenable = requestCurrentTime();
+ thenable = computeExpirationForFiber(thenable, boundaryFiber);
+ boundaryFiber = scheduleWorkToRoot(boundaryFiber, thenable);
+ null !== boundaryFiber && (markPendingPriorityLevel(boundaryFiber, thenable), thenable = boundaryFiber.expirationTime, 0 !== thenable && requestWork(boundaryFiber, thenable));
+ }
+
+ function scheduleWorkToRoot(fiber, expirationTime) {
+ fiber.expirationTime < expirationTime && (fiber.expirationTime = expirationTime);
+ var alternate = fiber.alternate;
+ null !== alternate && alternate.expirationTime < expirationTime && (alternate.expirationTime = expirationTime);
+ var node = fiber.return,
+ root = null;
+ if (null === node && 3 === fiber.tag) root = fiber.stateNode;else for (; null !== node;) {
+ alternate = node.alternate;
+ node.childExpirationTime < expirationTime && (node.childExpirationTime = expirationTime);
+ null !== alternate && alternate.childExpirationTime < expirationTime && (alternate.childExpirationTime = expirationTime);
+
+ if (null === node.return && 3 === node.tag) {
+ root = node.stateNode;
+ break;
+ }
+
+ node = node.return;
+ }
+ return root;
+ }
+
+ function scheduleWork(fiber, expirationTime) {
+ fiber = scheduleWorkToRoot(fiber, expirationTime);
+ null !== fiber && (!isWorking && 0 !== nextRenderExpirationTime && expirationTime > nextRenderExpirationTime && resetStack(), markPendingPriorityLevel(fiber, expirationTime), isWorking && !isCommitting$1 && nextRoot === fiber || requestWork(fiber, fiber.expirationTime), nestedUpdateCount > NESTED_UPDATE_LIMIT && (nestedUpdateCount = 0, 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.")));
+ }
+
+ var firstScheduledRoot = null,
+ lastScheduledRoot = null,
+ callbackExpirationTime = 0,
+ callbackID = void 0,
+ isRendering = !1,
+ nextFlushedRoot = null,
+ nextFlushedExpirationTime = 0,
+ lowestPriorityPendingInteractiveExpirationTime = 0,
+ hasUnhandledError = !1,
+ unhandledError = null,
+ isBatchingUpdates = !1,
+ isUnbatchingUpdates = !1,
+ completedBatches = null,
+ originalStartTimeMs = now$1(),
+ currentRendererTime = 1073741822 - (originalStartTimeMs / 10 | 0),
+ currentSchedulerTime = currentRendererTime,
+ NESTED_UPDATE_LIMIT = 50,
+ nestedUpdateCount = 0,
+ lastCommittedRootDuringThisBatch = null;
+
+ function recomputeCurrentRendererTime() {
+ currentRendererTime = 1073741822 - ((now$1() - originalStartTimeMs) / 10 | 0);
+ }
+
+ function scheduleCallbackWithExpirationTime(root, expirationTime) {
+ if (0 !== callbackExpirationTime) {
+ if (expirationTime < callbackExpirationTime) return;
+ null !== callbackID && (root = callbackID, scheduledCallback = null, clearTimeout(root));
+ }
+
+ callbackExpirationTime = expirationTime;
+ root = now$1() - originalStartTimeMs;
+ callbackID = scheduleDeferredCallback$1(performAsyncWork, {
+ timeout: 10 * (1073741822 - expirationTime) - root
+ });
+ }
+
+ function onSuspend(root, finishedWork, suspendedExpirationTime, rootExpirationTime, msUntilTimeout) {
+ root.expirationTime = rootExpirationTime;
+ 0 !== msUntilTimeout || frameDeadline <= now$1() ? 0 < msUntilTimeout && (root.timeoutHandle = scheduleTimeout(onTimeout.bind(null, root, finishedWork, suspendedExpirationTime), msUntilTimeout)) : (root.pendingCommitExpirationTime = suspendedExpirationTime, root.finishedWork = finishedWork);
+ }
+
+ function onTimeout(root, finishedWork, suspendedExpirationTime) {
+ root.pendingCommitExpirationTime = suspendedExpirationTime;
+ root.finishedWork = finishedWork;
+ recomputeCurrentRendererTime();
+ currentSchedulerTime = currentRendererTime;
+ invariant(!isRendering, "work.commit(): Cannot commit while already rendering. This likely means you attempted to commit from inside a lifecycle method.");
+ nextFlushedRoot = root;
+ nextFlushedExpirationTime = suspendedExpirationTime;
+ performWorkOnRoot(root, suspendedExpirationTime, !1);
+ performWork(1073741823, !1);
+ }
+
+ function onCommit(root, expirationTime) {
+ root.expirationTime = expirationTime;
+ root.finishedWork = null;
+ }
+
+ function requestCurrentTime() {
+ if (isRendering) return currentSchedulerTime;
+ findHighestPriorityRoot();
+ if (0 === nextFlushedExpirationTime || 1 === nextFlushedExpirationTime) recomputeCurrentRendererTime(), currentSchedulerTime = currentRendererTime;
+ return currentSchedulerTime;
+ }
+
+ function requestWork(root, expirationTime) {
+ null === root.nextScheduledRoot ? (root.expirationTime = expirationTime, null === lastScheduledRoot ? (firstScheduledRoot = lastScheduledRoot = root, root.nextScheduledRoot = root) : (lastScheduledRoot = lastScheduledRoot.nextScheduledRoot = root, lastScheduledRoot.nextScheduledRoot = firstScheduledRoot)) : expirationTime > root.expirationTime && (root.expirationTime = expirationTime);
+ isRendering || (isBatchingUpdates ? isUnbatchingUpdates && (nextFlushedRoot = root, nextFlushedExpirationTime = 1073741823, performWorkOnRoot(root, 1073741823, !1)) : 1073741823 === expirationTime ? performWork(1073741823, !1) : scheduleCallbackWithExpirationTime(root, 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 {
+ remainingExpirationTime > highestPriorityWork && (highestPriorityWork = remainingExpirationTime, highestPriorityRoot = root);
+ if (root === lastScheduledRoot) break;
+ if (1073741823 === highestPriorityWork) break;
+ previousScheduledRoot = root;
+ root = root.nextScheduledRoot;
+ }
+ }
+ nextFlushedRoot = highestPriorityRoot;
+ nextFlushedExpirationTime = highestPriorityWork;
+ }
+
+ function performAsyncWork(didTimeout) {
+ if (didTimeout && null !== firstScheduledRoot) {
+ recomputeCurrentRendererTime();
+ didTimeout = firstScheduledRoot;
+
+ do {
+ var expirationTime = didTimeout.expirationTime;
+ 0 !== expirationTime && currentRendererTime <= expirationTime && (didTimeout.nextExpirationTimeToWorkOn = currentRendererTime);
+ didTimeout = didTimeout.nextScheduledRoot;
+ } while (didTimeout !== firstScheduledRoot);
+ }
+
+ performWork(0, !0);
+ }
+
+ function performWork(minExpirationTime, isYieldy) {
+ findHighestPriorityRoot();
+ if (isYieldy) for (recomputeCurrentRendererTime(), currentSchedulerTime = currentRendererTime; null !== nextFlushedRoot && 0 !== nextFlushedExpirationTime && minExpirationTime <= nextFlushedExpirationTime && !(frameDeadline <= now$1() && currentRendererTime > nextFlushedExpirationTime);) {
+ performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, currentRendererTime > nextFlushedExpirationTime), findHighestPriorityRoot(), recomputeCurrentRendererTime(), currentSchedulerTime = currentRendererTime;
+ } else for (; null !== nextFlushedRoot && 0 !== nextFlushedExpirationTime && minExpirationTime <= nextFlushedExpirationTime;) {
+ performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, !1), findHighestPriorityRoot();
+ }
+ isYieldy && (callbackExpirationTime = 0, callbackID = null);
+ 0 !== nextFlushedExpirationTime && scheduleCallbackWithExpirationTime(nextFlushedRoot, nextFlushedExpirationTime);
+ nestedUpdateCount = 0;
+ lastCommittedRootDuringThisBatch = null;
+ if (null !== completedBatches) for (minExpirationTime = completedBatches, completedBatches = null, isYieldy = 0; isYieldy < minExpirationTime.length; isYieldy++) {
+ var batch = minExpirationTime[isYieldy];
+
+ try {
+ batch._onComplete();
+ } catch (error) {
+ hasUnhandledError || (hasUnhandledError = !0, unhandledError = error);
+ }
+ }
+ if (hasUnhandledError) throw minExpirationTime = unhandledError, unhandledError = null, hasUnhandledError = !1, minExpirationTime;
+ }
+
+ 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;
+
+ if (isYieldy) {
+ var _finishedWork = root.finishedWork;
+ null !== _finishedWork ? completeRoot(root, _finishedWork, expirationTime) : (root.finishedWork = null, _finishedWork = root.timeoutHandle, -1 !== _finishedWork && (root.timeoutHandle = -1, cancelTimeout(_finishedWork)), renderRoot(root, isYieldy), _finishedWork = root.finishedWork, null !== _finishedWork && (frameDeadline <= now$1() ? root.finishedWork = _finishedWork : completeRoot(root, _finishedWork, expirationTime)));
+ } else _finishedWork = root.finishedWork, null !== _finishedWork ? completeRoot(root, _finishedWork, expirationTime) : (root.finishedWork = null, _finishedWork = root.timeoutHandle, -1 !== _finishedWork && (root.timeoutHandle = -1, cancelTimeout(_finishedWork)), renderRoot(root, isYieldy), _finishedWork = root.finishedWork, null !== _finishedWork && completeRoot(root, _finishedWork, expirationTime));
+
+ isRendering = !1;
+ }
+
+ function completeRoot(root, finishedWork, expirationTime) {
+ var firstBatch = root.firstBatch;
+
+ if (null !== firstBatch && firstBatch._expirationTime >= expirationTime && (null === completedBatches ? completedBatches = [firstBatch] : completedBatches.push(firstBatch), firstBatch._defer)) {
+ root.finishedWork = finishedWork;
+ root.expirationTime = 0;
+ return;
+ }
+
+ root.finishedWork = null;
+ root === lastCommittedRootDuringThisBatch ? nestedUpdateCount++ : (lastCommittedRootDuringThisBatch = root, nestedUpdateCount = 0);
+ scheduler.unstable_runWithPriority(scheduler.unstable_ImmediatePriority, function () {
+ commitRoot(root, finishedWork);
+ });
+ }
+
+ 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 findHostInstance(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$$1 = container.current,
+ currentTime = requestCurrentTime();
+ current$$1 = computeExpirationForFiber(currentTime, current$$1);
+ currentTime = container.current;
+
+ a: if (parentComponent) {
+ parentComponent = parentComponent._reactInternalFiber;
+
+ b: {
+ invariant(2 === isFiberMountedImpl(parentComponent) && 1 === 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.");
+ var parentContext = parentComponent;
+
+ do {
+ switch (parentContext.tag) {
+ case 3:
+ parentContext = parentContext.stateNode.context;
+ break b;
+
+ case 1:
+ if (isContextProvider(parentContext.type)) {
+ parentContext = parentContext.stateNode.__reactInternalMemoizedMergedChildContext;
+ break b;
+ }
+
+ }
+
+ parentContext = parentContext.return;
+ } while (null !== parentContext);
+
+ invariant(!1, "Found unexpected detached subtree parent. This error is likely caused by a bug in React. Please file an issue.");
+ parentContext = void 0;
+ }
+
+ if (1 === parentComponent.tag) {
+ var Component = parentComponent.type;
+
+ if (isContextProvider(Component)) {
+ parentComponent = processChildContext(parentComponent, Component, parentContext);
+ break a;
+ }
+ }
+
+ parentComponent = parentContext;
+ } else parentComponent = emptyContextObject;
+
+ null === container.context ? container.context = parentComponent : container.pendingContext = parentComponent;
+ container = callback;
+ callback = createUpdate(current$$1);
+ callback.payload = {
+ element: element
+ };
+ container = void 0 === container ? null : container;
+ null !== container && (callback.callback = container);
+ flushPassiveEffects();
+ enqueueUpdate(currentTime, callback);
+ scheduleWork(currentTime, current$$1);
+ return current$$1;
+ }
+
+ function _createPortal(children, containerInfo, implementation) {
+ var key = 3 < arguments.length && void 0 !== arguments[3] ? arguments[3] : null;
+ return {
+ $$typeof: REACT_PORTAL_TYPE,
+ key: null == key ? null : "" + key,
+ children: children,
+ containerInfo: containerInfo,
+ implementation: implementation
+ };
+ }
+
+ function _inherits(subClass, superClass) {
+ if ("function" !== typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+ subClass.prototype = Object.create(superClass && superClass.prototype, {
+ constructor: {
+ value: subClass,
+ enumerable: !1,
+ writable: !0,
+ configurable: !0
+ }
+ });
+ superClass && (Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass);
+ }
+
+ var getInspectorDataForViewTag = void 0;
+
+ getInspectorDataForViewTag = function getInspectorDataForViewTag() {
+ 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(componentOrHandle);
+ return null == componentOrHandle ? componentOrHandle : componentOrHandle.canonical ? componentOrHandle.canonical._nativeTag : componentOrHandle._nativeTag;
+ }
+
+ _batchedUpdatesImpl = function _batchedUpdatesImpl(fn, a) {
+ var previousIsBatchingUpdates = isBatchingUpdates;
+ isBatchingUpdates = !0;
+
+ try {
+ return fn(a);
+ } finally {
+ (isBatchingUpdates = previousIsBatchingUpdates) || isRendering || performWork(1073741823, !1);
+ }
+ };
+
+ _flushInteractiveUpdatesImpl = function _flushInteractiveUpdatesImpl() {
+ isRendering || 0 === lowestPriorityPendingInteractiveExpirationTime || (performWork(lowestPriorityPendingInteractiveExpirationTime, !1), lowestPriorityPendingInteractiveExpirationTime = 0);
+ };
+
+ 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_NOT_REALLY_SAFE(this, callback));
+ };
+
+ ReactNativeComponent.prototype.measureInWindow = function (callback) {
+ UIManager.measureInWindow(findNodeHandle(this), mountSafeCallback_NOT_REALLY_SAFE(this, callback));
+ };
+
+ ReactNativeComponent.prototype.measureLayout = function (relativeToNativeNode, onSuccess, onFail) {
+ UIManager.measureLayout(findNodeHandle(this), relativeToNativeNode, mountSafeCallback_NOT_REALLY_SAFE(this, onFail), mountSafeCallback_NOT_REALLY_SAFE(this, onSuccess));
+ };
+
+ ReactNativeComponent.prototype.setNativeProps = function (nativeProps) {
+ var maybeInstance = void 0;
+
+ try {
+ maybeInstance = findHostInstance(this);
+ } catch (error) {}
+
+ if (null != maybeInstance) {
+ var nativeTag = maybeInstance._nativeTag || maybeInstance.canonical._nativeTag;
+ maybeInstance = maybeInstance.viewConfig || maybeInstance.canonical.viewConfig;
+ nativeProps = diffProperties(null, emptyObject, nativeProps, maybeInstance.validAttributes);
+ null != nativeProps && UIManager.updateView(nativeTag, maybeInstance.uiViewClassName, nativeProps);
+ }
+ };
+
+ return ReactNativeComponent;
+ }(React.Component);
+ }(findNodeHandle, findHostInstance),
+ findNodeHandle: findNodeHandle,
+ setNativeProps: function setNativeProps(handle, nativeProps) {
+ null != handle._nativeTag && (nativeProps = diffProperties(null, emptyObject, nativeProps, handle.viewConfig.validAttributes), null != nativeProps && UIManager.updateView(handle._nativeTag, handle.viewConfig.uiViewClassName, nativeProps));
+ },
+ render: function render(element, containerTag, callback) {
+ var root = roots.get(containerTag);
+
+ if (!root) {
+ root = createFiber(3, null, null, 0);
+ var root$jscomp$0 = {
+ current: root,
+ containerInfo: containerTag,
+ pendingChildren: null,
+ pingCache: null,
+ earliestPendingTime: 0,
+ latestPendingTime: 0,
+ earliestSuspendedTime: 0,
+ latestSuspendedTime: 0,
+ latestPingedTime: 0,
+ didError: !1,
+ pendingCommitExpirationTime: 0,
+ finishedWork: null,
+ timeoutHandle: -1,
+ context: null,
+ pendingContext: null,
+ hydrate: !1,
+ nextExpirationTimeToWorkOn: 0,
+ expirationTime: 0,
+ firstBatch: null,
+ nextScheduledRoot: null
+ };
+ root = root.stateNode = root$jscomp$0;
+ roots.set(containerTag, root);
+ }
+
+ updateContainer(element, root, null, callback);
+
+ a: if (element = root.current, element.child) switch (element.child.tag) {
+ case 5:
+ element = element.child.stateNode;
+ break a;
+
+ default:
+ element = element.child.stateNode;
+ } else element = null;
+
+ return element;
+ },
+ unmountComponentAtNode: function unmountComponentAtNode(containerTag) {
+ var root = roots.get(containerTag);
+ root && updateContainer(null, root, null, function () {
+ roots.delete(containerTag);
+ });
+ },
+ unmountComponentAtNodeAndRemoveContainer: function unmountComponentAtNodeAndRemoveContainer(containerTag) {
+ ReactNativeRenderer.unmountComponentAtNode(containerTag);
+ 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_NOT_REALLY_SAFE(this, callback));
+ },
+ measureInWindow: function measureInWindow(callback) {
+ UIManager.measureInWindow(findNodeHandle(this), mountSafeCallback_NOT_REALLY_SAFE(this, callback));
+ },
+ measureLayout: function measureLayout(relativeToNativeNode, onSuccess, onFail) {
+ UIManager.measureLayout(findNodeHandle(this), relativeToNativeNode, mountSafeCallback_NOT_REALLY_SAFE(this, onFail), mountSafeCallback_NOT_REALLY_SAFE(this, onSuccess));
+ },
+ setNativeProps: function setNativeProps(nativeProps) {
+ var maybeInstance = void 0;
+
+ try {
+ maybeInstance = findHostInstance(this);
+ } catch (error) {}
+
+ if (null != maybeInstance) {
+ var nativeTag = maybeInstance._nativeTag || maybeInstance.canonical._nativeTag;
+ maybeInstance = maybeInstance.viewConfig || maybeInstance.canonical.viewConfig;
+ nativeProps = diffProperties(null, emptyObject, nativeProps, maybeInstance.validAttributes);
+ null != nativeProps && UIManager.updateView(nativeTag, maybeInstance.uiViewClassName, nativeProps);
+ }
+ },
+ focus: function focus() {
+ TextInputState.focusTextInput(findNodeHandle(this));
+ },
+ blur: function blur() {
+ TextInputState.blurTextInput(findNodeHandle(this));
+ }
+ };
+ }(findNodeHandle, findHostInstance),
+ computeComponentStackForErrorReporting: function computeComponentStackForErrorReporting(reactTag) {
+ return (reactTag = getInstanceFromTag(reactTag)) ? getStackByFiberInDevAndProd(reactTag) : "";
+ }
+ }
+ };
+
+ (function (devToolsConfig) {
+ var _findFiberByHostInstance = devToolsConfig.findFiberByHostInstance;
+ return injectInternals(_extends({}, devToolsConfig, {
+ overrideProps: null,
+ currentDispatcherRef: ReactSharedInternals.ReactCurrentDispatcher,
+ findHostInstanceByFiber: function findHostInstanceByFiber(fiber) {
+ fiber = findCurrentHostFiber(fiber);
+ return null === fiber ? null : fiber.stateNode;
+ },
+ findFiberByHostInstance: function findFiberByHostInstance(instance) {
+ return _findFiberByHostInstance ? _findFiberByHostInstance(instance) : null;
+ }
+ }));
+ })({
+ findFiberByHostInstance: getInstanceFromTag,
+ getInspectorDataForViewTag: getInspectorDataForViewTag,
+ bundleType: 0,
+ version: "16.8.3",
+ rendererPackageName: "react-native-renderer"
+ });
+
+ var ReactNativeRenderer$2 = {
+ default: ReactNativeRenderer
+ },
+ ReactNativeRenderer$3 = ReactNativeRenderer$2 && ReactNativeRenderer || ReactNativeRenderer$2;
+ module.exports = ReactNativeRenderer$3.default || ReactNativeRenderer$3;
+},183,[14,86,173,71,174,11,175,80,176,180,98],"node_modules\\react-native\\Libraries\\Renderer\\oss\\ReactNativeRenderer-prod.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var createReactNativeComponentClass = _$$_REQUIRE(_dependencyMap[0], "createReactNativeComponentClass");
+
+ var getNativeComponentAttributes = _$$_REQUIRE(_dependencyMap[1], "getNativeComponentAttributes");
+
+ var requireNativeComponent = function requireNativeComponent(uiViewClassName) {
+ return createReactNativeComponentClass(uiViewClassName, function () {
+ return getNativeComponentAttributes(uiViewClassName);
+ });
+ };
+
+ module.exports = requireNativeComponent;
+},184,[185,186],"node_modules\\react-native\\Libraries\\ReactNative\\requireNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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;
+},185,[173],"node_modules\\react-native\\Libraries\\Renderer\\shims\\createReactNativeComponentClass.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/defineProperty");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var ReactNativeStyleAttributes = _$$_REQUIRE(_dependencyMap[2], "ReactNativeStyleAttributes");
+
+ var UIManager = _$$_REQUIRE(_dependencyMap[3], "UIManager");
+
+ var insetsDiffer = _$$_REQUIRE(_dependencyMap[4], "insetsDiffer");
+
+ var matricesDiffer = _$$_REQUIRE(_dependencyMap[5], "matricesDiffer");
+
+ var pointsDiffer = _$$_REQUIRE(_dependencyMap[6], "pointsDiffer");
+
+ var processColor = _$$_REQUIRE(_dependencyMap[7], "processColor");
+
+ var resolveAssetSource = _$$_REQUIRE(_dependencyMap[8], "resolveAssetSource");
+
+ var sizesDiffer = _$$_REQUIRE(_dependencyMap[9], "sizesDiffer");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[10], "invariant");
+
+ var warning = _$$_REQUIRE(_dependencyMap[11], "fbjs/lib/warning");
+
+ function getNativeComponentAttributes(uiViewClassName) {
+ var viewConfig = UIManager.getViewManagerConfig(uiViewClassName);
+ invariant(viewConfig != null && viewConfig.NativeProps != null, 'requireNativeComponent: "%s" was not found in the UIManager.', uiViewClassName);
+ var baseModuleName = viewConfig.baseModuleName,
+ bubblingEventTypes = viewConfig.bubblingEventTypes,
+ directEventTypes = viewConfig.directEventTypes;
+ var nativeProps = viewConfig.NativeProps;
+
+ while (baseModuleName) {
+ var baseModule = UIManager.getViewManagerConfig(baseModuleName);
+
+ if (!baseModule) {
+ warning(false, 'Base module "%s" does not exist', baseModuleName);
+ baseModuleName = null;
+ } else {
+ bubblingEventTypes = _objectSpread({}, baseModule.bubblingEventTypes, {}, bubblingEventTypes);
+ directEventTypes = _objectSpread({}, baseModule.directEventTypes, {}, directEventTypes);
+ nativeProps = _objectSpread({}, baseModule.NativeProps, {}, nativeProps);
+ baseModuleName = baseModule.baseModuleName;
+ }
+ }
+
+ var validAttributes = {};
+
+ for (var key in nativeProps) {
+ var typeName = nativeProps[key];
+ var diff = getDifferForType(typeName);
+ var process = getProcessorForType(typeName);
+ validAttributes[key] = diff == null && process == null ? true : {
+ diff: diff,
+ process: process
+ };
+ }
+
+ validAttributes.style = ReactNativeStyleAttributes;
+
+ _extends(viewConfig, {
+ uiViewClassName: uiViewClassName,
+ validAttributes: validAttributes,
+ bubblingEventTypes: bubblingEventTypes,
+ directEventTypes: directEventTypes
+ });
+
+ if (!hasAttachedDefaultEventTypes) {
+ attachDefaultEventTypes(viewConfig);
+ hasAttachedDefaultEventTypes = true;
+ }
+
+ return viewConfig;
+ }
+
+ var hasAttachedDefaultEventTypes = false;
+
+ function attachDefaultEventTypes(viewConfig) {
+ if (UIManager.ViewManagerNames || UIManager.LazyViewManagersEnabled) {
+ 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 = getNativeComponentAttributes;
+},186,[14,32,57,71,187,188,189,75,190,78,19,21],"node_modules\\react-native\\Libraries\\ReactNative\\getNativeComponentAttributes.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var dummyInsets = {
+ top: undefined,
+ left: undefined,
+ right: undefined,
+ bottom: undefined
+ };
+
+ var insetsDiffer = function insetsDiffer(one, two) {
+ one = one || dummyInsets;
+ two = two || dummyInsets;
+ return one !== two && (one.top !== two.top || one.left !== two.left || one.right !== two.right || one.bottom !== two.bottom);
+ };
+
+ module.exports = insetsDiffer;
+},187,[],"node_modules\\react-native\\Libraries\\Utilities\\differ\\insetsDiffer.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var matricesDiffer = function matricesDiffer(one, two) {
+ if (one === two) {
+ return false;
+ }
+
+ return !one || !two || one[12] !== two[12] || one[13] !== two[13] || one[14] !== two[14] || one[5] !== two[5] || one[10] !== two[10] || one[1] !== two[1] || one[2] !== two[2] || one[3] !== two[3] || one[4] !== two[4] || one[6] !== two[6] || one[7] !== two[7] || one[8] !== two[8] || one[9] !== two[9] || one[11] !== two[11] || one[15] !== two[15];
+ };
+
+ module.exports = matricesDiffer;
+},188,[],"node_modules\\react-native\\Libraries\\Utilities\\differ\\matricesDiffer.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var dummyPoint = {
+ x: undefined,
+ y: undefined
+ };
+
+ var pointsDiffer = function pointsDiffer(one, two) {
+ one = one || dummyPoint;
+ two = two || dummyPoint;
+ return one !== two && (one.x !== two.x || one.y !== two.y);
+ };
+
+ module.exports = pointsDiffer;
+},189,[],"node_modules\\react-native\\Libraries\\Utilities\\differ\\pointsDiffer.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var AssetRegistry = _$$_REQUIRE(_dependencyMap[0], "AssetRegistry");
+
+ var AssetSourceResolver = _$$_REQUIRE(_dependencyMap[1], "AssetSourceResolver");
+
+ var _customSourceTransformer, _serverURL, _scriptURL;
+
+ var _sourceCodeScriptURL;
+
+ function getSourceCodeScriptURL() {
+ if (_sourceCodeScriptURL) {
+ return _sourceCodeScriptURL;
+ }
+
+ var sourceCode = global.nativeExtensions && global.nativeExtensions.SourceCode;
+
+ if (!sourceCode) {
+ 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;
+},190,[191,192,36],"node_modules\\react-native\\Libraries\\Image\\resolveAssetSource.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var assets = [];
+
+ function registerAsset(asset) {
+ return assets.push(asset);
+ }
+
+ function getAssetByID(assetId) {
+ return assets[assetId - 1];
+ }
+
+ module.exports = {
+ registerAsset: registerAsset,
+ getAssetByID: getAssetByID
+ };
+},191,[],"node_modules\\react-native\\Libraries\\Image\\AssetRegistry.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var PixelRatio = _$$_REQUIRE(_dependencyMap[2], "PixelRatio");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[3], "Platform");
+
+ var assetPathUtils = _$$_REQUIRE(_dependencyMap[4], "./assetPathUtils");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[5], "invariant");
+
+ function getScaledAssetPath(asset) {
+ var scale = AssetSourceResolver.pickScale(asset.scales, PixelRatio.get());
+ var scaleSuffix = scale === 1 ? '' : '@' + scale + 'x';
+ var assetDir = assetPathUtils.getBasePath(asset);
+ return assetDir + '/' + asset.name + scaleSuffix + '.' + asset.type;
+ }
+
+ function getAssetPathInDrawableFolder(asset) {
+ var scale = AssetSourceResolver.pickScale(asset.scales, PixelRatio.get());
+ var drawbleFolder = assetPathUtils.getAndroidResourceFolderName(asset, scale);
+ var fileName = assetPathUtils.getAndroidResourceIdentifier(asset);
+ return drawbleFolder + '/' + fileName + '.' + asset.type;
+ }
+
+ var AssetSourceResolver = function () {
+ function AssetSourceResolver(serverUrl, jsbundleUrl, asset) {
+ _classCallCheck(this, AssetSourceResolver);
+
+ this.serverUrl = serverUrl;
+ this.jsbundleUrl = jsbundleUrl;
+ this.asset = asset;
+ }
+
+ _createClass(AssetSourceResolver, [{
+ key: "isLoadedFromServer",
+ value: function isLoadedFromServer() {
+ return !!this.serverUrl;
+ }
+ }, {
+ key: "isLoadedFromFileSystem",
+ value: function isLoadedFromFileSystem() {
+ return !!(this.jsbundleUrl && this.jsbundleUrl.startsWith('file://'));
+ }
+ }, {
+ key: "defaultAsset",
+ value: function defaultAsset() {
+ if (this.isLoadedFromServer()) {
+ return this.assetServerURL();
+ }
+
+ if (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;
+},192,[3,4,54,35,193,19],"node_modules\\react-native\\Libraries\\Image\\AssetSourceResolver.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var androidScaleSuffix = {
+ '0.75': 'ldpi',
+ '1': 'mdpi',
+ '1.5': 'hdpi',
+ '2': 'xhdpi',
+ '3': 'xxhdpi',
+ '4': 'xxxhdpi'
+ };
+
+ function getAndroidAssetSuffix(scale) {
+ if (scale.toString() in androidScaleSuffix) {
+ return androidScaleSuffix[scale.toString()];
+ }
+
+ throw new Error('no such scale ' + scale.toString());
+ }
+
+ var drawableFileTypes = new Set(['gif', 'jpeg', 'jpg', 'png', 'svg', 'webp', 'xml']);
+
+ function getAndroidResourceFolderName(asset, scale) {
+ if (!drawableFileTypes.has(asset.type)) {
+ return 'raw';
+ }
+
+ var suffix = getAndroidAssetSuffix(scale);
+
+ if (!suffix) {
+ throw new Error("Don't know which android drawable suffix to use for scale: " + scale + '\nAsset: ' + JSON.stringify(asset, null, '\t') + '\nPossible scales are:' + JSON.stringify(androidScaleSuffix, null, '\t'));
+ }
+
+ var androidFolder = 'drawable-' + suffix;
+ return androidFolder;
+ }
+
+ function getAndroidResourceIdentifier(asset) {
+ var folderPath = getBasePath(asset);
+ return (folderPath + '/' + asset.name).toLowerCase().replace(/\//g, '_').replace(/([^a-z0-9_])/g, '').replace(/^assets_/, '');
+ }
+
+ function getBasePath(asset) {
+ var basePath = asset.httpServerLocation;
+
+ if (basePath[0] === '/') {
+ basePath = basePath.substr(1);
+ }
+
+ return basePath;
+ }
+
+ module.exports = {
+ getAndroidAssetSuffix: getAndroidAssetSuffix,
+ getAndroidResourceFolderName: getAndroidResourceFolderName,
+ getAndroidResourceIdentifier: getAndroidResourceIdentifier,
+ getBasePath: getBasePath
+ };
+},193,[],"node_modules\\react-native\\Libraries\\Image\\assetPathUtils.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var requireNativeComponent = _$$_REQUIRE(_dependencyMap[0], "requireNativeComponent");
+
+ module.exports = requireNativeComponent('RCTActivityIndicatorView');
+},194,[184],"node_modules\\react-native\\Libraries\\Components\\ActivityIndicator\\RCTActivityIndicatorViewNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "UnimplementedView");
+},195,[196],"Libraries\\Components\\ProgressBarAndroid\\ProgressBarAndroid.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Components\\UnimplementedViews\\UnimplementedView.js";
+
+ var React = _$$_REQUIRE(_dependencyMap[5], "React");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[6], "StyleSheet");
+
+ var UnimplementedView = function (_React$Component) {
+ _inherits(UnimplementedView, _React$Component);
+
+ function UnimplementedView() {
+ _classCallCheck(this, UnimplementedView);
+
+ return _possibleConstructorReturn(this, _getPrototypeOf(UnimplementedView).apply(this, arguments));
+ }
+
+ _createClass(UnimplementedView, [{
+ key: "setNativeProps",
+ value: function setNativeProps() {}
+ }, {
+ key: "render",
+ value: function render() {
+ var View = _$$_REQUIRE(_dependencyMap[7], "View");
+
+ return React.createElement(View, {
+ style: [styles.unimplementedView, this.props.style],
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 30
+ }
+ }, this.props.children);
+ }
+ }]);
+
+ return UnimplementedView;
+ }(React.Component);
+
+ var styles = StyleSheet.create({
+ unimplementedView: __DEV__ ? {
+ alignSelf: 'flex-start',
+ borderColor: 'red',
+ borderWidth: 1
+ } : {}
+ });
+ module.exports = UnimplementedView;
+},196,[3,4,5,8,9,52,53,81],"node_modules\\react-native\\Libraries\\Components\\UnimplementedViews\\UnimplementedView.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\ART\\ReactNativeART.js";
+
+ var Color = _$$_REQUIRE(_dependencyMap[5], "art/core/color");
+
+ var Path = _$$_REQUIRE(_dependencyMap[6], "ARTSerializablePath");
+
+ var Transform = _$$_REQUIRE(_dependencyMap[7], "art/core/transform");
+
+ var React = _$$_REQUIRE(_dependencyMap[8], "React");
+
+ var PropTypes = _$$_REQUIRE(_dependencyMap[9], "prop-types");
+
+ var ReactNativeViewAttributes = _$$_REQUIRE(_dependencyMap[10], "ReactNativeViewAttributes");
+
+ var createReactNativeComponentClass = _$$_REQUIRE(_dependencyMap[11], "createReactNativeComponentClass");
+
+ var merge = _$$_REQUIRE(_dependencyMap[12], "merge");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[13], "invariant");
+
+ function arrayDiffer(a, b) {
+ if (a == null || b == null) {
+ return true;
+ }
+
+ if (a.length !== b.length) {
+ return true;
+ }
+
+ for (var i = 0; i < a.length; i++) {
+ if (a[i] !== b[i]) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ function fontAndLinesDiffer(a, b) {
+ if (a === b) {
+ return false;
+ }
+
+ if (a.font !== b.font) {
+ if (a.font === null) {
+ return true;
+ }
+
+ if (b.font === null) {
+ return true;
+ }
+
+ if (a.font.fontFamily !== b.font.fontFamily || a.font.fontSize !== b.font.fontSize || a.font.fontWeight !== b.font.fontWeight || a.font.fontStyle !== b.font.fontStyle) {
+ return true;
+ }
+ }
+
+ return arrayDiffer(a.lines, b.lines);
+ }
+
+ var SurfaceViewAttributes = merge(ReactNativeViewAttributes.UIView, {});
+ var NodeAttributes = {
+ transform: {
+ diff: arrayDiffer
+ },
+ opacity: true
+ };
+ var GroupAttributes = merge(NodeAttributes, {
+ clipping: {
+ diff: arrayDiffer
+ }
+ });
+ var RenderableAttributes = merge(NodeAttributes, {
+ fill: {
+ diff: arrayDiffer
+ },
+ stroke: {
+ diff: arrayDiffer
+ },
+ strokeWidth: true,
+ strokeCap: true,
+ strokeJoin: true,
+ strokeDash: {
+ diff: arrayDiffer
+ }
+ });
+ var ShapeAttributes = merge(RenderableAttributes, {
+ d: {
+ diff: arrayDiffer
+ }
+ });
+ var TextAttributes = merge(RenderableAttributes, {
+ alignment: true,
+ frame: {
+ diff: fontAndLinesDiffer
+ },
+ path: {
+ diff: arrayDiffer
+ }
+ });
+ var NativeSurfaceView = createReactNativeComponentClass('ARTSurfaceView', function () {
+ return {
+ validAttributes: SurfaceViewAttributes,
+ uiViewClassName: 'ARTSurfaceView'
+ };
+ });
+ var NativeGroup = createReactNativeComponentClass('ARTGroup', function () {
+ return {
+ validAttributes: GroupAttributes,
+ uiViewClassName: 'ARTGroup'
+ };
+ });
+ var NativeShape = createReactNativeComponentClass('ARTShape', function () {
+ return {
+ validAttributes: ShapeAttributes,
+ uiViewClassName: 'ARTShape'
+ };
+ });
+ var NativeText = createReactNativeComponentClass('ARTText', function () {
+ return {
+ validAttributes: TextAttributes,
+ uiViewClassName: 'ARTText'
+ };
+ });
+
+ function childrenAsString(children) {
+ if (!children) {
+ return '';
+ }
+
+ if (typeof children === 'string') {
+ return children;
+ }
+
+ if (children.length) {
+ return children.join('\n');
+ }
+
+ return '';
+ }
+
+ var Surface = function (_React$Component) {
+ _inherits(Surface, _React$Component);
+
+ function Surface() {
+ _classCallCheck(this, Surface);
+
+ return _possibleConstructorReturn(this, _getPrototypeOf(Surface).apply(this, arguments));
+ }
+
+ _createClass(Surface, [{
+ key: "getChildContext",
+ value: function getChildContext() {
+ return {
+ isInSurface: true
+ };
+ }
+ }, {
+ key: "render",
+ value: function render() {
+ var height = extractNumber(this.props.height, 0);
+ var width = extractNumber(this.props.width, 0);
+ return React.createElement(NativeSurfaceView, {
+ style: [this.props.style, {
+ height: height,
+ width: width
+ }],
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 157
+ }
+ }, this.props.children);
+ }
+ }]);
+
+ return Surface;
+ }(React.Component);
+
+ Surface.childContextTypes = {
+ isInSurface: PropTypes.bool
+ };
+
+ function extractNumber(value, defaultValue) {
+ if (value == null) {
+ return defaultValue;
+ }
+
+ return +value;
+ }
+
+ var pooledTransform = new Transform();
+
+ function extractTransform(props) {
+ var scaleX = props.scaleX != null ? props.scaleX : props.scale != null ? props.scale : 1;
+ var scaleY = props.scaleY != null ? props.scaleY : props.scale != null ? props.scale : 1;
+ pooledTransform.transformTo(1, 0, 0, 1, 0, 0).move(props.x || 0, props.y || 0).rotate(props.rotation || 0, props.originX, props.originY).scale(scaleX, scaleY, props.originX, props.originY);
+
+ if (props.transform != null) {
+ pooledTransform.transform(props.transform);
+ }
+
+ return [pooledTransform.xx, pooledTransform.yx, pooledTransform.xy, pooledTransform.yy, pooledTransform.x, pooledTransform.y];
+ }
+
+ function extractOpacity(props) {
+ if (props.visible === false) {
+ return 0;
+ }
+
+ if (props.opacity == null) {
+ return 1;
+ }
+
+ return +props.opacity;
+ }
+
+ var Group = function (_React$Component2) {
+ _inherits(Group, _React$Component2);
+
+ function Group() {
+ _classCallCheck(this, Group);
+
+ return _possibleConstructorReturn(this, _getPrototypeOf(Group).apply(this, arguments));
+ }
+
+ _createClass(Group, [{
+ key: "render",
+ value: function render() {
+ var props = this.props;
+ invariant(this.context.isInSurface, 'ART: must be a child of a ');
+ return React.createElement(NativeGroup, {
+ opacity: extractOpacity(props),
+ transform: extractTransform(props),
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 232
+ }
+ }, this.props.children);
+ }
+ }]);
+
+ return Group;
+ }(React.Component);
+
+ Group.contextTypes = {
+ isInSurface: PropTypes.bool.isRequired
+ };
+
+ var ClippingRectangle = function (_React$Component3) {
+ _inherits(ClippingRectangle, _React$Component3);
+
+ function ClippingRectangle() {
+ _classCallCheck(this, ClippingRectangle);
+
+ return _possibleConstructorReturn(this, _getPrototypeOf(ClippingRectangle).apply(this, arguments));
+ }
+
+ _createClass(ClippingRectangle, [{
+ key: "render",
+ value: function render() {
+ var props = this.props;
+ var x = extractNumber(props.x, 0);
+ var y = extractNumber(props.y, 0);
+ var w = extractNumber(props.width, 0);
+ var h = extractNumber(props.height, 0);
+ var clipping = [x, y, w, h];
+ var propsExcludingXAndY = merge(props);
+ delete propsExcludingXAndY.x;
+ delete propsExcludingXAndY.y;
+ return React.createElement(NativeGroup, {
+ clipping: clipping,
+ opacity: extractOpacity(props),
+ transform: extractTransform(propsExcludingXAndY),
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 254
+ }
+ }, this.props.children);
+ }
+ }]);
+
+ return ClippingRectangle;
+ }(React.Component);
+
+ var SOLID_COLOR = 0;
+ var LINEAR_GRADIENT = 1;
+ var RADIAL_GRADIENT = 2;
+ var PATTERN = 3;
+
+ function insertColorIntoArray(color, targetArray, atIndex) {
+ var c = new Color(color);
+ targetArray[atIndex + 0] = c.red / 255;
+ targetArray[atIndex + 1] = c.green / 255;
+ targetArray[atIndex + 2] = c.blue / 255;
+ targetArray[atIndex + 3] = c.alpha;
+ }
+
+ function insertColorsIntoArray(stops, targetArray, atIndex) {
+ var i = 0;
+
+ if ('length' in stops) {
+ while (i < stops.length) {
+ insertColorIntoArray(stops[i], targetArray, atIndex + i * 4);
+ i++;
+ }
+ } else {
+ for (var offset in stops) {
+ insertColorIntoArray(stops[offset], targetArray, atIndex + i * 4);
+ i++;
+ }
+ }
+
+ return atIndex + i * 4;
+ }
+
+ function insertOffsetsIntoArray(stops, targetArray, atIndex, multi, reverse) {
+ var offsetNumber;
+ var i = 0;
+
+ if ('length' in stops) {
+ while (i < stops.length) {
+ offsetNumber = i / (stops.length - 1) * multi;
+ targetArray[atIndex + i] = reverse ? 1 - offsetNumber : offsetNumber;
+ i++;
+ }
+ } else {
+ for (var offsetString in stops) {
+ offsetNumber = +offsetString * multi;
+ targetArray[atIndex + i] = reverse ? 1 - offsetNumber : offsetNumber;
+ i++;
+ }
+ }
+
+ return atIndex + i;
+ }
+
+ function insertColorStopsIntoArray(stops, targetArray, atIndex) {
+ var lastIndex = insertColorsIntoArray(stops, targetArray, atIndex);
+ insertOffsetsIntoArray(stops, targetArray, lastIndex, 1, false);
+ }
+
+ function insertDoubleColorStopsIntoArray(stops, targetArray, atIndex) {
+ var lastIndex = insertColorsIntoArray(stops, targetArray, atIndex);
+ lastIndex = insertColorsIntoArray(stops, targetArray, lastIndex);
+ lastIndex = insertOffsetsIntoArray(stops, targetArray, lastIndex, 0.5, false);
+ insertOffsetsIntoArray(stops, targetArray, lastIndex, 0.5, true);
+ }
+
+ function applyBoundingBoxToBrushData(brushData, props) {
+ var type = brushData[0];
+ var width = +props.width;
+ var height = +props.height;
+
+ if (type === LINEAR_GRADIENT) {
+ brushData[1] *= width;
+ brushData[2] *= height;
+ brushData[3] *= width;
+ brushData[4] *= height;
+ } else if (type === RADIAL_GRADIENT) {
+ brushData[1] *= width;
+ brushData[2] *= height;
+ brushData[3] *= width;
+ brushData[4] *= height;
+ brushData[5] *= width;
+ brushData[6] *= height;
+ } else if (type === PATTERN) {}
+ }
+
+ function extractBrush(colorOrBrush, props) {
+ if (colorOrBrush == null) {
+ return null;
+ }
+
+ if (colorOrBrush._brush) {
+ if (colorOrBrush._bb) {
+ applyBoundingBoxToBrushData(colorOrBrush._brush, props);
+ colorOrBrush._bb = false;
+ }
+
+ return colorOrBrush._brush;
+ }
+
+ var c = new Color(colorOrBrush);
+ return [SOLID_COLOR, c.red / 255, c.green / 255, c.blue / 255, c.alpha];
+ }
+
+ function extractColor(color) {
+ if (color == null) {
+ return null;
+ }
+
+ var c = new Color(color);
+ return [c.red / 255, c.green / 255, c.blue / 255, c.alpha];
+ }
+
+ function extractStrokeCap(strokeCap) {
+ switch (strokeCap) {
+ case 'butt':
+ return 0;
+
+ case 'square':
+ return 2;
+
+ default:
+ return 1;
+ }
+ }
+
+ function extractStrokeJoin(strokeJoin) {
+ switch (strokeJoin) {
+ case 'miter':
+ return 0;
+
+ case 'bevel':
+ return 2;
+
+ default:
+ return 1;
+ }
+ }
+
+ var Shape = function (_React$Component4) {
+ _inherits(Shape, _React$Component4);
+
+ function Shape() {
+ _classCallCheck(this, Shape);
+
+ return _possibleConstructorReturn(this, _getPrototypeOf(Shape).apply(this, arguments));
+ }
+
+ _createClass(Shape, [{
+ key: "render",
+ value: function render() {
+ var props = this.props;
+ var path = props.d || childrenAsString(props.children);
+ var d = (path instanceof Path ? path : new Path(path)).toJSON();
+ return React.createElement(NativeShape, {
+ fill: extractBrush(props.fill, props),
+ opacity: extractOpacity(props),
+ stroke: extractColor(props.stroke),
+ strokeCap: extractStrokeCap(props.strokeCap),
+ strokeDash: props.strokeDash || null,
+ strokeJoin: extractStrokeJoin(props.strokeJoin),
+ strokeWidth: extractNumber(props.strokeWidth, 1),
+ transform: extractTransform(props),
+ d: d,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 420
+ }
+ });
+ }
+ }]);
+
+ return Shape;
+ }(React.Component);
+
+ var cachedFontObjectsFromString = {};
+ var fontFamilyPrefix = /^[\s"']*/;
+ var fontFamilySuffix = /[\s"']*$/;
+
+ function extractSingleFontFamily(fontFamilyString) {
+ return fontFamilyString.split(',')[0].replace(fontFamilyPrefix, '').replace(fontFamilySuffix, '');
+ }
+
+ function parseFontString(font) {
+ if (cachedFontObjectsFromString.hasOwnProperty(font)) {
+ return cachedFontObjectsFromString[font];
+ }
+
+ var regexp = /^\s*((?:(?:normal|bold|italic)\s+)*)(?:(\d+(?:\.\d+)?)[ptexm\%]*(?:\s*\/.*?)?\s+)?\s*\"?([^\"]*)/i;
+ var match = regexp.exec(font);
+
+ if (!match) {
+ return null;
+ }
+
+ var fontFamily = extractSingleFontFamily(match[3]);
+ var fontSize = +match[2] || 12;
+ var isBold = /bold/.exec(match[1]);
+ var isItalic = /italic/.exec(match[1]);
+ cachedFontObjectsFromString[font] = {
+ fontFamily: fontFamily,
+ fontSize: fontSize,
+ fontWeight: isBold ? 'bold' : 'normal',
+ fontStyle: isItalic ? 'italic' : 'normal'
+ };
+ return cachedFontObjectsFromString[font];
+ }
+
+ function extractFont(font) {
+ if (font == null) {
+ return null;
+ }
+
+ if (typeof font === 'string') {
+ return parseFontString(font);
+ }
+
+ var fontFamily = extractSingleFontFamily(font.fontFamily);
+ var fontSize = +font.fontSize || 12;
+ var fontWeight = font.fontWeight != null ? font.fontWeight.toString() : '400';
+ return {
+ fontFamily: fontFamily,
+ fontSize: fontSize,
+ fontWeight: fontWeight,
+ fontStyle: font.fontStyle
+ };
+ }
+
+ var newLine = /\n/g;
+
+ function extractFontAndLines(font, text) {
+ return {
+ font: extractFont(font),
+ lines: text.split(newLine)
+ };
+ }
+
+ function extractAlignment(alignment) {
+ switch (alignment) {
+ case 'right':
+ return 1;
+
+ case 'center':
+ return 2;
+
+ default:
+ return 0;
+ }
+ }
+
+ var Text = function (_React$Component5) {
+ _inherits(Text, _React$Component5);
+
+ function Text() {
+ _classCallCheck(this, Text);
+
+ return _possibleConstructorReturn(this, _getPrototypeOf(Text).apply(this, arguments));
+ }
+
+ _createClass(Text, [{
+ key: "render",
+ value: function render() {
+ var props = this.props;
+ var path = props.path;
+ var textPath = path ? (path instanceof Path ? path : new Path(path)).toJSON() : null;
+ var textFrame = extractFontAndLines(props.font, childrenAsString(props.children));
+ return React.createElement(NativeText, {
+ fill: extractBrush(props.fill, props),
+ opacity: extractOpacity(props),
+ stroke: extractColor(props.stroke),
+ strokeCap: extractStrokeCap(props.strokeCap),
+ strokeDash: props.strokeDash || null,
+ strokeJoin: extractStrokeJoin(props.strokeJoin),
+ strokeWidth: extractNumber(props.strokeWidth, 1),
+ transform: extractTransform(props),
+ alignment: extractAlignment(props.alignment),
+ frame: textFrame,
+ path: textPath,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 522
+ }
+ });
+ }
+ }]);
+
+ return Text;
+ }(React.Component);
+
+ function LinearGradient(stops, x1, y1, x2, y2) {
+ var type = LINEAR_GRADIENT;
+
+ if (arguments.length < 5) {
+ var angle = (x1 == null ? 270 : x1) * Math.PI / 180;
+ var x = Math.cos(angle);
+ var y = -Math.sin(angle);
+ var l = (Math.abs(x) + Math.abs(y)) / 2;
+ x *= l;
+ y *= l;
+ x1 = 0.5 - x;
+ x2 = 0.5 + x;
+ y1 = 0.5 - y;
+ y2 = 0.5 + y;
+ this._bb = true;
+ } else {
+ this._bb = false;
+ }
+
+ var brushData = [type, +x1, +y1, +x2, +y2];
+ insertColorStopsIntoArray(stops, brushData, 5);
+ this._brush = brushData;
+ }
+
+ function RadialGradient(stops, fx, fy, rx, ry, cx, cy) {
+ if (ry == null) {
+ ry = rx;
+ }
+
+ if (cx == null) {
+ cx = fx;
+ }
+
+ if (cy == null) {
+ cy = fy;
+ }
+
+ if (fx == null) {
+ fx = fy = rx = ry = cx = cy = 0.5;
+ this._bb = true;
+ } else {
+ this._bb = false;
+ }
+
+ var brushData = [RADIAL_GRADIENT, +fx, +fy, +rx * 2, +ry * 2, +cx, +cy];
+ insertDoubleColorStopsIntoArray(stops, brushData, 7);
+ this._brush = brushData;
+ }
+
+ function Pattern(url, width, height, left, top) {
+ this._brush = [PATTERN, url, +left || 0, +top || 0, +width, +height];
+ }
+
+ var ReactART = {
+ LinearGradient: LinearGradient,
+ RadialGradient: RadialGradient,
+ Pattern: Pattern,
+ Transform: Transform,
+ Path: Path,
+ Surface: Surface,
+ Group: Group,
+ ClippingRectangle: ClippingRectangle,
+ Shape: Shape,
+ Text: Text
+ };
+ module.exports = ReactART;
+},197,[3,4,5,8,9,198,199,202,52,62,203,185,204,19],"node_modules\\react-native\\Libraries\\ART\\ReactNativeART.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var colors = {
+ maroon: '#800000',
+ red: '#ff0000',
+ orange: '#ffA500',
+ yellow: '#ffff00',
+ olive: '#808000',
+ purple: '#800080',
+ fuchsia: "#ff00ff",
+ white: '#ffffff',
+ lime: '#00ff00',
+ green: '#008000',
+ navy: '#000080',
+ blue: '#0000ff',
+ aqua: '#00ffff',
+ teal: '#008080',
+ black: '#000000',
+ silver: '#c0c0c0',
+ gray: '#808080'
+ };
+
+ var map = function map(array, fn) {
+ var results = [];
+
+ for (var i = 0, l = array.length; i < l; i++) {
+ results[i] = fn(array[i], i);
+ }
+
+ return results;
+ };
+
+ var Color = function Color(color, type) {
+ if (color.isColor) {
+ this.red = color.red;
+ this.green = color.green;
+ this.blue = color.blue;
+ this.alpha = color.alpha;
+ } else {
+ var namedColor = colors[color];
+
+ if (namedColor) {
+ color = namedColor;
+ type = 'hex';
+ }
+
+ switch (typeof color) {
+ case 'string':
+ if (!type) type = (type = color.match(/^rgb|^hsb|^hsl/)) ? type[0] : 'hex';
+ break;
+
+ case 'object':
+ type = type || 'rgb';
+ color = color.toString();
+ break;
+
+ case 'number':
+ type = 'hex';
+ color = color.toString(16);
+ break;
+ }
+
+ color = Color['parse' + type.toUpperCase()](color);
+ this.red = color[0];
+ this.green = color[1];
+ this.blue = color[2];
+ this.alpha = color[3];
+ }
+
+ this.isColor = true;
+ };
+
+ var limit = function limit(number, min, max) {
+ return Math.min(max, Math.max(min, number));
+ };
+
+ var listMatch = /([-.\d]+\%?)\s*,\s*([-.\d]+\%?)\s*,\s*([-.\d]+\%?)\s*,?\s*([-.\d]*\%?)/;
+ var hexMatch = /^#?([a-f0-9]{1,2})([a-f0-9]{1,2})([a-f0-9]{1,2})([a-f0-9]{0,2})$/i;
+
+ Color.parseRGB = function (color) {
+ return map(color.match(listMatch).slice(1), function (bit, i) {
+ if (bit) bit = parseFloat(bit) * (bit[bit.length - 1] == '%' ? 2.55 : 1);
+ return i < 3 ? Math.round((bit %= 256) < 0 ? bit + 256 : bit) : limit(bit === '' ? 1 : Number(bit), 0, 1);
+ });
+ };
+
+ Color.parseHEX = function (color) {
+ if (color.length == 1) color = color + color + color;
+ return map(color.match(hexMatch).slice(1), function (bit, i) {
+ if (i == 3) return bit ? parseInt(bit, 16) / 255 : 1;
+ return parseInt(bit.length == 1 ? bit + bit : bit, 16);
+ });
+ };
+
+ Color.parseHSB = function (color) {
+ var hsb = map(color.match(listMatch).slice(1), function (bit, i) {
+ if (bit) bit = parseFloat(bit);
+ if (i === 0) return Math.round((bit %= 360) < 0 ? bit + 360 : bit);else if (i < 3) return limit(Math.round(bit), 0, 100);else return limit(bit === '' ? 1 : Number(bit), 0, 1);
+ });
+ var a = hsb[3];
+ var br = Math.round(hsb[2] / 100 * 255);
+ if (hsb[1] == 0) return [br, br, br, a];
+ var hue = hsb[0];
+ var f = hue % 60;
+ var p = Math.round(hsb[2] * (100 - hsb[1]) / 10000 * 255);
+ var q = Math.round(hsb[2] * (6000 - hsb[1] * f) / 600000 * 255);
+ var t = Math.round(hsb[2] * (6000 - hsb[1] * (60 - f)) / 600000 * 255);
+
+ switch (Math.floor(hue / 60)) {
+ case 0:
+ return [br, t, p, a];
+
+ case 1:
+ return [q, br, p, a];
+
+ case 2:
+ return [p, br, t, a];
+
+ case 3:
+ return [p, q, br, a];
+
+ case 4:
+ return [t, p, br, a];
+
+ default:
+ return [br, p, q, a];
+ }
+ };
+
+ Color.parseHSL = function (color) {
+ var hsb = map(color.match(listMatch).slice(1), function (bit, i) {
+ if (bit) bit = parseFloat(bit);
+ if (i === 0) return Math.round((bit %= 360) < 0 ? bit + 360 : bit);else if (i < 3) return limit(Math.round(bit), 0, 100);else return limit(bit === '' ? 1 : Number(bit), 0, 1);
+ });
+ var h = hsb[0] / 60;
+ var s = hsb[1] / 100;
+ var l = hsb[2] / 100;
+ var a = hsb[3];
+ var c = (1 - Math.abs(2 * l - 1)) * s;
+ var x = c * (1 - Math.abs(h % 2 - 1));
+ var m = l - c / 2;
+ var p = Math.round((c + m) * 255);
+ var q = Math.round((x + m) * 255);
+ var t = Math.round(m * 255);
+
+ switch (Math.floor(h)) {
+ case 0:
+ return [p, q, t, a];
+
+ case 1:
+ return [q, p, t, a];
+
+ case 2:
+ return [t, p, q, a];
+
+ case 3:
+ return [t, q, p, a];
+
+ case 4:
+ return [q, t, p, a];
+
+ default:
+ return [p, t, q, a];
+ }
+ };
+
+ var toString = function toString(type, array) {
+ if (array[3] != 1) type += 'a';else array.pop();
+ return type + '(' + array.join(', ') + ')';
+ };
+
+ Color.prototype = {
+ toHSB: function toHSB(array) {
+ var red = this.red,
+ green = this.green,
+ blue = this.blue,
+ alpha = this.alpha;
+ var max = Math.max(red, green, blue),
+ min = Math.min(red, green, blue),
+ delta = max - min;
+ var hue = 0,
+ saturation = delta != 0 ? delta / max : 0,
+ brightness = max / 255;
+
+ if (saturation) {
+ var rr = (max - red) / delta,
+ gr = (max - green) / delta,
+ br = (max - blue) / delta;
+ hue = red == max ? br - gr : green == max ? 2 + rr - br : 4 + gr - rr;
+ if ((hue /= 6) < 0) hue++;
+ }
+
+ var hsb = [Math.round(hue * 360), Math.round(saturation * 100), Math.round(brightness * 100), alpha];
+ return array ? hsb : toString('hsb', hsb);
+ },
+ toHSL: function toHSL(array) {
+ var red = this.red,
+ green = this.green,
+ blue = this.blue,
+ alpha = this.alpha;
+ var max = Math.max(red, green, blue),
+ min = Math.min(red, green, blue),
+ delta = max - min;
+ var hue = 0,
+ saturation = delta != 0 ? delta / (255 - Math.abs(max + min - 255)) : 0,
+ lightness = (max + min) / 512;
+
+ if (saturation) {
+ var rr = (max - red) / delta,
+ gr = (max - green) / delta,
+ br = (max - blue) / delta;
+ hue = red == max ? br - gr : green == max ? 2 + rr - br : 4 + gr - rr;
+ if ((hue /= 6) < 0) hue++;
+ }
+
+ var hsl = [Math.round(hue * 360), Math.round(saturation * 100), Math.round(lightness * 100), alpha];
+ return array ? hsl : toString('hsl', hsl);
+ },
+ toHEX: function toHEX(array) {
+ var a = this.alpha;
+ var alpha = (a = Math.round(a * 255).toString(16)).length == 1 ? a + a : a;
+ var hex = map([this.red, this.green, this.blue], function (bit) {
+ bit = bit.toString(16);
+ return bit.length == 1 ? '0' + bit : bit;
+ });
+ return array ? hex.concat(alpha) : '#' + hex.join('') + (alpha == 'ff' ? '' : alpha);
+ },
+ toRGB: function toRGB(array) {
+ var rgb = [this.red, this.green, this.blue, this.alpha];
+ return array ? rgb : toString('rgb', rgb);
+ }
+ };
+ Color.prototype.toString = Color.prototype.toRGB;
+
+ Color.hex = function (hex) {
+ return new Color(hex, 'hex');
+ };
+
+ if (this.hex == null) this.hex = Color.hex;
+
+ Color.hsb = function (h, s, b, a) {
+ return new Color([h || 0, s || 0, b || 0, a == null ? 1 : a], 'hsb');
+ };
+
+ if (this.hsb == null) this.hsb = Color.hsb;
+
+ Color.hsl = function (h, s, l, a) {
+ return new Color([h || 0, s || 0, l || 0, a == null ? 1 : a], 'hsl');
+ };
+
+ if (this.hsl == null) this.hsl = Color.hsl;
+
+ Color.rgb = function (r, g, b, a) {
+ return new Color([r || 0, g || 0, b || 0, a == null ? 1 : a], 'rgb');
+ };
+
+ if (this.rgb == null) this.rgb = Color.rgb;
+
+ Color.detach = function (color) {
+ color = new Color(color);
+ return [Color.rgb(color.red, color.green, color.blue).toString(), color.alpha];
+ };
+
+ module.exports = Color;
+},198,[],"node_modules\\art\\core\\color.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var Class = _$$_REQUIRE(_dependencyMap[0], "art/core/class.js");
+
+ var Path = _$$_REQUIRE(_dependencyMap[1], "art/core/path.js");
+
+ var MOVE_TO = 0;
+ var CLOSE = 1;
+ var LINE_TO = 2;
+ var CURVE_TO = 3;
+ var ARC = 4;
+ var SerializablePath = Class(Path, {
+ initialize: function initialize(path) {
+ this.reset();
+
+ if (path instanceof SerializablePath) {
+ this.path = path.path.slice(0);
+ } else if (path) {
+ if (path.applyToPath) {
+ path.applyToPath(this);
+ } else {
+ this.push(path);
+ }
+ }
+ },
+ onReset: function onReset() {
+ this.path = [];
+ },
+ onMove: function onMove(sx, sy, x, y) {
+ this.path.push(MOVE_TO, x, y);
+ },
+ onLine: function onLine(sx, sy, x, y) {
+ this.path.push(LINE_TO, x, y);
+ },
+ onBezierCurve: function onBezierCurve(sx, sy, p1x, p1y, p2x, p2y, x, y) {
+ this.path.push(CURVE_TO, p1x, p1y, p2x, p2y, x, y);
+ },
+ _arcToBezier: Path.prototype.onArc,
+ onArc: function onArc(sx, sy, ex, ey, cx, cy, rx, ry, sa, ea, ccw, rotation) {
+ if (rx !== ry || rotation) {
+ return this._arcToBezier(sx, sy, ex, ey, cx, cy, rx, ry, sa, ea, ccw, rotation);
+ }
+
+ this.path.push(ARC, cx, cy, rx, sa, ea, ccw ? 0 : 1);
+ },
+ onClose: function onClose() {
+ this.path.push(CLOSE);
+ },
+ toJSON: function toJSON() {
+ return this.path;
+ }
+ });
+ module.exports = SerializablePath;
+},199,[200,201],"node_modules\\react-native\\Libraries\\ART\\ARTSerializablePath.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ module.exports = function (mixins) {
+ var proto = {};
+
+ for (var i = 0, l = arguments.length; i < l; i++) {
+ var mixin = arguments[i];
+ if (typeof mixin == 'function') mixin = mixin.prototype;
+
+ for (var key in mixin) {
+ proto[key] = mixin[key];
+ }
+ }
+
+ if (!proto.initialize) proto.initialize = function () {};
+
+ proto.constructor = function (a, b, c, d, e, f, g, h) {
+ return new proto.initialize(a, b, c, d, e, f, g, h);
+ };
+
+ proto.constructor.prototype = proto.initialize.prototype = proto;
+ return proto.constructor;
+ };
+},200,[],"node_modules\\art\\core\\class.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var Class = _$$_REQUIRE(_dependencyMap[0], "./class");
+
+ module.exports = Class({
+ initialize: function initialize(path) {
+ this.reset().push(path);
+ },
+ push: function push() {
+ var p = Array.prototype.join.call(arguments, ' ').match(/[a-df-z]|[\-+]?(?:[\d\.]e[\-+]?|[^\s\-+,a-z])+/ig);
+ if (!p) return this;
+ var last,
+ cmd = p[0],
+ i = 1;
+
+ while (cmd) {
+ switch (cmd) {
+ case 'm':
+ this.move(p[i++], p[i++]);
+ break;
+
+ case 'l':
+ this.line(p[i++], p[i++]);
+ break;
+
+ case 'c':
+ this.curve(p[i++], p[i++], p[i++], p[i++], p[i++], p[i++]);
+ break;
+
+ case 's':
+ this.curve(p[i++], p[i++], null, null, p[i++], p[i++]);
+ break;
+
+ case 'q':
+ this.curve(p[i++], p[i++], p[i++], p[i++]);
+ break;
+
+ case 't':
+ this.curve(p[i++], p[i++]);
+ break;
+
+ case 'a':
+ this.arc(p[i + 5], p[i + 6], p[i], p[i + 1], p[i + 3], !+p[i + 4], p[i + 2]);
+ i += 7;
+ break;
+
+ case 'h':
+ this.line(p[i++], 0);
+ break;
+
+ case 'v':
+ this.line(0, p[i++]);
+ break;
+
+ case 'M':
+ this.moveTo(p[i++], p[i++]);
+ break;
+
+ case 'L':
+ this.lineTo(p[i++], p[i++]);
+ break;
+
+ case 'C':
+ this.curveTo(p[i++], p[i++], p[i++], p[i++], p[i++], p[i++]);
+ break;
+
+ case 'S':
+ this.curveTo(p[i++], p[i++], null, null, p[i++], p[i++]);
+ break;
+
+ case 'Q':
+ this.curveTo(p[i++], p[i++], p[i++], p[i++]);
+ break;
+
+ case 'T':
+ this.curveTo(p[i++], p[i++]);
+ break;
+
+ case 'A':
+ this.arcTo(p[i + 5], p[i + 6], p[i], p[i + 1], p[i + 3], !+p[i + 4], p[i + 2]);
+ i += 7;
+ break;
+
+ case 'H':
+ this.lineTo(p[i++], this.penY);
+ break;
+
+ case 'V':
+ this.lineTo(this.penX, p[i++]);
+ break;
+
+ case 'Z':
+ case 'z':
+ this.close();
+ break;
+
+ default:
+ cmd = last;
+ i--;
+ continue;
+ }
+
+ last = cmd;
+ if (last == 'm') last = 'l';else if (last == 'M') last = 'L';
+ cmd = p[i++];
+ }
+
+ return this;
+ },
+ reset: function reset() {
+ this.penX = this.penY = 0;
+ this.penDownX = this.penDownY = null;
+ this._pivotX = this._pivotY = 0;
+ this.onReset();
+ return this;
+ },
+ move: function move(x, y) {
+ this.onMove(this.penX, this.penY, this._pivotX = this.penX += +x, this._pivotY = this.penY += +y);
+ return this;
+ },
+ moveTo: function moveTo(x, y) {
+ this.onMove(this.penX, this.penY, this._pivotX = this.penX = +x, this._pivotY = this.penY = +y);
+ return this;
+ },
+ line: function line(x, y) {
+ return this.lineTo(this.penX + +x, this.penY + +y);
+ },
+ lineTo: function lineTo(x, y) {
+ if (this.penDownX == null) {
+ this.penDownX = this.penX;
+ this.penDownY = this.penY;
+ }
+
+ this.onLine(this.penX, this.penY, this._pivotX = this.penX = +x, this._pivotY = this.penY = +y);
+ return this;
+ },
+ curve: function curve(c1x, c1y, c2x, c2y, ex, ey) {
+ var x = this.penX,
+ y = this.penY;
+ return this.curveTo(x + +c1x, y + +c1y, c2x == null ? null : x + +c2x, c2y == null ? null : y + +c2y, ex == null ? null : x + +ex, ey == null ? null : y + +ey);
+ },
+ curveTo: function curveTo(c1x, c1y, c2x, c2y, ex, ey) {
+ var x = this.penX,
+ y = this.penY;
+
+ if (c2x == null) {
+ c2x = +c1x;
+ c2y = +c1y;
+ c1x = x * 2 - (this._pivotX || 0);
+ c1y = y * 2 - (this._pivotY || 0);
+ }
+
+ if (ex == null) {
+ this._pivotX = +c1x;
+ this._pivotY = +c1y;
+ ex = +c2x;
+ ey = +c2y;
+ c2x = (ex + +c1x * 2) / 3;
+ c2y = (ey + +c1y * 2) / 3;
+ c1x = (x + +c1x * 2) / 3;
+ c1y = (y + +c1y * 2) / 3;
+ } else {
+ this._pivotX = +c2x;
+ this._pivotY = +c2y;
+ }
+
+ if (this.penDownX == null) {
+ this.penDownX = x;
+ this.penDownY = y;
+ }
+
+ this.onBezierCurve(x, y, +c1x, +c1y, +c2x, +c2y, this.penX = +ex, this.penY = +ey);
+ return this;
+ },
+ arc: function arc(x, y, rx, ry, outer, counterClockwise, rotation) {
+ return this.arcTo(this.penX + +x, this.penY + +y, rx, ry, outer, counterClockwise, rotation);
+ },
+ arcTo: function arcTo(x, y, rx, ry, outer, counterClockwise, rotation) {
+ ry = Math.abs(+ry || +rx || +y - this.penY);
+ rx = Math.abs(+rx || +x - this.penX);
+ if (!rx || !ry || x == this.penX && y == this.penY) return this.lineTo(x, y);
+ var tX = this.penX,
+ tY = this.penY,
+ clockwise = !+counterClockwise,
+ large = !!+outer;
+ var rad = rotation ? rotation * Math.PI / 180 : 0,
+ cos = Math.cos(rad),
+ sin = Math.sin(rad);
+ x -= tX;
+ y -= tY;
+ var cx = cos * x / 2 + sin * y / 2,
+ cy = -sin * x / 2 + cos * y / 2,
+ rxry = rx * rx * ry * ry,
+ rycx = ry * ry * cx * cx,
+ rxcy = rx * rx * cy * cy,
+ a = rxry - rxcy - rycx;
+
+ if (a < 0) {
+ a = Math.sqrt(1 - a / rxry);
+ rx *= a;
+ ry *= a;
+ cx = x / 2;
+ cy = y / 2;
+ } else {
+ a = Math.sqrt(a / (rxcy + rycx));
+ if (large == clockwise) a = -a;
+ var cxd = -a * cy * rx / ry,
+ cyd = a * cx * ry / rx;
+ cx = cos * cxd - sin * cyd + x / 2;
+ cy = sin * cxd + cos * cyd + y / 2;
+ }
+
+ var xx = cos / rx,
+ yx = sin / rx,
+ xy = -sin / ry,
+ yy = cos / ry;
+ var sa = Math.atan2(xy * -cx + yy * -cy, xx * -cx + yx * -cy),
+ ea = Math.atan2(xy * (x - cx) + yy * (y - cy), xx * (x - cx) + yx * (y - cy));
+ cx += tX;
+ cy += tY;
+ x += tX;
+ y += tY;
+
+ if (this.penDownX == null) {
+ this.penDownX = this.penX;
+ this.penDownY = this.penY;
+ }
+
+ this.onArc(tX, tY, this._pivotX = this.penX = x, this._pivotY = this.penY = y, cx, cy, rx, ry, sa, ea, !clockwise, rotation);
+ return this;
+ },
+ counterArc: function counterArc(x, y, rx, ry, outer) {
+ return this.arc(x, y, rx, ry, outer, true);
+ },
+ counterArcTo: function counterArcTo(x, y, rx, ry, outer) {
+ return this.arcTo(x, y, rx, ry, outer, true);
+ },
+ close: function close() {
+ if (this.penDownX != null) {
+ this.onClose(this.penX, this.penY, this.penX = this.penDownX, this.penY = this.penDownY);
+ this.penDownX = null;
+ }
+
+ return this;
+ },
+ onReset: function onReset() {},
+ onMove: function onMove(sx, sy, ex, ey) {},
+ onLine: function onLine(sx, sy, ex, ey) {
+ this.onBezierCurve(sx, sy, sx, sy, ex, ey, ex, ey);
+ },
+ onBezierCurve: function onBezierCurve(sx, sy, c1x, c1y, c2x, c2y, ex, ey) {
+ var gx = ex - sx,
+ gy = ey - sy,
+ g = gx * gx + gy * gy,
+ v1,
+ v2,
+ cx,
+ cy,
+ u;
+ cx = c1x - sx;
+ cy = c1y - sy;
+ u = cx * gx + cy * gy;
+
+ if (u > g) {
+ cx -= gx;
+ cy -= gy;
+ } else if (u > 0 && g != 0) {
+ cx -= u / g * gx;
+ cy -= u / g * gy;
+ }
+
+ v1 = cx * cx + cy * cy;
+ cx = c2x - sx;
+ cy = c2y - sy;
+ u = cx * gx + cy * gy;
+
+ if (u > g) {
+ cx -= gx;
+ cy -= gy;
+ } else if (u > 0 && g != 0) {
+ cx -= u / g * gx;
+ cy -= u / g * gy;
+ }
+
+ v2 = cx * cx + cy * cy;
+
+ if (v1 < 0.01 && v2 < 0.01) {
+ this.onLine(sx, sy, ex, ey);
+ return;
+ }
+
+ if (isNaN(v1) || isNaN(v2)) {
+ throw new Error('Bad input');
+ }
+
+ var s1x = (c1x + c2x) * 0.5,
+ s1y = (c1y + c2y) * 0.5,
+ l1x = (c1x + sx) * 0.5,
+ l1y = (c1y + sy) * 0.5,
+ l2x = (l1x + s1x) * 0.5,
+ l2y = (l1y + s1y) * 0.5,
+ r2x = (ex + c2x) * 0.5,
+ r2y = (ey + c2y) * 0.5,
+ r1x = (r2x + s1x) * 0.5,
+ r1y = (r2y + s1y) * 0.5,
+ l2r1x = (l2x + r1x) * 0.5,
+ l2r1y = (l2y + r1y) * 0.5;
+ this.onBezierCurve(sx, sy, l1x, l1y, l2x, l2y, l2r1x, l2r1y);
+ this.onBezierCurve(l2r1x, l2r1y, r1x, r1y, r2x, r2y, ex, ey);
+ },
+ onArc: function onArc(sx, sy, ex, ey, cx, cy, rx, ry, sa, ea, ccw, rotation) {
+ var rad = rotation ? rotation * Math.PI / 180 : 0,
+ cos = Math.cos(rad),
+ sin = Math.sin(rad),
+ xx = cos * rx,
+ yx = -sin * ry,
+ xy = sin * rx,
+ yy = cos * ry;
+ var arc = ea - sa;
+ if (arc < 0 && !ccw) arc += Math.PI * 2;else if (arc > 0 && ccw) arc -= Math.PI * 2;
+ var n = Math.ceil(Math.abs(arc / (Math.PI / 2))),
+ step = arc / n,
+ k = 4 / 3 * Math.tan(step / 4);
+ var x = Math.cos(sa),
+ y = Math.sin(sa);
+
+ for (var i = 0; i < n; i++) {
+ var cp1x = x - k * y,
+ cp1y = y + k * x;
+ sa += step;
+ x = Math.cos(sa);
+ y = Math.sin(sa);
+ var cp2x = x + k * y,
+ cp2y = y - k * x;
+ this.onBezierCurve(sx, sy, cx + xx * cp1x + yx * cp1y, cy + xy * cp1x + yy * cp1y, cx + xx * cp2x + yx * cp2y, cy + xy * cp2x + yy * cp2y, sx = cx + xx * x + yx * y, sy = cy + xy * x + yy * y);
+ }
+ },
+ onClose: function onClose(sx, sy, ex, ey) {
+ this.onLine(sx, sy, ex, ey);
+ }
+ });
+},201,[200],"node_modules\\art\\core\\path.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var Class = _$$_REQUIRE(_dependencyMap[0], "./class");
+
+ function Transform(xx, yx, xy, yy, x, y) {
+ if (xx && typeof xx == 'object') {
+ yx = xx.yx;
+ yy = xx.yy;
+ y = xx.y;
+ xy = xx.xy;
+ x = xx.x;
+ xx = xx.xx;
+ }
+
+ this.xx = xx == null ? 1 : xx;
+ this.yx = yx || 0;
+ this.xy = xy || 0;
+ this.yy = yy == null ? 1 : yy;
+ this.x = (x == null ? this.x : x) || 0;
+ this.y = (y == null ? this.y : y) || 0;
+
+ this._transform();
+
+ return this;
+ }
+
+ ;
+ module.exports = Class({
+ initialize: Transform,
+ _transform: function _transform() {},
+ xx: 1,
+ yx: 0,
+ x: 0,
+ xy: 0,
+ yy: 1,
+ y: 0,
+ transform: function transform(xx, yx, xy, yy, x, y) {
+ var m = this;
+
+ if (xx && typeof xx == 'object') {
+ yx = xx.yx;
+ yy = xx.yy;
+ y = xx.y;
+ xy = xx.xy;
+ x = xx.x;
+ xx = xx.xx;
+ }
+
+ if (!x) x = 0;
+ if (!y) y = 0;
+ return this.transformTo(m.xx * xx + m.xy * yx, m.yx * xx + m.yy * yx, m.xx * xy + m.xy * yy, m.yx * xy + m.yy * yy, m.xx * x + m.xy * y + m.x, m.yx * x + m.yy * y + m.y);
+ },
+ transformTo: Transform,
+ translate: function translate(x, y) {
+ return this.transform(1, 0, 0, 1, x, y);
+ },
+ move: function move(x, y) {
+ this.x += x || 0;
+ this.y += y || 0;
+
+ this._transform();
+
+ return this;
+ },
+ scale: function scale(x, y) {
+ if (y == null) y = x;
+ return this.transform(x, 0, 0, y, 0, 0);
+ },
+ rotate: function rotate(deg, x, y) {
+ if (x == null || y == null) {
+ x = (this.left || 0) + (this.width || 0) / 2;
+ y = (this.top || 0) + (this.height || 0) / 2;
+ }
+
+ var rad = deg * Math.PI / 180,
+ sin = Math.sin(rad),
+ cos = Math.cos(rad);
+ this.transform(1, 0, 0, 1, x, y);
+ var m = this;
+ return this.transformTo(cos * m.xx - sin * m.yx, sin * m.xx + cos * m.yx, cos * m.xy - sin * m.yy, sin * m.xy + cos * m.yy, m.x, m.y).transform(1, 0, 0, 1, -x, -y);
+ },
+ moveTo: function moveTo(x, y) {
+ var m = this;
+ return this.transformTo(m.xx, m.yx, m.xy, m.yy, x, y);
+ },
+ rotateTo: function rotateTo(deg, x, y) {
+ var m = this;
+ var flip = m.yx / m.xx > m.yy / m.xy ? -1 : 1;
+ if (m.xx < 0 ? m.xy >= 0 : m.xy < 0) flip = -flip;
+ return this.rotate(deg - Math.atan2(flip * m.yx, flip * m.xx) * 180 / Math.PI, x, y);
+ },
+ scaleTo: function scaleTo(x, y) {
+ var m = this;
+ var h = Math.sqrt(m.xx * m.xx + m.yx * m.yx);
+ m.xx /= h;
+ m.yx /= h;
+ h = Math.sqrt(m.yy * m.yy + m.xy * m.xy);
+ m.yy /= h;
+ m.xy /= h;
+ return this.scale(x, y);
+ },
+ resizeTo: function resizeTo(width, height) {
+ var w = this.width,
+ h = this.height;
+ if (!w || !h) return this;
+ return this.scaleTo(width / w, height / h);
+ },
+ inversePoint: function inversePoint(x, y) {
+ var a = this.xx,
+ b = this.yx,
+ c = this.xy,
+ d = this.yy,
+ e = this.x,
+ f = this.y;
+ var det = b * c - a * d;
+ if (det == 0) return null;
+ return {
+ x: (d * (e - x) + c * (y - f)) / det,
+ y: (a * (f - y) + b * (x - e)) / det
+ };
+ },
+ point: function point(x, y) {
+ var m = this;
+ return {
+ x: m.xx * x + m.xy * y + m.x,
+ y: m.yx * x + m.yy * y + m.y
+ };
+ }
+ });
+},202,[200],"node_modules\\art\\core\\transform.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var ReactNativeStyleAttributes = _$$_REQUIRE(_dependencyMap[1], "ReactNativeStyleAttributes");
+
+ var ReactNativeViewAttributes = {};
+ ReactNativeViewAttributes.UIView = {
+ pointerEvents: true,
+ accessible: true,
+ accessibilityActions: true,
+ accessibilityLabel: true,
+ accessibilityHint: true,
+ accessibilityComponentType: true,
+ accessibilityLiveRegion: true,
+ accessibilityRole: true,
+ accessibilityStates: true,
+ accessibilityTraits: true,
+ acceptsKeyboardFocus: true,
+ enableFocusRing: true,
+ importantForAccessibility: true,
+ nativeID: true,
+ testID: true,
+ tabIndex: true,
+ renderToHardwareTextureAndroid: true,
+ shouldRasterizeIOS: true,
+ onLayout: true,
+ onAccessibilityAction: true,
+ onAccessibilityTap: true,
+ onMagicTap: true,
+ onAccessibilityEscape: true,
+ collapsable: true,
+ needsOffscreenAlphaCompositing: true,
+ onMouseEnter: true,
+ onMouseLeave: true,
+ onDragEnter: true,
+ onDragLeave: true,
+ onDrop: true,
+ draggedTypes: true,
+ style: ReactNativeStyleAttributes
+ };
+ ReactNativeViewAttributes.RCTView = _objectSpread({}, ReactNativeViewAttributes.UIView, {
+ removeClippedSubviews: true
+ });
+ module.exports = ReactNativeViewAttributes;
+},203,[32,57],"node_modules\\react-native\\Libraries\\Components\\View\\ReactNativeViewAttributes.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ "use strict";
+
+ var mergeInto = _$$_REQUIRE(_dependencyMap[0], "mergeInto");
+
+ var merge = function merge(one, two) {
+ var result = {};
+ mergeInto(result, one);
+ mergeInto(result, two);
+ return result;
+ };
+
+ module.exports = merge;
+},204,[205],"node_modules\\react-native\\Libraries\\vendor\\core\\merge.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ "use strict";
+
+ var mergeHelpers = _$$_REQUIRE(_dependencyMap[0], "mergeHelpers");
+
+ var checkMergeObjectArg = mergeHelpers.checkMergeObjectArg;
+ var checkMergeIntoObjectArg = mergeHelpers.checkMergeIntoObjectArg;
+
+ function mergeInto(one, two) {
+ checkMergeIntoObjectArg(one);
+
+ if (two != null) {
+ checkMergeObjectArg(two);
+
+ for (var key in two) {
+ if (!Object.prototype.hasOwnProperty.call(two, key)) {
+ continue;
+ }
+
+ one[key] = two[key];
+ }
+ }
+ }
+
+ module.exports = mergeInto;
+},205,[206],"node_modules\\react-native\\Libraries\\vendor\\core\\mergeInto.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var invariant = _$$_REQUIRE(_dependencyMap[0], "invariant");
+
+ var MAX_MERGE_DEPTH = 36;
+
+ var isTerminal = function isTerminal(o) {
+ return typeof o !== 'object' || o instanceof Date || o === null;
+ };
+
+ var mergeHelpers = {
+ MAX_MERGE_DEPTH: MAX_MERGE_DEPTH,
+ isTerminal: isTerminal,
+ normalizeMergeArg: function normalizeMergeArg(arg) {
+ return arg === undefined || arg === null ? {} : arg;
+ },
+ checkMergeArrayArgs: function checkMergeArrayArgs(one, two) {
+ invariant(Array.isArray(one) && Array.isArray(two), 'Tried to merge arrays, instead got %s and %s.', one, two);
+ },
+ checkMergeObjectArgs: function checkMergeObjectArgs(one, two) {
+ mergeHelpers.checkMergeObjectArg(one);
+ mergeHelpers.checkMergeObjectArg(two);
+ },
+ checkMergeObjectArg: function checkMergeObjectArg(arg) {
+ invariant(!isTerminal(arg) && !Array.isArray(arg), 'Tried to merge an object, instead got %s.', arg);
+ },
+ checkMergeIntoObjectArg: function checkMergeIntoObjectArg(arg) {
+ invariant((!isTerminal(arg) || typeof arg === 'function') && !Array.isArray(arg), 'Tried to merge into an object, instead got %s.', arg);
+ },
+ checkMergeLevel: function checkMergeLevel(level) {
+ invariant(level < MAX_MERGE_DEPTH, 'Maximum deep merge depth exceeded. You may be attempting to merge ' + 'circular structures in an unsupported way.');
+ },
+ checkArrayStrategy: function checkArrayStrategy(strategy) {
+ invariant(strategy === undefined || strategy in mergeHelpers.ArrayStrategies, 'You must provide an array strategy to deep merge functions to ' + 'instruct the deep merge how to resolve merging two arrays.');
+ },
+ ArrayStrategies: {
+ Clobber: 'Clobber',
+ Concat: 'Concat',
+ IndexByIndex: 'IndexByIndex'
+ }
+ };
+ module.exports = mergeHelpers;
+},206,[19],"node_modules\\react-native\\Libraries\\vendor\\core\\mergeHelpers.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Components\\Button.js";
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var Platform = _$$_REQUIRE(_dependencyMap[6], "Platform");
+
+ var React = _$$_REQUIRE(_dependencyMap[7], "React");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[8], "StyleSheet");
+
+ var Text = _$$_REQUIRE(_dependencyMap[9], "Text");
+
+ var TouchableHighlight = _$$_REQUIRE(_dependencyMap[10], "TouchableHighlight");
+
+ var TouchableNativeFeedback = _$$_REQUIRE(_dependencyMap[11], "TouchableNativeFeedback");
+
+ var TouchableOpacity = _$$_REQUIRE(_dependencyMap[12], "TouchableOpacity");
+
+ var View = _$$_REQUIRE(_dependencyMap[13], "View");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[14], "invariant");
+
+ var Button = function (_React$Component) {
+ _inherits(Button, _React$Component);
+
+ function Button() {
+ _classCallCheck(this, Button);
+
+ return _possibleConstructorReturn(this, _getPrototypeOf(Button).apply(this, arguments));
+ }
+
+ _createClass(Button, [{
+ key: "render",
+ value: function render() {
+ var _this$props = this.props,
+ accessibilityLabel = _this$props.accessibilityLabel,
+ accessibilityHint = _this$props.accessibilityHint,
+ 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' || Platform.OS === 'macos') {
+ textStyles.push({
+ color: color
+ });
+ } else {
+ buttonStyles.push({
+ backgroundColor: color
+ });
+ }
+ }
+
+ var accessibilityStates = [];
+
+ if (disabled) {
+ buttonStyles.push(styles.buttonDisabled);
+ textStyles.push(styles.textDisabled);
+ accessibilityStates.push('disabled');
+ }
+
+ invariant(typeof title === 'string', 'The title prop of a Button must be a string');
+ var formattedTitle = Platform.OS === 'android' ? title.toUpperCase() : title;
+ var Touchable = Platform.OS === 'android' ? TouchableNativeFeedback : Platform.OS === 'uwp' || Platform.OS === 'windesktop' ? TouchableHighlight : TouchableOpacity;
+ return React.createElement(Touchable, {
+ accessibilityLabel: accessibilityLabel,
+ accessibilityHint: accessibilityHint,
+ accessibilityRole: "button",
+ accessibilityStates: accessibilityStates,
+ hasTVPreferredFocus: hasTVPreferredFocus,
+ testID: testID,
+ disabled: disabled,
+ onPress: onPress,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 137
+ }
+ }, React.createElement(View, {
+ style: buttonStyles,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 146
+ }
+ }, React.createElement(Text, {
+ style: textStyles,
+ disabled: disabled,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 147
+ }
+ }, formattedTitle)));
+ }
+ }]);
+
+ return Button;
+ }(React.Component);
+
+ var styles = StyleSheet.create({
+ button: Platform.select({
+ ios: {},
+ android: {
+ elevation: 4,
+ backgroundColor: '#2196F3',
+ borderRadius: 2
+ },
+ macos: {},
+ uwp: {
+ backgroundColor: '#2196F3',
+ borderRadius: 2
+ },
+ windesktop: {}
+ }),
+ text: _objectSpread({
+ textAlign: 'center',
+ padding: 8
+ }, Platform.select({
+ ios: {
+ color: '#007AFF',
+ fontSize: 18
+ },
+ android: {
+ color: 'white',
+ fontWeight: '500'
+ },
+ macos: {
+ color: '#007AFF',
+ fontSize: 18
+ },
+ uwp: {
+ color: 'white',
+ fontWeight: '500'
+ },
+ windesktop: {}
+ })),
+ buttonDisabled: Platform.select({
+ ios: {},
+ android: {
+ elevation: 0,
+ backgroundColor: '#dfdfdf'
+ },
+ macos: {},
+ uwp: {
+ backgroundColor: '#dfdfdf'
+ },
+ windesktop: {}
+ }),
+ textDisabled: Platform.select({
+ ios: {
+ color: '#cdcdcd'
+ },
+ macos: {
+ color: '#cdcdcd'
+ },
+ android: {
+ color: '#a1a1a1'
+ },
+ uwp: {
+ color: '#a1a1a1'
+ },
+ windesktop: {
+ color: '#a1a1a1'
+ }
+ })
+ });
+ module.exports = Button;
+},207,[32,3,4,5,8,9,35,52,53,208,221,235,236,81,19],"node_modules\\react-native\\Libraries\\Components\\Button.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _assertThisInitialized = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/assertThisInitialized");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits");
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/defineProperty");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Text\\Text.js";
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var DeprecatedTextPropTypes = _$$_REQUIRE(_dependencyMap[8], "DeprecatedTextPropTypes");
+
+ var React = _$$_REQUIRE(_dependencyMap[9], "React");
+
+ var ReactNativeViewAttributes = _$$_REQUIRE(_dependencyMap[10], "ReactNativeViewAttributes");
+
+ var TextAncestor = _$$_REQUIRE(_dependencyMap[11], "TextAncestor");
+
+ var Touchable = _$$_REQUIRE(_dependencyMap[12], "Touchable");
+
+ var UIManager = _$$_REQUIRE(_dependencyMap[13], "UIManager");
+
+ var createReactNativeComponentClass = _$$_REQUIRE(_dependencyMap[14], "createReactNativeComponentClass");
+
+ var nullthrows = _$$_REQUIRE(_dependencyMap[15], "nullthrows");
+
+ var processColor = _$$_REQUIRE(_dependencyMap[16], "processColor");
+
+ var PRESS_RECT_OFFSET = {
+ top: 20,
+ left: 20,
+ right: 20,
+ bottom: 30
+ };
+ var viewConfig = {
+ validAttributes: _objectSpread({}, ReactNativeViewAttributes.UIView, {
+ isHighlighted: true,
+ numberOfLines: true,
+ ellipsizeMode: true,
+ allowFontScaling: true,
+ maxFontSizeMultiplier: true,
+ disabled: true,
+ selectable: true,
+ selectionColor: true,
+ adjustsFontSizeToFit: true,
+ minimumFontScale: true,
+ textBreakStrategy: true,
+ onTextLayout: true
+ }),
+ directEventTypes: {
+ topTextLayout: {
+ registrationName: 'onTextLayout'
+ }
+ },
+ uiViewClassName: 'RCTText'
+ };
+
+ var TouchableText = function (_React$Component) {
+ _inherits(TouchableText, _React$Component);
+
+ function TouchableText() {
+ var _getPrototypeOf2;
+
+ var _this;
+
+ _classCallCheck(this, TouchableText);
+
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(TouchableText)).call.apply(_getPrototypeOf2, [this].concat(args)));
+ _this.state = _objectSpread({}, Touchable.Mixin.touchableGetInitialState(), {
+ isHighlighted: false,
+ createResponderHandlers: _this._createResponseHandlers.bind(_assertThisInitialized(_this)),
+ responseHandlers: null
+ });
+ return _this;
+ }
+
+ _createClass(TouchableText, [{
+ key: "render",
+ value: function render() {
+ var props = this.props;
+
+ if (isTouchable(props)) {
+ props = _objectSpread({}, props, {}, this.state.responseHandlers, {
+ isHighlighted: this.state.isHighlighted
+ });
+ }
+
+ if (props.selectionColor != null) {
+ props = _objectSpread({}, props, {
+ selectionColor: processColor(props.selectionColor)
+ });
+ }
+
+ if (__DEV__) {
+ if (Touchable.TOUCH_TARGET_DEBUG && props.onPress != null) {
+ props = _objectSpread({}, props, {
+ style: [props.style, {
+ color: 'magenta'
+ }]
+ });
+ }
+ }
+
+ return React.createElement(TextAncestor.Consumer, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 148
+ }
+ }, function (hasTextAncestor) {
+ return hasTextAncestor ? React.createElement(RCTVirtualText, _extends({}, props, {
+ ref: props.forwardedRef,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 151
+ }
+ })) : React.createElement(TextAncestor.Provider, {
+ value: true,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 153
+ }
+ }, React.createElement(RCTText, _extends({}, props, {
+ ref: props.forwardedRef,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 154
+ }
+ })));
+ });
+ }
+ }, {
+ key: "_createResponseHandlers",
+ value: function _createResponseHandlers() {
+ var _this2 = this;
+
+ return {
+ onStartShouldSetResponder: function onStartShouldSetResponder() {
+ var onStartShouldSetResponder = _this2.props.onStartShouldSetResponder;
+ var shouldSetResponder = (onStartShouldSetResponder == null ? false : onStartShouldSetResponder()) || isTouchable(_this2.props);
+
+ if (shouldSetResponder) {
+ _this2._attachTouchHandlers();
+ }
+
+ return shouldSetResponder;
+ },
+ onResponderGrant: function onResponderGrant(event, dispatchID) {
+ nullthrows(_this2.touchableHandleResponderGrant)(event, dispatchID);
+
+ if (_this2.props.onResponderGrant != null) {
+ _this2.props.onResponderGrant.call(_this2, event, dispatchID);
+ }
+ },
+ onResponderMove: function onResponderMove(event) {
+ nullthrows(_this2.touchableHandleResponderMove)(event);
+
+ if (_this2.props.onResponderMove != null) {
+ _this2.props.onResponderMove.call(_this2, event);
+ }
+ },
+ onResponderRelease: function onResponderRelease(event) {
+ nullthrows(_this2.touchableHandleResponderRelease)(event);
+
+ if (_this2.props.onResponderRelease != null) {
+ _this2.props.onResponderRelease.call(_this2, event);
+ }
+ },
+ onResponderTerminate: function onResponderTerminate(event) {
+ nullthrows(_this2.touchableHandleResponderTerminate)(event);
+
+ if (_this2.props.onResponderTerminate != null) {
+ _this2.props.onResponderTerminate.call(_this2, event);
+ }
+ },
+ onResponderTerminationRequest: function onResponderTerminationRequest() {
+ var onResponderTerminationRequest = _this2.props.onResponderTerminationRequest;
+
+ if (!nullthrows(_this2.touchableHandleResponderTerminationRequest)()) {
+ return false;
+ }
+
+ if (onResponderTerminationRequest == null) {
+ return true;
+ }
+
+ return onResponderTerminationRequest();
+ }
+ };
+ }
+ }, {
+ key: "_attachTouchHandlers",
+ value: function _attachTouchHandlers() {
+ var _this3 = this;
+
+ if (this.touchableGetPressRectOffset != null) {
+ return;
+ }
+
+ for (var key in Touchable.Mixin) {
+ if (typeof Touchable.Mixin[key] === 'function') {
+ this[key] = Touchable.Mixin[key].bind(this);
+ }
+ }
+
+ this.touchableHandleActivePressIn = function () {
+ if (!_this3.props.suppressHighlighting && isTouchable(_this3.props)) {
+ _this3.setState({
+ isHighlighted: true
+ });
+ }
+ };
+
+ this.touchableHandleActivePressOut = function () {
+ if (!_this3.props.suppressHighlighting && isTouchable(_this3.props)) {
+ _this3.setState({
+ isHighlighted: false
+ });
+ }
+ };
+
+ this.touchableHandlePress = function (event) {
+ if (_this3.props.onPress != null) {
+ _this3.props.onPress(event);
+ }
+ };
+
+ this.touchableHandleLongPress = function (event) {
+ if (_this3.props.onLongPress != null) {
+ _this3.props.onLongPress(event);
+ }
+ };
+
+ this.touchableGetPressRectOffset = function () {
+ return _this3.props.pressRetentionOffset == null ? PRESS_RECT_OFFSET : _this3.props.pressRetentionOffset;
+ };
+ }
+ }], [{
+ key: "getDerivedStateFromProps",
+ value: function getDerivedStateFromProps(nextProps, prevState) {
+ return prevState.responseHandlers == null && isTouchable(nextProps) ? {
+ responseHandlers: prevState.createResponderHandlers()
+ } : null;
+ }
+ }]);
+
+ return TouchableText;
+ }(React.Component);
+
+ TouchableText.defaultProps = {
+ accessible: true,
+ allowFontScaling: true,
+ ellipsizeMode: 'tail'
+ };
+ TouchableText.viewConfig = viewConfig;
+
+ var isTouchable = function isTouchable(props) {
+ return props.onPress != null || props.onLongPress != null || props.onStartShouldSetResponder != null;
+ };
+
+ var RCTText = createReactNativeComponentClass(viewConfig.uiViewClassName, function () {
+ return viewConfig;
+ });
+ var RCTVirtualText = UIManager.getViewManagerConfig('RCTVirtualText') == null ? RCTText : createReactNativeComponentClass('RCTVirtualText', function () {
+ return {
+ validAttributes: _objectSpread({}, ReactNativeViewAttributes.UIView, {
+ isHighlighted: true,
+ maxFontSizeMultiplier: true
+ }),
+ uiViewClassName: 'RCTVirtualText'
+ };
+ });
+
+ var Text = function Text(props, forwardedRef) {
+ return React.createElement(TouchableText, _extends({}, props, {
+ forwardedRef: forwardedRef,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 278
+ }
+ }));
+ };
+
+ var TextToExport = React.forwardRef(Text);
+ TextToExport.displayName = 'Text';
+ TextToExport.propTypes = DeprecatedTextPropTypes;
+ module.exports = TextToExport;
+},208,[14,3,4,5,8,7,9,32,209,52,203,82,213,71,185,220,75],"node_modules\\react-native\\Libraries\\Text\\Text.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var DeprecatedColorPropType = _$$_REQUIRE(_dependencyMap[0], "DeprecatedColorPropType");
+
+ var DeprecatedEdgeInsetsPropType = _$$_REQUIRE(_dependencyMap[1], "DeprecatedEdgeInsetsPropType");
+
+ var DeprecatedStyleSheetPropType = _$$_REQUIRE(_dependencyMap[2], "DeprecatedStyleSheetPropType");
+
+ var PropTypes = _$$_REQUIRE(_dependencyMap[3], "prop-types");
+
+ var TextStylePropTypes = _$$_REQUIRE(_dependencyMap[4], "TextStylePropTypes");
+
+ var stylePropType = DeprecatedStyleSheetPropType(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: DeprecatedEdgeInsetsPropType,
+ selectable: PropTypes.bool,
+ selectionColor: DeprecatedColorPropType,
+ suppressHighlighting: PropTypes.bool,
+ style: stylePropType,
+ testID: PropTypes.string,
+ nativeID: PropTypes.string,
+ allowFontScaling: PropTypes.bool,
+ maxFontSizeMultiplier: PropTypes.number,
+ accessible: PropTypes.bool,
+ adjustsFontSizeToFit: PropTypes.bool,
+ minimumFontScale: PropTypes.number,
+ disabled: PropTypes.bool
+ };
+},209,[59,210,211,62,73],"node_modules\\react-native\\Libraries\\DeprecatedPropTypes\\DeprecatedTextPropTypes.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var PropTypes = _$$_REQUIRE(_dependencyMap[0], "prop-types");
+
+ var DeprecatedEdgeInsetsPropType = PropTypes.shape({
+ top: PropTypes.number,
+ left: PropTypes.number,
+ bottom: PropTypes.number,
+ right: PropTypes.number
+ });
+ module.exports = DeprecatedEdgeInsetsPropType;
+},210,[62],"node_modules\\react-native\\Libraries\\DeprecatedPropTypes\\DeprecatedEdgeInsetsPropType.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var deprecatedCreateStrictShapeTypeChecker = _$$_REQUIRE(_dependencyMap[0], "deprecatedCreateStrictShapeTypeChecker");
+
+ var flattenStyle = _$$_REQUIRE(_dependencyMap[1], "flattenStyle");
+
+ function DeprecatedStyleSheetPropType(shape) {
+ var shapePropType = deprecatedCreateStrictShapeTypeChecker(shape);
+ return function (props, propName, componentName, location) {
+ var newProps = props;
+
+ if (props[propName]) {
+ newProps = {};
+ newProps[propName] = flattenStyle(props[propName]);
+ }
+
+ for (var _len = arguments.length, rest = new Array(_len > 4 ? _len - 4 : 0), _key = 4; _key < _len; _key++) {
+ rest[_key - 4] = arguments[_key];
+ }
+
+ return shapePropType.apply(void 0, [newProps, propName, componentName, location].concat(rest));
+ };
+ }
+
+ module.exports = DeprecatedStyleSheetPropType;
+},211,[212,80],"node_modules\\react-native\\Libraries\\DeprecatedPropTypes\\DeprecatedStyleSheetPropType.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var invariant = _$$_REQUIRE(_dependencyMap[0], "invariant");
+
+ var merge = _$$_REQUIRE(_dependencyMap[1], "merge");
+
+ function deprecatedCreateStrictShapeTypeChecker(shapeTypes) {
+ function checkType(isRequired, props, propName, componentName, location) {
+ if (!props[propName]) {
+ if (isRequired) {
+ invariant(false, "Required object `" + propName + "` was not specified in " + ("`" + componentName + "`."));
+ }
+
+ return;
+ }
+
+ var propValue = props[propName];
+ var propType = typeof propValue;
+ var locationName = location || '(unknown)';
+
+ if (propType !== 'object') {
+ invariant(false, "Invalid " + locationName + " `" + propName + "` of type `" + propType + "` " + ("supplied to `" + componentName + "`, expected `object`."));
+ }
+
+ var allKeys = merge(props[propName], shapeTypes);
+
+ for (var _len = arguments.length, rest = new Array(_len > 5 ? _len - 5 : 0), _key = 5; _key < _len; _key++) {
+ rest[_key - 5] = arguments[_key];
+ }
+
+ for (var _key2 in allKeys) {
+ var checker = shapeTypes[_key2];
+
+ if (!checker) {
+ invariant(false, "Invalid props." + propName + " key `" + _key2 + "` supplied to `" + componentName + "`." + '\nBad object: ' + JSON.stringify(props[propName], null, ' ') + '\nValid keys: ' + JSON.stringify(Object.keys(shapeTypes), null, ' '));
+ }
+
+ var error = checker.apply(void 0, [propValue, _key2, componentName, location].concat(rest));
+
+ if (error) {
+ invariant(false, error.message + '\nBad object: ' + JSON.stringify(props[propName], null, ' '));
+ }
+ }
+ }
+
+ function chainedCheckType(props, propName, componentName, location) {
+ for (var _len2 = arguments.length, rest = new Array(_len2 > 4 ? _len2 - 4 : 0), _key3 = 4; _key3 < _len2; _key3++) {
+ rest[_key3 - 4] = arguments[_key3];
+ }
+
+ return checkType.apply(void 0, [false, props, propName, componentName, location].concat(rest));
+ }
+
+ chainedCheckType.isRequired = checkType.bind(null, true);
+ return chainedCheckType;
+ }
+
+ module.exports = deprecatedCreateStrictShapeTypeChecker;
+},212,[19,204],"node_modules\\react-native\\Libraries\\DeprecatedPropTypes\\deprecatedCreateStrictShapeTypeChecker.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _objectWithoutProperties = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/objectWithoutProperties");
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/defineProperty");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Components\\Touchable\\Touchable.js";
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var BoundingDimensions = _$$_REQUIRE(_dependencyMap[2], "BoundingDimensions");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[3], "Platform");
+
+ var Position = _$$_REQUIRE(_dependencyMap[4], "Position");
+
+ var React = _$$_REQUIRE(_dependencyMap[5], "React");
+
+ var ReactNative = _$$_REQUIRE(_dependencyMap[6], "ReactNative");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[7], "StyleSheet");
+
+ var TVEventHandler = _$$_REQUIRE(_dependencyMap[8], "TVEventHandler");
+
+ var UIManager = _$$_REQUIRE(_dependencyMap[9], "UIManager");
+
+ var View = _$$_REQUIRE(_dependencyMap[10], "View");
+
+ var keyMirror = _$$_REQUIRE(_dependencyMap[11], "fbjs/lib/keyMirror");
+
+ var normalizeColor = _$$_REQUIRE(_dependencyMap[12], "normalizeColor");
+
+ var extractSingleTouch = function extractSingleTouch(nativeEvent) {
+ var touches = nativeEvent.touches;
+ var changedTouches = nativeEvent.changedTouches;
+ var hasTouches = touches && touches.length > 0;
+ var hasChangedTouches = changedTouches && changedTouches.length > 0;
+ return !hasTouches && hasChangedTouches ? changedTouches[0] : hasTouches ? touches[0] : nativeEvent;
+ };
+
+ var States = keyMirror({
+ NOT_RESPONDER: null,
+ RESPONDER_INACTIVE_PRESS_IN: null,
+ RESPONDER_INACTIVE_PRESS_OUT: null,
+ RESPONDER_ACTIVE_PRESS_IN: null,
+ RESPONDER_ACTIVE_PRESS_OUT: null,
+ RESPONDER_ACTIVE_LONG_PRESS_IN: null,
+ RESPONDER_ACTIVE_LONG_PRESS_OUT: null,
+ ERROR: null
+ });
+ var baseStatesConditions = {
+ NOT_RESPONDER: false,
+ RESPONDER_INACTIVE_PRESS_IN: false,
+ RESPONDER_INACTIVE_PRESS_OUT: false,
+ RESPONDER_ACTIVE_PRESS_IN: false,
+ RESPONDER_ACTIVE_PRESS_OUT: false,
+ RESPONDER_ACTIVE_LONG_PRESS_IN: false,
+ RESPONDER_ACTIVE_LONG_PRESS_OUT: false,
+ ERROR: false
+ };
+
+ var IsActive = _objectSpread({}, baseStatesConditions, {
+ RESPONDER_ACTIVE_PRESS_OUT: true,
+ RESPONDER_ACTIVE_PRESS_IN: true
+ });
+
+ var IsPressingIn = _objectSpread({}, baseStatesConditions, {
+ RESPONDER_INACTIVE_PRESS_IN: true,
+ RESPONDER_ACTIVE_PRESS_IN: true,
+ RESPONDER_ACTIVE_LONG_PRESS_IN: true
+ });
+
+ var IsLongPressingIn = _objectSpread({}, baseStatesConditions, {
+ RESPONDER_ACTIVE_LONG_PRESS_IN: true
+ });
+
+ var Signals = keyMirror({
+ DELAY: null,
+ RESPONDER_GRANT: null,
+ RESPONDER_RELEASE: null,
+ RESPONDER_TERMINATED: null,
+ ENTER_PRESS_RECT: null,
+ LEAVE_PRESS_RECT: null,
+ LONG_PRESS_DETECTED: null
+ });
+ var Transitions = {
+ NOT_RESPONDER: {
+ DELAY: States.ERROR,
+ RESPONDER_GRANT: States.RESPONDER_INACTIVE_PRESS_IN,
+ RESPONDER_RELEASE: States.ERROR,
+ RESPONDER_TERMINATED: States.ERROR,
+ ENTER_PRESS_RECT: States.ERROR,
+ LEAVE_PRESS_RECT: States.ERROR,
+ LONG_PRESS_DETECTED: States.ERROR
+ },
+ RESPONDER_INACTIVE_PRESS_IN: {
+ DELAY: States.RESPONDER_ACTIVE_PRESS_IN,
+ RESPONDER_GRANT: States.ERROR,
+ RESPONDER_RELEASE: States.NOT_RESPONDER,
+ RESPONDER_TERMINATED: States.NOT_RESPONDER,
+ ENTER_PRESS_RECT: States.RESPONDER_INACTIVE_PRESS_IN,
+ LEAVE_PRESS_RECT: States.RESPONDER_INACTIVE_PRESS_OUT,
+ LONG_PRESS_DETECTED: States.ERROR
+ },
+ RESPONDER_INACTIVE_PRESS_OUT: {
+ DELAY: States.RESPONDER_ACTIVE_PRESS_OUT,
+ RESPONDER_GRANT: States.ERROR,
+ RESPONDER_RELEASE: States.NOT_RESPONDER,
+ RESPONDER_TERMINATED: States.NOT_RESPONDER,
+ ENTER_PRESS_RECT: States.RESPONDER_INACTIVE_PRESS_IN,
+ LEAVE_PRESS_RECT: States.RESPONDER_INACTIVE_PRESS_OUT,
+ LONG_PRESS_DETECTED: States.ERROR
+ },
+ RESPONDER_ACTIVE_PRESS_IN: {
+ DELAY: States.ERROR,
+ RESPONDER_GRANT: States.ERROR,
+ RESPONDER_RELEASE: States.NOT_RESPONDER,
+ RESPONDER_TERMINATED: States.NOT_RESPONDER,
+ ENTER_PRESS_RECT: States.RESPONDER_ACTIVE_PRESS_IN,
+ LEAVE_PRESS_RECT: States.RESPONDER_ACTIVE_PRESS_OUT,
+ LONG_PRESS_DETECTED: States.RESPONDER_ACTIVE_LONG_PRESS_IN
+ },
+ RESPONDER_ACTIVE_PRESS_OUT: {
+ DELAY: States.ERROR,
+ RESPONDER_GRANT: States.ERROR,
+ RESPONDER_RELEASE: States.NOT_RESPONDER,
+ RESPONDER_TERMINATED: States.NOT_RESPONDER,
+ ENTER_PRESS_RECT: States.RESPONDER_ACTIVE_PRESS_IN,
+ LEAVE_PRESS_RECT: States.RESPONDER_ACTIVE_PRESS_OUT,
+ LONG_PRESS_DETECTED: States.ERROR
+ },
+ RESPONDER_ACTIVE_LONG_PRESS_IN: {
+ DELAY: States.ERROR,
+ RESPONDER_GRANT: States.ERROR,
+ RESPONDER_RELEASE: States.NOT_RESPONDER,
+ RESPONDER_TERMINATED: States.NOT_RESPONDER,
+ ENTER_PRESS_RECT: States.RESPONDER_ACTIVE_LONG_PRESS_IN,
+ LEAVE_PRESS_RECT: States.RESPONDER_ACTIVE_LONG_PRESS_OUT,
+ LONG_PRESS_DETECTED: States.RESPONDER_ACTIVE_LONG_PRESS_IN
+ },
+ RESPONDER_ACTIVE_LONG_PRESS_OUT: {
+ DELAY: States.ERROR,
+ RESPONDER_GRANT: States.ERROR,
+ RESPONDER_RELEASE: States.NOT_RESPONDER,
+ RESPONDER_TERMINATED: States.NOT_RESPONDER,
+ ENTER_PRESS_RECT: States.RESPONDER_ACTIVE_LONG_PRESS_IN,
+ LEAVE_PRESS_RECT: States.RESPONDER_ACTIVE_LONG_PRESS_OUT,
+ LONG_PRESS_DETECTED: States.ERROR
+ },
+ error: {
+ DELAY: States.NOT_RESPONDER,
+ RESPONDER_GRANT: States.RESPONDER_INACTIVE_PRESS_IN,
+ RESPONDER_RELEASE: States.NOT_RESPONDER,
+ RESPONDER_TERMINATED: States.NOT_RESPONDER,
+ ENTER_PRESS_RECT: States.NOT_RESPONDER,
+ LEAVE_PRESS_RECT: States.NOT_RESPONDER,
+ LONG_PRESS_DETECTED: States.NOT_RESPONDER
+ }
+ };
+ var HIGHLIGHT_DELAY_MS = 130;
+ var PRESS_EXPAND_PX = 20;
+ var LONG_PRESS_THRESHOLD = 500;
+ var LONG_PRESS_DELAY_MS = LONG_PRESS_THRESHOLD - HIGHLIGHT_DELAY_MS;
+ var LONG_PRESS_ALLOWED_MOVEMENT = 10;
+ var TouchableMixin = {
+ componentDidMount: function componentDidMount() {
+ if (!Platform.isTV) {
+ return;
+ }
+
+ this._tvEventHandler = new TVEventHandler();
+
+ this._tvEventHandler.enable(this, function (cmp, evt) {
+ var myTag = ReactNative.findNodeHandle(cmp);
+ evt.dispatchConfig = {};
+
+ if (myTag === evt.tag) {
+ if (evt.eventType === 'focus') {
+ cmp.touchableHandleFocus(evt);
+ } else if (evt.eventType === 'blur') {
+ cmp.touchableHandleBlur(evt);
+ } else if (evt.eventType === 'select') {
+ cmp.touchableHandlePress && !cmp.props.disabled && cmp.touchableHandlePress(evt);
+ }
+ }
+ });
+ },
+ componentWillUnmount: function componentWillUnmount() {
+ if (this._tvEventHandler) {
+ this._tvEventHandler.disable();
+
+ delete this._tvEventHandler;
+ }
+
+ this.touchableDelayTimeout && clearTimeout(this.touchableDelayTimeout);
+ this.longPressDelayTimeout && clearTimeout(this.longPressDelayTimeout);
+ this.pressOutDelayTimeout && clearTimeout(this.pressOutDelayTimeout);
+ },
+ touchableGetInitialState: function touchableGetInitialState() {
+ return {
+ touchable: {
+ touchState: undefined,
+ responderID: null
+ }
+ };
+ },
+ touchableHandleResponderTerminationRequest: function touchableHandleResponderTerminationRequest() {
+ return !this.props.rejectResponderTermination;
+ },
+ touchableHandleStartShouldSetResponder: function touchableHandleStartShouldSetResponder() {
+ return !this.props.disabled;
+ },
+ touchableLongPressCancelsPress: function touchableLongPressCancelsPress() {
+ return true;
+ },
+ touchableHandleResponderGrant: function touchableHandleResponderGrant(e) {
+ var dispatchID = e.currentTarget;
+ e.persist();
+ this.pressOutDelayTimeout && clearTimeout(this.pressOutDelayTimeout);
+ this.pressOutDelayTimeout = null;
+ this.state.touchable.touchState = States.NOT_RESPONDER;
+ this.state.touchable.responderID = dispatchID;
+
+ this._receiveSignal(Signals.RESPONDER_GRANT, e);
+
+ var delayMS = this.touchableGetHighlightDelayMS !== undefined ? Math.max(this.touchableGetHighlightDelayMS(), 0) : HIGHLIGHT_DELAY_MS;
+ delayMS = isNaN(delayMS) ? HIGHLIGHT_DELAY_MS : delayMS;
+
+ if (delayMS !== 0) {
+ this.touchableDelayTimeout = setTimeout(this._handleDelay.bind(this, e), delayMS);
+ } else {
+ this._handleDelay(e);
+ }
+
+ var longDelayMS = this.touchableGetLongPressDelayMS !== undefined ? Math.max(this.touchableGetLongPressDelayMS(), 10) : LONG_PRESS_DELAY_MS;
+ longDelayMS = isNaN(longDelayMS) ? LONG_PRESS_DELAY_MS : longDelayMS;
+ this.longPressDelayTimeout = setTimeout(this._handleLongDelay.bind(this, e), longDelayMS + delayMS);
+ },
+ touchableHandleResponderRelease: function touchableHandleResponderRelease(e) {
+ this._receiveSignal(Signals.RESPONDER_RELEASE, e);
+ },
+ touchableHandleResponderTerminate: function touchableHandleResponderTerminate(e) {
+ this._receiveSignal(Signals.RESPONDER_TERMINATED, e);
+ },
+ touchableHandleResponderMove: function touchableHandleResponderMove(e) {
+ if (!this.state.touchable.positionOnActivate) {
+ return;
+ }
+
+ var positionOnActivate = this.state.touchable.positionOnActivate;
+ var dimensionsOnActivate = this.state.touchable.dimensionsOnActivate;
+ var pressRectOffset = this.touchableGetPressRectOffset ? this.touchableGetPressRectOffset() : {
+ left: PRESS_EXPAND_PX,
+ right: PRESS_EXPAND_PX,
+ top: PRESS_EXPAND_PX,
+ bottom: PRESS_EXPAND_PX
+ };
+ var pressExpandLeft = pressRectOffset.left;
+ var pressExpandTop = pressRectOffset.top;
+ var pressExpandRight = pressRectOffset.right;
+ var pressExpandBottom = pressRectOffset.bottom;
+ var hitSlop = this.touchableGetHitSlop ? this.touchableGetHitSlop() : null;
+
+ if (hitSlop) {
+ pressExpandLeft += hitSlop.left || 0;
+ pressExpandTop += hitSlop.top || 0;
+ pressExpandRight += hitSlop.right || 0;
+ pressExpandBottom += hitSlop.bottom || 0;
+ }
+
+ var touch = extractSingleTouch(e.nativeEvent);
+ var pageX = touch && touch.pageX;
+ var pageY = touch && touch.pageY;
+
+ if (this.pressInLocation) {
+ var movedDistance = this._getDistanceBetweenPoints(pageX, pageY, this.pressInLocation.pageX, this.pressInLocation.pageY);
+
+ if (movedDistance > LONG_PRESS_ALLOWED_MOVEMENT) {
+ this._cancelLongPressDelayTimeout();
+ }
+ }
+
+ var isTouchWithinActive = pageX > positionOnActivate.left - pressExpandLeft && pageY > positionOnActivate.top - pressExpandTop && pageX < positionOnActivate.left + dimensionsOnActivate.width + pressExpandRight && pageY < positionOnActivate.top + dimensionsOnActivate.height + pressExpandBottom;
+
+ if (isTouchWithinActive) {
+ 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);
+ }
+ },
+ touchableHandleFocus: function touchableHandleFocus(e) {
+ this.props.onFocus && this.props.onFocus(e);
+ },
+ touchableHandleBlur: function touchableHandleBlur(e) {
+ this.props.onBlur && this.props.onBlur(e);
+ },
+ _remeasureMetricsOnActivation: function _remeasureMetricsOnActivation() {
+ var tag = this.state.touchable.responderID;
+
+ if (tag == null) {
+ return;
+ }
+
+ UIManager.measure(tag, this._handleQueryLayout);
+ },
+ _handleQueryLayout: function _handleQueryLayout(l, t, w, h, globalX, globalY) {
+ if (!l && !t && !w && !h && !globalX && !globalY) {
+ return;
+ }
+
+ this.state.touchable.positionOnActivate && Position.release(this.state.touchable.positionOnActivate);
+ this.state.touchable.dimensionsOnActivate && BoundingDimensions.release(this.state.touchable.dimensionsOnActivate);
+ this.state.touchable.positionOnActivate = Position.getPooled(globalX, globalY);
+ this.state.touchable.dimensionsOnActivate = BoundingDimensions.getPooled(w, h);
+ },
+ _handleDelay: function _handleDelay(e) {
+ this.touchableDelayTimeout = null;
+
+ this._receiveSignal(Signals.DELAY, e);
+ },
+ _handleLongDelay: function _handleLongDelay(e) {
+ this.longPressDelayTimeout = null;
+ var curState = this.state.touchable.touchState;
+
+ if (curState !== States.RESPONDER_ACTIVE_PRESS_IN && curState !== States.RESPONDER_ACTIVE_LONG_PRESS_IN) {
+ console.error('Attempted to transition from state `' + curState + '` to `' + States.RESPONDER_ACTIVE_LONG_PRESS_IN + '`, which is not supported. This is ' + 'most likely due to `Touchable.longPressDelayTimeout` not being cancelled.');
+ } else {
+ this._receiveSignal(Signals.LONG_PRESS_DETECTED, e);
+ }
+ },
+ _receiveSignal: function _receiveSignal(signal, e) {
+ var responderID = this.state.touchable.responderID;
+ var curState = this.state.touchable.touchState;
+ var nextState = Transitions[curState] && Transitions[curState][signal];
+
+ if (!responderID && signal === Signals.RESPONDER_RELEASE) {
+ return;
+ }
+
+ if (!nextState) {
+ throw new Error('Unrecognized signal `' + signal + '` or state `' + curState + '` for Touchable responder `' + responderID + '`');
+ }
+
+ if (nextState === States.ERROR) {
+ throw new Error('Touchable cannot transition from `' + curState + '` to `' + signal + '` for responder `' + responderID + '`');
+ }
+
+ if (curState !== nextState) {
+ this._performSideEffectsForTransition(curState, nextState, signal, e);
+
+ this.state.touchable.touchState = nextState;
+ }
+ },
+ _cancelLongPressDelayTimeout: function _cancelLongPressDelayTimeout() {
+ this.longPressDelayTimeout && clearTimeout(this.longPressDelayTimeout);
+ this.longPressDelayTimeout = null;
+ },
+ _isHighlight: function _isHighlight(state) {
+ return state === States.RESPONDER_ACTIVE_PRESS_IN || state === States.RESPONDER_ACTIVE_LONG_PRESS_IN;
+ },
+ _savePressInLocation: function _savePressInLocation(e) {
+ var touch = extractSingleTouch(e.nativeEvent);
+ var pageX = touch && touch.pageX;
+ var pageY = touch && touch.pageY;
+ var locationX = touch && touch.locationX;
+ var locationY = touch && touch.locationY;
+ this.pressInLocation = {
+ pageX: pageX,
+ pageY: pageY,
+ locationX: locationX,
+ locationY: locationY
+ };
+ },
+ _getDistanceBetweenPoints: function _getDistanceBetweenPoints(aX, aY, bX, bY) {
+ var deltaX = aX - bX;
+ var deltaY = aY - bY;
+ return Math.sqrt(deltaX * deltaX + deltaY * deltaY);
+ },
+ _performSideEffectsForTransition: function _performSideEffectsForTransition(curState, nextState, signal, e) {
+ var curIsHighlight = this._isHighlight(curState);
+
+ var newIsHighlight = this._isHighlight(nextState);
+
+ var isFinalSignal = signal === Signals.RESPONDER_TERMINATED || signal === Signals.RESPONDER_RELEASE;
+
+ if (isFinalSignal) {
+ this._cancelLongPressDelayTimeout();
+ }
+
+ var isInitialTransition = curState === States.NOT_RESPONDER && nextState === States.RESPONDER_INACTIVE_PRESS_IN;
+ var isActiveTransition = !IsActive[curState] && IsActive[nextState];
+
+ if (isInitialTransition || isActiveTransition) {
+ this._remeasureMetricsOnActivation();
+ }
+
+ if (IsPressingIn[curState] && signal === Signals.LONG_PRESS_DETECTED) {
+ this.touchableHandleLongPress && this.touchableHandleLongPress(e);
+ }
+
+ if (newIsHighlight && !curIsHighlight) {
+ this._startHighlight(e);
+ } else if (!newIsHighlight && curIsHighlight) {
+ this._endHighlight(e);
+ }
+
+ if (IsPressingIn[curState] && signal === Signals.RESPONDER_RELEASE) {
+ var hasLongPressHandler = !!this.props.onLongPress;
+ var pressIsLongButStillCallOnPress = IsLongPressingIn[curState] && (!hasLongPressHandler || !this.touchableLongPressCancelsPress());
+ var shouldInvokePress = !IsLongPressingIn[curState] || pressIsLongButStillCallOnPress;
+
+ if (shouldInvokePress && this.touchableHandlePress) {
+ if (!newIsHighlight && !curIsHighlight) {
+ this._startHighlight(e);
+
+ this._endHighlight(e);
+ }
+
+ if (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);
+ }
+ }
+ },
+ withoutDefaultFocusAndBlur: {}
+ };
+
+ var touchableHandleFocus = TouchableMixin.touchableHandleFocus,
+ touchableHandleBlur = TouchableMixin.touchableHandleBlur,
+ TouchableMixinWithoutDefaultFocusAndBlur = _objectWithoutProperties(TouchableMixin, ["touchableHandleFocus", "touchableHandleBlur"]);
+
+ TouchableMixin.withoutDefaultFocusAndBlur = TouchableMixinWithoutDefaultFocusAndBlur;
+ var Touchable = {
+ Mixin: TouchableMixin,
+ TOUCH_TARGET_DEBUG: false,
+ renderDebugView: function renderDebugView(_ref) {
+ var color = _ref.color,
+ hitSlop = _ref.hitSlop;
+
+ if (!Touchable.TOUCH_TARGET_DEBUG) {
+ return null;
+ }
+
+ if (!__DEV__) {
+ throw Error('Touchable.TOUCH_TARGET_DEBUG should not be enabled in prod!');
+ }
+
+ var debugHitSlopStyle = {};
+ hitSlop = hitSlop || {
+ top: 0,
+ bottom: 0,
+ left: 0,
+ right: 0
+ };
+
+ for (var key in hitSlop) {
+ debugHitSlopStyle[key] = -hitSlop[key];
+ }
+
+ var normalizedColor = normalizeColor(color);
+
+ if (typeof normalizedColor !== 'number') {
+ return null;
+ }
+
+ var hexColor = '#' + ('00000000' + normalizedColor.toString(16)).substr(-8);
+ return React.createElement(View, {
+ pointerEvents: "none",
+ style: [styles.debug, _objectSpread({
+ borderColor: hexColor.slice(0, -2) + '55',
+ backgroundColor: hexColor.slice(0, -2) + '0F'
+ }, debugHitSlopStyle)],
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 953
+ }
+ });
+ }
+ };
+ var styles = StyleSheet.create({
+ debug: {
+ position: 'absolute',
+ borderWidth: 1,
+ borderStyle: 'dashed'
+ }
+ });
+ module.exports = Touchable;
+},213,[33,32,214,35,216,52,84,53,217,71,81,218,60],"node_modules\\react-native\\Libraries\\Components\\Touchable\\Touchable.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var PooledClass = _$$_REQUIRE(_dependencyMap[0], "PooledClass");
+
+ var twoArgumentPooler = PooledClass.twoArgumentPooler;
+
+ function BoundingDimensions(width, height) {
+ this.width = width;
+ this.height = height;
+ }
+
+ BoundingDimensions.prototype.destructor = function () {
+ this.width = null;
+ this.height = null;
+ };
+
+ BoundingDimensions.getPooledFromElement = function (element) {
+ return BoundingDimensions.getPooled(element.offsetWidth, element.offsetHeight);
+ };
+
+ PooledClass.addPoolingTo(BoundingDimensions, twoArgumentPooler);
+ module.exports = BoundingDimensions;
+},214,[215],"node_modules\\react-native\\Libraries\\Components\\Touchable\\BoundingDimensions.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var invariant = _$$_REQUIRE(_dependencyMap[0], "invariant");
+
+ var oneArgumentPooler = function oneArgumentPooler(copyFieldsFrom) {
+ var Klass = this;
+
+ if (Klass.instancePool.length) {
+ var _instance = Klass.instancePool.pop();
+
+ Klass.call(_instance, copyFieldsFrom);
+ return _instance;
+ } else {
+ return new Klass(copyFieldsFrom);
+ }
+ };
+
+ var twoArgumentPooler = function twoArgumentPooler(a1, a2) {
+ var Klass = this;
+
+ if (Klass.instancePool.length) {
+ var _instance2 = Klass.instancePool.pop();
+
+ Klass.call(_instance2, a1, a2);
+ return _instance2;
+ } else {
+ return new Klass(a1, a2);
+ }
+ };
+
+ var threeArgumentPooler = function threeArgumentPooler(a1, a2, a3) {
+ var Klass = this;
+
+ if (Klass.instancePool.length) {
+ var _instance3 = Klass.instancePool.pop();
+
+ Klass.call(_instance3, a1, a2, a3);
+ return _instance3;
+ } else {
+ return new Klass(a1, a2, a3);
+ }
+ };
+
+ var fourArgumentPooler = function fourArgumentPooler(a1, a2, a3, a4) {
+ var Klass = this;
+
+ if (Klass.instancePool.length) {
+ var _instance4 = Klass.instancePool.pop();
+
+ Klass.call(_instance4, a1, a2, a3, a4);
+ return _instance4;
+ } else {
+ return new Klass(a1, a2, a3, a4);
+ }
+ };
+
+ var standardReleaser = function standardReleaser(instance) {
+ var Klass = this;
+ invariant(instance instanceof Klass, 'Trying to release an instance into a pool of a different type.');
+ instance.destructor();
+
+ if (Klass.instancePool.length < Klass.poolSize) {
+ Klass.instancePool.push(instance);
+ }
+ };
+
+ var DEFAULT_POOL_SIZE = 10;
+ var DEFAULT_POOLER = oneArgumentPooler;
+
+ var addPoolingTo = function addPoolingTo(CopyConstructor, pooler) {
+ var NewKlass = CopyConstructor;
+ NewKlass.instancePool = [];
+ NewKlass.getPooled = pooler || DEFAULT_POOLER;
+
+ if (!NewKlass.poolSize) {
+ NewKlass.poolSize = DEFAULT_POOL_SIZE;
+ }
+
+ NewKlass.release = standardReleaser;
+ return NewKlass;
+ };
+
+ var PooledClass = {
+ addPoolingTo: addPoolingTo,
+ oneArgumentPooler: oneArgumentPooler,
+ twoArgumentPooler: twoArgumentPooler,
+ threeArgumentPooler: threeArgumentPooler,
+ fourArgumentPooler: fourArgumentPooler
+ };
+ module.exports = PooledClass;
+},215,[19],"node_modules\\react-native\\Libraries\\Components\\Touchable\\PooledClass.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var PooledClass = _$$_REQUIRE(_dependencyMap[0], "PooledClass");
+
+ var twoArgumentPooler = PooledClass.twoArgumentPooler;
+
+ function Position(left, top) {
+ this.left = left;
+ this.top = top;
+ }
+
+ Position.prototype.destructor = function () {
+ this.left = null;
+ this.top = null;
+ };
+
+ PooledClass.addPoolingTo(Position, twoArgumentPooler);
+ module.exports = Position;
+},216,[215],"node_modules\\react-native\\Libraries\\Components\\Touchable\\Position.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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;
+},217,[35,36,131],"node_modules\\react-native\\Libraries\\Components\\AppleTV\\TVEventHandler.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var invariant = _$$_REQUIRE(_dependencyMap[0], "./invariant");
+
+ var keyMirror = function keyMirror(obj) {
+ var ret = {};
+ var key;
+ !(obj instanceof Object && !Array.isArray(obj)) ? process.env.NODE_ENV !== "production" ? invariant(false, 'keyMirror(...): Argument must be an object.') : invariant(false) : void 0;
+
+ for (key in obj) {
+ if (!obj.hasOwnProperty(key)) {
+ continue;
+ }
+
+ ret[key] = key;
+ }
+
+ return ret;
+ };
+
+ module.exports = keyMirror;
+},218,[219],"node_modules\\fbjs\\lib\\keyMirror.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var validateFormat = process.env.NODE_ENV !== "production" ? function (format) {} : function (format) {
+ if (format === undefined) {
+ throw new Error('invariant(...): Second argument must be a string.');
+ }
+ };
+
+ function invariant(condition, format) {
+ for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+ args[_key - 2] = arguments[_key];
+ }
+
+ validateFormat(format);
+
+ if (!condition) {
+ var error;
+
+ if (format === undefined) {
+ error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');
+ } else {
+ var argIndex = 0;
+ error = new Error(format.replace(/%s/g, function () {
+ return String(args[argIndex++]);
+ }));
+ error.name = 'Invariant Violation';
+ }
+
+ error.framesToPop = 1;
+ throw error;
+ }
+ }
+
+ module.exports = invariant;
+},219,[],"node_modules\\fbjs\\lib\\invariant.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ function nullthrows(x, message) {
+ if (x != null) {
+ return x;
+ }
+
+ var error = new Error(message !== undefined ? message : 'Got unexpected ' + x);
+ error.framesToPop = 1;
+ throw error;
+ }
+
+ module.exports = nullthrows;
+ module.exports.default = nullthrows;
+ Object.defineProperty(module.exports, '__esModule', {
+ value: true
+ });
+},220,[],"node_modules\\nullthrows\\nullthrows.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Components\\Touchable\\TouchableHighlight.js";
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var DeprecatedColorPropType = _$$_REQUIRE(_dependencyMap[1], "DeprecatedColorPropType");
+
+ var DeprecatedViewPropTypes = _$$_REQUIRE(_dependencyMap[2], "DeprecatedViewPropTypes");
+
+ var NativeMethodsMixin = _$$_REQUIRE(_dependencyMap[3], "NativeMethodsMixin");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[4], "Platform");
+
+ var PropTypes = _$$_REQUIRE(_dependencyMap[5], "prop-types");
+
+ var React = _$$_REQUIRE(_dependencyMap[6], "React");
+
+ var ReactNativeViewAttributes = _$$_REQUIRE(_dependencyMap[7], "ReactNativeViewAttributes");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[8], "StyleSheet");
+
+ var Touchable = _$$_REQUIRE(_dependencyMap[9], "Touchable");
+
+ var TouchableWithoutFeedback = _$$_REQUIRE(_dependencyMap[10], "TouchableWithoutFeedback");
+
+ var View = _$$_REQUIRE(_dependencyMap[11], "View");
+
+ var createReactClass = _$$_REQUIRE(_dependencyMap[12], "create-react-class");
+
+ var ensurePositiveDelayProps = _$$_REQUIRE(_dependencyMap[13], "ensurePositiveDelayProps");
+
+ var DEFAULT_PROPS = {
+ activeOpacity: 0.85,
+ delayPressOut: 100,
+ underlayColor: 'black'
+ };
+ var PRESS_RETENTION_OFFSET = {
+ top: 20,
+ left: 20,
+ right: 20,
+ bottom: 30
+ };
+ var TouchableHighlight = createReactClass({
+ displayName: 'TouchableHighlight',
+ propTypes: _objectSpread({}, TouchableWithoutFeedback.propTypes, {
+ activeOpacity: PropTypes.number,
+ underlayColor: DeprecatedColorPropType,
+ style: DeprecatedViewPropTypes.style,
+ onShowUnderlay: PropTypes.func,
+ onHideUnderlay: PropTypes.func,
+ hasTVPreferredFocus: PropTypes.bool,
+ tvParallaxProperties: PropTypes.object,
+ testOnly_pressed: PropTypes.bool
+ }),
+ mixins: [NativeMethodsMixin, Touchable.Mixin.withoutDefaultFocusAndBlur],
+ getDefaultProps: function getDefaultProps() {
+ return DEFAULT_PROPS;
+ },
+ getInitialState: function getInitialState() {
+ this._isMounted = false;
+
+ if (this.props.testOnly_pressed) {
+ return _objectSpread({}, this.touchableGetInitialState(), {
+ extraChildStyle: {
+ opacity: this.props.activeOpacity
+ },
+ extraUnderlayStyle: {
+ backgroundColor: this.props.underlayColor
+ }
+ });
+ } else {
+ return _objectSpread({}, this.touchableGetInitialState(), {
+ extraChildStyle: null,
+ extraUnderlayStyle: null
+ });
+ }
+ },
+ componentDidMount: function componentDidMount() {
+ this._isMounted = true;
+ ensurePositiveDelayProps(this.props);
+ },
+ componentWillUnmount: function componentWillUnmount() {
+ this._isMounted = false;
+ clearTimeout(this._hideTimeout);
+ },
+ UNSAFE_componentWillReceiveProps: function UNSAFE_componentWillReceiveProps(nextProps) {
+ ensurePositiveDelayProps(nextProps);
+ },
+ viewConfig: {
+ uiViewClassName: 'RCTView',
+ validAttributes: ReactNativeViewAttributes.RCTView
+ },
+ touchableHandleActivePressIn: function touchableHandleActivePressIn(e) {
+ clearTimeout(this._hideTimeout);
+ this._hideTimeout = null;
+
+ this._showUnderlay();
+
+ this.props.onPressIn && this.props.onPressIn(e);
+ },
+ touchableHandleActivePressOut: function touchableHandleActivePressOut(e) {
+ if (!this._hideTimeout) {
+ this._hideUnderlay();
+ }
+
+ this.props.onPressOut && this.props.onPressOut(e);
+ },
+ touchableHandleFocus: function touchableHandleFocus(e) {
+ if (Platform.isTV) {
+ this._showUnderlay();
+ }
+
+ this.props.onFocus && this.props.onFocus(e);
+ },
+ touchableHandleBlur: function touchableHandleBlur(e) {
+ if (Platform.isTV) {
+ this._hideUnderlay();
+ }
+
+ this.props.onBlur && this.props.onBlur(e);
+ },
+ touchableHandlePress: function touchableHandlePress(e) {
+ clearTimeout(this._hideTimeout);
+
+ if (!Platform.isTV) {
+ this._showUnderlay();
+
+ this._hideTimeout = setTimeout(this._hideUnderlay, this.props.delayPressOut);
+ }
+
+ this.props.onPress && this.props.onPress(e);
+ },
+ touchableHandleLongPress: function touchableHandleLongPress(e) {
+ this.props.onLongPress && this.props.onLongPress(e);
+ },
+ touchableGetPressRectOffset: function touchableGetPressRectOffset() {
+ return this.props.pressRetentionOffset || PRESS_RETENTION_OFFSET;
+ },
+ touchableGetHitSlop: function touchableGetHitSlop() {
+ return this.props.hitSlop;
+ },
+ touchableGetHighlightDelayMS: function touchableGetHighlightDelayMS() {
+ return this.props.delayPressIn;
+ },
+ touchableGetLongPressDelayMS: function touchableGetLongPressDelayMS() {
+ return this.props.delayLongPress;
+ },
+ touchableGetPressOutDelayMS: function touchableGetPressOutDelayMS() {
+ return this.props.delayPressOut;
+ },
+ _showUnderlay: function _showUnderlay() {
+ if (!this._isMounted || !this._hasPressHandler()) {
+ return;
+ }
+
+ this.setState({
+ extraChildStyle: {
+ opacity: this.props.activeOpacity
+ },
+ extraUnderlayStyle: {
+ backgroundColor: this.props.underlayColor
+ }
+ });
+ this.props.onShowUnderlay && this.props.onShowUnderlay();
+ },
+ _hideUnderlay: function _hideUnderlay() {
+ clearTimeout(this._hideTimeout);
+ this._hideTimeout = null;
+
+ if (this.props.testOnly_pressed) {
+ return;
+ }
+
+ if (this._hasPressHandler()) {
+ this.setState({
+ extraChildStyle: null,
+ extraUnderlayStyle: null
+ });
+ this.props.onHideUnderlay && this.props.onHideUnderlay();
+ }
+ },
+ _hasPressHandler: function _hasPressHandler() {
+ return !!(this.props.onPress || this.props.onPressIn || this.props.onPressOut || this.props.onLongPress);
+ },
+ render: function render() {
+ var child = React.Children.only(this.props.children);
+ return React.createElement(View, {
+ accessible: this.props.accessible !== false,
+ accessibilityLabel: this.props.accessibilityLabel,
+ accessibilityHint: this.props.accessibilityHint,
+ accessibilityRole: this.props.accessibilityRole,
+ accessibilityStates: this.props.accessibilityStates,
+ onAccessibilityTap: this.props.onAccessibilityTap,
+ acceptsKeyboardFocus: (this.props.acceptsKeyboardFocus === undefined || this.props.acceptsKeyboardFocus) && !this.props.disabled,
+ enableFocusRing: (this.props.enableFocusRing === undefined || this.props.enableFocusRing) && !this.props.disabled,
+ tabIndex: this.props.tabIndex,
+ 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,
+ tooltip: this.props.tooltip,
+ clickable: this.props.clickable !== false && this.props.onPress !== undefined,
+ onClick: this.touchableHandlePress,
+ onMouseEnter: this.props.onMouseEnter,
+ onMouseLeave: this.props.onMouseLeave,
+ onDragEnter: this.props.onDragEnter,
+ onDragLeave: this.props.onDragLeave,
+ onDrop: this.props.onDrop,
+ draggedTypes: this.props.draggedTypes,
+ nativeID: this.props.nativeID,
+ testID: this.props.testID,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 397
+ }
+ }, React.cloneElement(child, {
+ style: StyleSheet.compose(child.props.style, this.state.extraChildStyle)
+ }), Touchable.renderDebugView({
+ color: 'green',
+ hitSlop: this.props.hitSlop
+ }));
+ }
+ });
+ module.exports = TouchableHighlight;
+},221,[32,59,222,225,35,62,52,203,53,213,226,81,227,233],"node_modules\\react-native\\Libraries\\Components\\Touchable\\TouchableHighlight.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var DeprecatedEdgeInsetsPropType = _$$_REQUIRE(_dependencyMap[1], "DeprecatedEdgeInsetsPropType");
+
+ var PlatformViewPropTypes = _$$_REQUIRE(_dependencyMap[2], "PlatformViewPropTypes");
+
+ var PropTypes = _$$_REQUIRE(_dependencyMap[3], "prop-types");
+
+ var DeprecatedStyleSheetPropType = _$$_REQUIRE(_dependencyMap[4], "DeprecatedStyleSheetPropType");
+
+ var DeprecatedViewStylePropTypes = _$$_REQUIRE(_dependencyMap[5], "DeprecatedViewStylePropTypes");
+
+ var _require = _$$_REQUIRE(_dependencyMap[6], "DeprecatedViewAccessibility"),
+ DeprecatedAccessibilityComponentTypes = _require.DeprecatedAccessibilityComponentTypes,
+ DeprecatedAccessibilityTraits = _require.DeprecatedAccessibilityTraits,
+ DeprecatedAccessibilityRoles = _require.DeprecatedAccessibilityRoles,
+ DeprecatedAccessibilityStates = _require.DeprecatedAccessibilityStates;
+
+ var stylePropType = DeprecatedStyleSheetPropType(DeprecatedViewStylePropTypes);
+ module.exports = _objectSpread({
+ accessible: PropTypes.bool,
+ accessibilityLabel: PropTypes.node,
+ accessibilityHint: PropTypes.string,
+ accessibilityActions: PropTypes.arrayOf(PropTypes.string),
+ accessibilityIgnoresInvertColors: PropTypes.bool,
+ accessibilityComponentType: PropTypes.oneOf(DeprecatedAccessibilityComponentTypes),
+ accessibilityRole: PropTypes.oneOf(DeprecatedAccessibilityRoles),
+ accessibilityStates: PropTypes.arrayOf(PropTypes.oneOf(DeprecatedAccessibilityStates)),
+ accessibilityLiveRegion: PropTypes.oneOf(['none', 'polite', 'assertive']),
+ importantForAccessibility: PropTypes.oneOf(['auto', 'yes', 'no', 'no-hide-descendants']),
+ accessibilityTraits: PropTypes.oneOfType([PropTypes.oneOf(DeprecatedAccessibilityTraits), PropTypes.arrayOf(PropTypes.oneOf(DeprecatedAccessibilityTraits))]),
+ accessibilityViewIsModal: PropTypes.bool,
+ accessibilityElementsHidden: PropTypes.bool,
+ onAccessibilityAction: PropTypes.func,
+ onAccessibilityTap: PropTypes.func,
+ onMagicTap: PropTypes.func,
+ testID: PropTypes.string,
+ nativeID: PropTypes.string,
+ onResponderGrant: PropTypes.func,
+ onResponderMove: PropTypes.func,
+ onResponderReject: PropTypes.func,
+ onResponderRelease: PropTypes.func,
+ onResponderTerminate: PropTypes.func,
+ onResponderTerminationRequest: PropTypes.func,
+ onStartShouldSetResponder: PropTypes.func,
+ onStartShouldSetResponderCapture: PropTypes.func,
+ onMoveShouldSetResponder: PropTypes.func,
+ onMoveShouldSetResponderCapture: PropTypes.func,
+ hitSlop: DeprecatedEdgeInsetsPropType,
+ onLayout: PropTypes.func,
+ pointerEvents: PropTypes.oneOf(['box-none', 'none', 'box-only', 'auto']),
+ style: stylePropType,
+ removeClippedSubviews: PropTypes.bool,
+ renderToHardwareTextureAndroid: PropTypes.bool,
+ shouldRasterizeIOS: PropTypes.bool,
+ collapsable: PropTypes.bool,
+ needsOffscreenAlphaCompositing: PropTypes.bool
+ }, PlatformViewPropTypes);
+},222,[32,210,223,62,211,74,224],"node_modules\\react-native\\Libraries\\DeprecatedPropTypes\\DeprecatedViewPropTypes.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ module.export = {};
+},223,[],"Libraries\\Components\\View\\PlatformViewPropTypes.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ module.exports = {
+ DeprecatedAccessibilityTraits: ['none', 'button', 'link', 'header', 'search', 'image', 'selected', 'plays', 'key', 'text', 'summary', 'disabled', 'frequentUpdates', 'startsMedia', 'adjustable', 'allowsDirectInteraction', 'pageTurn'],
+ DeprecatedAccessibilityComponentTypes: ['none', 'button', 'radiobutton_checked', 'radiobutton_unchecked'],
+ DeprecatedAccessibilityRoles: ['none', 'button', 'link', 'search', 'image', 'keyboardkey', 'text', 'adjustable', 'imagebutton', 'header', 'summary', 'alert', 'checkbox', 'combobox', 'menu', 'menubar', 'menuitem', 'progressbar', 'radio', 'radiogroup', 'scrollbar', 'spinbutton', 'switch', 'tab', 'tablist', 'timer', 'toolbar'],
+ DeprecatedAccessibilityStates: ['selected', 'disabled', 'checked', 'unchecked', 'busy', 'expanded', 'collapsed']
+ };
+},224,[],"node_modules\\react-native\\Libraries\\DeprecatedPropTypes\\DeprecatedViewAccessibility.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _require = _$$_REQUIRE(_dependencyMap[0], "ReactNative"),
+ __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = _require.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+ var NativeMethodsMixin = __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.NativeMethodsMixin;
+ module.exports = NativeMethodsMixin;
+},225,[84],"node_modules\\react-native\\Libraries\\Renderer\\shims\\NativeMethodsMixin.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var DeprecatedEdgeInsetsPropType = _$$_REQUIRE(_dependencyMap[0], "DeprecatedEdgeInsetsPropType");
+
+ var React = _$$_REQUIRE(_dependencyMap[1], "React");
+
+ var PropTypes = _$$_REQUIRE(_dependencyMap[2], "prop-types");
+
+ var Touchable = _$$_REQUIRE(_dependencyMap[3], "Touchable");
+
+ var View = _$$_REQUIRE(_dependencyMap[4], "View");
+
+ var createReactClass = _$$_REQUIRE(_dependencyMap[5], "create-react-class");
+
+ var ensurePositiveDelayProps = _$$_REQUIRE(_dependencyMap[6], "ensurePositiveDelayProps");
+
+ var _require = _$$_REQUIRE(_dependencyMap[7], "DeprecatedViewAccessibility"),
+ DeprecatedAccessibilityComponentTypes = _require.DeprecatedAccessibilityComponentTypes,
+ DeprecatedAccessibilityRoles = _require.DeprecatedAccessibilityRoles,
+ DeprecatedAccessibilityStates = _require.DeprecatedAccessibilityStates,
+ DeprecatedAccessibilityTraits = _require.DeprecatedAccessibilityTraits;
+
+ var _require2 = _$$_REQUIRE(_dependencyMap[8], "DraggedType"),
+ DraggedTypes = _require2.DraggedTypes;
+
+ var PRESS_RETENTION_OFFSET = {
+ top: 20,
+ left: 20,
+ right: 20,
+ bottom: 30
+ };
+ var TouchableWithoutFeedback = createReactClass({
+ displayName: 'TouchableWithoutFeedback',
+ mixins: [Touchable.Mixin],
+ propTypes: {
+ accessible: PropTypes.bool,
+ accessibilityLabel: PropTypes.node,
+ accessibilityHint: PropTypes.string,
+ accessibilityComponentType: PropTypes.oneOf(DeprecatedAccessibilityComponentTypes),
+ accessibilityRole: PropTypes.oneOf(DeprecatedAccessibilityRoles),
+ accessibilityStates: PropTypes.arrayOf(PropTypes.oneOf(DeprecatedAccessibilityStates)),
+ accessibilityTraits: PropTypes.oneOfType([PropTypes.oneOf(DeprecatedAccessibilityTraits), PropTypes.arrayOf(PropTypes.oneOf(DeprecatedAccessibilityTraits))]),
+ onAccessibilityTap: PropTypes.func,
+ tabIndex: PropTypes.number,
+ onFocus: PropTypes.func,
+ onBlur: PropTypes.func,
+ disabled: PropTypes.bool,
+ onMouseEnter: PropTypes.func,
+ onMouseLeave: PropTypes.func,
+ onDragEnter: PropTypes.func,
+ onDragLeave: PropTypes.func,
+ onDrop: PropTypes.func,
+ draggedTypes: PropTypes.oneOfType([PropTypes.oneOf(DraggedTypes), PropTypes.arrayOf(PropTypes.oneOf(DraggedTypes))]),
+ tooltip: PropTypes.string,
+ 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: DeprecatedEdgeInsetsPropType,
+ hitSlop: DeprecatedEdgeInsetsPropType
+ },
+ getInitialState: function getInitialState() {
+ return this.touchableGetInitialState();
+ },
+ componentDidMount: function componentDidMount() {
+ ensurePositiveDelayProps(this.props);
+ },
+ UNSAFE_componentWillReceiveProps: function UNSAFE_componentWillReceiveProps(nextProps) {
+ ensurePositiveDelayProps(nextProps);
+ },
+ touchableHandlePress: function touchableHandlePress(e) {
+ this.props.onPress && this.props.onPress(e);
+ },
+ touchableHandleActivePressIn: function touchableHandleActivePressIn(e) {
+ this.props.onPressIn && this.props.onPressIn(e);
+ },
+ touchableHandleActivePressOut: function touchableHandleActivePressOut(e) {
+ this.props.onPressOut && this.props.onPressOut(e);
+ },
+ touchableHandleLongPress: function touchableHandleLongPress(e) {
+ this.props.onLongPress && this.props.onLongPress(e);
+ },
+ touchableGetPressRectOffset: function touchableGetPressRectOffset() {
+ return this.props.pressRetentionOffset || PRESS_RETENTION_OFFSET;
+ },
+ touchableGetHitSlop: function touchableGetHitSlop() {
+ return this.props.hitSlop;
+ },
+ touchableGetHighlightDelayMS: function touchableGetHighlightDelayMS() {
+ return this.props.delayPressIn || 0;
+ },
+ touchableGetLongPressDelayMS: function touchableGetLongPressDelayMS() {
+ return this.props.delayLongPress === 0 ? 0 : this.props.delayLongPress || 500;
+ },
+ touchableGetPressOutDelayMS: function touchableGetPressOutDelayMS() {
+ return this.props.delayPressOut || 0;
+ },
+ render: function render() {
+ var child = React.Children.only(this.props.children);
+ var children = child.props.children;
+
+ if (Touchable.TOUCH_TARGET_DEBUG && child.type === View) {
+ children = React.Children.toArray(children);
+ children.push(Touchable.renderDebugView({
+ color: 'red',
+ hitSlop: this.props.hitSlop
+ }));
+ }
+
+ return React.cloneElement(child, {
+ accessible: this.props.accessible !== false,
+ accessibilityLabel: this.props.accessibilityLabel,
+ accessibilityHint: this.props.accessibilityHint,
+ accessibilityComponentType: this.props.accessibilityComponentType,
+ accessibilityRole: this.props.accessibilityRole,
+ accessibilityStates: this.props.accessibilityStates,
+ accessibilityTraits: this.props.accessibilityTraits,
+ onAccessibilityTap: this.props.onAccessibilityTap,
+ acceptsKeyboardFocus: (this.props.acceptsKeyboardFocus === undefined || this.props.acceptsKeyboardFocus) && !this.props.disabled,
+ enableFocusRing: this.props.enableFocusRing === true && !this.props.disabled,
+ tabIndex: this.props.tabIndex,
+ 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,
+ tooltip: this.props.tooltip,
+ clickable: this.props.clickable !== false && this.props.onPress !== undefined,
+ onClick: this.touchableHandlePress,
+ onMouseEnter: this.props.onMouseEnter,
+ onMouseLeave: this.props.onMouseLeave,
+ onDragEnter: this.props.onDragEnter,
+ onDragLeave: this.props.onDragLeave,
+ onDrop: this.props.onDrop,
+ draggedTypes: this.props.draggedTypes,
+ children: children
+ });
+ }
+ });
+ module.exports = TouchableWithoutFeedback;
+},226,[210,52,62,213,81,227,233,224,234],"node_modules\\react-native\\Libraries\\Components\\Touchable\\TouchableWithoutFeedback.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var React = _$$_REQUIRE(_dependencyMap[0], "react");
+
+ var factory = _$$_REQUIRE(_dependencyMap[1], "./factory");
+
+ if (typeof React === 'undefined') {
+ throw Error('create-react-class could not find the React object. If you are using script tags, ' + 'make sure that React is being loaded before create-react-class.');
+ }
+
+ var ReactNoopUpdateQueue = new React.Component().updater;
+ module.exports = factory(React.Component, React.isValidElement, ReactNoopUpdateQueue);
+},227,[11,228],"node_modules\\create-react-class\\index.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _assign = _$$_REQUIRE(_dependencyMap[0], "object-assign");
+
+ var emptyObject = _$$_REQUIRE(_dependencyMap[1], "fbjs/lib/emptyObject");
+
+ var _invariant = _$$_REQUIRE(_dependencyMap[2], "fbjs/lib/invariant");
+
+ if (process.env.NODE_ENV !== 'production') {
+ var warning = _$$_REQUIRE(_dependencyMap[3], "fbjs/lib/warning");
+ }
+
+ var MIXINS_KEY = 'mixins';
+
+ function identity(fn) {
+ return fn;
+ }
+
+ var ReactPropTypeLocationNames;
+
+ if (process.env.NODE_ENV !== 'production') {
+ ReactPropTypeLocationNames = {
+ prop: 'prop',
+ context: 'context',
+ childContext: 'child context'
+ };
+ } else {
+ ReactPropTypeLocationNames = {};
+ }
+
+ function factory(ReactComponent, isValidElement, ReactNoopUpdateQueue) {
+ var injectedMixins = [];
+ var ReactClassInterface = {
+ mixins: 'DEFINE_MANY',
+ statics: 'DEFINE_MANY',
+ propTypes: 'DEFINE_MANY',
+ contextTypes: 'DEFINE_MANY',
+ childContextTypes: 'DEFINE_MANY',
+ getDefaultProps: 'DEFINE_MANY_MERGED',
+ getInitialState: 'DEFINE_MANY_MERGED',
+ getChildContext: 'DEFINE_MANY_MERGED',
+ render: 'DEFINE_ONCE',
+ componentWillMount: 'DEFINE_MANY',
+ componentDidMount: 'DEFINE_MANY',
+ componentWillReceiveProps: 'DEFINE_MANY',
+ shouldComponentUpdate: 'DEFINE_ONCE',
+ componentWillUpdate: 'DEFINE_MANY',
+ componentDidUpdate: 'DEFINE_MANY',
+ componentWillUnmount: 'DEFINE_MANY',
+ UNSAFE_componentWillMount: 'DEFINE_MANY',
+ UNSAFE_componentWillReceiveProps: 'DEFINE_MANY',
+ UNSAFE_componentWillUpdate: 'DEFINE_MANY',
+ updateComponent: 'OVERRIDE_BASE'
+ };
+ var ReactClassStaticInterface = {
+ getDerivedStateFromProps: 'DEFINE_MANY_MERGED'
+ };
+ var RESERVED_SPEC_KEYS = {
+ displayName: function displayName(Constructor, _displayName) {
+ Constructor.displayName = _displayName;
+ },
+ mixins: function mixins(Constructor, _mixins) {
+ if (_mixins) {
+ for (var i = 0; i < _mixins.length; i++) {
+ mixSpecIntoComponent(Constructor, _mixins[i]);
+ }
+ }
+ },
+ childContextTypes: function childContextTypes(Constructor, _childContextTypes) {
+ if (process.env.NODE_ENV !== 'production') {
+ validateTypeDef(Constructor, _childContextTypes, 'childContext');
+ }
+
+ Constructor.childContextTypes = _assign({}, Constructor.childContextTypes, _childContextTypes);
+ },
+ contextTypes: function contextTypes(Constructor, _contextTypes) {
+ if (process.env.NODE_ENV !== 'production') {
+ validateTypeDef(Constructor, _contextTypes, 'context');
+ }
+
+ Constructor.contextTypes = _assign({}, Constructor.contextTypes, _contextTypes);
+ },
+ getDefaultProps: function getDefaultProps(Constructor, _getDefaultProps) {
+ if (Constructor.getDefaultProps) {
+ Constructor.getDefaultProps = createMergedResultFunction(Constructor.getDefaultProps, _getDefaultProps);
+ } else {
+ Constructor.getDefaultProps = _getDefaultProps;
+ }
+ },
+ propTypes: function propTypes(Constructor, _propTypes) {
+ if (process.env.NODE_ENV !== 'production') {
+ validateTypeDef(Constructor, _propTypes, 'prop');
+ }
+
+ Constructor.propTypes = _assign({}, Constructor.propTypes, _propTypes);
+ },
+ statics: function statics(Constructor, _statics) {
+ mixStaticSpecIntoComponent(Constructor, _statics);
+ },
+ autobind: function autobind() {}
+ };
+
+ function validateTypeDef(Constructor, typeDef, location) {
+ for (var propName in typeDef) {
+ if (typeDef.hasOwnProperty(propName)) {
+ if (process.env.NODE_ENV !== 'production') {
+ warning(typeof typeDef[propName] === 'function', '%s: %s type `%s` is invalid; it must be a function, usually from ' + 'React.PropTypes.', Constructor.displayName || 'ReactClass', ReactPropTypeLocationNames[location], propName);
+ }
+ }
+ }
+ }
+
+ function validateMethodOverride(isAlreadyDefined, name) {
+ var specPolicy = ReactClassInterface.hasOwnProperty(name) ? ReactClassInterface[name] : null;
+
+ if (ReactClassMixin.hasOwnProperty(name)) {
+ _invariant(specPolicy === 'OVERRIDE_BASE', 'ReactClassInterface: You are attempting to override ' + '`%s` from your class specification. Ensure that your method names ' + 'do not overlap with React methods.', name);
+ }
+
+ if (isAlreadyDefined) {
+ _invariant(specPolicy === 'DEFINE_MANY' || specPolicy === 'DEFINE_MANY_MERGED', 'ReactClassInterface: You are attempting to define ' + '`%s` on your component more than once. This conflict may be due ' + 'to a mixin.', name);
+ }
+ }
+
+ function mixSpecIntoComponent(Constructor, spec) {
+ if (!spec) {
+ if (process.env.NODE_ENV !== 'production') {
+ var typeofSpec = typeof spec;
+ var isMixinValid = typeofSpec === 'object' && spec !== null;
+
+ if (process.env.NODE_ENV !== 'production') {
+ warning(isMixinValid, "%s: You're attempting to include a mixin that is either null " + 'or not an object. Check the mixins included by the component, ' + 'as well as any mixins they include themselves. ' + 'Expected object but got %s.', Constructor.displayName || 'ReactClass', spec === null ? null : typeofSpec);
+ }
+ }
+
+ return;
+ }
+
+ _invariant(typeof spec !== 'function', "ReactClass: You're attempting to " + 'use a component class or function as a mixin. Instead, just use a ' + 'regular object.');
+
+ _invariant(!isValidElement(spec), "ReactClass: You're attempting to " + 'use a component as a mixin. Instead, just use a regular object.');
+
+ var proto = Constructor.prototype;
+ var autoBindPairs = proto.__reactAutoBindPairs;
+
+ if (spec.hasOwnProperty(MIXINS_KEY)) {
+ RESERVED_SPEC_KEYS.mixins(Constructor, spec.mixins);
+ }
+
+ for (var name in spec) {
+ if (!spec.hasOwnProperty(name)) {
+ continue;
+ }
+
+ if (name === MIXINS_KEY) {
+ continue;
+ }
+
+ var property = spec[name];
+ var isAlreadyDefined = proto.hasOwnProperty(name);
+ validateMethodOverride(isAlreadyDefined, name);
+
+ if (RESERVED_SPEC_KEYS.hasOwnProperty(name)) {
+ RESERVED_SPEC_KEYS[name](Constructor, property);
+ } else {
+ var isReactClassMethod = ReactClassInterface.hasOwnProperty(name);
+ var isFunction = typeof property === 'function';
+ var shouldAutoBind = isFunction && !isReactClassMethod && !isAlreadyDefined && spec.autobind !== false;
+
+ if (shouldAutoBind) {
+ autoBindPairs.push(name, property);
+ proto[name] = property;
+ } else {
+ if (isAlreadyDefined) {
+ var specPolicy = ReactClassInterface[name];
+
+ _invariant(isReactClassMethod && (specPolicy === 'DEFINE_MANY_MERGED' || specPolicy === 'DEFINE_MANY'), 'ReactClass: Unexpected spec policy %s for key %s ' + 'when mixing in component specs.', specPolicy, name);
+
+ if (specPolicy === 'DEFINE_MANY_MERGED') {
+ proto[name] = createMergedResultFunction(proto[name], property);
+ } else if (specPolicy === 'DEFINE_MANY') {
+ proto[name] = createChainedFunction(proto[name], property);
+ }
+ } else {
+ proto[name] = property;
+
+ if (process.env.NODE_ENV !== 'production') {
+ if (typeof property === 'function' && spec.displayName) {
+ proto[name].displayName = spec.displayName + '_' + name;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ function mixStaticSpecIntoComponent(Constructor, statics) {
+ if (!statics) {
+ return;
+ }
+
+ for (var name in statics) {
+ var property = statics[name];
+
+ if (!statics.hasOwnProperty(name)) {
+ continue;
+ }
+
+ var isReserved = name in RESERVED_SPEC_KEYS;
+
+ _invariant(!isReserved, 'ReactClass: You are attempting to define a reserved ' + 'property, `%s`, that shouldn\'t be on the "statics" key. Define it ' + 'as an instance property instead; it will still be accessible on the ' + 'constructor.', name);
+
+ var isAlreadyDefined = name in Constructor;
+
+ if (isAlreadyDefined) {
+ var specPolicy = ReactClassStaticInterface.hasOwnProperty(name) ? ReactClassStaticInterface[name] : null;
+
+ _invariant(specPolicy === 'DEFINE_MANY_MERGED', 'ReactClass: You are attempting to define ' + '`%s` on your component more than once. This conflict may be ' + 'due to a mixin.', name);
+
+ Constructor[name] = createMergedResultFunction(Constructor[name], property);
+ return;
+ }
+
+ Constructor[name] = property;
+ }
+ }
+
+ function mergeIntoWithNoDuplicateKeys(one, two) {
+ _invariant(one && two && typeof one === 'object' && typeof two === 'object', 'mergeIntoWithNoDuplicateKeys(): Cannot merge non-objects.');
+
+ for (var key in two) {
+ if (two.hasOwnProperty(key)) {
+ _invariant(one[key] === undefined, 'mergeIntoWithNoDuplicateKeys(): ' + 'Tried to merge two objects with the same key: `%s`. This conflict ' + 'may be due to a mixin; in particular, this may be caused by two ' + 'getInitialState() or getDefaultProps() methods returning objects ' + 'with clashing keys.', key);
+
+ one[key] = two[key];
+ }
+ }
+
+ return one;
+ }
+
+ function createMergedResultFunction(one, two) {
+ return function mergedResult() {
+ var a = one.apply(this, arguments);
+ var b = two.apply(this, arguments);
+
+ if (a == null) {
+ return b;
+ } else if (b == null) {
+ return a;
+ }
+
+ var c = {};
+ mergeIntoWithNoDuplicateKeys(c, a);
+ mergeIntoWithNoDuplicateKeys(c, b);
+ return c;
+ };
+ }
+
+ function createChainedFunction(one, two) {
+ return function chainedFunction() {
+ one.apply(this, arguments);
+ two.apply(this, arguments);
+ };
+ }
+
+ function bindAutoBindMethod(component, method) {
+ var boundMethod = method.bind(component);
+
+ if (process.env.NODE_ENV !== 'production') {
+ boundMethod.__reactBoundContext = component;
+ boundMethod.__reactBoundMethod = method;
+ boundMethod.__reactBoundArguments = null;
+ var componentName = component.constructor.displayName;
+ var _bind = boundMethod.bind;
+
+ boundMethod.bind = function (newThis) {
+ for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+ args[_key - 1] = arguments[_key];
+ }
+
+ if (newThis !== component && newThis !== null) {
+ if (process.env.NODE_ENV !== 'production') {
+ warning(false, 'bind(): React component methods may only be bound to the ' + 'component instance. See %s', componentName);
+ }
+ } else if (!args.length) {
+ if (process.env.NODE_ENV !== 'production') {
+ warning(false, 'bind(): You are binding a component method to the component. ' + 'React does this for you automatically in a high-performance ' + 'way, so you can safely remove this call. See %s', componentName);
+ }
+
+ return boundMethod;
+ }
+
+ var reboundMethod = _bind.apply(boundMethod, arguments);
+
+ reboundMethod.__reactBoundContext = component;
+ reboundMethod.__reactBoundMethod = method;
+ reboundMethod.__reactBoundArguments = args;
+ return reboundMethod;
+ };
+ }
+
+ return boundMethod;
+ }
+
+ function bindAutoBindMethods(component) {
+ var pairs = component.__reactAutoBindPairs;
+
+ for (var i = 0; i < pairs.length; i += 2) {
+ var autoBindKey = pairs[i];
+ var method = pairs[i + 1];
+ component[autoBindKey] = bindAutoBindMethod(component, method);
+ }
+ }
+
+ var IsMountedPreMixin = {
+ componentDidMount: function componentDidMount() {
+ this.__isMounted = true;
+ }
+ };
+ var IsMountedPostMixin = {
+ componentWillUnmount: function componentWillUnmount() {
+ this.__isMounted = false;
+ }
+ };
+ var ReactClassMixin = {
+ replaceState: function replaceState(newState, callback) {
+ this.updater.enqueueReplaceState(this, newState, callback);
+ },
+ isMounted: function isMounted() {
+ if (process.env.NODE_ENV !== 'production') {
+ warning(this.__didWarnIsMounted, '%s: isMounted is deprecated. Instead, make sure to clean up ' + 'subscriptions and pending requests in componentWillUnmount to ' + 'prevent memory leaks.', this.constructor && this.constructor.displayName || this.name || 'Component');
+ this.__didWarnIsMounted = true;
+ }
+
+ return !!this.__isMounted;
+ }
+ };
+
+ var ReactClassComponent = function ReactClassComponent() {};
+
+ _assign(ReactClassComponent.prototype, ReactComponent.prototype, ReactClassMixin);
+
+ function createClass(spec) {
+ var Constructor = identity(function (props, context, updater) {
+ if (process.env.NODE_ENV !== 'production') {
+ warning(this instanceof Constructor, 'Something is calling a React component directly. Use a factory or ' + 'JSX instead. See: https://fb.me/react-legacyfactory');
+ }
+
+ if (this.__reactAutoBindPairs.length) {
+ bindAutoBindMethods(this);
+ }
+
+ this.props = props;
+ this.context = context;
+ this.refs = emptyObject;
+ this.updater = updater || ReactNoopUpdateQueue;
+ this.state = null;
+ var initialState = this.getInitialState ? this.getInitialState() : null;
+
+ if (process.env.NODE_ENV !== 'production') {
+ if (initialState === undefined && this.getInitialState._isMockFunction) {
+ initialState = null;
+ }
+ }
+
+ _invariant(typeof initialState === 'object' && !Array.isArray(initialState), '%s.getInitialState(): must return an object or null', Constructor.displayName || 'ReactCompositeComponent');
+
+ this.state = initialState;
+ });
+ Constructor.prototype = new ReactClassComponent();
+ Constructor.prototype.constructor = Constructor;
+ Constructor.prototype.__reactAutoBindPairs = [];
+ injectedMixins.forEach(mixSpecIntoComponent.bind(null, Constructor));
+ mixSpecIntoComponent(Constructor, IsMountedPreMixin);
+ mixSpecIntoComponent(Constructor, spec);
+ mixSpecIntoComponent(Constructor, IsMountedPostMixin);
+
+ if (Constructor.getDefaultProps) {
+ Constructor.defaultProps = Constructor.getDefaultProps();
+ }
+
+ if (process.env.NODE_ENV !== 'production') {
+ if (Constructor.getDefaultProps) {
+ Constructor.getDefaultProps.isReactClassApproved = {};
+ }
+
+ if (Constructor.prototype.getInitialState) {
+ Constructor.prototype.getInitialState.isReactClassApproved = {};
+ }
+ }
+
+ _invariant(Constructor.prototype.render, 'createClass(...): Class specification must implement a `render` method.');
+
+ if (process.env.NODE_ENV !== 'production') {
+ warning(!Constructor.prototype.componentShouldUpdate, '%s has a method called ' + 'componentShouldUpdate(). Did you mean shouldComponentUpdate()? ' + 'The name is phrased as a question because the function is ' + 'expected to return a value.', spec.displayName || 'A component');
+ warning(!Constructor.prototype.componentWillRecieveProps, '%s has a method called ' + 'componentWillRecieveProps(). Did you mean componentWillReceiveProps()?', spec.displayName || 'A component');
+ warning(!Constructor.prototype.UNSAFE_componentWillRecieveProps, '%s has a method called UNSAFE_componentWillRecieveProps(). ' + 'Did you mean UNSAFE_componentWillReceiveProps()?', spec.displayName || 'A component');
+ }
+
+ for (var methodName in ReactClassInterface) {
+ if (!Constructor.prototype[methodName]) {
+ Constructor.prototype[methodName] = null;
+ }
+ }
+
+ return Constructor;
+ }
+
+ return createClass;
+ }
+
+ module.exports = factory;
+},228,[13,229,230,231],"node_modules\\create-react-class\\factory.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var emptyObject = {};
+
+ if (process.env.NODE_ENV !== 'production') {
+ Object.freeze(emptyObject);
+ }
+
+ module.exports = emptyObject;
+},229,[],"node_modules\\create-react-class\\node_modules\\fbjs\\lib\\emptyObject.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var validateFormat = function validateFormat(format) {};
+
+ if (process.env.NODE_ENV !== 'production') {
+ validateFormat = function validateFormat(format) {
+ if (format === undefined) {
+ throw new Error('invariant requires an error message argument');
+ }
+ };
+ }
+
+ function invariant(condition, format, a, b, c, d, e, f) {
+ validateFormat(format);
+
+ if (!condition) {
+ var error;
+
+ if (format === undefined) {
+ error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');
+ } else {
+ var args = [a, b, c, d, e, f];
+ var argIndex = 0;
+ error = new Error(format.replace(/%s/g, function () {
+ return args[argIndex++];
+ }));
+ error.name = 'Invariant Violation';
+ }
+
+ error.framesToPop = 1;
+ throw error;
+ }
+ }
+
+ module.exports = invariant;
+},230,[],"node_modules\\create-react-class\\node_modules\\fbjs\\lib\\invariant.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var emptyFunction = _$$_REQUIRE(_dependencyMap[0], "./emptyFunction");
+
+ var warning = emptyFunction;
+
+ if (process.env.NODE_ENV !== 'production') {
+ var printWarning = function printWarning(format) {
+ for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+ args[_key - 1] = arguments[_key];
+ }
+
+ var argIndex = 0;
+ var message = 'Warning: ' + format.replace(/%s/g, function () {
+ return args[argIndex++];
+ });
+
+ if (typeof console !== 'undefined') {
+ console.error(message);
+ }
+
+ try {
+ throw new Error(message);
+ } catch (x) {}
+ };
+
+ warning = function warning(condition, format) {
+ if (format === undefined) {
+ throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument');
+ }
+
+ if (format.indexOf('Failed Composite propType: ') === 0) {
+ return;
+ }
+
+ if (!condition) {
+ for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
+ args[_key2 - 2] = arguments[_key2];
+ }
+
+ printWarning.apply(undefined, [format].concat(args));
+ }
+ };
+ }
+
+ module.exports = warning;
+},231,[232],"node_modules\\create-react-class\\node_modules\\fbjs\\lib\\warning.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ "use strict";
+
+ function makeEmptyFunction(arg) {
+ return function () {
+ return arg;
+ };
+ }
+
+ var emptyFunction = function emptyFunction() {};
+
+ emptyFunction.thatReturns = makeEmptyFunction;
+ emptyFunction.thatReturnsFalse = makeEmptyFunction(false);
+ emptyFunction.thatReturnsTrue = makeEmptyFunction(true);
+ emptyFunction.thatReturnsNull = makeEmptyFunction(null);
+
+ emptyFunction.thatReturnsThis = function () {
+ return this;
+ };
+
+ emptyFunction.thatReturnsArgument = function (arg) {
+ return arg;
+ };
+
+ module.exports = emptyFunction;
+},232,[],"node_modules\\create-react-class\\node_modules\\fbjs\\lib\\emptyFunction.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var invariant = _$$_REQUIRE(_dependencyMap[0], "invariant");
+
+ var ensurePositiveDelayProps = function ensurePositiveDelayProps(props) {
+ invariant(!(props.delayPressIn < 0 || props.delayPressOut < 0 || props.delayLongPress < 0), 'Touchable components cannot have negative delay properties');
+ };
+
+ module.exports = ensurePositiveDelayProps;
+},233,[19],"node_modules\\react-native\\Libraries\\Components\\Touchable\\ensurePositiveDelayProps.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ module.exports = {
+ DraggedTypes: ['fileUrl']
+ };
+},234,[],"node_modules\\react-native\\Libraries\\Components\\View\\DraggedType.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var __extends = this && this.__extends || function () {
+ var _extendStatics = function extendStatics(d, b) {
+ _extendStatics = Object.setPrototypeOf || {
+ __proto__: []
+ } instanceof Array && function (d, b) {
+ d.__proto__ = b;
+ } || function (d, b) {
+ for (var p in b) {
+ if (b.hasOwnProperty(p)) d[p] = b[p];
+ }
+ };
+
+ return _extendStatics(d, b);
+ };
+
+ return function (d, b) {
+ _extendStatics(d, b);
+
+ function __() {
+ this.constructor = d;
+ }
+
+ d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+ };
+ }();
+
+ Object.defineProperty(exports, "__esModule", {
+ value: true
+ });
+
+ var React = _$$_REQUIRE(_dependencyMap[0], "react");
+
+ var react_native_1 = _$$_REQUIRE(_dependencyMap[1], "react-native");
+
+ var styles = react_native_1.StyleSheet.create({
+ container: {
+ height: 100,
+ width: 300,
+ backgroundColor: '#ffbcbc',
+ borderWidth: 1,
+ borderColor: 'red',
+ alignItems: 'center',
+ justifyContent: 'center',
+ margin: 10
+ },
+ info: {
+ color: '#333333',
+ margin: 20
+ }
+ });
+
+ var DummyTouchableNativeFeedback = function (_super) {
+ __extends(DummyTouchableNativeFeedback, _super);
+
+ function DummyTouchableNativeFeedback() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+
+ DummyTouchableNativeFeedback.prototype.render = function () {
+ return React.createElement(react_native_1.View, {
+ style: [styles.container, this.props.style]
+ }, React.createElement(react_native_1.Text, {
+ style: styles.info
+ }, "TouchableNativeFeedback is not supported on this platform!"));
+ };
+
+ DummyTouchableNativeFeedback.SelectableBackground = function () {
+ return {};
+ };
+
+ DummyTouchableNativeFeedback.SelectableBackgroundBorderless = function () {
+ return {};
+ };
+
+ DummyTouchableNativeFeedback.Ripple = function () {
+ return {};
+ };
+
+ DummyTouchableNativeFeedback.canUseNativeForeground = function () {
+ return false;
+ };
+
+ return DummyTouchableNativeFeedback;
+ }(React.Component);
+
+ exports.default = DummyTouchableNativeFeedback;
+},235,[11,18],"Libraries\\Components\\Touchable\\TouchableNativeFeedback.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Components\\Touchable\\TouchableOpacity.js";
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var Animated = _$$_REQUIRE(_dependencyMap[1], "Animated");
+
+ var Easing = _$$_REQUIRE(_dependencyMap[2], "Easing");
+
+ var NativeMethodsMixin = _$$_REQUIRE(_dependencyMap[3], "NativeMethodsMixin");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[4], "Platform");
+
+ var React = _$$_REQUIRE(_dependencyMap[5], "React");
+
+ var PropTypes = _$$_REQUIRE(_dependencyMap[6], "prop-types");
+
+ var Touchable = _$$_REQUIRE(_dependencyMap[7], "Touchable");
+
+ var TouchableWithoutFeedback = _$$_REQUIRE(_dependencyMap[8], "TouchableWithoutFeedback");
+
+ var createReactClass = _$$_REQUIRE(_dependencyMap[9], "create-react-class");
+
+ var ensurePositiveDelayProps = _$$_REQUIRE(_dependencyMap[10], "ensurePositiveDelayProps");
+
+ var flattenStyle = _$$_REQUIRE(_dependencyMap[11], "flattenStyle");
+
+ var PRESS_RETENTION_OFFSET = {
+ top: 20,
+ left: 20,
+ right: 20,
+ bottom: 30
+ };
+ var TouchableOpacity = createReactClass({
+ displayName: 'TouchableOpacity',
+ mixins: [Touchable.Mixin.withoutDefaultFocusAndBlur, NativeMethodsMixin],
+ propTypes: _objectSpread({}, TouchableWithoutFeedback.propTypes, {
+ activeOpacity: PropTypes.number,
+ hasTVPreferredFocus: PropTypes.bool,
+ tvParallaxProperties: PropTypes.object
+ }),
+ getDefaultProps: function getDefaultProps() {
+ return {
+ activeOpacity: 0.2
+ };
+ },
+ getInitialState: function getInitialState() {
+ return _objectSpread({}, this.touchableGetInitialState(), {
+ anim: new Animated.Value(this._getChildStyleOpacityWithDefault())
+ });
+ },
+ componentDidMount: function componentDidMount() {
+ ensurePositiveDelayProps(this.props);
+ },
+ UNSAFE_componentWillReceiveProps: function UNSAFE_componentWillReceiveProps(nextProps) {
+ ensurePositiveDelayProps(nextProps);
+ },
+ componentDidUpdate: function componentDidUpdate(prevProps, prevState) {
+ if (this.props.disabled !== prevProps.disabled) {
+ this._opacityInactive(250);
+ }
+ },
+ setOpacityTo: function setOpacityTo(value, duration) {
+ Animated.timing(this.state.anim, {
+ toValue: value,
+ duration: duration,
+ easing: Easing.inOut(Easing.quad),
+ useNativeDriver: true
+ }).start();
+ },
+ touchableHandleActivePressIn: function touchableHandleActivePressIn(e) {
+ if (e.dispatchConfig.registrationName === 'onResponderGrant') {
+ this._opacityActive(0);
+ } else {
+ this._opacityActive(150);
+ }
+
+ this.props.onPressIn && this.props.onPressIn(e);
+ },
+ touchableHandleActivePressOut: function touchableHandleActivePressOut(e) {
+ this._opacityInactive(250);
+
+ this.props.onPressOut && this.props.onPressOut(e);
+ },
+ touchableHandleFocus: function touchableHandleFocus(e) {
+ if (Platform.isTV) {
+ this._opacityActive(150);
+ }
+
+ this.props.onFocus && this.props.onFocus(e);
+ },
+ touchableHandleBlur: function touchableHandleBlur(e) {
+ if (Platform.isTV) {
+ this._opacityInactive(250);
+ }
+
+ this.props.onBlur && this.props.onBlur(e);
+ },
+ touchableHandlePress: function touchableHandlePress(e) {
+ this.props.onPress && this.props.onPress(e);
+ },
+ touchableHandleLongPress: function touchableHandleLongPress(e) {
+ this.props.onLongPress && this.props.onLongPress(e);
+ },
+ touchableGetPressRectOffset: function touchableGetPressRectOffset() {
+ return this.props.pressRetentionOffset || PRESS_RETENTION_OFFSET;
+ },
+ touchableGetHitSlop: function touchableGetHitSlop() {
+ return this.props.hitSlop;
+ },
+ touchableGetHighlightDelayMS: function touchableGetHighlightDelayMS() {
+ return this.props.delayPressIn || 0;
+ },
+ touchableGetLongPressDelayMS: function touchableGetLongPressDelayMS() {
+ return this.props.delayLongPress === 0 ? 0 : this.props.delayLongPress || 500;
+ },
+ touchableGetPressOutDelayMS: function touchableGetPressOutDelayMS() {
+ return this.props.delayPressOut;
+ },
+ _opacityActive: function _opacityActive(duration) {
+ this.setOpacityTo(this.props.activeOpacity, duration);
+ },
+ _opacityInactive: function _opacityInactive(duration) {
+ this.setOpacityTo(this._getChildStyleOpacityWithDefault(), duration);
+ },
+ _getChildStyleOpacityWithDefault: function _getChildStyleOpacityWithDefault() {
+ var childStyle = flattenStyle(this.props.style) || {};
+ return childStyle.opacity == null ? 1 : childStyle.opacity;
+ },
+ render: function render() {
+ return React.createElement(Animated.View, {
+ accessible: this.props.accessible !== false,
+ accessibilityLabel: this.props.accessibilityLabel,
+ accessibilityHint: this.props.accessibilityHint,
+ accessibilityRole: this.props.accessibilityRole,
+ accessibilityStates: this.props.accessibilityStates,
+ onAccessibilityTap: this.props.onAccessibilityTap,
+ acceptsKeyboardFocus: (this.props.acceptsKeyboardFocus === undefined || this.props.acceptsKeyboardFocus) && !this.props.disabled,
+ enableFocusRing: (this.props.enableFocusRing === undefined || this.props.enableFocusRing) && !this.props.disabled,
+ tabIndex: this.props.tabIndex,
+ 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,
+ tooltip: this.props.tooltip,
+ clickable: this.props.clickable !== false && this.props.onPress !== undefined,
+ onClick: this.touchableHandlePress,
+ onMouseEnter: this.props.onMouseEnter,
+ onMouseLeave: this.props.onMouseLeave,
+ onDragEnter: this.props.onDragEnter,
+ onDragLeave: this.props.onDragLeave,
+ onDrop: this.props.onDrop,
+ draggedTypes: this.props.draggedTypes,
+ onResponderTerminate: this.touchableHandleResponderTerminate,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 282
+ }
+ }, this.props.children, Touchable.renderDebugView({
+ color: 'cyan',
+ hitSlop: this.props.hitSlop
+ }));
+ }
+ });
+ module.exports = TouchableOpacity;
+},236,[32,237,264,225,35,52,62,213,226,227,233,80],"node_modules\\react-native\\Libraries\\Components\\Touchable\\TouchableOpacity.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+
+ var _defineProperty2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/defineProperty"));
+
+ var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "Platform"));
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var AnimatedImplementation = _Platform.default.isTesting ? _$$_REQUIRE(_dependencyMap[3], "AnimatedMock") : _$$_REQUIRE(_dependencyMap[4], "AnimatedImplementation");
+ module.exports = _objectSpread({
+ get FlatList() {
+ return _$$_REQUIRE(_dependencyMap[5], "AnimatedFlatList");
+ },
+
+ get Image() {
+ return _$$_REQUIRE(_dependencyMap[6], "AnimatedImage");
+ },
+
+ get ScrollView() {
+ return _$$_REQUIRE(_dependencyMap[7], "AnimatedScrollView");
+ },
+
+ get SectionList() {
+ return _$$_REQUIRE(_dependencyMap[8], "AnimatedSectionList");
+ },
+
+ get Text() {
+ return _$$_REQUIRE(_dependencyMap[9], "AnimatedText");
+ },
+
+ get View() {
+ return _$$_REQUIRE(_dependencyMap[10], "AnimatedView");
+ }
+
+ }, AnimatedImplementation);
+},237,[1,32,35,238,247,267,286,290,291,294,295],"node_modules\\react-native\\Libraries\\Animated\\src\\Animated.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _require = _$$_REQUIRE(_dependencyMap[0], "./AnimatedEvent"),
+ AnimatedEvent = _require.AnimatedEvent,
+ attachNativeEvent = _require.attachNativeEvent;
+
+ var AnimatedImplementation = _$$_REQUIRE(_dependencyMap[1], "AnimatedImplementation");
+
+ var AnimatedInterpolation = _$$_REQUIRE(_dependencyMap[2], "./nodes/AnimatedInterpolation");
+
+ var AnimatedNode = _$$_REQUIRE(_dependencyMap[3], "./nodes/AnimatedNode");
+
+ var AnimatedProps = _$$_REQUIRE(_dependencyMap[4], "./nodes/AnimatedProps");
+
+ var AnimatedValue = _$$_REQUIRE(_dependencyMap[5], "./nodes/AnimatedValue");
+
+ var AnimatedValueXY = _$$_REQUIRE(_dependencyMap[6], "./nodes/AnimatedValueXY");
+
+ var createAnimatedComponent = _$$_REQUIRE(_dependencyMap[7], "./createAnimatedComponent");
+
+ var emptyAnimation = {
+ start: function start() {},
+ stop: function stop() {},
+ reset: function reset() {},
+ _startNativeLoop: function _startNativeLoop() {},
+ _isUsingNativeDriver: function _isUsingNativeDriver() {
+ return false;
+ }
+ };
+
+ var spring = function spring(value, config) {
+ return emptyAnimation;
+ };
+
+ var timing = function timing(value, config) {
+ return emptyAnimation;
+ };
+
+ var decay = function decay(value, config) {
+ return emptyAnimation;
+ };
+
+ var sequence = function sequence(animations) {
+ return emptyAnimation;
+ };
+
+ var parallel = function parallel(animations, config) {
+ return emptyAnimation;
+ };
+
+ var delay = function delay(time) {
+ return emptyAnimation;
+ };
+
+ var stagger = function stagger(time, animations) {
+ return emptyAnimation;
+ };
+
+ var loop = function loop(animation) {
+ var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+ _ref$iterations = _ref.iterations,
+ iterations = _ref$iterations === void 0 ? -1 : _ref$iterations;
+
+ return emptyAnimation;
+ };
+
+ var event = function event(argMapping, config) {
+ return null;
+ };
+
+ module.exports = {
+ Value: AnimatedValue,
+ ValueXY: AnimatedValueXY,
+ Interpolation: AnimatedInterpolation,
+ Node: AnimatedNode,
+ decay: decay,
+ timing: timing,
+ spring: spring,
+ add: AnimatedImplementation.add,
+ subtract: AnimatedImplementation.subtract,
+ divide: AnimatedImplementation.divide,
+ multiply: AnimatedImplementation.multiply,
+ modulo: AnimatedImplementation.modulo,
+ diffClamp: AnimatedImplementation.diffClamp,
+ delay: delay,
+ sequence: sequence,
+ parallel: parallel,
+ stagger: stagger,
+ loop: loop,
+ event: event,
+ createAnimatedComponent: createAnimatedComponent,
+ attachNativeEvent: attachNativeEvent,
+ forkEvent: AnimatedImplementation.forkEvent,
+ unforkEvent: AnimatedImplementation.unforkEvent,
+ Event: AnimatedEvent,
+ __PropsOnlyForTests: AnimatedProps
+ };
+},238,[239,247,241,242,253,240,258,266],"node_modules\\react-native\\Libraries\\Animated\\src\\AnimatedMock.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var AnimatedValue = _$$_REQUIRE(_dependencyMap[2], "./nodes/AnimatedValue");
+
+ var NativeAnimatedHelper = _$$_REQUIRE(_dependencyMap[3], "./NativeAnimatedHelper");
+
+ var ReactNative = _$$_REQUIRE(_dependencyMap[4], "ReactNative");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[5], "invariant");
+
+ var _require = _$$_REQUIRE(_dependencyMap[3], "./NativeAnimatedHelper"),
+ shouldUseNativeDriver = _require.shouldUseNativeDriver;
+
+ function attachNativeEvent(viewRef, eventName, argMapping) {
+ var eventMappings = [];
+
+ var traverse = function traverse(value, path) {
+ if (value instanceof AnimatedValue) {
+ value.__makeNative();
+
+ eventMappings.push({
+ nativeEventPath: path,
+ animatedValueTag: value.__getNativeTag()
+ });
+ } else if (typeof value === 'object') {
+ for (var _key in value) {
+ traverse(value[_key], path.concat(_key));
+ }
+ }
+ };
+
+ invariant(argMapping[0] && argMapping[0].nativeEvent, 'Native driven events only support animated values contained inside `nativeEvent`.');
+ traverse(argMapping[0].nativeEvent, []);
+ var viewTag = ReactNative.findNodeHandle(viewRef);
+ eventMappings.forEach(function (mapping) {
+ NativeAnimatedHelper.API.addAnimatedEventToView(viewTag, eventName, mapping);
+ });
+ return {
+ detach: function detach() {
+ eventMappings.forEach(function (mapping) {
+ NativeAnimatedHelper.API.removeAnimatedEventFromView(viewTag, eventName, mapping.animatedValueTag);
+ });
+ }
+ };
+ }
+
+ var AnimatedEvent = function () {
+ function AnimatedEvent(argMapping) {
+ var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+ _classCallCheck(this, AnimatedEvent);
+
+ this._listeners = [];
+ this._argMapping = argMapping;
+
+ if (config.listener) {
+ this.__addListener(config.listener);
+ }
+
+ this._callListeners = this._callListeners.bind(this);
+ this._attachedEvent = null;
+ this.__isNative = shouldUseNativeDriver(config);
+
+ if (__DEV__) {
+ this._validateMapping();
+ }
+ }
+
+ _createClass(AnimatedEvent, [{
+ key: "__addListener",
+ value: function __addListener(callback) {
+ this._listeners.push(callback);
+ }
+ }, {
+ key: "__removeListener",
+ value: function __removeListener(callback) {
+ this._listeners = this._listeners.filter(function (listener) {
+ return listener !== callback;
+ });
+ }
+ }, {
+ key: "__attach",
+ value: function __attach(viewRef, eventName) {
+ invariant(this.__isNative, 'Only native driven events need to be attached.');
+ this._attachedEvent = attachNativeEvent(viewRef, eventName, this._argMapping);
+ }
+ }, {
+ key: "__detach",
+ value: function __detach(viewTag, eventName) {
+ invariant(this.__isNative, 'Only native driven events need to be detached.');
+ this._attachedEvent && this._attachedEvent.detach();
+ }
+ }, {
+ key: "__getHandler",
+ value: function __getHandler() {
+ var _this = this;
+
+ if (this.__isNative) {
+ return this._callListeners;
+ }
+
+ return function () {
+ for (var _len = arguments.length, args = new Array(_len), _key2 = 0; _key2 < _len; _key2++) {
+ args[_key2] = arguments[_key2];
+ }
+
+ var traverse = function traverse(recMapping, recEvt, key) {
+ if (typeof recEvt === 'number' && recMapping instanceof AnimatedValue) {
+ recMapping.setValue(recEvt);
+ } else if (typeof recMapping === 'object') {
+ for (var mappingKey in recMapping) {
+ traverse(recMapping[mappingKey], recEvt[mappingKey], mappingKey);
+ }
+ }
+ };
+
+ if (!_this.__isNative) {
+ _this._argMapping.forEach(function (mapping, idx) {
+ traverse(mapping, args[idx], 'arg' + idx);
+ });
+ }
+
+ _this._callListeners.apply(_this, args);
+ };
+ }
+ }, {
+ key: "_callListeners",
+ value: function _callListeners() {
+ for (var _len2 = arguments.length, args = new Array(_len2), _key3 = 0; _key3 < _len2; _key3++) {
+ args[_key3] = arguments[_key3];
+ }
+
+ this._listeners.forEach(function (listener) {
+ return listener.apply(void 0, args);
+ });
+ }
+ }, {
+ key: "_validateMapping",
+ value: function _validateMapping() {
+ var traverse = function traverse(recMapping, recEvt, key) {
+ if (typeof recEvt === 'number') {
+ invariant(recMapping instanceof AnimatedValue, 'Bad mapping of type ' + typeof recMapping + ' for key ' + key + ', event value must map to AnimatedValue');
+ return;
+ }
+
+ invariant(typeof recMapping === 'object', 'Bad mapping of type ' + typeof recMapping + ' for key ' + key);
+ invariant(typeof recEvt === 'object', 'Bad event of type ' + typeof recEvt + ' for key ' + key);
+
+ for (var mappingKey in recMapping) {
+ traverse(recMapping[mappingKey], recEvt[mappingKey], mappingKey);
+ }
+ };
+ }
+ }]);
+
+ return AnimatedEvent;
+ }();
+
+ module.exports = {
+ AnimatedEvent: AnimatedEvent,
+ attachNativeEvent: attachNativeEvent
+ };
+},239,[3,4,240,243,84,19],"node_modules\\react-native\\Libraries\\Animated\\src\\AnimatedEvent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _get = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/get");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var AnimatedInterpolation = _$$_REQUIRE(_dependencyMap[6], "./AnimatedInterpolation");
+
+ var AnimatedWithChildren = _$$_REQUIRE(_dependencyMap[7], "./AnimatedWithChildren");
+
+ var InteractionManager = _$$_REQUIRE(_dependencyMap[8], "InteractionManager");
+
+ var NativeAnimatedHelper = _$$_REQUIRE(_dependencyMap[9], "../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) {
+ _inherits(AnimatedValue, _AnimatedWithChildren);
+
+ function AnimatedValue(value) {
+ var _this;
+
+ _classCallCheck(this, AnimatedValue);
+
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(AnimatedValue).call(this));
+ _this._startingValue = _this._value = value;
+ _this._offset = 0;
+ _this._animation = null;
+ _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
+ };
+ }
+ }]);
+
+ return AnimatedValue;
+ }(AnimatedWithChildren);
+
+ module.exports = AnimatedValue;
+},240,[3,4,5,8,25,9,241,244,245,243],"node_modules\\react-native\\Libraries\\Animated\\src\\nodes\\AnimatedValue.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _get = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/get");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/defineProperty");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var AnimatedNode = _$$_REQUIRE(_dependencyMap[7], "./AnimatedNode");
+
+ var AnimatedWithChildren = _$$_REQUIRE(_dependencyMap[8], "./AnimatedWithChildren");
+
+ var NativeAnimatedHelper = _$$_REQUIRE(_dependencyMap[9], "../NativeAnimatedHelper");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[10], "invariant");
+
+ var normalizeColor = _$$_REQUIRE(_dependencyMap[11], "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 || typeof int32Color !== 'number') {
+ 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) {
+ _inherits(AnimatedInterpolation, _AnimatedWithChildren);
+
+ function AnimatedInterpolation(parent, config) {
+ var _this;
+
+ _classCallCheck(this, AnimatedInterpolation);
+
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(AnimatedInterpolation).call(this));
+ _this._parent = parent;
+ _this._config = config;
+ _this._interpolation = createInterpolation(config);
+ return _this;
+ }
+
+ _createClass(AnimatedInterpolation, [{
+ key: "__makeNative",
+ value: function __makeNative() {
+ this._parent.__makeNative();
+
+ _get(_getPrototypeOf(AnimatedInterpolation.prototype), "__makeNative", this).call(this);
+ }
+ }, {
+ key: "__getValue",
+ value: function __getValue() {
+ var parentValue = this._parent.__getValue();
+
+ invariant(typeof parentValue === 'number', 'Cannot interpolate an input which is not a number.');
+ return this._interpolation(parentValue);
+ }
+ }, {
+ key: "interpolate",
+ value: function interpolate(config) {
+ return new AnimatedInterpolation(this, config);
+ }
+ }, {
+ key: "__attach",
+ value: function __attach() {
+ this._parent.__addChild(this);
+ }
+ }, {
+ key: "__detach",
+ value: function __detach() {
+ this._parent.__removeChild(this);
+
+ _get(_getPrototypeOf(AnimatedInterpolation.prototype), "__detach", this).call(this);
+ }
+ }, {
+ key: "__transformDataType",
+ value: function __transformDataType(range) {
+ return range.map(NativeAnimatedHelper.transformDataType);
+ }
+ }, {
+ key: "__getNativeConfig",
+ value: function __getNativeConfig() {
+ if (__DEV__) {
+ NativeAnimatedHelper.validateInterpolation(this._config);
+ }
+
+ return {
+ inputRange: this._config.inputRange,
+ outputRange: this.__transformDataType(this._config.outputRange),
+ extrapolateLeft: this._config.extrapolateLeft || this._config.extrapolate || 'extend',
+ extrapolateRight: this._config.extrapolateRight || this._config.extrapolate || 'extend',
+ type: 'interpolation'
+ };
+ }
+ }]);
+
+ return AnimatedInterpolation;
+ }(AnimatedWithChildren);
+
+ AnimatedInterpolation.__createInterpolation = createInterpolation;
+ module.exports = AnimatedInterpolation;
+},241,[3,4,5,8,25,9,32,242,244,243,19,60],"node_modules\\react-native\\Libraries\\Animated\\src\\nodes\\AnimatedInterpolation.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var NativeAnimatedHelper = _$$_REQUIRE(_dependencyMap[2], "../NativeAnimatedHelper");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[3], "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;
+},242,[3,4,243,19],"node_modules\\react-native\\Libraries\\Animated\\src\\nodes\\AnimatedNode.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var NativeAnimatedModule = _$$_REQUIRE(_dependencyMap[0], "NativeModules").NativeAnimatedModule;
+
+ var NativeEventEmitter = _$$_REQUIRE(_dependencyMap[1], "NativeEventEmitter");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[2], "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,
+ elevation: true,
+ shadowOpacity: true,
+ shadowRadius: true,
+ scaleX: true,
+ scaleY: true,
+ translateX: true,
+ translateY: true
+ };
+ var TRANSFORM_WHITELIST = {
+ translateX: true,
+ translateY: true,
+ scale: true,
+ scaleX: true,
+ scaleY: true,
+ rotate: true,
+ rotateX: true,
+ rotateY: true,
+ 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;
+ }
+
+ function transformDataType(value) {
+ if (typeof value !== 'string') {
+ return value;
+ }
+
+ if (/deg$/.test(value)) {
+ var degrees = parseFloat(value) || 0;
+ var radians = degrees * Math.PI / 180.0;
+ return radians;
+ } else {
+ return parseFloat(value) || 0;
+ }
+ }
+
+ module.exports = {
+ API: API,
+ addWhitelistedStyleProp: addWhitelistedStyleProp,
+ addWhitelistedTransformProp: addWhitelistedTransformProp,
+ addWhitelistedInterpolationParam: addWhitelistedInterpolationParam,
+ validateStyles: validateStyles,
+ validateTransform: validateTransform,
+ validateInterpolation: validateInterpolation,
+ generateNewNodeTag: generateNewNodeTag,
+ generateNewAnimationId: generateNewAnimationId,
+ assertNativeAnimatedModule: assertNativeAnimatedModule,
+ shouldUseNativeDriver: shouldUseNativeDriver,
+ transformDataType: transformDataType,
+
+ get nativeEventEmitter() {
+ if (!nativeEventEmitter) {
+ nativeEventEmitter = new NativeEventEmitter(NativeAnimatedModule);
+ }
+
+ return nativeEventEmitter;
+ }
+
+ };
+},243,[36,131,19],"node_modules\\react-native\\Libraries\\Animated\\src\\NativeAnimatedHelper.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var AnimatedNode = _$$_REQUIRE(_dependencyMap[5], "./AnimatedNode");
+
+ var NativeAnimatedHelper = _$$_REQUIRE(_dependencyMap[6], "../NativeAnimatedHelper");
+
+ var AnimatedWithChildren = function (_AnimatedNode) {
+ _inherits(AnimatedWithChildren, _AnimatedNode);
+
+ function AnimatedWithChildren() {
+ var _this;
+
+ _classCallCheck(this, AnimatedWithChildren);
+
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(AnimatedWithChildren).call(this));
+ _this._children = [];
+ return _this;
+ }
+
+ _createClass(AnimatedWithChildren, [{
+ key: "__makeNative",
+ value: function __makeNative() {
+ if (!this.__isNative) {
+ this.__isNative = true;
+
+ for (var _iterator = this._children, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();;) {
+ var _ref;
+
+ if (_isArray) {
+ if (_i >= _iterator.length) break;
+ _ref = _iterator[_i++];
+ } else {
+ _i = _iterator.next();
+ if (_i.done) break;
+ _ref = _i.value;
+ }
+
+ var _child = _ref;
+
+ _child.__makeNative();
+
+ NativeAnimatedHelper.API.connectAnimatedNodes(this.__getNativeTag(), _child.__getNativeTag());
+ }
+ }
+ }
+ }, {
+ 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;
+ }
+ }]);
+
+ return AnimatedWithChildren;
+ }(AnimatedNode);
+
+ module.exports = AnimatedWithChildren;
+},244,[3,4,5,8,9,242,243],"node_modules\\react-native\\Libraries\\Animated\\src\\nodes\\AnimatedWithChildren.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var BatchedBridge = _$$_REQUIRE(_dependencyMap[0], "BatchedBridge");
+
+ var EventEmitter = _$$_REQUIRE(_dependencyMap[1], "EventEmitter");
+
+ var TaskQueue = _$$_REQUIRE(_dependencyMap[2], "TaskQueue");
+
+ var infoLog = _$$_REQUIRE(_dependencyMap[3], "infoLog");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[4], "invariant");
+
+ var keyMirror = _$$_REQUIRE(_dependencyMap[5], "fbjs/lib/keyMirror");
+
+ var _emitter = new EventEmitter();
+
+ var DEBUG_DELAY = 0;
+ var DEBUG = false;
+ var InteractionManager = {
+ Events: keyMirror({
+ interactionStart: true,
+ interactionComplete: true
+ }),
+ runAfterInteractions: function runAfterInteractions(task) {
+ var tasks = [];
+ var promise = new Promise(function (resolve) {
+ _scheduleUpdate();
+
+ if (task) {
+ tasks.push(task);
+ }
+
+ tasks.push({
+ run: resolve,
+ name: 'resolve ' + (task && task.name || '?')
+ });
+
+ _taskQueue.enqueueTasks(tasks);
+ });
+ return {
+ then: promise.then.bind(promise),
+ done: function done() {
+ if (promise.done) {
+ return promise.done.apply(promise, arguments);
+ } else {
+ console.warn('Tried to call done when not supported by current Promise implementation.');
+ }
+ },
+ cancel: function cancel() {
+ _taskQueue.cancelTasks(tasks);
+ }
+ };
+ },
+ createInteractionHandle: function createInteractionHandle() {
+ DEBUG && infoLog('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;
+},245,[41,27,246,157,19,218],"node_modules\\react-native\\Libraries\\Interaction\\InteractionManager.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var infoLog = _$$_REQUIRE(_dependencyMap[3], "infoLog");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[4], "invariant");
+
+ var DEBUG = false;
+
+ var TaskQueue = function () {
+ function TaskQueue(_ref) {
+ var onMoreTasks = _ref.onMoreTasks;
+
+ _classCallCheck(this, TaskQueue);
+
+ this._onMoreTasks = onMoreTasks;
+ this._queueStack = [{
+ tasks: [],
+ popable: false
+ }];
+ }
+
+ _createClass(TaskQueue, [{
+ key: "enqueue",
+ value: function enqueue(task) {
+ this._getCurrentQueue().push(task);
+ }
+ }, {
+ key: "enqueueTasks",
+ value: function enqueueTasks(tasks) {
+ var _this = this;
+
+ tasks.forEach(function (task) {
+ return _this.enqueue(task);
+ });
+ }
+ }, {
+ key: "cancelTasks",
+ value: function cancelTasks(tasksToCancel) {
+ this._queueStack = this._queueStack.map(function (queue) {
+ return _objectSpread({}, queue, {
+ tasks: queue.tasks.filter(function (task) {
+ return tasksToCancel.indexOf(task) === -1;
+ })
+ });
+ }).filter(function (queue, idx) {
+ return queue.tasks.length > 0 || idx === 0;
+ });
+ }
+ }, {
+ key: "hasTasksToProcess",
+ value: function hasTasksToProcess() {
+ return this._getCurrentQueue().length > 0;
+ }
+ }, {
+ key: "processNext",
+ value: function processNext() {
+ var queue = this._getCurrentQueue();
+
+ if (queue.length) {
+ var task = queue.shift();
+
+ try {
+ if (task.gen) {
+ DEBUG && infoLog('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;
+},246,[32,3,4,157,19],"node_modules\\react-native\\Libraries\\Interaction\\TaskQueue.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var _require = _$$_REQUIRE(_dependencyMap[1], "./AnimatedEvent"),
+ AnimatedEvent = _require.AnimatedEvent,
+ attachNativeEvent = _require.attachNativeEvent;
+
+ var AnimatedAddition = _$$_REQUIRE(_dependencyMap[2], "./nodes/AnimatedAddition");
+
+ var AnimatedDiffClamp = _$$_REQUIRE(_dependencyMap[3], "./nodes/AnimatedDiffClamp");
+
+ var AnimatedDivision = _$$_REQUIRE(_dependencyMap[4], "./nodes/AnimatedDivision");
+
+ var AnimatedInterpolation = _$$_REQUIRE(_dependencyMap[5], "./nodes/AnimatedInterpolation");
+
+ var AnimatedModulo = _$$_REQUIRE(_dependencyMap[6], "./nodes/AnimatedModulo");
+
+ var AnimatedMultiplication = _$$_REQUIRE(_dependencyMap[7], "./nodes/AnimatedMultiplication");
+
+ var AnimatedNode = _$$_REQUIRE(_dependencyMap[8], "./nodes/AnimatedNode");
+
+ var AnimatedProps = _$$_REQUIRE(_dependencyMap[9], "./nodes/AnimatedProps");
+
+ var AnimatedSubtraction = _$$_REQUIRE(_dependencyMap[10], "./nodes/AnimatedSubtraction");
+
+ var AnimatedTracking = _$$_REQUIRE(_dependencyMap[11], "./nodes/AnimatedTracking");
+
+ var AnimatedValue = _$$_REQUIRE(_dependencyMap[12], "./nodes/AnimatedValue");
+
+ var AnimatedValueXY = _$$_REQUIRE(_dependencyMap[13], "./nodes/AnimatedValueXY");
+
+ var DecayAnimation = _$$_REQUIRE(_dependencyMap[14], "./animations/DecayAnimation");
+
+ var SpringAnimation = _$$_REQUIRE(_dependencyMap[15], "./animations/SpringAnimation");
+
+ var TimingAnimation = _$$_REQUIRE(_dependencyMap[16], "./animations/TimingAnimation");
+
+ var createAnimatedComponent = _$$_REQUIRE(_dependencyMap[17], "./createAnimatedComponent");
+
+ var add = function add(a, b) {
+ return new AnimatedAddition(a, b);
+ };
+
+ var subtract = function subtract(a, b) {
+ return new AnimatedSubtraction(a, b);
+ };
+
+ var divide = function divide(a, b) {
+ return new AnimatedDivision(a, b);
+ };
+
+ var multiply = function multiply(a, b) {
+ return new AnimatedMultiplication(a, b);
+ };
+
+ var modulo = function modulo(a, modulus) {
+ return new AnimatedModulo(a, modulus);
+ };
+
+ var diffClamp = function diffClamp(a, min, max) {
+ return new AnimatedDiffClamp(a, min, max);
+ };
+
+ var _combineCallbacks = function _combineCallbacks(callback, config) {
+ if (callback && config.onComplete) {
+ return function () {
+ config.onComplete && config.onComplete.apply(config, arguments);
+ callback && callback.apply(void 0, arguments);
+ };
+ } else {
+ return callback || config.onComplete;
+ }
+ };
+
+ var maybeVectorAnim = function maybeVectorAnim(value, config, anim) {
+ if (value instanceof AnimatedValueXY) {
+ var configX = _objectSpread({}, config);
+
+ var configY = _objectSpread({}, config);
+
+ for (var key in config) {
+ var _config$key = config[key],
+ x = _config$key.x,
+ y = _config$key.y;
+
+ if (x !== undefined && y !== undefined) {
+ configX[key] = x;
+ configY[key] = y;
+ }
+ }
+
+ var aX = anim(value.x, configX);
+ var aY = anim(value.y, configY);
+ return parallel([aX, aY], {
+ stopTogether: false
+ });
+ }
+
+ return null;
+ };
+
+ var spring = function spring(value, config) {
+ var _start = function start(animatedValue, configuration, callback) {
+ callback = _combineCallbacks(callback, configuration);
+ var singleValue = animatedValue;
+ var singleConfig = configuration;
+ singleValue.stopTracking();
+
+ if (configuration.toValue instanceof AnimatedNode) {
+ singleValue.track(new AnimatedTracking(singleValue, configuration.toValue, SpringAnimation, singleConfig, callback));
+ } else {
+ singleValue.animate(new SpringAnimation(singleConfig), callback);
+ }
+ };
+
+ return maybeVectorAnim(value, config, spring) || {
+ start: function start(callback) {
+ _start(value, config, callback);
+ },
+ stop: function stop() {
+ value.stopAnimation();
+ },
+ reset: function reset() {
+ value.resetAnimation();
+ },
+ _startNativeLoop: function _startNativeLoop(iterations) {
+ var singleConfig = _objectSpread({}, config, {
+ iterations: iterations
+ });
+
+ _start(value, singleConfig);
+ },
+ _isUsingNativeDriver: function _isUsingNativeDriver() {
+ return config.useNativeDriver || false;
+ }
+ };
+ };
+
+ var timing = function timing(value, config) {
+ var _start2 = function start(animatedValue, configuration, callback) {
+ callback = _combineCallbacks(callback, configuration);
+ var singleValue = animatedValue;
+ var singleConfig = configuration;
+ singleValue.stopTracking();
+
+ if (configuration.toValue instanceof AnimatedNode) {
+ singleValue.track(new AnimatedTracking(singleValue, configuration.toValue, TimingAnimation, singleConfig, callback));
+ } else {
+ singleValue.animate(new TimingAnimation(singleConfig), callback);
+ }
+ };
+
+ return maybeVectorAnim(value, config, timing) || {
+ start: function start(callback) {
+ _start2(value, config, callback);
+ },
+ stop: function stop() {
+ value.stopAnimation();
+ },
+ reset: function reset() {
+ value.resetAnimation();
+ },
+ _startNativeLoop: function _startNativeLoop(iterations) {
+ var singleConfig = _objectSpread({}, config, {
+ iterations: iterations
+ });
+
+ _start2(value, singleConfig);
+ },
+ _isUsingNativeDriver: function _isUsingNativeDriver() {
+ return config.useNativeDriver || false;
+ }
+ };
+ };
+
+ var decay = function decay(value, config) {
+ var _start3 = function start(animatedValue, configuration, callback) {
+ callback = _combineCallbacks(callback, configuration);
+ var singleValue = animatedValue;
+ var singleConfig = configuration;
+ singleValue.stopTracking();
+ singleValue.animate(new DecayAnimation(singleConfig), callback);
+ };
+
+ return maybeVectorAnim(value, config, decay) || {
+ start: function start(callback) {
+ _start3(value, config, callback);
+ },
+ stop: function stop() {
+ value.stopAnimation();
+ },
+ reset: function reset() {
+ value.resetAnimation();
+ },
+ _startNativeLoop: function _startNativeLoop(iterations) {
+ var singleConfig = _objectSpread({}, config, {
+ iterations: iterations
+ });
+
+ _start3(value, singleConfig);
+ },
+ _isUsingNativeDriver: function _isUsingNativeDriver() {
+ return config.useNativeDriver || false;
+ }
+ };
+ };
+
+ var sequence = function sequence(animations) {
+ var current = 0;
+ return {
+ start: function start(callback) {
+ var onComplete = function onComplete(result) {
+ if (!result.finished) {
+ callback && callback(result);
+ return;
+ }
+
+ current++;
+
+ if (current === animations.length) {
+ callback && callback(result);
+ return;
+ }
+
+ animations[current].start(onComplete);
+ };
+
+ if (animations.length === 0) {
+ callback && callback({
+ finished: true
+ });
+ } else {
+ animations[current].start(onComplete);
+ }
+ },
+ stop: function stop() {
+ if (current < animations.length) {
+ animations[current].stop();
+ }
+ },
+ reset: function reset() {
+ animations.forEach(function (animation, idx) {
+ if (idx <= current) {
+ animation.reset();
+ }
+ });
+ current = 0;
+ },
+ _startNativeLoop: function _startNativeLoop() {
+ throw new Error('Loops run using the native driver cannot contain Animated.sequence animations');
+ },
+ _isUsingNativeDriver: function _isUsingNativeDriver() {
+ return false;
+ }
+ };
+ };
+
+ var parallel = function parallel(animations, config) {
+ var doneCount = 0;
+ var hasEnded = {};
+ var stopTogether = !(config && config.stopTogether === false);
+ var result = {
+ start: function start(callback) {
+ if (doneCount === animations.length) {
+ callback && callback({
+ finished: true
+ });
+ return;
+ }
+
+ animations.forEach(function (animation, idx) {
+ var cb = function cb(endResult) {
+ hasEnded[idx] = true;
+ doneCount++;
+
+ if (doneCount === animations.length) {
+ doneCount = 0;
+ callback && callback(endResult);
+ return;
+ }
+
+ if (!endResult.finished && stopTogether) {
+ result.stop();
+ }
+ };
+
+ if (!animation) {
+ cb({
+ finished: true
+ });
+ } else {
+ animation.start(cb);
+ }
+ });
+ },
+ stop: function stop() {
+ animations.forEach(function (animation, idx) {
+ !hasEnded[idx] && animation.stop();
+ hasEnded[idx] = true;
+ });
+ },
+ reset: function reset() {
+ animations.forEach(function (animation, idx) {
+ animation.reset();
+ hasEnded[idx] = false;
+ doneCount = 0;
+ });
+ },
+ _startNativeLoop: function _startNativeLoop() {
+ throw new Error('Loops run using the native driver cannot contain Animated.parallel animations');
+ },
+ _isUsingNativeDriver: function _isUsingNativeDriver() {
+ return false;
+ }
+ };
+ return result;
+ };
+
+ var delay = function delay(time) {
+ return timing(new AnimatedValue(0), {
+ toValue: 0,
+ delay: time,
+ duration: 0
+ });
+ };
+
+ 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,
+ Event: AnimatedEvent,
+ __PropsOnlyForTests: AnimatedProps
+ };
+},247,[32,239,248,249,250,241,251,252,242,253,256,257,240,258,259,261,263,266],"node_modules\\react-native\\Libraries\\Animated\\src\\AnimatedImplementation.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _get = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/get");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var AnimatedInterpolation = _$$_REQUIRE(_dependencyMap[6], "./AnimatedInterpolation");
+
+ var AnimatedNode = _$$_REQUIRE(_dependencyMap[7], "./AnimatedNode");
+
+ var AnimatedValue = _$$_REQUIRE(_dependencyMap[8], "./AnimatedValue");
+
+ var AnimatedWithChildren = _$$_REQUIRE(_dependencyMap[9], "./AnimatedWithChildren");
+
+ var AnimatedAddition = function (_AnimatedWithChildren) {
+ _inherits(AnimatedAddition, _AnimatedWithChildren);
+
+ function AnimatedAddition(a, b) {
+ var _this;
+
+ _classCallCheck(this, AnimatedAddition);
+
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(AnimatedAddition).call(this));
+ _this._a = typeof a === 'number' ? new AnimatedValue(a) : a;
+ _this._b = typeof b === 'number' ? new AnimatedValue(b) : b;
+ return _this;
+ }
+
+ _createClass(AnimatedAddition, [{
+ key: "__makeNative",
+ value: function __makeNative() {
+ this._a.__makeNative();
+
+ this._b.__makeNative();
+
+ _get(_getPrototypeOf(AnimatedAddition.prototype), "__makeNative", this).call(this);
+ }
+ }, {
+ key: "__getValue",
+ value: function __getValue() {
+ return this._a.__getValue() + this._b.__getValue();
+ }
+ }, {
+ key: "interpolate",
+ value: function interpolate(config) {
+ return new AnimatedInterpolation(this, config);
+ }
+ }, {
+ key: "__attach",
+ value: function __attach() {
+ this._a.__addChild(this);
+
+ this._b.__addChild(this);
+ }
+ }, {
+ key: "__detach",
+ value: function __detach() {
+ this._a.__removeChild(this);
+
+ this._b.__removeChild(this);
+
+ _get(_getPrototypeOf(AnimatedAddition.prototype), "__detach", this).call(this);
+ }
+ }, {
+ key: "__getNativeConfig",
+ value: function __getNativeConfig() {
+ return {
+ type: 'addition',
+ input: [this._a.__getNativeTag(), this._b.__getNativeTag()]
+ };
+ }
+ }]);
+
+ return AnimatedAddition;
+ }(AnimatedWithChildren);
+
+ module.exports = AnimatedAddition;
+},248,[3,4,5,8,25,9,241,242,240,244],"node_modules\\react-native\\Libraries\\Animated\\src\\nodes\\AnimatedAddition.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _get = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/get");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var AnimatedInterpolation = _$$_REQUIRE(_dependencyMap[6], "./AnimatedInterpolation");
+
+ var AnimatedNode = _$$_REQUIRE(_dependencyMap[7], "./AnimatedNode");
+
+ var AnimatedWithChildren = _$$_REQUIRE(_dependencyMap[8], "./AnimatedWithChildren");
+
+ var AnimatedDiffClamp = function (_AnimatedWithChildren) {
+ _inherits(AnimatedDiffClamp, _AnimatedWithChildren);
+
+ function AnimatedDiffClamp(a, min, max) {
+ var _this;
+
+ _classCallCheck(this, AnimatedDiffClamp);
+
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(AnimatedDiffClamp).call(this));
+ _this._a = a;
+ _this._min = min;
+ _this._max = max;
+ _this._value = _this._lastValue = _this._a.__getValue();
+ return _this;
+ }
+
+ _createClass(AnimatedDiffClamp, [{
+ key: "__makeNative",
+ value: function __makeNative() {
+ this._a.__makeNative();
+
+ _get(_getPrototypeOf(AnimatedDiffClamp.prototype), "__makeNative", this).call(this);
+ }
+ }, {
+ key: "interpolate",
+ value: function interpolate(config) {
+ return new AnimatedInterpolation(this, config);
+ }
+ }, {
+ key: "__getValue",
+ value: function __getValue() {
+ var value = this._a.__getValue();
+
+ var diff = value - this._lastValue;
+ this._lastValue = value;
+ this._value = Math.min(Math.max(this._value + diff, this._min), this._max);
+ return this._value;
+ }
+ }, {
+ key: "__attach",
+ value: function __attach() {
+ this._a.__addChild(this);
+ }
+ }, {
+ key: "__detach",
+ value: function __detach() {
+ this._a.__removeChild(this);
+
+ _get(_getPrototypeOf(AnimatedDiffClamp.prototype), "__detach", this).call(this);
+ }
+ }, {
+ key: "__getNativeConfig",
+ value: function __getNativeConfig() {
+ return {
+ type: 'diffclamp',
+ input: this._a.__getNativeTag(),
+ min: this._min,
+ max: this._max
+ };
+ }
+ }]);
+
+ return AnimatedDiffClamp;
+ }(AnimatedWithChildren);
+
+ module.exports = AnimatedDiffClamp;
+},249,[3,4,5,8,25,9,241,242,244],"node_modules\\react-native\\Libraries\\Animated\\src\\nodes\\AnimatedDiffClamp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _get = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/get");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var AnimatedInterpolation = _$$_REQUIRE(_dependencyMap[6], "./AnimatedInterpolation");
+
+ var AnimatedNode = _$$_REQUIRE(_dependencyMap[7], "./AnimatedNode");
+
+ var AnimatedValue = _$$_REQUIRE(_dependencyMap[8], "./AnimatedValue");
+
+ var AnimatedWithChildren = _$$_REQUIRE(_dependencyMap[9], "./AnimatedWithChildren");
+
+ var AnimatedDivision = function (_AnimatedWithChildren) {
+ _inherits(AnimatedDivision, _AnimatedWithChildren);
+
+ function AnimatedDivision(a, b) {
+ var _this;
+
+ _classCallCheck(this, AnimatedDivision);
+
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(AnimatedDivision).call(this));
+ _this._a = typeof a === 'number' ? new AnimatedValue(a) : a;
+ _this._b = typeof b === 'number' ? new AnimatedValue(b) : b;
+ return _this;
+ }
+
+ _createClass(AnimatedDivision, [{
+ key: "__makeNative",
+ value: function __makeNative() {
+ this._a.__makeNative();
+
+ this._b.__makeNative();
+
+ _get(_getPrototypeOf(AnimatedDivision.prototype), "__makeNative", this).call(this);
+ }
+ }, {
+ key: "__getValue",
+ value: function __getValue() {
+ var a = this._a.__getValue();
+
+ var b = this._b.__getValue();
+
+ if (b === 0) {
+ console.error('Detected division by zero in AnimatedDivision');
+ }
+
+ return a / b;
+ }
+ }, {
+ key: "interpolate",
+ value: function interpolate(config) {
+ return new AnimatedInterpolation(this, config);
+ }
+ }, {
+ key: "__attach",
+ value: function __attach() {
+ this._a.__addChild(this);
+
+ this._b.__addChild(this);
+ }
+ }, {
+ key: "__detach",
+ value: function __detach() {
+ this._a.__removeChild(this);
+
+ this._b.__removeChild(this);
+
+ _get(_getPrototypeOf(AnimatedDivision.prototype), "__detach", this).call(this);
+ }
+ }, {
+ key: "__getNativeConfig",
+ value: function __getNativeConfig() {
+ return {
+ type: 'division',
+ input: [this._a.__getNativeTag(), this._b.__getNativeTag()]
+ };
+ }
+ }]);
+
+ return AnimatedDivision;
+ }(AnimatedWithChildren);
+
+ module.exports = AnimatedDivision;
+},250,[3,4,5,8,25,9,241,242,240,244],"node_modules\\react-native\\Libraries\\Animated\\src\\nodes\\AnimatedDivision.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _get = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/get");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var AnimatedInterpolation = _$$_REQUIRE(_dependencyMap[6], "./AnimatedInterpolation");
+
+ var AnimatedNode = _$$_REQUIRE(_dependencyMap[7], "./AnimatedNode");
+
+ var AnimatedWithChildren = _$$_REQUIRE(_dependencyMap[8], "./AnimatedWithChildren");
+
+ var AnimatedModulo = function (_AnimatedWithChildren) {
+ _inherits(AnimatedModulo, _AnimatedWithChildren);
+
+ function AnimatedModulo(a, modulus) {
+ var _this;
+
+ _classCallCheck(this, AnimatedModulo);
+
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(AnimatedModulo).call(this));
+ _this._a = a;
+ _this._modulus = modulus;
+ return _this;
+ }
+
+ _createClass(AnimatedModulo, [{
+ key: "__makeNative",
+ value: function __makeNative() {
+ this._a.__makeNative();
+
+ _get(_getPrototypeOf(AnimatedModulo.prototype), "__makeNative", this).call(this);
+ }
+ }, {
+ key: "__getValue",
+ value: function __getValue() {
+ return (this._a.__getValue() % this._modulus + this._modulus) % this._modulus;
+ }
+ }, {
+ key: "interpolate",
+ value: function interpolate(config) {
+ return new AnimatedInterpolation(this, config);
+ }
+ }, {
+ key: "__attach",
+ value: function __attach() {
+ this._a.__addChild(this);
+ }
+ }, {
+ key: "__detach",
+ value: function __detach() {
+ this._a.__removeChild(this);
+
+ _get(_getPrototypeOf(AnimatedModulo.prototype), "__detach", this).call(this);
+ }
+ }, {
+ key: "__getNativeConfig",
+ value: function __getNativeConfig() {
+ return {
+ type: 'modulus',
+ input: this._a.__getNativeTag(),
+ modulus: this._modulus
+ };
+ }
+ }]);
+
+ return AnimatedModulo;
+ }(AnimatedWithChildren);
+
+ module.exports = AnimatedModulo;
+},251,[3,4,5,8,25,9,241,242,244],"node_modules\\react-native\\Libraries\\Animated\\src\\nodes\\AnimatedModulo.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _get = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/get");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var AnimatedInterpolation = _$$_REQUIRE(_dependencyMap[6], "./AnimatedInterpolation");
+
+ var AnimatedNode = _$$_REQUIRE(_dependencyMap[7], "./AnimatedNode");
+
+ var AnimatedValue = _$$_REQUIRE(_dependencyMap[8], "./AnimatedValue");
+
+ var AnimatedWithChildren = _$$_REQUIRE(_dependencyMap[9], "./AnimatedWithChildren");
+
+ var AnimatedMultiplication = function (_AnimatedWithChildren) {
+ _inherits(AnimatedMultiplication, _AnimatedWithChildren);
+
+ function AnimatedMultiplication(a, b) {
+ var _this;
+
+ _classCallCheck(this, AnimatedMultiplication);
+
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(AnimatedMultiplication).call(this));
+ _this._a = typeof a === 'number' ? new AnimatedValue(a) : a;
+ _this._b = typeof b === 'number' ? new AnimatedValue(b) : b;
+ return _this;
+ }
+
+ _createClass(AnimatedMultiplication, [{
+ key: "__makeNative",
+ value: function __makeNative() {
+ this._a.__makeNative();
+
+ this._b.__makeNative();
+
+ _get(_getPrototypeOf(AnimatedMultiplication.prototype), "__makeNative", this).call(this);
+ }
+ }, {
+ key: "__getValue",
+ value: function __getValue() {
+ return this._a.__getValue() * this._b.__getValue();
+ }
+ }, {
+ key: "interpolate",
+ value: function interpolate(config) {
+ return new AnimatedInterpolation(this, config);
+ }
+ }, {
+ key: "__attach",
+ value: function __attach() {
+ this._a.__addChild(this);
+
+ this._b.__addChild(this);
+ }
+ }, {
+ key: "__detach",
+ value: function __detach() {
+ this._a.__removeChild(this);
+
+ this._b.__removeChild(this);
+
+ _get(_getPrototypeOf(AnimatedMultiplication.prototype), "__detach", this).call(this);
+ }
+ }, {
+ key: "__getNativeConfig",
+ value: function __getNativeConfig() {
+ return {
+ type: 'multiplication',
+ input: [this._a.__getNativeTag(), this._b.__getNativeTag()]
+ };
+ }
+ }]);
+
+ return AnimatedMultiplication;
+ }(AnimatedWithChildren);
+
+ module.exports = AnimatedMultiplication;
+},252,[3,4,5,8,25,9,241,242,240,244],"node_modules\\react-native\\Libraries\\Animated\\src\\nodes\\AnimatedMultiplication.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _get = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/get");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var _require = _$$_REQUIRE(_dependencyMap[7], "../AnimatedEvent"),
+ AnimatedEvent = _require.AnimatedEvent;
+
+ var AnimatedNode = _$$_REQUIRE(_dependencyMap[8], "./AnimatedNode");
+
+ var AnimatedStyle = _$$_REQUIRE(_dependencyMap[9], "./AnimatedStyle");
+
+ var NativeAnimatedHelper = _$$_REQUIRE(_dependencyMap[10], "../NativeAnimatedHelper");
+
+ var ReactNative = _$$_REQUIRE(_dependencyMap[11], "ReactNative");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[12], "invariant");
+
+ var AnimatedProps = function (_AnimatedNode) {
+ _inherits(AnimatedProps, _AnimatedNode);
+
+ function AnimatedProps(props, callback) {
+ var _this;
+
+ _classCallCheck(this, AnimatedProps);
+
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(AnimatedProps).call(this));
+
+ if (props.style) {
+ props = _objectSpread({}, props, {
+ style: new AnimatedStyle(props.style)
+ });
+ }
+
+ _this._props = props;
+ _this._callback = callback;
+
+ _this.__attach();
+
+ return _this;
+ }
+
+ _createClass(AnimatedProps, [{
+ key: "__getValue",
+ value: function __getValue() {
+ var props = {};
+
+ for (var key in this._props) {
+ var value = this._props[key];
+
+ if (value instanceof AnimatedNode) {
+ if (!value.__isNative || value instanceof AnimatedStyle) {
+ props[key] = value.__getValue();
+ }
+ } else if (value instanceof AnimatedEvent) {
+ props[key] = value.__getHandler();
+ } else {
+ props[key] = value;
+ }
+ }
+
+ return props;
+ }
+ }, {
+ key: "__getAnimatedValue",
+ value: function __getAnimatedValue() {
+ var props = {};
+
+ for (var key in this._props) {
+ var value = this._props[key];
+
+ if (value instanceof AnimatedNode) {
+ props[key] = value.__getAnimatedValue();
+ }
+ }
+
+ return props;
+ }
+ }, {
+ key: "__attach",
+ value: function __attach() {
+ for (var key in this._props) {
+ var value = this._props[key];
+
+ if (value instanceof AnimatedNode) {
+ value.__addChild(this);
+ }
+ }
+ }
+ }, {
+ key: "__detach",
+ value: function __detach() {
+ if (this.__isNative && this._animatedView) {
+ this.__disconnectAnimatedView();
+ }
+
+ for (var key in this._props) {
+ var value = this._props[key];
+
+ if (value instanceof AnimatedNode) {
+ value.__removeChild(this);
+ }
+ }
+
+ _get(_getPrototypeOf(AnimatedProps.prototype), "__detach", this).call(this);
+ }
+ }, {
+ key: "update",
+ value: function update() {
+ this._callback();
+ }
+ }, {
+ key: "__makeNative",
+ value: function __makeNative() {
+ if (!this.__isNative) {
+ this.__isNative = true;
+
+ for (var key in this._props) {
+ var value = this._props[key];
+
+ if (value instanceof AnimatedNode) {
+ value.__makeNative();
+ }
+ }
+
+ if (this._animatedView) {
+ this.__connectAnimatedView();
+ }
+ }
+ }
+ }, {
+ key: "setNativeView",
+ value: function setNativeView(animatedView) {
+ if (this._animatedView === animatedView) {
+ return;
+ }
+
+ this._animatedView = animatedView;
+
+ if (this.__isNative) {
+ this.__connectAnimatedView();
+ }
+ }
+ }, {
+ key: "__connectAnimatedView",
+ value: function __connectAnimatedView() {
+ invariant(this.__isNative, 'Expected node to be marked as "native"');
+ var nativeViewTag = ReactNative.findNodeHandle(this._animatedView);
+ invariant(nativeViewTag != null, 'Unable to locate attached view in the native tree');
+ NativeAnimatedHelper.API.connectAnimatedNodeToView(this.__getNativeTag(), nativeViewTag);
+ }
+ }, {
+ key: "__disconnectAnimatedView",
+ value: function __disconnectAnimatedView() {
+ invariant(this.__isNative, 'Expected node to be marked as "native"');
+ var nativeViewTag = ReactNative.findNodeHandle(this._animatedView);
+ invariant(nativeViewTag != null, 'Unable to locate attached view in the native tree');
+ NativeAnimatedHelper.API.disconnectAnimatedNodeFromView(this.__getNativeTag(), nativeViewTag);
+ }
+ }, {
+ key: "__getNativeConfig",
+ value: function __getNativeConfig() {
+ var propsConfig = {};
+
+ for (var propKey in this._props) {
+ var value = this._props[propKey];
+
+ if (value instanceof AnimatedNode) {
+ propsConfig[propKey] = value.__getNativeTag();
+ }
+ }
+
+ return {
+ type: 'props',
+ props: propsConfig
+ };
+ }
+ }]);
+
+ return AnimatedProps;
+ }(AnimatedNode);
+
+ module.exports = AnimatedProps;
+},253,[32,3,4,5,8,25,9,239,242,254,243,84,19],"node_modules\\react-native\\Libraries\\Animated\\src\\nodes\\AnimatedProps.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _get = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/get");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var AnimatedNode = _$$_REQUIRE(_dependencyMap[7], "./AnimatedNode");
+
+ var AnimatedTransform = _$$_REQUIRE(_dependencyMap[8], "./AnimatedTransform");
+
+ var AnimatedWithChildren = _$$_REQUIRE(_dependencyMap[9], "./AnimatedWithChildren");
+
+ var NativeAnimatedHelper = _$$_REQUIRE(_dependencyMap[10], "../NativeAnimatedHelper");
+
+ var flattenStyle = _$$_REQUIRE(_dependencyMap[11], "flattenStyle");
+
+ var AnimatedStyle = function (_AnimatedWithChildren) {
+ _inherits(AnimatedStyle, _AnimatedWithChildren);
+
+ function AnimatedStyle(style) {
+ var _this;
+
+ _classCallCheck(this, AnimatedStyle);
+
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(AnimatedStyle).call(this));
+ style = flattenStyle(style) || {};
+
+ if (style.transform) {
+ style = _objectSpread({}, style, {
+ transform: new AnimatedTransform(style.transform)
+ });
+ }
+
+ _this._style = style;
+ return _this;
+ }
+
+ _createClass(AnimatedStyle, [{
+ key: "_walkStyleAndGetValues",
+ value: function _walkStyleAndGetValues(style) {
+ var updatedStyle = {};
+
+ for (var key in style) {
+ var value = style[key];
+
+ if (value instanceof AnimatedNode) {
+ if (!value.__isNative) {
+ updatedStyle[key] = value.__getValue();
+ }
+ } else if (value && !Array.isArray(value) && typeof value === 'object') {
+ updatedStyle[key] = this._walkStyleAndGetValues(value);
+ } else {
+ updatedStyle[key] = value;
+ }
+ }
+
+ return updatedStyle;
+ }
+ }, {
+ key: "__getValue",
+ value: function __getValue() {
+ return this._walkStyleAndGetValues(this._style);
+ }
+ }, {
+ key: "_walkStyleAndGetAnimatedValues",
+ value: function _walkStyleAndGetAnimatedValues(style) {
+ var updatedStyle = {};
+
+ for (var key in style) {
+ var value = style[key];
+
+ if (value instanceof AnimatedNode) {
+ updatedStyle[key] = value.__getAnimatedValue();
+ } else if (value && !Array.isArray(value) && typeof value === 'object') {
+ updatedStyle[key] = this._walkStyleAndGetAnimatedValues(value);
+ }
+ }
+
+ return updatedStyle;
+ }
+ }, {
+ key: "__getAnimatedValue",
+ value: function __getAnimatedValue() {
+ return this._walkStyleAndGetAnimatedValues(this._style);
+ }
+ }, {
+ key: "__attach",
+ value: function __attach() {
+ for (var key in this._style) {
+ var value = this._style[key];
+
+ if (value instanceof AnimatedNode) {
+ value.__addChild(this);
+ }
+ }
+ }
+ }, {
+ key: "__detach",
+ value: function __detach() {
+ for (var key in this._style) {
+ var value = this._style[key];
+
+ if (value instanceof AnimatedNode) {
+ value.__removeChild(this);
+ }
+ }
+
+ _get(_getPrototypeOf(AnimatedStyle.prototype), "__detach", this).call(this);
+ }
+ }, {
+ key: "__makeNative",
+ value: function __makeNative() {
+ for (var key in this._style) {
+ var value = this._style[key];
+
+ if (value instanceof AnimatedNode) {
+ value.__makeNative();
+ }
+ }
+
+ _get(_getPrototypeOf(AnimatedStyle.prototype), "__makeNative", this).call(this);
+ }
+ }, {
+ key: "__getNativeConfig",
+ value: function __getNativeConfig() {
+ var styleConfig = {};
+
+ for (var styleKey in this._style) {
+ if (this._style[styleKey] instanceof AnimatedNode) {
+ styleConfig[styleKey] = this._style[styleKey].__getNativeTag();
+ }
+ }
+
+ NativeAnimatedHelper.validateStyles(styleConfig);
+ return {
+ type: 'style',
+ style: styleConfig
+ };
+ }
+ }]);
+
+ return AnimatedStyle;
+ }(AnimatedWithChildren);
+
+ module.exports = AnimatedStyle;
+},254,[32,3,4,5,8,25,9,242,255,244,243,80],"node_modules\\react-native\\Libraries\\Animated\\src\\nodes\\AnimatedStyle.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _get = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/get");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var AnimatedNode = _$$_REQUIRE(_dependencyMap[6], "./AnimatedNode");
+
+ var AnimatedWithChildren = _$$_REQUIRE(_dependencyMap[7], "./AnimatedWithChildren");
+
+ var NativeAnimatedHelper = _$$_REQUIRE(_dependencyMap[8], "../NativeAnimatedHelper");
+
+ var AnimatedTransform = function (_AnimatedWithChildren) {
+ _inherits(AnimatedTransform, _AnimatedWithChildren);
+
+ function AnimatedTransform(transforms) {
+ var _this;
+
+ _classCallCheck(this, AnimatedTransform);
+
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(AnimatedTransform).call(this));
+ _this._transforms = transforms;
+ return _this;
+ }
+
+ _createClass(AnimatedTransform, [{
+ key: "__makeNative",
+ value: function __makeNative() {
+ this._transforms.forEach(function (transform) {
+ for (var key in transform) {
+ var value = transform[key];
+
+ if (value instanceof AnimatedNode) {
+ value.__makeNative();
+ }
+ }
+ });
+
+ _get(_getPrototypeOf(AnimatedTransform.prototype), "__makeNative", this).call(this);
+ }
+ }, {
+ key: "__getValue",
+ value: function __getValue() {
+ return this._transforms.map(function (transform) {
+ var result = {};
+
+ for (var key in transform) {
+ var value = transform[key];
+
+ if (value instanceof AnimatedNode) {
+ result[key] = value.__getValue();
+ } else {
+ result[key] = value;
+ }
+ }
+
+ return result;
+ });
+ }
+ }, {
+ key: "__getAnimatedValue",
+ value: function __getAnimatedValue() {
+ return this._transforms.map(function (transform) {
+ var result = {};
+
+ for (var key in transform) {
+ var value = transform[key];
+
+ if (value instanceof AnimatedNode) {
+ result[key] = value.__getAnimatedValue();
+ } else {
+ result[key] = value;
+ }
+ }
+
+ return result;
+ });
+ }
+ }, {
+ key: "__attach",
+ value: function __attach() {
+ var _this2 = this;
+
+ this._transforms.forEach(function (transform) {
+ for (var key in transform) {
+ var value = transform[key];
+
+ if (value instanceof AnimatedNode) {
+ value.__addChild(_this2);
+ }
+ }
+ });
+ }
+ }, {
+ key: "__detach",
+ value: function __detach() {
+ var _this3 = this;
+
+ this._transforms.forEach(function (transform) {
+ for (var key in transform) {
+ var value = transform[key];
+
+ if (value instanceof AnimatedNode) {
+ value.__removeChild(_this3);
+ }
+ }
+ });
+
+ _get(_getPrototypeOf(AnimatedTransform.prototype), "__detach", this).call(this);
+ }
+ }, {
+ key: "__getNativeConfig",
+ value: function __getNativeConfig() {
+ var transConfigs = [];
+
+ this._transforms.forEach(function (transform) {
+ for (var key in transform) {
+ var value = transform[key];
+
+ if (value instanceof AnimatedNode) {
+ transConfigs.push({
+ type: 'animated',
+ property: key,
+ nodeTag: value.__getNativeTag()
+ });
+ } else {
+ transConfigs.push({
+ type: 'static',
+ property: key,
+ value: NativeAnimatedHelper.transformDataType(value)
+ });
+ }
+ }
+ });
+
+ NativeAnimatedHelper.validateTransform(transConfigs);
+ return {
+ type: 'transform',
+ transforms: transConfigs
+ };
+ }
+ }]);
+
+ return AnimatedTransform;
+ }(AnimatedWithChildren);
+
+ module.exports = AnimatedTransform;
+},255,[3,4,5,8,25,9,242,244,243],"node_modules\\react-native\\Libraries\\Animated\\src\\nodes\\AnimatedTransform.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _get = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/get");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var AnimatedInterpolation = _$$_REQUIRE(_dependencyMap[6], "./AnimatedInterpolation");
+
+ var AnimatedNode = _$$_REQUIRE(_dependencyMap[7], "./AnimatedNode");
+
+ var AnimatedValue = _$$_REQUIRE(_dependencyMap[8], "./AnimatedValue");
+
+ var AnimatedWithChildren = _$$_REQUIRE(_dependencyMap[9], "./AnimatedWithChildren");
+
+ var AnimatedSubtraction = function (_AnimatedWithChildren) {
+ _inherits(AnimatedSubtraction, _AnimatedWithChildren);
+
+ function AnimatedSubtraction(a, b) {
+ var _this;
+
+ _classCallCheck(this, AnimatedSubtraction);
+
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(AnimatedSubtraction).call(this));
+ _this._a = typeof a === 'number' ? new AnimatedValue(a) : a;
+ _this._b = typeof b === 'number' ? new AnimatedValue(b) : b;
+ return _this;
+ }
+
+ _createClass(AnimatedSubtraction, [{
+ key: "__makeNative",
+ value: function __makeNative() {
+ this._a.__makeNative();
+
+ this._b.__makeNative();
+
+ _get(_getPrototypeOf(AnimatedSubtraction.prototype), "__makeNative", this).call(this);
+ }
+ }, {
+ key: "__getValue",
+ value: function __getValue() {
+ return this._a.__getValue() - this._b.__getValue();
+ }
+ }, {
+ key: "interpolate",
+ value: function interpolate(config) {
+ return new AnimatedInterpolation(this, config);
+ }
+ }, {
+ key: "__attach",
+ value: function __attach() {
+ this._a.__addChild(this);
+
+ this._b.__addChild(this);
+ }
+ }, {
+ key: "__detach",
+ value: function __detach() {
+ this._a.__removeChild(this);
+
+ this._b.__removeChild(this);
+
+ _get(_getPrototypeOf(AnimatedSubtraction.prototype), "__detach", this).call(this);
+ }
+ }, {
+ key: "__getNativeConfig",
+ value: function __getNativeConfig() {
+ return {
+ type: 'subtraction',
+ input: [this._a.__getNativeTag(), this._b.__getNativeTag()]
+ };
+ }
+ }]);
+
+ return AnimatedSubtraction;
+ }(AnimatedWithChildren);
+
+ module.exports = AnimatedSubtraction;
+},256,[3,4,5,8,25,9,241,242,240,244],"node_modules\\react-native\\Libraries\\Animated\\src\\nodes\\AnimatedSubtraction.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _get = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/get");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var AnimatedValue = _$$_REQUIRE(_dependencyMap[7], "./AnimatedValue");
+
+ var AnimatedNode = _$$_REQUIRE(_dependencyMap[8], "./AnimatedNode");
+
+ var _require = _$$_REQUIRE(_dependencyMap[9], "../NativeAnimatedHelper"),
+ generateNewAnimationId = _require.generateNewAnimationId,
+ shouldUseNativeDriver = _require.shouldUseNativeDriver;
+
+ var AnimatedTracking = function (_AnimatedNode) {
+ _inherits(AnimatedTracking, _AnimatedNode);
+
+ function AnimatedTracking(value, parent, animationClass, animationConfig, callback) {
+ var _this;
+
+ _classCallCheck(this, AnimatedTracking);
+
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(AnimatedTracking).call(this));
+ _this._value = value;
+ _this._parent = parent;
+ _this._animationClass = animationClass;
+ _this._animationConfig = animationConfig;
+ _this._useNativeDriver = shouldUseNativeDriver(animationConfig);
+ _this._callback = callback;
+
+ _this.__attach();
+
+ return _this;
+ }
+
+ _createClass(AnimatedTracking, [{
+ key: "__makeNative",
+ value: function __makeNative() {
+ this.__isNative = true;
+
+ this._parent.__makeNative();
+
+ _get(_getPrototypeOf(AnimatedTracking.prototype), "__makeNative", this).call(this);
+
+ this._value.__makeNative();
+ }
+ }, {
+ key: "__getValue",
+ value: function __getValue() {
+ return this._parent.__getValue();
+ }
+ }, {
+ key: "__attach",
+ value: function __attach() {
+ this._parent.__addChild(this);
+
+ if (this._useNativeDriver) {
+ this.__makeNative();
+ }
+ }
+ }, {
+ key: "__detach",
+ value: function __detach() {
+ this._parent.__removeChild(this);
+
+ _get(_getPrototypeOf(AnimatedTracking.prototype), "__detach", this).call(this);
+ }
+ }, {
+ key: "update",
+ value: function update() {
+ this._value.animate(new this._animationClass(_objectSpread({}, this._animationConfig, {
+ toValue: this._animationConfig.toValue.__getValue()
+ })), this._callback);
+ }
+ }, {
+ key: "__getNativeConfig",
+ value: function __getNativeConfig() {
+ var animation = new this._animationClass(_objectSpread({}, this._animationConfig, {
+ toValue: undefined
+ }));
+
+ var animationConfig = animation.__getNativeAnimationConfig();
+
+ return {
+ type: 'tracking',
+ animationId: generateNewAnimationId(),
+ animationConfig: animationConfig,
+ toValue: this._parent.__getNativeTag(),
+ value: this._value.__getNativeTag()
+ };
+ }
+ }]);
+
+ return AnimatedTracking;
+ }(AnimatedNode);
+
+ module.exports = AnimatedTracking;
+},257,[32,3,4,5,8,25,9,240,242,243],"node_modules\\react-native\\Libraries\\Animated\\src\\nodes\\AnimatedTracking.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var AnimatedValue = _$$_REQUIRE(_dependencyMap[5], "./AnimatedValue");
+
+ var AnimatedWithChildren = _$$_REQUIRE(_dependencyMap[6], "./AnimatedWithChildren");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[7], "invariant");
+
+ var _uniqueId = 1;
+
+ var AnimatedValueXY = function (_AnimatedWithChildren) {
+ _inherits(AnimatedValueXY, _AnimatedWithChildren);
+
+ function AnimatedValueXY(valueIn) {
+ var _this;
+
+ _classCallCheck(this, AnimatedValueXY);
+
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(AnimatedValueXY).call(this));
+ var value = valueIn || {
+ x: 0,
+ y: 0
+ };
+
+ if (typeof value.x === 'number' && typeof value.y === 'number') {
+ _this.x = new AnimatedValue(value.x);
+ _this.y = new AnimatedValue(value.y);
+ } else {
+ invariant(value.x instanceof AnimatedValue && value.y instanceof AnimatedValue, 'AnimatedValueXY must be initialized with an object of numbers or ' + 'AnimatedValues.');
+ _this.x = value.x;
+ _this.y = value.y;
+ }
+
+ _this._listeners = {};
+ return _this;
+ }
+
+ _createClass(AnimatedValueXY, [{
+ key: "setValue",
+ value: function setValue(value) {
+ this.x.setValue(value.x);
+ this.y.setValue(value.y);
+ }
+ }, {
+ key: "setOffset",
+ value: function setOffset(offset) {
+ this.x.setOffset(offset.x);
+ this.y.setOffset(offset.y);
+ }
+ }, {
+ key: "flattenOffset",
+ value: function flattenOffset() {
+ this.x.flattenOffset();
+ this.y.flattenOffset();
+ }
+ }, {
+ key: "extractOffset",
+ value: function extractOffset() {
+ this.x.extractOffset();
+ this.y.extractOffset();
+ }
+ }, {
+ key: "__getValue",
+ value: function __getValue() {
+ return {
+ x: this.x.__getValue(),
+ y: this.y.__getValue()
+ };
+ }
+ }, {
+ key: "resetAnimation",
+ value: function resetAnimation(callback) {
+ this.x.resetAnimation();
+ this.y.resetAnimation();
+ callback && callback(this.__getValue());
+ }
+ }, {
+ key: "stopAnimation",
+ value: function stopAnimation(callback) {
+ this.x.stopAnimation();
+ this.y.stopAnimation();
+ callback && callback(this.__getValue());
+ }
+ }, {
+ key: "addListener",
+ value: function addListener(callback) {
+ var _this2 = this;
+
+ var id = String(_uniqueId++);
+
+ var jointCallback = function jointCallback(_ref) {
+ var number = _ref.value;
+ callback(_this2.__getValue());
+ };
+
+ this._listeners[id] = {
+ x: this.x.addListener(jointCallback),
+ y: this.y.addListener(jointCallback)
+ };
+ return id;
+ }
+ }, {
+ key: "removeListener",
+ value: function removeListener(id) {
+ this.x.removeListener(this._listeners[id].x);
+ this.y.removeListener(this._listeners[id].y);
+ delete this._listeners[id];
+ }
+ }, {
+ key: "removeAllListeners",
+ value: function removeAllListeners() {
+ this.x.removeAllListeners();
+ this.y.removeAllListeners();
+ this._listeners = {};
+ }
+ }, {
+ key: "getLayout",
+ value: function getLayout() {
+ return {
+ left: this.x,
+ top: this.y
+ };
+ }
+ }, {
+ key: "getTranslateTransform",
+ value: function getTranslateTransform() {
+ return [{
+ translateX: this.x
+ }, {
+ translateY: this.y
+ }];
+ }
+ }]);
+
+ return AnimatedValueXY;
+ }(AnimatedWithChildren);
+
+ module.exports = AnimatedValueXY;
+},258,[3,4,5,8,9,240,244,19],"node_modules\\react-native\\Libraries\\Animated\\src\\nodes\\AnimatedValueXY.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _get = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/get");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var Animation = _$$_REQUIRE(_dependencyMap[6], "./Animation");
+
+ var _require = _$$_REQUIRE(_dependencyMap[7], "../NativeAnimatedHelper"),
+ shouldUseNativeDriver = _require.shouldUseNativeDriver;
+
+ var DecayAnimation = function (_Animation) {
+ _inherits(DecayAnimation, _Animation);
+
+ function DecayAnimation(config) {
+ var _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
+ });
+ }
+ }]);
+
+ return DecayAnimation;
+ }(Animation);
+
+ module.exports = DecayAnimation;
+},259,[3,4,5,8,25,9,260,243],"node_modules\\react-native\\Libraries\\Animated\\src\\animations\\DecayAnimation.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var NativeAnimatedHelper = _$$_REQUIRE(_dependencyMap[2], "NativeAnimatedHelper");
+
+ var Animation = function () {
+ function Animation() {
+ _classCallCheck(this, Animation);
+ }
+
+ _createClass(Animation, [{
+ key: "start",
+ value: function start(fromValue, onUpdate, onEnd, previousAnimation, animatedValue) {}
+ }, {
+ key: "stop",
+ value: function stop() {
+ if (this.__nativeId) {
+ NativeAnimatedHelper.API.stopAnimation(this.__nativeId);
+ }
+ }
+ }, {
+ key: "__getNativeAnimationConfig",
+ value: function __getNativeAnimationConfig() {
+ throw new Error('This animation type cannot be offloaded to native');
+ }
+ }, {
+ key: "__debouncedOnEnd",
+ value: function __debouncedOnEnd(result) {
+ var onEnd = this.__onEnd;
+ this.__onEnd = null;
+ onEnd && onEnd(result);
+ }
+ }, {
+ key: "__startNativeAnimation",
+ value: function __startNativeAnimation(animatedValue) {
+ animatedValue.__makeNative();
+
+ this.__nativeId = NativeAnimatedHelper.generateNewAnimationId();
+ NativeAnimatedHelper.API.startAnimatingNode(this.__nativeId, animatedValue.__getNativeTag(), this.__getNativeAnimationConfig(), this.__debouncedOnEnd.bind(this));
+ }
+ }]);
+
+ return Animation;
+ }();
+
+ module.exports = Animation;
+},260,[3,4,243],"node_modules\\react-native\\Libraries\\Animated\\src\\animations\\Animation.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _get = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/get");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var AnimatedValue = _$$_REQUIRE(_dependencyMap[6], "../nodes/AnimatedValue");
+
+ var AnimatedValueXY = _$$_REQUIRE(_dependencyMap[7], "../nodes/AnimatedValueXY");
+
+ var Animation = _$$_REQUIRE(_dependencyMap[8], "./Animation");
+
+ var SpringConfig = _$$_REQUIRE(_dependencyMap[9], "../SpringConfig");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[10], "invariant");
+
+ var _require = _$$_REQUIRE(_dependencyMap[11], "../NativeAnimatedHelper"),
+ shouldUseNativeDriver = _require.shouldUseNativeDriver;
+
+ function withDefault(value, defaultValue) {
+ if (value === undefined || value === null) {
+ return defaultValue;
+ }
+
+ return value;
+ }
+
+ var SpringAnimation = function (_Animation) {
+ _inherits(SpringAnimation, _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
+ });
+ }
+ }]);
+
+ return SpringAnimation;
+ }(Animation);
+
+ module.exports = SpringAnimation;
+},261,[3,4,5,8,25,9,240,258,260,262,19,243],"node_modules\\react-native\\Libraries\\Animated\\src\\animations\\SpringAnimation.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ function stiffnessFromOrigamiValue(oValue) {
+ return (oValue - 30) * 3.62 + 194;
+ }
+
+ function dampingFromOrigamiValue(oValue) {
+ return (oValue - 8) * 3 + 25;
+ }
+
+ function fromOrigamiTensionAndFriction(tension, friction) {
+ return {
+ stiffness: stiffnessFromOrigamiValue(tension),
+ damping: dampingFromOrigamiValue(friction)
+ };
+ }
+
+ function fromBouncinessAndSpeed(bounciness, speed) {
+ function normalize(value, startValue, endValue) {
+ return (value - startValue) / (endValue - startValue);
+ }
+
+ function projectNormal(n, start, end) {
+ return start + n * (end - start);
+ }
+
+ function linearInterpolation(t, start, end) {
+ return t * end + (1 - t) * start;
+ }
+
+ function quadraticOutInterpolation(t, start, end) {
+ return linearInterpolation(2 * t - t * t, start, end);
+ }
+
+ function b3Friction1(x) {
+ return 0.0007 * Math.pow(x, 3) - 0.031 * Math.pow(x, 2) + 0.64 * x + 1.28;
+ }
+
+ function b3Friction2(x) {
+ return 0.000044 * Math.pow(x, 3) - 0.006 * Math.pow(x, 2) + 0.36 * x + 2;
+ }
+
+ function b3Friction3(x) {
+ return 0.00000045 * Math.pow(x, 3) - 0.000332 * Math.pow(x, 2) + 0.1078 * x + 5.84;
+ }
+
+ function b3Nobounce(tension) {
+ if (tension <= 18) {
+ return b3Friction1(tension);
+ } else if (tension > 18 && tension <= 44) {
+ return b3Friction2(tension);
+ } else {
+ return b3Friction3(tension);
+ }
+ }
+
+ var b = normalize(bounciness / 1.7, 0, 20);
+ b = projectNormal(b, 0, 0.8);
+ var s = normalize(speed / 1.7, 0, 20);
+ var bouncyTension = projectNormal(s, 0.5, 200);
+ var bouncyFriction = quadraticOutInterpolation(b, b3Nobounce(bouncyTension), 0.01);
+ return {
+ stiffness: stiffnessFromOrigamiValue(bouncyTension),
+ damping: dampingFromOrigamiValue(bouncyFriction)
+ };
+ }
+
+ module.exports = {
+ fromOrigamiTensionAndFriction: fromOrigamiTensionAndFriction,
+ fromBouncinessAndSpeed: fromBouncinessAndSpeed
+ };
+},262,[],"node_modules\\react-native\\Libraries\\Animated\\src\\SpringConfig.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _get = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/get");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var AnimatedValue = _$$_REQUIRE(_dependencyMap[6], "../nodes/AnimatedValue");
+
+ var AnimatedValueXY = _$$_REQUIRE(_dependencyMap[7], "../nodes/AnimatedValueXY");
+
+ var Animation = _$$_REQUIRE(_dependencyMap[8], "./Animation");
+
+ var _require = _$$_REQUIRE(_dependencyMap[9], "../NativeAnimatedHelper"),
+ shouldUseNativeDriver = _require.shouldUseNativeDriver;
+
+ var _easeInOut;
+
+ function easeInOut() {
+ if (!_easeInOut) {
+ var Easing = _$$_REQUIRE(_dependencyMap[10], "Easing");
+
+ _easeInOut = Easing.inOut(Easing.ease);
+ }
+
+ return _easeInOut;
+ }
+
+ var TimingAnimation = function (_Animation) {
+ _inherits(TimingAnimation, _Animation);
+
+ function TimingAnimation(config) {
+ var _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
+ });
+ }
+ }]);
+
+ return TimingAnimation;
+ }(Animation);
+
+ module.exports = TimingAnimation;
+},263,[3,4,5,8,25,9,240,258,260,243,264],"node_modules\\react-native\\Libraries\\Animated\\src\\animations\\TimingAnimation.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _ease;
+
+ var Easing = function () {
+ function Easing() {
+ _classCallCheck(this, Easing);
+ }
+
+ _createClass(Easing, null, [{
+ key: "step0",
+ value: function step0(n) {
+ return n > 0 ? 1 : 0;
+ }
+ }, {
+ key: "step1",
+ value: function step1(n) {
+ return n >= 1 ? 1 : 0;
+ }
+ }, {
+ key: "linear",
+ value: function linear(t) {
+ return t;
+ }
+ }, {
+ key: "ease",
+ value: function ease(t) {
+ if (!_ease) {
+ _ease = Easing.bezier(0.42, 0, 1, 1);
+ }
+
+ return _ease(t);
+ }
+ }, {
+ key: "quad",
+ value: function quad(t) {
+ return t * t;
+ }
+ }, {
+ key: "cubic",
+ value: function cubic(t) {
+ return t * t * t;
+ }
+ }, {
+ key: "poly",
+ value: function poly(n) {
+ return function (t) {
+ return Math.pow(t, n);
+ };
+ }
+ }, {
+ key: "sin",
+ value: function sin(t) {
+ return 1 - Math.cos(t * Math.PI / 2);
+ }
+ }, {
+ key: "circle",
+ value: function circle(t) {
+ return 1 - Math.sqrt(1 - t * t);
+ }
+ }, {
+ key: "exp",
+ value: function exp(t) {
+ return Math.pow(2, 10 * (t - 1));
+ }
+ }, {
+ key: "elastic",
+ value: function elastic() {
+ var bounciness = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
+ var p = bounciness * Math.PI;
+ return function (t) {
+ return 1 - Math.pow(Math.cos(t * Math.PI / 2), 3) * Math.cos(t * p);
+ };
+ }
+ }, {
+ key: "back",
+ value: function back() {
+ var s = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1.70158;
+ return function (t) {
+ return t * t * ((s + 1) * t - s);
+ };
+ }
+ }, {
+ key: "bounce",
+ value: function bounce(t) {
+ if (t < 1 / 2.75) {
+ return 7.5625 * t * t;
+ }
+
+ if (t < 2 / 2.75) {
+ var _t = t - 1.5 / 2.75;
+
+ return 7.5625 * _t * _t + 0.75;
+ }
+
+ if (t < 2.5 / 2.75) {
+ var _t2 = t - 2.25 / 2.75;
+
+ return 7.5625 * _t2 * _t2 + 0.9375;
+ }
+
+ var t2 = t - 2.625 / 2.75;
+ return 7.5625 * t2 * t2 + 0.984375;
+ }
+ }, {
+ key: "bezier",
+ value: function bezier(x1, y1, x2, y2) {
+ var _bezier = _$$_REQUIRE(_dependencyMap[2], "bezier");
+
+ return _bezier(x1, y1, x2, y2);
+ }
+ }, {
+ key: "in",
+ value: function _in(easing) {
+ return easing;
+ }
+ }, {
+ key: "out",
+ value: function out(easing) {
+ return function (t) {
+ return 1 - easing(1 - t);
+ };
+ }
+ }, {
+ key: "inOut",
+ value: function inOut(easing) {
+ return function (t) {
+ if (t < 0.5) {
+ return easing(t * 2) / 2;
+ }
+
+ return 1 - easing((1 - t) * 2) / 2;
+ };
+ }
+ }]);
+
+ return Easing;
+ }();
+
+ module.exports = Easing;
+},264,[3,4,265],"node_modules\\react-native\\Libraries\\Animated\\src\\Easing.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var NEWTON_ITERATIONS = 4;
+ var NEWTON_MIN_SLOPE = 0.001;
+ var SUBDIVISION_PRECISION = 0.0000001;
+ var SUBDIVISION_MAX_ITERATIONS = 10;
+ var kSplineTableSize = 11;
+ var kSampleStepSize = 1.0 / (kSplineTableSize - 1.0);
+ var float32ArraySupported = typeof Float32Array === 'function';
+
+ function A(aA1, aA2) {
+ return 1.0 - 3.0 * aA2 + 3.0 * aA1;
+ }
+
+ function B(aA1, aA2) {
+ return 3.0 * aA2 - 6.0 * aA1;
+ }
+
+ function C(aA1) {
+ return 3.0 * aA1;
+ }
+
+ function calcBezier(aT, aA1, aA2) {
+ return ((A(aA1, aA2) * aT + B(aA1, aA2)) * aT + C(aA1)) * aT;
+ }
+
+ function getSlope(aT, aA1, aA2) {
+ return 3.0 * A(aA1, aA2) * aT * aT + 2.0 * B(aA1, aA2) * aT + C(aA1);
+ }
+
+ function binarySubdivide(aX, _aA, _aB, mX1, mX2) {
+ var currentX,
+ currentT,
+ i = 0,
+ aA = _aA,
+ aB = _aB;
+
+ do {
+ currentT = aA + (aB - aA) / 2.0;
+ currentX = calcBezier(currentT, mX1, mX2) - aX;
+
+ if (currentX > 0.0) {
+ aB = currentT;
+ } else {
+ aA = currentT;
+ }
+ } while (Math.abs(currentX) > SUBDIVISION_PRECISION && ++i < SUBDIVISION_MAX_ITERATIONS);
+
+ return currentT;
+ }
+
+ function newtonRaphsonIterate(aX, _aGuessT, mX1, mX2) {
+ var aGuessT = _aGuessT;
+
+ for (var i = 0; i < NEWTON_ITERATIONS; ++i) {
+ var currentSlope = getSlope(aGuessT, mX1, mX2);
+
+ if (currentSlope === 0.0) {
+ return aGuessT;
+ }
+
+ var currentX = calcBezier(aGuessT, mX1, mX2) - aX;
+ aGuessT -= currentX / currentSlope;
+ }
+
+ return aGuessT;
+ }
+
+ module.exports = function bezier(mX1, mY1, mX2, mY2) {
+ if (!(mX1 >= 0 && mX1 <= 1 && mX2 >= 0 && mX2 <= 1)) {
+ throw new Error('bezier x values must be in [0, 1] range');
+ }
+
+ var sampleValues = float32ArraySupported ? new Float32Array(kSplineTableSize) : new Array(kSplineTableSize);
+
+ if (mX1 !== mY1 || mX2 !== mY2) {
+ for (var i = 0; i < kSplineTableSize; ++i) {
+ sampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2);
+ }
+ }
+
+ function getTForX(aX) {
+ var intervalStart = 0.0;
+ var currentSample = 1;
+ var lastSample = kSplineTableSize - 1;
+
+ for (; currentSample !== lastSample && sampleValues[currentSample] <= aX; ++currentSample) {
+ intervalStart += kSampleStepSize;
+ }
+
+ --currentSample;
+ var dist = (aX - sampleValues[currentSample]) / (sampleValues[currentSample + 1] - sampleValues[currentSample]);
+ var guessForT = intervalStart + dist * kSampleStepSize;
+ var initialSlope = getSlope(guessForT, mX1, mX2);
+
+ if (initialSlope >= NEWTON_MIN_SLOPE) {
+ return newtonRaphsonIterate(aX, guessForT, mX1, mX2);
+ } else if (initialSlope === 0.0) {
+ return guessForT;
+ } else {
+ return binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize, mX1, mX2);
+ }
+ }
+
+ return function BezierEasing(x) {
+ if (mX1 === mY1 && mX2 === mY2) {
+ return x;
+ }
+
+ if (x === 0) {
+ return 0;
+ }
+
+ if (x === 1) {
+ return 1;
+ }
+
+ return calcBezier(getTForX(x), mY1, mY2);
+ };
+ };
+},265,[],"node_modules\\react-native\\Libraries\\Animated\\src\\bezier.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Animated\\src\\createAnimatedComponent.js";
+
+ var _require = _$$_REQUIRE(_dependencyMap[6], "./AnimatedEvent"),
+ AnimatedEvent = _require.AnimatedEvent;
+
+ var AnimatedProps = _$$_REQUIRE(_dependencyMap[7], "./nodes/AnimatedProps");
+
+ var React = _$$_REQUIRE(_dependencyMap[8], "React");
+
+ var DeprecatedViewStylePropTypes = _$$_REQUIRE(_dependencyMap[9], "DeprecatedViewStylePropTypes");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[10], "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) {
+ _inherits(AnimatedComponent, _React$Component);
+
+ function AnimatedComponent(props) {
+ var _this;
+
+ _classCallCheck(this, AnimatedComponent);
+
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(AnimatedComponent).call(this, props));
+ _this._invokeAnimatedPropsCallbackOnMount = false;
+ _this._eventDetachers = [];
+
+ _this._animatedPropsCallback = function () {
+ if (_this._component == null) {
+ _this._invokeAnimatedPropsCallbackOnMount = true;
+ } else if (AnimatedComponent.__skipSetNativeProps_FOR_TESTS_ONLY || typeof _this._component.setNativeProps !== 'function') {
+ _this.forceUpdate();
+ } else if (!_this._propsAnimated.__isNative) {
+ _this._component.setNativeProps(_this._propsAnimated.__getAnimatedValue());
+ } else {
+ throw new Error('Attempting to run JS driven animation on animated ' + 'node that has been moved to "native" earlier by starting an ' + 'animation with `useNativeDriver: true`');
+ }
+ };
+
+ _this._setComponentRef = function (c) {
+ _this._prevComponent = _this._component;
+ _this._component = c;
+ };
+
+ return _this;
+ }
+
+ _createClass(AnimatedComponent, [{
+ key: "componentWillUnmount",
+ value: function componentWillUnmount() {
+ this._propsAnimated && this._propsAnimated.__detach();
+
+ this._detachNativeEvents();
+ }
+ }, {
+ key: "setNativeProps",
+ value: function setNativeProps(props) {
+ this._component.setNativeProps(props);
+ }
+ }, {
+ key: "UNSAFE_componentWillMount",
+ value: function UNSAFE_componentWillMount() {
+ this._attachProps(this.props);
+ }
+ }, {
+ key: "componentDidMount",
+ value: function componentDidMount() {
+ if (this._invokeAnimatedPropsCallbackOnMount) {
+ this._invokeAnimatedPropsCallbackOnMount = false;
+
+ this._animatedPropsCallback();
+ }
+
+ this._propsAnimated.setNativeView(this._component);
+
+ this._attachNativeEvents();
+ }
+ }, {
+ key: "_attachNativeEvents",
+ value: function _attachNativeEvents() {
+ var _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: 151
+ }
+ }));
+ }
+ }, {
+ key: "getNode",
+ value: function getNode() {
+ return this._component;
+ }
+ }]);
+
+ return AnimatedComponent;
+ }(React.Component);
+
+ AnimatedComponent.__skipSetNativeProps_FOR_TESTS_ONLY = false;
+ var propTypes = Component.propTypes;
+ AnimatedComponent.propTypes = {
+ style: function style(props, propName, componentName) {
+ if (!propTypes) {
+ return;
+ }
+
+ for (var key in DeprecatedViewStylePropTypes) {
+ if (!propTypes[key] && props[key] !== undefined) {
+ console.warn('You are setting the style `{ ' + key + ': ... }` as a prop. You ' + 'should nest it in a style object. ' + 'E.g. `{ style: { ' + key + ': ... } }`');
+ }
+ }
+ }
+ };
+ return AnimatedComponent;
+ }
+
+ module.exports = createAnimatedComponent;
+},266,[14,3,4,5,8,9,239,253,52,74,19],"node_modules\\react-native\\Libraries\\Animated\\src\\createAnimatedComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var FlatList = _$$_REQUIRE(_dependencyMap[0], "FlatList");
+
+ var createAnimatedComponent = _$$_REQUIRE(_dependencyMap[1], "createAnimatedComponent");
+
+ module.exports = createAnimatedComponent(FlatList);
+},267,[268,266],"node_modules\\react-native\\Libraries\\Animated\\src\\components\\AnimatedFlatList.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/createClass");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/defineProperty");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Lists\\FlatList.js";
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var Platform = _$$_REQUIRE(_dependencyMap[7], "Platform");
+
+ var deepDiffer = _$$_REQUIRE(_dependencyMap[8], "deepDiffer");
+
+ var React = _$$_REQUIRE(_dependencyMap[9], "React");
+
+ var View = _$$_REQUIRE(_dependencyMap[10], "View");
+
+ var VirtualizedList = _$$_REQUIRE(_dependencyMap[11], "VirtualizedList");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[12], "StyleSheet");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[13], "invariant");
+
+ var defaultProps = _objectSpread({}, VirtualizedList.defaultProps, {
+ numColumns: 1,
+ removeClippedSubviews: Platform.OS === 'android'
+ });
+
+ var FlatList = function (_React$PureComponent) {
+ _inherits(FlatList, _React$PureComponent);
+
+ _createClass(FlatList, [{
+ key: "scrollToEnd",
+ value: function scrollToEnd(params) {
+ if (this._listRef) {
+ this._listRef.scrollToEnd(params);
+ }
+ }
+ }, {
+ key: "scrollToIndex",
+ value: function scrollToIndex(params) {
+ if (this._listRef) {
+ this._listRef.scrollToIndex(params);
+ }
+ }
+ }, {
+ key: "scrollToItem",
+ value: function scrollToItem(params) {
+ if (this._listRef) {
+ this._listRef.scrollToItem(params);
+ }
+ }
+ }, {
+ key: "scrollToOffset",
+ value: function scrollToOffset(params) {
+ if (this._listRef) {
+ this._listRef.scrollToOffset(params);
+ }
+ }
+ }, {
+ key: "recordInteraction",
+ value: function recordInteraction() {
+ if (this._listRef) {
+ this._listRef.recordInteraction();
+ }
+ }
+ }, {
+ key: "flashScrollIndicators",
+ value: function flashScrollIndicators() {
+ if (this._listRef) {
+ this._listRef.flashScrollIndicators();
+ }
+ }
+ }, {
+ key: "getScrollResponder",
+ value: function getScrollResponder() {
+ if (this._listRef) {
+ return this._listRef.getScrollResponder();
+ }
+ }
+ }, {
+ key: "getScrollableNode",
+ value: function getScrollableNode() {
+ if (this._listRef) {
+ return this._listRef.getScrollableNode();
+ }
+ }
+ }, {
+ key: "setNativeProps",
+ value: function setNativeProps(props) {
+ if (this._listRef) {
+ this._listRef.setNativeProps(props);
+ }
+ }
+ }]);
+
+ function FlatList(props) {
+ var _this;
+
+ _classCallCheck(this, FlatList);
+
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(FlatList).call(this, props));
+ _this._virtualizedListPairs = [];
+
+ _this._captureRef = function (ref) {
+ _this._listRef = ref;
+ };
+
+ _this._getItem = function (data, index) {
+ var numColumns = _this.props.numColumns;
+
+ if (numColumns > 1) {
+ var ret = [];
+
+ for (var kk = 0; kk < numColumns; kk++) {
+ var _item = data[index * numColumns + kk];
+
+ if (_item != null) {
+ ret.push(_item);
+ }
+ }
+
+ return ret;
+ } else {
+ return data[index];
+ }
+ };
+
+ _this._getItemCount = function (data) {
+ return data ? Math.ceil(data.length / _this.props.numColumns) : 0;
+ };
+
+ _this._keyExtractor = function (items, index) {
+ var _this$props = _this.props,
+ keyExtractor = _this$props.keyExtractor,
+ numColumns = _this$props.numColumns;
+
+ if (numColumns > 1) {
+ invariant(Array.isArray(items), 'FlatList: Encountered internal consistency error, expected each item to consist of an ' + 'array with 1-%s columns; instead, received a single item.', numColumns);
+ return items.map(function (it, kk) {
+ return keyExtractor(it, index * numColumns + kk);
+ }).join(':');
+ } else {
+ return keyExtractor(items, index);
+ }
+ };
+
+ _this._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,
+ isSelected = info.isSelected;
+ 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: 610
+ }
+ }, _item2.map(function (it, kk) {
+ var element = renderItem({
+ item: it,
+ index: _index * numColumns + kk,
+ isSelected: isSelected,
+ 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(!deepDiffer(prevProps.viewabilityConfig, this.props.viewabilityConfig), 'Changing viewabilityConfig on the fly is not supported');
+ invariant(prevProps.viewabilityConfigCallbackPairs === this.props.viewabilityConfigCallbackPairs, 'Changing viewabilityConfigCallbackPairs on the fly is not supported');
+
+ this._checkProps(this.props);
+ }
+ }, {
+ key: "_checkProps",
+ value: function _checkProps(props) {
+ var getItem = props.getItem,
+ getItemCount = props.getItemCount,
+ horizontal = props.horizontal,
+ numColumns = props.numColumns,
+ columnWrapperStyle = props.columnWrapperStyle,
+ onViewableItemsChanged = props.onViewableItemsChanged,
+ viewabilityConfigCallbackPairs = props.viewabilityConfigCallbackPairs;
+ invariant(!getItem && !getItemCount, 'FlatList does not support custom data formats.');
+
+ if (numColumns > 1) {
+ invariant(!horizontal, 'numColumns does not support horizontal.');
+ } else {
+ invariant(!columnWrapperStyle, 'columnWrapperStyle not supported for single column lists');
+ }
+
+ invariant(!(onViewableItemsChanged && viewabilityConfigCallbackPairs), 'FlatList does not support setting both onViewableItemsChanged and ' + 'viewabilityConfigCallbackPairs.');
+ }
+ }, {
+ key: "_pushMultiColumnViewable",
+ value: function _pushMultiColumnViewable(arr, v) {
+ var _this$props3 = this.props,
+ numColumns = _this$props3.numColumns,
+ keyExtractor = _this$props3.keyExtractor;
+ v.item.forEach(function (item, ii) {
+ invariant(v.index != null, 'Missing index!');
+ var index = v.index * numColumns + ii;
+ arr.push(_objectSpread({}, v, {
+ item: item,
+ key: keyExtractor(item, index),
+ index: index
+ }));
+ });
+ }
+ }, {
+ key: "_createOnViewableItemsChanged",
+ value: function _createOnViewableItemsChanged(onViewableItemsChanged) {
+ var _this2 = this;
+
+ return function (info) {
+ var numColumns = _this2.props.numColumns;
+
+ if (onViewableItemsChanged) {
+ if (numColumns > 1) {
+ var changed = [];
+ var viewableItems = [];
+ info.viewableItems.forEach(function (v) {
+ return _this2._pushMultiColumnViewable(viewableItems, v);
+ });
+ info.changed.forEach(function (v) {
+ return _this2._pushMultiColumnViewable(changed, v);
+ });
+ onViewableItemsChanged({
+ viewableItems: viewableItems,
+ changed: changed
+ });
+ } else {
+ onViewableItemsChanged(info);
+ }
+ }
+ };
+ }
+ }, {
+ key: "render",
+ value: function render() {
+ return React.createElement(VirtualizedList, _extends({}, this.props, {
+ renderItem: this._renderItem,
+ getItem: this._getItem,
+ getItemCount: this._getItemCount,
+ keyExtractor: this._keyExtractor,
+ ref: this._captureRef,
+ viewabilityConfigCallbackPairs: this._virtualizedListPairs,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 633
+ }
+ }));
+ }
+ }]);
+
+ return FlatList;
+ }(React.PureComponent);
+
+ FlatList.defaultProps = defaultProps;
+ var styles = StyleSheet.create({
+ row: {
+ flexDirection: 'row'
+ }
+ });
+ module.exports = FlatList;
+},268,[14,3,5,8,4,9,32,35,175,52,81,269,53,19],"node_modules\\react-native\\Libraries\\Lists\\FlatList.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/defineProperty");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _assertThisInitialized = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/assertThisInitialized");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/createClass");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Lists\\VirtualizedList.js";
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var Batchinator = _$$_REQUIRE(_dependencyMap[8], "Batchinator");
+
+ var FillRateHelper = _$$_REQUIRE(_dependencyMap[9], "FillRateHelper");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[10], "Platform");
+
+ var PropTypes = _$$_REQUIRE(_dependencyMap[11], "prop-types");
+
+ var React = _$$_REQUIRE(_dependencyMap[12], "React");
+
+ var ReactNative = _$$_REQUIRE(_dependencyMap[13], "ReactNative");
+
+ var RefreshControl = _$$_REQUIRE(_dependencyMap[14], "RefreshControl");
+
+ var ScrollView = _$$_REQUIRE(_dependencyMap[15], "ScrollView");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[16], "StyleSheet");
+
+ var UIManager = _$$_REQUIRE(_dependencyMap[17], "UIManager");
+
+ var View = _$$_REQUIRE(_dependencyMap[18], "View");
+
+ var ViewabilityHelper = _$$_REQUIRE(_dependencyMap[19], "ViewabilityHelper");
+
+ var flattenStyle = _$$_REQUIRE(_dependencyMap[20], "flattenStyle");
+
+ var infoLog = _$$_REQUIRE(_dependencyMap[21], "infoLog");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[22], "invariant");
+
+ var warning = _$$_REQUIRE(_dependencyMap[23], "fbjs/lib/warning");
+
+ var _require = _$$_REQUIRE(_dependencyMap[24], "VirtualizeUtils"),
+ computeWindowedRenderLimits = _require.computeWindowedRenderLimits;
+
+ var _usedIndexForKey = false;
+ var _keylessItemComponentName = '';
+
+ var VirtualizedList = function (_React$PureComponent) {
+ _inherits(VirtualizedList, _React$PureComponent);
+
+ _createClass(VirtualizedList, [{
+ key: "scrollToEnd",
+ value: function scrollToEnd(params) {
+ var animated = params ? params.animated : true;
+ var veryLast = this.props.getItemCount(this.props.data) - 1;
+
+ var frame = this._getFrameMetricsApprox(veryLast);
+
+ var offset = Math.max(0, frame.offset + frame.length + this._footerLength - this._scrollMetrics.visibleLength);
+
+ this._scrollRef.scrollTo(this.props.horizontal ? {
+ x: offset,
+ animated: animated
+ } : {
+ y: offset,
+ animated: animated
+ });
+ }
+ }, {
+ key: "scrollToIndex",
+ value: function scrollToIndex(params) {
+ var _this$props = this.props,
+ data = _this$props.data,
+ horizontal = _this$props.horizontal,
+ getItemCount = _this$props.getItemCount,
+ getItemLayout = _this$props.getItemLayout,
+ onScrollToIndexFailed = _this$props.onScrollToIndexFailed;
+ var animated = params.animated,
+ index = params.index,
+ viewOffset = params.viewOffset,
+ viewPosition = params.viewPosition;
+ invariant(index >= 0 && index < getItemCount(data), "scrollToIndex out of range: " + 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.ensureItemAtIndexIsVisible = function (rowIndex) {
+ var frame = _this._getFrameMetricsApprox(rowIndex);
+
+ var visTop = _this._scrollMetrics.offset;
+ var visLen = _this._scrollMetrics.visibleLength;
+ var visEnd = visTop + visLen;
+ var contentLength = _this._scrollMetrics.contentLength;
+ var frameEnd = frame.offset + frame.length;
+
+ if (frameEnd > visEnd) {
+ var newOffset = Math.min(contentLength, visTop + (frameEnd - visEnd));
+
+ _this.scrollToOffset({
+ offset: newOffset
+ });
+ } else if (frame.offset < visTop) {
+ var _newOffset = Math.max(0, visTop - frame.length);
+
+ _this.scrollToOffset({
+ offset: _newOffset
+ });
+ }
+ };
+
+ _this._getScrollMetrics = function () {
+ return _this._scrollMetrics;
+ };
+
+ _this._getOutermostParentListRef = function () {
+ if (_this._isNestedWithSameOrientation()) {
+ return _this.context.virtualizedList.getOutermostParentListRef();
+ } else {
+ return _assertThisInitialized(_this);
+ }
+ };
+
+ _this._getNestedChildState = function (key) {
+ var existingChildData = _this._nestedChildLists.get(key);
+
+ return existingChildData && existingChildData.state;
+ };
+
+ _this._registerAsNestedChild = function (childList) {
+ var childListsInCell = _this._cellKeysToChildListKeys.get(childList.cellKey) || new Set();
+ childListsInCell.add(childList.key);
+
+ _this._cellKeysToChildListKeys.set(childList.cellKey, childListsInCell);
+
+ var existingChildData = _this._nestedChildLists.get(childList.key);
+
+ 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 keyEventHandler = _this.props.onKeyDown;
+
+ if (!keyEventHandler) {
+ keyEventHandler = _this.props.enableSelectionOnKeyPress ? _this._handleKeyDown : null;
+ }
+
+ var onRefresh = props.onRefresh;
+
+ if (_this._isNestedWithSameOrientation()) {
+ return React.createElement(View, _extends({}, props, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 1095
+ }
+ }));
+ } 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, {
+ onKeyDown: keyEventHandler,
+ refreshControl: props.refreshControl == null ? React.createElement(RefreshControl, {
+ refreshing: props.refreshing,
+ onRefresh: onRefresh,
+ progressViewOffset: props.progressViewOffset,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 1110
+ }
+ }) : props.refreshControl,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 1105
+ }
+ }));
+ } else {
+ return React.createElement(ScrollView, _extends({}, props, {
+ onKeyDown: keyEventHandler,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 1123
+ }
+ }));
+ }
+ };
+
+ _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._selectRowAboveIndex = function (rowIndex) {
+ var rowAbove = rowIndex > 0 ? rowIndex - 1 : rowIndex;
+
+ _this.setState(function (state) {
+ return {
+ selectedRowIndex: rowAbove
+ };
+ });
+
+ return rowAbove;
+ };
+
+ _this._selectRowBelowIndex = function (rowIndex) {
+ if (_this.props.getItemCount) {
+ var _data = _this.props.data;
+
+ var itemCount = _this.props.getItemCount(_data);
+
+ var rowBelow = rowIndex < itemCount - 1 ? rowIndex + 1 : rowIndex;
+
+ _this.setState(function (state) {
+ return {
+ selectedRowIndex: rowBelow
+ };
+ });
+
+ return rowBelow;
+ } else {
+ return rowIndex;
+ }
+ };
+
+ _this._handleKeyDown = function (e) {
+ if (_this.props.onKeyDown) {
+ _this.props.onKeyDown(e);
+ } else {
+ if (Platform.OS === 'macos') {
+ var _event = e.nativeEvent;
+ var _key = _event.key;
+ var prevIndex = -1;
+ var newIndex = -1;
+
+ if ('selectedRowIndex' in _this.state) {
+ prevIndex = _this.state.selectedRowIndex;
+ }
+
+ var _this$props3 = _this.props,
+ _data2 = _this$props3.data,
+ getItem = _this$props3.getItem;
+
+ if (_key === 'DOWN_ARROW') {
+ newIndex = _this._selectRowBelowIndex(prevIndex);
+
+ _this.ensureItemAtIndexIsVisible(newIndex);
+
+ if (_this.props.onSelectionChanged && prevIndex != newIndex) {
+ var _item = getItem(_data2, newIndex);
+
+ _this.props.onSelectionChanged({
+ previousSelection: prevIndex,
+ newSelection: newIndex,
+ item: _item
+ });
+ }
+ } else if (_key === 'UP_ARROW') {
+ newIndex = _this._selectRowAboveIndex(prevIndex);
+
+ _this.ensureItemAtIndexIsVisible(newIndex);
+
+ if (_this.props.onSelectionChanged && prevIndex != newIndex) {
+ var _item2 = getItem(_data2, newIndex);
+
+ _this.props.onSelectionChanged({
+ previousSelection: prevIndex,
+ newSelection: newIndex,
+ item: _item2
+ });
+ }
+ } else if (_key === 'ENTER') {
+ if (_this.props.onSelectionEntered) {
+ var _item3 = getItem(_data2, prevIndex);
+
+ _this.props.onSelectionEntered(_item3);
+ }
+ }
+ }
+ }
+ };
+
+ _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$props4 = _this.props,
+ data = _this$props4.data,
+ getItemCount = _this$props4.getItemCount,
+ onEndReachedThreshold = _this$props4.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$props5 = _this.props,
+ data = _this$props5.data,
+ getItem = _this$props5.getItem,
+ keyExtractor = _this$props5.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$props6 = _this.props,
+ data = _this$props6.data,
+ getItem = _this$props6.getItem,
+ getItemCount = _this$props6.getItemCount,
+ getItemLayout = _this$props6.getItemLayout,
+ keyExtractor = _this$props6.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,
+ selectedRowIndex: 0
+ };
+
+ 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$props7 = this.props,
+ CellRendererComponent = _this$props7.CellRendererComponent,
+ ItemSeparatorComponent = _this$props7.ItemSeparatorComponent,
+ data = _this$props7.data,
+ getItem = _this$props7.getItem,
+ getItemCount = _this$props7.getItemCount,
+ horizontal = _this$props7.horizontal,
+ keyExtractor = _this$props7.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,
+ isSelected: _this2.state.selectedRowIndex == ii ? true : false,
+ key: key,
+ prevCellKey: prevCellKey,
+ onUpdateSeparators: _this2._onUpdateSeparators,
+ onLayout: function onLayout(e) {
+ return _this2._onCellLayout(e, key, ii);
+ },
+ onUnmount: _this2._onCellUnmount,
+ parentProps: _this2.props,
+ ref: function ref(_ref2) {
+ _this2._cellRefs[key] = _ref2;
+ },
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 738
+ }
+ }));
+ 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$props8 = this.props,
+ ListEmptyComponent = _this$props8.ListEmptyComponent,
+ ListFooterComponent = _this$props8.ListFooterComponent,
+ ListHeaderComponent = _this$props8.ListHeaderComponent;
+ var _this$props9 = this.props,
+ data = _this$props9.data,
+ horizontal = _this$props9.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: 813
+ }
+ });
+ cells.push(React.createElement(VirtualizedCellWrapper, {
+ cellKey: this._getCellKey() + '-header',
+ key: "$header",
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 816
+ }
+ }, React.createElement(View, {
+ onLayout: this._onLayoutHeader,
+ style: StyleSheet.compose(inversionStyle, this.props.ListHeaderComponentStyle),
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 819
+ }
+ }, element)));
+ }
+
+ var itemCount = this.props.getItemCount(data);
+
+ if (itemCount > 0) {
+ _usedIndexForKey = false;
+ _keylessItemComponentName = '';
+ var spacerKey = !horizontal ? 'height' : 'width';
+ var lastInitialIndex = this.props.initialScrollIndex ? -1 : this.props.initialNumToRender - 1;
+ var _this$state = this.state,
+ first = _this$state.first,
+ last = _this$state.last;
+
+ this._pushCells(cells, stickyHeaderIndices, stickyIndicesFromProps, 0, lastInitialIndex, inversionStyle);
+
+ var firstAfterInitial = Math.max(lastInitialIndex + 1, first);
+
+ if (!isVirtualizationDisabled && first > lastInitialIndex + 1) {
+ var insertedStickySpacer = false;
+
+ if (stickyIndicesFromProps.size > 0) {
+ var stickyOffset = ListHeaderComponent ? 1 : 0;
+
+ for (var ii = firstAfterInitial - 1; ii > lastInitialIndex; ii--) {
+ if (stickyIndicesFromProps.has(ii + stickyOffset)) {
+ var initBlock = this._getFrameMetricsApprox(lastInitialIndex);
+
+ var stickyBlock = this._getFrameMetricsApprox(ii);
+
+ var leadSpace = stickyBlock.offset - initBlock.offset - (this.props.initialScrollIndex ? 0 : initBlock.length);
+ cells.push(React.createElement(View, {
+ key: "$sticky_lead",
+ style: _defineProperty({}, spacerKey, leadSpace),
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 865
+ }
+ }));
+
+ 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: 879
+ }
+ }));
+ 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: 892
+ }
+ }));
+ }
+ }
+
+ 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: 926
+ }
+ }));
+ }
+ } else if (ListEmptyComponent) {
+ var _element = React.isValidElement(ListEmptyComponent) ? ListEmptyComponent : React.createElement(ListEmptyComponent, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 936
+ }
+ });
+
+ 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: 956
+ }
+ });
+
+ cells.push(React.createElement(VirtualizedCellWrapper, {
+ cellKey: this._getCellKey() + '-footer',
+ key: "$footer",
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 959
+ }
+ }, React.createElement(View, {
+ onLayout: this._onLayoutFooter,
+ style: StyleSheet.compose(inversionStyle, this.props.ListFooterComponentStyle),
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 962
+ }
+ }, _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 && itemCount !== 0) {
+ 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: styles.debug,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 1012
+ }
+ }, ret, this._renderDebugOverlay());
+ } else {
+ return ret;
+ }
+ }
+ }, {
+ key: "componentDidUpdate",
+ value: function componentDidUpdate(prevProps) {
+ var _this$props10 = this.props,
+ data = _this$props10.data,
+ extraData = _this$props10.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;
+
+ try {
+ 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;
+ });
+ } catch (error) {
+ console.warn('measureLayoutRelativeToContainingList threw an error', error.stack);
+ }
+ }
+ }, {
+ 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;
+ return React.createElement(View, {
+ style: [styles.debugOverlayBase, styles.debugOverlay],
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 1334
+ }
+ }, framesInLayout.map(function (f, ii) {
+ return React.createElement(View, {
+ key: 'f' + ii,
+ style: [styles.debugOverlayBase, styles.debugOverlayFrame, {
+ top: f.offset * normalize,
+ height: f.length * normalize
+ }],
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 1336
+ }
+ });
+ }), React.createElement(View, {
+ style: [styles.debugOverlayBase, styles.debugOverlayFrameLast, {
+ top: windowTop * normalize,
+ height: windowLen * normalize
+ }],
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 1348
+ }
+ }), React.createElement(View, {
+ style: [styles.debugOverlayBase, styles.debugOverlayFrameVis, {
+ top: visTop * normalize,
+ height: visLen * normalize
+ }],
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 1358
+ }
+ }));
+ }
+ }, {
+ key: "_selectLength",
+ value: function _selectLength(metrics) {
+ return !this.props.horizontal ? metrics.height : metrics.width;
+ }
+ }, {
+ key: "_selectOffset",
+ value: function _selectOffset(metrics) {
+ return !this.props.horizontal ? metrics.y : metrics.x;
+ }
+ }, {
+ key: "_maybeCallOnEndReached",
+ value: function _maybeCallOnEndReached() {
+ var _this$props11 = this.props,
+ data = _this$props11.data,
+ getItemCount = _this$props11.getItemCount,
+ onEndReached = _this$props11.onEndReached,
+ onEndReachedThreshold = _this$props11.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,
+ getItemCount = newProps.getItemCount,
+ maxToRenderPerBatch = newProps.maxToRenderPerBatch;
+ return {
+ first: Math.max(0, Math.min(prevState.first, getItemCount(data) - 1 - maxToRenderPerBatch)),
+ last: Math.max(0, Math.min(prevState.last, getItemCount(data) - 1))
+ };
+ }
+ }]);
+
+ return VirtualizedList;
+ }(React.PureComponent);
+
+ VirtualizedList.defaultProps = {
+ disableVirtualization: false,
+ horizontal: false,
+ initialNumToRender: 10,
+ keyExtractor: function keyExtractor(item, index) {
+ if (item.key != null) {
+ return item.key;
+ }
+
+ _usedIndexForKey = true;
+
+ if (item.type && item.type.displayName) {
+ _keylessItemComponentName = item.type.displayName;
+ }
+
+ return String(index);
+ },
+ maxToRenderPerBatch: 10,
+ onEndReachedThreshold: 2,
+ scrollEventThrottle: 50,
+ updateCellsBatchingPeriod: 50,
+ windowSize: 21
+ };
+ VirtualizedList.contextTypes = {
+ virtualizedCell: PropTypes.shape({
+ cellKey: PropTypes.string
+ }),
+ virtualizedList: PropTypes.shape({
+ getScrollMetrics: PropTypes.func,
+ horizontal: PropTypes.bool,
+ getOutermostParentListRef: PropTypes.func,
+ getNestedChildState: PropTypes.func,
+ registerAsNestedChild: PropTypes.func,
+ unregisterAsNestedChild: PropTypes.func
+ })
+ };
+ VirtualizedList.childContextTypes = {
+ virtualizedList: PropTypes.shape({
+ getScrollMetrics: PropTypes.func,
+ horizontal: PropTypes.bool,
+ getOutermostParentListRef: PropTypes.func,
+ getNestedChildState: PropTypes.func,
+ registerAsNestedChild: PropTypes.func,
+ unregisterAsNestedChild: PropTypes.func
+ })
+ };
+
+ var CellRenderer = function (_React$Component) {
+ _inherits(CellRenderer, _React$Component);
+
+ function CellRenderer() {
+ var _getPrototypeOf2;
+
+ var _this6;
+
+ _classCallCheck(this, CellRenderer);
+
+ for (var _len = arguments.length, args = new Array(_len), _key2 = 0; _key2 < _len; _key2++) {
+ args[_key2] = arguments[_key2];
+ }
+
+ _this6 = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(CellRenderer)).call.apply(_getPrototypeOf2, [this].concat(args)));
+ _this6.state = {
+ separatorProps: {
+ highlighted: false,
+ leadingItem: _this6.props.item
+ }
+ };
+ _this6._separators = {
+ highlight: function highlight() {
+ var _this6$props = _this6.props,
+ cellKey = _this6$props.cellKey,
+ prevCellKey = _this6$props.prevCellKey;
+
+ _this6.props.onUpdateSeparators([cellKey, prevCellKey], {
+ highlighted: true
+ });
+ },
+ unhighlight: function unhighlight() {
+ var _this6$props2 = _this6.props,
+ cellKey = _this6$props2.cellKey,
+ prevCellKey = _this6$props2.prevCellKey;
+
+ _this6.props.onUpdateSeparators([cellKey, prevCellKey], {
+ highlighted: false
+ });
+ },
+ updateProps: function updateProps(select, newProps) {
+ var _this6$props3 = _this6.props,
+ cellKey = _this6$props3.cellKey,
+ prevCellKey = _this6$props3.prevCellKey;
+
+ _this6.props.onUpdateSeparators([select === 'leading' ? prevCellKey : cellKey], newProps);
+ }
+ };
+ return _this6;
+ }
+
+ _createClass(CellRenderer, [{
+ key: "getChildContext",
+ value: function getChildContext() {
+ return {
+ virtualizedCell: {
+ cellKey: this.props.cellKey
+ }
+ };
+ }
+ }, {
+ key: "updateSeparatorProps",
+ value: function updateSeparatorProps(newProps) {
+ this.setState(function (state) {
+ return {
+ separatorProps: _objectSpread({}, state.separatorProps, {}, newProps)
+ };
+ });
+ }
+ }, {
+ key: "componentWillUnmount",
+ value: function componentWillUnmount() {
+ this.props.onUnmount(this.props.cellKey);
+ }
+ }, {
+ key: "render",
+ value: function render() {
+ var _this$props12 = this.props,
+ CellRendererComponent = _this$props12.CellRendererComponent,
+ ItemSeparatorComponent = _this$props12.ItemSeparatorComponent,
+ fillRateHelper = _this$props12.fillRateHelper,
+ horizontal = _this$props12.horizontal,
+ item = _this$props12.item,
+ index = _this$props12.index,
+ inversionStyle = _this$props12.inversionStyle,
+ isSelected = _this$props12.isSelected,
+ parentProps = _this$props12.parentProps;
+ var renderItem = parentProps.renderItem,
+ getItemLayout = parentProps.getItemLayout;
+ invariant(renderItem, 'no renderItem!');
+ var element = renderItem({
+ item: item,
+ index: index,
+ isSelected: isSelected,
+ 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: 1861
+ }
+ }));
+ 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: 1875
+ }
+ }, element, itemSeparator);
+ }
+
+ return React.createElement(CellRendererComponent, _extends({}, this.props, {
+ style: cellStyle,
+ onLayout: onLayout,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 1882
+ }
+ }), element, itemSeparator);
+ }
+ }]);
+
+ return CellRenderer;
+ }(React.Component);
+
+ CellRenderer.childContextTypes = {
+ virtualizedCell: PropTypes.shape({
+ cellKey: PropTypes.string
+ })
+ };
+
+ var VirtualizedCellWrapper = function (_React$Component2) {
+ _inherits(VirtualizedCellWrapper, _React$Component2);
+
+ function VirtualizedCellWrapper() {
+ _classCallCheck(this, VirtualizedCellWrapper);
+
+ return _possibleConstructorReturn(this, _getPrototypeOf(VirtualizedCellWrapper).apply(this, arguments));
+ }
+
+ _createClass(VirtualizedCellWrapper, [{
+ key: "getChildContext",
+ value: function getChildContext() {
+ return {
+ virtualizedCell: {
+ cellKey: this.props.cellKey
+ }
+ };
+ }
+ }, {
+ key: "render",
+ value: function render() {
+ return this.props.children;
+ }
+ }]);
+
+ return VirtualizedCellWrapper;
+ }(React.Component);
+
+ VirtualizedCellWrapper.childContextTypes = {
+ virtualizedCell: PropTypes.shape({
+ cellKey: PropTypes.string
+ })
+ };
+ var styles = StyleSheet.create({
+ verticallyInverted: {
+ transform: [{
+ scaleY: -1
+ }]
+ },
+ horizontallyInverted: {
+ transform: [{
+ scaleX: -1
+ }]
+ },
+ debug: {
+ flex: 1
+ },
+ debugOverlayBase: {
+ position: 'absolute',
+ top: 0,
+ right: 0
+ },
+ debugOverlay: {
+ bottom: 0,
+ width: 20,
+ borderColor: 'blue',
+ borderWidth: 1
+ },
+ debugOverlayFrame: {
+ left: 0,
+ backgroundColor: 'orange'
+ },
+ debugOverlayFrameLast: {
+ left: 0,
+ borderColor: 'green',
+ borderWidth: 2
+ },
+ debugOverlayFrameVis: {
+ left: 0,
+ borderColor: 'red',
+ borderWidth: 2
+ }
+ });
+ module.exports = VirtualizedList;
+},269,[14,32,3,5,8,7,4,9,270,271,35,62,52,84,272,275,53,71,81,284,80,157,19,21,285],"node_modules\\react-native\\Libraries\\Lists\\VirtualizedList.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var InteractionManager = _$$_REQUIRE(_dependencyMap[2], "InteractionManager");
+
+ var Batchinator = function () {
+ function Batchinator(callback, delayMS) {
+ _classCallCheck(this, Batchinator);
+
+ this._delay = delayMS;
+ this._callback = callback;
+ }
+
+ _createClass(Batchinator, [{
+ key: "dispose",
+ value: function dispose() {
+ var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
+ abort: false
+ };
+
+ if (this._taskHandle) {
+ this._taskHandle.cancel();
+
+ if (!options.abort) {
+ this._callback();
+ }
+
+ this._taskHandle = null;
+ }
+ }
+ }, {
+ key: "schedule",
+ value: function schedule() {
+ var _this = this;
+
+ if (this._taskHandle) {
+ return;
+ }
+
+ var timeoutHandle = setTimeout(function () {
+ _this._taskHandle = InteractionManager.runAfterInteractions(function () {
+ _this._taskHandle = null;
+
+ _this._callback();
+ });
+ }, this._delay);
+ this._taskHandle = {
+ cancel: function cancel() {
+ return clearTimeout(timeoutHandle);
+ }
+ };
+ }
+ }]);
+
+ return Batchinator;
+ }();
+
+ module.exports = Batchinator;
+},270,[3,4,245],"node_modules\\react-native\\Libraries\\Interaction\\Batchinator.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var performanceNow = _$$_REQUIRE(_dependencyMap[3], "fbjs/lib/performanceNow");
+
+ var warning = _$$_REQUIRE(_dependencyMap[4], "fbjs/lib/warning");
+
+ var Info = function Info() {
+ _classCallCheck(this, Info);
+
+ this.any_blank_count = 0;
+ this.any_blank_ms = 0;
+ this.any_blank_speed_sum = 0;
+ this.mostly_blank_count = 0;
+ this.mostly_blank_ms = 0;
+ this.pixels_blank = 0;
+ this.pixels_sampled = 0;
+ this.pixels_scrolled = 0;
+ this.total_time_spent = 0;
+ this.sample_count = 0;
+ };
+
+ var DEBUG = false;
+ var _listeners = [];
+ var _minSampleCount = 10;
+
+ var _sampleRate = DEBUG ? 1 : null;
+
+ var FillRateHelper = function () {
+ _createClass(FillRateHelper, null, [{
+ key: "addListener",
+ value: function addListener(callback) {
+ warning(_sampleRate !== null, 'Call `FillRateHelper.setSampleRate` before `addListener`.');
+
+ _listeners.push(callback);
+
+ return {
+ remove: function remove() {
+ _listeners = _listeners.filter(function (listener) {
+ return callback !== listener;
+ });
+ }
+ };
+ }
+ }, {
+ key: "setSampleRate",
+ value: function setSampleRate(sampleRate) {
+ _sampleRate = sampleRate;
+ }
+ }, {
+ key: "setMinSampleCount",
+ value: function setMinSampleCount(minSampleCount) {
+ _minSampleCount = minSampleCount;
+ }
+ }]);
+
+ function FillRateHelper(getFrameMetrics) {
+ _classCallCheck(this, FillRateHelper);
+
+ this._anyBlankStartTime = null;
+ this._enabled = false;
+ this._info = new Info();
+ this._mostlyBlankStartTime = null;
+ this._samplesStartTime = null;
+ this._getFrameMetrics = getFrameMetrics;
+ this._enabled = (_sampleRate || 0) > Math.random();
+
+ this._resetData();
+ }
+
+ _createClass(FillRateHelper, [{
+ key: "activate",
+ value: function activate() {
+ if (this._enabled && this._samplesStartTime == null) {
+ DEBUG && console.debug('FillRateHelper: activate');
+ this._samplesStartTime = performanceNow();
+ }
+ }
+ }, {
+ key: "deactivateAndFlush",
+ value: function deactivateAndFlush() {
+ if (!this._enabled) {
+ return;
+ }
+
+ var start = this._samplesStartTime;
+
+ if (start == null) {
+ DEBUG && console.debug('FillRateHelper: bail on deactivate with no start time');
+ return;
+ }
+
+ if (this._info.sample_count < _minSampleCount) {
+ this._resetData();
+
+ return;
+ }
+
+ var total_time_spent = performanceNow() - start;
+
+ var info = _objectSpread({}, this._info, {
+ total_time_spent: total_time_spent
+ });
+
+ if (DEBUG) {
+ var derived = {
+ avg_blankness: this._info.pixels_blank / this._info.pixels_sampled,
+ avg_speed: this._info.pixels_scrolled / (total_time_spent / 1000),
+ avg_speed_when_any_blank: this._info.any_blank_speed_sum / this._info.any_blank_count,
+ any_blank_per_min: this._info.any_blank_count / (total_time_spent / 1000 / 60),
+ any_blank_time_frac: this._info.any_blank_ms / total_time_spent,
+ mostly_blank_per_min: this._info.mostly_blank_count / (total_time_spent / 1000 / 60),
+ mostly_blank_time_frac: this._info.mostly_blank_ms / total_time_spent
+ };
+
+ for (var key in derived) {
+ derived[key] = Math.round(1000 * derived[key]) / 1000;
+ }
+
+ console.debug('FillRateHelper deactivateAndFlush: ', {
+ derived: derived,
+ info: info
+ });
+ }
+
+ _listeners.forEach(function (listener) {
+ return listener(info);
+ });
+
+ this._resetData();
+ }
+ }, {
+ key: "computeBlankness",
+ value: function computeBlankness(props, state, scrollMetrics) {
+ if (!this._enabled || props.getItemCount(props.data) === 0 || this._samplesStartTime == null) {
+ return 0;
+ }
+
+ var dOffset = scrollMetrics.dOffset,
+ offset = scrollMetrics.offset,
+ velocity = scrollMetrics.velocity,
+ visibleLength = scrollMetrics.visibleLength;
+ this._info.sample_count++;
+ this._info.pixels_sampled += Math.round(visibleLength);
+ this._info.pixels_scrolled += Math.round(Math.abs(dOffset));
+ var scrollSpeed = Math.round(Math.abs(velocity) * 1000);
+ var now = performanceNow();
+
+ if (this._anyBlankStartTime != null) {
+ this._info.any_blank_ms += now - this._anyBlankStartTime;
+ }
+
+ this._anyBlankStartTime = null;
+
+ if (this._mostlyBlankStartTime != null) {
+ this._info.mostly_blank_ms += now - this._mostlyBlankStartTime;
+ }
+
+ this._mostlyBlankStartTime = null;
+ var blankTop = 0;
+ var first = state.first;
+
+ var firstFrame = this._getFrameMetrics(first);
+
+ while (first <= state.last && (!firstFrame || !firstFrame.inLayout)) {
+ firstFrame = this._getFrameMetrics(first);
+ first++;
+ }
+
+ if (firstFrame && first > 0) {
+ blankTop = Math.min(visibleLength, Math.max(0, firstFrame.offset - offset));
+ }
+
+ var blankBottom = 0;
+ var last = state.last;
+
+ var lastFrame = this._getFrameMetrics(last);
+
+ while (last >= state.first && (!lastFrame || !lastFrame.inLayout)) {
+ lastFrame = this._getFrameMetrics(last);
+ last--;
+ }
+
+ if (lastFrame && last < props.getItemCount(props.data) - 1) {
+ var bottomEdge = lastFrame.offset + lastFrame.length;
+ blankBottom = Math.min(visibleLength, Math.max(0, offset + visibleLength - bottomEdge));
+ }
+
+ var pixels_blank = Math.round(blankTop + blankBottom);
+ var blankness = pixels_blank / visibleLength;
+
+ if (blankness > 0) {
+ this._anyBlankStartTime = now;
+ this._info.any_blank_speed_sum += scrollSpeed;
+ this._info.any_blank_count++;
+ this._info.pixels_blank += pixels_blank;
+
+ if (blankness > 0.5) {
+ this._mostlyBlankStartTime = now;
+ this._info.mostly_blank_count++;
+ }
+ } else if (scrollSpeed < 0.01 || Math.abs(dOffset) < 1) {
+ this.deactivateAndFlush();
+ }
+
+ return blankness;
+ }
+ }, {
+ key: "enabled",
+ value: function enabled() {
+ return this._enabled;
+ }
+ }, {
+ key: "_resetData",
+ value: function _resetData() {
+ this._anyBlankStartTime = null;
+ this._info = new Info();
+ this._mostlyBlankStartTime = null;
+ this._samplesStartTime = null;
+ }
+ }]);
+
+ return FillRateHelper;
+ }();
+
+ module.exports = FillRateHelper;
+},271,[32,4,3,120,21],"node_modules\\react-native\\Libraries\\Lists\\FillRateHelper.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _objectWithoutProperties = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/objectWithoutProperties");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Components\\RefreshControl\\RefreshControl.js";
+
+ var Platform = _$$_REQUIRE(_dependencyMap[7], "Platform");
+
+ var React = _$$_REQUIRE(_dependencyMap[8], "React");
+
+ var _require = _$$_REQUIRE(_dependencyMap[9], "ReactNative"),
+ NativeComponent = _require.NativeComponent;
+
+ var AndroidSwipeRefreshLayoutNativeComponent = _$$_REQUIRE(_dependencyMap[10], "AndroidSwipeRefreshLayoutNativeComponent");
+
+ var RCTRefreshControlNativeComponent = _$$_REQUIRE(_dependencyMap[11], "RCTRefreshControlNativeComponent");
+
+ var nullthrows = _$$_REQUIRE(_dependencyMap[12], "nullthrows");
+
+ var RefreshLayoutConsts;
+
+ if (Platform.OS === 'android') {
+ var AndroidSwipeRefreshLayout = _$$_REQUIRE(_dependencyMap[13], "UIManager").getViewManagerConfig('AndroidSwipeRefreshLayout');
+
+ RefreshLayoutConsts = AndroidSwipeRefreshLayout ? AndroidSwipeRefreshLayout.Constants : {
+ SIZE: {}
+ };
+ } else {
+ RefreshLayoutConsts = {
+ SIZE: {}
+ };
+ }
+
+ var RefreshControl = function (_React$Component) {
+ _inherits(RefreshControl, _React$Component);
+
+ function RefreshControl() {
+ var _getPrototypeOf2;
+
+ var _this;
+
+ _classCallCheck(this, RefreshControl);
+
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(RefreshControl)).call.apply(_getPrototypeOf2, [this].concat(args)));
+ _this._lastNativeRefreshing = false;
+
+ _this._onRefresh = function () {
+ _this._lastNativeRefreshing = true;
+ _this.props.onRefresh && _this.props.onRefresh();
+
+ _this.forceUpdate();
+ };
+
+ return _this;
+ }
+
+ _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 && this._setNativePropsOnRef) {
+ this._setNativePropsOnRef({
+ refreshing: this.props.refreshing
+ });
+
+ this._lastNativeRefreshing = this.props.refreshing;
+ }
+ }
+ }, {
+ key: "render",
+ value: function render() {
+ var _this2 = this;
+
+ var setRef = function setRef(ref) {
+ return _this2._setNativePropsOnRef = ref ? ref.setNativeProps.bind(ref) : null;
+ };
+
+ if (Platform.OS === 'ios') {
+ var _this$props = this.props,
+ enabled = _this$props.enabled,
+ colors = _this$props.colors,
+ progressBackgroundColor = _this$props.progressBackgroundColor,
+ size = _this$props.size,
+ progressViewOffset = _this$props.progressViewOffset,
+ props = _objectWithoutProperties(_this$props, ["enabled", "colors", "progressBackgroundColor", "size", "progressViewOffset"]);
+
+ return React.createElement(RCTRefreshControlNativeComponent, _extends({}, props, {
+ ref: setRef,
+ onRefresh: this._onRefresh,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 178
+ }
+ }));
+ } else {
+ var _this$props2 = this.props,
+ tintColor = _this$props2.tintColor,
+ titleColor = _this$props2.titleColor,
+ title = _this$props2.title,
+ _props = _objectWithoutProperties(_this$props2, ["tintColor", "titleColor", "title"]);
+
+ return React.createElement(AndroidSwipeRefreshLayoutNativeComponent, _extends({}, _props, {
+ ref: setRef,
+ onRefresh: this._onRefresh,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 187
+ }
+ }));
+ }
+ }
+ }]);
+
+ return RefreshControl;
+ }(React.Component);
+
+ RefreshControl.SIZE = RefreshLayoutConsts.SIZE;
+ module.exports = RefreshControl;
+},272,[14,33,3,4,5,8,9,35,52,84,273,274,220,71],"node_modules\\react-native\\Libraries\\Components\\RefreshControl\\RefreshControl.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var requireNativeComponent = _$$_REQUIRE(_dependencyMap[0], "requireNativeComponent");
+
+ var AndroidSwipeRefreshLayout = _$$_REQUIRE(_dependencyMap[1], "UIManager").getViewManagerConfig('AndroidSwipeRefreshLayout');
+
+ var RefreshLayoutConsts = AndroidSwipeRefreshLayout ? AndroidSwipeRefreshLayout.Constants : {
+ SIZE: {}
+ };
+ module.exports = requireNativeComponent('AndroidSwipeRefreshLayout');
+},273,[184,71],"node_modules\\react-native\\Libraries\\Components\\RefreshControl\\AndroidSwipeRefreshLayoutNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var requireNativeComponent = _$$_REQUIRE(_dependencyMap[0], "requireNativeComponent");
+
+ module.exports = requireNativeComponent('RCTRefreshControl');
+},274,[184],"node_modules\\react-native\\Libraries\\Components\\RefreshControl\\RCTRefreshControlNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _assertThisInitialized = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/assertThisInitialized");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits");
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/defineProperty");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Components\\ScrollView\\ScrollView.js";
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var AnimatedImplementation = _$$_REQUIRE(_dependencyMap[8], "AnimatedImplementation");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[9], "Platform");
+
+ var React = _$$_REQUIRE(_dependencyMap[10], "React");
+
+ var ReactNative = _$$_REQUIRE(_dependencyMap[11], "ReactNative");
+
+ var ScrollResponder = _$$_REQUIRE(_dependencyMap[12], "ScrollResponder");
+
+ var ScrollViewStickyHeader = _$$_REQUIRE(_dependencyMap[13], "ScrollViewStickyHeader");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[14], "StyleSheet");
+
+ var View = _$$_REQUIRE(_dependencyMap[15], "View");
+
+ var InternalScrollViewType = _$$_REQUIRE(_dependencyMap[16], "InternalScrollViewType");
+
+ var dismissKeyboard = _$$_REQUIRE(_dependencyMap[17], "dismissKeyboard");
+
+ var flattenStyle = _$$_REQUIRE(_dependencyMap[18], "flattenStyle");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[19], "invariant");
+
+ var processDecelerationRate = _$$_REQUIRE(_dependencyMap[20], "processDecelerationRate");
+
+ var requireNativeComponent = _$$_REQUIRE(_dependencyMap[21], "requireNativeComponent");
+
+ var resolveAssetSource = _$$_REQUIRE(_dependencyMap[22], "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');
+ }
+
+ function createScrollResponder(node) {
+ var scrollResponder = _objectSpread({}, ScrollResponder.Mixin);
+
+ for (var key in scrollResponder) {
+ if (typeof scrollResponder[key] === 'function') {
+ scrollResponder[key] = scrollResponder[key].bind(node);
+ }
+ }
+
+ return scrollResponder;
+ }
+
+ var ScrollView = function (_React$Component) {
+ _inherits(ScrollView, _React$Component);
+
+ function ScrollView() {
+ var _getPrototypeOf2;
+
+ var _this;
+
+ _classCallCheck(this, ScrollView);
+
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(ScrollView)).call.apply(_getPrototypeOf2, [this].concat(args)));
+ _this._scrollResponder = createScrollResponder(_assertThisInitialized(_this));
+ _this._scrollAnimatedValue = new AnimatedImplementation.Value(0);
+ _this._scrollAnimatedValueAttachment = null;
+ _this._stickyHeaderRefs = new Map();
+ _this._headerLayoutYs = new Map();
+ _this.state = _objectSpread({
+ layoutHeight: null
+ }, ScrollResponder.Mixin.scrollResponderMixinGetInitialState());
+
+ _this._handleKeyDown = function (e) {
+ if (_this.props.onKeyDown) {
+ _this.props.onKeyDown(e);
+ } else {
+ var _event = e.nativeEvent;
+ var key = _event.key;
+ var kMinScrollOffset = 10;
+
+ if (Platform.OS === 'macos') {
+ if (key === 'PAGE_UP') {
+ _this._handleScrollByKeyDown(_event, {
+ x: _event.contentOffset.x,
+ y: _event.contentOffset.y + -_event.layoutMeasurement.height
+ });
+ } else if (key === 'PAGE_DOWN') {
+ _this._handleScrollByKeyDown(_event, {
+ x: _event.contentOffset.x,
+ y: _event.contentOffset.y + _event.layoutMeasurement.height
+ });
+ } else if (key === 'LEFT_ARROW') {
+ _this._handleScrollByKeyDown(_event, {
+ x: _event.contentOffset.x + -(_this.props.horizontalLineScroll || kMinScrollOffset),
+ y: _event.contentOffset.y
+ });
+ } else if (key === 'RIGHT_ARROW') {
+ _this._handleScrollByKeyDown(_event, {
+ x: _event.contentOffset.x + (_this.props.horizontalLineScroll || kMinScrollOffset),
+ y: _event.contentOffset.y
+ });
+ } else if (key === 'DOWN_ARROW') {
+ _this._handleScrollByKeyDown(_event, {
+ x: _event.contentOffset.x,
+ y: _event.contentOffset.y + (_this.props.verticalLineScroll || kMinScrollOffset)
+ });
+ } else if (key === 'UP_ARROW') {
+ _this._handleScrollByKeyDown(_event, {
+ x: _event.contentOffset.x,
+ y: _event.contentOffset.y + -(_this.props.verticalLineScroll || kMinScrollOffset)
+ });
+ }
+ }
+ }
+ };
+
+ _this._handleScrollByKeyDown = function (e, newOffset) {
+ var maxX = e.contentSize.width - e.layoutMeasurement.width;
+ var maxY = e.contentSize.height - e.layoutMeasurement.height;
+
+ _this.scrollTo({
+ x: Math.max(0, Math.min(maxX, newOffset.x)),
+ y: Math.max(0, Math.min(maxY, newOffset.y))
+ });
+ };
+
+ _this._handleScroll = function (e) {
+ if (__DEV__) {
+ if (_this.props.onScroll && _this.props.scrollEventThrottle == null && (Platform.OS === 'ios' || Platform.OS === 'macos')) {
+ console.log('You specified `onScroll` on a 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._scrollResponder.scrollResponderHandleScroll(e);
+ };
+
+ _this._handleLayout = function (e) {
+ if (_this.props.invertStickyHeaders) {
+ _this.setState({
+ layoutHeight: e.nativeEvent.layout.height
+ });
+ }
+
+ if (_this.props.onLayout) {
+ _this.props.onLayout(e);
+ }
+ };
+
+ _this._handleContentOnLayout = function (e) {
+ var _e$nativeEvent$layout = e.nativeEvent.layout,
+ width = _e$nativeEvent$layout.width,
+ height = _e$nativeEvent$layout.height;
+ _this.props.onContentSizeChange && _this.props.onContentSizeChange(width, height);
+ };
+
+ _this._scrollViewRef = null;
+
+ _this._setScrollViewRef = function (ref) {
+ _this._scrollViewRef = ref;
+ };
+
+ _this._innerViewRef = null;
+
+ _this._setInnerViewRef = function (ref) {
+ _this._innerViewRef = ref;
+ };
+
+ for (var key in ScrollResponder.Mixin) {
+ if (typeof ScrollResponder.Mixin[key] === 'function' && key.startsWith('scrollResponder')) {
+ _assertThisInitialized(_this)[key] = ScrollResponder.Mixin[key].bind(_assertThisInitialized(_this));
+ }
+ }
+
+ Object.keys(ScrollResponder.Mixin).filter(function (key) {
+ return typeof ScrollResponder.Mixin[key] !== 'function';
+ }).forEach(function (key) {
+ _assertThisInitialized(_this)[key] = ScrollResponder.Mixin[key];
+ });
+ return _this;
+ }
+
+ _createClass(ScrollView, [{
+ key: "UNSAFE_componentWillMount",
+ value: function UNSAFE_componentWillMount() {
+ this._scrollResponder.UNSAFE_componentWillMount();
+
+ this._scrollAnimatedValue = new AnimatedImplementation.Value(this.props.contentOffset ? this.props.contentOffset.y : 0);
+
+ this._scrollAnimatedValue.setOffset(this.props.contentInset ? this.props.contentInset.top : 0);
+
+ this._stickyHeaderRefs = new Map();
+ this._headerLayoutYs = new Map();
+ }
+ }, {
+ key: "componentDidMount",
+ value: function componentDidMount() {
+ this._updateAnimatedNodeAttachment();
+ }
+ }, {
+ key: "componentDidUpdate",
+ value: function componentDidUpdate() {
+ this._updateAnimatedNodeAttachment();
+ }
+ }, {
+ key: "componentWillUnmount",
+ value: function componentWillUnmount() {
+ this._scrollResponder.componentWillUnmount();
+
+ if (this._scrollAnimatedValueAttachment) {
+ this._scrollAnimatedValueAttachment.detach();
+ }
+ }
+ }, {
+ key: "setNativeProps",
+ value: function setNativeProps(props) {
+ this._scrollViewRef && this._scrollViewRef.setNativeProps(props);
+ }
+ }, {
+ key: "getScrollResponder",
+ value: function getScrollResponder() {
+ return this;
+ }
+ }, {
+ key: "getScrollableNode",
+ value: function getScrollableNode() {
+ return ReactNative.findNodeHandle(this._scrollViewRef);
+ }
+ }, {
+ key: "getInnerViewNode",
+ value: function getInnerViewNode() {
+ return ReactNative.findNodeHandle(this._innerViewRef);
+ }
+ }, {
+ key: "scrollTo",
+ value: 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._scrollResponder.scrollResponderScrollTo({
+ x: x || 0,
+ y: y || 0,
+ animated: animated !== false
+ });
+ }
+ }, {
+ key: "scrollToEnd",
+ value: function scrollToEnd(options) {
+ var animated = (options && options.animated) !== false;
+
+ this._scrollResponder.scrollResponderScrollToEnd({
+ animated: animated
+ });
+ }
+ }, {
+ key: "scrollWithoutAnimationTo",
+ value: function scrollWithoutAnimationTo() {
+ var y = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+ var x = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+ console.warn('`scrollWithoutAnimationTo` is deprecated. Use `scrollTo` instead');
+ this.scrollTo({
+ x: x,
+ y: y,
+ animated: false
+ });
+ }
+ }, {
+ key: "flashScrollIndicators",
+ value: function flashScrollIndicators() {
+ this._scrollResponder.scrollResponderFlashScrollIndicators();
+ }
+ }, {
+ key: "_getKeyForIndex",
+ value: function _getKeyForIndex(index, childArray) {
+ var child = childArray[index];
+ return child && child.key;
+ }
+ }, {
+ key: "_updateAnimatedNodeAttachment",
+ value: function _updateAnimatedNodeAttachment() {
+ if (this._scrollAnimatedValueAttachment) {
+ this._scrollAnimatedValueAttachment.detach();
+ }
+
+ if (this.props.stickyHeaderIndices && this.props.stickyHeaderIndices.length > 0) {
+ this._scrollAnimatedValueAttachment = AnimatedImplementation.attachNativeEvent(this._scrollViewRef, 'onScroll', [{
+ nativeEvent: {
+ contentOffset: {
+ y: this._scrollAnimatedValue
+ }
+ }
+ }]);
+ }
+ }
+ }, {
+ key: "_setStickyHeaderRef",
+ value: function _setStickyHeaderRef(key, ref) {
+ if (ref) {
+ this._stickyHeaderRefs.set(key, ref);
+ } else {
+ this._stickyHeaderRefs.delete(key);
+ }
+ }
+ }, {
+ key: "_onStickyHeaderLayout",
+ value: function _onStickyHeaderLayout(index, event, key) {
+ var stickyHeaderIndices = this.props.stickyHeaderIndices;
+
+ if (!stickyHeaderIndices) {
+ return;
+ }
+
+ var childArray = React.Children.toArray(this.props.children);
+
+ if (key !== this._getKeyForIndex(index, childArray)) {
+ return;
+ }
+
+ var layoutY = event.nativeEvent.layout.y;
+
+ this._headerLayoutYs.set(key, layoutY);
+
+ var indexOfIndex = stickyHeaderIndices.indexOf(index);
+ var previousHeaderIndex = stickyHeaderIndices[indexOfIndex - 1];
+
+ if (previousHeaderIndex != null) {
+ var previousHeader = this._stickyHeaderRefs.get(this._getKeyForIndex(previousHeaderIndex, childArray));
+
+ previousHeader && previousHeader.setNextHeaderY(layoutY);
+ }
+ }
+ }, {
+ key: "render",
+ value: function render() {
+ var _this2 = this;
+
+ var ScrollViewClass;
+ var ScrollContentContainerViewClass;
+
+ if (Platform.OS === 'android') {
+ if (this.props.horizontal) {
+ ScrollViewClass = AndroidHorizontalScrollView;
+ ScrollContentContainerViewClass = AndroidHorizontalScrollContentView;
+ } else {
+ ScrollViewClass = AndroidScrollView;
+ ScrollContentContainerViewClass = View;
+ }
+ } else if (Platform.OS === 'windesktop') {
+ ScrollViewClass = RCTScrollView;
+ ScrollContentContainerViewClass = View;
+ } else {
+ ScrollViewClass = RCTScrollView;
+ ScrollContentContainerViewClass = RCTScrollContentView;
+ }
+
+ invariant(ScrollViewClass !== undefined, 'ScrollViewClass must not be undefined');
+ invariant(ScrollContentContainerViewClass !== undefined, 'ScrollContentContainerViewClass must not be undefined');
+ var contentContainerStyle = [this.props.horizontal && 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 children = this.props.children;
+
+ if (stickyHeaderIndices != null && stickyHeaderIndices.length > 0) {
+ var childArray = React.Children.toArray(this.props.children);
+ children = childArray.map(function (child, index) {
+ var indexOfIndex = child ? stickyHeaderIndices.indexOf(index) : -1;
+
+ if (indexOfIndex > -1) {
+ var key = child.key;
+ var nextIndex = stickyHeaderIndices[indexOfIndex + 1];
+ return React.createElement(ScrollViewStickyHeader, {
+ key: key,
+ ref: function ref(_ref2) {
+ return _this2._setStickyHeaderRef(key, _ref2);
+ },
+ nextHeaderLayoutY: _this2._headerLayoutYs.get(_this2._getKeyForIndex(nextIndex, childArray)),
+ onLayout: function onLayout(event) {
+ return _this2._onStickyHeaderLayout(index, event, key);
+ },
+ scrollAnimatedValue: _this2._scrollAnimatedValue,
+ inverted: _this2.props.invertStickyHeaders,
+ scrollViewHeight: _this2.state.layoutHeight,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 1009
+ }
+ }, child);
+ } else {
+ return child;
+ }
+ });
+ }
+
+ var hasStickyHeaders = stickyHeaderIndices && stickyHeaderIndices.length > 0;
+ 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: 1032
+ }
+ }), 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,
+ onKeyDown: this._handleKeyDown,
+ onLayout: this._handleLayout,
+ onMomentumScrollBegin: this._scrollResponder.scrollResponderHandleMomentumScrollBegin,
+ onMomentumScrollEnd: this._scrollResponder.scrollResponderHandleMomentumScrollEnd,
+ onResponderGrant: this._scrollResponder.scrollResponderHandleResponderGrant,
+ onResponderReject: this._scrollResponder.scrollResponderHandleResponderReject,
+ onResponderRelease: this._scrollResponder.scrollResponderHandleResponderRelease,
+ onResponderTerminate: this._scrollResponder.scrollResponderHandleTerminate,
+ onResponderTerminationRequest: this._scrollResponder.scrollResponderHandleTerminationRequest,
+ onScrollBeginDrag: this._scrollResponder.scrollResponderHandleScrollBeginDrag,
+ onScrollEndDrag: this._scrollResponder.scrollResponderHandleScrollEndDrag,
+ onScrollShouldSetResponder: this._scrollResponder.scrollResponderHandleScrollShouldSetResponder,
+ onStartShouldSetResponder: this._scrollResponder.scrollResponderHandleStartShouldSetResponder,
+ onStartShouldSetResponderCapture: this._scrollResponder.scrollResponderHandleStartShouldSetResponderCapture,
+ onTouchEnd: this._scrollResponder.scrollResponderHandleTouchEnd,
+ onTouchMove: this._scrollResponder.scrollResponderHandleTouchMove,
+ onTouchStart: this._scrollResponder.scrollResponderHandleTouchStart,
+ onTouchCancel: this._scrollResponder.scrollResponderHandleTouchCancel,
+ onScroll: this._handleScroll,
+ scrollBarThumbImage: resolveAssetSource(this.props.scrollBarThumbImage),
+ scrollEventThrottle: hasStickyHeaders ? 1 : this.props.scrollEventThrottle,
+ sendMomentumEvents: this.props.onMomentumScrollBegin || this.props.onMomentumScrollEnd ? true : false,
+ DEPRECATED_sendUpdatedChildFrames: DEPRECATED_sendUpdatedChildFrames,
+ snapToStart: this.props.snapToStart !== false,
+ snapToEnd: this.props.snapToEnd !== false,
+ pagingEnabled: Platform.select({
+ ios: this.props.pagingEnabled && this.props.snapToInterval == null && this.props.snapToOffsets == null,
+ macos: this.props.pagingEnabled && this.props.snapToInterval == null && this.props.snapToOffsets == null,
+ android: this.props.pagingEnabled || this.props.snapToInterval != null || this.props.snapToOffsets != null
+ })
+ });
+
+ var decelerationRate = this.props.decelerationRate;
+
+ if (decelerationRate != null) {
+ props.decelerationRate = processDecelerationRate(decelerationRate);
+ }
+
+ var refreshControl = this.props.refreshControl;
+
+ if (refreshControl) {
+ if (Platform.OS === 'ios') {
+ return React.createElement(ScrollViewClass, _extends({}, props, {
+ ref: this._setScrollViewRef,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 1150
+ }
+ }), 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: 1165
+ }
+ }), contentContainer));
+ }
+ }
+
+ return React.createElement(ScrollViewClass, _extends({}, props, {
+ ref: this._setScrollViewRef,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 1177
+ }
+ }), contentContainer);
+ }
+ }]);
+
+ return ScrollView;
+ }(React.Component);
+
+ 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;
+},275,[14,3,4,5,8,7,9,32,247,35,52,84,276,281,53,81,282,280,80,19,283,184,190],"node_modules\\react-native\\Libraries\\Components\\ScrollView\\ScrollView.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var Dimensions = _$$_REQUIRE(_dependencyMap[0], "Dimensions");
+
+ var FrameRateLogger = _$$_REQUIRE(_dependencyMap[1], "FrameRateLogger");
+
+ var Keyboard = _$$_REQUIRE(_dependencyMap[2], "Keyboard");
+
+ var ReactNative = _$$_REQUIRE(_dependencyMap[3], "ReactNative");
+
+ var TextInputState = _$$_REQUIRE(_dependencyMap[4], "TextInputState");
+
+ var UIManager = _$$_REQUIRE(_dependencyMap[5], "UIManager");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[6], "invariant");
+
+ var nullthrows = _$$_REQUIRE(_dependencyMap[7], "nullthrows");
+
+ var performanceNow = _$$_REQUIRE(_dependencyMap[8], "fbjs/lib/performanceNow");
+
+ var warning = _$$_REQUIRE(_dependencyMap[9], "fbjs/lib/warning");
+
+ var _require = _$$_REQUIRE(_dependencyMap[10], "NativeModules"),
+ ScrollViewManager = _require.ScrollViewManager;
+
+ var IS_ANIMATING_TOUCH_START_THRESHOLD_MS = 16;
+ var ScrollResponderMixin = {
+ _subscriptionKeyboardWillShow: null,
+ _subscriptionKeyboardWillHide: null,
+ _subscriptionKeyboardDidShow: null,
+ _subscriptionKeyboardDidHide: null,
+ scrollResponderMixinGetInitialState: function scrollResponderMixinGetInitialState() {
+ return {
+ isTouching: false,
+ lastMomentumScrollBeginTime: 0,
+ lastMomentumScrollEndTime: 0,
+ observedScrollSinceBecomingResponder: false,
+ becameResponderWhileAnimating: false
+ };
+ },
+ scrollResponderHandleScrollShouldSetResponder: function scrollResponderHandleScrollShouldSetResponder() {
+ 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 && e.target && !TextInputState.isTextInput(e.target)) {
+ return true;
+ }
+
+ return false;
+ },
+ scrollResponderHandleResponderReject: function scrollResponderHandleResponderReject() {},
+ scrollResponderHandleTerminationRequest: function scrollResponderHandleTerminationRequest() {
+ return !this.state.observedScrollSinceBecomingResponder;
+ },
+ scrollResponderHandleTouchEnd: function scrollResponderHandleTouchEnd(e) {
+ var nativeEvent = e.nativeEvent;
+ this.state.isTouching = nativeEvent.touches.length !== 0;
+ this.props.onTouchEnd && this.props.onTouchEnd(e);
+ },
+ scrollResponderHandleTouchCancel: function scrollResponderHandleTouchCancel(e) {
+ this.state.isTouching = false;
+ this.props.onTouchCancel && this.props.onTouchCancel(e);
+ },
+ scrollResponderHandleResponderRelease: function scrollResponderHandleResponderRelease(e) {
+ this.props.onResponderRelease && this.props.onResponderRelease(e);
+ var currentlyFocusedTextInput = TextInputState.currentlyFocusedField();
+
+ if (this.props.keyboardShouldPersistTaps !== true && this.props.keyboardShouldPersistTaps !== 'always' && currentlyFocusedTextInput != null && e.target !== currentlyFocusedTextInput && !this.state.observedScrollSinceBecomingResponder && !this.state.becameResponderWhileAnimating) {
+ this.props.onScrollResponderKeyboardDismissed && this.props.onScrollResponderKeyboardDismissed(e);
+ TextInputState.blurTextInput(currentlyFocusedTextInput);
+ }
+ },
+ scrollResponderHandleScroll: function scrollResponderHandleScroll(e) {
+ this.state.observedScrollSinceBecomingResponder = true;
+ this.props.onScroll && this.props.onScroll(e);
+ },
+ scrollResponderHandleResponderGrant: function scrollResponderHandleResponderGrant(e) {
+ this.state.observedScrollSinceBecomingResponder = false;
+ this.props.onResponderGrant && this.props.onResponderGrant(e);
+ this.state.becameResponderWhileAnimating = this.scrollResponderIsAnimating();
+ },
+ scrollResponderHandleScrollBeginDrag: function scrollResponderHandleScrollBeginDrag(e) {
+ FrameRateLogger.beginScroll();
+ this.props.onScrollBeginDrag && this.props.onScrollBeginDrag(e);
+ },
+ scrollResponderHandleScrollEndDrag: function scrollResponderHandleScrollEndDrag(e) {
+ var velocity = e.nativeEvent.velocity;
+
+ if (!this.scrollResponderIsAnimating() && (!velocity || velocity.x === 0 && velocity.y === 0)) {
+ FrameRateLogger.endScroll();
+ }
+
+ this.props.onScrollEndDrag && this.props.onScrollEndDrag(e);
+ },
+ scrollResponderHandleMomentumScrollBegin: function scrollResponderHandleMomentumScrollBegin(e) {
+ this.state.lastMomentumScrollBeginTime = performanceNow();
+ this.props.onMomentumScrollBegin && this.props.onMomentumScrollBegin(e);
+ },
+ scrollResponderHandleMomentumScrollEnd: function scrollResponderHandleMomentumScrollEnd(e) {
+ FrameRateLogger.endScroll();
+ this.state.lastMomentumScrollEndTime = performanceNow();
+ this.props.onMomentumScrollEnd && this.props.onMomentumScrollEnd(e);
+ },
+ scrollResponderHandleTouchStart: function scrollResponderHandleTouchStart(e) {
+ this.state.isTouching = true;
+ this.props.onTouchStart && this.props.onTouchStart(e);
+ },
+ scrollResponderHandleTouchMove: function scrollResponderHandleTouchMove(e) {
+ this.props.onTouchMove && this.props.onTouchMove(e);
+ },
+ scrollResponderIsAnimating: function scrollResponderIsAnimating() {
+ var now = performanceNow();
+ var timeSinceLastMomentumScrollEnd = now - this.state.lastMomentumScrollEndTime;
+ var isAnimating = timeSinceLastMomentumScrollEnd < IS_ANIMATING_TOUCH_START_THRESHOLD_MS || this.state.lastMomentumScrollEndTime < this.state.lastMomentumScrollBeginTime;
+ return isAnimating;
+ },
+ scrollResponderGetScrollableNode: function scrollResponderGetScrollableNode() {
+ return this.getScrollableNode ? this.getScrollableNode() : ReactNative.findNodeHandle(this);
+ },
+ scrollResponderScrollTo: function scrollResponderScrollTo(x, y, animated) {
+ if (typeof x === 'number') {
+ console.warn('`scrollResponderScrollTo(x, y, animated)` is deprecated. Use `scrollResponderScrollTo({x: 5, y: 5, animated: true})` instead.');
+ } else {
+ var _ref = x || {};
+
+ x = _ref.x;
+ y = _ref.y;
+ animated = _ref.animated;
+ }
+
+ UIManager.dispatchViewManagerCommand(nullthrows(this.scrollResponderGetScrollableNode()), UIManager.getViewManagerConfig('RCTScrollView').Commands.scrollTo, [x || 0, y || 0, animated !== false]);
+ },
+ scrollResponderScrollToEnd: function scrollResponderScrollToEnd(options) {
+ var animated = (options && options.animated) !== false;
+ UIManager.dispatchViewManagerCommand(this.scrollResponderGetScrollableNode(), UIManager.getViewManagerConfig('RCTScrollView').Commands.scrollToEnd, [animated]);
+ },
+ scrollResponderScrollWithoutAnimationTo: function scrollResponderScrollWithoutAnimationTo(offsetX, offsetY) {
+ console.warn('`scrollResponderScrollWithoutAnimationTo` is deprecated. Use `scrollResponderScrollTo` instead');
+ this.scrollResponderScrollTo({
+ x: offsetX,
+ y: offsetY,
+ animated: false
+ });
+ },
+ scrollResponderZoomTo: function scrollResponderZoomTo(rect, animated) {
+ invariant(ScrollViewManager && ScrollViewManager.zoomToRect, 'zoomToRect is not implemented');
+
+ if ('animated' in rect) {
+ animated = rect.animated;
+ delete rect.animated;
+ } else if (typeof animated !== 'undefined') {
+ console.warn('`scrollResponderZoomTo` `animated` argument is deprecated. Use `options.animated` instead');
+ }
+
+ ScrollViewManager.zoomToRect(this.scrollResponderGetScrollableNode(), rect, animated !== false);
+ },
+ scrollResponderFlashScrollIndicators: function scrollResponderFlashScrollIndicators() {
+ UIManager.dispatchViewManagerCommand(this.scrollResponderGetScrollableNode(), UIManager.getViewManagerConfig('RCTScrollView').Commands.flashScrollIndicators, []);
+ },
+ scrollResponderScrollNativeHandleToKeyboard: function scrollResponderScrollNativeHandleToKeyboard(nodeHandle, additionalOffset, preventNegativeScrollOffset) {
+ this.additionalScrollOffset = additionalOffset || 0;
+ this.preventNegativeScrollOffset = !!preventNegativeScrollOffset;
+ UIManager.measureLayout(nodeHandle, ReactNative.findNodeHandle(this.getInnerViewNode()), this.scrollResponderTextInputFocusError, this.scrollResponderInputMeasureAndScrollToKeyboard);
+ },
+ scrollResponderInputMeasureAndScrollToKeyboard: function scrollResponderInputMeasureAndScrollToKeyboard(left, top, width, height) {
+ var keyboardScreenY = Dimensions.get('window').height;
+
+ if (this.keyboardWillOpenTo) {
+ keyboardScreenY = this.keyboardWillOpenTo.endCoordinates.screenY;
+ }
+
+ var scrollOffsetY = top - keyboardScreenY + height + this.additionalScrollOffset;
+
+ if (this.preventNegativeScrollOffset) {
+ scrollOffsetY = Math.max(0, scrollOffsetY);
+ }
+
+ this.scrollResponderScrollTo({
+ x: 0,
+ y: scrollOffsetY,
+ animated: true
+ });
+ this.additionalOffset = 0;
+ this.preventNegativeScrollOffset = false;
+ },
+ scrollResponderTextInputFocusError: function scrollResponderTextInputFocusError(msg) {
+ console.error('Error measuring text field: ', msg);
+ },
+ UNSAFE_componentWillMount: function UNSAFE_componentWillMount() {
+ var keyboardShouldPersistTaps = this.props.keyboardShouldPersistTaps;
+ warning(typeof keyboardShouldPersistTaps !== 'boolean', "'keyboardShouldPersistTaps={" + keyboardShouldPersistTaps + "}' is deprecated. " + ("Use 'keyboardShouldPersistTaps=\"" + (keyboardShouldPersistTaps ? 'always' : 'never') + "\"' instead"));
+ this.keyboardWillOpenTo = null;
+ this.additionalScrollOffset = 0;
+ this._subscriptionKeyboardWillShow = Keyboard.addListener('keyboardWillShow', this.scrollResponderKeyboardWillShow);
+ this._subscriptionKeyboardWillHide = Keyboard.addListener('keyboardWillHide', this.scrollResponderKeyboardWillHide);
+ this._subscriptionKeyboardDidShow = Keyboard.addListener('keyboardDidShow', this.scrollResponderKeyboardDidShow);
+ this._subscriptionKeyboardDidHide = Keyboard.addListener('keyboardDidHide', this.scrollResponderKeyboardDidHide);
+ },
+ componentWillUnmount: function componentWillUnmount() {
+ if (this._subscriptionKeyboardWillShow != null) {
+ this._subscriptionKeyboardWillShow.remove();
+ }
+
+ if (this._subscriptionKeyboardWillHide != null) {
+ this._subscriptionKeyboardWillHide.remove();
+ }
+
+ if (this._subscriptionKeyboardDidShow != null) {
+ this._subscriptionKeyboardDidShow.remove();
+ }
+
+ if (this._subscriptionKeyboardDidHide != null) {
+ this._subscriptionKeyboardDidHide.remove();
+ }
+ },
+ scrollResponderKeyboardWillShow: function scrollResponderKeyboardWillShow(e) {
+ this.keyboardWillOpenTo = e;
+ this.props.onKeyboardWillShow && this.props.onKeyboardWillShow(e);
+ },
+ scrollResponderKeyboardWillHide: function scrollResponderKeyboardWillHide(e) {
+ this.keyboardWillOpenTo = null;
+ this.props.onKeyboardWillHide && this.props.onKeyboardWillHide(e);
+ },
+ scrollResponderKeyboardDidShow: function scrollResponderKeyboardDidShow(e) {
+ if (e) {
+ this.keyboardWillOpenTo = e;
+ }
+
+ this.props.onKeyboardDidShow && this.props.onKeyboardDidShow(e);
+ },
+ scrollResponderKeyboardDidHide: function scrollResponderKeyboardDidHide(e) {
+ this.keyboardWillOpenTo = null;
+ this.props.onKeyboardDidHide && this.props.onKeyboardDidHide(e);
+ }
+ };
+ var ScrollResponder = {
+ Mixin: ScrollResponderMixin
+ };
+ module.exports = ScrollResponder;
+},276,[55,277,278,84,176,71,19,220,120,21,36],"node_modules\\react-native\\Libraries\\Components\\ScrollResponder.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var NativeModules = _$$_REQUIRE(_dependencyMap[0], "NativeModules");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[1], "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;
+},277,[36,19],"node_modules\\react-native\\Libraries\\Interaction\\FrameRateLogger.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var LayoutAnimation = _$$_REQUIRE(_dependencyMap[0], "LayoutAnimation");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[1], "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 != null && duration !== 0) {
+ LayoutAnimation.configureNext({
+ duration: duration,
+ update: {
+ duration: duration,
+ type: easing != null && LayoutAnimation.Types[easing] || 'keyboard'
+ }
+ });
+ }
+ };
+
+ module.exports = Keyboard;
+},278,[279,19,131,36,280],"node_modules\\react-native\\Libraries\\Components\\Keyboard\\Keyboard.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+
+ var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "Platform"));
+
+ var UIManager = _$$_REQUIRE(_dependencyMap[2], "UIManager");
+
+ function configureNext(config, onAnimationDidEnd) {
+ if (!_Platform.default.isTesting) {
+ var _onAnimationDidEnd;
+
+ UIManager.configureNextLayoutAnimation(config, (_onAnimationDidEnd = onAnimationDidEnd) != null ? _onAnimationDidEnd : function () {}, function () {});
+ }
+ }
+
+ function create(duration, type, property) {
+ return {
+ duration: duration,
+ create: {
+ type: type,
+ property: property
+ },
+ update: {
+ type: type
+ },
+ delete: {
+ type: type,
+ property: property
+ }
+ };
+ }
+
+ var Presets = {
+ easeInEaseOut: create(300, 'easeInEaseOut', 'opacity'),
+ linear: create(500, 'linear', 'opacity'),
+ spring: {
+ duration: 700,
+ create: {
+ type: 'linear',
+ property: 'opacity'
+ },
+ update: {
+ type: 'spring',
+ springDamping: 0.4
+ },
+ delete: {
+ type: 'linear',
+ property: 'opacity'
+ }
+ }
+ };
+ var LayoutAnimation = {
+ configureNext: configureNext,
+ create: create,
+ Types: Object.freeze({
+ spring: 'spring',
+ linear: 'linear',
+ easeInEaseOut: 'easeInEaseOut',
+ easeIn: 'easeIn',
+ easeOut: 'easeOut',
+ keyboard: 'keyboard'
+ }),
+ Properties: Object.freeze({
+ opacity: 'opacity',
+ scaleX: 'scaleX',
+ scaleY: 'scaleY',
+ scaleXY: 'scaleXY'
+ }),
+ checkConfig: function checkConfig() {
+ console.error('LayoutAnimation.checkConfig(...) has been disabled.');
+ },
+ Presets: Presets,
+ easeInEaseOut: configureNext.bind(null, Presets.easeInEaseOut),
+ linear: configureNext.bind(null, Presets.linear),
+ spring: configureNext.bind(null, Presets.spring)
+ };
+ module.exports = LayoutAnimation;
+},279,[1,35,71],"node_modules\\react-native\\Libraries\\LayoutAnimation\\LayoutAnimation.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var TextInputState = _$$_REQUIRE(_dependencyMap[0], "TextInputState");
+
+ function dismissKeyboard() {
+ TextInputState.blurTextInput(TextInputState.currentlyFocusedField());
+ }
+
+ module.exports = dismissKeyboard;
+},280,[176],"node_modules\\react-native\\Libraries\\Utilities\\dismissKeyboard.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Components\\ScrollView\\ScrollViewStickyHeader.js";
+
+ var AnimatedImplementation = _$$_REQUIRE(_dependencyMap[5], "AnimatedImplementation");
+
+ var React = _$$_REQUIRE(_dependencyMap[6], "React");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[7], "StyleSheet");
+
+ var View = _$$_REQUIRE(_dependencyMap[8], "View");
+
+ var AnimatedView = AnimatedImplementation.createAnimatedComponent(View);
+
+ var ScrollViewStickyHeader = function (_React$Component) {
+ _inherits(ScrollViewStickyHeader, _React$Component);
+
+ function ScrollViewStickyHeader() {
+ var _getPrototypeOf2;
+
+ var _this;
+
+ _classCallCheck(this, ScrollViewStickyHeader);
+
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(ScrollViewStickyHeader)).call.apply(_getPrototypeOf2, [this].concat(args)));
+ _this.state = {
+ measured: false,
+ layoutY: 0,
+ layoutHeight: 0,
+ nextHeaderLayoutY: _this.props.nextHeaderLayoutY
+ };
+
+ _this._onLayout = function (event) {
+ _this.setState({
+ measured: true,
+ layoutY: event.nativeEvent.layout.y,
+ layoutHeight: event.nativeEvent.layout.height
+ });
+
+ _this.props.onLayout(event);
+
+ var child = React.Children.only(_this.props.children);
+
+ if (child.props.onLayout) {
+ child.props.onLayout(event);
+ }
+ };
+
+ return _this;
+ }
+
+ _createClass(ScrollViewStickyHeader, [{
+ key: "setNextHeaderY",
+ value: function setNextHeaderY(y) {
+ this.setState({
+ nextHeaderLayoutY: y
+ });
+ }
+ }, {
+ key: "render",
+ value: function render() {
+ var _this$props = this.props,
+ inverted = _this$props.inverted,
+ scrollViewHeight = _this$props.scrollViewHeight;
+ var _this$state = this.state,
+ measured = _this$state.measured,
+ layoutHeight = _this$state.layoutHeight,
+ layoutY = _this$state.layoutY,
+ nextHeaderLayoutY = _this$state.nextHeaderLayoutY;
+ var inputRange = [-1, 0];
+ var outputRange = [0, 0];
+
+ if (measured) {
+ if (inverted) {
+ if (scrollViewHeight != null) {
+ var stickStartPoint = layoutY + layoutHeight - scrollViewHeight;
+
+ if (stickStartPoint > 0) {
+ inputRange.push(stickStartPoint);
+ outputRange.push(0);
+ inputRange.push(stickStartPoint + 1);
+ outputRange.push(1);
+ var collisionPoint = (nextHeaderLayoutY || 0) - layoutHeight - scrollViewHeight;
+
+ if (collisionPoint > stickStartPoint) {
+ inputRange.push(collisionPoint, collisionPoint + 1);
+ outputRange.push(collisionPoint - stickStartPoint, collisionPoint - stickStartPoint);
+ }
+ }
+ }
+ } else {
+ inputRange.push(layoutY);
+ outputRange.push(0);
+
+ var _collisionPoint = (nextHeaderLayoutY || 0) - layoutHeight;
+
+ if (_collisionPoint >= layoutY) {
+ inputRange.push(_collisionPoint, _collisionPoint + 1);
+ outputRange.push(_collisionPoint - layoutY, _collisionPoint - layoutY);
+ } else {
+ inputRange.push(layoutY + 1);
+ outputRange.push(1);
+ }
+ }
+ }
+
+ var translateY = this.props.scrollAnimatedValue.interpolate({
+ inputRange: inputRange,
+ outputRange: outputRange
+ });
+ var child = React.Children.only(this.props.children);
+ return React.createElement(AnimatedView, {
+ collapsable: false,
+ onLayout: this._onLayout,
+ style: [child.props.style, styles.header, {
+ transform: [{
+ translateY: translateY
+ }]
+ }],
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 141
+ }
+ }, React.cloneElement(child, {
+ style: styles.fill,
+ onLayout: undefined
+ }));
+ }
+ }]);
+
+ return ScrollViewStickyHeader;
+ }(React.Component);
+
+ var styles = StyleSheet.create({
+ header: {
+ zIndex: 10
+ },
+ fill: {
+ flex: 1
+ }
+ });
+ module.exports = ScrollViewStickyHeader;
+},281,[3,4,5,8,9,247,52,53,81],"node_modules\\react-native\\Libraries\\Components\\ScrollView\\ScrollViewStickyHeader.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var ReactNative = _$$_REQUIRE(_dependencyMap[5], "ReactNative");
+
+ var InternalScrollViewType = function (_ReactNative$NativeCo) {
+ "use strict";
+
+ _inherits(InternalScrollViewType, _ReactNative$NativeCo);
+
+ 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) {}
+ }]);
+
+ return InternalScrollViewType;
+ }(ReactNative.NativeComponent);
+
+ module.exports = InternalScrollViewType;
+},282,[3,4,5,8,9,84],"node_modules\\react-native\\Libraries\\Components\\ScrollView\\InternalScrollViewType.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var Platform = _$$_REQUIRE(_dependencyMap[0], "Platform");
+
+ function processDecelerationRate(decelerationRate) {
+ if (decelerationRate === 'normal') {
+ return Platform.select({
+ ios: 0.998,
+ android: 0.985
+ });
+ } else if (decelerationRate === 'fast') {
+ return Platform.select({
+ ios: 0.99,
+ android: 0.9
+ });
+ }
+
+ return decelerationRate;
+ }
+
+ module.exports = processDecelerationRate;
+},283,[35],"node_modules\\react-native\\Libraries\\Components\\ScrollView\\processDecelerationRate.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ var _slicedToArray = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var invariant = _$$_REQUIRE(_dependencyMap[4], "invariant");
+
+ var ViewabilityHelper = function () {
+ function ViewabilityHelper() {
+ var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
+ viewAreaCoveragePercentThreshold: 0
+ };
+
+ _classCallCheck(this, ViewabilityHelper);
+
+ this._hasInteracted = false;
+ this._timers = new Set();
+ this._viewableIndices = [];
+ this._viewableItems = new Map();
+ this._config = config;
+ }
+
+ _createClass(ViewabilityHelper, [{
+ key: "dispose",
+ value: function dispose() {
+ this._timers.forEach(clearTimeout);
+ }
+ }, {
+ key: "computeViewableItems",
+ value: function computeViewableItems(itemCount, scrollOffset, viewportHeight, getFrameMetrics, renderRange) {
+ var _this$_config = this._config,
+ itemVisiblePercentThreshold = _this$_config.itemVisiblePercentThreshold,
+ viewAreaCoveragePercentThreshold = _this$_config.viewAreaCoveragePercentThreshold;
+ var viewAreaMode = viewAreaCoveragePercentThreshold != null;
+ var viewablePercentThreshold = viewAreaMode ? viewAreaCoveragePercentThreshold : itemVisiblePercentThreshold;
+ invariant(viewablePercentThreshold != null && itemVisiblePercentThreshold != null !== (viewAreaCoveragePercentThreshold != null), 'Must set exactly one of itemVisiblePercentThreshold or viewAreaCoveragePercentThreshold');
+ var viewableIndices = [];
+
+ if (itemCount === 0) {
+ return viewableIndices;
+ }
+
+ var firstVisible = -1;
+
+ var _ref = renderRange || {
+ first: 0,
+ last: itemCount - 1
+ },
+ first = _ref.first,
+ last = _ref.last;
+
+ if (last >= itemCount) {
+ console.warn('Invalid render range computing viewability ' + JSON.stringify({
+ renderRange: renderRange,
+ itemCount: itemCount
+ }));
+ return [];
+ }
+
+ for (var idx = first; idx <= last; idx++) {
+ var metrics = getFrameMetrics(idx);
+
+ if (!metrics) {
+ continue;
+ }
+
+ var top = metrics.offset - scrollOffset;
+ var bottom = top + metrics.length;
+
+ if (top < viewportHeight && bottom > 0) {
+ firstVisible = idx;
+
+ if (_isViewable(viewAreaMode, viewablePercentThreshold, top, bottom, viewportHeight, metrics.length)) {
+ viewableIndices.push(idx);
+ }
+ } else if (firstVisible >= 0) {
+ break;
+ }
+ }
+
+ return viewableIndices;
+ }
+ }, {
+ key: "onUpdate",
+ value: function onUpdate(itemCount, scrollOffset, viewportHeight, getFrameMetrics, createViewToken, onViewableItemsChanged, renderRange) {
+ var _this = this;
+
+ if (this._config.waitForInteraction && !this._hasInteracted || itemCount === 0 || !getFrameMetrics(0)) {
+ return;
+ }
+
+ var viewableIndices = [];
+
+ if (itemCount) {
+ viewableIndices = this.computeViewableItems(itemCount, scrollOffset, viewportHeight, getFrameMetrics, renderRange);
+ }
+
+ if (this._viewableIndices.length === viewableIndices.length && this._viewableIndices.every(function (v, ii) {
+ return v === viewableIndices[ii];
+ })) {
+ return;
+ }
+
+ this._viewableIndices = viewableIndices;
+
+ if (this._config.minimumViewTime) {
+ var handle = setTimeout(function () {
+ _this._timers.delete(handle);
+
+ _this._onUpdateSync(viewableIndices, onViewableItemsChanged, createViewToken);
+ }, this._config.minimumViewTime);
+
+ this._timers.add(handle);
+ } else {
+ this._onUpdateSync(viewableIndices, onViewableItemsChanged, createViewToken);
+ }
+ }
+ }, {
+ key: "resetViewableIndices",
+ value: function resetViewableIndices() {
+ this._viewableIndices = [];
+ }
+ }, {
+ key: "recordInteraction",
+ value: function recordInteraction() {
+ this._hasInteracted = true;
+ }
+ }, {
+ key: "_onUpdateSync",
+ value: function _onUpdateSync(viewableIndicesToCheck, onViewableItemsChanged, createViewToken) {
+ var _this2 = this;
+
+ viewableIndicesToCheck = viewableIndicesToCheck.filter(function (ii) {
+ return _this2._viewableIndices.includes(ii);
+ });
+ var prevItems = this._viewableItems;
+ var nextItems = new Map(viewableIndicesToCheck.map(function (ii) {
+ var viewable = createViewToken(ii, true);
+ return [viewable.key, viewable];
+ }));
+ var changed = [];
+
+ for (var _iterator = nextItems, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();;) {
+ var _ref4;
+
+ if (_isArray) {
+ if (_i >= _iterator.length) break;
+ _ref4 = _iterator[_i++];
+ } else {
+ _i = _iterator.next();
+ if (_i.done) break;
+ _ref4 = _i.value;
+ }
+
+ var _ref8 = _ref4;
+
+ var _ref3 = _slicedToArray(_ref8, 2);
+
+ var _key2 = _ref3[0];
+ var _viewable2 = _ref3[1];
+
+ if (!prevItems.has(_key2)) {
+ changed.push(_viewable2);
+ }
+ }
+
+ for (var _iterator2 = prevItems, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();;) {
+ var _ref7;
+
+ if (_isArray2) {
+ if (_i2 >= _iterator2.length) break;
+ _ref7 = _iterator2[_i2++];
+ } else {
+ _i2 = _iterator2.next();
+ if (_i2.done) break;
+ _ref7 = _i2.value;
+ }
+
+ var _ref9 = _ref7;
+
+ var _ref6 = _slicedToArray(_ref9, 2);
+
+ var _key3 = _ref6[0];
+ var _viewable3 = _ref6[1];
+
+ if (!nextItems.has(_key3)) {
+ changed.push(_objectSpread({}, _viewable3, {
+ isViewable: false
+ }));
+ }
+ }
+
+ if (changed.length > 0) {
+ this._viewableItems = nextItems;
+ onViewableItemsChanged({
+ viewableItems: Array.from(nextItems.values()),
+ changed: changed,
+ viewabilityConfig: this._config
+ });
+ }
+ }
+ }]);
+
+ return ViewabilityHelper;
+ }();
+
+ function _isViewable(viewAreaMode, viewablePercentThreshold, top, bottom, viewportHeight, itemLength) {
+ if (_isEntirelyVisible(top, bottom, viewportHeight)) {
+ return true;
+ } else {
+ var pixels = _getPixelsVisible(top, bottom, viewportHeight);
+
+ var percent = 100 * (viewAreaMode ? pixels / viewportHeight : pixels / itemLength);
+ return percent >= viewablePercentThreshold;
+ }
+ }
+
+ function _getPixelsVisible(top, bottom, viewportHeight) {
+ var visibleHeight = Math.min(bottom, viewportHeight) - Math.max(top, 0);
+ return Math.max(0, visibleHeight);
+ }
+
+ function _isEntirelyVisible(top, bottom, viewportHeight) {
+ return top >= 0 && bottom <= viewportHeight && bottom > top;
+ }
+
+ module.exports = ViewabilityHelper;
+},284,[32,37,3,4,19],"node_modules\\react-native\\Libraries\\Lists\\ViewabilityHelper.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _slicedToArray = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/slicedToArray");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[1], "invariant");
+
+ function elementsThatOverlapOffsets(offsets, itemCount, getFrameMetrics) {
+ var out = [];
+ var outLength = 0;
+
+ for (var ii = 0; ii < itemCount; ii++) {
+ var frame = getFrameMetrics(ii);
+ var trailingOffset = frame.offset + frame.length;
+
+ for (var kk = 0; kk < offsets.length; kk++) {
+ if (out[kk] == null && trailingOffset >= offsets[kk]) {
+ out[kk] = ii;
+ outLength++;
+
+ if (kk === offsets.length - 1) {
+ invariant(outLength === offsets.length, 'bad offsets input, should be in increasing order: %s', JSON.stringify(offsets));
+ return out;
+ }
+ }
+ }
+ }
+
+ return out;
+ }
+
+ function newRangeCount(prev, next) {
+ return next.last - next.first + 1 - Math.max(0, 1 + Math.min(next.last, prev.last) - Math.max(next.first, prev.first));
+ }
+
+ function computeWindowedRenderLimits(props, prev, getFrameMetricsApprox, scrollMetrics) {
+ var data = props.data,
+ getItemCount = props.getItemCount,
+ maxToRenderPerBatch = props.maxToRenderPerBatch,
+ windowSize = props.windowSize;
+ var itemCount = getItemCount(data);
+
+ if (itemCount === 0) {
+ return prev;
+ }
+
+ var offset = scrollMetrics.offset,
+ velocity = scrollMetrics.velocity,
+ visibleLength = scrollMetrics.visibleLength;
+ var visibleBegin = Math.max(0, offset);
+ var visibleEnd = visibleBegin + visibleLength;
+ var overscanLength = (windowSize - 1) * visibleLength;
+ var leadFactor = 0.5;
+ var fillPreference = velocity > 1 ? 'after' : velocity < -1 ? 'before' : 'none';
+ var overscanBegin = Math.max(0, visibleBegin - (1 - leadFactor) * overscanLength);
+ var overscanEnd = Math.max(0, visibleEnd + leadFactor * overscanLength);
+ var lastItemOffset = getFrameMetricsApprox(itemCount - 1).offset;
+
+ if (lastItemOffset < overscanBegin) {
+ return {
+ first: Math.max(0, itemCount - 1 - maxToRenderPerBatch),
+ last: itemCount - 1
+ };
+ }
+
+ var _elementsThatOverlapO = elementsThatOverlapOffsets([overscanBegin, visibleBegin, visibleEnd, overscanEnd], props.getItemCount(props.data), getFrameMetricsApprox),
+ _elementsThatOverlapO2 = _slicedToArray(_elementsThatOverlapO, 4),
+ overscanFirst = _elementsThatOverlapO2[0],
+ first = _elementsThatOverlapO2[1],
+ last = _elementsThatOverlapO2[2],
+ overscanLast = _elementsThatOverlapO2[3];
+
+ overscanFirst = overscanFirst == null ? 0 : overscanFirst;
+ first = first == null ? Math.max(0, overscanFirst) : first;
+ overscanLast = overscanLast == null ? itemCount - 1 : overscanLast;
+ last = last == null ? Math.min(overscanLast, first + maxToRenderPerBatch - 1) : last;
+ var visible = {
+ first: first,
+ last: last
+ };
+ var newCellCount = newRangeCount(prev, visible);
+
+ while (true) {
+ if (first <= overscanFirst && last >= overscanLast) {
+ break;
+ }
+
+ var maxNewCells = newCellCount >= maxToRenderPerBatch;
+ var firstWillAddMore = first <= prev.first || first > prev.last;
+ var firstShouldIncrement = first > overscanFirst && (!maxNewCells || !firstWillAddMore);
+ var lastWillAddMore = last >= prev.last || last < prev.first;
+ var lastShouldIncrement = last < overscanLast && (!maxNewCells || !lastWillAddMore);
+
+ if (maxNewCells && !firstShouldIncrement && !lastShouldIncrement) {
+ break;
+ }
+
+ if (firstShouldIncrement && !(fillPreference === 'after' && lastShouldIncrement && lastWillAddMore)) {
+ if (firstWillAddMore) {
+ newCellCount++;
+ }
+
+ first--;
+ }
+
+ if (lastShouldIncrement && !(fillPreference === 'before' && firstShouldIncrement && firstWillAddMore)) {
+ if (lastWillAddMore) {
+ newCellCount++;
+ }
+
+ last++;
+ }
+ }
+
+ if (!(last >= first && first >= 0 && last < itemCount && first >= overscanFirst && last <= overscanLast && first <= visible.first && last >= visible.last)) {
+ throw new Error('Bad window calculation ' + JSON.stringify({
+ first: first,
+ last: last,
+ itemCount: itemCount,
+ overscanFirst: overscanFirst,
+ overscanLast: overscanLast,
+ visible: visible
+ }));
+ }
+
+ return {
+ first: first,
+ last: last
+ };
+ }
+
+ var VirtualizeUtils = {
+ computeWindowedRenderLimits: computeWindowedRenderLimits,
+ elementsThatOverlapOffsets: elementsThatOverlapOffsets,
+ newRangeCount: newRangeCount
+ };
+ module.exports = VirtualizeUtils;
+},285,[37,19],"node_modules\\react-native\\Libraries\\Lists\\VirtualizeUtils.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var Image = _$$_REQUIRE(_dependencyMap[0], "Image");
+
+ var createAnimatedComponent = _$$_REQUIRE(_dependencyMap[1], "createAnimatedComponent");
+
+ module.exports = createAnimatedComponent(Image);
+},286,[287,266],"node_modules\\react-native\\Libraries\\Animated\\src\\components\\AnimatedImage.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _regeneratorRuntime = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/regenerator");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\Libraries\\Image\\Image.uwp.js";
+
+ var DeprecatedImagePropType = _$$_REQUIRE(_dependencyMap[2], "DeprecatedImagePropType");
+
+ var NativeModules = _$$_REQUIRE(_dependencyMap[3], "NativeModules");
+
+ var React = _$$_REQUIRE(_dependencyMap[4], "React");
+
+ var ReactNative = _$$_REQUIRE(_dependencyMap[5], "ReactNative");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[6], "StyleSheet");
+
+ 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');
+
+ function getSize(uri, success, failure) {
+ ImageViewManager.getSize(uri, success, failure || function () {
+ console.warn('Failed to get size for image: ' + uri);
+ });
+ }
+
+ function prefetch(url) {
+ return ImageViewManager.prefetchImage(url);
+ }
+
+ function queryCache(urls) {
+ return _regeneratorRuntime.async(function queryCache$(_context) {
+ while (1) {
+ switch (_context.prev = _context.next) {
+ case 0:
+ _context.next = 2;
+ return _regeneratorRuntime.awrap(ImageViewManager.queryCache(urls));
+
+ case 2:
+ return _context.abrupt("return", _context.sent);
+
+ case 3:
+ case "end":
+ return _context.stop();
+ }
+ }
+ });
+ }
+
+ var Image = function Image(props, forwardedRef) {
+ var source = resolveAssetSource(props.source) || {
+ uri: undefined,
+ width: undefined,
+ height: undefined
+ };
+ var sources;
+ var style;
+
+ if (Array.isArray(source)) {
+ style = flattenStyle([styles.base, props.style]) || {};
+ sources = source;
+ } else {
+ var _width = source.width,
+ _height = source.height,
+ uri = source.uri;
+ style = flattenStyle([{
+ width: _width,
+ height: _height
+ }, styles.base, props.style]) || {};
+ sources = [source];
+
+ if (uri === '') {
+ console.warn('source.uri should not be an empty string');
+ }
+ }
+
+ var resizeMode = props.resizeMode || style.resizeMode || 'cover';
+ var tintColor = style.tintColor;
+
+ if (props.src != null) {
+ console.warn('The component requires a `source` property rather than `src`.');
+ }
+
+ if (props.children != null) {
+ throw new Error('The component cannot contain children. If you want to render content on top of the image, consider using the component or absolute positioning.');
+ }
+
+ return React.createElement(RCTImageView, _extends({}, props, {
+ ref: forwardedRef,
+ style: style,
+ resizeMode: resizeMode,
+ tintColor: tintColor,
+ source: sources,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 113
+ }
+ }));
+ };
+
+ Image = React.forwardRef(Image);
+ Image.displayName = 'Image';
+ Image.getSize = getSize;
+ Image.prefetch = prefetch;
+ Image.queryCache = queryCache;
+ Image.resolveAssetSource = resolveAssetSource;
+ Image.propTypes = DeprecatedImagePropType;
+ var styles = StyleSheet.create({
+ base: {
+ overflow: 'hidden'
+ }
+ });
+ module.exports = Image;
+},287,[14,102,288,36,52,84,53,80,184,190],"Libraries\\Image\\Image.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var DeprecatedEdgeInsetsPropType = _$$_REQUIRE(_dependencyMap[0], "DeprecatedEdgeInsetsPropType");
+
+ var DeprecatedImageSourcePropType = _$$_REQUIRE(_dependencyMap[1], "DeprecatedImageSourcePropType");
+
+ var DeprecatedImageStylePropTypes = _$$_REQUIRE(_dependencyMap[2], "DeprecatedImageStylePropTypes");
+
+ var DeprecatedStyleSheetPropType = _$$_REQUIRE(_dependencyMap[3], "DeprecatedStyleSheetPropType");
+
+ var PropTypes = _$$_REQUIRE(_dependencyMap[4], "prop-types");
+
+ module.exports = {
+ style: DeprecatedStyleSheetPropType(DeprecatedImageStylePropTypes),
+ source: DeprecatedImageSourcePropType,
+ 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: DeprecatedEdgeInsetsPropType,
+ 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
+ };
+},288,[210,289,58,211,62],"node_modules\\react-native\\Libraries\\DeprecatedPropTypes\\DeprecatedImagePropType.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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;
+},289,[62],"node_modules\\react-native\\Libraries\\DeprecatedPropTypes\\DeprecatedImageSourcePropType.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var ScrollView = _$$_REQUIRE(_dependencyMap[0], "ScrollView");
+
+ var createAnimatedComponent = _$$_REQUIRE(_dependencyMap[1], "createAnimatedComponent");
+
+ module.exports = createAnimatedComponent(ScrollView);
+},290,[275,266],"node_modules\\react-native\\Libraries\\Animated\\src\\components\\AnimatedScrollView.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var SectionList = _$$_REQUIRE(_dependencyMap[0], "SectionList");
+
+ var createAnimatedComponent = _$$_REQUIRE(_dependencyMap[1], "createAnimatedComponent");
+
+ module.exports = createAnimatedComponent(SectionList);
+},291,[292,266],"node_modules\\react-native\\Libraries\\Animated\\src\\components\\AnimatedSectionList.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/defineProperty");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Lists\\SectionList.js";
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var Platform = _$$_REQUIRE(_dependencyMap[7], "Platform");
+
+ var React = _$$_REQUIRE(_dependencyMap[8], "React");
+
+ var ScrollView = _$$_REQUIRE(_dependencyMap[9], "ScrollView");
+
+ var VirtualizedSectionList = _$$_REQUIRE(_dependencyMap[10], "VirtualizedSectionList");
+
+ var defaultProps = _objectSpread({}, VirtualizedSectionList.defaultProps, {
+ stickySectionHeadersEnabled: Platform.OS === 'ios'
+ });
+
+ var SectionList = function (_React$PureComponent) {
+ _inherits(SectionList, _React$PureComponent);
+
+ function SectionList() {
+ var _getPrototypeOf2;
+
+ var _this;
+
+ _classCallCheck(this, SectionList);
+
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(SectionList)).call.apply(_getPrototypeOf2, [this].concat(args)));
+
+ _this._captureRef = function (ref) {
+ _this._wrapperListRef = ref;
+ };
+
+ return _this;
+ }
+
+ _createClass(SectionList, [{
+ key: "scrollToLocation",
+ value: function scrollToLocation(params) {
+ if (this._wrapperListRef != null) {
+ this._wrapperListRef.scrollToLocation(params);
+ }
+ }
+ }, {
+ key: "recordInteraction",
+ value: function recordInteraction() {
+ var listRef = this._wrapperListRef && this._wrapperListRef.getListRef();
+
+ listRef && listRef.recordInteraction();
+ }
+ }, {
+ key: "flashScrollIndicators",
+ value: function flashScrollIndicators() {
+ var listRef = this._wrapperListRef && this._wrapperListRef.getListRef();
+
+ listRef && listRef.flashScrollIndicators();
+ }
+ }, {
+ key: "getScrollResponder",
+ value: function getScrollResponder() {
+ var listRef = this._wrapperListRef && this._wrapperListRef.getListRef();
+
+ if (listRef) {
+ return listRef.getScrollResponder();
+ }
+ }
+ }, {
+ key: "getScrollableNode",
+ value: function getScrollableNode() {
+ var listRef = this._wrapperListRef && this._wrapperListRef.getListRef();
+
+ if (listRef) {
+ return listRef.getScrollableNode();
+ }
+ }
+ }, {
+ key: "setNativeProps",
+ value: function setNativeProps(props) {
+ var listRef = this._wrapperListRef && this._wrapperListRef.getListRef();
+
+ if (listRef) {
+ listRef.setNativeProps(props);
+ }
+ }
+ }, {
+ key: "render",
+ value: function render() {
+ return React.createElement(VirtualizedSectionList, _extends({}, this.props, {
+ ref: this._captureRef,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 334
+ }
+ }));
+ }
+ }]);
+
+ return SectionList;
+ }(React.PureComponent);
+
+ SectionList.defaultProps = defaultProps;
+ module.exports = SectionList;
+},292,[14,3,4,5,8,9,32,35,52,275,293],"node_modules\\react-native\\Libraries\\Lists\\SectionList.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/defineProperty");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _assertThisInitialized = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/assertThisInitialized");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/createClass");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Lists\\VirtualizedSectionList.js";
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var Platform = _$$_REQUIRE(_dependencyMap[8], "Platform");
+
+ var React = _$$_REQUIRE(_dependencyMap[9], "React");
+
+ var View = _$$_REQUIRE(_dependencyMap[10], "View");
+
+ var VirtualizedList = _$$_REQUIRE(_dependencyMap[11], "VirtualizedList");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[12], "invariant");
+
+ var VirtualizedSectionList = function (_React$PureComponent) {
+ _inherits(VirtualizedSectionList, _React$PureComponent);
+
+ _createClass(VirtualizedSectionList, [{
+ key: "scrollToLocation",
+ value: function scrollToLocation(params) {
+ var index = Platform.OS === 'ios' ? params.itemIndex : 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._selectRowAboveIndexPath = function (rowIndexPath) {
+ var sectionIndex = rowIndexPath.sectionIndex;
+
+ if (sectionIndex >= _this.props.sections.length) {
+ return rowIndexPath;
+ }
+
+ var count = _this.props.sections[sectionIndex].data.length;
+ var row = rowIndexPath.rowIndex;
+ var rowAbove = row - 1;
+
+ if (rowAbove < 0) {
+ if (sectionIndex > 0) {
+ sectionIndex = sectionIndex - 1;
+ rowAbove = Math.max(0, _this.props.sections[sectionIndex].data.length - 1);
+ } else {
+ rowAbove = row;
+ }
+ }
+
+ var nextIndexPath = {
+ sectionIndex: sectionIndex,
+ rowIndex: rowAbove
+ };
+
+ _this.setState(function (state) {
+ return {
+ selectedRowIndexPath: nextIndexPath
+ };
+ });
+
+ return nextIndexPath;
+ };
+
+ _this._selectRowBelowIndexPath = function (rowIndexPath) {
+ var sectionIndex = rowIndexPath.sectionIndex;
+
+ if (sectionIndex >= _this.props.sections.length) {
+ return rowIndexPath;
+ }
+
+ var count = _this.props.sections[sectionIndex].data.length;
+ var row = rowIndexPath.rowIndex;
+ var rowBelow = row + 1;
+
+ if (rowBelow > count - 1) {
+ if (sectionIndex < _this.props.sections.length - 1) {
+ sectionIndex = sectionIndex + 1;
+ rowBelow = 0;
+ } else {
+ rowBelow = row;
+ }
+ }
+
+ var nextIndexPath = {
+ sectionIndex: sectionIndex,
+ rowIndex: rowBelow
+ };
+
+ _this.setState(function (state) {
+ return {
+ selectedRowIndexPath: nextIndexPath
+ };
+ });
+
+ return nextIndexPath;
+ };
+
+ _this._ensureItemAtIndexPathIsVisible = function (rowIndexPath) {
+ var index = rowIndexPath.rowIndex + 1;
+
+ for (var ii = 0; ii < rowIndexPath.sectionIndex; ii++) {
+ index += _this.props.sections[ii].data.length + 2;
+ }
+
+ _this._listRef.ensureItemAtIndexIsVisible(index);
+ };
+
+ _this._handleKeyDown = function (e) {
+ if (Platform.OS === 'macos') {
+ var event = e.nativeEvent;
+ var key = event.key;
+ var prevIndexPath = _this.state.selectedRowIndexPath;
+ var nextIndexPath = null;
+ var sectionIndex = _this.state.selectedRowIndexPath.sectionIndex;
+ var rowIndex = _this.state.selectedRowIndexPath.rowIndex;
+
+ if (key === 'DOWN_ARROW') {
+ nextIndexPath = _this._selectRowBelowIndexPath(prevIndexPath);
+
+ _this._ensureItemAtIndexPathIsVisible(nextIndexPath);
+
+ if (_this.props.onSelectionChanged) {
+ var _item = _this.props.sections[sectionIndex].data[rowIndex];
+
+ _this.props.onSelectionChanged({
+ previousSelection: prevIndexPath,
+ newSelection: nextIndexPath,
+ item: _item
+ });
+ }
+ } else if (key === 'UP_ARROW') {
+ nextIndexPath = _this._selectRowAboveIndexPath(prevIndexPath);
+
+ _this._ensureItemAtIndexPathIsVisible(nextIndexPath);
+
+ if (_this.props.onSelectionChanged) {
+ var _item2 = _this.props.sections[sectionIndex].data[rowIndex];
+
+ _this.props.onSelectionChanged({
+ previousSelection: prevIndexPath,
+ newSelection: nextIndexPath,
+ item: _item2
+ });
+ }
+ } else if (key === 'ENTER') {
+ if (_this.props.onSelectionEntered) {
+ var _item3 = _this.props.sections[sectionIndex].data[rowIndex];
+
+ _this.props.onSelectionEntered(_item3);
+ }
+ }
+ }
+ };
+
+ _this._keyExtractor = function (item, index) {
+ var info = _this._subExtractor(index);
+
+ return info && info.key || String(index);
+ };
+
+ _this._convertViewable = function (viewable) {
+ invariant(viewable.index != null, 'Received a broken ViewToken');
+
+ var info = _this._subExtractor(viewable.index);
+
+ if (!info) {
+ return null;
+ }
+
+ var keyExtractor = info.section.keyExtractor || _this.props.keyExtractor;
+ return _objectSpread({}, viewable, {
+ index: info.index,
+ key: keyExtractor(viewable.item, info.index),
+ section: info.section
+ });
+ };
+
+ _this._onViewableItemsChanged = function (_ref) {
+ var viewableItems = _ref.viewableItems,
+ changed = _ref.changed;
+
+ if (_this.props.onViewableItemsChanged) {
+ _this.props.onViewableItemsChanged({
+ viewableItems: viewableItems.map(_this._convertViewable, _assertThisInitialized(_this)).filter(Boolean),
+ changed: changed.map(_this._convertViewable, _assertThisInitialized(_this)).filter(Boolean)
+ });
+ }
+ };
+
+ _this._isItemSelected = function (item) {
+ var isSelected = false;
+
+ if (_this.state.selectedRowIndexPath) {
+ var selection = _this.state.selectedRowIndexPath;
+ var sections = _this.props.sections;
+
+ if (sections && selection.sectionIndex < sections.length) {
+ var section = sections[selection.sectionIndex];
+
+ if (selection.rowIndex < section.data.length) {
+ var selectedItem = section.data[selection.rowIndex];
+ isSelected = item == selectedItem;
+ }
+ }
+ }
+
+ return isSelected;
+ };
+
+ _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,
+ isSelected: _this._isItemSelected(item),
+ 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: 477
+ }
+ });
+ }
+ };
+
+ _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
+ }),
+ selectedRowIndexPath: {
+ sectionIndex: 0,
+ rowIndex: -1
+ }
+ };
+ }
+ }, {
+ key: "render",
+ value: function render() {
+ var keyEventHandler = this.props.onKeyDown;
+
+ if (!keyEventHandler) {
+ keyEventHandler = this.props.enableSelectionOnKeyPress ? this._handleKeyDown : null;
+ }
+
+ return React.createElement(VirtualizedList, _extends({}, this.state.childProps, {
+ ref: this._captureRef,
+ onKeyDown: keyEventHandler
+ }, this.state.selectedRowIndexPath, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 339
+ }
+ }));
+ }
+ }, {
+ 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 section = this.props.sections[ii];
+ var key = section.key || String(ii);
+ itemIndex -= 1;
+
+ if (itemIndex >= section.data.length + 1) {
+ itemIndex -= section.data.length + 1;
+ } else if (itemIndex === -1) {
+ return {
+ section: section,
+ key: key + ':header',
+ index: null,
+ header: true,
+ trailingSection: this.props.sections[ii + 1]
+ };
+ } else if (itemIndex === section.data.length) {
+ return {
+ section: section,
+ key: key + ':footer',
+ index: null,
+ header: false,
+ trailingSection: this.props.sections[ii + 1]
+ };
+ } else {
+ var keyExtractor = section.keyExtractor || defaultKeyExtractor;
+ return {
+ section: section,
+ key: key + ':' + keyExtractor(section.data[itemIndex], itemIndex),
+ index: itemIndex,
+ leadingItem: section.data[itemIndex - 1],
+ leadingSection: this.props.sections[ii - 1],
+ trailingItem: section.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;
+ }
+ }]);
+
+ return VirtualizedSectionList;
+ }(React.PureComponent);
+
+ VirtualizedSectionList.defaultProps = _objectSpread({}, VirtualizedList.defaultProps, {
+ data: []
+ });
+
+ var ItemWithSeparator = function (_React$Component) {
+ _inherits(ItemWithSeparator, _React$Component);
+
+ function ItemWithSeparator() {
+ var _getPrototypeOf2;
+
+ var _this2;
+
+ _classCallCheck(this, ItemWithSeparator);
+
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ _this2 = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(ItemWithSeparator)).call.apply(_getPrototypeOf2, [this].concat(args)));
+ _this2.state = {
+ separatorProps: {
+ highlighted: false,
+ leadingItem: _this2.props.item,
+ leadingSection: _this2.props.leadingSection,
+ section: _this2.props.section,
+ trailingItem: _this2.props.trailingItem,
+ trailingSection: _this2.props.trailingSection
+ },
+ leadingSeparatorProps: {
+ highlighted: false,
+ leadingItem: _this2.props.leadingItem,
+ leadingSection: _this2.props.leadingSection,
+ section: _this2.props.section,
+ trailingItem: _this2.props.item,
+ trailingSection: _this2.props.trailingSection
+ }
+ };
+ _this2._separators = {
+ highlight: function highlight() {
+ ['leading', 'trailing'].forEach(function (s) {
+ return _this2._separators.updateProps(s, {
+ highlighted: true
+ });
+ });
+ },
+ unhighlight: function unhighlight() {
+ ['leading', 'trailing'].forEach(function (s) {
+ return _this2._separators.updateProps(s, {
+ highlighted: false
+ });
+ });
+ },
+ updateProps: function updateProps(select, newProps) {
+ var _this2$props = _this2.props,
+ LeadingSeparatorComponent = _this2$props.LeadingSeparatorComponent,
+ cellKey = _this2$props.cellKey,
+ prevCellKey = _this2$props.prevCellKey;
+
+ if (select === 'leading' && LeadingSeparatorComponent != null) {
+ _this2.setState(function (state) {
+ return {
+ leadingSeparatorProps: _objectSpread({}, state.leadingSeparatorProps, {}, newProps)
+ };
+ });
+ } else {
+ _this2.props.onUpdateSeparator(select === 'leading' && prevCellKey || cellKey, newProps);
+ }
+ }
+ };
+ return _this2;
+ }
+
+ _createClass(ItemWithSeparator, [{
+ key: "updateSeparatorProps",
+ value: function updateSeparatorProps(newProps) {
+ this.setState(function (state) {
+ return {
+ separatorProps: _objectSpread({}, state.separatorProps, {}, newProps)
+ };
+ });
+ }
+ }, {
+ key: "render",
+ value: function render() {
+ var _this$props = this.props,
+ LeadingSeparatorComponent = _this$props.LeadingSeparatorComponent,
+ SeparatorComponent = _this$props.SeparatorComponent,
+ item = _this$props.item,
+ index = _this$props.index,
+ isSelected = _this$props.isSelected,
+ section = _this$props.section;
+ var element = this.props.renderItem({
+ item: item,
+ index: index,
+ isSelected: isSelected,
+ section: section,
+ separators: this._separators
+ });
+ var leadingSeparator = LeadingSeparatorComponent && React.createElement(LeadingSeparatorComponent, _extends({}, this.state.leadingSeparatorProps, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 667
+ }
+ }));
+ var separator = SeparatorComponent && React.createElement(SeparatorComponent, _extends({}, this.state.separatorProps, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 670
+ }
+ }));
+ return leadingSeparator || separator ? React.createElement(View, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 676
+ }
+ }, leadingSeparator, element, separator) : element;
+ }
+ }], [{
+ key: "getDerivedStateFromProps",
+ value: function getDerivedStateFromProps(props, prevState) {
+ return {
+ separatorProps: _objectSpread({}, prevState.separatorProps, {
+ leadingItem: props.item,
+ leadingSection: props.leadingSection,
+ section: props.section,
+ trailingItem: props.trailingItem,
+ trailingSection: props.trailingSection
+ }),
+ leadingSeparatorProps: _objectSpread({}, prevState.leadingSeparatorProps, {
+ leadingItem: props.leadingItem,
+ leadingSection: props.leadingSection,
+ section: props.section,
+ trailingItem: props.item,
+ trailingSection: props.trailingSection
+ })
+ };
+ }
+ }]);
+
+ return ItemWithSeparator;
+ }(React.Component);
+
+ function getItem(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;
+},293,[14,32,3,5,8,7,4,9,35,52,81,269,19],"node_modules\\react-native\\Libraries\\Lists\\VirtualizedSectionList.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var Text = _$$_REQUIRE(_dependencyMap[0], "Text");
+
+ var createAnimatedComponent = _$$_REQUIRE(_dependencyMap[1], "createAnimatedComponent");
+
+ module.exports = createAnimatedComponent(Text);
+},294,[208,266],"node_modules\\react-native\\Libraries\\Animated\\src\\components\\AnimatedText.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var View = _$$_REQUIRE(_dependencyMap[0], "View");
+
+ var createAnimatedComponent = _$$_REQUIRE(_dependencyMap[1], "createAnimatedComponent");
+
+ module.exports = createAnimatedComponent(View);
+},295,[81,266],"node_modules\\react-native\\Libraries\\Animated\\src\\components\\AnimatedView.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var __extends = this && this.__extends || function () {
+ var _extendStatics = function extendStatics(d, b) {
+ _extendStatics = Object.setPrototypeOf || {
+ __proto__: []
+ } instanceof Array && function (d, b) {
+ d.__proto__ = b;
+ } || function (d, b) {
+ for (var p in b) {
+ if (b.hasOwnProperty(p)) d[p] = b[p];
+ }
+ };
+
+ return _extendStatics(d, b);
+ };
+
+ return function (d, b) {
+ _extendStatics(d, b);
+
+ function __() {
+ this.constructor = d;
+ }
+
+ d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+ };
+ }();
+
+ var __assign = this && this.__assign || function () {
+ __assign = Object.assign || function (t) {
+ for (var s, i = 1, n = arguments.length; i < n; i++) {
+ s = arguments[i];
+
+ for (var p in s) {
+ if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+ }
+ }
+
+ return t;
+ };
+
+ return __assign.apply(this, arguments);
+ };
+
+ Object.defineProperty(exports, "__esModule", {
+ value: true
+ });
+
+ var React = _$$_REQUIRE(_dependencyMap[0], "react");
+
+ var react_native_1 = _$$_REQUIRE(_dependencyMap[1], "react-native");
+
+ var styles = react_native_1.StyleSheet.create({
+ rctCheckBox: {
+ height: 32,
+ width: 32
+ }
+ });
+ var RCTCheckBox = react_native_1.requireNativeComponent('RCTCheckBox');
+
+ var CheckBox = function (_super) {
+ __extends(CheckBox, _super);
+
+ function CheckBox(props) {
+ var _this = _super.call(this, props) || this;
+
+ _this._setRef = function (checkBox) {
+ _this._rctCheckBox = checkBox;
+ };
+
+ _this._onChange = function (event) {
+ if (_this._rctCheckBox) {
+ _this._rctCheckBox.setNativeProps({
+ checked: _this.props.checked
+ });
+ }
+
+ _this.props.onChange && _this.props.onChange(event);
+ _this.props.onValueChange && _this.props.onValueChange(event.nativeEvent.value);
+ };
+
+ _this._rctCheckBox = React.createRef();
+ return _this;
+ }
+
+ CheckBox.prototype.render = function () {
+ var props = __assign({}, this.props);
+
+ props.onStartShouldSetResponder = function () {
+ return true;
+ };
+
+ props.onResponderTerminationRequest = function () {
+ return false;
+ };
+
+ props.style = [styles.rctCheckBox, this.props.style];
+ return React.createElement(RCTCheckBox, __assign({}, props, {
+ onChange: this._onChange,
+ ref: this._setRef
+ }));
+ };
+
+ return CheckBox;
+ }(React.Component);
+
+ exports.CheckBox = CheckBox;
+ exports.default = CheckBox;
+},296,[11,18],"Libraries\\Components\\CheckBox\\CheckBox.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "UnimplementedView");
+},297,[196],"Libraries\\Components\\DatePicker\\DatePickerIOS.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "UnimplementedView");
+},298,[196],"Libraries\\Components\\DrawerAndroid\\DrawerLayoutAndroid.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _objectWithoutProperties = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/objectWithoutProperties");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Image\\ImageBackground.js";
+
+ var Image = _$$_REQUIRE(_dependencyMap[7], "Image");
+
+ var React = _$$_REQUIRE(_dependencyMap[8], "React");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[9], "StyleSheet");
+
+ var View = _$$_REQUIRE(_dependencyMap[10], "View");
+
+ var ensureComponentIsNative = _$$_REQUIRE(_dependencyMap[11], "ensureComponentIsNative");
+
+ var ImageBackground = function (_React$Component) {
+ _inherits(ImageBackground, _React$Component);
+
+ function ImageBackground() {
+ var _getPrototypeOf2;
+
+ var _this;
+
+ _classCallCheck(this, ImageBackground);
+
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(ImageBackground)).call.apply(_getPrototypeOf2, [this].concat(args)));
+ _this._viewRef = null;
+
+ _this._captureRef = function (ref) {
+ _this._viewRef = ref;
+ };
+
+ return _this;
+ }
+
+ _createClass(ImageBackground, [{
+ key: "setNativeProps",
+ value: function setNativeProps(props) {
+ var viewRef = this._viewRef;
+
+ if (viewRef) {
+ 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, {
+ accessibilityIgnoresInvertColors: true,
+ 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: 67
+ }
+ })), children);
+ }
+ }]);
+
+ return ImageBackground;
+ }(React.Component);
+
+ module.exports = ImageBackground;
+},299,[14,33,3,4,5,8,9,287,52,53,81,300],"node_modules\\react-native\\Libraries\\Image\\ImageBackground.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var invariant = _$$_REQUIRE(_dependencyMap[0], "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;
+},300,[19],"node_modules\\react-native\\Libraries\\Components\\Touchable\\ensureComponentIsNative.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var RCTImageEditingManager = _$$_REQUIRE(_dependencyMap[2], "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;
+},301,[3,4,36],"node_modules\\react-native\\Libraries\\Image\\ImageEditor.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var RCTImageStoreManager = _$$_REQUIRE(_dependencyMap[2], "NativeModules").ImageStoreManager;
+
+ var Platform = _$$_REQUIRE(_dependencyMap[3], "Platform");
+
+ var warnOnce = _$$_REQUIRE(_dependencyMap[4], "warnOnce");
+
+ function warnUnimplementedMethod(methodName) {
+ warnOnce("imagestore-" + methodName, "react-native: ImageStore." + methodName + "() is not implemented on " + Platform.OS);
+ }
+
+ 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 {
+ warnUnimplementedMethod('hasImageForTag');
+ }
+ }
+ }, {
+ key: "removeImageForTag",
+ value: function removeImageForTag(uri) {
+ if (RCTImageStoreManager.removeImageForTag) {
+ RCTImageStoreManager.removeImageForTag(uri);
+ } else {
+ warnUnimplementedMethod('removeImageForTag');
+ }
+ }
+ }, {
+ key: "addImageFromBase64",
+ value: function addImageFromBase64(base64ImageData, success, failure) {
+ if (RCTImageStoreManager.addImageFromBase64) {
+ RCTImageStoreManager.addImageFromBase64(base64ImageData, success, failure);
+ } else {
+ warnUnimplementedMethod('addImageFromBase64');
+ }
+ }
+ }, {
+ key: "getBase64ForTag",
+ value: function getBase64ForTag(uri, success, failure) {
+ if (RCTImageStoreManager.getBase64ForTag) {
+ RCTImageStoreManager.getBase64ForTag(uri, success, failure);
+ } else {
+ warnUnimplementedMethod('getBase64ForTag');
+ }
+ }
+ }]);
+
+ return ImageStore;
+ }();
+
+ module.exports = ImageStore;
+},302,[3,4,36,35,20],"node_modules\\react-native\\Libraries\\Image\\ImageStore.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Components\\TextInput\\InputAccessoryView.js";
+
+ var DeprecatedColorPropType = _$$_REQUIRE(_dependencyMap[5], "DeprecatedColorPropType");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[6], "Platform");
+
+ var React = _$$_REQUIRE(_dependencyMap[7], "React");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[8], "StyleSheet");
+
+ var RCTInputAccessoryViewNativeComponent = _$$_REQUIRE(_dependencyMap[9], "RCTInputAccessoryViewNativeComponent");
+
+ var InputAccessoryView = function (_React$Component) {
+ _inherits(InputAccessoryView, _React$Component);
+
+ function InputAccessoryView() {
+ _classCallCheck(this, InputAccessoryView);
+
+ return _possibleConstructorReturn(this, _getPrototypeOf(InputAccessoryView).apply(this, arguments));
+ }
+
+ _createClass(InputAccessoryView, [{
+ key: "render",
+ value: function render() {
+ if (Platform.OS !== 'ios') {
+ console.warn(' is only supported on iOS.');
+ }
+
+ if (React.Children.count(this.props.children) === 0) {
+ return null;
+ }
+
+ return React.createElement(RCTInputAccessoryViewNativeComponent, {
+ style: [this.props.style, styles.container],
+ nativeID: this.props.nativeID,
+ backgroundColor: this.props.backgroundColor,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 101
+ }
+ }, this.props.children);
+ }
+ }]);
+
+ return InputAccessoryView;
+ }(React.Component);
+
+ var styles = StyleSheet.create({
+ container: {
+ position: 'absolute'
+ }
+ });
+ module.exports = InputAccessoryView;
+},303,[3,4,5,8,9,59,35,52,53,304],"node_modules\\react-native\\Libraries\\Components\\TextInput\\InputAccessoryView.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var React = _$$_REQUIRE(_dependencyMap[0], "React");
+
+ var requireNativeComponent = _$$_REQUIRE(_dependencyMap[1], "requireNativeComponent");
+
+ module.exports = requireNativeComponent('RCTInputAccessoryView');
+},304,[52,184],"node_modules\\react-native\\Libraries\\Components\\TextInput\\RCTInputAccessoryViewNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _objectWithoutProperties = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/objectWithoutProperties");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Components\\Keyboard\\KeyboardAvoidingView.js";
+
+ var Keyboard = _$$_REQUIRE(_dependencyMap[7], "Keyboard");
+
+ var LayoutAnimation = _$$_REQUIRE(_dependencyMap[8], "LayoutAnimation");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[9], "Platform");
+
+ var React = _$$_REQUIRE(_dependencyMap[10], "React");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[11], "StyleSheet");
+
+ var View = _$$_REQUIRE(_dependencyMap[12], "View");
+
+ var KeyboardAvoidingView = function (_React$Component) {
+ _inherits(KeyboardAvoidingView, _React$Component);
+
+ function KeyboardAvoidingView(props) {
+ var _this;
+
+ _classCallCheck(this, KeyboardAvoidingView);
+
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(KeyboardAvoidingView).call(this, props));
+ _this._frame = null;
+ _this._subscriptions = [];
+
+ _this._onKeyboardChange = function (event) {
+ if (event == null) {
+ _this.setState({
+ bottom: 0
+ });
+
+ return;
+ }
+
+ var duration = event.duration,
+ easing = event.easing,
+ endCoordinates = event.endCoordinates;
+
+ var height = _this._relativeKeyboardHeight(endCoordinates);
+
+ if (_this.state.bottom === height) {
+ return;
+ }
+
+ if (duration && easing) {
+ LayoutAnimation.configureNext({
+ duration: duration > 10 ? duration : 10,
+ update: {
+ duration: duration > 10 ? duration : 10,
+ type: LayoutAnimation.Types[easing] || 'keyboard'
+ }
+ });
+ }
+
+ _this.setState({
+ bottom: height
+ });
+ };
+
+ _this._onLayout = function (event) {
+ _this._frame = event.nativeEvent.layout;
+ };
+
+ _this.state = {
+ bottom: 0
+ };
+ _this.viewRef = React.createRef();
+ return _this;
+ }
+
+ _createClass(KeyboardAvoidingView, [{
+ key: "_relativeKeyboardHeight",
+ value: function _relativeKeyboardHeight(keyboardFrame) {
+ var frame = this._frame;
+
+ if (!frame || !keyboardFrame) {
+ return 0;
+ }
+
+ var keyboardY = keyboardFrame.screenY - this.props.keyboardVerticalOffset;
+ return Math.max(frame.y + frame.height - keyboardY, 0);
+ }
+ }, {
+ key: "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 && this.state.bottom > 0) {
+ heightStyle = {
+ height: this._frame.height - bottomHeight,
+ flex: 0
+ };
+ }
+
+ return React.createElement(View, _extends({
+ ref: this.viewRef,
+ style: StyleSheet.compose(style, heightStyle),
+ onLayout: this._onLayout
+ }, props, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 174
+ }
+ }), children);
+
+ case 'position':
+ return React.createElement(View, _extends({
+ ref: this.viewRef,
+ style: style,
+ onLayout: this._onLayout
+ }, props, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 188
+ }
+ }), React.createElement(View, {
+ style: StyleSheet.compose(contentContainerStyle, {
+ bottom: bottomHeight
+ }),
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 193
+ }
+ }, children));
+
+ case 'padding':
+ return React.createElement(View, _extends({
+ ref: this.viewRef,
+ style: StyleSheet.compose(style, {
+ paddingBottom: bottomHeight
+ }),
+ onLayout: this._onLayout
+ }, props, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 207
+ }
+ }), children);
+
+ default:
+ return React.createElement(View, _extends({
+ ref: this.viewRef,
+ onLayout: this._onLayout,
+ style: style
+ }, props, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 221
+ }
+ }), children);
+ }
+ }
+ }]);
+
+ return KeyboardAvoidingView;
+ }(React.Component);
+
+ KeyboardAvoidingView.defaultProps = {
+ enabled: true,
+ keyboardVerticalOffset: 0
+ };
+ module.exports = KeyboardAvoidingView;
+},305,[14,33,3,4,5,8,9,278,279,35,52,53,81],"node_modules\\react-native\\Libraries\\Components\\Keyboard\\KeyboardAvoidingView.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _objectWithoutProperties = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/objectWithoutProperties");
+
+ var _extends = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/extends");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Lists\\ListView\\ListView.js";
+
+ var InternalListViewType = _$$_REQUIRE(_dependencyMap[2], "InternalListViewType");
+
+ var ListViewDataSource = _$$_REQUIRE(_dependencyMap[3], "ListViewDataSource");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[4], "Platform");
+
+ var React = _$$_REQUIRE(_dependencyMap[5], "React");
+
+ var ReactNative = _$$_REQUIRE(_dependencyMap[6], "ReactNative");
+
+ var RCTScrollViewManager = _$$_REQUIRE(_dependencyMap[7], "NativeModules").ScrollViewManager;
+
+ var ScrollView = _$$_REQUIRE(_dependencyMap[8], "ScrollView");
+
+ var ScrollResponder = _$$_REQUIRE(_dependencyMap[9], "ScrollResponder");
+
+ var StaticRenderer = _$$_REQUIRE(_dependencyMap[10], "StaticRenderer");
+
+ 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',
+ _rafIds: [],
+ _childFrames: [],
+ _sentEndForContentLength: null,
+ _scrollComponent: null,
+ _prevRenderedRowsCount: 0,
+ _visibleRows: {},
+ scrollProperties: {},
+ mixins: [ScrollResponder.Mixin],
+ statics: {
+ DataSource: ListViewDataSource
+ },
+ 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: 324
+ }
+ }));
+ },
+ 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 && this._scrollComponent.getInnerViewNode();
+ },
+ UNSAFE_componentWillMount: function UNSAFE_componentWillMount() {
+ this.scrollProperties = {
+ visibleLength: null,
+ contentLength: null,
+ offset: 0
+ };
+ this._rafIds = [];
+ this._childFrames = [];
+ this._visibleRows = {};
+ this._prevRenderedRowsCount = 0;
+ this._sentEndForContentLength = null;
+ },
+ componentWillUnmount: function componentWillUnmount() {
+ this._rafIds.forEach(cancelAnimationFrame);
+
+ this._rafIds = [];
+ },
+ 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], "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: 463
+ }
+ });
+ 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: 492
+ }
+ }, 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);
+ },
+ _requestAnimationFrame: function _requestAnimationFrame(fn) {
+ var _this4 = this;
+
+ var rafId = requestAnimationFrame(function () {
+ _this4._rafIds = _this4._rafIds.filter(function (id) {
+ return id !== rafId;
+ });
+ fn();
+ });
+
+ this._rafIds.push(rafId);
+ },
+ _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 _this5 = this;
+
+ this.setState(function (state, props) {
+ var rowsToRender = Math.min(state.curRenderedRowsCount + props.pageSize, props.enableEmptySections ? props.dataSource.getRowAndSectionCount() : props.dataSource.getRowCount());
+ _this5._prevRenderedRowsCount = state.curRenderedRowsCount;
+ return {
+ curRenderedRowsCount: rowsToRender
+ };
+ }, function () {
+ _this5._measureAndUpdateScrollProps();
+
+ _this5._prevRenderedRowsCount = _this5.state.curRenderedRowsCount;
+ });
+ },
+ _getDistanceFromEnd: function _getDistanceFromEnd(scrollProperties) {
+ return scrollProperties.contentLength - scrollProperties.visibleLength - scrollProperties.offset;
+ },
+ _updateVisibleRows: function _updateVisibleRows(updatedFrames) {
+ var _this6 = this;
+
+ if (!this.props.onChangeVisibleRows) {
+ return;
+ }
+
+ if (updatedFrames) {
+ updatedFrames.forEach(function (newFrame) {
+ _this6._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;
+},306,[33,14,307,308,35,52,84,36,275,276,310,81,311,227,309,204,21,19],"node_modules\\react-native\\Libraries\\Lists\\ListView\\ListView.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var React = _$$_REQUIRE(_dependencyMap[5], "React");
+
+ var ListViewDataSource = _$$_REQUIRE(_dependencyMap[6], "ListViewDataSource");
+
+ var InternalListViewType = function (_React$Component) {
+ "use strict";
+
+ _inherits(InternalListViewType, _React$Component);
+
+ 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) {}
+ }]);
+
+ return InternalListViewType;
+ }(React.Component);
+
+ InternalListViewType.DataSource = ListViewDataSource;
+ module.exports = InternalListViewType;
+},307,[3,4,5,8,9,52,308],"node_modules\\react-native\\Libraries\\Lists\\ListView\\InternalListViewType.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _toConsumableArray = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/toConsumableArray");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[3], "invariant");
+
+ var isEmpty = _$$_REQUIRE(_dependencyMap[4], "isEmpty");
+
+ var warning = _$$_REQUIRE(_dependencyMap[5], "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;
+},308,[43,3,4,19,309,21],"node_modules\\react-native\\Libraries\\Lists\\ListView\\ListViewDataSource.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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;
+},309,[],"node_modules\\react-native\\Libraries\\vendor\\core\\isEmpty.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var React = _$$_REQUIRE(_dependencyMap[5], "React");
+
+ var StaticRenderer = function (_React$Component) {
+ _inherits(StaticRenderer, _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();
+ }
+ }]);
+
+ return StaticRenderer;
+ }(React.Component);
+
+ module.exports = StaticRenderer;
+},310,[3,4,5,8,9,52],"node_modules\\react-native\\Libraries\\Components\\StaticRenderer.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var React = _$$_REQUIRE(_dependencyMap[1], "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;
+},311,[32,11],"node_modules\\react-clone-referenced-element\\cloneReferencedElement.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "UnimplementedView");
+},312,[196],"Libraries\\Components\\MaskedView\\MaskedViewIOS.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Modal\\Modal.js",
+ _container;
+
+ var AppContainer = _$$_REQUIRE(_dependencyMap[6], "AppContainer");
+
+ var I18nManager = _$$_REQUIRE(_dependencyMap[7], "I18nManager");
+
+ var NativeEventEmitter = _$$_REQUIRE(_dependencyMap[8], "NativeEventEmitter");
+
+ var NativeModules = _$$_REQUIRE(_dependencyMap[9], "NativeModules");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[10], "Platform");
+
+ var React = _$$_REQUIRE(_dependencyMap[11], "React");
+
+ var PropTypes = _$$_REQUIRE(_dependencyMap[12], "prop-types");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[13], "StyleSheet");
+
+ var View = _$$_REQUIRE(_dependencyMap[14], "View");
+
+ var RCTModalHostView = _$$_REQUIRE(_dependencyMap[15], "RCTModalHostViewNativeComponent");
+
+ var ModalEventEmitter = Platform.OS === 'ios' && NativeModules.ModalManager ? new NativeEventEmitter(NativeModules.ModalManager) : null;
+ var uniqueModalIdentifier = 0;
+
+ var Modal = function (_React$Component) {
+ _inherits(Modal, _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 !== true) {
+ return null;
+ }
+
+ var containerStyles = {
+ backgroundColor: this.props.transparent ? 'transparent' : 'white'
+ };
+ var animationType = this.props.animationType;
+
+ if (!animationType) {
+ animationType = 'none';
+
+ if (this.props.animated) {
+ animationType = 'slide';
+ }
+ }
+
+ var presentationStyle = this.props.presentationStyle;
+
+ if (!presentationStyle) {
+ presentationStyle = 'fullScreen';
+
+ if (this.props.transparent) {
+ presentationStyle = 'overFullScreen';
+ }
+ }
+
+ var innerChildren = __DEV__ ? React.createElement(AppContainer, {
+ rootTag: this.context.rootTag,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 244
+ }
+ }, 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: 252
+ }
+ }, React.createElement(View, {
+ style: [styles.container, containerStyles],
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 264
+ }
+ }, innerChildren));
+ }
+ }, {
+ key: "_shouldSetResponder",
+ value: function _shouldSetResponder() {
+ return true;
+ }
+ }], [{
+ key: "_confirmProps",
+ value: function _confirmProps(props) {
+ if (props.presentationStyle && props.presentationStyle !== 'overFullScreen' && props.transparent) {
+ console.warn("Modal with '" + props.presentationStyle + "' presentation style and 'transparent' value is not supported.");
+ }
+ }
+ }]);
+
+ return Modal;
+ }(React.Component);
+
+ Modal.defaultProps = {
+ visible: true,
+ hardwareAccelerated: false
+ };
+ Modal.contextTypes = {
+ rootTag: PropTypes.number
+ };
+ Modal.childContextTypes = {
+ virtualizedList: PropTypes.object
+ };
+ var side = I18nManager.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;
+},313,[32,3,4,5,8,9,314,320,131,36,35,52,62,53,81,349],"node_modules\\react-native\\Libraries\\Modal\\Modal.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\ReactNative\\AppContainer.js";
+
+ var EmitterSubscription = _$$_REQUIRE(_dependencyMap[5], "EmitterSubscription");
+
+ var PropTypes = _$$_REQUIRE(_dependencyMap[6], "prop-types");
+
+ var RCTDeviceEventEmitter = _$$_REQUIRE(_dependencyMap[7], "RCTDeviceEventEmitter");
+
+ var React = _$$_REQUIRE(_dependencyMap[8], "React");
+
+ var ReactNative = _$$_REQUIRE(_dependencyMap[9], "ReactNative");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[10], "StyleSheet");
+
+ var View = _$$_REQUIRE(_dependencyMap[11], "View");
+
+ var AppContainer = function (_React$Component) {
+ _inherits(AppContainer, _React$Component);
+
+ function AppContainer() {
+ var _getPrototypeOf2;
+
+ var _this;
+
+ _classCallCheck(this, AppContainer);
+
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(AppContainer)).call.apply(_getPrototypeOf2, [this].concat(args)));
+ _this.state = {
+ inspector: null,
+ mainKey: 1
+ };
+ _this._subscription = null;
+ return _this;
+ }
+
+ _createClass(AppContainer, [{
+ key: "getChildContext",
+ value: function getChildContext() {
+ return {
+ rootTag: this.props.rootTag
+ };
+ }
+ }, {
+ key: "componentDidMount",
+ value: function componentDidMount() {
+ var _this2 = this;
+
+ if (__DEV__) {
+ if (!global.__RCTProfileIsProfiling) {
+ this._subscription = RCTDeviceEventEmitter.addListener('toggleElementInspector', function () {
+ var Inspector = _$$_REQUIRE(_dependencyMap[12], "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[13], "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);
+ }
+ }]);
+
+ return AppContainer;
+ }(React.Component);
+
+ AppContainer.childContextTypes = {
+ rootTag: PropTypes.number
+ };
+ var styles = StyleSheet.create({
+ appContainer: {
+ flex: 1
+ }
+ });
+
+ if (__DEV__) {
+ if (!global.__RCTProfileIsProfiling) {
+ var YellowBox = _$$_REQUIRE(_dependencyMap[13], "YellowBox");
+
+ YellowBox.install();
+ }
+ }
+
+ module.exports = AppContainer;
+},314,[3,4,5,8,9,28,62,24,52,84,53,81,315,331],"node_modules\\react-native\\Libraries\\ReactNative\\AppContainer.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Inspector\\Inspector.js";
+
+ var Dimensions = _$$_REQUIRE(_dependencyMap[5], "Dimensions");
+
+ var InspectorOverlay = _$$_REQUIRE(_dependencyMap[6], "InspectorOverlay");
+
+ var InspectorPanel = _$$_REQUIRE(_dependencyMap[7], "InspectorPanel");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[8], "Platform");
+
+ var React = _$$_REQUIRE(_dependencyMap[9], "React");
+
+ var ReactNative = _$$_REQUIRE(_dependencyMap[10], "ReactNative");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[11], "StyleSheet");
+
+ var Touchable = _$$_REQUIRE(_dependencyMap[12], "Touchable");
+
+ var UIManager = _$$_REQUIRE(_dependencyMap[13], "UIManager");
+
+ var View = _$$_REQUIRE(_dependencyMap[14], "View");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[15], "invariant");
+
+ var hook = window.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+ var renderers = findRenderers();
+ hook.resolveRNStyle = _$$_REQUIRE(_dependencyMap[16], "flattenStyle");
+
+ function findRenderers() {
+ var allRenderers = Object.keys(hook._renderers).map(function (key) {
+ return hook._renderers[key];
+ });
+ invariant(allRenderers.length >= 1, 'Expected to find at least one React Native renderer on DevTools hook.');
+ return allRenderers;
+ }
+
+ function getInspectorDataForViewTag(touchedViewTag) {
+ for (var i = 0; i < renderers.length; i++) {
+ var renderer = renderers[i];
+
+ if (Object.prototype.hasOwnProperty.call(renderer, 'getInspectorDataForViewTag')) {
+ var inspectorData = renderer.getInspectorDataForViewTag(touchedViewTag);
+
+ if (inspectorData.hierarchy.length > 0) {
+ return inspectorData;
+ }
+ }
+ }
+
+ throw new Error('Expected to find at least one React renderer.');
+ }
+
+ var Inspector = function (_React$Component) {
+ _inherits(Inspector, _React$Component);
+
+ function Inspector(_props) {
+ var _this;
+
+ _classCallCheck(this, Inspector);
+
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(Inspector).call(this, _props));
+
+ _this.attachToDevtools = function (agent) {
+ var _hideWait = null;
+ var hlSub = agent.sub('highlight', function (_ref) {
+ var node = _ref.node,
+ name = _ref.name,
+ props = _ref.props;
+ clearTimeout(_hideWait);
+
+ if (typeof node !== 'number') {
+ node = ReactNative.findNodeHandle(node);
+ }
+
+ UIManager.measure(node, function (x, y, width, height, left, top) {
+ _this.setState({
+ hierarchy: [],
+ inspected: {
+ frame: {
+ left: left,
+ top: top,
+ width: width,
+ height: height
+ },
+ style: props ? props.style : {}
+ }
+ });
+ });
+ });
+ var hideSub = agent.sub('hideHighlight', function () {
+ if (_this.state.inspected === null) {
+ return;
+ }
+
+ _hideWait = setTimeout(function () {
+ _this.setState({
+ inspected: null
+ });
+ }, 100);
+ });
+ _this._subs = [hlSub, hideSub];
+ agent.on('shutdown', function () {
+ _this.setState({
+ devtoolsAgent: null
+ });
+
+ _this._subs = null;
+ });
+
+ _this.setState({
+ devtoolsAgent: agent
+ });
+ };
+
+ _this.state = {
+ devtoolsAgent: null,
+ hierarchy: null,
+ panelPos: 'bottom',
+ inspecting: true,
+ perfing: false,
+ inspected: null,
+ selection: null,
+ inspectedViewTag: _this.props.inspectedViewTag,
+ networking: false
+ };
+ return _this;
+ }
+
+ _createClass(Inspector, [{
+ key: "componentDidMount",
+ value: function componentDidMount() {
+ hook.on('react-devtools', this.attachToDevtools);
+
+ if (hook.reactDevtoolsAgent) {
+ this.attachToDevtools(hook.reactDevtoolsAgent);
+ }
+ }
+ }, {
+ key: "componentWillUnmount",
+ value: function componentWillUnmount() {
+ if (this._subs) {
+ this._subs.map(function (fn) {
+ return fn();
+ });
+ }
+
+ hook.off('react-devtools', this.attachToDevtools);
+ }
+ }, {
+ key: "UNSAFE_componentWillReceiveProps",
+ value: function UNSAFE_componentWillReceiveProps(newProps) {
+ this.setState({
+ inspectedViewTag: newProps.inspectedViewTag
+ });
+ }
+ }, {
+ key: "setSelection",
+ value: function setSelection(i) {
+ var _this2 = this;
+
+ var hierarchyItem = this.state.hierarchy[i];
+
+ var _hierarchyItem$getIns = hierarchyItem.getInspectorData(ReactNative.findNodeHandle),
+ measure = _hierarchyItem$getIns.measure,
+ props = _hierarchyItem$getIns.props,
+ source = _hierarchyItem$getIns.source;
+
+ measure(function (x, y, width, height, left, top) {
+ _this2.setState({
+ inspected: {
+ frame: {
+ left: left,
+ top: top,
+ width: width,
+ height: height
+ },
+ style: props.style,
+ source: source
+ },
+ selection: i
+ });
+ });
+ }
+ }, {
+ key: "onTouchViewTag",
+ value: function onTouchViewTag(touchedViewTag, frame, pointerY) {
+ var _getInspectorDataForV = getInspectorDataForViewTag(touchedViewTag),
+ hierarchy = _getInspectorDataForV.hierarchy,
+ props = _getInspectorDataForV.props,
+ selection = _getInspectorDataForV.selection,
+ source = _getInspectorDataForV.source;
+
+ if (this.state.devtoolsAgent) {
+ var offsetFromLeaf = hierarchy.length - 1 - selection;
+ this.state.devtoolsAgent.selectFromDOMNode(touchedViewTag, true, offsetFromLeaf);
+ }
+
+ this.setState({
+ panelPos: pointerY > Dimensions.get('window').height / 2 ? 'top' : 'bottom',
+ selection: selection,
+ hierarchy: hierarchy,
+ inspected: {
+ style: props.style,
+ frame: frame,
+ source: source
+ }
+ });
+ }
+ }, {
+ key: "setPerfing",
+ value: function setPerfing(val) {
+ this.setState({
+ perfing: val,
+ inspecting: false,
+ inspected: null,
+ networking: false
+ });
+ }
+ }, {
+ key: "setInspecting",
+ value: function setInspecting(val) {
+ this.setState({
+ inspecting: val,
+ inspected: null
+ });
+ }
+ }, {
+ key: "setTouchTargeting",
+ value: function setTouchTargeting(val) {
+ var _this3 = this;
+
+ Touchable.TOUCH_TARGET_DEBUG = val;
+ this.props.onRequestRerenderApp(function (inspectedViewTag) {
+ _this3.setState({
+ inspectedViewTag: inspectedViewTag
+ });
+ });
+ }
+ }, {
+ key: "setNetworking",
+ value: function setNetworking(val) {
+ this.setState({
+ networking: val,
+ perfing: false,
+ inspecting: false,
+ inspected: null
+ });
+ }
+ }, {
+ key: "render",
+ value: function render() {
+ var panelContainerStyle = this.state.panelPos === 'bottom' ? {
+ bottom: 0
+ } : {
+ top: Platform.OS === 'ios' ? 20 : 0
+ };
+ return React.createElement(View, {
+ style: styles.container,
+ pointerEvents: "box-none",
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 248
+ }
+ }, this.state.inspecting && React.createElement(InspectorOverlay, {
+ inspected: this.state.inspected,
+ inspectedViewTag: this.state.inspectedViewTag,
+ onTouchViewTag: this.onTouchViewTag.bind(this),
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 250
+ }
+ }), React.createElement(View, {
+ style: [styles.panelContainer, panelContainerStyle],
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 256
+ }
+ }, React.createElement(InspectorPanel, {
+ devtoolsIsOpen: !!this.state.devtoolsAgent,
+ inspecting: this.state.inspecting,
+ perfing: this.state.perfing,
+ setPerfing: this.setPerfing.bind(this),
+ setInspecting: this.setInspecting.bind(this),
+ inspected: this.state.inspected,
+ hierarchy: this.state.hierarchy,
+ selection: this.state.selection,
+ setSelection: this.setSelection.bind(this),
+ touchTargeting: Touchable.TOUCH_TARGET_DEBUG,
+ setTouchTargeting: this.setTouchTargeting.bind(this),
+ networking: this.state.networking,
+ setNetworking: this.setNetworking.bind(this),
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 257
+ }
+ })));
+ }
+ }]);
+
+ return Inspector;
+ }(React.Component);
+
+ var styles = StyleSheet.create({
+ container: {
+ position: 'absolute',
+ backgroundColor: 'transparent',
+ top: 0,
+ left: 0,
+ right: 0,
+ bottom: 0
+ },
+ panelContainer: {
+ position: 'absolute',
+ left: 0,
+ right: 0
+ }
+ });
+ module.exports = Inspector;
+},315,[3,4,5,8,9,55,316,321,35,52,84,53,213,71,81,19,80],"node_modules\\react-native\\Libraries\\Inspector\\Inspector.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Inspector\\InspectorOverlay.js";
+
+ var Dimensions = _$$_REQUIRE(_dependencyMap[5], "Dimensions");
+
+ var ElementBox = _$$_REQUIRE(_dependencyMap[6], "ElementBox");
+
+ var React = _$$_REQUIRE(_dependencyMap[7], "React");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[8], "StyleSheet");
+
+ var UIManager = _$$_REQUIRE(_dependencyMap[9], "UIManager");
+
+ var View = _$$_REQUIRE(_dependencyMap[10], "View");
+
+ var InspectorOverlay = function (_React$Component) {
+ _inherits(InspectorOverlay, _React$Component);
+
+ function InspectorOverlay() {
+ var _getPrototypeOf2;
+
+ var _this;
+
+ _classCallCheck(this, InspectorOverlay);
+
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(InspectorOverlay)).call.apply(_getPrototypeOf2, [this].concat(args)));
+
+ _this.findViewForTouchEvent = function (e) {
+ var _e$nativeEvent$touche = e.nativeEvent.touches[0],
+ locationX = _e$nativeEvent$touche.locationX,
+ locationY = _e$nativeEvent$touche.locationY;
+ UIManager.findSubviewIn(_this.props.inspectedViewTag, [locationX, locationY], function (nativeViewTag, left, top, width, height) {
+ _this.props.onTouchViewTag(nativeViewTag, {
+ left: left,
+ top: top,
+ width: width,
+ height: height
+ }, locationY);
+ });
+ };
+
+ _this.shouldSetResponser = function (e) {
+ _this.findViewForTouchEvent(e);
+
+ return true;
+ };
+
+ return _this;
+ }
+
+ _createClass(InspectorOverlay, [{
+ key: "render",
+ value: function render() {
+ var content = null;
+
+ if (this.props.inspected) {
+ content = React.createElement(ElementBox, {
+ frame: this.props.inspected.frame,
+ style: this.props.inspected.style,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 59
+ }
+ });
+ }
+
+ return React.createElement(View, {
+ onStartShouldSetResponder: this.shouldSetResponser,
+ onResponderMove: this.findViewForTouchEvent,
+ style: [styles.inspector, {
+ height: Dimensions.get('window').height
+ }],
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 67
+ }
+ }, content);
+ }
+ }]);
+
+ return InspectorOverlay;
+ }(React.Component);
+
+ var styles = StyleSheet.create({
+ inspector: {
+ backgroundColor: 'transparent',
+ position: 'absolute',
+ left: 0,
+ top: 0,
+ right: 0
+ }
+ });
+ module.exports = InspectorOverlay;
+},316,[3,4,5,8,9,55,317,52,53,71,81],"node_modules\\react-native\\Libraries\\Inspector\\InspectorOverlay.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Inspector\\ElementBox.js";
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var BorderBox = _$$_REQUIRE(_dependencyMap[6], "BorderBox");
+
+ var React = _$$_REQUIRE(_dependencyMap[7], "React");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[8], "StyleSheet");
+
+ var View = _$$_REQUIRE(_dependencyMap[9], "View");
+
+ var flattenStyle = _$$_REQUIRE(_dependencyMap[10], "flattenStyle");
+
+ var resolveBoxStyle = _$$_REQUIRE(_dependencyMap[11], "resolveBoxStyle");
+
+ var ElementBox = function (_React$Component) {
+ _inherits(ElementBox, _React$Component);
+
+ function ElementBox() {
+ _classCallCheck(this, ElementBox);
+
+ return _possibleConstructorReturn(this, _getPrototypeOf(ElementBox).apply(this, arguments));
+ }
+
+ _createClass(ElementBox, [{
+ key: "render",
+ value: function render() {
+ var style = flattenStyle(this.props.style) || {};
+ var margin = resolveBoxStyle('margin', style);
+ var padding = resolveBoxStyle('padding', style);
+
+ var frameStyle = _objectSpread({}, this.props.frame);
+
+ var contentStyle = {
+ width: this.props.frame.width,
+ height: this.props.frame.height
+ };
+
+ if (margin != null) {
+ frameStyle.top -= margin.top;
+ frameStyle.left -= margin.left;
+ frameStyle.height += margin.top + margin.bottom;
+ frameStyle.width += margin.left + margin.right;
+
+ if (margin.top < 0) {
+ contentStyle.height += margin.top;
+ }
+
+ if (margin.bottom < 0) {
+ contentStyle.height += margin.bottom;
+ }
+
+ if (margin.left < 0) {
+ contentStyle.width += margin.left;
+ }
+
+ if (margin.right < 0) {
+ contentStyle.width += margin.right;
+ }
+ }
+
+ if (padding != null) {
+ contentStyle.width -= padding.left + padding.right;
+ contentStyle.height -= padding.top + padding.bottom;
+ }
+
+ return React.createElement(View, {
+ style: [styles.frame, frameStyle],
+ pointerEvents: "none",
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 59
+ }
+ }, React.createElement(BorderBox, {
+ box: margin,
+ style: styles.margin,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 60
+ }
+ }, React.createElement(BorderBox, {
+ box: padding,
+ style: styles.padding,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 61
+ }
+ }, React.createElement(View, {
+ style: [styles.content, contentStyle],
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 62
+ }
+ }))));
+ }
+ }]);
+
+ return ElementBox;
+ }(React.Component);
+
+ var styles = StyleSheet.create({
+ frame: {
+ position: 'absolute'
+ },
+ content: {
+ backgroundColor: 'rgba(200, 230, 255, 0.8)'
+ },
+ padding: {
+ borderColor: 'rgba(77, 255, 0, 0.3)'
+ },
+ margin: {
+ borderColor: 'rgba(255, 132, 0, 0.3)'
+ }
+ });
+ module.exports = ElementBox;
+},317,[32,3,4,5,8,9,318,52,53,81,80,319],"node_modules\\react-native\\Libraries\\Inspector\\ElementBox.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Inspector\\BorderBox.js";
+
+ var React = _$$_REQUIRE(_dependencyMap[5], "React");
+
+ var View = _$$_REQUIRE(_dependencyMap[6], "View");
+
+ var BorderBox = function (_React$Component) {
+ _inherits(BorderBox, _React$Component);
+
+ function BorderBox() {
+ _classCallCheck(this, BorderBox);
+
+ return _possibleConstructorReturn(this, _getPrototypeOf(BorderBox).apply(this, arguments));
+ }
+
+ _createClass(BorderBox, [{
+ key: "render",
+ value: function render() {
+ var box = this.props.box;
+
+ if (!box) {
+ return this.props.children;
+ }
+
+ var style = {
+ borderTopWidth: box.top,
+ borderBottomWidth: box.bottom,
+ borderLeftWidth: box.left,
+ borderRightWidth: box.right
+ };
+ return React.createElement(View, {
+ style: [style, this.props.style],
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 28
+ }
+ }, this.props.children);
+ }
+ }]);
+
+ return BorderBox;
+ }(React.Component);
+
+ module.exports = BorderBox;
+},318,[3,4,5,8,9,52,81],"node_modules\\react-native\\Libraries\\Inspector\\BorderBox.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var I18nManager = _$$_REQUIRE(_dependencyMap[0], "I18nManager");
+
+ function resolveBoxStyle(prefix, style) {
+ var hasParts = false;
+ var result = {
+ bottom: 0,
+ left: 0,
+ right: 0,
+ top: 0
+ };
+ var styleForAll = style[prefix];
+
+ if (styleForAll != null) {
+ for (var _i = 0, _Object$keys = Object.keys(result); _i < _Object$keys.length; _i++) {
+ var key = _Object$keys[_i];
+ result[key] = styleForAll;
+ }
+
+ hasParts = true;
+ }
+
+ var styleForHorizontal = style[prefix + 'Horizontal'];
+
+ if (styleForHorizontal != null) {
+ result.left = styleForHorizontal;
+ result.right = styleForHorizontal;
+ hasParts = true;
+ } else {
+ var styleForLeft = style[prefix + 'Left'];
+
+ if (styleForLeft != null) {
+ result.left = styleForLeft;
+ hasParts = true;
+ }
+
+ var styleForRight = style[prefix + 'Right'];
+
+ if (styleForRight != null) {
+ result.right = styleForRight;
+ hasParts = true;
+ }
+
+ var styleForEnd = style[prefix + 'End'];
+
+ if (styleForEnd != null) {
+ if (I18nManager.isRTL && I18nManager.doLeftAndRightSwapInRTL) {
+ result.left = styleForEnd;
+ } else {
+ result.right = styleForEnd;
+ }
+
+ hasParts = true;
+ }
+
+ var styleForStart = style[prefix + 'Start'];
+
+ if (styleForStart != null) {
+ if (I18nManager.isRTL && I18nManager.doLeftAndRightSwapInRTL) {
+ result.right = styleForStart;
+ } else {
+ result.left = styleForStart;
+ }
+
+ hasParts = true;
+ }
+ }
+
+ var styleForVertical = style[prefix + 'Vertical'];
+
+ if (styleForVertical != null) {
+ result.bottom = styleForVertical;
+ result.top = styleForVertical;
+ hasParts = true;
+ } else {
+ var styleForBottom = style[prefix + 'Bottom'];
+
+ if (styleForBottom != null) {
+ result.bottom = styleForBottom;
+ hasParts = true;
+ }
+
+ var styleForTop = style[prefix + 'Top'];
+
+ if (styleForTop != null) {
+ result.top = styleForTop;
+ hasParts = true;
+ }
+ }
+
+ return hasParts ? result : null;
+ }
+
+ module.exports = resolveBoxStyle;
+},319,[320],"node_modules\\react-native\\Libraries\\Inspector\\resolveBoxStyle.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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;
+},320,[36],"node_modules\\react-native\\Libraries\\ReactNative\\I18nManager.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Inspector\\InspectorPanel.js";
+
+ var ElementProperties = _$$_REQUIRE(_dependencyMap[5], "ElementProperties");
+
+ var NetworkOverlay = _$$_REQUIRE(_dependencyMap[6], "NetworkOverlay");
+
+ var PerformanceOverlay = _$$_REQUIRE(_dependencyMap[7], "PerformanceOverlay");
+
+ var React = _$$_REQUIRE(_dependencyMap[8], "React");
+
+ var ScrollView = _$$_REQUIRE(_dependencyMap[9], "ScrollView");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[10], "StyleSheet");
+
+ var Text = _$$_REQUIRE(_dependencyMap[11], "Text");
+
+ var TouchableHighlight = _$$_REQUIRE(_dependencyMap[12], "TouchableHighlight");
+
+ var View = _$$_REQUIRE(_dependencyMap[13], "View");
+
+ var InspectorPanel = function (_React$Component) {
+ _inherits(InspectorPanel, _React$Component);
+
+ function InspectorPanel() {
+ _classCallCheck(this, InspectorPanel);
+
+ return _possibleConstructorReturn(this, _getPrototypeOf(InspectorPanel).apply(this, arguments));
+ }
+
+ _createClass(InspectorPanel, [{
+ key: "renderWaiting",
+ value: function renderWaiting() {
+ if (this.props.inspecting) {
+ return React.createElement(Text, {
+ style: styles.waitingText,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 57
+ }
+ }, "Tap something to inspect it");
+ }
+
+ return React.createElement(Text, {
+ style: styles.waitingText,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 60
+ }
+ }, "Nothing is inspected");
+ }
+ }, {
+ key: "render",
+ value: function render() {
+ var contents;
+
+ if (this.props.inspected) {
+ contents = React.createElement(ScrollView, {
+ style: styles.properties,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 67
+ }
+ }, React.createElement(ElementProperties, {
+ style: this.props.inspected.style,
+ frame: this.props.inspected.frame,
+ source: this.props.inspected.source,
+ hierarchy: this.props.hierarchy,
+ selection: this.props.selection,
+ setSelection: this.props.setSelection,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 68
+ }
+ }));
+ } else if (this.props.perfing) {
+ contents = React.createElement(PerformanceOverlay, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 80
+ }
+ });
+ } else if (this.props.networking) {
+ contents = React.createElement(NetworkOverlay, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 82
+ }
+ });
+ } else {
+ contents = React.createElement(View, {
+ style: styles.waiting,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 84
+ }
+ }, this.renderWaiting());
+ }
+
+ return React.createElement(View, {
+ style: styles.container,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 87
+ }
+ }, !this.props.devtoolsIsOpen && contents, React.createElement(View, {
+ style: styles.buttonRow,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 89
+ }
+ }, React.createElement(InspectorPanelButton, {
+ title: 'Inspect',
+ pressed: this.props.inspecting,
+ onClick: this.props.setInspecting,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 90
+ }
+ }), React.createElement(InspectorPanelButton, {
+ title: 'Perf',
+ pressed: this.props.perfing,
+ onClick: this.props.setPerfing,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 95
+ }
+ }), React.createElement(InspectorPanelButton, {
+ title: 'Network',
+ pressed: this.props.networking,
+ onClick: this.props.setNetworking,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 100
+ }
+ }), React.createElement(InspectorPanelButton, {
+ title: 'Touchables',
+ pressed: this.props.touchTargeting,
+ onClick: this.props.setTouchTargeting,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 105
+ }
+ })));
+ }
+ }]);
+
+ return InspectorPanel;
+ }(React.Component);
+
+ var InspectorPanelButton = function (_React$Component2) {
+ _inherits(InspectorPanelButton, _React$Component2);
+
+ function InspectorPanelButton() {
+ _classCallCheck(this, InspectorPanelButton);
+
+ return _possibleConstructorReturn(this, _getPrototypeOf(InspectorPanelButton).apply(this, arguments));
+ }
+
+ _createClass(InspectorPanelButton, [{
+ key: "render",
+ value: function render() {
+ var _this = this;
+
+ return React.createElement(TouchableHighlight, {
+ onPress: function onPress() {
+ return _this.props.onClick(!_this.props.pressed);
+ },
+ style: [styles.button, this.props.pressed && styles.buttonPressed],
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 125
+ }
+ }, React.createElement(Text, {
+ style: styles.buttonText,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 128
+ }
+ }, this.props.title));
+ }
+ }]);
+
+ return InspectorPanelButton;
+ }(React.Component);
+
+ var styles = StyleSheet.create({
+ buttonRow: {
+ flexDirection: 'row'
+ },
+ button: {
+ backgroundColor: 'rgba(0, 0, 0, 0.3)',
+ margin: 2,
+ height: 30,
+ justifyContent: 'center',
+ alignItems: 'center'
+ },
+ buttonPressed: {
+ backgroundColor: 'rgba(255, 255, 255, 0.3)'
+ },
+ buttonText: {
+ textAlign: 'center',
+ color: 'white',
+ margin: 5
+ },
+ container: {
+ backgroundColor: 'rgba(0, 0, 0, 0.7)'
+ },
+ properties: {
+ height: 200
+ },
+ waiting: {
+ height: 100
+ },
+ waitingText: {
+ fontSize: 20,
+ textAlign: 'center',
+ marginVertical: 20,
+ color: 'white'
+ }
+ });
+ module.exports = InspectorPanel;
+},321,[3,4,5,8,9,322,327,330,52,275,53,208,221,81],"node_modules\\react-native\\Libraries\\Inspector\\InspectorPanel.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Inspector\\ElementProperties.js";
+
+ var BoxInspector = _$$_REQUIRE(_dependencyMap[5], "BoxInspector");
+
+ var React = _$$_REQUIRE(_dependencyMap[6], "React");
+
+ var StyleInspector = _$$_REQUIRE(_dependencyMap[7], "StyleInspector");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[8], "StyleSheet");
+
+ var Text = _$$_REQUIRE(_dependencyMap[9], "Text");
+
+ var TouchableHighlight = _$$_REQUIRE(_dependencyMap[10], "TouchableHighlight");
+
+ var TouchableWithoutFeedback = _$$_REQUIRE(_dependencyMap[11], "TouchableWithoutFeedback");
+
+ var View = _$$_REQUIRE(_dependencyMap[12], "View");
+
+ var flattenStyle = _$$_REQUIRE(_dependencyMap[13], "flattenStyle");
+
+ var mapWithSeparator = _$$_REQUIRE(_dependencyMap[14], "mapWithSeparator");
+
+ var openFileInEditor = _$$_REQUIRE(_dependencyMap[15], "openFileInEditor");
+
+ var ElementProperties = function (_React$Component) {
+ _inherits(ElementProperties, _React$Component);
+
+ function ElementProperties() {
+ _classCallCheck(this, ElementProperties);
+
+ return _possibleConstructorReturn(this, _getPrototypeOf(ElementProperties).apply(this, arguments));
+ }
+
+ _createClass(ElementProperties, [{
+ key: "render",
+ value: function render() {
+ var _this = this;
+
+ var style = flattenStyle(this.props.style);
+ var selection = this.props.selection;
+ var openFileButton;
+ var source = this.props.source;
+
+ var _ref = source || {},
+ fileName = _ref.fileName,
+ lineNumber = _ref.lineNumber;
+
+ if (fileName && lineNumber) {
+ var parts = fileName.split('/');
+ var fileNameShort = parts[parts.length - 1];
+ openFileButton = React.createElement(TouchableHighlight, {
+ style: styles.openButton,
+ onPress: openFileInEditor.bind(null, fileName, lineNumber),
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 51
+ }
+ }, React.createElement(Text, {
+ style: styles.openButtonTitle,
+ numberOfLines: 1,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 54
+ }
+ }, fileNameShort, ":", lineNumber));
+ }
+
+ return React.createElement(TouchableWithoutFeedback, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 63
+ }
+ }, React.createElement(View, {
+ style: styles.info,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 64
+ }
+ }, React.createElement(View, {
+ style: styles.breadcrumb,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 65
+ }
+ }, mapWithSeparator(this.props.hierarchy, function (hierarchyItem, i) {
+ return React.createElement(TouchableHighlight, {
+ key: 'item-' + i,
+ style: [styles.breadItem, i === selection && styles.selected],
+ onPress: function onPress() {
+ return _this.props.setSelection(i);
+ },
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 69
+ }
+ }, React.createElement(Text, {
+ style: styles.breadItemText,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 74
+ }
+ }, hierarchyItem.name));
+ }, function (i) {
+ return React.createElement(Text, {
+ key: 'sep-' + i,
+ style: styles.breadSep,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 78
+ }
+ }, "\u25B8");
+ })), React.createElement(View, {
+ style: styles.row,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 84
+ }
+ }, React.createElement(View, {
+ style: styles.col,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 85
+ }
+ }, React.createElement(StyleInspector, {
+ style: style,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 86
+ }
+ }), openFileButton), React.createElement(BoxInspector, {
+ style: style,
+ frame: this.props.frame,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 89
+ }
+ }))));
+ }
+ }]);
+
+ return ElementProperties;
+ }(React.Component);
+
+ var styles = StyleSheet.create({
+ breadSep: {
+ fontSize: 8,
+ color: 'white'
+ },
+ breadcrumb: {
+ flexDirection: 'row',
+ flexWrap: 'wrap',
+ alignItems: 'flex-start',
+ marginBottom: 5
+ },
+ selected: {
+ borderColor: 'white',
+ borderRadius: 5
+ },
+ breadItem: {
+ borderWidth: 1,
+ borderColor: 'transparent',
+ marginHorizontal: 2
+ },
+ breadItemText: {
+ fontSize: 10,
+ color: 'white',
+ marginHorizontal: 5
+ },
+ row: {
+ flexDirection: 'row',
+ alignItems: 'center',
+ justifyContent: 'space-between'
+ },
+ col: {
+ flex: 1
+ },
+ info: {
+ padding: 10
+ },
+ openButton: {
+ padding: 10,
+ backgroundColor: '#000',
+ marginVertical: 5,
+ marginRight: 5,
+ borderRadius: 2
+ },
+ openButtonTitle: {
+ color: 'white',
+ fontSize: 8
+ }
+ });
+ module.exports = ElementProperties;
+},322,[3,4,5,8,9,323,52,324,53,208,221,226,81,80,325,326],"node_modules\\react-native\\Libraries\\Inspector\\ElementProperties.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Inspector\\BoxInspector.js";
+
+ var React = _$$_REQUIRE(_dependencyMap[5], "React");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[6], "StyleSheet");
+
+ var Text = _$$_REQUIRE(_dependencyMap[7], "Text");
+
+ var View = _$$_REQUIRE(_dependencyMap[8], "View");
+
+ var resolveBoxStyle = _$$_REQUIRE(_dependencyMap[9], "resolveBoxStyle");
+
+ var blank = {
+ top: 0,
+ left: 0,
+ right: 0,
+ bottom: 0
+ };
+
+ var BoxInspector = function (_React$Component) {
+ _inherits(BoxInspector, _React$Component);
+
+ function BoxInspector() {
+ _classCallCheck(this, BoxInspector);
+
+ return _possibleConstructorReturn(this, _getPrototypeOf(BoxInspector).apply(this, arguments));
+ }
+
+ _createClass(BoxInspector, [{
+ key: "render",
+ value: function render() {
+ var frame = this.props.frame;
+ var style = this.props.style;
+ var margin = style && resolveBoxStyle('margin', style) || blank;
+ var padding = style && resolveBoxStyle('padding', style) || blank;
+ return React.createElement(BoxContainer, {
+ title: "margin",
+ titleStyle: styles.marginLabel,
+ box: margin,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 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)))));
+ }
+ }]);
+
+ return BoxInspector;
+ }(React.Component);
+
+ var BoxContainer = function (_React$Component2) {
+ _inherits(BoxContainer, _React$Component2);
+
+ function BoxContainer() {
+ _classCallCheck(this, BoxContainer);
+
+ return _possibleConstructorReturn(this, _getPrototypeOf(BoxContainer).apply(this, arguments));
+ }
+
+ _createClass(BoxContainer, [{
+ key: "render",
+ value: function render() {
+ var box = this.props.box;
+ return React.createElement(View, {
+ style: styles.box,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 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));
+ }
+ }]);
+
+ return BoxContainer;
+ }(React.Component);
+
+ var styles = StyleSheet.create({
+ row: {
+ flexDirection: 'row',
+ alignItems: 'center',
+ justifyContent: 'space-around'
+ },
+ marginLabel: {
+ width: 60
+ },
+ label: {
+ fontSize: 10,
+ color: 'rgb(255,100,0)',
+ marginLeft: 5,
+ flex: 1,
+ textAlign: 'left',
+ top: -3
+ },
+ innerText: {
+ color: 'yellow',
+ fontSize: 12,
+ textAlign: 'center',
+ width: 70
+ },
+ box: {
+ borderWidth: 1,
+ borderColor: 'grey'
+ },
+ boxText: {
+ color: 'white',
+ fontSize: 12,
+ marginHorizontal: 3,
+ marginVertical: 2,
+ textAlign: 'center'
+ }
+ });
+ module.exports = BoxInspector;
+},323,[3,4,5,8,9,52,53,208,81,319],"node_modules\\react-native\\Libraries\\Inspector\\BoxInspector.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Inspector\\StyleInspector.js";
+
+ var React = _$$_REQUIRE(_dependencyMap[5], "React");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[6], "StyleSheet");
+
+ var Text = _$$_REQUIRE(_dependencyMap[7], "Text");
+
+ var View = _$$_REQUIRE(_dependencyMap[8], "View");
+
+ var StyleInspector = function (_React$Component) {
+ _inherits(StyleInspector, _React$Component);
+
+ function StyleInspector() {
+ _classCallCheck(this, StyleInspector);
+
+ return _possibleConstructorReturn(this, _getPrototypeOf(StyleInspector).apply(this, arguments));
+ }
+
+ _createClass(StyleInspector, [{
+ key: "render",
+ value: function render() {
+ var _this = this;
+
+ if (!this.props.style) {
+ return React.createElement(Text, {
+ style: styles.noStyle,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 21
+ }
+ }, "No style");
+ }
+
+ var names = Object.keys(this.props.style);
+ return React.createElement(View, {
+ style: styles.container,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 25
+ }
+ }, React.createElement(View, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 26
+ }
+ }, names.map(function (name) {
+ return React.createElement(Text, {
+ key: name,
+ style: styles.attr,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 28
+ }
+ }, name, ":");
+ })), React.createElement(View, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 34
+ }
+ }, names.map(function (name) {
+ var value = typeof _this.props.style[name] === 'object' ? JSON.stringify(_this.props.style[name]) : _this.props.style[name];
+ return React.createElement(Text, {
+ key: name,
+ style: styles.value,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 41
+ }
+ }, value);
+ })));
+ }
+ }]);
+
+ return StyleInspector;
+ }(React.Component);
+
+ var styles = StyleSheet.create({
+ container: {
+ flexDirection: 'row'
+ },
+ attr: {
+ fontSize: 10,
+ color: '#ccc'
+ },
+ value: {
+ fontSize: 10,
+ color: 'white',
+ marginLeft: 10
+ },
+ noStyle: {
+ color: 'white',
+ fontSize: 10
+ }
+ });
+ module.exports = StyleInspector;
+},324,[3,4,5,8,9,52,53,208,81],"node_modules\\react-native\\Libraries\\Inspector\\StyleInspector.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ function mapWithSeparator(items, itemRenderer, spacerRenderer) {
+ var mapped = [];
+
+ if (items.length > 0) {
+ mapped.push(itemRenderer(items[0], 0, items));
+
+ for (var ii = 1; ii < items.length; ii++) {
+ mapped.push(spacerRenderer(ii - 1), itemRenderer(items[ii], ii, items));
+ }
+ }
+
+ return mapped;
+ }
+
+ module.exports = mapWithSeparator;
+},325,[],"node_modules\\react-native\\Libraries\\Utilities\\mapWithSeparator.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var getDevServer = _$$_REQUIRE(_dependencyMap[0], "getDevServer");
+
+ function openFileInEditor(file, lineNumber) {
+ fetch(getDevServer().url + 'open-stack-frame', {
+ method: 'POST',
+ body: JSON.stringify({
+ file: file,
+ lineNumber: lineNumber
+ })
+ });
+ }
+
+ module.exports = openFileInEditor;
+},326,[104],"node_modules\\react-native\\Libraries\\Core\\Devtools\\openFileInEditor.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Inspector\\NetworkOverlay.js";
+
+ var FlatList = _$$_REQUIRE(_dependencyMap[5], "FlatList");
+
+ var React = _$$_REQUIRE(_dependencyMap[6], "React");
+
+ 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 WebSocketInterceptor = _$$_REQUIRE(_dependencyMap[12], "WebSocketInterceptor");
+
+ var XHRInterceptor = _$$_REQUIRE(_dependencyMap[13], "XHRInterceptor");
+
+ var LISTVIEW_CELL_HEIGHT = 15;
+ var nextXHRId = 0;
+
+ function getStringByValue(value) {
+ if (value === undefined) {
+ return 'undefined';
+ }
+
+ if (typeof value === 'object') {
+ return JSON.stringify(value);
+ }
+
+ if (typeof value === 'string' && value.length > 500) {
+ return String(value).substr(0, 500).concat('\n***TRUNCATED TO 500 CHARACTERS***');
+ }
+
+ return value;
+ }
+
+ function getTypeShortName(type) {
+ if (type === 'XMLHttpRequest') {
+ return 'XHR';
+ } else if (type === 'WebSocket') {
+ return 'WS';
+ }
+
+ return '';
+ }
+
+ function keyExtractor(request) {
+ return String(request.id);
+ }
+
+ var NetworkOverlay = function (_React$Component) {
+ _inherits(NetworkOverlay, _React$Component);
+
+ function NetworkOverlay() {
+ var _getPrototypeOf2;
+
+ var _this;
+
+ _classCallCheck(this, NetworkOverlay);
+
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(NetworkOverlay)).call.apply(_getPrototypeOf2, [this].concat(args)));
+ _this._socketIdMap = {};
+ _this._xhrIdMap = {};
+ _this.state = {
+ detailRowId: null,
+ requests: []
+ };
+
+ _this._renderItem = function (_ref) {
+ var item = _ref.item,
+ index = _ref.index;
+ var tableRowViewStyle = [styles.tableRow, index % 2 === 1 ? styles.tableRowOdd : styles.tableRowEven, index === _this.state.detailRowId && styles.tableRowPressed];
+ var urlCellViewStyle = styles.urlCellView;
+ var methodCellViewStyle = styles.methodCellView;
+ return React.createElement(TouchableHighlight, {
+ onPress: function onPress() {
+ _this._pressRow(index);
+ },
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 328
+ }
+ }, React.createElement(View, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 332
+ }
+ }, React.createElement(View, {
+ style: tableRowViewStyle,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 333
+ }
+ }, React.createElement(View, {
+ style: urlCellViewStyle,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 334
+ }
+ }, React.createElement(Text, {
+ style: styles.cellText,
+ numberOfLines: 1,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 335
+ }
+ }, item.url)), React.createElement(View, {
+ style: methodCellViewStyle,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 339
+ }
+ }, React.createElement(Text, {
+ style: styles.cellText,
+ numberOfLines: 1,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 340
+ }
+ }, getTypeShortName(item.type))))));
+ };
+
+ _this._scrollDetailToTop = function () {
+ if (_this._detailScrollView) {
+ _this._detailScrollView.scrollTo({
+ y: 0,
+ animated: false
+ });
+ }
+ };
+
+ _this._closeButtonClicked = function () {
+ _this.setState({
+ detailRowId: null
+ });
+ };
+
+ return _this;
+ }
+
+ _createClass(NetworkOverlay, [{
+ key: "_enableXHRInterception",
+ value: function _enableXHRInterception() {
+ var _this2 = this;
+
+ if (XHRInterceptor.isInterceptorEnabled()) {
+ return;
+ }
+
+ XHRInterceptor.setOpenCallback(function (method, url, xhr) {
+ xhr._index = nextXHRId++;
+ var xhrIndex = _this2.state.requests.length;
+ _this2._xhrIdMap[xhr._index] = xhrIndex;
+ var _xhr = {
+ id: xhrIndex,
+ type: 'XMLHttpRequest',
+ method: method,
+ url: url
+ };
+
+ _this2.setState({
+ requests: _this2.state.requests.concat(_xhr)
+ }, _this2._scrollRequestsToBottom);
+ });
+ XHRInterceptor.setRequestHeaderCallback(function (header, value, xhr) {
+ var xhrIndex = _this2._getRequestIndexByXHRID(xhr._index);
+
+ if (xhrIndex === -1) {
+ return;
+ }
+
+ _this2.setState(function (_ref2) {
+ var requests = _ref2.requests;
+ var networkRequestInfo = requests[xhrIndex];
+
+ if (!networkRequestInfo.requestHeaders) {
+ networkRequestInfo.requestHeaders = {};
+ }
+
+ networkRequestInfo.requestHeaders[header] = value;
+ return {
+ requests: requests
+ };
+ });
+ });
+ XHRInterceptor.setSendCallback(function (data, xhr) {
+ var xhrIndex = _this2._getRequestIndexByXHRID(xhr._index);
+
+ if (xhrIndex === -1) {
+ return;
+ }
+
+ _this2.setState(function (_ref3) {
+ var requests = _ref3.requests;
+ var networkRequestInfo = requests[xhrIndex];
+ networkRequestInfo.dataSent = data;
+ return {
+ requests: requests
+ };
+ });
+ });
+ XHRInterceptor.setHeaderReceivedCallback(function (type, size, responseHeaders, xhr) {
+ var xhrIndex = _this2._getRequestIndexByXHRID(xhr._index);
+
+ if (xhrIndex === -1) {
+ return;
+ }
+
+ _this2.setState(function (_ref4) {
+ var requests = _ref4.requests;
+ var networkRequestInfo = requests[xhrIndex];
+ networkRequestInfo.responseContentType = type;
+ networkRequestInfo.responseSize = size;
+ networkRequestInfo.responseHeaders = responseHeaders;
+ return {
+ requests: requests
+ };
+ });
+ });
+ XHRInterceptor.setResponseCallback(function (status, timeout, response, responseURL, responseType, xhr) {
+ var xhrIndex = _this2._getRequestIndexByXHRID(xhr._index);
+
+ if (xhrIndex === -1) {
+ return;
+ }
+
+ _this2.setState(function (_ref5) {
+ var requests = _ref5.requests;
+ var networkRequestInfo = requests[xhrIndex];
+ networkRequestInfo.status = status;
+ networkRequestInfo.timeout = timeout;
+ networkRequestInfo.response = response;
+ networkRequestInfo.responseURL = responseURL;
+ networkRequestInfo.responseType = responseType;
+ return {
+ requests: requests
+ };
+ });
+ });
+ XHRInterceptor.enableInterception();
+ }
+ }, {
+ key: "_enableWebSocketInterception",
+ value: function _enableWebSocketInterception() {
+ var _this3 = this;
+
+ if (WebSocketInterceptor.isInterceptorEnabled()) {
+ return;
+ }
+
+ WebSocketInterceptor.setConnectCallback(function (url, protocols, options, socketId) {
+ var socketIndex = _this3.state.requests.length;
+ _this3._socketIdMap[socketId] = socketIndex;
+ var _webSocket = {
+ id: socketIndex,
+ type: 'WebSocket',
+ url: url,
+ protocols: protocols
+ };
+
+ _this3.setState({
+ requests: _this3.state.requests.concat(_webSocket)
+ }, _this3._scrollRequestsToBottom);
+ });
+ WebSocketInterceptor.setCloseCallback(function (statusCode, closeReason, socketId) {
+ var socketIndex = _this3._socketIdMap[socketId];
+
+ if (socketIndex === undefined) {
+ return;
+ }
+
+ if (statusCode !== null && closeReason !== null) {
+ _this3.setState(function (_ref6) {
+ var requests = _ref6.requests;
+ var networkRequestInfo = requests[socketIndex];
+ networkRequestInfo.status = statusCode;
+ networkRequestInfo.closeReason = closeReason;
+ return {
+ requests: requests
+ };
+ });
+ }
+ });
+ WebSocketInterceptor.setSendCallback(function (data, socketId) {
+ var socketIndex = _this3._socketIdMap[socketId];
+
+ if (socketIndex === undefined) {
+ return;
+ }
+
+ _this3.setState(function (_ref7) {
+ var requests = _ref7.requests;
+ var networkRequestInfo = requests[socketIndex];
+
+ if (!networkRequestInfo.messages) {
+ networkRequestInfo.messages = '';
+ }
+
+ networkRequestInfo.messages += 'Sent: ' + JSON.stringify(data) + '\n';
+ return {
+ requests: requests
+ };
+ });
+ });
+ WebSocketInterceptor.setOnMessageCallback(function (socketId, message) {
+ var socketIndex = _this3._socketIdMap[socketId];
+
+ if (socketIndex === undefined) {
+ return;
+ }
+
+ _this3.setState(function (_ref8) {
+ var requests = _ref8.requests;
+ var networkRequestInfo = requests[socketIndex];
+
+ if (!networkRequestInfo.messages) {
+ networkRequestInfo.messages = '';
+ }
+
+ networkRequestInfo.messages += 'Received: ' + JSON.stringify(message) + '\n';
+ return {
+ requests: requests
+ };
+ });
+ });
+ WebSocketInterceptor.setOnCloseCallback(function (socketId, message) {
+ var socketIndex = _this3._socketIdMap[socketId];
+
+ if (socketIndex === undefined) {
+ return;
+ }
+
+ _this3.setState(function (_ref9) {
+ var requests = _ref9.requests;
+ var networkRequestInfo = requests[socketIndex];
+ networkRequestInfo.serverClose = message;
+ return {
+ requests: requests
+ };
+ });
+ });
+ WebSocketInterceptor.setOnErrorCallback(function (socketId, message) {
+ var socketIndex = _this3._socketIdMap[socketId];
+
+ if (socketIndex === undefined) {
+ return;
+ }
+
+ _this3.setState(function (_ref10) {
+ var requests = _ref10.requests;
+ var networkRequestInfo = requests[socketIndex];
+ networkRequestInfo.serverError = message;
+ return {
+ requests: requests
+ };
+ });
+ });
+ WebSocketInterceptor.enableInterception();
+ }
+ }, {
+ key: "componentDidMount",
+ value: function componentDidMount() {
+ this._enableXHRInterception();
+
+ this._enableWebSocketInterception();
+ }
+ }, {
+ key: "componentWillUnmount",
+ value: function componentWillUnmount() {
+ XHRInterceptor.disableInterception();
+ WebSocketInterceptor.disableInterception();
+ }
+ }, {
+ key: "_renderItemDetail",
+ value: function _renderItemDetail(id) {
+ var _this4 = this;
+
+ var requestItem = this.state.requests[id];
+ var details = Object.keys(requestItem).map(function (key) {
+ if (key === 'id') {
+ return;
+ }
+
+ return React.createElement(View, {
+ style: styles.detailViewRow,
+ key: key,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 357
+ }
+ }, React.createElement(Text, {
+ style: [styles.detailViewText, styles.detailKeyCellView],
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 358
+ }
+ }, key), React.createElement(Text, {
+ style: [styles.detailViewText, styles.detailValueCellView],
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 361
+ }
+ }, getStringByValue(requestItem[key])));
+ });
+ return React.createElement(View, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 369
+ }
+ }, React.createElement(TouchableHighlight, {
+ style: styles.closeButton,
+ onPress: this._closeButtonClicked,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 370
+ }
+ }, React.createElement(View, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 373
+ }
+ }, React.createElement(Text, {
+ style: styles.closeButtonText,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 374
+ }
+ }, "v"))), React.createElement(ScrollView, {
+ style: styles.detailScrollView,
+ ref: function ref(scrollRef) {
+ return _this4._detailScrollView = scrollRef;
+ },
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 377
+ }
+ }, details));
+ }
+ }, {
+ key: "_scrollRequestsToBottom",
+ value: function _scrollRequestsToBottom() {
+ if (this._requestsListView) {
+ this._requestsListView.scrollToEnd();
+ }
+ }
+ }, {
+ key: "_pressRow",
+ value: function _pressRow(rowId) {
+ this.setState({
+ detailRowId: rowId
+ }, this._scrollDetailToTop);
+ }
+ }, {
+ key: "_getRequestIndexByXHRID",
+ value: function _getRequestIndexByXHRID(index) {
+ if (index === undefined) {
+ return -1;
+ }
+
+ var xhrIndex = this._xhrIdMap[index];
+
+ if (xhrIndex === undefined) {
+ return -1;
+ } else {
+ return xhrIndex;
+ }
+ }
+ }, {
+ key: "render",
+ value: function render() {
+ var _this5 = this;
+
+ var _this$state = this.state,
+ requests = _this$state.requests,
+ detailRowId = _this$state.detailRowId;
+ return React.createElement(View, {
+ style: styles.container,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 429
+ }
+ }, detailRowId != null && this._renderItemDetail(detailRowId), React.createElement(View, {
+ style: styles.listViewTitle,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 431
+ }
+ }, requests.length > 0 && React.createElement(View, {
+ style: styles.tableRow,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 433
+ }
+ }, React.createElement(View, {
+ style: styles.urlTitleCellView,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 434
+ }
+ }, React.createElement(Text, {
+ style: styles.cellText,
+ numberOfLines: 1,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 435
+ }
+ }, "URL")), React.createElement(View, {
+ style: styles.methodTitleCellView,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 439
+ }
+ }, React.createElement(Text, {
+ style: styles.cellText,
+ numberOfLines: 1,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 440
+ }
+ }, "Type")))), React.createElement(FlatList, {
+ ref: function ref(listRef) {
+ return _this5._requestsListView = listRef;
+ },
+ style: styles.listView,
+ data: requests,
+ renderItem: this._renderItem,
+ keyExtractor: keyExtractor,
+ extraData: this.state,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 448
+ }
+ }));
+ }
+ }]);
+
+ return NetworkOverlay;
+ }(React.Component);
+
+ var styles = StyleSheet.create({
+ container: {
+ paddingTop: 10,
+ paddingBottom: 10,
+ paddingLeft: 5,
+ paddingRight: 5
+ },
+ listViewTitle: {
+ height: 20
+ },
+ listView: {
+ flex: 1,
+ height: 60
+ },
+ tableRow: {
+ flexDirection: 'row',
+ flex: 1,
+ height: LISTVIEW_CELL_HEIGHT
+ },
+ tableRowEven: {
+ backgroundColor: '#555'
+ },
+ tableRowOdd: {
+ backgroundColor: '#000'
+ },
+ tableRowPressed: {
+ backgroundColor: '#3B5998'
+ },
+ cellText: {
+ color: 'white',
+ fontSize: 12
+ },
+ methodTitleCellView: {
+ height: 18,
+ borderColor: '#DCD7CD',
+ borderTopWidth: 1,
+ borderBottomWidth: 1,
+ borderRightWidth: 1,
+ alignItems: 'center',
+ justifyContent: 'center',
+ backgroundColor: '#444',
+ flex: 1
+ },
+ urlTitleCellView: {
+ height: 18,
+ borderColor: '#DCD7CD',
+ borderTopWidth: 1,
+ borderBottomWidth: 1,
+ borderLeftWidth: 1,
+ borderRightWidth: 1,
+ justifyContent: 'center',
+ backgroundColor: '#444',
+ flex: 5,
+ paddingLeft: 3
+ },
+ methodCellView: {
+ height: 15,
+ borderColor: '#DCD7CD',
+ borderRightWidth: 1,
+ alignItems: 'center',
+ justifyContent: 'center',
+ flex: 1
+ },
+ urlCellView: {
+ height: 15,
+ borderColor: '#DCD7CD',
+ borderLeftWidth: 1,
+ borderRightWidth: 1,
+ justifyContent: 'center',
+ flex: 5,
+ paddingLeft: 3
+ },
+ detailScrollView: {
+ flex: 1,
+ height: 180,
+ marginTop: 5,
+ marginBottom: 5
+ },
+ detailKeyCellView: {
+ flex: 1.3
+ },
+ detailValueCellView: {
+ flex: 2
+ },
+ detailViewRow: {
+ flexDirection: 'row',
+ paddingHorizontal: 3
+ },
+ detailViewText: {
+ color: 'white',
+ fontSize: 11
+ },
+ closeButtonText: {
+ color: 'white',
+ fontSize: 10
+ },
+ closeButton: {
+ marginTop: 5,
+ backgroundColor: '#888',
+ justifyContent: 'center',
+ alignItems: 'center'
+ }
+ });
+ module.exports = NetworkOverlay;
+},327,[3,4,5,8,9,268,52,275,53,208,221,81,328,329],"node_modules\\react-native\\Libraries\\Inspector\\NetworkOverlay.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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;
+},328,[36,131,134],"node_modules\\react-native\\Libraries\\WebSocket\\WebSocketInterceptor.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var XMLHttpRequest = _$$_REQUIRE(_dependencyMap[0], "XMLHttpRequest");
+
+ var originalXHROpen = XMLHttpRequest.prototype.open;
+ var originalXHRSend = XMLHttpRequest.prototype.send;
+ var originalXHRSetRequestHeader = XMLHttpRequest.prototype.setRequestHeader;
+ var openCallback;
+ var sendCallback;
+ var requestHeaderCallback;
+ var headerReceivedCallback;
+ var responseCallback;
+ var _isInterceptorEnabled = false;
+ var XHRInterceptor = {
+ setOpenCallback: function setOpenCallback(callback) {
+ openCallback = callback;
+ },
+ setSendCallback: function setSendCallback(callback) {
+ sendCallback = callback;
+ },
+ setHeaderReceivedCallback: function setHeaderReceivedCallback(callback) {
+ headerReceivedCallback = callback;
+ },
+ setResponseCallback: function setResponseCallback(callback) {
+ responseCallback = callback;
+ },
+ setRequestHeaderCallback: function setRequestHeaderCallback(callback) {
+ requestHeaderCallback = callback;
+ },
+ isInterceptorEnabled: function isInterceptorEnabled() {
+ return _isInterceptorEnabled;
+ },
+ enableInterception: function enableInterception() {
+ if (_isInterceptorEnabled) {
+ return;
+ }
+
+ XMLHttpRequest.prototype.open = function (method, url) {
+ if (openCallback) {
+ openCallback(method, url, this);
+ }
+
+ originalXHROpen.apply(this, arguments);
+ };
+
+ XMLHttpRequest.prototype.setRequestHeader = function (header, value) {
+ if (requestHeaderCallback) {
+ requestHeaderCallback(header, value, this);
+ }
+
+ originalXHRSetRequestHeader.apply(this, arguments);
+ };
+
+ XMLHttpRequest.prototype.send = function (data) {
+ var _this = this;
+
+ if (sendCallback) {
+ sendCallback(data, this);
+ }
+
+ if (this.addEventListener) {
+ this.addEventListener('readystatechange', function () {
+ if (!_isInterceptorEnabled) {
+ return;
+ }
+
+ if (_this.readyState === _this.HEADERS_RECEIVED) {
+ var contentTypeString = _this.getResponseHeader('Content-Type');
+
+ var contentLengthString = _this.getResponseHeader('Content-Length');
+
+ var responseContentType, responseSize;
+
+ if (contentTypeString) {
+ responseContentType = contentTypeString.split(';')[0];
+ }
+
+ if (contentLengthString) {
+ responseSize = parseInt(contentLengthString, 10);
+ }
+
+ if (headerReceivedCallback) {
+ headerReceivedCallback(responseContentType, responseSize, _this.getAllResponseHeaders(), _this);
+ }
+ }
+
+ if (_this.readyState === _this.DONE) {
+ if (responseCallback) {
+ responseCallback(_this.status, _this.timeout, _this.response, _this.responseURL, _this.responseType, _this);
+ }
+ }
+ }, false);
+ }
+
+ originalXHRSend.apply(this, arguments);
+ };
+
+ _isInterceptorEnabled = true;
+ },
+ disableInterception: function disableInterception() {
+ if (!_isInterceptorEnabled) {
+ return;
+ }
+
+ _isInterceptorEnabled = false;
+ XMLHttpRequest.prototype.send = originalXHRSend;
+ XMLHttpRequest.prototype.open = originalXHROpen;
+ XMLHttpRequest.prototype.setRequestHeader = originalXHRSetRequestHeader;
+ responseCallback = null;
+ openCallback = null;
+ sendCallback = null;
+ headerReceivedCallback = null;
+ requestHeaderCallback = null;
+ }
+ };
+ module.exports = XHRInterceptor;
+},329,[124],"node_modules\\react-native\\Libraries\\Network\\XHRInterceptor.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Inspector\\PerformanceOverlay.js";
+
+ var PerformanceLogger = _$$_REQUIRE(_dependencyMap[5], "PerformanceLogger");
+
+ var React = _$$_REQUIRE(_dependencyMap[6], "React");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[7], "StyleSheet");
+
+ var Text = _$$_REQUIRE(_dependencyMap[8], "Text");
+
+ var View = _$$_REQUIRE(_dependencyMap[9], "View");
+
+ var PerformanceOverlay = function (_React$Component) {
+ _inherits(PerformanceOverlay, _React$Component);
+
+ function PerformanceOverlay() {
+ _classCallCheck(this, PerformanceOverlay);
+
+ return _possibleConstructorReturn(this, _getPrototypeOf(PerformanceOverlay).apply(this, arguments));
+ }
+
+ _createClass(PerformanceOverlay, [{
+ key: "render",
+ value: function render() {
+ var perfLogs = PerformanceLogger.getTimespans();
+ var items = [];
+
+ for (var key in perfLogs) {
+ if (perfLogs[key].totalTime) {
+ var unit = key === 'BundleSize' ? 'b' : 'ms';
+ items.push(React.createElement(View, {
+ style: styles.row,
+ key: key,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 28
+ }
+ }, React.createElement(Text, {
+ style: [styles.text, styles.label],
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 29
+ }
+ }, key), React.createElement(Text, {
+ style: [styles.text, styles.totalTime],
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 30
+ }
+ }, perfLogs[key].totalTime + unit)));
+ }
+ }
+
+ return React.createElement(View, {
+ style: styles.container,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 38
+ }
+ }, items);
+ }
+ }]);
+
+ return PerformanceOverlay;
+ }(React.Component);
+
+ var styles = StyleSheet.create({
+ container: {
+ height: 100,
+ paddingTop: 10
+ },
+ label: {
+ flex: 1
+ },
+ row: {
+ flexDirection: 'row',
+ paddingHorizontal: 10
+ },
+ text: {
+ color: 'white',
+ fontSize: 12
+ },
+ totalTime: {
+ paddingRight: 100
+ }
+ });
+ module.exports = PerformanceOverlay;
+},330,[3,4,5,8,9,156,52,53,208,81],"node_modules\\react-native\\Libraries\\Inspector\\PerformanceOverlay.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\YellowBox\\YellowBox.js";
+
+ var React = _$$_REQUIRE(_dependencyMap[5], "React");
+
+ var YellowBox;
+
+ if (__DEV__) {
+ var _temp;
+
+ var Platform = _$$_REQUIRE(_dependencyMap[6], "Platform");
+
+ var RCTLog = _$$_REQUIRE(_dependencyMap[7], "RCTLog");
+
+ var YellowBoxList = _$$_REQUIRE(_dependencyMap[8], "YellowBoxList");
+
+ var YellowBoxRegistry = _$$_REQUIRE(_dependencyMap[9], "YellowBoxRegistry");
+
+ var _console = console,
+ error = _console.error,
+ warn = _console.warn;
+ YellowBox = (_temp = function (_React$Component) {
+ _inherits(YellowBox, _React$Component);
+
+ function YellowBox() {
+ var _getPrototypeOf2;
+
+ var _this;
+
+ _classCallCheck(this, YellowBox);
+
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(YellowBox)).call.apply(_getPrototypeOf2, [this].concat(args)));
+ _this.state = {
+ registry: null
+ };
+
+ _this._handleDismiss = function (category) {
+ YellowBoxRegistry.delete(category);
+ };
+
+ return _this;
+ }
+
+ _createClass(YellowBox, [{
+ key: "render",
+ value: function render() {
+ return this.state.registry == null ? null : React.createElement(YellowBoxList, {
+ onDismiss: this._handleDismiss,
+ onDismissAll: this._handleDismissAll,
+ registry: this.state.registry,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 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;
+ }
+ }]);
+
+ return YellowBox;
+ }(React.Component), _temp);
+
+ var registerWarning = function registerWarning() {
+ for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+ args[_key4] = arguments[_key4];
+ }
+
+ YellowBoxRegistry.add({
+ args: args,
+ framesToPop: 2
+ });
+ };
+ } else {
+ YellowBox = function (_React$Component2) {
+ _inherits(YellowBox, _React$Component2);
+
+ function YellowBox() {
+ _classCallCheck(this, YellowBox);
+
+ return _possibleConstructorReturn(this, _getPrototypeOf(YellowBox).apply(this, arguments));
+ }
+
+ _createClass(YellowBox, [{
+ key: "render",
+ value: function render() {
+ return null;
+ }
+ }], [{
+ key: "ignoreWarnings",
+ value: function ignoreWarnings(patterns) {}
+ }, {
+ key: "install",
+ value: function install() {}
+ }, {
+ key: "uninstall",
+ value: function uninstall() {}
+ }]);
+
+ return YellowBox;
+ }(React.Component);
+ }
+
+ module.exports = YellowBox;
+},331,[3,4,5,8,9,52,35,154,332,348],"node_modules\\react-native\\Libraries\\YellowBox\\YellowBox.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _slicedToArray = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\YellowBox\\UI\\YellowBoxList.js";
+
+ var Dimensions = _$$_REQUIRE(_dependencyMap[7], "Dimensions");
+
+ var React = _$$_REQUIRE(_dependencyMap[8], "React");
+
+ var FlatList = _$$_REQUIRE(_dependencyMap[9], "FlatList");
+
+ var SafeAreaView = _$$_REQUIRE(_dependencyMap[10], "SafeAreaView");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[11], "StyleSheet");
+
+ var View = _$$_REQUIRE(_dependencyMap[12], "View");
+
+ var YellowBoxButton = _$$_REQUIRE(_dependencyMap[13], "YellowBoxButton");
+
+ var YellowBoxInspector = _$$_REQUIRE(_dependencyMap[14], "YellowBoxInspector");
+
+ var YellowBoxListRow = _$$_REQUIRE(_dependencyMap[15], "YellowBoxListRow");
+
+ var YellowBoxStyle = _$$_REQUIRE(_dependencyMap[16], "YellowBoxStyle");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[17], "Platform");
+
+ var VIEWPORT_RATIO = 0.5;
+ var MAX_ITEMS = Platform.OS === 'win32' || Platform.OS === 'windesktop' ? 3 : Math.floor(Dimensions.get('window').height * VIEWPORT_RATIO / (YellowBoxListRow.GUTTER + YellowBoxListRow.HEIGHT));
+
+ var YellowBoxList = function (_React$Component) {
+ _inherits(YellowBoxList, _React$Component);
+
+ function YellowBoxList() {
+ var _getPrototypeOf2;
+
+ var _this;
+
+ _classCallCheck(this, YellowBoxList);
+
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(YellowBoxList)).call.apply(_getPrototypeOf2, [this].concat(args)));
+ _this.state = {
+ selectedCategory: null
+ };
+
+ _this._handleInspectorDismiss = function () {
+ var category = _this.state.selectedCategory;
+
+ if (category == null) {
+ return;
+ }
+
+ _this.setState({
+ selectedCategory: null
+ }, function () {
+ _this.props.onDismiss(category);
+ });
+ };
+
+ _this._handleInspectorMinimize = function () {
+ _this.setState({
+ selectedCategory: null
+ });
+ };
+
+ _this._handleRowPress = function (category) {
+ _this.setState({
+ selectedCategory: category
+ });
+ };
+
+ return _this;
+ }
+
+ _createClass(YellowBoxList, [{
+ key: "render",
+ value: function render() {
+ var _this2 = this;
+
+ var selectedWarnings = this.state.selectedCategory == null ? null : this.props.registry.get(this.state.selectedCategory);
+
+ if (selectedWarnings != null) {
+ return React.createElement(View, {
+ style: StyleSheet.absoluteFill,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 60
+ }
+ }, React.createElement(YellowBoxInspector, {
+ onDismiss: this._handleInspectorDismiss,
+ onMinimize: this._handleInspectorMinimize,
+ warnings: selectedWarnings,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 61
+ }
+ }));
+ }
+
+ var items = [];
+
+ for (var _iterator = this.props.registry, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();;) {
+ var _ref3;
+
+ if (_isArray) {
+ if (_i >= _iterator.length) break;
+ _ref3 = _iterator[_i++];
+ } else {
+ _i = _iterator.next();
+ if (_i.done) break;
+ _ref3 = _i.value;
+ }
+
+ var _ref5 = _ref3;
+
+ var _ref2 = _slicedToArray(_ref5, 2);
+
+ var _category2 = _ref2[0];
+ var _warnings = _ref2[1];
+ items.unshift({
+ category: _category2,
+ warnings: _warnings
+ });
+ }
+
+ var listStyle = {
+ height: Math.min(items.length, MAX_ITEMS + 0.5) * (YellowBoxListRow.GUTTER + YellowBoxListRow.HEIGHT)
+ };
+ return items.length === 0 ? null : React.createElement(View, {
+ style: styles.list,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 83
+ }
+ }, React.createElement(View, {
+ pointerEvents: "box-none",
+ style: styles.dismissAll,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 84
+ }
+ }, React.createElement(YellowBoxButton, {
+ hitSlop: {
+ bottom: 4,
+ left: 4,
+ right: 4,
+ top: 4
+ },
+ label: "Dismiss All",
+ onPress: this.props.onDismissAll,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 85
+ }
+ })), 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: 95
+ }
+ }));
+ },
+ scrollEnabled: items.length > MAX_ITEMS,
+ scrollsToTop: false,
+ style: listStyle,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 91
+ }
+ }), React.createElement(SafeAreaView, {
+ style: styles.safeArea,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 101
+ }
+ }));
+ }
+ }]);
+
+ return YellowBoxList;
+ }(React.Component);
+
+ var styles = StyleSheet.create({
+ list: {
+ bottom: 0,
+ position: 'absolute',
+ width: Platform.OS === 'win32' ? 270 : '100%'
+ },
+ dismissAll: {
+ bottom: Platform.OS === 'win32' ? undefined : '100%',
+ flexDirection: 'row',
+ justifyContent: 'flex-end',
+ paddingBottom: 4,
+ paddingEnd: 4,
+ position: 'absolute',
+ width: Platform.OS === 'win32' ? 350 : '100%'
+ },
+ safeArea: {
+ backgroundColor: YellowBoxStyle.getBackgroundColor(0.95),
+ marginTop: StyleSheet.hairlineWidth
+ }
+ });
+ module.exports = YellowBoxList;
+},332,[14,37,3,4,5,8,9,55,52,268,333,53,81,334,337,345,336,35],"node_modules\\react-native\\Libraries\\YellowBox\\UI\\YellowBoxList.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "View");
+},333,[81],"Libraries\\Components\\SafeAreaView\\SafeAreaView.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\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;
+},334,[52,53,208,335,336],"node_modules\\react-native\\Libraries\\YellowBox\\UI\\YellowBoxButton.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\YellowBox\\UI\\YellowBoxPressable.js";
+
+ var React = _$$_REQUIRE(_dependencyMap[5], "React");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[6], "StyleSheet");
+
+ var TouchableWithoutFeedback = _$$_REQUIRE(_dependencyMap[7], "TouchableWithoutFeedback");
+
+ var View = _$$_REQUIRE(_dependencyMap[8], "View");
+
+ var YellowBoxStyle = _$$_REQUIRE(_dependencyMap[9], "YellowBoxStyle");
+
+ var YellowBoxPressable = function (_React$Component) {
+ _inherits(YellowBoxPressable, _React$Component);
+
+ function YellowBoxPressable() {
+ var _getPrototypeOf2;
+
+ var _this;
+
+ _classCallCheck(this, YellowBoxPressable);
+
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(YellowBoxPressable)).call.apply(_getPrototypeOf2, [this].concat(args)));
+ _this.state = {
+ pressed: false
+ };
+
+ _this._handlePressIn = function () {
+ _this.setState({
+ pressed: true
+ });
+ };
+
+ _this._handlePressOut = function () {
+ _this.setState({
+ pressed: false
+ });
+ };
+
+ return _this;
+ }
+
+ _createClass(YellowBoxPressable, [{
+ key: "render",
+ value: function render() {
+ var content = React.createElement(View, {
+ style: StyleSheet.compose({
+ backgroundColor: this.state.pressed ? this.props.backgroundColor.pressed : this.props.backgroundColor.default
+ }, this.props.style),
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 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);
+ }
+ }]);
+
+ return YellowBoxPressable;
+ }(React.Component);
+
+ YellowBoxPressable.defaultProps = {
+ backgroundColor: {
+ default: YellowBoxStyle.getBackgroundColor(0.95),
+ pressed: YellowBoxStyle.getHighlightColor(1)
+ }
+ };
+ module.exports = YellowBoxPressable;
+},335,[3,4,5,8,9,52,53,226,81,336],"node_modules\\react-native\\Libraries\\YellowBox\\UI\\YellowBoxPressable.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var YellowBoxStyle = {
+ getBackgroundColor: function getBackgroundColor(opacity) {
+ return "rgba(250, 186, 48, " + opacity + ")";
+ },
+ getDividerColor: function getDividerColor(opacity) {
+ return "rgba(255, 255, 255, " + opacity + ")";
+ },
+ getHighlightColor: function getHighlightColor(opacity) {
+ return "rgba(252, 176, 29, " + opacity + ")";
+ },
+ getTextColor: function getTextColor(opacity) {
+ return "rgba(255, 255, 255, " + opacity + ")";
+ }
+ };
+ module.exports = YellowBoxStyle;
+},336,[],"node_modules\\react-native\\Libraries\\YellowBox\\UI\\YellowBoxStyle.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\YellowBox\\UI\\YellowBoxInspector.js";
+
+ var Platform = _$$_REQUIRE(_dependencyMap[5], "Platform");
+
+ var React = _$$_REQUIRE(_dependencyMap[6], "React");
+
+ var ScrollView = _$$_REQUIRE(_dependencyMap[7], "ScrollView");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[8], "StyleSheet");
+
+ var Text = _$$_REQUIRE(_dependencyMap[9], "Text");
+
+ var View = _$$_REQUIRE(_dependencyMap[10], "View");
+
+ var YellowBoxCategory = _$$_REQUIRE(_dependencyMap[11], "YellowBoxCategory");
+
+ var YellowBoxInspectorFooter = _$$_REQUIRE(_dependencyMap[12], "YellowBoxInspectorFooter");
+
+ var YellowBoxInspectorHeader = _$$_REQUIRE(_dependencyMap[13], "YellowBoxInspectorHeader");
+
+ var YellowBoxInspectorSourceMapStatus = _$$_REQUIRE(_dependencyMap[14], "YellowBoxInspectorSourceMapStatus");
+
+ var YellowBoxInspectorStackFrame = _$$_REQUIRE(_dependencyMap[15], "YellowBoxInspectorStackFrame");
+
+ var YellowBoxStyle = _$$_REQUIRE(_dependencyMap[16], "YellowBoxStyle");
+
+ var openFileInEditor = _$$_REQUIRE(_dependencyMap[17], "openFileInEditor");
+
+ var YellowBoxInspector = function (_React$Component) {
+ _inherits(YellowBoxInspector, _React$Component);
+
+ function YellowBoxInspector() {
+ var _getPrototypeOf2;
+
+ var _this;
+
+ _classCallCheck(this, YellowBoxInspector);
+
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(YellowBoxInspector)).call.apply(_getPrototypeOf2, [this].concat(args)));
+ _this.state = {
+ selectedIndex: 0
+ };
+
+ _this._handleRetrySymbolication = function () {
+ _this._cancelSymbolication();
+
+ _this.forceUpdate(function () {
+ var warning = _this.props.warnings[_this.state.selectedIndex];
+ _this._symbolication = warning.retrySymbolicate(function () {
+ _this.forceUpdate();
+ });
+ });
+ };
+
+ _this._handleSelectIndex = function (selectedIndex) {
+ _this.setState({
+ selectedIndex: selectedIndex
+ });
+ };
+
+ return _this;
+ }
+
+ _createClass(YellowBoxInspector, [{
+ key: "render",
+ value: function render() {
+ var warnings = this.props.warnings;
+ var selectedIndex = this.state.selectedIndex;
+ var warning = warnings[selectedIndex];
+ return React.createElement(View, {
+ style: styles.root,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 55
+ }
+ }, React.createElement(YellowBoxInspectorHeader, {
+ onSelectIndex: this._handleSelectIndex,
+ selectedIndex: selectedIndex,
+ warnings: warnings,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 56
+ }
+ }), React.createElement(ScrollView, {
+ contentContainerStyle: styles.bodyContent,
+ key: selectedIndex,
+ style: styles.body,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 61
+ }
+ }, React.createElement(View, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 65
+ }
+ }, React.createElement(View, {
+ style: styles.bodyHeading,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 66
+ }
+ }, React.createElement(Text, {
+ style: styles.bodyHeadingText,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 67
+ }
+ }, "Warning")), React.createElement(Text, {
+ style: styles.bodyText,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 69
+ }
+ }, YellowBoxCategory.render(warning.message, styles.substitutionText))), React.createElement(View, {
+ style: styles.bodySection,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 76
+ }
+ }, React.createElement(View, {
+ style: styles.bodyHeading,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 77
+ }
+ }, React.createElement(Text, {
+ style: styles.bodyHeadingText,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 78
+ }
+ }, "Stack"), React.createElement(YellowBoxInspectorSourceMapStatus, {
+ onPress: warning.symbolicated.status === 'FAILED' ? this._handleRetrySymbolication : null,
+ status: warning.symbolicated.status,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 79
+ }
+ })), warning.getAvailableStack().map(function (frame, index) {
+ return React.createElement(YellowBoxInspectorStackFrame, {
+ key: index,
+ frame: frame,
+ onPress: warning.symbolicated.status === 'COMPLETE' ? function () {
+ openFileInEditor(frame.file, frame.lineNumber);
+ } : null,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 89
+ }
+ });
+ }))), React.createElement(YellowBoxInspectorFooter, {
+ onDismiss: this.props.onDismiss,
+ onMinimize: this.props.onMinimize,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 103
+ }
+ }));
+ }
+ }, {
+ key: "componentDidMount",
+ value: function componentDidMount() {
+ this._handleSymbolication();
+ }
+ }, {
+ key: "componentDidUpdate",
+ value: function componentDidUpdate(prevProps, prevState) {
+ if (prevProps.warnings !== this.props.warnings || prevState.selectedIndex !== this.state.selectedIndex) {
+ this._cancelSymbolication();
+
+ this._handleSymbolication();
+ }
+ }
+ }, {
+ key: "componentWillUnmount",
+ value: function componentWillUnmount() {
+ this._cancelSymbolication();
+ }
+ }, {
+ key: "_handleSymbolication",
+ value: function _handleSymbolication() {
+ var _this2 = this;
+
+ var warning = this.props.warnings[this.state.selectedIndex];
+
+ if (warning.symbolicated.status !== 'COMPLETE') {
+ this._symbolication = warning.symbolicate(function () {
+ _this2.forceUpdate();
+ });
+ }
+ }
+ }, {
+ key: "_cancelSymbolication",
+ value: function _cancelSymbolication() {
+ if (this._symbolication != null) {
+ this._symbolication.abort();
+
+ this._symbolication = null;
+ }
+ }
+ }]);
+
+ return YellowBoxInspector;
+ }(React.Component);
+
+ var styles = StyleSheet.create({
+ root: {
+ elevation: 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;
+},337,[3,4,5,8,9,35,52,275,53,208,81,338,340,341,343,344,336,326],"node_modules\\react-native\\Libraries\\YellowBox\\UI\\YellowBoxInspector.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _toConsumableArray = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/toConsumableArray");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\YellowBox\\Data\\YellowBoxCategory.js";
+
+ var React = _$$_REQUIRE(_dependencyMap[1], "React");
+
+ var Text = _$$_REQUIRE(_dependencyMap[2], "Text");
+
+ var UTFSequence = _$$_REQUIRE(_dependencyMap[3], "UTFSequence");
+
+ var stringifySafe = _$$_REQUIRE(_dependencyMap[4], "stringifySafe");
+
+ var SUBSTITUTION = UTFSequence.BOM + '%s';
+ var YellowBoxCategory = {
+ parse: function parse(args) {
+ var categoryParts = [];
+ var contentParts = [];
+ var substitutionOffsets = [];
+
+ var remaining = _toConsumableArray(args);
+
+ if (typeof remaining[0] === 'string') {
+ var formatString = String(remaining.shift());
+ var formatStringParts = formatString.split('%s');
+ var substitutionCount = formatStringParts.length - 1;
+ var substitutions = remaining.splice(0, substitutionCount);
+ var categoryString = '';
+ var contentString = '';
+ var substitutionIndex = 0;
+
+ for (var _iterator = formatStringParts, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();;) {
+ var _ref;
+
+ if (_isArray) {
+ if (_i >= _iterator.length) break;
+ _ref = _iterator[_i++];
+ } else {
+ _i = _iterator.next();
+ if (_i.done) break;
+ _ref = _i.value;
+ }
+
+ var _formatStringPart = _ref;
+ categoryString += _formatStringPart;
+ contentString += _formatStringPart;
+
+ if (substitutionIndex < substitutionCount) {
+ if (substitutionIndex < substitutions.length) {
+ var substitution = stringifySafe(substitutions[substitutionIndex]);
+ substitutionOffsets.push({
+ length: substitution.length,
+ offset: contentString.length
+ });
+ categoryString += SUBSTITUTION;
+ contentString += substitution;
+ } else {
+ substitutionOffsets.push({
+ length: 2,
+ offset: contentString.length
+ });
+ categoryString += '%s';
+ contentString += '%s';
+ }
+
+ substitutionIndex++;
+ }
+ }
+
+ categoryParts.push(categoryString);
+ contentParts.push(contentString);
+ }
+
+ var remainingArgs = remaining.map(stringifySafe);
+ categoryParts.push.apply(categoryParts, _toConsumableArray(remainingArgs));
+ contentParts.push.apply(contentParts, _toConsumableArray(remainingArgs));
+ return {
+ category: categoryParts.join(' '),
+ message: {
+ content: contentParts.join(' '),
+ substitutions: substitutionOffsets
+ }
+ };
+ },
+ render: function render(_ref2, substitutionStyle) {
+ var content = _ref2.content,
+ substitutions = _ref2.substitutions;
+ var elements = [];
+ var lastOffset = substitutions.reduce(function (prevOffset, substitution, index) {
+ var key = String(index);
+
+ if (substitution.offset > prevOffset) {
+ var prevPart = content.substr(prevOffset, substitution.offset - prevOffset);
+ elements.push(React.createElement(Text, {
+ key: key,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 119
+ }
+ }, prevPart));
+ }
+
+ var substititionPart = content.substr(substitution.offset, substitution.length);
+ elements.push(React.createElement(Text, {
+ key: key + '.5',
+ style: substitutionStyle,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 127
+ }
+ }, substititionPart));
+ return substitution.offset + substitution.length;
+ }, 0);
+
+ if (lastOffset < content.length) {
+ var lastPart = content.substr(lastOffset);
+ elements.push(React.createElement(Text, {
+ key: "-1",
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 139
+ }
+ }, lastPart));
+ }
+
+ return elements;
+ }
+ };
+ module.exports = YellowBoxCategory;
+},338,[43,52,208,339,50],"node_modules\\react-native\\Libraries\\YellowBox\\Data\\YellowBoxCategory.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var deepFreezeAndThrowOnMutationInDev = _$$_REQUIRE(_dependencyMap[0], "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;
+},339,[49],"node_modules\\react-native\\Libraries\\UTFSequence.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\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;
+},340,[52,333,53,208,81,335,336],"node_modules\\react-native\\Libraries\\YellowBox\\UI\\YellowBoxInspectorFooter.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\YellowBox\\UI\\YellowBoxInspectorHeader.js";
+
+ var Image = _$$_REQUIRE(_dependencyMap[0], "Image");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[1], "Platform");
+
+ var React = _$$_REQUIRE(_dependencyMap[2], "React");
+
+ var SafeAreaView = _$$_REQUIRE(_dependencyMap[3], "SafeAreaView");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[4], "StyleSheet");
+
+ var Text = _$$_REQUIRE(_dependencyMap[5], "Text");
+
+ var View = _$$_REQUIRE(_dependencyMap[6], "View");
+
+ var YellowBoxImageSource = _$$_REQUIRE(_dependencyMap[7], "YellowBoxImageSource");
+
+ var YellowBoxPressable = _$$_REQUIRE(_dependencyMap[8], "YellowBoxPressable");
+
+ var YellowBoxStyle = _$$_REQUIRE(_dependencyMap[9], "YellowBoxStyle");
+
+ var YellowBoxInspectorHeader = function YellowBoxInspectorHeader(props) {
+ var prevIndex = props.selectedIndex - 1;
+ var nextIndex = props.selectedIndex + 1;
+ var titleText = props.warnings.length === 1 ? 'Single Occurrence' : "Occurrence " + (props.selectedIndex + 1) + " of " + props.warnings.length;
+ return React.createElement(SafeAreaView, {
+ style: styles.root,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 42
+ }
+ }, React.createElement(View, {
+ style: styles.header,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 43
+ }
+ }, React.createElement(YellowBoxInspectorHeaderButton, {
+ disabled: props.warnings[prevIndex] == null,
+ image: YellowBoxImageSource.chevronLeft,
+ onPress: function onPress() {
+ return props.onSelectIndex(prevIndex);
+ },
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 44
+ }
+ }), React.createElement(View, {
+ style: styles.headerTitle,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 49
+ }
+ }, React.createElement(Text, {
+ style: styles.headerTitleText,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 50
+ }
+ }, titleText)), React.createElement(YellowBoxInspectorHeaderButton, {
+ disabled: props.warnings[nextIndex] == null,
+ image: YellowBoxImageSource.chevronRight,
+ onPress: function onPress() {
+ return props.onSelectIndex(nextIndex);
+ },
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 52
+ }
+ })));
+ };
+
+ var YellowBoxInspectorHeaderButton = function YellowBoxInspectorHeaderButton(props) {
+ return React.createElement(YellowBoxPressable, {
+ backgroundColor: {
+ default: 'transparent',
+ pressed: YellowBoxStyle.getHighlightColor(1)
+ },
+ onPress: props.disabled ? null : props.onPress,
+ style: styles.headerButton,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 69
+ }
+ }, props.disabled ? null : React.createElement(Image, {
+ source: {
+ height: 16,
+ uri: props.image,
+ width: 16
+ },
+ style: styles.headerButtonImage,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 77
+ }
+ }));
+ };
+
+ var styles = StyleSheet.create({
+ root: {
+ backgroundColor: YellowBoxStyle.getBackgroundColor(0.95)
+ },
+ header: {
+ flexDirection: 'row',
+ height: Platform.select({
+ android: 48,
+ ios: 44
+ })
+ },
+ headerButton: {
+ alignItems: 'center',
+ aspectRatio: 1,
+ justifyContent: 'center'
+ },
+ headerButtonImage: {
+ tintColor: YellowBoxStyle.getTextColor(1)
+ },
+ headerTitle: {
+ alignItems: 'center',
+ flex: 1,
+ justifyContent: 'center'
+ },
+ headerTitleText: {
+ color: YellowBoxStyle.getTextColor(1),
+ fontSize: 16,
+ fontWeight: '600',
+ includeFontPadding: false,
+ lineHeight: 20
+ }
+ });
+ module.exports = YellowBoxInspectorHeader;
+},341,[287,35,52,333,53,208,81,342,335,336],"node_modules\\react-native\\Libraries\\YellowBox\\UI\\YellowBoxInspectorHeader.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var PixelRatio = _$$_REQUIRE(_dependencyMap[0], "PixelRatio");
+
+ var scale = PixelRatio.get();
+ /**
+ * We use inline images for YellowBox in order to avoid display latency due to
+ * resource contention with symbolicating stack traces.
+ *
+ * The following steps were used to create these:
+ *
+ * 1. Download SVG files from: https://feathericons.com
+ * 2. Rasterize SVG files to PNG files at 16dp, 36dp, and 48dp.
+ * 3. Convert to Base64: https://www.google.com/search?q=base64+image+encoder
+ *
+ * @see https://github.com/feathericons/feather
+ * @copyright 2013-2017 Cole Bemis
+ * @license MIT
+ */
+
+ var YellowBoxImageSource = {
+ alertTriangle: scale > 2 ? 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAYAAABXAvmHAAAB60lEQVRoge2Z3W3DIBSFj9oFPAIjZARGyAiMkBHuJh4hI2QEj5AR3Me+tQ91JALHmD8bKvmTkCr5Auc6/kzUACcnRXzuvL4GoAB8Afjeea9qXADcAfw4475c65orgBl++NeYl5ouUQiHt5tQTRJuwB6b5zLY49QVGn7I0bo+kuv60IQbuHf5CWCIqOkCgX93maia1MkRAUMo+OI+AvUPp7a50EzcUCBF6psJrUkYiZgnZJ7eId8mMeIyhpW5hyLw72LKCXsl86VqwgAKceKapW5e/nZpJnSsuHaTM7muyDq7C63JprJS69YxhNTpSlkpKeLGNHCo0EJChcSNaQA4SGiFtBMXJFSI3YVOPXFB6kMoUl9NaE0Wl4h5KQ0AOwqde+KmNrCL0EKCxJ64qQ0AlYVWSBfXZusgW6Oa0Dni2hiEv0qsoci+yUJrsoikLlKAkP11ygK54taiSOgb/O5b/DMqS+gBZeLWJlnoEX7XwQkBDPIktlEkz7hWrEmxZG4M5L9GXYTk0qxwcopKxa3VABN6cosM/C5LxTUof4ReMKHf1nRlaSnuGsGM7kfU4w8RF5Bz4aNlokLe/HQ/ngl9/Qih4L9k3h4hA1+S3odxu3Q77Hl4r1Hg75n6D01M2Difbp02Mi3ZTk5OLH4BUyEtOlDYuK0AAAAASUVORK5CYII=' : scale > 1 ? 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAABVklEQVRYheWX4U3DMBBGH4gBMoJHyAgeoSNkAxjBG5QNOkJHCGzQDcoGZQP4gY3Oqe1cEscS4pNOqs9Jvqvv6ZrCf9fDhnutD4A3H810Br4mcW5l7hLmIdze5mZi+OJD5syeBYzC6CjyR5Ef9zI/CJMb0Im9zufC/qG2eQdchcGQuGYQ+9dJgZvl0B2xbJGrZW6IIevFXp9YVwcyB540syJfFcgSeJb0cVcDcg68XAFQCUhH+ShLBcBGIA158LQFqIB8zBRwEp9fgctcxQld/L2pZxZVAk/KkucjaDGQmoknrz35KEE2sABIRxm8tVIBaZgHb61UQOYmXk7aFgQVJ6QWPCnLAriYAVILnpTxD7yh/9EZiIEE4m+y29uMkGy1nQ6i9wYFRB5PwKdYP/v1msmnUe89gn695bG0iqjdXeMiRu9599csvGKZ0jlu0Ac/7d2rxX9Q37HW6QfX/ZguAAAAAElFTkSuQmCC' : 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAvUlEQVQ4jbWT4Q3CIBCFP40DdANxg24gIzhKuwEjuIFxAkcwTtARGicoG+iPXlMCB8UfvoQc4e7ePV4A/ogWuMlqc0W7AsEo0QMNcPplugMmwMia5KwKWkNIuIkHq3wLXGQ/Sq4IC3wkLpOfmZyKeEpIEKsDYB8VN0Afkfpg30uNiycbdKcNqXEOxdBEWoEAoqta8uZ0iqqkxwGDUrSFAXAHZpOWd/+ubD5Kz335Cx1wZna4Bh54AddauVl8ARfCLO9Xq7xGAAAAAElFTkSuQmCC',
+ check: scale > 2 ? 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAYAAABXAvmHAAAAqElEQVRoge3YTQ7CIBRF4bPUu/8JS6gTSaqilh95vuR+CaO2cGgYNAUzMzOzFgHlPhRaMkDAcRoltKaTeIxPtQHxGn+Q5AgJx8cQjo8hHB9DOP76Yiu/RcTmN18WLiQCjs3zBkYXVGOeLWd+xcIr5pgyEzDz7FIjISPP/FRPUM+9W4nvYVfuCSXeB3669ldEOzRFfCUSx1cicXwlEsdXIvEPKDMzM7PMbtugw3XTpNA2AAAAAElFTkSuQmCC' : scale > 1 ? 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAAf0lEQVRYhe2UvQ2AIBQGL3EBR3AESkv3bxxFN8DmWUgwvkI+En1X0cBd+IMg+DuDyDMCs413kfMiX4EMbD3l8oCaPIU85B4mYLEF5XJscrYFPRGvb/sZ4IlocubJGdH0wj1FSG77XYT0qdUi5O+8jOjyyZQRUnkZ0UUeBMF3OQC/0VsyGlxligAAAABJRU5ErkJggg==' : 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAASElEQVQ4jWNgGJHAgIGBIYESze8ZGBjWU6L5PAMDgwBNNCdAFZJt83qoQmRDSHK2AFQhzBCy/IxsCNkBJsDAwLAfiknWPBIBAETPFeuA4fr6AAAAAElFTkSuQmCC',
+ chevronLeft: scale > 2 ? 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAYAAABXAvmHAAAAgElEQVRoge3YMQ6DQBAEwRYvnf8nPAECbAnkyATsrt0lXUyPdAE6kCRJ/yXA+jopLbkhwHY6a2nNl8I1ftSA8Bm/MeQKBeNrBONrBONrBONrhMHxcPwOlMUvT32oszD8CoEj+giO6CE4oofgiB7Cj44Y86zyFoYPgOFPi5Ik6WwHji+QVIOyhqgAAAAASUVORK5CYII=' : scale > 1 ? 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACQAAAAkCAYAAADhAJiYAAAAaUlEQVRYhe3WsQ2AMAwAwRcs5LEYg3HpYANoQKKgcEEUI/6adM5LbgySfmZsNDeACdiApdEfaQGswH6+Xd1jugc9xYQxxhjz9RhaxwxvDuul3MrAqDyjsozKKnWgXUqdsJcAZgqsTFJ5B7gjUNw0n0HHAAAAAElFTkSuQmCC' : 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAARklEQVQ4jWNgGPKAmUh1AQwMDBIMDAwPyLEkgYGB4T/UELI1J9BdcwCxmpnIMZ1YkECsK+hmCNZoZCHCgAUMDAwfoHg4AgDJuQ/bcLyV+QAAAABJRU5ErkJggg==',
+ chevronRight: scale > 2 ? 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAYAAABXAvmHAAAAeElEQVRoge3YMQ6AIBQE0Ykn3fs3HEEbC6MdFp+v8xJaspNQAZIkqbcA4zwpXTJpAPvlpHTNhHtAu4jwDDCiQjBiDcGINQQj1hCMWEN4Boy3l25vL/iL0PgJBcfXCI6vERxfIzi+Rmg8Hj7wrdL+Yys0/1qUJEmzDvSAkFQ8EOdJAAAAAElFTkSuQmCC' : scale > 1 ? 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACQAAAAkCAYAAADhAJiYAAAAZElEQVRYhe3WsQmAQAxA0Y8ulLEcw3HtdANtBNvzCJjD/5pUgQ9pApJ+Zu7YCWABDmDLzemzA+c94+MW4AkqExUY1caoVka1GibqlSm7qJJSJzPGGGMylYqBgi9sACtFYiQN7wKC6VDcJ7tlpQAAAABJRU5ErkJggg==' : 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAANUlEQVQ4jWNgGLbAgYGBIYASAwIYGBj+MzAwJFBiSMLQMISJEpMptp2mmimORgcGChPSEAIAHGENPH8gqdYAAAAASUVORK5CYII=',
+ loader: scale > 2 ? 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAYAAABXAvmHAAABXElEQVRoge2a3W3DMAyEr+0CHkGjaISOcKN4k6zQETpCR+gGzgbpQ10kcamIpKQ6avQBBPxg3pHwL2UDg/8LASxrcNdKnCwATmssrUyeWgnju/DmXs8tRP+Sh2kgAJga1rFlWj2rcMD5YqQh77QJLbzIORjyRIJQCJW5ngYo5AVlrsgkCGqbsDbAhFfxqZsSZibP0oDXQ43HQPsg82i7sBoR+VcJq2YxKcPo0IoJLRZXmYGC6ezQmQUdVqhPBVH/CNBTSMkLVlzjA8Bbocb7GoPBoADi+umZilYzbrG/JrnljOvy734iu4To/BQaDB6Rl4LciPPF9Lmjhgvi+s7w6tCIGw3WKS0P8fvWNjt0ZkGHFeq7CQXTbkZKGg2JOxrqPUZ3s6ziNdju38IjS/dLi0EQpDLX2gDQYHEX6Hx5/YcA+6H0NgAYPnCMj3x7Mxq4wTGx3Q1E578aDDR8AX0mOGD6BEN/AAAAAElFTkSuQmCC' : scale > 1 ? 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAABN0lEQVRYhe2WzU3EMBCFP34KyJEjJaQDXAIlJJ24BSow2wEdhHSwJSwd7JHbcmC0mOxMnDiWDIInWbHkN29exo4n8IvRAEFGU8OAA04yulyR60Jm7msbyIZloAMGwBfI4UWrWxM08LW/weC4iOMNTog4g0awKjBG827GxBwC3996NHizAifsSrTRmlsZm23CT9adktyXSq6ZUPdxgiXnZzW8CLcLuC3lvqA/gCt5NtjlPQL7TP0Wu1HtRRu4PO3T4TKTz2kG+AG9IN6CR/Su9iojBw69egfghWgL/pGCp+JFVPUqTjWjlsuqeAo1o6rt2C8QcNiV0UxoHPMieojmz0CfMKyhl1hN84xbI3gnz5Ftp7kH3iT5LsFdDUf6pzSJ6r2glIFDbuDNhqRH4I7Pvv4EvG/QqocP2Jh/xzzX/zUAAAAASUVORK5CYII=' : 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAsklEQVQ4jaWTYRHCMAyFP7gJmIQ6oChgEpBQKXMwC3MADpAAEiphDuBHC4QuDRu8u9ylyWtem7Rgw2X7GT1wsghb4beAVzhtsfYyJgs44AoEQzBkjrMId1HkKPwyZ6oMSnxYsnk1NqT7yMo34Fzhd9meGJvs7Hh3NhqCLXDI/rT0lKsR+KOJgc9RdaRRarkZvELogYsi8HqxjUhGYE+aQg1jzketwFTZXHbbEpjB8eU7PwAbLiJz46707gAAAABJRU5ErkJggg=='
+ };
+ module.exports = YellowBoxImageSource;
+},342,[54],"node_modules\\react-native\\Libraries\\YellowBox\\UI\\YellowBoxImageSource.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\YellowBox\\UI\\YellowBoxInspectorSourceMapStatus.js";
+
+ var Animated = _$$_REQUIRE(_dependencyMap[5], "Animated");
+
+ var Easing = _$$_REQUIRE(_dependencyMap[6], "Easing");
+
+ var React = _$$_REQUIRE(_dependencyMap[7], "React");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[8], "StyleSheet");
+
+ var Text = _$$_REQUIRE(_dependencyMap[9], "Text");
+
+ var YellowBoxImageSource = _$$_REQUIRE(_dependencyMap[10], "YellowBoxImageSource");
+
+ var YellowBoxPressable = _$$_REQUIRE(_dependencyMap[11], "YellowBoxPressable");
+
+ var YellowBoxStyle = _$$_REQUIRE(_dependencyMap[12], "YellowBoxStyle");
+
+ var YellowBoxInspectorSourceMapStatus = function (_React$Component) {
+ _inherits(YellowBoxInspectorSourceMapStatus, _React$Component);
+
+ function YellowBoxInspectorSourceMapStatus() {
+ var _getPrototypeOf2;
+
+ var _this;
+
+ _classCallCheck(this, YellowBoxInspectorSourceMapStatus);
+
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(YellowBoxInspectorSourceMapStatus)).call.apply(_getPrototypeOf2, [this].concat(args)));
+ _this.state = {
+ animation: null,
+ rotate: null
+ };
+ return _this;
+ }
+
+ _createClass(YellowBoxInspectorSourceMapStatus, [{
+ key: "render",
+ value: function render() {
+ var image;
+
+ switch (this.props.status) {
+ case 'COMPLETE':
+ image = YellowBoxImageSource.check;
+ break;
+
+ case 'FAILED':
+ image = YellowBoxImageSource.alertTriangle;
+ break;
+
+ case 'PENDING':
+ image = YellowBoxImageSource.loader;
+ break;
+ }
+
+ return image == null ? null : React.createElement(YellowBoxPressable, {
+ backgroundColor: {
+ default: YellowBoxStyle.getTextColor(0.8),
+ pressed: YellowBoxStyle.getTextColor(0.6)
+ },
+ hitSlop: {
+ bottom: 8,
+ left: 8,
+ right: 8,
+ top: 8
+ },
+ onPress: this.props.onPress,
+ style: StyleSheet.compose(styles.root, this.props.status === 'PENDING' ? styles.pending : null),
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 57
+ }
+ }, React.createElement(Animated.Image, {
+ source: {
+ height: 16,
+ uri: image,
+ width: 16
+ },
+ style: StyleSheet.compose(styles.image, this.state.rotate == null ? null : {
+ transform: [{
+ rotate: this.state.rotate
+ }]
+ }),
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 68
+ }
+ }), React.createElement(Text, {
+ style: styles.text,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 77
+ }
+ }, "Source Map"));
+ }
+ }, {
+ key: "componentDidMount",
+ value: function componentDidMount() {
+ this._updateAnimation();
+ }
+ }, {
+ key: "componentDidUpdate",
+ value: function componentDidUpdate() {
+ this._updateAnimation();
+ }
+ }, {
+ key: "componentWillUnmount",
+ value: function componentWillUnmount() {
+ if (this.state.animation != null) {
+ this.state.animation.stop();
+ }
+ }
+ }, {
+ key: "_updateAnimation",
+ value: function _updateAnimation() {
+ if (this.props.status === 'PENDING') {
+ if (this.state.animation == null) {
+ var animated = new Animated.Value(0);
+ var animation = Animated.loop(Animated.timing(animated, {
+ duration: 2000,
+ easing: Easing.linear,
+ toValue: 1,
+ useNativeDriver: true
+ }));
+ this.setState({
+ animation: animation,
+ rotate: animated.interpolate({
+ inputRange: [0, 1],
+ outputRange: ['0deg', '360deg']
+ })
+ }, function () {
+ animation.start();
+ });
+ }
+ } else {
+ if (this.state.animation != null) {
+ this.state.animation.stop();
+ this.setState({
+ animation: null,
+ rotate: null
+ });
+ }
+ }
+ }
+ }]);
+
+ return YellowBoxInspectorSourceMapStatus;
+ }(React.Component);
+
+ var styles = StyleSheet.create({
+ root: {
+ alignItems: 'center',
+ borderRadius: 12,
+ flexDirection: 'row',
+ height: 24,
+ paddingHorizontal: 8
+ },
+ pending: {
+ backgroundColor: YellowBoxStyle.getTextColor(0.6)
+ },
+ image: {
+ marginEnd: 4,
+ tintColor: YellowBoxStyle.getBackgroundColor(1)
+ },
+ text: {
+ color: YellowBoxStyle.getBackgroundColor(1),
+ fontSize: 12,
+ includeFontPadding: false,
+ lineHeight: 16
+ }
+ });
+ module.exports = YellowBoxInspectorSourceMapStatus;
+},343,[3,4,5,8,9,237,264,52,53,208,342,335,336],"node_modules\\react-native\\Libraries\\YellowBox\\UI\\YellowBoxInspectorSourceMapStatus.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\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;
+},344,[52,53,208,335,336],"node_modules\\react-native\\Libraries\\YellowBox\\UI\\YellowBoxInspectorStackFrame.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\YellowBox\\UI\\YellowBoxListRow.js";
+
+ var React = _$$_REQUIRE(_dependencyMap[5], "React");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[6], "StyleSheet");
+
+ var Text = _$$_REQUIRE(_dependencyMap[7], "Text");
+
+ var YellowBoxPressable = _$$_REQUIRE(_dependencyMap[8], "YellowBoxPressable");
+
+ var View = _$$_REQUIRE(_dependencyMap[9], "View");
+
+ var YellowBoxCategory = _$$_REQUIRE(_dependencyMap[10], "YellowBoxCategory");
+
+ var YellowBoxStyle = _$$_REQUIRE(_dependencyMap[11], "YellowBoxStyle");
+
+ var YellowBoxWarning = _$$_REQUIRE(_dependencyMap[12], "YellowBoxWarning");
+
+ var YellowBoxListRow = function (_React$Component) {
+ _inherits(YellowBoxListRow, _React$Component);
+
+ function YellowBoxListRow() {
+ var _getPrototypeOf2;
+
+ var _this;
+
+ _classCallCheck(this, YellowBoxListRow);
+
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(YellowBoxListRow)).call.apply(_getPrototypeOf2, [this].concat(args)));
+
+ _this._handlePress = function () {
+ _this.props.onPress(_this.props.category);
+ };
+
+ return _this;
+ }
+
+ _createClass(YellowBoxListRow, [{
+ key: "shouldComponentUpdate",
+ value: function shouldComponentUpdate(nextProps) {
+ var prevProps = this.props;
+ return prevProps.category !== nextProps.category || prevProps.onPress !== nextProps.onPress || prevProps.warnings.length !== nextProps.warnings.length || prevProps.warnings.some(function (prevWarning, index) {
+ return prevWarning !== nextProps[index];
+ });
+ }
+ }, {
+ key: "render",
+ value: function render() {
+ var warnings = this.props.warnings;
+ return React.createElement(YellowBoxPressable, {
+ onPress: this._handlePress,
+ style: styles.root,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 50
+ }
+ }, React.createElement(View, {
+ style: styles.content,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 51
+ }
+ }, warnings.length < 2 ? null : React.createElement(Text, {
+ style: styles.metaText,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 53
+ }
+ }, '(' + warnings.length + ') '), React.createElement(Text, {
+ numberOfLines: 2,
+ style: styles.bodyText,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 55
+ }
+ }, YellowBoxCategory.render(warnings[warnings.length - 1].message, styles.substitutionText))));
+ }
+ }]);
+
+ return YellowBoxListRow;
+ }(React.Component);
+
+ YellowBoxListRow.GUTTER = StyleSheet.hairlineWidth;
+ YellowBoxListRow.HEIGHT = 48;
+ var styles = StyleSheet.create({
+ root: {
+ height: YellowBoxListRow.HEIGHT,
+ justifyContent: 'center',
+ marginTop: YellowBoxListRow.GUTTER,
+ paddingHorizontal: 12
+ },
+ content: {
+ alignItems: 'flex-start',
+ flexDirection: 'row'
+ },
+ bodyText: {
+ color: YellowBoxStyle.getTextColor(1),
+ flex: 1,
+ fontSize: 14,
+ includeFontPadding: false,
+ lineHeight: 18
+ },
+ metaText: {
+ color: YellowBoxStyle.getTextColor(0.5),
+ fontSize: 14,
+ includeFontPadding: false,
+ lineHeight: 18
+ },
+ substitutionText: {
+ color: YellowBoxStyle.getTextColor(0.6)
+ }
+ });
+ module.exports = YellowBoxListRow;
+},345,[3,4,5,8,9,52,53,208,335,81,338,336,346],"node_modules\\react-native\\Libraries\\YellowBox\\UI\\YellowBoxListRow.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var YellowBoxCategory = _$$_REQUIRE(_dependencyMap[3], "YellowBoxCategory");
+
+ var YellowBoxSymbolication = _$$_REQUIRE(_dependencyMap[4], "YellowBoxSymbolication");
+
+ var parseErrorStack = _$$_REQUIRE(_dependencyMap[5], "parseErrorStack");
+
+ var YellowBoxWarning = function () {
+ _createClass(YellowBoxWarning, null, [{
+ key: "parse",
+ value: function parse(_ref) {
+ var args = _ref.args,
+ framesToPop = _ref.framesToPop;
+ return _objectSpread({}, YellowBoxCategory.parse(args), {
+ stack: createStack({
+ framesToPop: framesToPop + 1
+ })
+ });
+ }
+ }]);
+
+ function YellowBoxWarning(message, stack) {
+ _classCallCheck(this, YellowBoxWarning);
+
+ this.symbolicated = {
+ error: null,
+ stack: null,
+ status: 'NONE'
+ };
+ this.message = message;
+ this.stack = stack;
+ }
+
+ _createClass(YellowBoxWarning, [{
+ key: "getAvailableStack",
+ value: function getAvailableStack() {
+ return this.symbolicated.status === 'COMPLETE' ? this.symbolicated.stack : this.stack;
+ }
+ }, {
+ key: "retrySymbolicate",
+ value: function retrySymbolicate(callback) {
+ YellowBoxSymbolication.delete(this.stack);
+ return this.symbolicate(callback);
+ }
+ }, {
+ key: "symbolicate",
+ value: function symbolicate(callback) {
+ var _this = this;
+
+ var aborted = false;
+
+ if (this.symbolicated.status !== 'COMPLETE') {
+ var updateStatus = function updateStatus(error, stack) {
+ if (error != null) {
+ _this.symbolicated = {
+ error: error,
+ stack: null,
+ status: 'FAILED'
+ };
+ } else if (stack != null) {
+ _this.symbolicated = {
+ error: null,
+ stack: stack,
+ status: 'COMPLETE'
+ };
+ } else {
+ _this.symbolicated = {
+ error: null,
+ stack: null,
+ status: 'PENDING'
+ };
+ }
+
+ if (!aborted) {
+ callback();
+ }
+ };
+
+ updateStatus(null, null);
+ YellowBoxSymbolication.symbolicate(this.stack).then(function (stack) {
+ updateStatus(null, stack);
+ }, function (error) {
+ updateStatus(error, null);
+ });
+ }
+
+ return {
+ abort: function abort() {
+ aborted = true;
+ }
+ };
+ }
+ }]);
+
+ return YellowBoxWarning;
+ }();
+
+ function createStack(_ref2) {
+ var framesToPop = _ref2.framesToPop;
+ var error = new Error();
+ error.framesToPop = framesToPop + 1;
+ return parseErrorStack(error);
+ }
+
+ module.exports = YellowBoxWarning;
+},346,[32,3,4,338,347,99],"node_modules\\react-native\\Libraries\\YellowBox\\Data\\YellowBoxWarning.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var symbolicateStackTrace = _$$_REQUIRE(_dependencyMap[0], "symbolicateStackTrace");
+
+ var cache = new Map();
+ var YellowBoxSymbolication = {
+ delete: function _delete(stack) {
+ cache.delete(getCacheKey(stack));
+ },
+ symbolicate: function symbolicate(stack) {
+ var key = getCacheKey(stack);
+ var promise = cache.get(key);
+
+ if (promise == null) {
+ promise = symbolicateStackTrace(stack).then(sanitize);
+ cache.set(key, promise);
+ }
+
+ return promise;
+ }
+ };
+
+ var getCacheKey = function getCacheKey(stack) {
+ return JSON.stringify(stack);
+ };
+
+ var sanitize = function sanitize(maybeStack) {
+ if (!Array.isArray(maybeStack)) {
+ throw new Error('Expected stack to be an array.');
+ }
+
+ var stack = [];
+
+ for (var _iterator = maybeStack, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();;) {
+ var _ref;
+
+ if (_isArray) {
+ if (_i >= _iterator.length) break;
+ _ref = _iterator[_i++];
+ } else {
+ _i = _iterator.next();
+ if (_i.done) break;
+ _ref = _i.value;
+ }
+
+ var _maybeFrame = _ref;
+
+ if (typeof _maybeFrame !== 'object' || _maybeFrame == null) {
+ throw new Error('Expected each stack frame to be an object.');
+ }
+
+ if (typeof _maybeFrame.column !== 'number' && _maybeFrame.column != null) {
+ throw new Error('Expected stack frame `column` to be a nullable number.');
+ }
+
+ if (typeof _maybeFrame.file !== 'string') {
+ throw new Error('Expected stack frame `file` to be a string.');
+ }
+
+ if (typeof _maybeFrame.lineNumber !== 'number') {
+ throw new Error('Expected stack frame `lineNumber` to be a number.');
+ }
+
+ if (typeof _maybeFrame.methodName !== 'string') {
+ throw new Error('Expected stack frame `methodName` to be a string.');
+ }
+
+ stack.push({
+ column: _maybeFrame.column,
+ file: _maybeFrame.file,
+ lineNumber: _maybeFrame.lineNumber,
+ methodName: _maybeFrame.methodName
+ });
+ }
+
+ return stack;
+ };
+
+ module.exports = YellowBoxSymbolication;
+},347,[101],"node_modules\\react-native\\Libraries\\YellowBox\\Data\\YellowBoxSymbolication.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _toConsumableArray = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/toConsumableArray");
+
+ var _slicedToArray = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray");
+
+ var YellowBoxWarning = _$$_REQUIRE(_dependencyMap[2], "YellowBoxWarning");
+
+ var observers = new Set();
+ var ignorePatterns = new Set();
+ var registry = new Map();
+ var disabled = false;
+ var projection = new Map();
+ var updateTimeout = null;
+
+ function isWarningIgnored(warning) {
+ for (var _iterator = ignorePatterns, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();;) {
+ var _ref;
+
+ if (_isArray) {
+ if (_i >= _iterator.length) break;
+ _ref = _iterator[_i++];
+ } else {
+ _i = _iterator.next();
+ if (_i.done) break;
+ _ref = _i.value;
+ }
+
+ var _pattern = _ref;
+
+ if (warning.message.content.includes(_pattern)) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ function handleUpdate() {
+ projection = new Map();
+
+ if (!disabled) {
+ for (var _iterator2 = registry, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();;) {
+ var _ref4;
+
+ if (_isArray2) {
+ if (_i2 >= _iterator2.length) break;
+ _ref4 = _iterator2[_i2++];
+ } else {
+ _i2 = _iterator2.next();
+ if (_i2.done) break;
+ _ref4 = _i2.value;
+ }
+
+ var _ref5 = _ref4;
+
+ var _ref3 = _slicedToArray(_ref5, 2);
+
+ var _category = _ref3[0];
+ var _warnings = _ref3[1];
+
+ var filtered = _warnings.filter(function (warning) {
+ return !isWarningIgnored(warning);
+ });
+
+ if (filtered.length > 0) {
+ projection.set(_category, filtered);
+ }
+ }
+ }
+
+ if (updateTimeout == null) {
+ updateTimeout = setImmediate(function () {
+ updateTimeout = null;
+
+ for (var _iterator3 = observers, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();;) {
+ var _ref7;
+
+ if (_isArray3) {
+ if (_i3 >= _iterator3.length) break;
+ _ref7 = _iterator3[_i3++];
+ } else {
+ _i3 = _iterator3.next();
+ if (_i3.done) break;
+ _ref7 = _i3.value;
+ }
+
+ var _ref8 = _ref7;
+ var _observer = _ref8.observer;
+
+ _observer(projection);
+ }
+ });
+ }
+ }
+
+ var YellowBoxRegistry = {
+ add: function add(_ref9) {
+ var args = _ref9.args,
+ framesToPop = _ref9.framesToPop;
+
+ if (typeof args[0] === 'string' && args[0].startsWith('(ADVICE)')) {
+ return;
+ }
+
+ var _YellowBoxWarning$par = YellowBoxWarning.parse({
+ args: args,
+ framesToPop: framesToPop + 1
+ }),
+ category = _YellowBoxWarning$par.category,
+ message = _YellowBoxWarning$par.message,
+ stack = _YellowBoxWarning$par.stack;
+
+ var warnings = registry.get(category);
+
+ if (warnings == null) {
+ warnings = [];
+ }
+
+ warnings = [].concat(_toConsumableArray(warnings), [new YellowBoxWarning(message, stack)]);
+ registry.delete(category);
+ registry.set(category, warnings);
+ handleUpdate();
+ },
+ delete: function _delete(category) {
+ if (registry.has(category)) {
+ registry.delete(category);
+ handleUpdate();
+ }
+ },
+ clear: function clear() {
+ if (registry.size > 0) {
+ registry.clear();
+ handleUpdate();
+ }
+ },
+ addIgnorePatterns: function addIgnorePatterns(patterns) {
+ var newPatterns = patterns.filter(function (pattern) {
+ 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;
+},348,[43,37,346],"node_modules\\react-native\\Libraries\\YellowBox\\Data\\YellowBoxRegistry.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var requireNativeComponent = _$$_REQUIRE(_dependencyMap[0], "requireNativeComponent");
+
+ module.exports = requireNativeComponent('RCTModalHostView');
+},349,[184],"node_modules\\react-native\\Libraries\\Modal\\RCTModalHostViewNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Components\\Picker\\Picker.js";
+
+ var PickerAndroid = _$$_REQUIRE(_dependencyMap[6], "PickerAndroid");
+
+ var PickerIOS = _$$_REQUIRE(_dependencyMap[7], "PickerIOS");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[8], "Platform");
+
+ var React = _$$_REQUIRE(_dependencyMap[9], "React");
+
+ var UnimplementedView = _$$_REQUIRE(_dependencyMap[10], "UnimplementedView");
+
+ var MODE_DIALOG = 'dialog';
+ var MODE_DROPDOWN = 'dropdown';
+
+ var PickerItem = function (_React$Component) {
+ _inherits(PickerItem, _React$Component);
+
+ function PickerItem() {
+ _classCallCheck(this, PickerItem);
+
+ return _possibleConstructorReturn(this, _getPrototypeOf(PickerItem).apply(this, arguments));
+ }
+
+ _createClass(PickerItem, [{
+ key: "render",
+ value: function render() {
+ throw null;
+ }
+ }]);
+
+ return PickerItem;
+ }(React.Component);
+
+ var Picker = function (_React$Component2) {
+ _inherits(Picker, _React$Component2);
+
+ function Picker() {
+ _classCallCheck(this, Picker);
+
+ return _possibleConstructorReturn(this, _getPrototypeOf(Picker).apply(this, arguments));
+ }
+
+ _createClass(Picker, [{
+ key: "render",
+ value: function render() {
+ if (Platform.OS === 'ios' || Platform.OS === 'macos') {
+ return React.createElement(PickerIOS, _extends({}, this.props, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 144
+ }
+ }), this.props.children);
+ } else if (Platform.OS === 'android') {
+ return React.createElement(PickerAndroid, _extends({}, this.props, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 149
+ }
+ }), this.props.children);
+ } else {
+ return React.createElement(UnimplementedView, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 152
+ }
+ });
+ }
+ }
+ }]);
+
+ return Picker;
+ }(React.Component);
+
+ Picker.MODE_DIALOG = MODE_DIALOG;
+ Picker.MODE_DROPDOWN = MODE_DROPDOWN;
+ Picker.Item = PickerItem;
+ Picker.defaultProps = {
+ mode: MODE_DIALOG
+ };
+ module.exports = Picker;
+},350,[14,3,4,5,8,9,351,352,35,52,196],"node_modules\\react-native\\Libraries\\Components\\Picker\\Picker.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "UnimplementedView");
+},351,[196],"Libraries\\Components\\Picker\\PickerAndroid.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "UnimplementedView");
+},352,[196],"Libraries\\Components\\Picker\\PickerIOS.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "UnimplementedView");
+},353,[196],"Libraries\\Components\\ProgressViewIOS\\ProgressViewIOS.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "UnimplementedView");
+},354,[196],"Libraries\\Components\\SegmentedControlIOS\\SegmentedControlIOS.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _objectWithoutProperties = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/objectWithoutProperties");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Components\\Slider\\Slider.js";
+
+ var Platform = _$$_REQUIRE(_dependencyMap[2], "Platform");
+
+ var RCTSliderNativeComponent = _$$_REQUIRE(_dependencyMap[3], "RCTSliderNativeComponent");
+
+ var React = _$$_REQUIRE(_dependencyMap[4], "React");
+
+ var ReactNative = _$$_REQUIRE(_dependencyMap[5], "ReactNative");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[6], "StyleSheet");
+
+ var Slider = function Slider(props, forwardedRef) {
+ var style = StyleSheet.compose(styles.slider, props.style);
+
+ var onValueChange = props.onValueChange,
+ onSlidingComplete = props.onSlidingComplete,
+ localProps = _objectWithoutProperties(props, ["onValueChange", "onSlidingComplete"]);
+
+ var onValueChangeEvent = onValueChange ? function (event) {
+ var userEvent = true;
+
+ if (Platform.OS === 'android') {
+ userEvent = event.nativeEvent.fromUser != null && event.nativeEvent.fromUser;
+ }
+
+ userEvent && onValueChange(event.nativeEvent.value);
+ } : null;
+ var onChangeEvent = onValueChangeEvent;
+ var onSlidingCompleteEvent = onSlidingComplete ? function (event) {
+ onSlidingComplete(event.nativeEvent.value);
+ } : null;
+ return React.createElement(RCTSliderNativeComponent, _extends({}, localProps, {
+ ref: forwardedRef,
+ style: style,
+ onChange: onChangeEvent,
+ onSlidingComplete: onSlidingCompleteEvent,
+ onValueChange: onValueChangeEvent,
+ enabled: !props.disabled,
+ onStartShouldSetResponder: function onStartShouldSetResponder() {
+ return true;
+ },
+ onResponderTerminationRequest: function onResponderTerminationRequest() {
+ return false;
+ },
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 230
+ }
+ }));
+ };
+
+ var SliderWithRef = React.forwardRef(Slider);
+ SliderWithRef.defaultProps = {
+ disabled: false,
+ value: 0,
+ minimumValue: 0,
+ maximumValue: 1,
+ step: 0
+ };
+ var styles;
+
+ if (Platform.OS === 'ios' || Platform.OS === 'macos') {
+ styles = StyleSheet.create({
+ slider: {
+ height: 40
+ }
+ });
+ } else {
+ styles = StyleSheet.create({
+ slider: {}
+ });
+ }
+
+ module.exports = SliderWithRef;
+},355,[14,33,35,356,52,84,53],"node_modules\\react-native\\Libraries\\Components\\Slider\\Slider.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var requireNativeComponent = _$$_REQUIRE(_dependencyMap[0], "requireNativeComponent");
+
+ module.exports = requireNativeComponent('RCTSlider');
+},356,[184],"node_modules\\react-native\\Libraries\\Components\\Slider\\RCTSliderNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "UnimplementedView");
+},357,[196],"Libraries\\RCTTest\\SnapshotViewIOS.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _objectWithoutProperties = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/objectWithoutProperties");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Components\\Switch\\Switch.js";
+
+ var SwitchNativeComponent = _$$_REQUIRE(_dependencyMap[7], "SwitchNativeComponent");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[8], "Platform");
+
+ var React = _$$_REQUIRE(_dependencyMap[9], "React");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[10], "StyleSheet");
+
+ var Switch = function (_React$Component) {
+ _inherits(Switch, _React$Component);
+
+ function Switch() {
+ var _getPrototypeOf2;
+
+ var _this;
+
+ _classCallCheck(this, Switch);
+
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(Switch)).call.apply(_getPrototypeOf2, [this].concat(args)));
+
+ _this._handleChange = function (event) {
+ if (_this._nativeSwitchRef == null) {
+ return;
+ }
+
+ var value = _this.props.value === true;
+
+ if (Platform.OS === 'android') {
+ _this._nativeSwitchRef.setNativeProps({
+ on: value
+ });
+ } else {
+ _this._nativeSwitchRef.setNativeProps({
+ value: value
+ });
+ }
+
+ if (_this.props.onChange != null) {
+ _this.props.onChange(event);
+ }
+
+ if (_this.props.onValueChange != null) {
+ _this.props.onValueChange(event.nativeEvent.value);
+ }
+ };
+
+ _this._handleSwitchNativeComponentRef = function (ref) {
+ _this._nativeSwitchRef = ref;
+ };
+
+ return _this;
+ }
+
+ _createClass(Switch, [{
+ key: "render",
+ value: function render() {
+ var _props$accessibilityR;
+
+ var _this$props = this.props,
+ disabled = _this$props.disabled,
+ ios_backgroundColor = _this$props.ios_backgroundColor,
+ onChange = _this$props.onChange,
+ onValueChange = _this$props.onValueChange,
+ style = _this$props.style,
+ thumbColor = _this$props.thumbColor,
+ trackColor = _this$props.trackColor,
+ value = _this$props.value,
+ props = _objectWithoutProperties(_this$props, ["disabled", "ios_backgroundColor", "onChange", "onValueChange", "style", "thumbColor", "trackColor", "value"]);
+
+ var _thumbColor = thumbColor;
+
+ var _trackColorForFalse = trackColor == null ? void 0 : trackColor.false;
+
+ var _trackColorForTrue = trackColor == null ? void 0 : trackColor.true;
+
+ var _ref = props,
+ thumbTintColor = _ref.thumbTintColor,
+ tintColor = _ref.tintColor,
+ onTintColor = _ref.onTintColor;
+
+ if (thumbTintColor != null) {
+ _thumbColor = thumbTintColor;
+
+ if (__DEV__) {
+ console.warn('Switch: `thumbTintColor` is deprecated, use `thumbColor` instead.');
+ }
+ }
+
+ if (tintColor != null) {
+ _trackColorForFalse = tintColor;
+
+ if (__DEV__) {
+ console.warn('Switch: `tintColor` is deprecated, use `trackColor` instead.');
+ }
+ }
+
+ if (onTintColor != null) {
+ _trackColorForTrue = onTintColor;
+
+ if (__DEV__) {
+ console.warn('Switch: `onTintColor` is deprecated, use `trackColor` instead.');
+ }
+ }
+
+ var platformProps = Platform.OS === 'android' ? {
+ enabled: disabled !== true,
+ on: value === true,
+ style: style,
+ thumbTintColor: _thumbColor,
+ trackTintColor: value === true ? _trackColorForTrue : _trackColorForFalse
+ } : {
+ disabled: disabled,
+ onTintColor: _trackColorForTrue,
+ style: StyleSheet.compose({
+ height: 31,
+ width: 51
+ }, StyleSheet.compose(style, ios_backgroundColor == null ? null : {
+ backgroundColor: ios_backgroundColor,
+ borderRadius: 16
+ })),
+ thumbTintColor: _thumbColor,
+ tintColor: _trackColorForFalse,
+ value: value === true
+ };
+ return React.createElement(SwitchNativeComponent, _extends({}, props, platformProps, {
+ accessibilityRole: (_props$accessibilityR = props.accessibilityRole) != null ? _props$accessibilityR : 'button',
+ onChange: this._handleChange,
+ onResponderTerminationRequest: returnsFalse,
+ onStartShouldSetResponder: returnsTrue,
+ ref: this._handleSwitchNativeComponentRef,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 164
+ }
+ }));
+ }
+ }]);
+
+ return Switch;
+ }(React.Component);
+
+ var returnsFalse = function returnsFalse() {
+ return false;
+ };
+
+ var returnsTrue = function returnsTrue() {
+ return true;
+ };
+
+ module.exports = Switch;
+},358,[14,33,3,4,5,8,9,359,35,52,53],"node_modules\\react-native\\Libraries\\Components\\Switch\\Switch.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var Platform = _$$_REQUIRE(_dependencyMap[0], "Platform");
+
+ var ReactNative = _$$_REQUIRE(_dependencyMap[1], "ReactNative");
+
+ var requireNativeComponent = _$$_REQUIRE(_dependencyMap[2], "requireNativeComponent");
+
+ var SwitchNativeComponent = Platform.OS === 'android' ? requireNativeComponent('AndroidSwitch') : requireNativeComponent('RCTSwitch');
+ module.exports = SwitchNativeComponent;
+},359,[35,84,184],"node_modules\\react-native\\Libraries\\Components\\Switch\\SwitchNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var _extends = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/extends");
+
+ var _StatusBarManager$DEF;
+
+ var React = _$$_REQUIRE(_dependencyMap[6], "React");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[7], "Platform");
+
+ var processColor = _$$_REQUIRE(_dependencyMap[8], "processColor");
+
+ var StatusBarManager = _$$_REQUIRE(_dependencyMap[9], "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) {
+ _inherits(StatusBar, _React$Component);
+
+ function StatusBar() {
+ var _getPrototypeOf2;
+
+ var _this;
+
+ _classCallCheck(this, StatusBar);
+
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(StatusBar)).call.apply(_getPrototypeOf2, [this].concat(args)));
+ _this._stackEntry = null;
+ return _this;
+ }
+
+ _createClass(StatusBar, [{
+ key: "componentDidMount",
+ value: function componentDidMount() {
+ this._stackEntry = StatusBar.pushStackEntry(this.props);
+ }
+ }, {
+ key: "componentWillUnmount",
+ value: function componentWillUnmount() {
+ StatusBar.popStackEntry(this._stackEntry);
+ }
+ }, {
+ key: "componentDidUpdate",
+ value: function componentDidUpdate() {
+ this._stackEntry = StatusBar.replaceStackEntry(this._stackEntry, this.props);
+ }
+ }, {
+ key: "render",
+ value: function render() {
+ return null;
+ }
+ }], [{
+ key: "setHidden",
+ value: function setHidden(hidden, animation) {
+ animation = animation || 'none';
+ StatusBar._defaultProps.hidden.value = hidden;
+
+ if (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);
+ }
+ }, {
+ key: "pushStackEntry",
+ value: function pushStackEntry(props) {
+ var entry = createStackEntry(props);
+
+ StatusBar._propsStack.push(entry);
+
+ StatusBar._updatePropsStack();
+
+ return entry;
+ }
+ }, {
+ key: "popStackEntry",
+ value: function popStackEntry(entry) {
+ var index = StatusBar._propsStack.indexOf(entry);
+
+ if (index !== -1) {
+ StatusBar._propsStack.splice(index, 1);
+ }
+
+ StatusBar._updatePropsStack();
+ }
+ }, {
+ key: "replaceStackEntry",
+ value: function replaceStackEntry(entry, props) {
+ var newEntry = createStackEntry(props);
+
+ var index = StatusBar._propsStack.indexOf(entry);
+
+ if (index !== -1) {
+ StatusBar._propsStack[index] = newEntry;
+ }
+
+ StatusBar._updatePropsStack();
+
+ return newEntry;
+ }
+ }]);
+
+ return StatusBar;
+ }(React.Component);
+
+ StatusBar._propsStack = [];
+ StatusBar._defaultProps = createStackEntry({
+ animated: false,
+ showHideTransition: 'fade',
+ backgroundColor: Platform.select({
+ android: (_StatusBarManager$DEF = StatusBarManager.DEFAULT_BACKGROUND_COLOR) != null ? _StatusBarManager$DEF : 'black',
+ ios: 'black'
+ }),
+ barStyle: 'default',
+ translucent: false,
+ hidden: false,
+ networkActivityIndicatorVisible: false
+ });
+ StatusBar._updateImmediate = null;
+ StatusBar._currentValues = null;
+ StatusBar.currentHeight = StatusBarManager.HEIGHT;
+ StatusBar.defaultProps = {
+ animated: false,
+ showHideTransition: 'fade'
+ };
+
+ StatusBar._updatePropsStack = function () {
+ clearImmediate(StatusBar._updateImmediate);
+ StatusBar._updateImmediate = setImmediate(function () {
+ var oldProps = StatusBar._currentValues;
+ var mergedProps = mergePropsStack(StatusBar._propsStack, StatusBar._defaultProps);
+
+ if (Platform.OS === 'ios') {
+ if (!oldProps || oldProps.barStyle.value !== mergedProps.barStyle.value) {
+ StatusBarManager.setStyle(mergedProps.barStyle.value, mergedProps.barStyle.animated || false);
+ }
+
+ 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;
+ });
+ };
+
+ module.exports = StatusBar;
+},360,[3,4,5,8,9,14,52,35,75,36],"node_modules\\react-native\\Libraries\\Components\\StatusBar\\StatusBar.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ var _extends = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/extends");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Experimental\\SwipeableRow\\SwipeableFlatList.js";
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var React = _$$_REQUIRE(_dependencyMap[7], "React");
+
+ var SwipeableRow = _$$_REQUIRE(_dependencyMap[8], "SwipeableRow");
+
+ var FlatList = _$$_REQUIRE(_dependencyMap[9], "FlatList");
+
+ var SwipeableFlatList = function (_React$Component) {
+ _inherits(SwipeableFlatList, _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: 122
+ }
+ }, _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,
+ extraData: this.state,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 83
+ }
+ }));
+ }
+ }, {
+ 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
+ });
+ }
+ }]);
+
+ return SwipeableFlatList;
+ }(React.Component);
+
+ SwipeableFlatList.defaultProps = _objectSpread({}, FlatList.defaultProps, {
+ bounceFirstRowOnMount: true,
+ renderQuickActions: function renderQuickActions() {
+ return null;
+ }
+ });
+ module.exports = SwipeableFlatList;
+},361,[32,14,3,4,5,8,9,52,362,268],"node_modules\\react-native\\Libraries\\Experimental\\SwipeableRow\\SwipeableFlatList.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Experimental\\SwipeableRow\\SwipeableRow.js";
+
+ var Animated = _$$_REQUIRE(_dependencyMap[6], "Animated");
+
+ var I18nManager = _$$_REQUIRE(_dependencyMap[7], "I18nManager");
+
+ var PanResponder = _$$_REQUIRE(_dependencyMap[8], "PanResponder");
+
+ var React = _$$_REQUIRE(_dependencyMap[9], "React");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[10], "StyleSheet");
+
+ var View = _$$_REQUIRE(_dependencyMap[11], "View");
+
+ 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 DEFAULT_SWIPE_THRESHOLD = 30;
+
+ var emptyFunction = function emptyFunction() {};
+
+ var SwipeableRow = function (_React$Component) {
+ _inherits(SwipeableRow, _React$Component);
+
+ function SwipeableRow() {
+ var _getPrototypeOf2;
+
+ var _this;
+
+ _classCallCheck(this, SwipeableRow);
+
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(SwipeableRow)).call.apply(_getPrototypeOf2, [this].concat(args)));
+
+ _this._handleMoveShouldSetPanResponderCapture = function (event, gestureState) {
+ return gestureState.dy < 10 && _this._isValidSwipe(gestureState);
+ };
+
+ _this._handlePanResponderGrant = function (event, gestureState) {};
+
+ _this._handlePanResponderMove = function (event, gestureState) {
+ if (_this._isSwipingExcessivelyRightFromClosedPosition(gestureState)) {
+ return;
+ }
+
+ _this.props.onSwipeStart && _this.props.onSwipeStart();
+
+ if (_this._isSwipingRightFromClosed(gestureState)) {
+ _this._swipeSlowSpeed(gestureState);
+ } else {
+ _this._swipeFullSpeed(gestureState);
+ }
+ };
+
+ _this._onPanResponderTerminationRequest = function (event, gestureState) {
+ return false;
+ };
+
+ _this._handlePanResponderEnd = function (event, gestureState) {
+ var horizontalDistance = IS_RTL ? -gestureState.dx : gestureState.dx;
+
+ if (_this._isSwipingRightFromClosed(gestureState)) {
+ _this.props.onOpen && _this.props.onOpen();
+
+ _this._animateBounceBack(RIGHT_SWIPE_BOUNCE_BACK_DURATION);
+ } else if (_this._shouldAnimateRemainder(gestureState)) {
+ if (horizontalDistance < 0) {
+ _this.props.onOpen && _this.props.onOpen();
+
+ _this._animateToOpenPositionWith(gestureState.vx, horizontalDistance);
+ } else {
+ _this.props.onClose && _this.props.onClose();
+
+ _this._animateToClosedPosition();
+ }
+ } else {
+ if (_this._previousLeft === CLOSED_LEFT_POSITION) {
+ _this._animateToClosedPosition();
+ } else {
+ _this._animateToOpenPosition();
+ }
+ }
+
+ _this.props.onSwipeEnd && _this.props.onSwipeEnd();
+ };
+
+ _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;
+ }
+ });
+ _this._previousLeft = CLOSED_LEFT_POSITION;
+ _this._timeoutID = null;
+ _this.state = {
+ currentLeft: new Animated.Value(_this._previousLeft),
+ isSwipeableViewRendered: false,
+ rowHeight: null
+ };
+
+ _this._onSwipeableViewLayout = function (event) {
+ _this.setState({
+ isSwipeableViewRendered: true,
+ rowHeight: event.nativeEvent.layout.height
+ });
+ };
+
+ _this._animateToClosedPositionDuringBounce = function () {
+ _this._animateToClosedPosition(RIGHT_SWIPE_BOUNCE_BACK_DURATION);
+ };
+
+ return _this;
+ }
+
+ _createClass(SwipeableRow, [{
+ key: "componentDidMount",
+ value: function componentDidMount() {
+ var _this2 = this;
+
+ if (this.props.shouldBounceOnMount) {
+ this._timeoutID = setTimeout(function () {
+ _this2._animateBounceBack(ON_MOUNT_BOUNCE_DURATION);
+ }, ON_MOUNT_BOUNCE_DELAY);
+ }
+ }
+ }, {
+ key: "UNSAFE_componentWillReceiveProps",
+ value: function UNSAFE_componentWillReceiveProps(nextProps) {
+ var _this$props$isOpen, _nextProps$isOpen;
+
+ var isOpen = (_this$props$isOpen = this.props.isOpen) != null ? _this$props$isOpen : false;
+ var nextIsOpen = (_nextProps$isOpen = nextProps.isOpen) != null ? _nextProps$isOpen : false;
+
+ if (isOpen && !nextIsOpen) {
+ this._animateToClosedPosition();
+ }
+ }
+ }, {
+ key: "componentWillUnmount",
+ value: function componentWillUnmount() {
+ if (this._timeoutID != null) {
+ clearTimeout(this._timeoutID);
+ }
+ }
+ }, {
+ key: "render",
+ value: 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: 214
+ }
+ }, this.props.slideoutView);
+ }
+
+ var swipeableView = React.createElement(Animated.View, {
+ onLayout: this._onSwipeableViewLayout,
+ style: {
+ transform: [{
+ translateX: this.state.currentLeft
+ }]
+ },
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 223
+ }
+ }, this.props.children);
+ return React.createElement(View, _extends({}, this._panResponder.panHandlers, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 231
+ }
+ }), slideOutView, swipeableView);
+ }
+ }, {
+ key: "close",
+ value: function close() {
+ this.props.onClose && this.props.onClose();
+
+ this._animateToClosedPosition();
+ }
+ }, {
+ key: "_isSwipingRightFromClosed",
+ value: function _isSwipingRightFromClosed(gestureState) {
+ var gestureStateDx = IS_RTL ? -gestureState.dx : gestureState.dx;
+ return this._previousLeft === CLOSED_LEFT_POSITION && gestureStateDx > 0;
+ }
+ }, {
+ key: "_swipeFullSpeed",
+ value: function _swipeFullSpeed(gestureState) {
+ this.state.currentLeft.setValue(this._previousLeft + gestureState.dx);
+ }
+ }, {
+ key: "_swipeSlowSpeed",
+ value: function _swipeSlowSpeed(gestureState) {
+ this.state.currentLeft.setValue(this._previousLeft + gestureState.dx / SLOW_SPEED_SWIPE_FACTOR);
+ }
+ }, {
+ key: "_isSwipingExcessivelyRightFromClosedPosition",
+ value: function _isSwipingExcessivelyRightFromClosedPosition(gestureState) {
+ var gestureStateDx = IS_RTL ? -gestureState.dx : gestureState.dx;
+ return this._isSwipingRightFromClosed(gestureState) && gestureStateDx > RIGHT_SWIPE_THRESHOLD;
+ }
+ }, {
+ key: "_animateTo",
+ value: function _animateTo(toValue) {
+ var _this3 = 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 () {
+ _this3._previousLeft = toValue;
+ callback();
+ });
+ }
+ }, {
+ key: "_animateToOpenPosition",
+ value: function _animateToOpenPosition() {
+ var _this$props$maxSwipeD;
+
+ var maxSwipeDistance = (_this$props$maxSwipeD = this.props.maxSwipeDistance) != null ? _this$props$maxSwipeD : 0;
+ var directionAwareMaxSwipeDistance = IS_RTL ? -maxSwipeDistance : maxSwipeDistance;
+
+ this._animateTo(-directionAwareMaxSwipeDistance);
+ }
+ }, {
+ key: "_animateToOpenPositionWith",
+ value: function _animateToOpenPositionWith(speed, distMoved) {
+ var _this$props$maxSwipeD2;
+
+ speed = speed > HORIZONTAL_FULL_SWIPE_SPEED_THRESHOLD ? speed : HORIZONTAL_FULL_SWIPE_SPEED_THRESHOLD;
+ var maxSwipeDistance = (_this$props$maxSwipeD2 = this.props.maxSwipeDistance) != null ? _this$props$maxSwipeD2 : 0;
+ var duration = Math.abs((maxSwipeDistance - Math.abs(distMoved)) / speed);
+ var directionAwareMaxSwipeDistance = IS_RTL ? -maxSwipeDistance : maxSwipeDistance;
+
+ this._animateTo(-directionAwareMaxSwipeDistance, duration);
+ }
+ }, {
+ key: "_animateToClosedPosition",
+ value: function _animateToClosedPosition() {
+ var duration = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : SWIPE_DURATION;
+
+ this._animateTo(CLOSED_LEFT_POSITION, duration);
+ }
+ }, {
+ key: "_animateBounceBack",
+ value: function _animateBounceBack(duration) {
+ var swipeBounceBackDistance = IS_RTL ? -RIGHT_SWIPE_BOUNCE_BACK_DISTANCE : RIGHT_SWIPE_BOUNCE_BACK_DISTANCE;
+
+ this._animateTo(-swipeBounceBackDistance, duration, this._animateToClosedPositionDuringBounce);
+ }
+ }, {
+ key: "_isValidSwipe",
+ value: function _isValidSwipe(gestureState) {
+ var _this$props$preventSw;
+
+ var preventSwipeRight = (_this$props$preventSw = this.props.preventSwipeRight) != null ? _this$props$preventSw : false;
+
+ if (preventSwipeRight && this._previousLeft === CLOSED_LEFT_POSITION && gestureState.dx > 0) {
+ return false;
+ }
+
+ return Math.abs(gestureState.dx) > HORIZONTAL_SWIPE_DISTANCE_THRESHOLD;
+ }
+ }, {
+ key: "_shouldAnimateRemainder",
+ value: function _shouldAnimateRemainder(gestureState) {
+ var _this$props$swipeThre;
+
+ var swipeThreshold = (_this$props$swipeThre = this.props.swipeThreshold) != null ? _this$props$swipeThre : DEFAULT_SWIPE_THRESHOLD;
+ return Math.abs(gestureState.dx) > swipeThreshold || gestureState.vx > HORIZONTAL_FULL_SWIPE_SPEED_THRESHOLD;
+ }
+ }]);
+
+ return SwipeableRow;
+ }(React.Component);
+
+ var styles = StyleSheet.create({
+ slideOutContainer: {
+ bottom: 0,
+ left: 0,
+ position: 'absolute',
+ right: 0,
+ top: 0
+ }
+ });
+ module.exports = SwipeableRow;
+},362,[14,3,4,5,8,9,237,320,363,52,53,81],"node_modules\\react-native\\Libraries\\Experimental\\SwipeableRow\\SwipeableRow.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var InteractionManager = _$$_REQUIRE(_dependencyMap[0], "./InteractionManager");
+
+ var TouchHistoryMath = _$$_REQUIRE(_dependencyMap[1], "./TouchHistoryMath");
+
+ var currentCentroidXOfTouchesChangedAfter = TouchHistoryMath.currentCentroidXOfTouchesChangedAfter;
+ var currentCentroidYOfTouchesChangedAfter = TouchHistoryMath.currentCentroidYOfTouchesChangedAfter;
+ var previousCentroidXOfTouchesChangedAfter = TouchHistoryMath.previousCentroidXOfTouchesChangedAfter;
+ var previousCentroidYOfTouchesChangedAfter = TouchHistoryMath.previousCentroidYOfTouchesChangedAfter;
+ var currentCentroidX = TouchHistoryMath.currentCentroidX;
+ var currentCentroidY = TouchHistoryMath.currentCentroidY;
+ var PanResponder = {
+ _initializeGestureState: function _initializeGestureState(gestureState) {
+ gestureState.moveX = 0;
+ gestureState.moveY = 0;
+ gestureState.x0 = 0;
+ gestureState.y0 = 0;
+ gestureState.dx = 0;
+ gestureState.dy = 0;
+ gestureState.vx = 0;
+ gestureState.vy = 0;
+ gestureState.numberActiveTouches = 0;
+ gestureState._accountsForMovesUpTo = 0;
+ },
+ _updateGestureStateOnMove: function _updateGestureStateOnMove(gestureState, touchHistory) {
+ gestureState.numberActiveTouches = touchHistory.numberActiveTouches;
+ gestureState.moveX = currentCentroidXOfTouchesChangedAfter(touchHistory, gestureState._accountsForMovesUpTo);
+ gestureState.moveY = currentCentroidYOfTouchesChangedAfter(touchHistory, gestureState._accountsForMovesUpTo);
+ var movedAfter = gestureState._accountsForMovesUpTo;
+ var prevX = previousCentroidXOfTouchesChangedAfter(touchHistory, movedAfter);
+ var x = currentCentroidXOfTouchesChangedAfter(touchHistory, movedAfter);
+ var prevY = previousCentroidYOfTouchesChangedAfter(touchHistory, movedAfter);
+ var y = currentCentroidYOfTouchesChangedAfter(touchHistory, movedAfter);
+ var nextDX = gestureState.dx + (x - prevX);
+ var nextDY = gestureState.dy + (y - prevY);
+ var dt = touchHistory.mostRecentTimeStamp - gestureState._accountsForMovesUpTo;
+ gestureState.vx = (nextDX - gestureState.dx) / dt;
+ gestureState.vy = (nextDY - gestureState.dy) / dt;
+ gestureState.dx = nextDX;
+ gestureState.dy = nextDY;
+ gestureState._accountsForMovesUpTo = touchHistory.mostRecentTimeStamp;
+ },
+ create: function create(config) {
+ var interactionState = {
+ handle: null
+ };
+ var gestureState = {
+ stateID: Math.random(),
+ moveX: 0,
+ moveY: 0,
+ x0: 0,
+ y0: 0,
+ dx: 0,
+ dy: 0,
+ vx: 0,
+ vy: 0,
+ numberActiveTouches: 0,
+ _accountsForMovesUpTo: 0
+ };
+ var panHandlers = {
+ onStartShouldSetResponder: function onStartShouldSetResponder(event) {
+ return config.onStartShouldSetPanResponder == null ? false : config.onStartShouldSetPanResponder(event, gestureState);
+ },
+ onMoveShouldSetResponder: function onMoveShouldSetResponder(event) {
+ return config.onMoveShouldSetPanResponder == null ? false : config.onMoveShouldSetPanResponder(event, gestureState);
+ },
+ onStartShouldSetResponderCapture: function onStartShouldSetResponderCapture(event) {
+ if (event.nativeEvent.touches.length === 1) {
+ PanResponder._initializeGestureState(gestureState);
+ }
+
+ gestureState.numberActiveTouches = event.touchHistory.numberActiveTouches;
+ return config.onStartShouldSetPanResponderCapture != null ? config.onStartShouldSetPanResponderCapture(event, gestureState) : false;
+ },
+ onMoveShouldSetResponderCapture: function onMoveShouldSetResponderCapture(event) {
+ var touchHistory = event.touchHistory;
+
+ if (gestureState._accountsForMovesUpTo === touchHistory.mostRecentTimeStamp) {
+ return false;
+ }
+
+ PanResponder._updateGestureStateOnMove(gestureState, touchHistory);
+
+ return config.onMoveShouldSetPanResponderCapture ? config.onMoveShouldSetPanResponderCapture(event, gestureState) : false;
+ },
+ onResponderGrant: function onResponderGrant(event) {
+ if (!interactionState.handle) {
+ interactionState.handle = InteractionManager.createInteractionHandle();
+ }
+
+ gestureState.x0 = currentCentroidX(event.touchHistory);
+ gestureState.y0 = currentCentroidY(event.touchHistory);
+ gestureState.dx = 0;
+ gestureState.dy = 0;
+
+ if (config.onPanResponderGrant) {
+ config.onPanResponderGrant(event, gestureState);
+ }
+
+ return config.onShouldBlockNativeResponder == null ? true : config.onShouldBlockNativeResponder(event, gestureState);
+ },
+ onResponderReject: function onResponderReject(event) {
+ clearInteractionHandle(interactionState, config.onPanResponderReject, event, gestureState);
+ },
+ onResponderRelease: function onResponderRelease(event) {
+ clearInteractionHandle(interactionState, config.onPanResponderRelease, event, gestureState);
+
+ PanResponder._initializeGestureState(gestureState);
+ },
+ onResponderStart: function onResponderStart(event) {
+ var touchHistory = event.touchHistory;
+ gestureState.numberActiveTouches = touchHistory.numberActiveTouches;
+
+ if (config.onPanResponderStart) {
+ config.onPanResponderStart(event, gestureState);
+ }
+ },
+ onResponderMove: function onResponderMove(event) {
+ var touchHistory = event.touchHistory;
+
+ if (gestureState._accountsForMovesUpTo === touchHistory.mostRecentTimeStamp) {
+ return;
+ }
+
+ PanResponder._updateGestureStateOnMove(gestureState, touchHistory);
+
+ if (config.onPanResponderMove) {
+ config.onPanResponderMove(event, gestureState);
+ }
+ },
+ onResponderEnd: function onResponderEnd(event) {
+ var touchHistory = event.touchHistory;
+ gestureState.numberActiveTouches = touchHistory.numberActiveTouches;
+ clearInteractionHandle(interactionState, config.onPanResponderEnd, event, gestureState);
+ },
+ onResponderTerminate: function onResponderTerminate(event) {
+ clearInteractionHandle(interactionState, config.onPanResponderTerminate, event, gestureState);
+
+ PanResponder._initializeGestureState(gestureState);
+ },
+ onResponderTerminationRequest: function onResponderTerminationRequest(event) {
+ return config.onPanResponderTerminationRequest == null ? true : config.onPanResponderTerminationRequest(event, gestureState);
+ }
+ };
+ return {
+ panHandlers: panHandlers,
+ getInteractionHandle: function getInteractionHandle() {
+ return interactionState.handle;
+ }
+ };
+ }
+ };
+
+ function clearInteractionHandle(interactionState, callback, event, gestureState) {
+ if (interactionState.handle) {
+ InteractionManager.clearInteractionHandle(interactionState.handle);
+ interactionState.handle = null;
+ }
+
+ if (callback) {
+ callback(event, gestureState);
+ }
+ }
+
+ module.exports = PanResponder;
+},363,[245,364],"node_modules\\react-native\\Libraries\\Interaction\\PanResponder.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var TouchHistoryMath = {
+ centroidDimension: function centroidDimension(touchHistory, touchesChangedAfter, isXAxis, ofCurrent) {
+ var touchBank = touchHistory.touchBank;
+ var total = 0;
+ var count = 0;
+ var oneTouchData = touchHistory.numberActiveTouches === 1 ? touchHistory.touchBank[touchHistory.indexOfSingleActiveTouch] : null;
+
+ if (oneTouchData !== null) {
+ if (oneTouchData.touchActive && oneTouchData.currentTimeStamp > touchesChangedAfter) {
+ total += ofCurrent && isXAxis ? oneTouchData.currentPageX : ofCurrent && !isXAxis ? oneTouchData.currentPageY : !ofCurrent && isXAxis ? oneTouchData.previousPageX : oneTouchData.previousPageY;
+ count = 1;
+ }
+ } else {
+ for (var i = 0; i < touchBank.length; i++) {
+ var touchTrack = touchBank[i];
+
+ if (touchTrack !== null && touchTrack !== undefined && touchTrack.touchActive && touchTrack.currentTimeStamp >= touchesChangedAfter) {
+ var toAdd = void 0;
+
+ if (ofCurrent && isXAxis) {
+ toAdd = touchTrack.currentPageX;
+ } else if (ofCurrent && !isXAxis) {
+ toAdd = touchTrack.currentPageY;
+ } else if (!ofCurrent && isXAxis) {
+ toAdd = touchTrack.previousPageX;
+ } else {
+ toAdd = touchTrack.previousPageY;
+ }
+
+ total += toAdd;
+ count++;
+ }
+ }
+ }
+
+ return count > 0 ? total / count : TouchHistoryMath.noCentroid;
+ },
+ currentCentroidXOfTouchesChangedAfter: function currentCentroidXOfTouchesChangedAfter(touchHistory, touchesChangedAfter) {
+ return TouchHistoryMath.centroidDimension(touchHistory, touchesChangedAfter, true, true);
+ },
+ currentCentroidYOfTouchesChangedAfter: function currentCentroidYOfTouchesChangedAfter(touchHistory, touchesChangedAfter) {
+ return TouchHistoryMath.centroidDimension(touchHistory, touchesChangedAfter, false, true);
+ },
+ previousCentroidXOfTouchesChangedAfter: function previousCentroidXOfTouchesChangedAfter(touchHistory, touchesChangedAfter) {
+ return TouchHistoryMath.centroidDimension(touchHistory, touchesChangedAfter, true, false);
+ },
+ previousCentroidYOfTouchesChangedAfter: function previousCentroidYOfTouchesChangedAfter(touchHistory, touchesChangedAfter) {
+ return TouchHistoryMath.centroidDimension(touchHistory, touchesChangedAfter, false, false);
+ },
+ currentCentroidX: function currentCentroidX(touchHistory) {
+ return TouchHistoryMath.centroidDimension(touchHistory, 0, true, true);
+ },
+ currentCentroidY: function currentCentroidY(touchHistory) {
+ return TouchHistoryMath.centroidDimension(touchHistory, 0, false, true);
+ },
+ noCentroid: -1
+ };
+ module.exports = TouchHistoryMath;
+},364,[],"node_modules\\react-native\\Libraries\\Interaction\\TouchHistoryMath.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/createClass");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Experimental\\SwipeableRow\\SwipeableListView.js";
+
+ var ListView = _$$_REQUIRE(_dependencyMap[6], "ListView");
+
+ var React = _$$_REQUIRE(_dependencyMap[7], "React");
+
+ var SwipeableListViewDataSource = _$$_REQUIRE(_dependencyMap[8], "SwipeableListViewDataSource");
+
+ var SwipeableRow = _$$_REQUIRE(_dependencyMap[9], "SwipeableRow");
+
+ var SwipeableListView = function (_React$Component) {
+ _inherits(SwipeableListView, _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: 216
+ }
+ }, _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: 124
+ }
+ }));
+ }
+ }, {
+ 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)
+ });
+ }
+ }]);
+
+ return SwipeableListView;
+ }(React.Component);
+
+ SwipeableListView.defaultProps = {
+ bounceFirstRowOnMount: false,
+ renderQuickActions: function renderQuickActions() {
+ return null;
+ }
+ };
+ module.exports = SwipeableListView;
+},365,[14,3,5,8,4,9,306,52,366,362],"node_modules\\react-native\\Libraries\\Experimental\\SwipeableRow\\SwipeableListView.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var ListViewDataSource = _$$_REQUIRE(_dependencyMap[2], "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;
+},366,[3,4,308],"node_modules\\react-native\\Libraries\\Experimental\\SwipeableRow\\SwipeableListViewDataSource.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\Libraries\\Components\\TextInput\\TextInput.uwp.js";
+
+ var EventEmitter = _$$_REQUIRE(_dependencyMap[1], "EventEmitter");
+
+ var NativeMethodsMixin = _$$_REQUIRE(_dependencyMap[2], "NativeMethodsMixin");
+
+ var React = _$$_REQUIRE(_dependencyMap[3], "React");
+
+ var createReactClass = _$$_REQUIRE(_dependencyMap[4], "create-react-class");
+
+ var PropTypes = _$$_REQUIRE(_dependencyMap[5], "prop-types");
+
+ var ReactNative = _$$_REQUIRE(_dependencyMap[6], "ReactNative");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[7], "StyleSheet");
+
+ var TextAncestor = _$$_REQUIRE(_dependencyMap[8], "TextAncestor");
+
+ var TextInputState = _$$_REQUIRE(_dependencyMap[9], "TextInputState");
+
+ var TimerMixin = _$$_REQUIRE(_dependencyMap[10], "react-timer-mixin");
+
+ var requireNativeComponent = _$$_REQUIRE(_dependencyMap[11], "requireNativeComponent");
+
+ var RCTTextInput = requireNativeComponent('RCTTextInput');
+ var TextInput = createReactClass({
+ displayName: 'TextInput',
+ statics: {
+ State: {
+ currentlyFocusedField: TextInputState.currentlyFocusedField,
+ focusTextInput: TextInputState.focusTextInput,
+ blurTextInput: TextInputState.blurTextInput
+ }
+ },
+ getDefaultProps: function getDefaultProps() {
+ return {
+ allowFontScaling: true
+ };
+ },
+ mixins: [NativeMethodsMixin, TimerMixin],
+ isFocused: function isFocused() {
+ return TextInputState.currentlyFocusedField() === ReactNative.findNodeHandle(this._inputRef);
+ },
+ getTextViewHandle: function getTextViewHandle() {
+ return ReactNative.findNodeHandle(this._inputRef);
+ },
+ _inputRef: undefined,
+ _focusSubscription: undefined,
+ _lastNativeText: undefined,
+ _lastNativeSelection: undefined,
+ _rafId: null,
+ 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._rafId = requestAnimationFrame(_this.focus);
+ } else if (_this.isFocused()) {
+ _this.blur();
+ }
+ });
+
+ if (this.props.autoFocus) {
+ this.context.onFocusRequested(this);
+ }
+ } else {
+ if (this.props.autoFocus) {
+ this._rafId = requestAnimationFrame(this.focus);
+ }
+ }
+ },
+ componentWillUnmount: function componentWillUnmount() {
+ this._focusSubscription && this._focusSubscription.remove();
+
+ if (this.isFocused()) {
+ this.blur();
+ }
+
+ if (this._rafId != null) {
+ cancelAnimationFrame(this._rafId);
+ }
+ },
+ contextTypes: {
+ onFocusRequested: PropTypes.func,
+ focusEmitter: PropTypes.instanceOf(EventEmitter)
+ },
+ clear: function clear() {
+ this.setNativeProps({
+ text: ''
+ });
+ },
+ render: function render() {
+ var props = _extends({}, this.props);
+
+ props.style = [styles.input, this.props.style];
+ return React.createElement(TextAncestor.Provider, {
+ value: true,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 310
+ }
+ }, React.createElement(RCTTextInput, _extends({
+ ref: this._setNativeRef
+ }, props, {
+ mostRecentEventCount: 0,
+ onChange: this._onChange,
+ onBlur: this._onBlur,
+ onFocus: this._onFocus,
+ onSelectionChange: this._onSelectionChange,
+ text: this._getText(),
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 311
+ }
+ })));
+ },
+ _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;
+ },
+ _onFocus: function _onFocus(event) {
+ TextInputState.setFocusedTextInput(ReactNative.findNodeHandle(this._inputRef));
+
+ if (this.props.onFocus) {
+ this.props.onFocus(event);
+ }
+ },
+ _onPress: function _onPress(event) {
+ if (this.props.editable || this.props.editable === undefined) {
+ this.focus();
+ }
+ },
+ _onChange: function _onChange(event) {
+ if (this._inputRef && this._inputRef.setNativeProps) {
+ 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.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) {
+ this._inputRef.setNativeProps(nativeProps);
+ }
+ },
+ _onBlur: function _onBlur(event) {
+ TextInputState.clearFocusedTextInput(ReactNative.findNodeHandle(this._inputRef));
+
+ if (this.props.onBlur) {
+ this.props.onBlur(event);
+ }
+ },
+ _onTextInput: function _onTextInput(event) {
+ this.props.onTextInput && this.props.onTextInput(event);
+ },
+ _onScroll: function _onScroll(event) {
+ this.props.onScroll && this.props.onScroll(event);
+ }
+ });
+ var styles = StyleSheet.create({
+ multilineInput: {
+ paddingTop: 5
+ }
+ });
+ module.exports = TextInput;
+},367,[14,27,225,52,227,62,84,53,82,176,368,184],"Libraries\\Components\\TextInput\\TextInput.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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;
+},368,[],"node_modules\\react-timer-mixin\\TimerMixin.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "UnimplementedView");
+},369,[196],"Libraries\\Components\\ToolbarAndroid\\ToolbarAndroid.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "UnimplementedView");
+},370,[196],"Libraries\\Components\\ViewPager\\ViewPagerAndroid.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\Libraries\\Components\\WebView\\WebView.uwp.js";
+
+ var React = _$$_REQUIRE(_dependencyMap[0], "React");
+
+ var ReactNative = _$$_REQUIRE(_dependencyMap[1], "ReactNative");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[2], "StyleSheet");
+
+ var UIManager = _$$_REQUIRE(_dependencyMap[3], "UIManager");
+
+ var View = _$$_REQUIRE(_dependencyMap[4], "View");
+
+ var keyMirror = _$$_REQUIRE(_dependencyMap[5], "fbjs/lib/keyMirror");
+
+ var requireNativeComponent = _$$_REQUIRE(_dependencyMap[6], "requireNativeComponent");
+
+ var resolveAssetSource = _$$_REQUIRE(_dependencyMap[7], "resolveAssetSource");
+
+ var createReactClass = _$$_REQUIRE(_dependencyMap[8], "create-react-class");
+
+ var RCT_WEBVIEW_REF = 'webview';
+ var WebViewState = keyMirror({
+ IDLE: null,
+ LOADING: null,
+ ERROR: null
+ });
+ var WebView = createReactClass({
+ displayName: "WebView",
+ getInitialState: function getInitialState() {
+ return {
+ viewState: WebViewState.IDLE,
+ lastErrorEvent: null,
+ startInLoadingState: true
+ };
+ },
+ getDefaultProps: function getDefaultProps() {
+ return {
+ javaScriptEnabled: true
+ };
+ },
+ componentWillMount: function componentWillMount() {
+ if (this.props.startInLoadingState) {
+ this.setState({
+ viewState: WebViewState.LOADING
+ });
+ }
+ },
+ render: function render() {
+ var otherView = null;
+
+ if (this.state.viewState === WebViewState.LOADING) {
+ otherView = this.props.renderLoading && this.props.renderLoading();
+ } else if (this.state.viewState === WebViewState.ERROR) {
+ var errorEvent = this.state.lastErrorEvent;
+ otherView = this.props.renderError && this.props.renderError(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, this.props.style];
+
+ if (this.state.viewState === WebViewState.LOADING || this.state.viewState === WebViewState.ERROR) {
+ webViewStyles.push(styles.hidden);
+ }
+
+ 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 webView = React.createElement(RCTWebView, {
+ ref: RCT_WEBVIEW_REF,
+ key: "webViewKey",
+ style: webViewStyles,
+ source: resolveAssetSource(source),
+ injectedJavaScript: this.props.injectedJavaScript,
+ javaScriptEnabled: this.props.javaScriptEnabled,
+ indexedDbEnabled: this.props.indexedDbEnabled,
+ contentInset: this.props.contentInset,
+ automaticallyAdjustContentInsets: this.props.automaticallyAdjustContentInsets,
+ onLoadingStart: this.onLoadingStart,
+ onLoadingFinish: this.onLoadingFinish,
+ onLoadingError: this.onLoadingError,
+ testID: this.props.testID,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 98
+ }
+ });
+ return React.createElement(View, {
+ style: styles.container,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 118
+ }
+ }, webView, otherView);
+ },
+ goForward: function goForward() {
+ UIManager.dispatchViewManagerCommand(this.getWebViewHandle(), UIManager.RCTWebView.Commands.goForward, null);
+ },
+ goBack: function goBack() {
+ UIManager.dispatchViewManagerCommand(this.getWebViewHandle(), UIManager.RCTWebView.Commands.goBack, null);
+ },
+ reload: function reload() {
+ UIManager.dispatchViewManagerCommand(this.getWebViewHandle(), UIManager.RCTWebView.Commands.reload, null);
+ },
+ updateNavigationState: function updateNavigationState(event) {
+ if (this.props.onNavigationStateChange) {
+ this.props.onNavigationStateChange(event.nativeEvent);
+ }
+ },
+ getWebViewHandle: function getWebViewHandle() {
+ return ReactNative.findNodeHandle(this.refs[RCT_WEBVIEW_REF]);
+ },
+ onLoadingStart: function onLoadingStart(event) {
+ var onLoadStart = this.props.onLoadStart;
+ onLoadStart && onLoadStart(event);
+ this.updateNavigationState(event);
+ },
+ onLoadingError: function onLoadingError(event) {
+ event.persist();
+ var _this$props = this.props,
+ onError = _this$props.onError,
+ onLoadEnd = _this$props.onLoadEnd;
+ onError && onError(event);
+ onLoadEnd && onLoadEnd(event);
+ console.error('Encountered an error loading page', event.nativeEvent);
+ this.setState({
+ lastErrorEvent: event.nativeEvent,
+ viewState: WebViewState.ERROR
+ });
+ },
+ onLoadingFinish: function onLoadingFinish(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);
+ }
+ });
+ var RCTWebView = requireNativeComponent('RCTWebView', WebView);
+ var styles = StyleSheet.create({
+ container: {
+ flex: 1
+ },
+ hidden: {
+ height: 0,
+ flex: 0
+ },
+ loadingView: {
+ flex: 1,
+ justifyContent: 'center',
+ alignItems: 'center'
+ },
+ loadingProgressBar: {
+ height: 20
+ }
+ });
+ module.exports = WebView;
+},371,[52,84,53,71,81,218,184,190,227],"Libraries\\Components\\WebView\\WebView.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var RCTActionSheetManager = _$$_REQUIRE(_dependencyMap[1], "NativeModules").ActionSheetManager;
+
+ var invariant = _$$_REQUIRE(_dependencyMap[2], "invariant");
+
+ var processColor = _$$_REQUIRE(_dependencyMap[3], "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;
+},372,[32,36,19,75],"node_modules\\react-native\\Libraries\\ActionSheetIOS\\ActionSheetIOS.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var BatchedBridge = _$$_REQUIRE(_dependencyMap[1], "BatchedBridge");
+
+ var BugReporting = _$$_REQUIRE(_dependencyMap[2], "BugReporting");
+
+ var NativeModules = _$$_REQUIRE(_dependencyMap[3], "NativeModules");
+
+ var ReactNative = _$$_REQUIRE(_dependencyMap[4], "ReactNative");
+
+ var SceneTracker = _$$_REQUIRE(_dependencyMap[5], "SceneTracker");
+
+ var infoLog = _$$_REQUIRE(_dependencyMap[6], "infoLog");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[7], "invariant");
+
+ var renderApplication = _$$_REQUIRE(_dependencyMap[8], "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;
+},373,[32,41,374,36,84,376,157,19,377],"node_modules\\react-native\\Libraries\\ReactNative\\AppRegistry.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _slicedToArray = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/slicedToArray");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ var RCTDeviceEventEmitter = _$$_REQUIRE(_dependencyMap[3], "RCTDeviceEventEmitter");
+
+ var infoLog = _$$_REQUIRE(_dependencyMap[4], "infoLog");
+
+ function defaultExtras() {
+ BugReporting.addFileSource('react_hierarchy.txt', function () {
+ return _$$_REQUIRE(_dependencyMap[5], "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), _i = 0, _iterator = _isArray ? _iterator : _iterator[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();;) {
+ var _ref3;
+
+ if (_isArray) {
+ if (_i >= _iterator.length) break;
+ _ref3 = _iterator[_i++];
+ } else {
+ _i = _iterator.next();
+ if (_i.done) break;
+ _ref3 = _i.value;
+ }
+
+ var _ref7 = _ref3;
+
+ var _ref2 = _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), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();;) {
+ var _ref6;
+
+ if (_isArray2) {
+ if (_i2 >= _iterator2.length) break;
+ _ref6 = _iterator2[_i2++];
+ } else {
+ _i2 = _iterator2.next();
+ if (_i2.done) break;
+ _ref6 = _i2.value;
+ }
+
+ var _ref8 = _ref6;
+
+ var _ref5 = _slicedToArray(_ref8, 2);
+
+ var _key4 = _ref5[0];
+ var _callback3 = _ref5[1];
+ fileData[_key4] = _callback3();
+ }
+
+ infoLog('BugReporting extraData:', extraData);
+
+ var BugReportingNativeModule = _$$_REQUIRE(_dependencyMap[6], "NativeModules").BugReporting;
+
+ BugReportingNativeModule && BugReportingNativeModule.setExtraData && BugReportingNativeModule.setExtraData(extraData, fileData);
+
+ var RedBoxNativeModule = _$$_REQUIRE(_dependencyMap[6], "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;
+},374,[37,3,4,24,157,375,36],"node_modules\\react-native\\Libraries\\BugReporting\\BugReporting.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ function dumpReactTree() {
+ try {
+ return getReactTree();
+ } catch (e) {
+ return 'Failed to dump react tree: ' + e;
+ }
+ }
+
+ function getReactTree() {
+ return 'React tree dumps have been temporarily disabled while React is ' + 'upgraded to Fiber.';
+ }
+
+ module.exports = dumpReactTree;
+},375,[],"node_modules\\react-native\\Libraries\\BugReporting\\dumpReactTree.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _listeners = [];
+ var _activeScene = {
+ name: 'default'
+ };
+ var SceneTracker = {
+ setActiveScene: function setActiveScene(scene) {
+ _activeScene = scene;
+
+ _listeners.forEach(function (listener) {
+ return listener(_activeScene);
+ });
+ },
+ getActiveScene: function getActiveScene() {
+ return _activeScene;
+ },
+ addActiveSceneChangedListener: function addActiveSceneChangedListener(callback) {
+ _listeners.push(callback);
+
+ return {
+ remove: function remove() {
+ _listeners = _listeners.filter(function (listener) {
+ return callback !== listener;
+ });
+ }
+ };
+ }
+ };
+ module.exports = SceneTracker;
+},376,[],"node_modules\\react-native\\Libraries\\Utilities\\SceneTracker.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+
+ var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/extends"));
+
+ var _PerformanceLogger = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "PerformanceLogger"));
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\ReactNative\\renderApplication.js";
+
+ var AppContainer = _$$_REQUIRE(_dependencyMap[3], "AppContainer");
+
+ var React = _$$_REQUIRE(_dependencyMap[4], "React");
+
+ var ReactFabricIndicator = _$$_REQUIRE(_dependencyMap[5], "ReactFabricIndicator");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[6], "invariant");
+
+ _$$_REQUIRE(_dependencyMap[7], "BackHandler");
+
+ function renderApplication(RootComponent, initialProps, rootTag, WrapperComponent, fabric, showFabricIndicator) {
+ invariant(rootTag, 'Expect to have a valid rootTag, instead got ', rootTag);
+ var renderable = React.createElement(AppContainer, {
+ rootTag: rootTag,
+ WrapperComponent: WrapperComponent,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 34
+ }
+ }, React.createElement(RootComponent, (0, _extends2.default)({}, initialProps, {
+ rootTag: rootTag,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 35
+ }
+ })), fabric === true && showFabricIndicator === true ? React.createElement(ReactFabricIndicator, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 37
+ }
+ }) : null);
+
+ if (RootComponent.prototype != null && RootComponent.prototype.unstable_isAsyncReactComponent === true) {
+ var ConcurrentMode = React.unstable_ConcurrentMode;
+ renderable = React.createElement(ConcurrentMode, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 54
+ }
+ }, renderable);
+ }
+
+ _PerformanceLogger.default.startTimespan('renderApplication_React_render');
+
+ if (fabric) {
+ _$$_REQUIRE(_dependencyMap[8], "ReactFabric").render(renderable, rootTag);
+ } else {
+ _$$_REQUIRE(_dependencyMap[9], "ReactNative").render(renderable, rootTag);
+ }
+
+ _PerformanceLogger.default.stopTimespan('renderApplication_React_render');
+ }
+
+ module.exports = renderApplication;
+},377,[1,14,156,314,52,378,19,379,380,84],"node_modules\\react-native\\Libraries\\ReactNative\\renderApplication.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\ReactNative\\ReactFabricIndicator.js";
+
+ var React = _$$_REQUIRE(_dependencyMap[0], "React");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[1], "StyleSheet");
+
+ var Text = _$$_REQUIRE(_dependencyMap[2], "Text");
+
+ var View = _$$_REQUIRE(_dependencyMap[3], "View");
+
+ function ReactFabricIndicator() {
+ return React.createElement(View, {
+ style: styles.container,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 20
+ }
+ }, React.createElement(Text, {
+ style: styles.text,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 21
+ }
+ }, "FABRIC"));
+ }
+
+ var styles = StyleSheet.create({
+ container: {
+ alignItems: 'center',
+ justifyContent: 'center',
+ backgroundColor: 'rgba(0,0,0, 0.25)',
+ position: 'absolute',
+ top: 0,
+ right: 0,
+ padding: 2
+ },
+ text: {
+ fontSize: 6,
+ color: '#ffffff'
+ }
+ });
+ module.exports = ReactFabricIndicator;
+},378,[52,53,208,81],"node_modules\\react-native\\Libraries\\ReactNative\\ReactFabricIndicator.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ function emptyFunction() {}
+
+ var BackHandler = {
+ exitApp: emptyFunction,
+ addEventListener: function addEventListener() {
+ return {
+ remove: emptyFunction
+ };
+ },
+ removeEventListener: emptyFunction
+ };
+ module.exports = BackHandler;
+},379,[],"Libraries\\Utilities\\BackHandler.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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;
+},380,[41,381,383],"node_modules\\react-native\\Libraries\\Renderer\\shims\\ReactFabric.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ if (__DEV__) {
+ (function () {
+ "use strict";
+
+ _$$_REQUIRE(_dependencyMap[1], "InitializeCore");
+
+ var ReactNativeViewConfigRegistry = _$$_REQUIRE(_dependencyMap[2], "ReactNativeViewConfigRegistry");
+
+ var UIManager = _$$_REQUIRE(_dependencyMap[3], "UIManager");
+
+ var React = _$$_REQUIRE(_dependencyMap[4], "react");
+
+ var deepDiffer = _$$_REQUIRE(_dependencyMap[5], "deepDiffer");
+
+ var flattenStyle = _$$_REQUIRE(_dependencyMap[6], "flattenStyle");
+
+ var deepFreezeAndThrowOnMutationInDev = _$$_REQUIRE(_dependencyMap[7], "deepFreezeAndThrowOnMutationInDev");
+
+ var TextInputState = _$$_REQUIRE(_dependencyMap[8], "TextInputState");
+
+ var FabricUIManager = _$$_REQUIRE(_dependencyMap[9], "FabricUIManager");
+
+ var checkPropTypes = _$$_REQUIRE(_dependencyMap[10], "prop-types/checkPropTypes");
+
+ var tracing = _$$_REQUIRE(_dependencyMap[11], "scheduler/tracing");
+
+ var scheduler = _$$_REQUIRE(_dependencyMap[12], "scheduler");
+
+ var ExceptionsManager = _$$_REQUIRE(_dependencyMap[13], "ExceptionsManager");
+
+ var validateFormat = function validateFormat() {};
+
+ {
+ 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 = void 0;
+
+ 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;
+ }
+ }
+
+ var invokeGuardedCallbackImpl = function invokeGuardedCallbackImpl(name, func, context, a, b, c, d, e, f) {
+ var funcArgs = Array.prototype.slice.call(arguments, 3);
+
+ try {
+ func.apply(context, funcArgs);
+ } catch (error) {
+ this.onError(error);
+ }
+ };
+
+ {
+ if (typeof window !== "undefined" && typeof window.dispatchEvent === "function" && typeof document !== "undefined" && typeof document.createEvent === "function") {
+ var fakeNode = document.createElement("react");
+
+ var invokeGuardedCallbackDev = function invokeGuardedCallbackDev(name, func, context, a, b, c, d, e, f) {
+ 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 windowEvent = window.event;
+ var windowEventDescriptor = Object.getOwnPropertyDescriptor(window, "event");
+ var funcArgs = Array.prototype.slice.call(arguments, 3);
+
+ function callCallback() {
+ fakeNode.removeEventListener(evtType, callCallback, false);
+
+ if (typeof window.event !== "undefined" && window.hasOwnProperty("event")) {
+ window.event = windowEvent;
+ }
+
+ func.apply(context, funcArgs);
+ didError = false;
+ }
+
+ var error = void 0;
+ var didSetError = false;
+ var isCrossOriginError = false;
+
+ function handleWindowError(event) {
+ error = event.error;
+ didSetError = true;
+
+ if (error === null && event.colno === 0 && event.lineno === 0) {
+ isCrossOriginError = true;
+ }
+
+ if (event.defaultPrevented) {
+ if (error != null && typeof error === "object") {
+ try {
+ error._suppressLogging = true;
+ } catch (inner) {}
+ }
+ }
+ }
+
+ var evtType = "react-" + (name ? name : "invokeguardedcallback");
+ window.addEventListener("error", handleWindowError);
+ fakeNode.addEventListener(evtType, callCallback, false);
+ evt.initEvent(evtType, false, false);
+ fakeNode.dispatchEvent(evt);
+
+ if (windowEventDescriptor) {
+ Object.defineProperty(window, "event", windowEventDescriptor);
+ }
+
+ if (didError) {
+ if (!didSetError) {
+ error = new Error("An error was thrown inside one of your components, but React " + "doesn't know what it was. This is likely due to browser " + 'flakiness. React does its best to preserve the "Pause on ' + 'exceptions" behavior of the DevTools, which requires some ' + "DEV-mode only tricks. It's possible that these don't work in " + "your browser. Try triggering the error in production mode, " + "or switching to a modern browser. If you suspect that this is " + "actually an issue with React, please file an issue.");
+ } else if (isCrossOriginError) {
+ error = new Error("A cross-origin error was thrown. React doesn't have access to " + "the actual error object in development. " + "See https://fb.me/react-crossorigin-error for more information.");
+ }
+
+ this.onError(error);
+ }
+
+ window.removeEventListener("error", handleWindowError);
+ };
+
+ invokeGuardedCallbackImpl = invokeGuardedCallbackDev;
+ }
+ }
+ var invokeGuardedCallbackImpl$1 = invokeGuardedCallbackImpl;
+ var hasError = false;
+ var caughtError = null;
+ var hasRethrowError = false;
+ var rethrowError = null;
+ var reporter = {
+ onError: function onError(error) {
+ hasError = true;
+ caughtError = error;
+ }
+ };
+
+ function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
+ hasError = false;
+ caughtError = null;
+ invokeGuardedCallbackImpl$1.apply(reporter, arguments);
+ }
+
+ function invokeGuardedCallbackAndCatchFirstError(name, func, context, a, b, c, d, e, f) {
+ invokeGuardedCallback.apply(this, arguments);
+
+ if (hasError) {
+ var error = clearCaughtError();
+
+ if (!hasRethrowError) {
+ hasRethrowError = true;
+ rethrowError = error;
+ }
+ }
+ }
+
+ function rethrowCaughtError() {
+ if (hasRethrowError) {
+ var error = rethrowError;
+ hasRethrowError = false;
+ rethrowError = null;
+ throw error;
+ }
+ }
+
+ function hasCaughtError() {
+ return hasError;
+ }
+
+ function clearCaughtError() {
+ if (hasError) {
+ var error = caughtError;
+ hasError = false;
+ caughtError = null;
+ return error;
+ } else {
+ 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 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 warningWithoutStack = function warningWithoutStack() {};
+
+ {
+ warningWithoutStack = function warningWithoutStack(condition, format) {
+ for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+ args[_key - 2] = arguments[_key];
+ }
+
+ if (format === undefined) {
+ throw new Error("`warningWithoutStack(condition, format, ...args)` requires a warning " + "message argument");
+ }
+
+ if (args.length > 8) {
+ throw new Error("warningWithoutStack() currently supports at most 8 arguments.");
+ }
+
+ if (condition) {
+ return;
+ }
+
+ if (typeof console !== "undefined") {
+ var argsWithFormat = args.map(function (item) {
+ return "" + item;
+ });
+ argsWithFormat.unshift("Warning: " + format);
+ Function.prototype.apply.call(console.error, console, argsWithFormat);
+ }
+
+ try {
+ var argIndex = 0;
+ var message = "Warning: " + format.replace(/%s/g, function () {
+ return args[argIndex++];
+ });
+ throw new Error(message);
+ } catch (x) {}
+ };
+ }
+ var warningWithoutStack$1 = warningWithoutStack;
+ var getFiberCurrentPropsFromNode = null;
+ var getInstanceFromNode = null;
+ var getNodeFromInstance = null;
+
+ function setComponentTree(getFiberCurrentPropsFromNodeImpl, getInstanceFromNodeImpl, getNodeFromInstanceImpl) {
+ getFiberCurrentPropsFromNode = getFiberCurrentPropsFromNodeImpl;
+ getInstanceFromNode = getInstanceFromNodeImpl;
+ getNodeFromInstance = getNodeFromInstanceImpl;
+ {
+ !(getNodeFromInstance && getInstanceFromNode) ? warningWithoutStack$1(false, "EventPluginUtils.setComponentTree(...): Injected " + "module is missing getNodeFromInstance or getInstanceFromNode.") : void 0;
+ }
+ }
+
+ var validateEventDispatches = void 0;
+ {
+ validateEventDispatches = function validateEventDispatches(event) {
+ var dispatchListeners = event._dispatchListeners;
+ var dispatchInstances = event._dispatchInstances;
+ var listenersIsArr = Array.isArray(dispatchListeners);
+ var listenersLen = listenersIsArr ? dispatchListeners.length : dispatchListeners ? 1 : 0;
+ var instancesIsArr = Array.isArray(dispatchInstances);
+ var instancesLen = instancesIsArr ? dispatchInstances.length : dispatchInstances ? 1 : 0;
+ !(instancesIsArr === listenersIsArr && instancesLen === listenersLen) ? warningWithoutStack$1(false, "EventPluginUtils: Invalid `event`.") : void 0;
+ };
+ }
+
+ function executeDispatch(event, listener, inst) {
+ var type = event.type || "unknown-event";
+ event.currentTarget = getNodeFromInstance(inst);
+ invokeGuardedCallbackAndCatchFirstError(type, listener, undefined, event);
+ event.currentTarget = null;
+ }
+
+ function executeDispatchesInOrder(event) {
+ var dispatchListeners = event._dispatchListeners;
+ var dispatchInstances = event._dispatchInstances;
+ {
+ validateEventDispatches(event);
+ }
+
+ if (Array.isArray(dispatchListeners)) {
+ for (var i = 0; i < dispatchListeners.length; i++) {
+ if (event.isPropagationStopped()) {
+ break;
+ }
+
+ executeDispatch(event, dispatchListeners[i], dispatchInstances[i]);
+ }
+ } else if (dispatchListeners) {
+ executeDispatch(event, dispatchListeners, dispatchInstances);
+ }
+
+ event._dispatchListeners = null;
+ event._dispatchInstances = null;
+ }
+
+ function executeDispatchesInOrderStopAtTrueImpl(event) {
+ var dispatchListeners = event._dispatchListeners;
+ var dispatchInstances = event._dispatchInstances;
+ {
+ validateEventDispatches(event);
+ }
+
+ if (Array.isArray(dispatchListeners)) {
+ for (var i = 0; i < dispatchListeners.length; i++) {
+ if (event.isPropagationStopped()) {
+ break;
+ }
+
+ if (dispatchListeners[i](event, dispatchInstances[i])) {
+ return dispatchInstances[i];
+ }
+ }
+ } else if (dispatchListeners) {
+ if (dispatchListeners(event, dispatchInstances)) {
+ return dispatchInstances;
+ }
+ }
+
+ return null;
+ }
+
+ function executeDispatchesInOrderStopAtTrue(event) {
+ var ret = executeDispatchesInOrderStopAtTrueImpl(event);
+ event._dispatchInstances = null;
+ event._dispatchListeners = null;
+ return ret;
+ }
+
+ function executeDirectDispatch(event) {
+ {
+ validateEventDispatches(event);
+ }
+ var dispatchListener = event._dispatchListeners;
+ var dispatchInstance = event._dispatchInstances;
+ 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) {
+ if (event) {
+ executeDispatchesInOrder(event);
+
+ if (!event.isPersistent()) {
+ event.constructor.release(event);
+ }
+ }
+ };
+
+ var executeDispatchesAndReleaseTopLevel = function executeDispatchesAndReleaseTopLevel(e) {
+ return executeDispatchesAndRelease(e);
+ };
+
+ 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) {
+ if (events !== null) {
+ eventQueue = accumulateInto(eventQueue, events);
+ }
+
+ var processingEventQueue = eventQueue;
+ eventQueue = null;
+
+ if (!processingEventQueue) {
+ return;
+ }
+
+ forEachAccumulated(processingEventQueue, executeDispatchesAndReleaseTopLevel);
+ invariant(!eventQueue, "processEventQueue(): Additional events were enqueued while processing " + "an event queue. Support for this has not yet been implemented.");
+ rethrowCaughtError();
+ }
+
+ function runExtractedEventsInBatch(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+ var events = extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget);
+ runEventsInBatch(events);
+ }
+
+ var FunctionComponent = 0;
+ var ClassComponent = 1;
+ var IndeterminateComponent = 2;
+ var HostRoot = 3;
+ var HostPortal = 4;
+ var HostComponent = 5;
+ var HostText = 6;
+ var Fragment = 7;
+ var Mode = 8;
+ var ContextConsumer = 9;
+ var ContextProvider = 10;
+ var ForwardRef = 11;
+ var Profiler = 12;
+ var SuspenseComponent = 13;
+ var MemoComponent = 14;
+ var SimpleMemoComponent = 15;
+ var LazyComponent = 16;
+ var IncompleteClassComponent = 17;
+ var DehydratedSuspenseComponent = 18;
+
+ function getParent(inst) {
+ do {
+ inst = inst.return;
+ } while (inst && inst.tag !== HostComponent);
+
+ if (inst) {
+ return inst;
+ }
+
+ return null;
+ }
+
+ function getLowestCommonAncestor(instA, instB) {
+ var depthA = 0;
+
+ for (var tempA = instA; tempA; tempA = getParent(tempA)) {
+ depthA++;
+ }
+
+ var depthB = 0;
+
+ for (var tempB = instB; tempB; tempB = getParent(tempB)) {
+ depthB++;
+ }
+
+ while (depthA - depthB > 0) {
+ instA = getParent(instA);
+ depthA--;
+ }
+
+ while (depthB - depthA > 0) {
+ instB = getParent(instB);
+ depthB--;
+ }
+
+ var depth = depthA;
+
+ while (depth--) {
+ if (instA === instB || instA === instB.alternate) {
+ return instA;
+ }
+
+ instA = getParent(instA);
+ instB = getParent(instB);
+ }
+
+ return null;
+ }
+
+ function isAncestor(instA, instB) {
+ while (instB) {
+ if (instA === instB || instA === instB.alternate) {
+ return true;
+ }
+
+ instB = getParent(instB);
+ }
+
+ return false;
+ }
+
+ function getParentInstance(inst) {
+ return getParent(inst);
+ }
+
+ function traverseTwoPhase(inst, fn, arg) {
+ var path = [];
+
+ while (inst) {
+ path.push(inst);
+ inst = getParent(inst);
+ }
+
+ var i = void 0;
+
+ for (i = path.length; i-- > 0;) {
+ fn(path[i], "captured", arg);
+ }
+
+ for (i = 0; i < path.length; i++) {
+ fn(path[i], "bubbled", arg);
+ }
+ }
+
+ function listenerAtPhase(inst, event, propagationPhase) {
+ var registrationName = event.dispatchConfig.phasedRegistrationNames[propagationPhase];
+ return getListener(inst, registrationName);
+ }
+
+ function accumulateDirectionalDispatches(inst, phase, event) {
+ {
+ !inst ? warningWithoutStack$1(false, "Dispatching inst must not be null") : void 0;
+ }
+ var listener = listenerAtPhase(inst, event, phase);
+
+ if (listener) {
+ event._dispatchListeners = accumulateInto(event._dispatchListeners, listener);
+ event._dispatchInstances = accumulateInto(event._dispatchInstances, inst);
+ }
+ }
+
+ function accumulateTwoPhaseDispatchesSingle(event) {
+ if (event && event.dispatchConfig.phasedRegistrationNames) {
+ traverseTwoPhase(event._targetInst, accumulateDirectionalDispatches, event);
+ }
+ }
+
+ function accumulateTwoPhaseDispatchesSingleSkipTarget(event) {
+ if (event && event.dispatchConfig.phasedRegistrationNames) {
+ var targetInst = event._targetInst;
+ var parentInst = targetInst ? getParentInstance(targetInst) : null;
+ traverseTwoPhase(parentInst, accumulateDirectionalDispatches, event);
+ }
+ }
+
+ function accumulateDispatches(inst, ignoredDirection, event) {
+ if (inst && event && event.dispatchConfig.registrationName) {
+ var registrationName = event.dispatchConfig.registrationName;
+ var listener = getListener(inst, registrationName);
+
+ if (listener) {
+ event._dispatchListeners = accumulateInto(event._dispatchListeners, listener);
+ event._dispatchInstances = accumulateInto(event._dispatchInstances, inst);
+ }
+ }
+ }
+
+ function accumulateDirectDispatchesSingle(event) {
+ if (event && event.dispatchConfig.registrationName) {
+ accumulateDispatches(event._targetInst, null, event);
+ }
+ }
+
+ function accumulateTwoPhaseDispatches(events) {
+ forEachAccumulated(events, accumulateTwoPhaseDispatchesSingle);
+ }
+
+ function accumulateTwoPhaseDispatchesSkipTarget(events) {
+ forEachAccumulated(events, accumulateTwoPhaseDispatchesSingleSkipTarget);
+ }
+
+ function accumulateDirectDispatches(events) {
+ forEachAccumulated(events, accumulateDirectDispatchesSingle);
+ }
+
+ var EVENT_POOL_SIZE = 10;
+ var EventInterface = {
+ type: null,
+ target: null,
+ currentTarget: function currentTarget() {
+ return null;
+ },
+ eventPhase: null,
+ bubbles: null,
+ cancelable: null,
+ timeStamp: function timeStamp(event) {
+ return event.timeStamp || Date.now();
+ },
+ defaultPrevented: null,
+ isTrusted: null
+ };
+
+ function functionThatReturnsTrue() {
+ return true;
+ }
+
+ function functionThatReturnsFalse() {
+ return false;
+ }
+
+ function SyntheticEvent(dispatchConfig, targetInst, nativeEvent, nativeEventTarget) {
+ {
+ delete this.nativeEvent;
+ delete this.preventDefault;
+ delete this.stopPropagation;
+ delete this.isDefaultPrevented;
+ delete this.isPropagationStopped;
+ }
+ this.dispatchConfig = dispatchConfig;
+ this._targetInst = targetInst;
+ this.nativeEvent = nativeEvent;
+ var Interface = this.constructor.Interface;
+
+ for (var propName in Interface) {
+ if (!Interface.hasOwnProperty(propName)) {
+ continue;
+ }
+
+ {
+ delete this[propName];
+ }
+ var normalize = Interface[propName];
+
+ if (normalize) {
+ this[propName] = normalize(nativeEvent);
+ } else {
+ if (propName === "target") {
+ this.target = nativeEventTarget;
+ } else {
+ this[propName] = nativeEvent[propName];
+ }
+ }
+ }
+
+ var defaultPrevented = nativeEvent.defaultPrevented != null ? nativeEvent.defaultPrevented : nativeEvent.returnValue === false;
+
+ if (defaultPrevented) {
+ this.isDefaultPrevented = functionThatReturnsTrue;
+ } else {
+ this.isDefaultPrevented = functionThatReturnsFalse;
+ }
+
+ this.isPropagationStopped = functionThatReturnsFalse;
+ return this;
+ }
+
+ _extends(SyntheticEvent.prototype, {
+ preventDefault: function preventDefault() {
+ this.defaultPrevented = true;
+ var event = this.nativeEvent;
+
+ if (!event) {
+ return;
+ }
+
+ if (event.preventDefault) {
+ event.preventDefault();
+ } else if (typeof event.returnValue !== "unknown") {
+ event.returnValue = false;
+ }
+
+ this.isDefaultPrevented = functionThatReturnsTrue;
+ },
+ stopPropagation: function stopPropagation() {
+ var event = this.nativeEvent;
+
+ if (!event) {
+ return;
+ }
+
+ if (event.stopPropagation) {
+ event.stopPropagation();
+ } else if (typeof event.cancelBubble !== "unknown") {
+ event.cancelBubble = true;
+ }
+
+ this.isPropagationStopped = functionThatReturnsTrue;
+ },
+ persist: function persist() {
+ this.isPersistent = functionThatReturnsTrue;
+ },
+ isPersistent: functionThatReturnsFalse,
+ destructor: function destructor() {
+ var Interface = this.constructor.Interface;
+
+ for (var propName in Interface) {
+ {
+ Object.defineProperty(this, propName, getPooledWarningPropertyDefinition(propName, Interface[propName]));
+ }
+ }
+
+ this.dispatchConfig = null;
+ this._targetInst = null;
+ this.nativeEvent = null;
+ this.isDefaultPrevented = functionThatReturnsFalse;
+ this.isPropagationStopped = functionThatReturnsFalse;
+ this._dispatchListeners = null;
+ this._dispatchInstances = null;
+ {
+ Object.defineProperty(this, "nativeEvent", getPooledWarningPropertyDefinition("nativeEvent", null));
+ Object.defineProperty(this, "isDefaultPrevented", getPooledWarningPropertyDefinition("isDefaultPrevented", functionThatReturnsFalse));
+ Object.defineProperty(this, "isPropagationStopped", getPooledWarningPropertyDefinition("isPropagationStopped", functionThatReturnsFalse));
+ Object.defineProperty(this, "preventDefault", getPooledWarningPropertyDefinition("preventDefault", function () {}));
+ Object.defineProperty(this, "stopPropagation", getPooledWarningPropertyDefinition("stopPropagation", function () {}));
+ }
+ }
+ });
+
+ SyntheticEvent.Interface = EventInterface;
+
+ SyntheticEvent.extend = function (Interface) {
+ var Super = this;
+
+ var E = function E() {};
+
+ E.prototype = Super.prototype;
+ var prototype = new E();
+
+ function Class() {
+ return Super.apply(this, arguments);
+ }
+
+ _extends(prototype, Class.prototype);
+
+ Class.prototype = prototype;
+ Class.prototype.constructor = Class;
+ Class.Interface = _extends({}, Super.Interface, Interface);
+ Class.extend = Super.extend;
+ addEventPoolingTo(Class);
+ return Class;
+ };
+
+ addEventPoolingTo(SyntheticEvent);
+
+ function getPooledWarningPropertyDefinition(propName, getVal) {
+ var isFunction = typeof getVal === "function";
+ return {
+ configurable: true,
+ set: set,
+ get: get$$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 ? warningWithoutStack$1(false, "This synthetic event is reused for performance reasons. If you're seeing this, " + "you're %s `%s` on a released/nullified synthetic event. %s. " + "If you must keep the original synthetic event around, use event.persist(). " + "See https://fb.me/react-event-pooling for more information.", action, propName, result) : void 0;
+ }
+ }
+
+ function getPooledEvent(dispatchConfig, targetInst, nativeEvent, nativeInst) {
+ var EventConstructor = this;
+
+ if (EventConstructor.eventPool.length) {
+ var instance = EventConstructor.eventPool.pop();
+ EventConstructor.call(instance, dispatchConfig, targetInst, nativeEvent, nativeInst);
+ return instance;
+ }
+
+ return new EventConstructor(dispatchConfig, targetInst, nativeEvent, nativeInst);
+ }
+
+ function releasePooledEvent(event) {
+ var EventConstructor = this;
+ 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 ResponderSyntheticEvent = SyntheticEvent.extend({
+ touchHistory: function touchHistory(nativeEvent) {
+ return null;
+ }
+ });
+ var TOP_TOUCH_START = "topTouchStart";
+ var TOP_TOUCH_MOVE = "topTouchMove";
+ var TOP_TOUCH_END = "topTouchEnd";
+ var TOP_TOUCH_CANCEL = "topTouchCancel";
+ var TOP_SCROLL = "topScroll";
+ var TOP_SELECTION_CHANGE = "topSelectionChange";
+
+ function isStartish(topLevelType) {
+ return topLevelType === TOP_TOUCH_START;
+ }
+
+ function isMoveish(topLevelType) {
+ return topLevelType === TOP_TOUCH_MOVE;
+ }
+
+ function isEndish(topLevelType) {
+ return topLevelType === TOP_TOUCH_END || topLevelType === TOP_TOUCH_CANCEL;
+ }
+
+ var startDependencies = [TOP_TOUCH_START];
+ var moveDependencies = [TOP_TOUCH_MOVE];
+ var endDependencies = [TOP_TOUCH_CANCEL, TOP_TOUCH_END];
+ var MAX_TOUCH_BANK = 20;
+ var touchBank = [];
+ var touchHistory = {
+ touchBank: touchBank,
+ numberActiveTouches: 0,
+ indexOfSingleActiveTouch: -1,
+ mostRecentTimeStamp: 0
+ };
+
+ function timestampForTouch(touch) {
+ return touch.timeStamp || touch.timestamp;
+ }
+
+ function createTouchRecord(touch) {
+ return {
+ touchActive: true,
+ startPageX: touch.pageX,
+ startPageY: touch.pageY,
+ startTimeStamp: timestampForTouch(touch),
+ currentPageX: touch.pageX,
+ currentPageY: touch.pageY,
+ currentTimeStamp: timestampForTouch(touch),
+ previousPageX: touch.pageX,
+ previousPageY: touch.pageY,
+ previousTimeStamp: timestampForTouch(touch)
+ };
+ }
+
+ function resetTouchRecord(touchRecord, touch) {
+ touchRecord.touchActive = true;
+ touchRecord.startPageX = touch.pageX;
+ touchRecord.startPageY = touch.pageY;
+ touchRecord.startTimeStamp = timestampForTouch(touch);
+ touchRecord.currentPageX = touch.pageX;
+ touchRecord.currentPageY = touch.pageY;
+ touchRecord.currentTimeStamp = timestampForTouch(touch);
+ touchRecord.previousPageX = touch.pageX;
+ touchRecord.previousPageY = touch.pageY;
+ touchRecord.previousTimeStamp = timestampForTouch(touch);
+ }
+
+ function getTouchIdentifier(_ref) {
+ var identifier = _ref.identifier;
+ invariant(identifier != null, "Touch object is missing identifier.");
+ {
+ !(identifier <= MAX_TOUCH_BANK) ? warningWithoutStack$1(false, "Touch identifier %s is greater than maximum supported %s which causes " + "performance issues backfilling array locations for all of the indices.", identifier, MAX_TOUCH_BANK) : void 0;
+ }
+ return identifier;
+ }
+
+ function recordTouchStart(touch) {
+ var identifier = getTouchIdentifier(touch);
+ var touchRecord = touchBank[identifier];
+
+ if (touchRecord) {
+ resetTouchRecord(touchRecord, touch);
+ } else {
+ touchBank[identifier] = createTouchRecord(touch);
+ }
+
+ touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
+ }
+
+ function recordTouchMove(touch) {
+ var touchRecord = touchBank[getTouchIdentifier(touch)];
+
+ if (touchRecord) {
+ touchRecord.touchActive = true;
+ touchRecord.previousPageX = touchRecord.currentPageX;
+ touchRecord.previousPageY = touchRecord.currentPageY;
+ touchRecord.previousTimeStamp = touchRecord.currentTimeStamp;
+ touchRecord.currentPageX = touch.pageX;
+ touchRecord.currentPageY = touch.pageY;
+ touchRecord.currentTimeStamp = timestampForTouch(touch);
+ touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
+ } else {
+ console.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) ? warningWithoutStack$1(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 ReactNativeBridgeEventPlugin = {
+ eventTypes: ReactNativeViewConfigRegistry.eventTypes,
+ extractEvents: function extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+ if (targetInst == null) {
+ return null;
+ }
+
+ var bubbleDispatchConfig = ReactNativeViewConfigRegistry.customBubblingEventTypes[topLevelType];
+ var directDispatchConfig = ReactNativeViewConfigRegistry.customDirectEventTypes[topLevelType];
+ invariant(bubbleDispatchConfig || directDispatchConfig, 'Unsupported top level event type "%s" dispatched', topLevelType);
+ var event = SyntheticEvent.getPooled(bubbleDispatchConfig || directDispatchConfig, targetInst, nativeEvent, nativeEventTarget);
+
+ if (bubbleDispatchConfig) {
+ accumulateTwoPhaseDispatches(event);
+ } else if (directDispatchConfig) {
+ accumulateDirectDispatches(event);
+ } else {
+ return null;
+ }
+
+ return event;
+ }
+ };
+ var ReactNativeEventPluginOrder = ["ResponderEventPlugin", "ReactNativeBridgeEventPlugin"];
+ injection.injectEventPluginOrder(ReactNativeEventPluginOrder);
+ injection.injectEventPluginsByName({
+ ResponderEventPlugin: ResponderEventPlugin,
+ ReactNativeBridgeEventPlugin: ReactNativeBridgeEventPlugin
+ });
+
+ function getInstanceFromInstance(instanceHandle) {
+ return instanceHandle;
+ }
+
+ function getTagFromInstance(inst) {
+ var tag = inst.stateNode.canonical._nativeTag;
+ invariant(tag, "All native instances should have a tag.");
+ return tag;
+ }
+
+ function getFiberCurrentPropsFromNode$1(inst) {
+ return inst.canonical.currentProps;
+ }
+
+ var ReactFabricGlobalResponderHandler = {
+ onChange: function onChange(from, to, blockNativeResponder) {
+ if (to !== null) {
+ var tag = to.stateNode.canonical._nativeTag;
+ UIManager.setJSResponder(tag, blockNativeResponder);
+ } else {
+ UIManager.clearJSResponder();
+ }
+ }
+ };
+ setComponentTree(getFiberCurrentPropsFromNode$1, getInstanceFromInstance, getTagFromInstance);
+ ResponderEventPlugin.injection.injectGlobalResponderHandler(ReactFabricGlobalResponderHandler);
+
+ function get$1(key) {
+ return key._reactInternalFiber;
+ }
+
+ function set(key, value) {
+ key._reactInternalFiber = value;
+ }
+
+ var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+ if (!ReactSharedInternals.hasOwnProperty("ReactCurrentDispatcher")) {
+ ReactSharedInternals.ReactCurrentDispatcher = {
+ current: null
+ };
+ }
+
+ var hasSymbol = typeof Symbol === "function" && (typeof Symbol === "function" ? Symbol.for : "@@for");
+ var REACT_ELEMENT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.element") : 0xeac7;
+ var REACT_PORTAL_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.portal") : 0xeaca;
+ var REACT_FRAGMENT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.fragment") : 0xeacb;
+ var REACT_STRICT_MODE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.strict_mode") : 0xeacc;
+ var REACT_PROFILER_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.profiler") : 0xead2;
+ var REACT_PROVIDER_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.provider") : 0xeacd;
+ var REACT_CONTEXT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.context") : 0xeace;
+ var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.concurrent_mode") : 0xeacf;
+ var REACT_FORWARD_REF_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.forward_ref") : 0xead0;
+ var REACT_SUSPENSE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.suspense") : 0xead1;
+ var REACT_MEMO_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.memo") : 0xead3;
+ var REACT_LAZY_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.lazy") : 0xead4;
+ var MAYBE_ITERATOR_SYMBOL = typeof Symbol === "function" && (typeof Symbol === "function" ? Symbol.iterator : "@@iterator");
+ var FAUX_ITERATOR_SYMBOL = "@@iterator";
+
+ function getIteratorFn(maybeIterable) {
+ if (maybeIterable === null || typeof maybeIterable !== "object") {
+ return null;
+ }
+
+ var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+ if (typeof maybeIterator === "function") {
+ return maybeIterator;
+ }
+
+ return null;
+ }
+
+ var Pending = 0;
+ var Resolved = 1;
+ var Rejected = 2;
+
+ function refineResolvedLazyComponent(lazyComponent) {
+ return lazyComponent._status === Resolved ? lazyComponent._result : null;
+ }
+
+ function getWrappedName(outerType, innerType, wrapperName) {
+ var functionName = innerType.displayName || innerType.name || "";
+ return outerType.displayName || (functionName !== "" ? wrapperName + "(" + functionName + ")" : wrapperName);
+ }
+
+ function getComponentName(type) {
+ if (type == null) {
+ return null;
+ }
+
+ {
+ if (typeof type.tag === "number") {
+ warningWithoutStack$1(false, "Received an unexpected object in getComponentName(). " + "This is likely a bug in React. Please file an issue.");
+ }
+ }
+
+ if (typeof type === "function") {
+ return type.displayName || type.name || null;
+ }
+
+ if (typeof type === "string") {
+ return type;
+ }
+
+ switch (type) {
+ case REACT_CONCURRENT_MODE_TYPE:
+ return "ConcurrentMode";
+
+ case REACT_FRAGMENT_TYPE:
+ return "Fragment";
+
+ case REACT_PORTAL_TYPE:
+ return "Portal";
+
+ case REACT_PROFILER_TYPE:
+ return "Profiler";
+
+ case REACT_STRICT_MODE_TYPE:
+ return "StrictMode";
+
+ case REACT_SUSPENSE_TYPE:
+ return "Suspense";
+ }
+
+ if (typeof type === "object") {
+ switch (type.$$typeof) {
+ case REACT_CONTEXT_TYPE:
+ return "Context.Consumer";
+
+ case REACT_PROVIDER_TYPE:
+ return "Context.Provider";
+
+ case REACT_FORWARD_REF_TYPE:
+ return getWrappedName(type, type.render, "ForwardRef");
+
+ case REACT_MEMO_TYPE:
+ return getComponentName(type.type);
+
+ case REACT_LAZY_TYPE:
+ {
+ var thenable = type;
+ var resolvedThenable = refineResolvedLazyComponent(thenable);
+
+ if (resolvedThenable) {
+ return getComponentName(resolvedThenable);
+ }
+ }
+ }
+ }
+
+ return null;
+ }
+
+ var NoEffect = 0;
+ var PerformedWork = 1;
+ var Placement = 2;
+ var Update = 4;
+ var PlacementAndUpdate = 6;
+ var Deletion = 8;
+ var ContentReset = 16;
+ var Callback = 32;
+ var DidCapture = 64;
+ var Ref = 128;
+ var Snapshot = 256;
+ var Passive = 512;
+ var LifecycleEffectMask = 932;
+ var HostEffectMask = 1023;
+ var Incomplete = 1024;
+ var ShouldCapture = 2048;
+ var ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner;
+ var MOUNTING = 1;
+ var MOUNTED = 2;
+ var UNMOUNTED = 3;
+
+ function isFiberMountedImpl(fiber) {
+ var node = fiber;
+
+ if (!fiber.alternate) {
+ if ((node.effectTag & Placement) !== NoEffect) {
+ return MOUNTING;
+ }
+
+ while (node.return) {
+ node = node.return;
+
+ if ((node.effectTag & Placement) !== NoEffect) {
+ return MOUNTING;
+ }
+ }
+ } else {
+ while (node.return) {
+ node = node.return;
+ }
+ }
+
+ if (node.tag === HostRoot) {
+ return MOUNTED;
+ }
+
+ return UNMOUNTED;
+ }
+
+ function isFiberMounted(fiber) {
+ return isFiberMountedImpl(fiber) === MOUNTED;
+ }
+
+ function isMounted(component) {
+ {
+ var owner = ReactCurrentOwner$1.current;
+
+ if (owner !== null && owner.tag === ClassComponent) {
+ var ownerFiber = owner;
+ var instance = ownerFiber.stateNode;
+ !instance._warnedAboutRefsInRender ? warningWithoutStack$1(false, "%s is accessing isMounted inside its render() function. " + "render() should be a pure function of props and state. It should " + "never access something that requires stale data from the previous " + "render, such as refs. Move this logic to componentDidMount and " + "componentDidUpdate instead.", getComponentName(ownerFiber.type) || "A component") : void 0;
+ instance._warnedAboutRefsInRender = true;
+ }
+ }
+ var fiber = get$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 mountSafeCallback_NOT_REALLY_SAFE(context, callback) {
+ return function () {
+ if (!callback) {
+ return undefined;
+ }
+
+ if (typeof context.__isMounted === "boolean") {
+ if (!context.__isMounted) {
+ return undefined;
+ }
+ }
+
+ return callback.apply(context, arguments);
+ };
+ }
+
+ function throwOnStylesProp(component, props) {
+ if (props.styles !== undefined) {
+ var owner = component._owner || null;
+ var name = component.constructor.displayName;
+ var msg = "`styles` is not a supported property of `" + name + "`, did " + "you mean `style` (singular)?";
+
+ if (owner && owner.constructor && owner.constructor.displayName) {
+ msg += "\n\nCheck the `" + owner.constructor.displayName + "` parent " + " component.";
+ }
+
+ throw new Error(msg);
+ }
+ }
+
+ function warnForStyleProps(props, validAttributes) {
+ for (var key in validAttributes.style) {
+ if (!(validAttributes[key] || props[key] === undefined)) {
+ console.error("You are setting the style `{ " + key + ": ... }` as a prop. You " + "should nest it in a style object. " + "E.g. `{ style: { " + key + ": ... } }`");
+ }
+ }
+ }
+
+ var emptyObject = {};
+ var removedKeys = null;
+ var removedKeyCount = 0;
+
+ function defaultDiffer(prevProp, nextProp) {
+ if (typeof nextProp !== "object" || nextProp === null) {
+ return true;
+ } else {
+ return 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, props, validAttributes);
+ }
+
+ function clearProperties(updatePayload, prevProps, validAttributes) {
+ return diffProperties(updatePayload, prevProps, emptyObject, validAttributes);
+ }
+
+ function create(props, validAttributes) {
+ return addProperties(null, props, validAttributes);
+ }
+
+ function diff(prevProps, nextProps, validAttributes) {
+ return diffProperties(null, prevProps, nextProps, validAttributes);
+ }
+
+ var 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;
+
+ function setTimeoutCallback() {
+ frameDeadline = now$1() + 5;
+ var callback = scheduledCallback;
+ scheduledCallback = null;
+
+ if (callback !== null) {
+ callback();
+ }
+ }
+
+ function scheduleDeferredCallback$1(callback, options) {
+ scheduledCallback = callback;
+ var timeoutId = setTimeout(setTimeoutCallback, 1);
+ return timeoutId;
+ }
+
+ function cancelDeferredCallback$1(callbackID) {
+ scheduledCallback = null;
+ clearTimeout(callbackID);
+ }
+
+ function shouldYield$1() {
+ return frameDeadline <= now$1();
+ }
+
+ var debugRenderPhaseSideEffects = false;
+ var debugRenderPhaseSideEffectsForStrictMode = false;
+ var enableUserTimingAPI = true;
+ var replayFailedUnitOfWorkWithInvokeGuardedCallback = true;
+ var warnAboutDeprecatedLifecycles = false;
+ var enableProfilerTimer = true;
+ var enableSchedulerTracing = true;
+ var enableSuspenseServerRenderer = false;
+ var warnAboutDeprecatedSetNativeProps = false;
+ var restoreImpl = null;
+ var restoreTarget = null;
+ var restoreQueue = null;
+
+ function restoreStateOfTarget(target) {
+ var internalInstance = getInstanceFromNode(target);
+
+ if (!internalInstance) {
+ return;
+ }
+
+ invariant(typeof restoreImpl === "function", "setRestoreImplementation() needs to be called to handle a target for controlled " + "events. This error is likely caused by a bug in React. Please file an issue.");
+ var props = getFiberCurrentPropsFromNode(internalInstance.stateNode);
+ restoreImpl(internalInstance.stateNode, internalInstance.type, props);
+ }
+
+ function needsStateRestore() {
+ return restoreTarget !== null || restoreQueue !== null;
+ }
+
+ function restoreStateIfNeeded() {
+ if (!restoreTarget) {
+ return;
+ }
+
+ var target = restoreTarget;
+ var queuedTargets = restoreQueue;
+ restoreTarget = null;
+ restoreQueue = null;
+ restoreStateOfTarget(target);
+
+ if (queuedTargets) {
+ for (var i = 0; i < queuedTargets.length; i++) {
+ restoreStateOfTarget(queuedTargets[i]);
+ }
+ }
+ }
+
+ var _batchedUpdatesImpl = function _batchedUpdatesImpl(fn, bookkeeping) {
+ return fn(bookkeeping);
+ };
+
+ var _flushInteractiveUpdatesImpl = function _flushInteractiveUpdatesImpl() {};
+
+ var isBatching = false;
+
+ function batchedUpdates(fn, bookkeeping) {
+ if (isBatching) {
+ return fn(bookkeeping);
+ }
+
+ isBatching = true;
+
+ try {
+ return _batchedUpdatesImpl(fn, bookkeeping);
+ } finally {
+ isBatching = false;
+ var controlledComponentsHavePendingUpdates = needsStateRestore();
+
+ if (controlledComponentsHavePendingUpdates) {
+ _flushInteractiveUpdatesImpl();
+
+ restoreStateIfNeeded();
+ }
+ }
+ }
+
+ function setBatchingImplementation(batchedUpdatesImpl, interactiveUpdatesImpl, flushInteractiveUpdatesImpl) {
+ _batchedUpdatesImpl = batchedUpdatesImpl;
+ _flushInteractiveUpdatesImpl = flushInteractiveUpdatesImpl;
+ }
+
+ 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;
+ var hideInstance = shim;
+ var hideTextInstance = shim;
+ var unhideInstance = shim;
+ var unhideTextInstance = shim;
+
+ function shim$1() {
+ invariant(false, "The current renderer does not support hydration. " + "This error is likely caused by a bug in React. " + "Please file an issue.");
+ }
+
+ var supportsHydration = false;
+ var canHydrateInstance = shim$1;
+ var canHydrateTextInstance = shim$1;
+ var canHydrateSuspenseInstance = shim$1;
+ var isSuspenseInstancePending = shim$1;
+ var isSuspenseInstanceFallback = shim$1;
+ var registerSuspenseInstanceRetry = shim$1;
+ var getNextHydratableSibling = shim$1;
+ var getFirstHydratableChild = shim$1;
+ var hydrateInstance = shim$1;
+ var hydrateTextInstance = shim$1;
+ var getNextHydratableInstanceAfterSuspenseInstance = shim$1;
+ var clearSuspenseBoundary = shim$1;
+ var clearSuspenseBoundaryFromContainer = shim$1;
+ var didNotMatchHydratedContainerTextInstance = shim$1;
+ var didNotMatchHydratedTextInstance = shim$1;
+ var didNotHydrateContainerInstance = shim$1;
+ var didNotHydrateInstance = shim$1;
+ var didNotFindHydratableContainerInstance = shim$1;
+ var didNotFindHydratableContainerTextInstance = shim$1;
+ var didNotFindHydratableContainerSuspenseInstance = shim$1;
+ var didNotFindHydratableInstance = shim$1;
+ var didNotFindHydratableTextInstance = shim$1;
+ var didNotFindHydratableSuspenseInstance = shim$1;
+
+ function _classCallCheck(instance, Constructor) {
+ if (!(instance instanceof Constructor)) {
+ throw new TypeError("Cannot call a class as a function");
+ }
+ }
+
+ var 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_NOT_REALLY_SAFE(this, callback));
+ };
+
+ ReactFabricHostComponent.prototype.measureInWindow = function measureInWindow(callback) {
+ UIManager.measureInWindow(this._nativeTag, mountSafeCallback_NOT_REALLY_SAFE(this, callback));
+ };
+
+ ReactFabricHostComponent.prototype.measureLayout = function measureLayout(relativeToNativeNode, onSuccess, onFail) {
+ UIManager.measureLayout(this._nativeTag, relativeToNativeNode, mountSafeCallback_NOT_REALLY_SAFE(this, onFail), mountSafeCallback_NOT_REALLY_SAFE(this, onSuccess));
+ };
+
+ ReactFabricHostComponent.prototype.setNativeProps = function setNativeProps(nativeProps) {
+ {
+ if (warnAboutDeprecatedSetNativeProps) {
+ warningWithoutStack$1(false, "Warning: Calling ref.setNativeProps(nativeProps) " + "is deprecated and will be removed in a future release. " + "Use the setNativeProps export from the react-native package instead." + "\n\timport {setNativeProps} from 'react-native';\n\tsetNativeProps(ref, nativeProps);\n");
+ }
+
+ warnForStyleProps(nativeProps, this.viewConfig.validAttributes);
+ }
+ var updatePayload = create(nativeProps, this.viewConfig.validAttributes);
+
+ if (updatePayload != null) {
+ 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 within 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 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$$1 = now$1;
+ var scheduleDeferredCallback$$1 = scheduleDeferredCallback$1;
+ var cancelDeferredCallback$$1 = cancelDeferredCallback$1;
+ var shouldYield$$1 = shouldYield$1;
+ var scheduleTimeout = setTimeout;
+ var cancelTimeout = clearTimeout;
+ var noTimeout = -1;
+ var schedulePassiveEffects = scheduleDeferredCallback$$1;
+ var cancelPassiveEffects = 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);
+ } else {
+ clone = FabricUIManager.cloneNode(node);
+ }
+ } else {
+ if (updatePayload !== null) {
+ clone = FabricUIManager.cloneNodeWithNewChildrenAndProps(node, updatePayload);
+ } else {
+ clone = FabricUIManager.cloneNodeWithNewChildren(node);
+ }
+ }
+
+ return {
+ node: clone,
+ canonical: instance.canonical
+ };
+ }
+
+ function cloneHiddenInstance(instance, type, props, internalInstanceHandle) {
+ var viewConfig = instance.canonical.viewConfig;
+ var node = instance.node;
+ var updatePayload = create({
+ style: {
+ display: "none"
+ }
+ }, viewConfig.validAttributes);
+ return {
+ node: FabricUIManager.cloneNodeWithNewProps(node, updatePayload),
+ canonical: instance.canonical
+ };
+ }
+
+ function cloneUnhiddenInstance(instance, type, props, internalInstanceHandle) {
+ var viewConfig = instance.canonical.viewConfig;
+ var node = instance.node;
+ var updatePayload = diff(_extends({}, props, {
+ style: [props.style, {
+ display: "none"
+ }]
+ }), props, viewConfig.validAttributes);
+ return {
+ node: FabricUIManager.cloneNodeWithNewProps(node, updatePayload),
+ canonical: instance.canonical
+ };
+ }
+
+ function createHiddenTextInstance(text, rootContainerInstance, hostContext, internalInstanceHandle) {
+ throw new Error("Not yet implemented.");
+ }
+
+ 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 BEFORE_SLASH_RE = /^(.*)[\\\/]/;
+
+ var describeComponentFrame = function describeComponentFrame(name, source, ownerName) {
+ var sourceInfo = "";
+
+ if (source) {
+ var path = source.fileName;
+ var fileName = path.replace(BEFORE_SLASH_RE, "");
+ {
+ if (/^index\./.test(fileName)) {
+ var match = path.match(BEFORE_SLASH_RE);
+
+ if (match) {
+ var pathBeforeSlash = match[1];
+
+ if (pathBeforeSlash) {
+ var folderName = pathBeforeSlash.replace(BEFORE_SLASH_RE, "");
+ fileName = folderName + "/" + fileName;
+ }
+ }
+ }
+ }
+ sourceInfo = " (at " + fileName + ":" + source.lineNumber + ")";
+ } else if (ownerName) {
+ sourceInfo = " (created by " + ownerName + ")";
+ }
+
+ return "\n in " + (name || "Unknown") + sourceInfo;
+ };
+
+ var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+
+ function describeFiber(fiber) {
+ switch (fiber.tag) {
+ case HostRoot:
+ case HostPortal:
+ case HostText:
+ case Fragment:
+ case ContextProvider:
+ case ContextConsumer:
+ return "";
+
+ default:
+ var owner = fiber._debugOwner;
+ var source = fiber._debugSource;
+ var name = getComponentName(fiber.type);
+ var ownerName = null;
+
+ if (owner) {
+ ownerName = getComponentName(owner.type);
+ }
+
+ return describeComponentFrame(name, source, ownerName);
+ }
+ }
+
+ function getStackByFiberInDevAndProd(workInProgress) {
+ var info = "";
+ var node = workInProgress;
+
+ do {
+ info += describeFiber(node);
+ node = node.return;
+ } while (node);
+
+ return info;
+ }
+
+ var current = null;
+ var phase = null;
+
+ function getCurrentFiberOwnerNameInDevOrNull() {
+ {
+ if (current === null) {
+ return null;
+ }
+
+ var owner = current._debugOwner;
+
+ if (owner !== null && typeof owner !== "undefined") {
+ return getComponentName(owner.type);
+ }
+ }
+ return null;
+ }
+
+ function getCurrentFiberStackInDev() {
+ {
+ if (current === null) {
+ return "";
+ }
+
+ return getStackByFiberInDevAndProd(current);
+ }
+ return "";
+ }
+
+ function resetCurrentFiber() {
+ {
+ ReactDebugCurrentFrame.getCurrentStack = null;
+ current = null;
+ phase = null;
+ }
+ }
+
+ function setCurrentFiber(fiber) {
+ {
+ ReactDebugCurrentFrame.getCurrentStack = getCurrentFiberStackInDev;
+ current = fiber;
+ phase = null;
+ }
+ }
+
+ function setCurrentPhase(lifeCyclePhase) {
+ {
+ phase = lifeCyclePhase;
+ }
+ }
+
+ var reactEmoji = "\u269B";
+ var warningEmoji = "\u26D4";
+ var supportsUserTiming = typeof performance !== "undefined" && typeof performance.mark === "function" && typeof performance.clearMarks === "function" && typeof performance.measure === "function" && typeof performance.clearMeasures === "function";
+ var currentFiber = null;
+ var currentPhase = null;
+ var currentPhaseFiber = null;
+ var isCommitting = false;
+ var hasScheduledUpdateInCurrentCommit = false;
+ var hasScheduledUpdateInCurrentPhase = false;
+ var commitCountInCurrentWorkLoop = 0;
+ var effectCountInCurrentCommit = 0;
+ var isWaitingForCallback = false;
+ var labelsInCurrentCommit = new Set();
+
+ var formatMarkName = function formatMarkName(markName) {
+ return reactEmoji + " " + markName;
+ };
+
+ var formatLabel = function formatLabel(label, warning) {
+ var prefix = warning ? warningEmoji + " " : reactEmoji + " ";
+ var suffix = warning ? " Warning: " + warning : "";
+ return "" + prefix + label + suffix;
+ };
+
+ var beginMark = function beginMark(markName) {
+ performance.mark(formatMarkName(markName));
+ };
+
+ var clearMark = function clearMark(markName) {
+ performance.clearMarks(formatMarkName(markName));
+ };
+
+ var endMark = function endMark(label, markName, warning) {
+ var formattedMarkName = formatMarkName(markName);
+ var formattedLabel = formatLabel(label, warning);
+
+ try {
+ performance.measure(formattedLabel, formattedMarkName);
+ } catch (err) {}
+
+ performance.clearMarks(formattedMarkName);
+ performance.clearMeasures(formattedLabel);
+ };
+
+ var getFiberMarkName = function getFiberMarkName(label, debugID) {
+ return label + " (#" + debugID + ")";
+ };
+
+ var getFiberLabel = function getFiberLabel(componentName, isMounted, phase) {
+ if (phase === null) {
+ return componentName + " [" + (isMounted ? "update" : "mount") + "]";
+ } else {
+ return componentName + "." + phase;
+ }
+ };
+
+ var beginFiberMark = function beginFiberMark(fiber, phase) {
+ var componentName = getComponentName(fiber.type) || "Unknown";
+ var debugID = fiber._debugID;
+ var isMounted = fiber.alternate !== null;
+ var label = getFiberLabel(componentName, isMounted, phase);
+
+ if (isCommitting && labelsInCurrentCommit.has(label)) {
+ return false;
+ }
+
+ labelsInCurrentCommit.add(label);
+ var markName = getFiberMarkName(label, debugID);
+ beginMark(markName);
+ return true;
+ };
+
+ var clearFiberMark = function clearFiberMark(fiber, phase) {
+ var componentName = getComponentName(fiber.type) || "Unknown";
+ var debugID = fiber._debugID;
+ var isMounted = fiber.alternate !== null;
+ var label = getFiberLabel(componentName, isMounted, phase);
+ var markName = getFiberMarkName(label, debugID);
+ clearMark(markName);
+ };
+
+ var endFiberMark = function endFiberMark(fiber, phase, warning) {
+ var componentName = getComponentName(fiber.type) || "Unknown";
+ var debugID = fiber._debugID;
+ var isMounted = fiber.alternate !== null;
+ var label = getFiberLabel(componentName, isMounted, phase);
+ var markName = getFiberMarkName(label, debugID);
+ endMark(label, markName, warning);
+ };
+
+ var shouldIgnoreFiber = function shouldIgnoreFiber(fiber) {
+ switch (fiber.tag) {
+ case HostRoot:
+ case HostComponent:
+ case HostText:
+ case HostPortal:
+ case Fragment:
+ case ContextProvider:
+ case ContextConsumer:
+ case Mode:
+ return true;
+
+ default:
+ return false;
+ }
+ };
+
+ var clearPendingPhaseMeasurement = function clearPendingPhaseMeasurement() {
+ if (currentPhase !== null && currentPhaseFiber !== null) {
+ clearFiberMark(currentPhaseFiber, currentPhase);
+ }
+
+ currentPhaseFiber = null;
+ currentPhase = null;
+ hasScheduledUpdateInCurrentPhase = false;
+ };
+
+ var pauseTimers = function pauseTimers() {
+ var fiber = currentFiber;
+
+ while (fiber) {
+ if (fiber._debugIsCurrentlyTiming) {
+ endFiberMark(fiber, null, null);
+ }
+
+ fiber = fiber.return;
+ }
+ };
+
+ var resumeTimersRecursively = function resumeTimersRecursively(fiber) {
+ if (fiber.return !== null) {
+ resumeTimersRecursively(fiber.return);
+ }
+
+ if (fiber._debugIsCurrentlyTiming) {
+ beginFiberMark(fiber, null);
+ }
+ };
+
+ var resumeTimers = function resumeTimers() {
+ if (currentFiber !== null) {
+ resumeTimersRecursively(currentFiber);
+ }
+ };
+
+ function recordEffect() {
+ if (enableUserTimingAPI) {
+ effectCountInCurrentCommit++;
+ }
+ }
+
+ function recordScheduleUpdate() {
+ if (enableUserTimingAPI) {
+ if (isCommitting) {
+ hasScheduledUpdateInCurrentCommit = true;
+ }
+
+ if (currentPhase !== null && currentPhase !== "componentWillMount" && currentPhase !== "componentWillReceiveProps") {
+ hasScheduledUpdateInCurrentPhase = true;
+ }
+ }
+ }
+
+ function startRequestCallbackTimer() {
+ if (enableUserTimingAPI) {
+ if (supportsUserTiming && !isWaitingForCallback) {
+ isWaitingForCallback = true;
+ beginMark("(Waiting for async callback...)");
+ }
+ }
+ }
+
+ function stopRequestCallbackTimer(didExpire, expirationTime) {
+ if (enableUserTimingAPI) {
+ if (supportsUserTiming) {
+ isWaitingForCallback = false;
+ var warning = didExpire ? "React was blocked by main thread" : null;
+ endMark("(Waiting for async callback... will force flush in " + expirationTime + " ms)", "(Waiting for async callback...)", warning);
+ }
+ }
+ }
+
+ function startWorkTimer(fiber) {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming || shouldIgnoreFiber(fiber)) {
+ return;
+ }
+
+ currentFiber = fiber;
+
+ if (!beginFiberMark(fiber, null)) {
+ return;
+ }
+
+ fiber._debugIsCurrentlyTiming = true;
+ }
+ }
+
+ function cancelWorkTimer(fiber) {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming || shouldIgnoreFiber(fiber)) {
+ return;
+ }
+
+ fiber._debugIsCurrentlyTiming = false;
+ clearFiberMark(fiber, null);
+ }
+ }
+
+ function stopWorkTimer(fiber) {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming || shouldIgnoreFiber(fiber)) {
+ return;
+ }
+
+ currentFiber = fiber.return;
+
+ if (!fiber._debugIsCurrentlyTiming) {
+ return;
+ }
+
+ fiber._debugIsCurrentlyTiming = false;
+ endFiberMark(fiber, null, null);
+ }
+ }
+
+ function stopFailedWorkTimer(fiber) {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming || shouldIgnoreFiber(fiber)) {
+ return;
+ }
+
+ currentFiber = fiber.return;
+
+ if (!fiber._debugIsCurrentlyTiming) {
+ return;
+ }
+
+ fiber._debugIsCurrentlyTiming = false;
+ var warning = fiber.tag === SuspenseComponent || fiber.tag === DehydratedSuspenseComponent ? "Rendering was suspended" : "An error was thrown inside this error boundary";
+ endFiberMark(fiber, null, warning);
+ }
+ }
+
+ function startPhaseTimer(fiber, phase) {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ clearPendingPhaseMeasurement();
+
+ if (!beginFiberMark(fiber, phase)) {
+ return;
+ }
+
+ currentPhaseFiber = fiber;
+ currentPhase = phase;
+ }
+ }
+
+ function stopPhaseTimer() {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ if (currentPhase !== null && currentPhaseFiber !== null) {
+ var warning = hasScheduledUpdateInCurrentPhase ? "Scheduled a cascading update" : null;
+ endFiberMark(currentPhaseFiber, currentPhase, warning);
+ }
+
+ currentPhase = null;
+ currentPhaseFiber = null;
+ }
+ }
+
+ function startWorkLoopTimer(nextUnitOfWork) {
+ if (enableUserTimingAPI) {
+ currentFiber = nextUnitOfWork;
+
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ commitCountInCurrentWorkLoop = 0;
+ beginMark("(React Tree Reconciliation)");
+ resumeTimers();
+ }
+ }
+
+ function stopWorkLoopTimer(interruptedBy, didCompleteRoot) {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ var warning = null;
+
+ if (interruptedBy !== null) {
+ if (interruptedBy.tag === HostRoot) {
+ warning = "A top-level update interrupted the previous render";
+ } else {
+ var componentName = getComponentName(interruptedBy.type) || "Unknown";
+ warning = "An update to " + componentName + " interrupted the previous render";
+ }
+ } else if (commitCountInCurrentWorkLoop > 1) {
+ warning = "There were cascading updates";
+ }
+
+ commitCountInCurrentWorkLoop = 0;
+ var label = didCompleteRoot ? "(React Tree Reconciliation: Completed Root)" : "(React Tree Reconciliation: Yielded)";
+ pauseTimers();
+ endMark(label, "(React Tree Reconciliation)", warning);
+ }
+ }
+
+ function startCommitTimer() {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ isCommitting = true;
+ hasScheduledUpdateInCurrentCommit = false;
+ labelsInCurrentCommit.clear();
+ beginMark("(Committing Changes)");
+ }
+ }
+
+ function stopCommitTimer() {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ var warning = null;
+
+ if (hasScheduledUpdateInCurrentCommit) {
+ warning = "Lifecycle hook scheduled a cascading update";
+ } else if (commitCountInCurrentWorkLoop > 0) {
+ warning = "Caused by a cascading update in earlier commit";
+ }
+
+ hasScheduledUpdateInCurrentCommit = false;
+ commitCountInCurrentWorkLoop++;
+ isCommitting = false;
+ labelsInCurrentCommit.clear();
+ endMark("(Committing Changes)", "(Committing Changes)", warning);
+ }
+ }
+
+ function startCommitSnapshotEffectsTimer() {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ effectCountInCurrentCommit = 0;
+ beginMark("(Committing Snapshot Effects)");
+ }
+ }
+
+ function stopCommitSnapshotEffectsTimer() {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ var count = effectCountInCurrentCommit;
+ effectCountInCurrentCommit = 0;
+ endMark("(Committing Snapshot Effects: " + count + " Total)", "(Committing Snapshot Effects)", null);
+ }
+ }
+
+ function startCommitHostEffectsTimer() {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ effectCountInCurrentCommit = 0;
+ beginMark("(Committing Host Effects)");
+ }
+ }
+
+ function stopCommitHostEffectsTimer() {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ var count = effectCountInCurrentCommit;
+ effectCountInCurrentCommit = 0;
+ endMark("(Committing Host Effects: " + count + " Total)", "(Committing Host Effects)", null);
+ }
+ }
+
+ function startCommitLifeCyclesTimer() {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ effectCountInCurrentCommit = 0;
+ beginMark("(Calling Lifecycle Methods)");
+ }
+ }
+
+ function stopCommitLifeCyclesTimer() {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ var count = effectCountInCurrentCommit;
+ effectCountInCurrentCommit = 0;
+ endMark("(Calling Lifecycle Methods: " + count + " Total)", "(Calling Lifecycle Methods)", null);
+ }
+ }
+
+ var valueStack = [];
+ var fiberStack = void 0;
+ {
+ fiberStack = [];
+ }
+ var index = -1;
+
+ function createCursor(defaultValue) {
+ return {
+ current: defaultValue
+ };
+ }
+
+ function pop(cursor, fiber) {
+ if (index < 0) {
+ {
+ warningWithoutStack$1(false, "Unexpected pop.");
+ }
+ return;
+ }
+
+ {
+ if (fiber !== fiberStack[index]) {
+ warningWithoutStack$1(false, "Unexpected Fiber popped.");
+ }
+ }
+ cursor.current = valueStack[index];
+ valueStack[index] = null;
+ {
+ fiberStack[index] = null;
+ }
+ index--;
+ }
+
+ function push(cursor, value, fiber) {
+ index++;
+ valueStack[index] = cursor.current;
+ {
+ fiberStack[index] = fiber;
+ }
+ cursor.current = value;
+ }
+
+ function checkThatStackIsEmpty() {
+ {
+ if (index !== -1) {
+ warningWithoutStack$1(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 emptyContextObject = {};
+ {
+ Object.freeze(emptyContextObject);
+ }
+ var contextStackCursor = createCursor(emptyContextObject);
+ var didPerformWorkStackCursor = createCursor(false);
+ var previousContext = emptyContextObject;
+
+ function getUnmaskedContext(workInProgress, Component, didPushOwnContextIfProvider) {
+ if (didPushOwnContextIfProvider && isContextProvider(Component)) {
+ 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 emptyContextObject;
+ }
+
+ var instance = workInProgress.stateNode;
+
+ if (instance && instance.__reactInternalMemoizedUnmaskedChildContext === unmaskedContext) {
+ return instance.__reactInternalMemoizedMaskedChildContext;
+ }
+
+ var context = {};
+
+ for (var key in contextTypes) {
+ context[key] = unmaskedContext[key];
+ }
+
+ {
+ var name = getComponentName(type) || "Unknown";
+ checkPropTypes(contextTypes, context, "context", name, getCurrentFiberStackInDev);
+ }
+
+ if (instance) {
+ cacheContext(workInProgress, unmaskedContext, context);
+ }
+
+ return context;
+ }
+
+ function hasContextChanged() {
+ return didPerformWorkStackCursor.current;
+ }
+
+ function isContextProvider(type) {
+ var childContextTypes = type.childContextTypes;
+ return childContextTypes !== null && childContextTypes !== undefined;
+ }
+
+ function popContext(fiber) {
+ pop(didPerformWorkStackCursor, fiber);
+ pop(contextStackCursor, fiber);
+ }
+
+ function popTopLevelContextObject(fiber) {
+ pop(didPerformWorkStackCursor, fiber);
+ pop(contextStackCursor, fiber);
+ }
+
+ function pushTopLevelContextObject(fiber, context, didChange) {
+ invariant(contextStackCursor.current === emptyContextObject, "Unexpected context found on stack. " + "This error is likely caused by a bug in React. Please file an issue.");
+ push(contextStackCursor, context, fiber);
+ push(didPerformWorkStackCursor, didChange, fiber);
+ }
+
+ function processChildContext(fiber, type, parentContext) {
+ var instance = fiber.stateNode;
+ var childContextTypes = type.childContextTypes;
+
+ if (typeof instance.getChildContext !== "function") {
+ {
+ var componentName = getComponentName(type) || "Unknown";
+
+ if (!warnedAboutMissingGetChildContext[componentName]) {
+ warnedAboutMissingGetChildContext[componentName] = true;
+ warningWithoutStack$1(false, "%s.childContextTypes is specified but there is no getChildContext() method " + "on the instance. You can either define getChildContext() on %s or remove " + "childContextTypes from it.", componentName, componentName);
+ }
+ }
+ return parentContext;
+ }
+
+ var childContext = void 0;
+ {
+ setCurrentPhase("getChildContext");
+ }
+ startPhaseTimer(fiber, "getChildContext");
+ childContext = instance.getChildContext();
+ stopPhaseTimer();
+ {
+ setCurrentPhase(null);
+ }
+
+ for (var contextKey in childContext) {
+ invariant(contextKey in childContextTypes, '%s.getChildContext(): key "%s" is not defined in childContextTypes.', getComponentName(type) || "Unknown", contextKey);
+ }
+
+ {
+ var name = getComponentName(type) || "Unknown";
+ checkPropTypes(childContextTypes, childContext, "child context", name, getCurrentFiberStackInDev);
+ }
+ return _extends({}, parentContext, childContext);
+ }
+
+ function pushContextProvider(workInProgress) {
+ var instance = workInProgress.stateNode;
+ var memoizedMergedChildContext = instance && instance.__reactInternalMemoizedMergedChildContext || emptyContextObject;
+ previousContext = contextStackCursor.current;
+ push(contextStackCursor, memoizedMergedChildContext, workInProgress);
+ push(didPerformWorkStackCursor, didPerformWorkStackCursor.current, workInProgress);
+ return true;
+ }
+
+ function invalidateContextProvider(workInProgress, type, didChange) {
+ 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, type, previousContext);
+ instance.__reactInternalMemoizedMergedChildContext = mergedContext;
+ pop(didPerformWorkStackCursor, workInProgress);
+ pop(contextStackCursor, workInProgress);
+ push(contextStackCursor, mergedContext, workInProgress);
+ push(didPerformWorkStackCursor, didChange, workInProgress);
+ } else {
+ pop(didPerformWorkStackCursor, workInProgress);
+ push(didPerformWorkStackCursor, didChange, workInProgress);
+ }
+ }
+
+ function findCurrentUnmaskedContext(fiber) {
+ 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;
+
+ do {
+ switch (node.tag) {
+ case HostRoot:
+ return node.stateNode.context;
+
+ case ClassComponent:
+ {
+ var Component = node.type;
+
+ if (isContextProvider(Component)) {
+ return node.stateNode.__reactInternalMemoizedMergedChildContext;
+ }
+
+ break;
+ }
+ }
+
+ node = node.return;
+ } while (node !== null);
+
+ invariant(false, "Found unexpected detached subtree parent. " + "This error is likely caused by a bug in React. Please file an issue.");
+ }
+
+ 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;
+ warningWithoutStack$1(false, "React DevTools encountered an error: %s", err);
+ }
+ }
+ };
+ }
+
+ var isDevToolsPresent = typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined";
+
+ function injectInternals(internals) {
+ if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === "undefined") {
+ return false;
+ }
+
+ var hook = __REACT_DEVTOOLS_GLOBAL_HOOK__;
+
+ if (hook.isDisabled) {
+ return true;
+ }
+
+ if (!hook.supportsFiber) {
+ {
+ warningWithoutStack$1(false, "The installed version of React DevTools is too old and will not work " + "with the current version of React. Please update React DevTools. " + "https://fb.me/react-devtools");
+ }
+ return true;
+ }
+
+ try {
+ var rendererID = hook.inject(internals);
+ onCommitFiberRoot = catchErrors(function (root) {
+ return hook.onCommitFiberRoot(rendererID, root);
+ });
+ onCommitFiberUnmount = catchErrors(function (fiber) {
+ return hook.onCommitFiberUnmount(rendererID, fiber);
+ });
+ } catch (err) {
+ {
+ warningWithoutStack$1(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 maxSigned31BitInt = 1073741823;
+ var NoWork = 0;
+ var Never = 1;
+ var Sync = maxSigned31BitInt;
+ var UNIT_SIZE = 10;
+ var MAGIC_NUMBER_OFFSET = maxSigned31BitInt - 1;
+
+ function msToExpirationTime(ms) {
+ return MAGIC_NUMBER_OFFSET - (ms / UNIT_SIZE | 0);
+ }
+
+ function expirationTimeToMs(expirationTime) {
+ return (MAGIC_NUMBER_OFFSET - expirationTime) * UNIT_SIZE;
+ }
+
+ function ceiling(num, precision) {
+ return ((num / precision | 0) + 1) * precision;
+ }
+
+ function computeExpirationBucket(currentTime, expirationInMs, bucketSizeMs) {
+ return MAGIC_NUMBER_OFFSET - ceiling(MAGIC_NUMBER_OFFSET - currentTime + expirationInMs / UNIT_SIZE, bucketSizeMs / UNIT_SIZE);
+ }
+
+ var LOW_PRIORITY_EXPIRATION = 5000;
+ var LOW_PRIORITY_BATCH_SIZE = 250;
+
+ function computeAsyncExpiration(currentTime) {
+ return computeExpirationBucket(currentTime, LOW_PRIORITY_EXPIRATION, LOW_PRIORITY_BATCH_SIZE);
+ }
+
+ var HIGH_PRIORITY_EXPIRATION = 500;
+ var HIGH_PRIORITY_BATCH_SIZE = 100;
+
+ function computeInteractiveExpiration(currentTime) {
+ return computeExpirationBucket(currentTime, HIGH_PRIORITY_EXPIRATION, HIGH_PRIORITY_BATCH_SIZE);
+ }
+
+ var NoContext = 0;
+ var ConcurrentMode = 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.elementType = null;
+ this.type = null;
+ this.stateNode = null;
+ this.return = null;
+ this.child = null;
+ this.sibling = null;
+ this.index = 0;
+ this.ref = null;
+ this.pendingProps = pendingProps;
+ this.memoizedProps = null;
+ this.updateQueue = null;
+ this.memoizedState = null;
+ this.contextDependencies = null;
+ this.mode = mode;
+ this.effectTag = NoEffect;
+ this.nextEffect = null;
+ this.firstEffect = null;
+ this.lastEffect = null;
+ this.expirationTime = NoWork;
+ this.childExpirationTime = NoWork;
+ this.alternate = null;
+
+ if (enableProfilerTimer) {
+ this.actualDuration = Number.NaN;
+ this.actualStartTime = Number.NaN;
+ this.selfBaseDuration = Number.NaN;
+ this.treeBaseDuration = Number.NaN;
+ this.actualDuration = 0;
+ this.actualStartTime = -1;
+ this.selfBaseDuration = 0;
+ this.treeBaseDuration = 0;
+ }
+
+ {
+ this._debugID = debugCounter++;
+ this._debugSource = null;
+ this._debugOwner = null;
+ this._debugIsCurrentlyTiming = false;
+
+ if (!hasBadMapPolyfill && typeof Object.preventExtensions === "function") {
+ Object.preventExtensions(this);
+ }
+ }
+ }
+
+ var createFiber = function createFiber(tag, pendingProps, key, mode) {
+ return new FiberNode(tag, pendingProps, key, mode);
+ };
+
+ function shouldConstruct(Component) {
+ var prototype = Component.prototype;
+ return !!(prototype && prototype.isReactComponent);
+ }
+
+ function isSimpleFunctionComponent(type) {
+ return typeof type === "function" && !shouldConstruct(type) && type.defaultProps === undefined;
+ }
+
+ function resolveLazyComponentTag(Component) {
+ if (typeof Component === "function") {
+ return shouldConstruct(Component) ? ClassComponent : FunctionComponent;
+ } else if (Component !== undefined && Component !== null) {
+ var $$typeof = Component.$$typeof;
+
+ if ($$typeof === REACT_FORWARD_REF_TYPE) {
+ return ForwardRef;
+ }
+
+ if ($$typeof === REACT_MEMO_TYPE) {
+ return MemoComponent;
+ }
+ }
+
+ return IndeterminateComponent;
+ }
+
+ function createWorkInProgress(current, pendingProps, expirationTime) {
+ var workInProgress = current.alternate;
+
+ if (workInProgress === null) {
+ workInProgress = createFiber(current.tag, pendingProps, current.key, current.mode);
+ workInProgress.elementType = current.elementType;
+ workInProgress.type = current.type;
+ workInProgress.stateNode = current.stateNode;
+ {
+ workInProgress._debugID = current._debugID;
+ workInProgress._debugSource = current._debugSource;
+ workInProgress._debugOwner = current._debugOwner;
+ }
+ workInProgress.alternate = current;
+ current.alternate = workInProgress;
+ } else {
+ workInProgress.pendingProps = pendingProps;
+ workInProgress.effectTag = NoEffect;
+ workInProgress.nextEffect = null;
+ workInProgress.firstEffect = null;
+ workInProgress.lastEffect = null;
+
+ if (enableProfilerTimer) {
+ workInProgress.actualDuration = 0;
+ workInProgress.actualStartTime = -1;
+ }
+ }
+
+ workInProgress.childExpirationTime = current.childExpirationTime;
+ workInProgress.expirationTime = current.expirationTime;
+ workInProgress.child = current.child;
+ workInProgress.memoizedProps = current.memoizedProps;
+ workInProgress.memoizedState = current.memoizedState;
+ workInProgress.updateQueue = current.updateQueue;
+ workInProgress.contextDependencies = current.contextDependencies;
+ workInProgress.sibling = current.sibling;
+ workInProgress.index = current.index;
+ workInProgress.ref = current.ref;
+
+ if (enableProfilerTimer) {
+ workInProgress.selfBaseDuration = current.selfBaseDuration;
+ workInProgress.treeBaseDuration = current.treeBaseDuration;
+ }
+
+ return workInProgress;
+ }
+
+ function createHostRootFiber(isConcurrent) {
+ var mode = isConcurrent ? ConcurrentMode | StrictMode : NoContext;
+
+ if (enableProfilerTimer && isDevToolsPresent) {
+ mode |= ProfileMode;
+ }
+
+ return createFiber(HostRoot, null, null, mode);
+ }
+
+ function createFiberFromTypeAndProps(type, key, pendingProps, owner, mode, expirationTime) {
+ var fiber = void 0;
+ var fiberTag = IndeterminateComponent;
+ var resolvedType = type;
+
+ if (typeof type === "function") {
+ if (shouldConstruct(type)) {
+ fiberTag = ClassComponent;
+ }
+ } else if (typeof type === "string") {
+ fiberTag = HostComponent;
+ } else {
+ getTag: switch (type) {
+ case REACT_FRAGMENT_TYPE:
+ return createFiberFromFragment(pendingProps.children, mode, expirationTime, key);
+
+ case REACT_CONCURRENT_MODE_TYPE:
+ return createFiberFromMode(pendingProps, mode | ConcurrentMode | StrictMode, expirationTime, key);
+
+ case REACT_STRICT_MODE_TYPE:
+ return createFiberFromMode(pendingProps, mode | StrictMode, expirationTime, key);
+
+ case REACT_PROFILER_TYPE:
+ return createFiberFromProfiler(pendingProps, mode, expirationTime, key);
+
+ case REACT_SUSPENSE_TYPE:
+ return createFiberFromSuspense(pendingProps, mode, expirationTime, key);
+
+ default:
+ {
+ if (typeof type === "object" && type !== null) {
+ switch (type.$$typeof) {
+ case REACT_PROVIDER_TYPE:
+ fiberTag = ContextProvider;
+ break getTag;
+
+ case REACT_CONTEXT_TYPE:
+ fiberTag = ContextConsumer;
+ break getTag;
+
+ case REACT_FORWARD_REF_TYPE:
+ fiberTag = ForwardRef;
+ break getTag;
+
+ case REACT_MEMO_TYPE:
+ fiberTag = MemoComponent;
+ break getTag;
+
+ case REACT_LAZY_TYPE:
+ fiberTag = LazyComponent;
+ resolvedType = null;
+ break getTag;
+ }
+ }
+
+ var info = "";
+ {
+ if (type === undefined || typeof type === "object" && type !== null && Object.keys(type).length === 0) {
+ info += " You likely forgot to export your component from the file " + "it's defined in, or you might have mixed up default and " + "named imports.";
+ }
+
+ var ownerName = owner ? getComponentName(owner.type) : null;
+
+ if (ownerName) {
+ info += "\n\nCheck the render method of `" + ownerName + "`.";
+ }
+ }
+ 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);
+ }
+ }
+ }
+
+ fiber = createFiber(fiberTag, pendingProps, key, mode);
+ fiber.elementType = type;
+ fiber.type = resolvedType;
+ fiber.expirationTime = expirationTime;
+ return fiber;
+ }
+
+ function createFiberFromElement(element, mode, expirationTime) {
+ var owner = null;
+ {
+ owner = element._owner;
+ }
+ var type = element.type;
+ var key = element.key;
+ var pendingProps = element.props;
+ var fiber = createFiberFromTypeAndProps(type, key, pendingProps, owner, mode, expirationTime);
+ {
+ fiber._debugSource = element._source;
+ fiber._debugOwner = element._owner;
+ }
+ return fiber;
+ }
+
+ function createFiberFromFragment(elements, mode, expirationTime, key) {
+ var fiber = createFiber(Fragment, elements, key, mode);
+ fiber.expirationTime = expirationTime;
+ return fiber;
+ }
+
+ function createFiberFromProfiler(pendingProps, mode, expirationTime, key) {
+ {
+ if (typeof pendingProps.id !== "string" || typeof pendingProps.onRender !== "function") {
+ warningWithoutStack$1(false, 'Profiler must specify an "id" string and "onRender" function as props');
+ }
+ }
+ var fiber = createFiber(Profiler, pendingProps, key, mode | ProfileMode);
+ fiber.elementType = REACT_PROFILER_TYPE;
+ fiber.type = REACT_PROFILER_TYPE;
+ fiber.expirationTime = expirationTime;
+ return fiber;
+ }
+
+ function createFiberFromMode(pendingProps, mode, expirationTime, key) {
+ var fiber = createFiber(Mode, pendingProps, key, mode);
+ var type = (mode & ConcurrentMode) === NoContext ? REACT_STRICT_MODE_TYPE : REACT_CONCURRENT_MODE_TYPE;
+ fiber.elementType = type;
+ fiber.type = type;
+ fiber.expirationTime = expirationTime;
+ return fiber;
+ }
+
+ function createFiberFromSuspense(pendingProps, mode, expirationTime, key) {
+ var fiber = createFiber(SuspenseComponent, pendingProps, key, mode);
+ var type = REACT_SUSPENSE_TYPE;
+ fiber.elementType = type;
+ fiber.type = 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.elementType = "DELETED";
+ fiber.type = "DELETED";
+ return fiber;
+ }
+
+ function createFiberFromPortal(portal, mode, expirationTime) {
+ var pendingProps = portal.children !== null ? portal.children : [];
+ var fiber = createFiber(HostPortal, pendingProps, portal.key, mode);
+ fiber.expirationTime = expirationTime;
+ fiber.stateNode = {
+ containerInfo: portal.containerInfo,
+ pendingChildren: null,
+ implementation: portal.implementation
+ };
+ return fiber;
+ }
+
+ function assignFiberPropertiesInDEV(target, source) {
+ if (target === null) {
+ target = createFiber(IndeterminateComponent, null, null, NoContext);
+ }
+
+ target.tag = source.tag;
+ target.key = source.key;
+ target.elementType = source.elementType;
+ target.type = source.type;
+ target.stateNode = source.stateNode;
+ target.return = source.return;
+ target.child = source.child;
+ target.sibling = source.sibling;
+ target.index = source.index;
+ target.ref = source.ref;
+ target.pendingProps = source.pendingProps;
+ target.memoizedProps = source.memoizedProps;
+ target.updateQueue = source.updateQueue;
+ target.memoizedState = source.memoizedState;
+ target.contextDependencies = source.contextDependencies;
+ target.mode = source.mode;
+ target.effectTag = source.effectTag;
+ target.nextEffect = source.nextEffect;
+ target.firstEffect = source.firstEffect;
+ target.lastEffect = source.lastEffect;
+ target.expirationTime = source.expirationTime;
+ target.childExpirationTime = source.childExpirationTime;
+ target.alternate = source.alternate;
+
+ if (enableProfilerTimer) {
+ target.actualDuration = source.actualDuration;
+ target.actualStartTime = source.actualStartTime;
+ target.selfBaseDuration = source.selfBaseDuration;
+ target.treeBaseDuration = source.treeBaseDuration;
+ }
+
+ target._debugID = source._debugID;
+ target._debugSource = source._debugSource;
+ target._debugOwner = source._debugOwner;
+ target._debugIsCurrentlyTiming = source._debugIsCurrentlyTiming;
+ return target;
+ }
+
+ function createFiberRoot(containerInfo, isConcurrent, hydrate) {
+ var uninitializedFiber = createHostRootFiber(isConcurrent);
+ var root = void 0;
+
+ if (enableSchedulerTracing) {
+ root = {
+ current: uninitializedFiber,
+ containerInfo: containerInfo,
+ pendingChildren: null,
+ earliestPendingTime: NoWork,
+ latestPendingTime: NoWork,
+ earliestSuspendedTime: NoWork,
+ latestSuspendedTime: NoWork,
+ latestPingedTime: NoWork,
+ pingCache: null,
+ didError: false,
+ pendingCommitExpirationTime: NoWork,
+ finishedWork: null,
+ timeoutHandle: noTimeout,
+ context: null,
+ pendingContext: null,
+ hydrate: hydrate,
+ nextExpirationTimeToWorkOn: NoWork,
+ expirationTime: NoWork,
+ firstBatch: null,
+ nextScheduledRoot: null,
+ interactionThreadID: tracing.unstable_getThreadID(),
+ memoizedInteractions: new Set(),
+ pendingInteractionMap: new Map()
+ };
+ } else {
+ root = {
+ current: uninitializedFiber,
+ containerInfo: containerInfo,
+ pendingChildren: null,
+ pingCache: null,
+ earliestPendingTime: NoWork,
+ latestPendingTime: NoWork,
+ earliestSuspendedTime: NoWork,
+ latestSuspendedTime: NoWork,
+ latestPingedTime: NoWork,
+ didError: false,
+ pendingCommitExpirationTime: NoWork,
+ finishedWork: null,
+ timeoutHandle: noTimeout,
+ context: null,
+ pendingContext: null,
+ hydrate: hydrate,
+ nextExpirationTimeToWorkOn: NoWork,
+ expirationTime: NoWork,
+ firstBatch: null,
+ nextScheduledRoot: null
+ };
+ }
+
+ uninitializedFiber.stateNode = root;
+ return root;
+ }
+
+ var lowPriorityWarning = function lowPriorityWarning() {};
+
+ {
+ var printWarning = function printWarning(format) {
+ for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+ args[_key - 1] = arguments[_key];
+ }
+
+ var argIndex = 0;
+ var message = "Warning: " + format.replace(/%s/g, function () {
+ return args[argIndex++];
+ });
+
+ if (typeof console !== "undefined") {
+ console.warn(message);
+ }
+
+ try {
+ throw new Error(message);
+ } catch (x) {}
+ };
+
+ lowPriorityWarning = function lowPriorityWarning(condition, format) {
+ if (format === undefined) {
+ throw new Error("`lowPriorityWarning(condition, format, ...args)` requires a warning " + "message argument");
+ }
+
+ if (!condition) {
+ for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
+ args[_key2 - 2] = arguments[_key2];
+ }
+
+ printWarning.apply(undefined, [format].concat(args));
+ }
+ };
+ }
+ var lowPriorityWarning$1 = lowPriorityWarning;
+ var ReactStrictModeWarnings = {
+ 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 lifecyclesWarningMessages = [];
+ 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.type) || "Component");
+ didWarnAboutUnsafeLifecycles.add(fiber.type);
+ });
+ var formatted = lifecycle.replace("UNSAFE_", "");
+ var suggestion = LIFECYCLE_SUGGESTIONS[lifecycle];
+ var sortedComponentNames = setToSortedString(componentNames);
+ lifecyclesWarningMessages.push(formatted + ": Please update the following components to use " + (suggestion + " instead: " + sortedComponentNames));
+ }
+ });
+
+ if (lifecyclesWarningMessages.length > 0) {
+ var strictRootComponentStack = getStackByFiberInDevAndProd(strictRoot);
+ warningWithoutStack$1(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, lifecyclesWarningMessages.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.type) || "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.type) || "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.type) || "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) {
+ warningWithoutStack$1(false, "Expected to find a StrictMode component in a strict mode tree. " + "This error is likely caused by a bug in React. Please file an issue.");
+ return;
+ }
+
+ if (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) {
+ warningWithoutStack$1(false, "Expected to find a StrictMode component in a strict mode tree. " + "This error is likely caused by a bug in React. Please file an issue.");
+ return;
+ }
+
+ if (didWarnAboutLegacyContext.has(fiber.type)) {
+ return;
+ }
+
+ var warningsForRoot = pendingLegacyContextWarning.get(strictRoot);
+
+ if (fiber.type.contextTypes != null || fiber.type.childContextTypes != null || instance !== null && typeof instance.getChildContext === "function") {
+ if (warningsForRoot === undefined) {
+ warningsForRoot = [];
+ pendingLegacyContextWarning.set(strictRoot, warningsForRoot);
+ }
+
+ warningsForRoot.push(fiber);
+ }
+ };
+
+ ReactStrictModeWarnings.flushLegacyContextWarning = function () {
+ pendingLegacyContextWarning.forEach(function (fiberArray, strictRoot) {
+ var uniqueNames = new Set();
+ fiberArray.forEach(function (fiber) {
+ uniqueNames.add(getComponentName(fiber.type) || "Component");
+ didWarnAboutLegacyContext.add(fiber.type);
+ });
+ var sortedNames = setToSortedString(uniqueNames);
+ var strictRootComponentStack = getStackByFiberInDevAndProd(strictRoot);
+ warningWithoutStack$1(false, "Legacy context API has been detected within a strict-mode tree: %s" + "\n\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;
+ }
+ }
+ }
+
+ findNextExpirationTimeToWorkOn(expirationTime, root);
+ }
+
+ function markCommittedPriorityLevels(root, earliestRemainingTime) {
+ root.didError = false;
+
+ if (earliestRemainingTime === NoWork) {
+ root.earliestPendingTime = NoWork;
+ root.latestPendingTime = NoWork;
+ root.earliestSuspendedTime = NoWork;
+ root.latestSuspendedTime = NoWork;
+ root.latestPingedTime = NoWork;
+ findNextExpirationTimeToWorkOn(NoWork, root);
+ return;
+ }
+
+ if (earliestRemainingTime < root.latestPingedTime) {
+ root.latestPingedTime = NoWork;
+ }
+
+ 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);
+ findNextExpirationTimeToWorkOn(NoWork, root);
+ return;
+ }
+
+ var latestSuspendedTime = root.latestSuspendedTime;
+
+ if (earliestRemainingTime < latestSuspendedTime) {
+ root.earliestSuspendedTime = NoWork;
+ root.latestSuspendedTime = NoWork;
+ root.latestPingedTime = NoWork;
+ markPendingPriorityLevel(root, earliestRemainingTime);
+ findNextExpirationTimeToWorkOn(NoWork, root);
+ return;
+ }
+
+ if (earliestRemainingTime > earliestSuspendedTime) {
+ markPendingPriorityLevel(root, earliestRemainingTime);
+ findNextExpirationTimeToWorkOn(NoWork, root);
+ return;
+ }
+
+ findNextExpirationTimeToWorkOn(NoWork, root);
+ }
+
+ function hasLowerPriorityWork(root, erroredExpirationTime) {
+ var latestPendingTime = root.latestPendingTime;
+ var latestSuspendedTime = root.latestSuspendedTime;
+ var latestPingedTime = root.latestPingedTime;
+ return latestPendingTime !== NoWork && latestPendingTime < erroredExpirationTime || latestSuspendedTime !== NoWork && latestSuspendedTime < erroredExpirationTime || latestPingedTime !== NoWork && latestPingedTime < erroredExpirationTime;
+ }
+
+ function isPriorityLevelSuspended(root, expirationTime) {
+ var earliestSuspendedTime = root.earliestSuspendedTime;
+ var latestSuspendedTime = root.latestSuspendedTime;
+ return earliestSuspendedTime !== NoWork && expirationTime <= earliestSuspendedTime && expirationTime >= latestSuspendedTime;
+ }
+
+ function markSuspendedPriorityLevel(root, suspendedTime) {
+ root.didError = false;
+ clearPing(root, suspendedTime);
+ 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 earliestSuspendedTime = root.earliestSuspendedTime;
+ var latestSuspendedTime = root.latestSuspendedTime;
+
+ if (earliestSuspendedTime === NoWork) {
+ root.earliestSuspendedTime = root.latestSuspendedTime = suspendedTime;
+ } else {
+ if (earliestSuspendedTime < suspendedTime) {
+ root.earliestSuspendedTime = suspendedTime;
+ } else if (latestSuspendedTime > suspendedTime) {
+ root.latestSuspendedTime = suspendedTime;
+ }
+ }
+
+ findNextExpirationTimeToWorkOn(suspendedTime, root);
+ }
+
+ function markPingedPriorityLevel(root, pingedTime) {
+ root.didError = false;
+ var latestPingedTime = root.latestPingedTime;
+
+ if (latestPingedTime === NoWork || latestPingedTime > pingedTime) {
+ root.latestPingedTime = pingedTime;
+ }
+
+ findNextExpirationTimeToWorkOn(pingedTime, root);
+ }
+
+ function clearPing(root, completedTime) {
+ var latestPingedTime = root.latestPingedTime;
+
+ if (latestPingedTime >= completedTime) {
+ root.latestPingedTime = NoWork;
+ }
+ }
+
+ function findEarliestOutstandingPriorityLevel(root, renderExpirationTime) {
+ var earliestExpirationTime = renderExpirationTime;
+ var earliestPendingTime = root.earliestPendingTime;
+ var earliestSuspendedTime = root.earliestSuspendedTime;
+
+ if (earliestPendingTime > earliestExpirationTime) {
+ earliestExpirationTime = earliestPendingTime;
+ }
+
+ if (earliestSuspendedTime > earliestExpirationTime) {
+ earliestExpirationTime = earliestSuspendedTime;
+ }
+
+ return earliestExpirationTime;
+ }
+
+ function didExpireAtExpirationTime(root, currentTime) {
+ var expirationTime = root.expirationTime;
+
+ if (expirationTime !== NoWork && currentTime <= expirationTime) {
+ root.nextExpirationTimeToWorkOn = currentTime;
+ }
+ }
+
+ function findNextExpirationTimeToWorkOn(completedExpirationTime, root) {
+ var earliestSuspendedTime = root.earliestSuspendedTime;
+ var latestSuspendedTime = root.latestSuspendedTime;
+ var earliestPendingTime = root.earliestPendingTime;
+ var latestPingedTime = root.latestPingedTime;
+ var nextExpirationTimeToWorkOn = earliestPendingTime !== NoWork ? earliestPendingTime : latestPingedTime;
+
+ if (nextExpirationTimeToWorkOn === NoWork && (completedExpirationTime === NoWork || latestSuspendedTime < completedExpirationTime)) {
+ nextExpirationTimeToWorkOn = latestSuspendedTime;
+ }
+
+ var expirationTime = nextExpirationTimeToWorkOn;
+
+ if (expirationTime !== NoWork && earliestSuspendedTime > expirationTime) {
+ expirationTime = earliestSuspendedTime;
+ }
+
+ root.nextExpirationTimeToWorkOn = nextExpirationTimeToWorkOn;
+ root.expirationTime = expirationTime;
+ }
+
+ var warning = warningWithoutStack$1;
+ {
+ warning = function warning(condition, format) {
+ if (condition) {
+ return;
+ }
+
+ var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+ var stack = ReactDebugCurrentFrame.getStackAddendum();
+
+ for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+ args[_key - 2] = arguments[_key];
+ }
+
+ warningWithoutStack$1.apply(undefined, [false, format + "%s"].concat(args, [stack]));
+ };
+ }
+ var warning$1 = warning;
+
+ function is(x, y) {
+ return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y;
+ }
+
+ var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+ function shallowEqual(objA, objB) {
+ if (is(objA, objB)) {
+ return true;
+ }
+
+ if (typeof objA !== "object" || objA === null || typeof objB !== "object" || objB === null) {
+ return false;
+ }
+
+ var keysA = Object.keys(objA);
+ var keysB = Object.keys(objB);
+
+ if (keysA.length !== keysB.length) {
+ return false;
+ }
+
+ for (var i = 0; i < keysA.length; i++) {
+ if (!hasOwnProperty.call(objB, keysA[i]) || !is(objA[keysA[i]], objB[keysA[i]])) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ function resolveDefaultProps(Component, baseProps) {
+ if (Component && Component.defaultProps) {
+ var props = _extends({}, baseProps);
+
+ var defaultProps = Component.defaultProps;
+
+ for (var propName in defaultProps) {
+ if (props[propName] === undefined) {
+ props[propName] = defaultProps[propName];
+ }
+ }
+
+ return props;
+ }
+
+ return baseProps;
+ }
+
+ function readLazyComponentType(lazyComponent) {
+ var status = lazyComponent._status;
+ var result = lazyComponent._result;
+
+ switch (status) {
+ case Resolved:
+ {
+ var Component = result;
+ return Component;
+ }
+
+ case Rejected:
+ {
+ var error = result;
+ throw error;
+ }
+
+ case Pending:
+ {
+ var thenable = result;
+ throw thenable;
+ }
+
+ default:
+ {
+ lazyComponent._status = Pending;
+ var ctor = lazyComponent._ctor;
+
+ var _thenable = ctor();
+
+ _thenable.then(function (moduleObject) {
+ if (lazyComponent._status === Pending) {
+ var defaultExport = moduleObject.default;
+ {
+ if (defaultExport === undefined) {
+ warning$1(false, "lazy: Expected the result of a dynamic import() call. " + "Instead received: %s\n\nYour code should look like: \n " + "const MyComponent = lazy(() => import('./MyComponent'))", moduleObject);
+ }
+ }
+ lazyComponent._status = Resolved;
+ lazyComponent._result = defaultExport;
+ }
+ }, function (error) {
+ if (lazyComponent._status === Pending) {
+ lazyComponent._status = Rejected;
+ lazyComponent._result = error;
+ }
+ });
+
+ switch (lazyComponent._status) {
+ case Resolved:
+ return lazyComponent._result;
+
+ case Rejected:
+ throw lazyComponent._result;
+ }
+
+ lazyComponent._result = _thenable;
+ throw _thenable;
+ }
+ }
+ }
+
+ var fakeInternalInstance = {};
+ var isArray$1 = Array.isArray;
+ var emptyRefsObject = new React.Component().refs;
+ var didWarnAboutStateAssignmentForComponent = void 0;
+ var didWarnAboutUninitializedState = void 0;
+ var didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate = void 0;
+ var didWarnAboutLegacyLifecyclesAndDerivedState = void 0;
+ var didWarnAboutUndefinedDerivedState = void 0;
+ var warnOnUndefinedDerivedState = void 0;
+ var warnOnInvalidCallback = void 0;
+ var didWarnAboutDirectlyAssigningPropsToState = void 0;
+ var didWarnAboutContextTypeAndContextTypes = void 0;
+ var didWarnAboutInvalidateContextType = void 0;
+ {
+ didWarnAboutStateAssignmentForComponent = new Set();
+ didWarnAboutUninitializedState = new Set();
+ didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate = new Set();
+ didWarnAboutLegacyLifecyclesAndDerivedState = new Set();
+ didWarnAboutDirectlyAssigningPropsToState = new Set();
+ didWarnAboutUndefinedDerivedState = new Set();
+ didWarnAboutContextTypeAndContextTypes = new Set();
+ didWarnAboutInvalidateContextType = new Set();
+ var didWarnOnInvalidCallback = new Set();
+
+ warnOnInvalidCallback = function warnOnInvalidCallback(callback, callerName) {
+ if (callback === null || typeof callback === "function") {
+ return;
+ }
+
+ var key = callerName + "_" + callback;
+
+ if (!didWarnOnInvalidCallback.has(key)) {
+ didWarnOnInvalidCallback.add(key);
+ warningWithoutStack$1(false, "%s(...): Expected the last optional `callback` argument to be a " + "function. Instead received: %s.", callerName, callback);
+ }
+ };
+
+ warnOnUndefinedDerivedState = function warnOnUndefinedDerivedState(type, partialState) {
+ if (partialState === undefined) {
+ var componentName = getComponentName(type) || "Component";
+
+ if (!didWarnAboutUndefinedDerivedState.has(componentName)) {
+ didWarnAboutUndefinedDerivedState.add(componentName);
+ warningWithoutStack$1(false, "%s.getDerivedStateFromProps(): A valid state object (or null) must be returned. " + "You have returned undefined.", componentName);
+ }
+ }
+ };
+
+ Object.defineProperty(fakeInternalInstance, "_processChildContext", {
+ enumerable: false,
+ value: function value() {
+ 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, ctor, getDerivedStateFromProps, nextProps) {
+ var prevState = workInProgress.memoizedState;
+ {
+ if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
+ getDerivedStateFromProps(nextProps, prevState);
+ }
+ }
+ var partialState = getDerivedStateFromProps(nextProps, prevState);
+ {
+ warnOnUndefinedDerivedState(ctor, partialState);
+ }
+ var memoizedState = partialState === null || partialState === undefined ? prevState : _extends({}, prevState, partialState);
+ workInProgress.memoizedState = memoizedState;
+ var updateQueue = workInProgress.updateQueue;
+
+ if (updateQueue !== null && workInProgress.expirationTime === NoWork) {
+ updateQueue.baseState = memoizedState;
+ }
+ }
+
+ var classComponentUpdater = {
+ isMounted: isMounted,
+ enqueueSetState: function enqueueSetState(inst, payload, callback) {
+ var fiber = get$1(inst);
+ var currentTime = requestCurrentTime();
+ var expirationTime = computeExpirationForFiber(currentTime, fiber);
+ var update = createUpdate(expirationTime);
+ update.payload = payload;
+
+ if (callback !== undefined && callback !== null) {
+ {
+ warnOnInvalidCallback(callback, "setState");
+ }
+ update.callback = callback;
+ }
+
+ flushPassiveEffects();
+ enqueueUpdate(fiber, update);
+ scheduleWork(fiber, expirationTime);
+ },
+ enqueueReplaceState: function enqueueReplaceState(inst, payload, callback) {
+ var fiber = get$1(inst);
+ var currentTime = requestCurrentTime();
+ 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;
+ }
+
+ flushPassiveEffects();
+ enqueueUpdate(fiber, update);
+ scheduleWork(fiber, expirationTime);
+ },
+ enqueueForceUpdate: function enqueueForceUpdate(inst, callback) {
+ var fiber = get$1(inst);
+ var currentTime = requestCurrentTime();
+ var expirationTime = computeExpirationForFiber(currentTime, fiber);
+ var update = createUpdate(expirationTime);
+ update.tag = ForceUpdate;
+
+ if (callback !== undefined && callback !== null) {
+ {
+ warnOnInvalidCallback(callback, "forceUpdate");
+ }
+ update.callback = callback;
+ }
+
+ flushPassiveEffects();
+ enqueueUpdate(fiber, update);
+ scheduleWork(fiber, expirationTime);
+ }
+ };
+
+ function checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext) {
+ var instance = workInProgress.stateNode;
+
+ if (typeof instance.shouldComponentUpdate === "function") {
+ startPhaseTimer(workInProgress, "shouldComponentUpdate");
+ var shouldUpdate = instance.shouldComponentUpdate(newProps, newState, nextContext);
+ stopPhaseTimer();
+ {
+ !(shouldUpdate !== undefined) ? warningWithoutStack$1(false, "%s.shouldComponentUpdate(): Returned undefined instead of a " + "boolean value. Make sure to return true or false.", getComponentName(ctor) || "Component") : void 0;
+ }
+ return shouldUpdate;
+ }
+
+ if (ctor.prototype && ctor.prototype.isPureReactComponent) {
+ return !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState);
+ }
+
+ return true;
+ }
+
+ function checkClassInstance(workInProgress, ctor, newProps) {
+ var instance = workInProgress.stateNode;
+ {
+ var name = getComponentName(ctor) || "Component";
+ var renderPresent = instance.render;
+
+ if (!renderPresent) {
+ if (ctor.prototype && typeof ctor.prototype.render === "function") {
+ warningWithoutStack$1(false, "%s(...): No `render` method found on the returned component " + "instance: did you accidentally return an object from the constructor?", name);
+ } else {
+ warningWithoutStack$1(false, "%s(...): No `render` method found on the returned component " + "instance: you may have forgotten to define `render`.", name);
+ }
+ }
+
+ var noGetInitialStateOnES6 = !instance.getInitialState || instance.getInitialState.isReactClassApproved || instance.state;
+ !noGetInitialStateOnES6 ? warningWithoutStack$1(false, "getInitialState was defined on %s, a plain JavaScript class. " + "This is only supported for classes created using React.createClass. " + "Did you mean to define a state property instead?", name) : void 0;
+ var noGetDefaultPropsOnES6 = !instance.getDefaultProps || instance.getDefaultProps.isReactClassApproved;
+ !noGetDefaultPropsOnES6 ? warningWithoutStack$1(false, "getDefaultProps was defined on %s, a plain JavaScript class. " + "This is only supported for classes created using React.createClass. " + "Use a static property to define defaultProps instead.", name) : void 0;
+ var noInstancePropTypes = !instance.propTypes;
+ !noInstancePropTypes ? warningWithoutStack$1(false, "propTypes was defined as an instance property on %s. Use a static " + "property to define propTypes instead.", name) : void 0;
+ var noInstanceContextType = !instance.contextType;
+ !noInstanceContextType ? warningWithoutStack$1(false, "contextType was defined as an instance property on %s. Use a static " + "property to define contextType instead.", name) : void 0;
+ var noInstanceContextTypes = !instance.contextTypes;
+ !noInstanceContextTypes ? warningWithoutStack$1(false, "contextTypes was defined as an instance property on %s. Use a static " + "property to define contextTypes instead.", name) : void 0;
+
+ if (ctor.contextType && ctor.contextTypes && !didWarnAboutContextTypeAndContextTypes.has(ctor)) {
+ didWarnAboutContextTypeAndContextTypes.add(ctor);
+ warningWithoutStack$1(false, "%s declares both contextTypes and contextType static properties. " + "The legacy contextTypes property will be ignored.", name);
+ }
+
+ var noComponentShouldUpdate = typeof instance.componentShouldUpdate !== "function";
+ !noComponentShouldUpdate ? warningWithoutStack$1(false, "%s has a method called " + "componentShouldUpdate(). Did you mean shouldComponentUpdate()? " + "The name is phrased as a question because the function is " + "expected to return a value.", name) : void 0;
+
+ if (ctor.prototype && ctor.prototype.isPureReactComponent && typeof instance.shouldComponentUpdate !== "undefined") {
+ warningWithoutStack$1(false, "%s has a method called shouldComponentUpdate(). " + "shouldComponentUpdate should not be used when extending React.PureComponent. " + "Please extend React.Component if shouldComponentUpdate is used.", getComponentName(ctor) || "A pure component");
+ }
+
+ var noComponentDidUnmount = typeof instance.componentDidUnmount !== "function";
+ !noComponentDidUnmount ? warningWithoutStack$1(false, "%s has a method called " + "componentDidUnmount(). But there is no such lifecycle method. " + "Did you mean componentWillUnmount()?", name) : void 0;
+ var noComponentDidReceiveProps = typeof instance.componentDidReceiveProps !== "function";
+ !noComponentDidReceiveProps ? warningWithoutStack$1(false, "%s has a method called " + "componentDidReceiveProps(). But there is no such lifecycle method. " + "If you meant to update the state in response to changing props, " + "use componentWillReceiveProps(). If you meant to fetch data or " + "run side-effects or mutations after React has updated the UI, use componentDidUpdate().", name) : void 0;
+ var noComponentWillRecieveProps = typeof instance.componentWillRecieveProps !== "function";
+ !noComponentWillRecieveProps ? warningWithoutStack$1(false, "%s has a method called " + "componentWillRecieveProps(). Did you mean componentWillReceiveProps()?", name) : void 0;
+ var noUnsafeComponentWillRecieveProps = typeof instance.UNSAFE_componentWillRecieveProps !== "function";
+ !noUnsafeComponentWillRecieveProps ? warningWithoutStack$1(false, "%s has a method called " + "UNSAFE_componentWillRecieveProps(). Did you mean UNSAFE_componentWillReceiveProps()?", name) : void 0;
+ var hasMutatedProps = instance.props !== newProps;
+ !(instance.props === undefined || !hasMutatedProps) ? warningWithoutStack$1(false, "%s(...): When calling super() in `%s`, make sure to pass " + "up the same props that your component's constructor was passed.", name, name) : void 0;
+ var noInstanceDefaultProps = !instance.defaultProps;
+ !noInstanceDefaultProps ? warningWithoutStack$1(false, "Setting defaultProps as an instance property on %s is not supported and will be ignored." + " Instead, define defaultProps as a static property on %s.", name, name) : void 0;
+
+ if (typeof instance.getSnapshotBeforeUpdate === "function" && typeof instance.componentDidUpdate !== "function" && !didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.has(ctor)) {
+ didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.add(ctor);
+ warningWithoutStack$1(false, "%s: getSnapshotBeforeUpdate() should be used with componentDidUpdate(). " + "This component defines getSnapshotBeforeUpdate() only.", getComponentName(ctor));
+ }
+
+ var noInstanceGetDerivedStateFromProps = typeof instance.getDerivedStateFromProps !== "function";
+ !noInstanceGetDerivedStateFromProps ? warningWithoutStack$1(false, "%s: getDerivedStateFromProps() is defined as an instance method " + "and will be ignored. Instead, declare it as a static method.", name) : void 0;
+ var noInstanceGetDerivedStateFromCatch = typeof instance.getDerivedStateFromError !== "function";
+ !noInstanceGetDerivedStateFromCatch ? warningWithoutStack$1(false, "%s: getDerivedStateFromError() is defined as an instance method " + "and will be ignored. Instead, declare it as a static method.", name) : void 0;
+ var noStaticGetSnapshotBeforeUpdate = typeof ctor.getSnapshotBeforeUpdate !== "function";
+ !noStaticGetSnapshotBeforeUpdate ? warningWithoutStack$1(false, "%s: getSnapshotBeforeUpdate() is defined as a static method " + "and will be ignored. Instead, declare it as an instance method.", name) : void 0;
+ var _state = instance.state;
+
+ if (_state && (typeof _state !== "object" || isArray$1(_state))) {
+ warningWithoutStack$1(false, "%s.state: must be set to an object or null", name);
+ }
+
+ if (typeof instance.getChildContext === "function") {
+ !(typeof ctor.childContextTypes === "object") ? warningWithoutStack$1(false, "%s.getChildContext(): childContextTypes must be defined in order to " + "use getChildContext().", name) : void 0;
+ }
+ }
+ }
+
+ function adoptClassInstance(workInProgress, instance) {
+ instance.updater = classComponentUpdater;
+ workInProgress.stateNode = instance;
+ set(instance, workInProgress);
+ {
+ instance._reactInternalInstance = fakeInternalInstance;
+ }
+ }
+
+ function constructClassInstance(workInProgress, ctor, props, renderExpirationTime) {
+ var isLegacyContextConsumer = false;
+ var unmaskedContext = emptyContextObject;
+ var context = null;
+ var contextType = ctor.contextType;
+
+ if (typeof contextType === "object" && contextType !== null) {
+ {
+ if (contextType.$$typeof !== REACT_CONTEXT_TYPE && !didWarnAboutInvalidateContextType.has(ctor)) {
+ didWarnAboutInvalidateContextType.add(ctor);
+ warningWithoutStack$1(false, "%s defines an invalid contextType. " + "contextType should point to the Context object returned by React.createContext(). " + "Did you accidentally pass the Context.Provider instead?", getComponentName(ctor) || "Component");
+ }
+ }
+ context = _readContext(contextType);
+ } else {
+ unmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
+ var contextTypes = ctor.contextTypes;
+ isLegacyContextConsumer = contextTypes !== null && contextTypes !== undefined;
+ context = isLegacyContextConsumer ? getMaskedContext(workInProgress, unmaskedContext) : emptyContextObject;
+ }
+
+ {
+ if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
+ new ctor(props, context);
+ }
+ }
+ var instance = new ctor(props, context);
+ var state = workInProgress.memoizedState = instance.state !== null && instance.state !== undefined ? instance.state : null;
+ adoptClassInstance(workInProgress, instance);
+ {
+ if (typeof ctor.getDerivedStateFromProps === "function" && state === null) {
+ var componentName = getComponentName(ctor) || "Component";
+
+ if (!didWarnAboutUninitializedState.has(componentName)) {
+ didWarnAboutUninitializedState.add(componentName);
+ warningWithoutStack$1(false, "`%s` uses `getDerivedStateFromProps` but its initial state is " + "%s. This is not recommended. Instead, define the initial state by " + "assigning an object to `this.state` in the constructor of `%s`. " + "This ensures that `getDerivedStateFromProps` arguments have a consistent shape.", componentName, instance.state === null ? "null" : "undefined", componentName);
+ }
+ }
+
+ if (typeof ctor.getDerivedStateFromProps === "function" || typeof instance.getSnapshotBeforeUpdate === "function") {
+ var foundWillMountName = null;
+ var foundWillReceivePropsName = null;
+ var foundWillUpdateName = null;
+
+ if (typeof instance.componentWillMount === "function" && instance.componentWillMount.__suppressDeprecationWarning !== true) {
+ foundWillMountName = "componentWillMount";
+ } else if (typeof instance.UNSAFE_componentWillMount === "function") {
+ foundWillMountName = "UNSAFE_componentWillMount";
+ }
+
+ if (typeof instance.componentWillReceiveProps === "function" && instance.componentWillReceiveProps.__suppressDeprecationWarning !== true) {
+ foundWillReceivePropsName = "componentWillReceiveProps";
+ } else if (typeof instance.UNSAFE_componentWillReceiveProps === "function") {
+ foundWillReceivePropsName = "UNSAFE_componentWillReceiveProps";
+ }
+
+ if (typeof instance.componentWillUpdate === "function" && instance.componentWillUpdate.__suppressDeprecationWarning !== true) {
+ foundWillUpdateName = "componentWillUpdate";
+ } else if (typeof instance.UNSAFE_componentWillUpdate === "function") {
+ foundWillUpdateName = "UNSAFE_componentWillUpdate";
+ }
+
+ if (foundWillMountName !== null || foundWillReceivePropsName !== null || foundWillUpdateName !== null) {
+ var _componentName = getComponentName(ctor) || "Component";
+
+ var newApiName = typeof ctor.getDerivedStateFromProps === "function" ? "getDerivedStateFromProps()" : "getSnapshotBeforeUpdate()";
+
+ if (!didWarnAboutLegacyLifecyclesAndDerivedState.has(_componentName)) {
+ didWarnAboutLegacyLifecyclesAndDerivedState.add(_componentName);
+ warningWithoutStack$1(false, "Unsafe legacy lifecycles will not be called for components using new component APIs.\n\n" + "%s uses %s but also contains the following legacy lifecycles:%s%s%s\n\n" + "The above lifecycles should be removed. Learn more about this warning here:\n" + "https://fb.me/react-async-component-lifecycle-hooks", _componentName, newApiName, foundWillMountName !== null ? "\n " + foundWillMountName : "", foundWillReceivePropsName !== null ? "\n " + foundWillReceivePropsName : "", foundWillUpdateName !== null ? "\n " + foundWillUpdateName : "");
+ }
+ }
+ }
+ }
+
+ if (isLegacyContextConsumer) {
+ cacheContext(workInProgress, unmaskedContext, context);
+ }
+
+ return instance;
+ }
+
+ function callComponentWillMount(workInProgress, instance) {
+ startPhaseTimer(workInProgress, "componentWillMount");
+ var oldState = instance.state;
+
+ if (typeof instance.componentWillMount === "function") {
+ instance.componentWillMount();
+ }
+
+ if (typeof instance.UNSAFE_componentWillMount === "function") {
+ instance.UNSAFE_componentWillMount();
+ }
+
+ stopPhaseTimer();
+
+ if (oldState !== instance.state) {
+ {
+ warningWithoutStack$1(false, "%s.componentWillMount(): Assigning directly to this.state is " + "deprecated (except inside a component's " + "constructor). Use setState instead.", getComponentName(workInProgress.type) || "Component");
+ }
+ classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
+ }
+ }
+
+ function callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext) {
+ var oldState = instance.state;
+ startPhaseTimer(workInProgress, "componentWillReceiveProps");
+
+ if (typeof instance.componentWillReceiveProps === "function") {
+ instance.componentWillReceiveProps(newProps, nextContext);
+ }
+
+ if (typeof instance.UNSAFE_componentWillReceiveProps === "function") {
+ instance.UNSAFE_componentWillReceiveProps(newProps, nextContext);
+ }
+
+ stopPhaseTimer();
+
+ if (instance.state !== oldState) {
+ {
+ var componentName = getComponentName(workInProgress.type) || "Component";
+
+ if (!didWarnAboutStateAssignmentForComponent.has(componentName)) {
+ didWarnAboutStateAssignmentForComponent.add(componentName);
+ warningWithoutStack$1(false, "%s.componentWillReceiveProps(): Assigning directly to " + "this.state is deprecated (except inside a component's " + "constructor). Use setState instead.", componentName);
+ }
+ }
+ classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
+ }
+ }
+
+ function mountClassInstance(workInProgress, ctor, newProps, renderExpirationTime) {
+ {
+ checkClassInstance(workInProgress, ctor, newProps);
+ }
+ var instance = workInProgress.stateNode;
+ instance.props = newProps;
+ instance.state = workInProgress.memoizedState;
+ instance.refs = emptyRefsObject;
+ var contextType = ctor.contextType;
+
+ if (typeof contextType === "object" && contextType !== null) {
+ instance.context = _readContext(contextType);
+ } else {
+ var unmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
+ instance.context = getMaskedContext(workInProgress, unmaskedContext);
+ }
+
+ {
+ if (instance.state === newProps) {
+ var componentName = getComponentName(ctor) || "Component";
+
+ if (!didWarnAboutDirectlyAssigningPropsToState.has(componentName)) {
+ didWarnAboutDirectlyAssigningPropsToState.add(componentName);
+ warningWithoutStack$1(false, "%s: It is not recommended to assign props directly to state " + "because updates to props won't be reflected in state. " + "In most cases, it is better to use props directly.", componentName);
+ }
+ }
+
+ if (workInProgress.mode & StrictMode) {
+ ReactStrictModeWarnings.recordUnsafeLifecycleWarnings(workInProgress, instance);
+ ReactStrictModeWarnings.recordLegacyContextWarning(workInProgress, instance);
+ }
+
+ if (warnAboutDeprecatedLifecycles) {
+ ReactStrictModeWarnings.recordDeprecationWarnings(workInProgress, instance);
+ }
+ }
+ var updateQueue = workInProgress.updateQueue;
+
+ if (updateQueue !== null) {
+ processUpdateQueue(workInProgress, updateQueue, newProps, instance, renderExpirationTime);
+ instance.state = workInProgress.memoizedState;
+ }
+
+ var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+
+ if (typeof getDerivedStateFromProps === "function") {
+ applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, newProps);
+ instance.state = workInProgress.memoizedState;
+ }
+
+ if (typeof ctor.getDerivedStateFromProps !== "function" && typeof instance.getSnapshotBeforeUpdate !== "function" && (typeof instance.UNSAFE_componentWillMount === "function" || typeof instance.componentWillMount === "function")) {
+ callComponentWillMount(workInProgress, instance);
+ updateQueue = workInProgress.updateQueue;
+
+ if (updateQueue !== null) {
+ processUpdateQueue(workInProgress, updateQueue, newProps, instance, renderExpirationTime);
+ instance.state = workInProgress.memoizedState;
+ }
+ }
+
+ if (typeof instance.componentDidMount === "function") {
+ workInProgress.effectTag |= Update;
+ }
+ }
+
+ function resumeMountClassInstance(workInProgress, ctor, newProps, renderExpirationTime) {
+ var instance = workInProgress.stateNode;
+ var oldProps = workInProgress.memoizedProps;
+ instance.props = oldProps;
+ var oldContext = instance.context;
+ var contextType = ctor.contextType;
+ var nextContext = void 0;
+
+ if (typeof contextType === "object" && contextType !== null) {
+ nextContext = _readContext(contextType);
+ } else {
+ var nextLegacyUnmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
+ nextContext = getMaskedContext(workInProgress, nextLegacyUnmaskedContext);
+ }
+
+ var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+ var hasNewLifecycles = typeof getDerivedStateFromProps === "function" || typeof instance.getSnapshotBeforeUpdate === "function";
+
+ if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillReceiveProps === "function" || typeof instance.componentWillReceiveProps === "function")) {
+ if (oldProps !== newProps || oldContext !== nextContext) {
+ callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext);
+ }
+ }
+
+ resetHasForceUpdateBeforeProcessing();
+ var oldState = workInProgress.memoizedState;
+ var newState = instance.state = oldState;
+ var updateQueue = workInProgress.updateQueue;
+
+ if (updateQueue !== null) {
+ processUpdateQueue(workInProgress, updateQueue, newProps, instance, renderExpirationTime);
+ newState = workInProgress.memoizedState;
+ }
+
+ if (oldProps === newProps && oldState === newState && !hasContextChanged() && !checkHasForceUpdateAfterProcessing()) {
+ if (typeof instance.componentDidMount === "function") {
+ workInProgress.effectTag |= Update;
+ }
+
+ return false;
+ }
+
+ if (typeof getDerivedStateFromProps === "function") {
+ applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, newProps);
+ newState = workInProgress.memoizedState;
+ }
+
+ var shouldUpdate = checkHasForceUpdateAfterProcessing() || checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext);
+
+ if (shouldUpdate) {
+ if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillMount === "function" || typeof instance.componentWillMount === "function")) {
+ startPhaseTimer(workInProgress, "componentWillMount");
+
+ if (typeof instance.componentWillMount === "function") {
+ instance.componentWillMount();
+ }
+
+ if (typeof instance.UNSAFE_componentWillMount === "function") {
+ instance.UNSAFE_componentWillMount();
+ }
+
+ stopPhaseTimer();
+ }
+
+ if (typeof instance.componentDidMount === "function") {
+ workInProgress.effectTag |= Update;
+ }
+ } else {
+ if (typeof instance.componentDidMount === "function") {
+ workInProgress.effectTag |= Update;
+ }
+
+ workInProgress.memoizedProps = newProps;
+ workInProgress.memoizedState = newState;
+ }
+
+ instance.props = newProps;
+ instance.state = newState;
+ instance.context = nextContext;
+ return shouldUpdate;
+ }
+
+ function updateClassInstance(current, workInProgress, ctor, newProps, renderExpirationTime) {
+ var instance = workInProgress.stateNode;
+ var oldProps = workInProgress.memoizedProps;
+ instance.props = workInProgress.type === workInProgress.elementType ? oldProps : resolveDefaultProps(workInProgress.type, oldProps);
+ var oldContext = instance.context;
+ var contextType = ctor.contextType;
+ var nextContext = void 0;
+
+ if (typeof contextType === "object" && contextType !== null) {
+ nextContext = _readContext(contextType);
+ } else {
+ var nextUnmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
+ nextContext = getMaskedContext(workInProgress, nextUnmaskedContext);
+ }
+
+ var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+ var hasNewLifecycles = typeof getDerivedStateFromProps === "function" || typeof instance.getSnapshotBeforeUpdate === "function";
+
+ if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillReceiveProps === "function" || typeof instance.componentWillReceiveProps === "function")) {
+ if (oldProps !== newProps || oldContext !== nextContext) {
+ callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext);
+ }
+ }
+
+ resetHasForceUpdateBeforeProcessing();
+ var oldState = workInProgress.memoizedState;
+ var newState = instance.state = oldState;
+ var updateQueue = workInProgress.updateQueue;
+
+ if (updateQueue !== null) {
+ processUpdateQueue(workInProgress, updateQueue, newProps, instance, renderExpirationTime);
+ newState = workInProgress.memoizedState;
+ }
+
+ if (oldProps === newProps && oldState === newState && !hasContextChanged() && !checkHasForceUpdateAfterProcessing()) {
+ if (typeof instance.componentDidUpdate === "function") {
+ if (oldProps !== current.memoizedProps || oldState !== current.memoizedState) {
+ workInProgress.effectTag |= Update;
+ }
+ }
+
+ if (typeof instance.getSnapshotBeforeUpdate === "function") {
+ if (oldProps !== current.memoizedProps || oldState !== current.memoizedState) {
+ workInProgress.effectTag |= Snapshot;
+ }
+ }
+
+ return false;
+ }
+
+ if (typeof getDerivedStateFromProps === "function") {
+ applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, newProps);
+ newState = workInProgress.memoizedState;
+ }
+
+ var shouldUpdate = checkHasForceUpdateAfterProcessing() || checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext);
+
+ if (shouldUpdate) {
+ if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillUpdate === "function" || typeof instance.componentWillUpdate === "function")) {
+ startPhaseTimer(workInProgress, "componentWillUpdate");
+
+ if (typeof instance.componentWillUpdate === "function") {
+ instance.componentWillUpdate(newProps, newState, nextContext);
+ }
+
+ if (typeof instance.UNSAFE_componentWillUpdate === "function") {
+ instance.UNSAFE_componentWillUpdate(newProps, newState, nextContext);
+ }
+
+ stopPhaseTimer();
+ }
+
+ if (typeof instance.componentDidUpdate === "function") {
+ workInProgress.effectTag |= Update;
+ }
+
+ if (typeof instance.getSnapshotBeforeUpdate === "function") {
+ workInProgress.effectTag |= Snapshot;
+ }
+ } else {
+ if (typeof instance.componentDidUpdate === "function") {
+ if (oldProps !== current.memoizedProps || oldState !== current.memoizedState) {
+ workInProgress.effectTag |= Update;
+ }
+ }
+
+ if (typeof instance.getSnapshotBeforeUpdate === "function") {
+ if (oldProps !== current.memoizedProps || oldState !== current.memoizedState) {
+ workInProgress.effectTag |= Snapshot;
+ }
+ }
+
+ workInProgress.memoizedProps = newProps;
+ workInProgress.memoizedState = newState;
+ }
+
+ instance.props = newProps;
+ instance.state = newState;
+ instance.context = nextContext;
+ return shouldUpdate;
+ }
+
+ var didWarnAboutMaps = void 0;
+ var didWarnAboutGenerators = void 0;
+ var didWarnAboutStringRefInStrictMode = void 0;
+ var ownerHasKeyUseWarning = void 0;
+ var ownerHasFunctionTypeWarning = void 0;
+
+ var warnForMissingKey = function warnForMissingKey(child) {};
+
+ {
+ didWarnAboutMaps = false;
+ didWarnAboutGenerators = 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 a list should have a unique " + '"key" prop. See https://fb.me/react-warning-keys for ' + "more information." + getCurrentFiberStackInDev();
+
+ if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {
+ return;
+ }
+
+ ownerHasKeyUseWarning[currentComponentErrorInfo] = true;
+ warning$1(false, "Each child in a list should have a unique " + '"key" prop. See https://fb.me/react-warning-keys for ' + "more information.");
+ };
+ }
+ var isArray = Array.isArray;
+
+ function coerceRef(returnFiber, current$$1, element) {
+ var mixedRef = element.ref;
+
+ if (mixedRef !== null && typeof mixedRef !== "function" && typeof mixedRef !== "object") {
+ {
+ if (returnFiber.mode & StrictMode) {
+ var componentName = getComponentName(returnFiber.type) || "Component";
+
+ if (!didWarnAboutStringRefInStrictMode[componentName]) {
+ warningWithoutStack$1(false, 'A string ref, "%s", has been found within a strict mode tree. ' + "String refs are a source of potential bugs and should be avoided. " + "We recommend using createRef() instead." + "\n%s" + "\n\nLearn more about using refs safely here:" + "\nhttps://fb.me/react-strict-mode-string-ref", mixedRef, getStackByFiberInDevAndProd(returnFiber));
+ didWarnAboutStringRefInStrictMode[componentName] = true;
+ }
+ }
+ }
+
+ if (element._owner) {
+ var owner = element._owner;
+ var inst = void 0;
+
+ if (owner) {
+ var ownerFiber = owner;
+ invariant(ownerFiber.tag === ClassComponent, "Function components cannot have refs. " + "Did you mean to use React.forwardRef()?");
+ 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$$1 !== null && current$$1.ref !== null && typeof current$$1.ref === "function" && current$$1.ref._stringRef === stringRef) {
+ return current$$1.ref;
+ }
+
+ var ref = function ref(value) {
+ var refs = inst.refs;
+
+ if (refs === emptyRefsObject) {
+ refs = inst.refs = {};
+ }
+
+ if (value === null) {
+ delete refs[stringRef];
+ } else {
+ refs[stringRef] = value;
+ }
+ };
+
+ ref._stringRef = stringRef;
+ return ref;
+ } else {
+ invariant(typeof mixedRef === "string", "Expected ref to be a function, a string, an object returned by React.createRef(), or null.");
+ 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 function 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." + getCurrentFiberStackInDev();
+ }
+ 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 from render. " + "Or maybe you meant to call this function rather than return it." + getCurrentFiberStackInDev();
+
+ if (ownerHasFunctionTypeWarning[currentComponentErrorInfo]) {
+ return;
+ }
+
+ ownerHasFunctionTypeWarning[currentComponentErrorInfo] = true;
+ warning$1(false, "Functions are not valid as a React child. This may happen if " + "you return a Component instead of from render. " + "Or maybe you meant to call this function rather than return it.");
+ }
+
+ function ChildReconciler(shouldTrackSideEffects) {
+ function deleteChild(returnFiber, childToDelete) {
+ if (!shouldTrackSideEffects) {
+ return;
+ }
+
+ var last = returnFiber.lastEffect;
+
+ if (last !== null) {
+ last.nextEffect = childToDelete;
+ returnFiber.lastEffect = childToDelete;
+ } else {
+ returnFiber.firstEffect = returnFiber.lastEffect = childToDelete;
+ }
+
+ childToDelete.nextEffect = null;
+ childToDelete.effectTag = Deletion;
+ }
+
+ function deleteRemainingChildren(returnFiber, currentFirstChild) {
+ if (!shouldTrackSideEffects) {
+ return null;
+ }
+
+ var childToDelete = currentFirstChild;
+
+ while (childToDelete !== null) {
+ deleteChild(returnFiber, childToDelete);
+ childToDelete = childToDelete.sibling;
+ }
+
+ return null;
+ }
+
+ function mapRemainingChildren(returnFiber, currentFirstChild) {
+ var existingChildren = new Map();
+ var existingChild = currentFirstChild;
+
+ while (existingChild !== null) {
+ if (existingChild.key !== null) {
+ existingChildren.set(existingChild.key, existingChild);
+ } else {
+ existingChildren.set(existingChild.index, existingChild);
+ }
+
+ existingChild = existingChild.sibling;
+ }
+
+ return existingChildren;
+ }
+
+ function useFiber(fiber, pendingProps, expirationTime) {
+ var clone = createWorkInProgress(fiber, pendingProps, expirationTime);
+ clone.index = 0;
+ clone.sibling = null;
+ return clone;
+ }
+
+ function placeChild(newFiber, lastPlacedIndex, newIndex) {
+ newFiber.index = newIndex;
+
+ if (!shouldTrackSideEffects) {
+ return lastPlacedIndex;
+ }
+
+ var current$$1 = newFiber.alternate;
+
+ if (current$$1 !== null) {
+ var oldIndex = current$$1.index;
+
+ if (oldIndex < lastPlacedIndex) {
+ newFiber.effectTag = Placement;
+ return lastPlacedIndex;
+ } else {
+ return oldIndex;
+ }
+ } else {
+ newFiber.effectTag = Placement;
+ return lastPlacedIndex;
+ }
+ }
+
+ function placeSingleChild(newFiber) {
+ if (shouldTrackSideEffects && newFiber.alternate === null) {
+ newFiber.effectTag = Placement;
+ }
+
+ return newFiber;
+ }
+
+ function updateTextNode(returnFiber, current$$1, textContent, expirationTime) {
+ if (current$$1 === null || current$$1.tag !== HostText) {
+ var created = createFiberFromText(textContent, returnFiber.mode, expirationTime);
+ created.return = returnFiber;
+ return created;
+ } else {
+ var existing = useFiber(current$$1, textContent, expirationTime);
+ existing.return = returnFiber;
+ return existing;
+ }
+ }
+
+ function updateElement(returnFiber, current$$1, element, expirationTime) {
+ if (current$$1 !== null && current$$1.elementType === element.type) {
+ var existing = useFiber(current$$1, element.props, expirationTime);
+ existing.ref = coerceRef(returnFiber, current$$1, element);
+ existing.return = returnFiber;
+ {
+ existing._debugSource = element._source;
+ existing._debugOwner = element._owner;
+ }
+ return existing;
+ } else {
+ var created = createFiberFromElement(element, returnFiber.mode, expirationTime);
+ created.ref = coerceRef(returnFiber, current$$1, element);
+ created.return = returnFiber;
+ return created;
+ }
+ }
+
+ function updatePortal(returnFiber, current$$1, portal, expirationTime) {
+ if (current$$1 === null || current$$1.tag !== HostPortal || current$$1.stateNode.containerInfo !== portal.containerInfo || current$$1.stateNode.implementation !== portal.implementation) {
+ var created = createFiberFromPortal(portal, returnFiber.mode, expirationTime);
+ created.return = returnFiber;
+ return created;
+ } else {
+ var existing = useFiber(current$$1, portal.children || [], expirationTime);
+ existing.return = returnFiber;
+ return existing;
+ }
+ }
+
+ function updateFragment(returnFiber, current$$1, fragment, expirationTime, key) {
+ if (current$$1 === null || current$$1.tag !== Fragment) {
+ var created = createFiberFromFragment(fragment, returnFiber.mode, expirationTime, key);
+ created.return = returnFiber;
+ return created;
+ } else {
+ var existing = useFiber(current$$1, fragment, expirationTime);
+ existing.return = returnFiber;
+ return existing;
+ }
+ }
+
+ function createChild(returnFiber, newChild, expirationTime) {
+ if (typeof newChild === "string" || typeof newChild === "number") {
+ var created = createFiberFromText("" + newChild, returnFiber.mode, expirationTime);
+ created.return = returnFiber;
+ return created;
+ }
+
+ if (typeof newChild === "object" && newChild !== null) {
+ switch (newChild.$$typeof) {
+ case REACT_ELEMENT_TYPE:
+ {
+ var _created = createFiberFromElement(newChild, returnFiber.mode, expirationTime);
+
+ _created.ref = coerceRef(returnFiber, null, newChild);
+ _created.return = returnFiber;
+ return _created;
+ }
+
+ case REACT_PORTAL_TYPE:
+ {
+ var _created2 = createFiberFromPortal(newChild, returnFiber.mode, expirationTime);
+
+ _created2.return = returnFiber;
+ return _created2;
+ }
+ }
+
+ if (isArray(newChild) || getIteratorFn(newChild)) {
+ var _created3 = createFiberFromFragment(newChild, returnFiber.mode, expirationTime, null);
+
+ _created3.return = returnFiber;
+ return _created3;
+ }
+
+ throwOnInvalidObjectType(returnFiber, newChild);
+ }
+
+ {
+ if (typeof newChild === "function") {
+ warnOnFunctionType();
+ }
+ }
+ return null;
+ }
+
+ function updateSlot(returnFiber, oldFiber, newChild, expirationTime) {
+ var key = oldFiber !== null ? oldFiber.key : null;
+
+ if (typeof newChild === "string" || typeof newChild === "number") {
+ if (key !== null) {
+ return null;
+ }
+
+ return updateTextNode(returnFiber, oldFiber, "" + newChild, expirationTime);
+ }
+
+ if (typeof newChild === "object" && newChild !== null) {
+ switch (newChild.$$typeof) {
+ case REACT_ELEMENT_TYPE:
+ {
+ if (newChild.key === key) {
+ if (newChild.type === REACT_FRAGMENT_TYPE) {
+ return updateFragment(returnFiber, oldFiber, newChild.props.children, expirationTime, key);
+ }
+
+ return updateElement(returnFiber, oldFiber, newChild, expirationTime);
+ } else {
+ return null;
+ }
+ }
+
+ case REACT_PORTAL_TYPE:
+ {
+ if (newChild.key === key) {
+ return updatePortal(returnFiber, oldFiber, newChild, expirationTime);
+ } else {
+ return null;
+ }
+ }
+ }
+
+ if (isArray(newChild) || getIteratorFn(newChild)) {
+ if (key !== null) {
+ return null;
+ }
+
+ return updateFragment(returnFiber, oldFiber, newChild, expirationTime, null);
+ }
+
+ throwOnInvalidObjectType(returnFiber, newChild);
+ }
+
+ {
+ if (typeof newChild === "function") {
+ warnOnFunctionType();
+ }
+ }
+ return null;
+ }
+
+ function updateFromMap(existingChildren, returnFiber, newIdx, newChild, expirationTime) {
+ if (typeof newChild === "string" || typeof newChild === "number") {
+ var matchedFiber = existingChildren.get(newIdx) || null;
+ return updateTextNode(returnFiber, matchedFiber, "" + newChild, expirationTime);
+ }
+
+ if (typeof newChild === "object" && newChild !== null) {
+ switch (newChild.$$typeof) {
+ case REACT_ELEMENT_TYPE:
+ {
+ var _matchedFiber = existingChildren.get(newChild.key === null ? newIdx : newChild.key) || null;
+
+ if (newChild.type === REACT_FRAGMENT_TYPE) {
+ return updateFragment(returnFiber, _matchedFiber, newChild.props.children, expirationTime, newChild.key);
+ }
+
+ return updateElement(returnFiber, _matchedFiber, newChild, expirationTime);
+ }
+
+ case REACT_PORTAL_TYPE:
+ {
+ var _matchedFiber2 = existingChildren.get(newChild.key === null ? newIdx : newChild.key) || null;
+
+ return updatePortal(returnFiber, _matchedFiber2, newChild, expirationTime);
+ }
+ }
+
+ if (isArray(newChild) || getIteratorFn(newChild)) {
+ var _matchedFiber3 = existingChildren.get(newIdx) || null;
+
+ return updateFragment(returnFiber, _matchedFiber3, newChild, expirationTime, null);
+ }
+
+ throwOnInvalidObjectType(returnFiber, newChild);
+ }
+
+ {
+ if (typeof newChild === "function") {
+ warnOnFunctionType();
+ }
+ }
+ return null;
+ }
+
+ function warnOnInvalidKey(child, knownKeys) {
+ {
+ if (typeof child !== "object" || child === null) {
+ return knownKeys;
+ }
+
+ switch (child.$$typeof) {
+ case REACT_ELEMENT_TYPE:
+ case REACT_PORTAL_TYPE:
+ warnForMissingKey(child);
+ var key = child.key;
+
+ if (typeof key !== "string") {
+ break;
+ }
+
+ if (knownKeys === null) {
+ knownKeys = new Set();
+ knownKeys.add(key);
+ break;
+ }
+
+ if (!knownKeys.has(key)) {
+ knownKeys.add(key);
+ break;
+ }
+
+ warning$1(false, "Encountered two children with the same key, `%s`. " + "Keys should be unique so that components maintain their identity " + "across updates. Non-unique keys may cause children to be " + "duplicated and/or omitted — the behavior is unsupported and " + "could change in a future version.", key);
+ break;
+
+ default:
+ break;
+ }
+ }
+ return knownKeys;
+ }
+
+ function reconcileChildrenArray(returnFiber, currentFirstChild, newChildren, expirationTime) {
+ {
+ var knownKeys = null;
+
+ for (var i = 0; i < newChildren.length; i++) {
+ var child = newChildren[i];
+ knownKeys = warnOnInvalidKey(child, knownKeys);
+ }
+ }
+ var resultingFirstChild = null;
+ var previousNewFiber = null;
+ var oldFiber = currentFirstChild;
+ var lastPlacedIndex = 0;
+ var newIdx = 0;
+ var nextOldFiber = null;
+
+ for (; oldFiber !== null && newIdx < newChildren.length; newIdx++) {
+ if (oldFiber.index > newIdx) {
+ nextOldFiber = oldFiber;
+ oldFiber = null;
+ } else {
+ nextOldFiber = oldFiber.sibling;
+ }
+
+ var newFiber = updateSlot(returnFiber, oldFiber, newChildren[newIdx], expirationTime);
+
+ if (newFiber === null) {
+ if (oldFiber === null) {
+ oldFiber = nextOldFiber;
+ }
+
+ break;
+ }
+
+ if (shouldTrackSideEffects) {
+ if (oldFiber && newFiber.alternate === null) {
+ deleteChild(returnFiber, oldFiber);
+ }
+ }
+
+ lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
+
+ if (previousNewFiber === null) {
+ resultingFirstChild = newFiber;
+ } else {
+ previousNewFiber.sibling = newFiber;
+ }
+
+ previousNewFiber = newFiber;
+ oldFiber = nextOldFiber;
+ }
+
+ if (newIdx === newChildren.length) {
+ deleteRemainingChildren(returnFiber, oldFiber);
+ return resultingFirstChild;
+ }
+
+ if (oldFiber === null) {
+ for (; newIdx < newChildren.length; newIdx++) {
+ var _newFiber = createChild(returnFiber, newChildren[newIdx], expirationTime);
+
+ if (!_newFiber) {
+ 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 (typeof Symbol === "function" && newChildrenIterable[typeof Symbol === "function" ? Symbol.toStringTag : "@@toStringTag"] === "Generator") {
+ !didWarnAboutGenerators ? warning$1(false, "Using Generators as children is unsupported and will likely yield " + "unexpected results because enumerating a generator mutates it. " + "You may convert it to an array with `Array.from()` or the " + "`[...spread]` operator before rendering. Keep in mind " + "you might need to polyfill these features for older browsers.") : void 0;
+ didWarnAboutGenerators = true;
+ }
+
+ if (newChildrenIterable.entries === iteratorFn) {
+ !didWarnAboutMaps ? warning$1(false, "Using Maps as children is unsupported and will likely yield " + "unexpected results. Convert it to a sequence/iterable of keyed " + "ReactElements instead.") : void 0;
+ didWarnAboutMaps = true;
+ }
+
+ var _newChildren = iteratorFn.call(newChildrenIterable);
+
+ if (_newChildren) {
+ var knownKeys = null;
+
+ var _step = _newChildren.next();
+
+ for (; !_step.done; _step = _newChildren.next()) {
+ var child = _step.value;
+ knownKeys = warnOnInvalidKey(child, knownKeys);
+ }
+ }
+ }
+ var newChildren = iteratorFn.call(newChildrenIterable);
+ 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.elementType === 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(newChild)) {
+ return reconcileChildrenArray(returnFiber, currentFirstChild, newChild, expirationTime);
+ }
+
+ if (getIteratorFn(newChild)) {
+ return reconcileChildrenIterator(returnFiber, currentFirstChild, newChild, expirationTime);
+ }
+
+ if (isObject) {
+ throwOnInvalidObjectType(returnFiber, newChild);
+ }
+
+ {
+ if (typeof newChild === "function") {
+ warnOnFunctionType();
+ }
+ }
+
+ if (typeof newChild === "undefined" && !isUnkeyedTopLevelFragment) {
+ switch (returnFiber.tag) {
+ case ClassComponent:
+ {
+ {
+ var instance = returnFiber.stateNode;
+
+ if (instance.render._isMockFunction) {
+ break;
+ }
+ }
+ }
+
+ case FunctionComponent:
+ {
+ var Component = returnFiber.type;
+ 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$$1, workInProgress) {
+ invariant(current$$1 === null || workInProgress.child === current$$1.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 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 NoEffect$1 = 0;
+ var UnmountSnapshot = 2;
+ var UnmountMutation = 4;
+ var MountMutation = 8;
+ var UnmountLayout = 16;
+ var MountLayout = 32;
+ var MountPassive = 64;
+ var UnmountPassive = 128;
+ var ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher;
+ var didWarnAboutMismatchedHooksForComponent = void 0;
+ {
+ didWarnAboutMismatchedHooksForComponent = new Set();
+ }
+ var renderExpirationTime = NoWork;
+ var currentlyRenderingFiber$1 = null;
+ var firstCurrentHook = null;
+ var currentHook = null;
+ var nextCurrentHook = null;
+ var firstWorkInProgressHook = null;
+ var workInProgressHook = null;
+ var nextWorkInProgressHook = null;
+ var remainingExpirationTime = NoWork;
+ var componentUpdateQueue = null;
+ var sideEffectTag = 0;
+ var didScheduleRenderPhaseUpdate = false;
+ var renderPhaseUpdates = null;
+ var numberOfReRenders = 0;
+ var RE_RENDER_LIMIT = 25;
+ var currentHookNameInDev = null;
+
+ function warnOnHookMismatchInDev() {
+ {
+ var componentName = getComponentName(currentlyRenderingFiber$1.type);
+
+ if (!didWarnAboutMismatchedHooksForComponent.has(componentName)) {
+ didWarnAboutMismatchedHooksForComponent.add(componentName);
+ var secondColumnStart = 22;
+ var table = "";
+ var prevHook = firstCurrentHook;
+ var nextHook = firstWorkInProgressHook;
+ var n = 1;
+
+ while (prevHook !== null && nextHook !== null) {
+ var oldHookName = prevHook._debugType;
+ var newHookName = nextHook._debugType;
+ var row = n + ". " + oldHookName;
+
+ while (row.length < secondColumnStart) {
+ row += " ";
+ }
+
+ row += newHookName + "\n";
+ table += row;
+ prevHook = prevHook.next;
+ nextHook = nextHook.next;
+ n++;
+ }
+
+ warning$1(false, "React has detected a change in the order of Hooks called by %s. " + "This will lead to bugs and errors if not fixed. " + "For more information, read the Rules of Hooks: https://fb.me/rules-of-hooks\n\n" + " Previous render Next render\n" + " -------------------------------\n" + "%s" + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", componentName, table);
+ }
+ }
+ }
+
+ function throwInvalidHookError() {
+ invariant(false, "Hooks can only be called inside the body of a function component. " + "(https://fb.me/react-invalid-hook-call)");
+ }
+
+ function areHookInputsEqual(nextDeps, prevDeps) {
+ if (prevDeps === null) {
+ {
+ warning$1(false, "%s received a final argument during this render, but not during " + "the previous render. Even though the final argument is optional, " + "its type cannot change between renders.", currentHookNameInDev);
+ }
+ return false;
+ }
+
+ {
+ if (nextDeps.length !== prevDeps.length) {
+ warning$1(false, "The final argument passed to %s changed size between renders. The " + "order and size of this array must remain constant.\n\n" + "Previous: %s\n" + "Incoming: %s", currentHookNameInDev, "[" + nextDeps.join(", ") + "]", "[" + prevDeps.join(", ") + "]");
+ }
+ }
+
+ for (var i = 0; i < prevDeps.length && i < nextDeps.length; i++) {
+ if (is(nextDeps[i], prevDeps[i])) {
+ continue;
+ }
+
+ return false;
+ }
+
+ return true;
+ }
+
+ function renderWithHooks(current, workInProgress, Component, props, refOrContext, nextRenderExpirationTime) {
+ renderExpirationTime = nextRenderExpirationTime;
+ currentlyRenderingFiber$1 = workInProgress;
+ firstCurrentHook = nextCurrentHook = current !== null ? current.memoizedState : null;
+ {
+ ReactCurrentDispatcher$1.current = nextCurrentHook === null ? HooksDispatcherOnMountInDEV : HooksDispatcherOnUpdateInDEV;
+ }
+ var children = Component(props, refOrContext);
+
+ if (didScheduleRenderPhaseUpdate) {
+ do {
+ didScheduleRenderPhaseUpdate = false;
+ numberOfReRenders += 1;
+ firstCurrentHook = nextCurrentHook = current !== null ? current.memoizedState : null;
+ nextWorkInProgressHook = firstWorkInProgressHook;
+ currentHook = null;
+ workInProgressHook = null;
+ componentUpdateQueue = null;
+ ReactCurrentDispatcher$1.current = HooksDispatcherOnUpdateInDEV;
+ children = Component(props, refOrContext);
+ } while (didScheduleRenderPhaseUpdate);
+
+ renderPhaseUpdates = null;
+ numberOfReRenders = 0;
+ }
+
+ {
+ currentHookNameInDev = null;
+ }
+ ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
+ var renderedWork = currentlyRenderingFiber$1;
+ renderedWork.memoizedState = firstWorkInProgressHook;
+ renderedWork.expirationTime = remainingExpirationTime;
+ renderedWork.updateQueue = componentUpdateQueue;
+ renderedWork.effectTag |= sideEffectTag;
+ var didRenderTooFewHooks = currentHook !== null && currentHook.next !== null;
+ renderExpirationTime = NoWork;
+ currentlyRenderingFiber$1 = null;
+ firstCurrentHook = null;
+ currentHook = null;
+ nextCurrentHook = null;
+ firstWorkInProgressHook = null;
+ workInProgressHook = null;
+ nextWorkInProgressHook = null;
+ remainingExpirationTime = NoWork;
+ componentUpdateQueue = null;
+ sideEffectTag = 0;
+ invariant(!didRenderTooFewHooks, "Rendered fewer hooks than expected. This may be caused by an accidental " + "early return statement.");
+ return children;
+ }
+
+ function bailoutHooks(current, workInProgress, expirationTime) {
+ workInProgress.updateQueue = current.updateQueue;
+ workInProgress.effectTag &= ~(Passive | Update);
+
+ if (current.expirationTime <= expirationTime) {
+ current.expirationTime = NoWork;
+ }
+ }
+
+ function resetHooks() {
+ ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
+ renderExpirationTime = NoWork;
+ currentlyRenderingFiber$1 = null;
+ firstCurrentHook = null;
+ currentHook = null;
+ nextCurrentHook = null;
+ firstWorkInProgressHook = null;
+ workInProgressHook = null;
+ nextWorkInProgressHook = null;
+ remainingExpirationTime = NoWork;
+ componentUpdateQueue = null;
+ sideEffectTag = 0;
+ {
+ currentHookNameInDev = null;
+ }
+ didScheduleRenderPhaseUpdate = false;
+ renderPhaseUpdates = null;
+ numberOfReRenders = 0;
+ }
+
+ function mountWorkInProgressHook() {
+ var hook = {
+ memoizedState: null,
+ baseState: null,
+ queue: null,
+ baseUpdate: null,
+ next: null
+ };
+ {
+ hook._debugType = currentHookNameInDev;
+ }
+
+ if (workInProgressHook === null) {
+ firstWorkInProgressHook = workInProgressHook = hook;
+ } else {
+ workInProgressHook = workInProgressHook.next = hook;
+ }
+
+ return workInProgressHook;
+ }
+
+ function updateWorkInProgressHook() {
+ if (nextWorkInProgressHook !== null) {
+ workInProgressHook = nextWorkInProgressHook;
+ nextWorkInProgressHook = workInProgressHook.next;
+ currentHook = nextCurrentHook;
+ nextCurrentHook = currentHook !== null ? currentHook.next : null;
+ } else {
+ invariant(nextCurrentHook !== null, "Rendered more hooks than during the previous render.");
+ currentHook = nextCurrentHook;
+ var newHook = {
+ memoizedState: currentHook.memoizedState,
+ baseState: currentHook.baseState,
+ queue: currentHook.queue,
+ baseUpdate: currentHook.baseUpdate,
+ next: null
+ };
+
+ if (workInProgressHook === null) {
+ workInProgressHook = firstWorkInProgressHook = newHook;
+ } else {
+ workInProgressHook = workInProgressHook.next = newHook;
+ }
+
+ nextCurrentHook = currentHook.next;
+ {
+ newHook._debugType = currentHookNameInDev;
+
+ if (currentHookNameInDev !== currentHook._debugType) {
+ warnOnHookMismatchInDev();
+ }
+ }
+ }
+
+ return workInProgressHook;
+ }
+
+ function createFunctionComponentUpdateQueue() {
+ return {
+ lastEffect: null
+ };
+ }
+
+ function basicStateReducer(state, action) {
+ return typeof action === "function" ? action(state) : action;
+ }
+
+ function mountContext(context, observedBits) {
+ {
+ mountWorkInProgressHook();
+ }
+ return _readContext(context, observedBits);
+ }
+
+ function updateContext(context, observedBits) {
+ {
+ updateWorkInProgressHook();
+ }
+ return _readContext(context, observedBits);
+ }
+
+ function mountReducer(reducer, initialArg, init) {
+ var hook = mountWorkInProgressHook();
+ var initialState = void 0;
+
+ if (init !== undefined) {
+ initialState = init(initialArg);
+ } else {
+ initialState = initialArg;
+ }
+
+ hook.memoizedState = hook.baseState = initialState;
+ var queue = hook.queue = {
+ last: null,
+ dispatch: null,
+ eagerReducer: reducer,
+ eagerState: initialState
+ };
+ var dispatch = queue.dispatch = dispatchAction.bind(null, currentlyRenderingFiber$1, queue);
+ return [hook.memoizedState, dispatch];
+ }
+
+ function updateReducer(reducer, initialArg, init) {
+ var hook = updateWorkInProgressHook();
+ var queue = hook.queue;
+ invariant(queue !== null, "Should have a queue. This is likely a bug in React. Please file an issue.");
+
+ if (numberOfReRenders > 0) {
+ var _dispatch = queue.dispatch;
+
+ if (renderPhaseUpdates !== null) {
+ var firstRenderPhaseUpdate = renderPhaseUpdates.get(queue);
+
+ if (firstRenderPhaseUpdate !== undefined) {
+ renderPhaseUpdates.delete(queue);
+ var newState = hook.memoizedState;
+ var update = firstRenderPhaseUpdate;
+
+ do {
+ var _action = update.action;
+ newState = reducer(newState, _action);
+ update = update.next;
+ } while (update !== null);
+
+ if (!is(newState, hook.memoizedState)) {
+ markWorkInProgressReceivedUpdate();
+ }
+
+ hook.memoizedState = newState;
+
+ if (hook.baseUpdate === queue.last) {
+ hook.baseState = newState;
+ }
+
+ queue.eagerReducer = reducer;
+ queue.eagerState = newState;
+ return [newState, _dispatch];
+ }
+ }
+
+ return [hook.memoizedState, _dispatch];
+ }
+
+ var last = queue.last;
+ var baseUpdate = hook.baseUpdate;
+ var baseState = hook.baseState;
+ var first = void 0;
+
+ if (baseUpdate !== null) {
+ if (last !== null) {
+ last.next = null;
+ }
+
+ first = baseUpdate.next;
+ } else {
+ first = last !== null ? last.next : null;
+ }
+
+ if (first !== null) {
+ var _newState = baseState;
+ var newBaseState = null;
+ var newBaseUpdate = null;
+ var prevUpdate = baseUpdate;
+ var _update = first;
+ var didSkip = false;
+
+ do {
+ var updateExpirationTime = _update.expirationTime;
+
+ if (updateExpirationTime < renderExpirationTime) {
+ if (!didSkip) {
+ didSkip = true;
+ newBaseUpdate = prevUpdate;
+ newBaseState = _newState;
+ }
+
+ if (updateExpirationTime > remainingExpirationTime) {
+ remainingExpirationTime = updateExpirationTime;
+ }
+ } else {
+ if (_update.eagerReducer === reducer) {
+ _newState = _update.eagerState;
+ } else {
+ var _action2 = _update.action;
+ _newState = reducer(_newState, _action2);
+ }
+ }
+
+ prevUpdate = _update;
+ _update = _update.next;
+ } while (_update !== null && _update !== first);
+
+ if (!didSkip) {
+ newBaseUpdate = prevUpdate;
+ newBaseState = _newState;
+ }
+
+ if (!is(_newState, hook.memoizedState)) {
+ markWorkInProgressReceivedUpdate();
+ }
+
+ hook.memoizedState = _newState;
+ hook.baseUpdate = newBaseUpdate;
+ hook.baseState = newBaseState;
+ queue.eagerReducer = reducer;
+ queue.eagerState = _newState;
+ }
+
+ var dispatch = queue.dispatch;
+ return [hook.memoizedState, dispatch];
+ }
+
+ function mountState(initialState) {
+ var hook = mountWorkInProgressHook();
+
+ if (typeof initialState === "function") {
+ initialState = initialState();
+ }
+
+ hook.memoizedState = hook.baseState = initialState;
+ var queue = hook.queue = {
+ last: null,
+ dispatch: null,
+ eagerReducer: basicStateReducer,
+ eagerState: initialState
+ };
+ var dispatch = queue.dispatch = dispatchAction.bind(null, currentlyRenderingFiber$1, queue);
+ return [hook.memoizedState, dispatch];
+ }
+
+ function updateState(initialState) {
+ return updateReducer(basicStateReducer, initialState);
+ }
+
+ function pushEffect(tag, create, destroy, deps) {
+ var effect = {
+ tag: tag,
+ create: create,
+ destroy: destroy,
+ deps: deps,
+ next: null
+ };
+
+ if (componentUpdateQueue === null) {
+ componentUpdateQueue = createFunctionComponentUpdateQueue();
+ componentUpdateQueue.lastEffect = effect.next = effect;
+ } else {
+ var _lastEffect = componentUpdateQueue.lastEffect;
+
+ if (_lastEffect === null) {
+ componentUpdateQueue.lastEffect = effect.next = effect;
+ } else {
+ var firstEffect = _lastEffect.next;
+ _lastEffect.next = effect;
+ effect.next = firstEffect;
+ componentUpdateQueue.lastEffect = effect;
+ }
+ }
+
+ return effect;
+ }
+
+ function mountRef(initialValue) {
+ var hook = mountWorkInProgressHook();
+ var ref = {
+ current: initialValue
+ };
+ {
+ Object.seal(ref);
+ }
+ hook.memoizedState = ref;
+ return ref;
+ }
+
+ function updateRef(initialValue) {
+ var hook = updateWorkInProgressHook();
+ return hook.memoizedState;
+ }
+
+ function mountEffectImpl(fiberEffectTag, hookEffectTag, create, deps) {
+ var hook = mountWorkInProgressHook();
+ var nextDeps = deps === undefined ? null : deps;
+ sideEffectTag |= fiberEffectTag;
+ hook.memoizedState = pushEffect(hookEffectTag, create, undefined, nextDeps);
+ }
+
+ function updateEffectImpl(fiberEffectTag, hookEffectTag, create, deps) {
+ var hook = updateWorkInProgressHook();
+ var nextDeps = deps === undefined ? null : deps;
+ var destroy = undefined;
+
+ if (currentHook !== null) {
+ var prevEffect = currentHook.memoizedState;
+ destroy = prevEffect.destroy;
+
+ if (nextDeps !== null) {
+ var prevDeps = prevEffect.deps;
+
+ if (areHookInputsEqual(nextDeps, prevDeps)) {
+ pushEffect(NoEffect$1, create, destroy, nextDeps);
+ return;
+ }
+ }
+ }
+
+ sideEffectTag |= fiberEffectTag;
+ hook.memoizedState = pushEffect(hookEffectTag, create, destroy, nextDeps);
+ }
+
+ function mountEffect(create, deps) {
+ return mountEffectImpl(Update | Passive, UnmountPassive | MountPassive, create, deps);
+ }
+
+ function updateEffect(create, deps) {
+ return updateEffectImpl(Update | Passive, UnmountPassive | MountPassive, create, deps);
+ }
+
+ function mountLayoutEffect(create, deps) {
+ return mountEffectImpl(Update, UnmountMutation | MountLayout, create, deps);
+ }
+
+ function updateLayoutEffect(create, deps) {
+ return updateEffectImpl(Update, UnmountMutation | MountLayout, create, deps);
+ }
+
+ function imperativeHandleEffect(create, ref) {
+ if (typeof ref === "function") {
+ var refCallback = ref;
+
+ var _inst = create();
+
+ refCallback(_inst);
+ return function () {
+ refCallback(null);
+ };
+ } else if (ref !== null && ref !== undefined) {
+ var refObject = ref;
+ {
+ !refObject.hasOwnProperty("current") ? warning$1(false, "Expected useImperativeHandle() first argument to either be a " + "ref callback or React.createRef() object. Instead received: %s.", "an object with keys {" + Object.keys(refObject).join(", ") + "}") : void 0;
+ }
+
+ var _inst2 = create();
+
+ refObject.current = _inst2;
+ return function () {
+ refObject.current = null;
+ };
+ }
+ }
+
+ function mountImperativeHandle(ref, create, deps) {
+ {
+ !(typeof create === "function") ? warning$1(false, "Expected useImperativeHandle() second argument to be a function " + "that creates a handle. Instead received: %s.", create !== null ? typeof create : "null") : void 0;
+ }
+ var effectDeps = deps !== null && deps !== undefined ? deps.concat([ref]) : null;
+ return mountEffectImpl(Update, UnmountMutation | MountLayout, imperativeHandleEffect.bind(null, create, ref), effectDeps);
+ }
+
+ function updateImperativeHandle(ref, create, deps) {
+ {
+ !(typeof create === "function") ? warning$1(false, "Expected useImperativeHandle() second argument to be a function " + "that creates a handle. Instead received: %s.", create !== null ? typeof create : "null") : void 0;
+ }
+ var effectDeps = deps !== null && deps !== undefined ? deps.concat([ref]) : null;
+ return updateEffectImpl(Update, UnmountMutation | MountLayout, imperativeHandleEffect.bind(null, create, ref), effectDeps);
+ }
+
+ function mountDebugValue(value, formatterFn) {}
+
+ var updateDebugValue = mountDebugValue;
+
+ function mountCallback(callback, deps) {
+ var hook = mountWorkInProgressHook();
+ var nextDeps = deps === undefined ? null : deps;
+ hook.memoizedState = [callback, nextDeps];
+ return callback;
+ }
+
+ function updateCallback(callback, deps) {
+ var hook = updateWorkInProgressHook();
+ var nextDeps = deps === undefined ? null : deps;
+ var prevState = hook.memoizedState;
+
+ if (prevState !== null) {
+ if (nextDeps !== null) {
+ var prevDeps = prevState[1];
+
+ if (areHookInputsEqual(nextDeps, prevDeps)) {
+ return prevState[0];
+ }
+ }
+ }
+
+ hook.memoizedState = [callback, nextDeps];
+ return callback;
+ }
+
+ function mountMemo(nextCreate, deps) {
+ var hook = mountWorkInProgressHook();
+ var nextDeps = deps === undefined ? null : deps;
+ var nextValue = nextCreate();
+ hook.memoizedState = [nextValue, nextDeps];
+ return nextValue;
+ }
+
+ function updateMemo(nextCreate, deps) {
+ var hook = updateWorkInProgressHook();
+ var nextDeps = deps === undefined ? null : deps;
+ var prevState = hook.memoizedState;
+
+ if (prevState !== null) {
+ if (nextDeps !== null) {
+ var prevDeps = prevState[1];
+
+ if (areHookInputsEqual(nextDeps, prevDeps)) {
+ return prevState[0];
+ }
+ }
+ }
+
+ var nextValue = nextCreate();
+ hook.memoizedState = [nextValue, nextDeps];
+ return nextValue;
+ }
+
+ var shouldWarnForUnbatchedSetState = false;
+ {
+ if ("undefined" !== typeof jest) {
+ shouldWarnForUnbatchedSetState = true;
+ }
+ }
+
+ function dispatchAction(fiber, queue, action) {
+ invariant(numberOfReRenders < RE_RENDER_LIMIT, "Too many re-renders. React limits the number of renders to prevent " + "an infinite loop.");
+ {
+ !(arguments.length <= 3) ? warning$1(false, "State updates from the useState() and useReducer() Hooks don't support the " + "second callback argument. To execute a side effect after " + "rendering, declare it in the component body with useEffect().") : void 0;
+ }
+ var alternate = fiber.alternate;
+
+ if (fiber === currentlyRenderingFiber$1 || alternate !== null && alternate === currentlyRenderingFiber$1) {
+ didScheduleRenderPhaseUpdate = true;
+ var update = {
+ expirationTime: renderExpirationTime,
+ action: action,
+ eagerReducer: null,
+ eagerState: null,
+ next: null
+ };
+
+ if (renderPhaseUpdates === null) {
+ renderPhaseUpdates = new Map();
+ }
+
+ var firstRenderPhaseUpdate = renderPhaseUpdates.get(queue);
+
+ if (firstRenderPhaseUpdate === undefined) {
+ renderPhaseUpdates.set(queue, update);
+ } else {
+ var lastRenderPhaseUpdate = firstRenderPhaseUpdate;
+
+ while (lastRenderPhaseUpdate.next !== null) {
+ lastRenderPhaseUpdate = lastRenderPhaseUpdate.next;
+ }
+
+ lastRenderPhaseUpdate.next = update;
+ }
+ } else {
+ flushPassiveEffects();
+ var currentTime = requestCurrentTime();
+
+ var _expirationTime = computeExpirationForFiber(currentTime, fiber);
+
+ var _update2 = {
+ expirationTime: _expirationTime,
+ action: action,
+ eagerReducer: null,
+ eagerState: null,
+ next: null
+ };
+ var _last = queue.last;
+
+ if (_last === null) {
+ _update2.next = _update2;
+ } else {
+ var first = _last.next;
+
+ if (first !== null) {
+ _update2.next = first;
+ }
+
+ _last.next = _update2;
+ }
+
+ queue.last = _update2;
+
+ if (fiber.expirationTime === NoWork && (alternate === null || alternate.expirationTime === NoWork)) {
+ var _eagerReducer = queue.eagerReducer;
+
+ if (_eagerReducer !== null) {
+ var prevDispatcher = void 0;
+ {
+ prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;
+ }
+
+ try {
+ var currentState = queue.eagerState;
+
+ var _eagerState = _eagerReducer(currentState, action);
+
+ _update2.eagerReducer = _eagerReducer;
+ _update2.eagerState = _eagerState;
+
+ if (is(_eagerState, currentState)) {
+ return;
+ }
+ } catch (error) {} finally {
+ {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ }
+ }
+ }
+
+ {
+ if (shouldWarnForUnbatchedSetState === true) {
+ warnIfNotCurrentlyBatchingInDev(fiber);
+ }
+ }
+ scheduleWork(fiber, _expirationTime);
+ }
+ }
+
+ var ContextOnlyDispatcher = {
+ readContext: _readContext,
+ useCallback: throwInvalidHookError,
+ useContext: throwInvalidHookError,
+ useEffect: throwInvalidHookError,
+ useImperativeHandle: throwInvalidHookError,
+ useLayoutEffect: throwInvalidHookError,
+ useMemo: throwInvalidHookError,
+ useReducer: throwInvalidHookError,
+ useRef: throwInvalidHookError,
+ useState: throwInvalidHookError,
+ useDebugValue: throwInvalidHookError
+ };
+ var HooksDispatcherOnMountInDEV = null;
+ var HooksDispatcherOnUpdateInDEV = null;
+ var InvalidNestedHooksDispatcherOnMountInDEV = null;
+ var InvalidNestedHooksDispatcherOnUpdateInDEV = null;
+ {
+ var warnInvalidContextAccess = function warnInvalidContextAccess() {
+ warning$1(false, "Context can only be read while React is rendering. " + "In classes, you can read it in the render method or getDerivedStateFromProps. " + "In function components, you can read it directly in the function body, but not " + "inside Hooks like useReducer() or useMemo().");
+ };
+
+ var warnInvalidHookAccess = function warnInvalidHookAccess() {
+ warning$1(false, "Do not call Hooks inside useEffect(...), useMemo(...), or other built-in Hooks. " + "You can only call Hooks at the top level of your React function. " + "For more information, see " + "https://fb.me/rules-of-hooks");
+ };
+
+ HooksDispatcherOnMountInDEV = {
+ readContext: function readContext(context, observedBits) {
+ return _readContext(context, observedBits);
+ },
+ useCallback: function useCallback(callback, deps) {
+ currentHookNameInDev = "useCallback";
+ return mountCallback(callback, deps);
+ },
+ useContext: function useContext(context, observedBits) {
+ currentHookNameInDev = "useContext";
+ return mountContext(context, observedBits);
+ },
+ useEffect: function useEffect(create, deps) {
+ currentHookNameInDev = "useEffect";
+ return mountEffect(create, deps);
+ },
+ useImperativeHandle: function useImperativeHandle(ref, create, deps) {
+ currentHookNameInDev = "useImperativeHandle";
+ return mountImperativeHandle(ref, create, deps);
+ },
+ useLayoutEffect: function useLayoutEffect(create, deps) {
+ currentHookNameInDev = "useLayoutEffect";
+ return mountLayoutEffect(create, deps);
+ },
+ useMemo: function useMemo(create, deps) {
+ currentHookNameInDev = "useMemo";
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;
+
+ try {
+ return mountMemo(create, deps);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useReducer: function useReducer(reducer, initialArg, init) {
+ currentHookNameInDev = "useReducer";
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;
+
+ try {
+ return mountReducer(reducer, initialArg, init);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useRef: function useRef(initialValue) {
+ currentHookNameInDev = "useRef";
+ return mountRef(initialValue);
+ },
+ useState: function useState(initialState) {
+ currentHookNameInDev = "useState";
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;
+
+ try {
+ return mountState(initialState);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useDebugValue: function useDebugValue(value, formatterFn) {
+ currentHookNameInDev = "useDebugValue";
+ return mountDebugValue(value, formatterFn);
+ }
+ };
+ HooksDispatcherOnUpdateInDEV = {
+ readContext: function readContext(context, observedBits) {
+ return _readContext(context, observedBits);
+ },
+ useCallback: function useCallback(callback, deps) {
+ currentHookNameInDev = "useCallback";
+ return updateCallback(callback, deps);
+ },
+ useContext: function useContext(context, observedBits) {
+ currentHookNameInDev = "useContext";
+ return updateContext(context, observedBits);
+ },
+ useEffect: function useEffect(create, deps) {
+ currentHookNameInDev = "useEffect";
+ return updateEffect(create, deps);
+ },
+ useImperativeHandle: function useImperativeHandle(ref, create, deps) {
+ currentHookNameInDev = "useImperativeHandle";
+ return updateImperativeHandle(ref, create, deps);
+ },
+ useLayoutEffect: function useLayoutEffect(create, deps) {
+ currentHookNameInDev = "useLayoutEffect";
+ return updateLayoutEffect(create, deps);
+ },
+ useMemo: function useMemo(create, deps) {
+ currentHookNameInDev = "useMemo";
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;
+
+ try {
+ return updateMemo(create, deps);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useReducer: function useReducer(reducer, initialArg, init) {
+ currentHookNameInDev = "useReducer";
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;
+
+ try {
+ return updateReducer(reducer, initialArg, init);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useRef: function useRef(initialValue) {
+ currentHookNameInDev = "useRef";
+ return updateRef(initialValue);
+ },
+ useState: function useState(initialState) {
+ currentHookNameInDev = "useState";
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;
+
+ try {
+ return updateState(initialState);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useDebugValue: function useDebugValue(value, formatterFn) {
+ currentHookNameInDev = "useDebugValue";
+ return updateDebugValue(value, formatterFn);
+ }
+ };
+ InvalidNestedHooksDispatcherOnMountInDEV = {
+ readContext: function readContext(context, observedBits) {
+ warnInvalidContextAccess();
+ return _readContext(context, observedBits);
+ },
+ useCallback: function useCallback(callback, deps) {
+ currentHookNameInDev = "useCallback";
+ warnInvalidHookAccess();
+ return mountCallback(callback, deps);
+ },
+ useContext: function useContext(context, observedBits) {
+ currentHookNameInDev = "useContext";
+ warnInvalidHookAccess();
+ return mountContext(context, observedBits);
+ },
+ useEffect: function useEffect(create, deps) {
+ currentHookNameInDev = "useEffect";
+ warnInvalidHookAccess();
+ return mountEffect(create, deps);
+ },
+ useImperativeHandle: function useImperativeHandle(ref, create, deps) {
+ currentHookNameInDev = "useImperativeHandle";
+ warnInvalidHookAccess();
+ return mountImperativeHandle(ref, create, deps);
+ },
+ useLayoutEffect: function useLayoutEffect(create, deps) {
+ currentHookNameInDev = "useLayoutEffect";
+ warnInvalidHookAccess();
+ return mountLayoutEffect(create, deps);
+ },
+ useMemo: function useMemo(create, deps) {
+ currentHookNameInDev = "useMemo";
+ warnInvalidHookAccess();
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;
+
+ try {
+ return mountMemo(create, deps);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useReducer: function useReducer(reducer, initialArg, init) {
+ currentHookNameInDev = "useReducer";
+ warnInvalidHookAccess();
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;
+
+ try {
+ return mountReducer(reducer, initialArg, init);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useRef: function useRef(initialValue) {
+ currentHookNameInDev = "useRef";
+ warnInvalidHookAccess();
+ return mountRef(initialValue);
+ },
+ useState: function useState(initialState) {
+ currentHookNameInDev = "useState";
+ warnInvalidHookAccess();
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;
+
+ try {
+ return mountState(initialState);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useDebugValue: function useDebugValue(value, formatterFn) {
+ currentHookNameInDev = "useDebugValue";
+ warnInvalidHookAccess();
+ return mountDebugValue(value, formatterFn);
+ }
+ };
+ InvalidNestedHooksDispatcherOnUpdateInDEV = {
+ readContext: function readContext(context, observedBits) {
+ warnInvalidContextAccess();
+ return _readContext(context, observedBits);
+ },
+ useCallback: function useCallback(callback, deps) {
+ currentHookNameInDev = "useCallback";
+ warnInvalidHookAccess();
+ return updateCallback(callback, deps);
+ },
+ useContext: function useContext(context, observedBits) {
+ currentHookNameInDev = "useContext";
+ warnInvalidHookAccess();
+ return updateContext(context, observedBits);
+ },
+ useEffect: function useEffect(create, deps) {
+ currentHookNameInDev = "useEffect";
+ warnInvalidHookAccess();
+ return updateEffect(create, deps);
+ },
+ useImperativeHandle: function useImperativeHandle(ref, create, deps) {
+ currentHookNameInDev = "useImperativeHandle";
+ warnInvalidHookAccess();
+ return updateImperativeHandle(ref, create, deps);
+ },
+ useLayoutEffect: function useLayoutEffect(create, deps) {
+ currentHookNameInDev = "useLayoutEffect";
+ warnInvalidHookAccess();
+ return updateLayoutEffect(create, deps);
+ },
+ useMemo: function useMemo(create, deps) {
+ currentHookNameInDev = "useMemo";
+ warnInvalidHookAccess();
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;
+
+ try {
+ return updateMemo(create, deps);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useReducer: function useReducer(reducer, initialArg, init) {
+ currentHookNameInDev = "useReducer";
+ warnInvalidHookAccess();
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;
+
+ try {
+ return updateReducer(reducer, initialArg, init);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useRef: function useRef(initialValue) {
+ currentHookNameInDev = "useRef";
+ warnInvalidHookAccess();
+ return updateRef(initialValue);
+ },
+ useState: function useState(initialState) {
+ currentHookNameInDev = "useState";
+ warnInvalidHookAccess();
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;
+
+ try {
+ return updateState(initialState);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useDebugValue: function useDebugValue(value, formatterFn) {
+ currentHookNameInDev = "useDebugValue";
+ warnInvalidHookAccess();
+ return updateDebugValue(value, formatterFn);
+ }
+ };
+ }
+ var commitTime = 0;
+ var profilerStartTime = -1;
+
+ function getCommitTime() {
+ return commitTime;
+ }
+
+ function recordCommitTime() {
+ if (!enableProfilerTimer) {
+ return;
+ }
+
+ commitTime = now$$1();
+ }
+
+ function startProfilerTimer(fiber) {
+ if (!enableProfilerTimer) {
+ return;
+ }
+
+ profilerStartTime = now$$1();
+
+ if (fiber.actualStartTime < 0) {
+ fiber.actualStartTime = now$$1();
+ }
+ }
+
+ function stopProfilerTimerIfRunning(fiber) {
+ if (!enableProfilerTimer) {
+ return;
+ }
+
+ profilerStartTime = -1;
+ }
+
+ function stopProfilerTimerIfRunningAndRecordDelta(fiber, overrideBaseTime) {
+ if (!enableProfilerTimer) {
+ return;
+ }
+
+ if (profilerStartTime >= 0) {
+ var elapsedTime = now$$1() - profilerStartTime;
+ fiber.actualDuration += elapsedTime;
+
+ if (overrideBaseTime) {
+ fiber.selfBaseDuration = elapsedTime;
+ }
+
+ profilerStartTime = -1;
+ }
+ }
+
+ var hydrationParentFiber = null;
+ var nextHydratableInstance = null;
+ var isHydrating = false;
+
+ function enterHydrationState(fiber) {
+ if (!supportsHydration) {
+ return false;
+ }
+
+ var parentInstance = fiber.stateNode.containerInfo;
+ nextHydratableInstance = getFirstHydratableChild(parentInstance);
+ hydrationParentFiber = fiber;
+ isHydrating = true;
+ return true;
+ }
+
+ function reenterHydrationStateFromDehydratedSuspenseInstance(fiber) {
+ if (!supportsHydration) {
+ return false;
+ }
+
+ var suspenseInstance = fiber.stateNode;
+ nextHydratableInstance = getNextHydratableSibling(suspenseInstance);
+ popToNextHostParent(fiber);
+ isHydrating = true;
+ return true;
+ }
+
+ function deleteHydratableInstance(returnFiber, instance) {
+ {
+ switch (returnFiber.tag) {
+ case HostRoot:
+ didNotHydrateContainerInstance(returnFiber.stateNode.containerInfo, instance);
+ break;
+
+ case HostComponent:
+ didNotHydrateInstance(returnFiber.type, returnFiber.memoizedProps, returnFiber.stateNode, instance);
+ break;
+ }
+ }
+ var childToDelete = createFiberFromHostInstanceForDeletion();
+ childToDelete.stateNode = instance;
+ childToDelete.return = returnFiber;
+ childToDelete.effectTag = Deletion;
+
+ if (returnFiber.lastEffect !== null) {
+ returnFiber.lastEffect.nextEffect = childToDelete;
+ returnFiber.lastEffect = childToDelete;
+ } else {
+ returnFiber.firstEffect = returnFiber.lastEffect = childToDelete;
+ }
+ }
+
+ function insertNonHydratedInstance(returnFiber, fiber) {
+ fiber.effectTag |= Placement;
+ {
+ switch (returnFiber.tag) {
+ case HostRoot:
+ {
+ var parentContainer = returnFiber.stateNode.containerInfo;
+
+ switch (fiber.tag) {
+ case HostComponent:
+ var type = fiber.type;
+ var props = fiber.pendingProps;
+ didNotFindHydratableContainerInstance(parentContainer, type, props);
+ break;
+
+ case HostText:
+ var text = fiber.pendingProps;
+ didNotFindHydratableContainerTextInstance(parentContainer, text);
+ break;
+
+ case SuspenseComponent:
+ didNotFindHydratableContainerSuspenseInstance(parentContainer);
+ break;
+ }
+
+ break;
+ }
+
+ case HostComponent:
+ {
+ var parentType = returnFiber.type;
+ var parentProps = returnFiber.memoizedProps;
+ var parentInstance = returnFiber.stateNode;
+
+ switch (fiber.tag) {
+ case HostComponent:
+ var _type = fiber.type;
+ var _props = fiber.pendingProps;
+ didNotFindHydratableInstance(parentType, parentProps, parentInstance, _type, _props);
+ break;
+
+ case HostText:
+ var _text = fiber.pendingProps;
+ didNotFindHydratableTextInstance(parentType, parentProps, parentInstance, _text);
+ break;
+
+ case SuspenseComponent:
+ didNotFindHydratableSuspenseInstance(parentType, parentProps, parentInstance);
+ break;
+ }
+
+ break;
+ }
+
+ default:
+ return;
+ }
+ }
+ }
+
+ function tryHydrate(fiber, nextInstance) {
+ switch (fiber.tag) {
+ case HostComponent:
+ {
+ var type = fiber.type;
+ var props = fiber.pendingProps;
+ var instance = canHydrateInstance(nextInstance, type, props);
+
+ if (instance !== null) {
+ fiber.stateNode = instance;
+ return true;
+ }
+
+ return false;
+ }
+
+ case HostText:
+ {
+ var text = fiber.pendingProps;
+ var textInstance = canHydrateTextInstance(nextInstance, text);
+
+ if (textInstance !== null) {
+ fiber.stateNode = textInstance;
+ return true;
+ }
+
+ return false;
+ }
+
+ case SuspenseComponent:
+ {
+ if (enableSuspenseServerRenderer) {
+ var suspenseInstance = canHydrateSuspenseInstance(nextInstance);
+
+ if (suspenseInstance !== null) {
+ fiber.tag = DehydratedSuspenseComponent;
+ fiber.stateNode = suspenseInstance;
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ default:
+ return false;
+ }
+ }
+
+ function tryToClaimNextHydratableInstance(fiber) {
+ if (!isHydrating) {
+ return;
+ }
+
+ var nextInstance = nextHydratableInstance;
+
+ if (!nextInstance) {
+ insertNonHydratedInstance(hydrationParentFiber, fiber);
+ isHydrating = false;
+ hydrationParentFiber = fiber;
+ return;
+ }
+
+ var firstAttemptedInstance = nextInstance;
+
+ if (!tryHydrate(fiber, nextInstance)) {
+ nextInstance = getNextHydratableSibling(firstAttemptedInstance);
+
+ if (!nextInstance || !tryHydrate(fiber, nextInstance)) {
+ insertNonHydratedInstance(hydrationParentFiber, fiber);
+ isHydrating = false;
+ hydrationParentFiber = fiber;
+ return;
+ }
+
+ deleteHydratableInstance(hydrationParentFiber, firstAttemptedInstance);
+ }
+
+ hydrationParentFiber = fiber;
+ nextHydratableInstance = getFirstHydratableChild(nextInstance);
+ }
+
+ function prepareToHydrateHostInstance(fiber, rootContainerInstance, hostContext) {
+ if (!supportsHydration) {
+ 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 skipPastDehydratedSuspenseInstance(fiber) {
+ if (!supportsHydration) {
+ invariant(false, "Expected skipPastDehydratedSuspenseInstance() to never be called. " + "This error is likely caused by a bug in React. Please file an issue.");
+ }
+
+ var suspenseInstance = fiber.stateNode;
+ invariant(suspenseInstance, "Expected to have a hydrated suspense instance. " + "This error is likely caused by a bug in React. Please file an issue.");
+ nextHydratableInstance = getNextHydratableInstanceAfterSuspenseInstance(suspenseInstance);
+ }
+
+ function popToNextHostParent(fiber) {
+ var parent = fiber.return;
+
+ while (parent !== null && parent.tag !== HostComponent && parent.tag !== HostRoot && parent.tag !== DehydratedSuspenseComponent) {
+ parent = parent.return;
+ }
+
+ hydrationParentFiber = parent;
+ }
+
+ function popHydrationState(fiber) {
+ if (!supportsHydration) {
+ return false;
+ }
+
+ if (fiber !== hydrationParentFiber) {
+ return false;
+ }
+
+ if (!isHydrating) {
+ popToNextHostParent(fiber);
+ isHydrating = true;
+ return false;
+ }
+
+ var type = fiber.type;
+
+ if (fiber.tag !== HostComponent || type !== "head" && type !== "body" && !shouldSetTextContent(type, fiber.memoizedProps)) {
+ var nextInstance = nextHydratableInstance;
+
+ while (nextInstance) {
+ deleteHydratableInstance(fiber, nextInstance);
+ nextInstance = getNextHydratableSibling(nextInstance);
+ }
+ }
+
+ popToNextHostParent(fiber);
+ nextHydratableInstance = hydrationParentFiber ? getNextHydratableSibling(fiber.stateNode) : null;
+ return true;
+ }
+
+ function resetHydrationState() {
+ if (!supportsHydration) {
+ return;
+ }
+
+ hydrationParentFiber = null;
+ nextHydratableInstance = null;
+ isHydrating = false;
+ }
+
+ var ReactCurrentOwner$3 = ReactSharedInternals.ReactCurrentOwner;
+ var didReceiveUpdate = false;
+ var didWarnAboutBadClass = void 0;
+ var didWarnAboutContextTypeOnFunctionComponent = void 0;
+ var didWarnAboutGetDerivedStateOnFunctionComponent = void 0;
+ var didWarnAboutFunctionRefs = void 0;
+ var didWarnAboutReassigningProps = void 0;
+ {
+ didWarnAboutBadClass = {};
+ didWarnAboutContextTypeOnFunctionComponent = {};
+ didWarnAboutGetDerivedStateOnFunctionComponent = {};
+ didWarnAboutFunctionRefs = {};
+ didWarnAboutReassigningProps = false;
+ }
+
+ function reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime) {
+ if (current$$1 === null) {
+ workInProgress.child = mountChildFibers(workInProgress, null, nextChildren, renderExpirationTime);
+ } else {
+ workInProgress.child = reconcileChildFibers(workInProgress, current$$1.child, nextChildren, renderExpirationTime);
+ }
+ }
+
+ function forceUnmountCurrentAndReconcile(current$$1, workInProgress, nextChildren, renderExpirationTime) {
+ workInProgress.child = reconcileChildFibers(workInProgress, current$$1.child, null, renderExpirationTime);
+ workInProgress.child = reconcileChildFibers(workInProgress, null, nextChildren, renderExpirationTime);
+ }
+
+ function updateForwardRef(current$$1, workInProgress, Component, nextProps, renderExpirationTime) {
+ {
+ if (workInProgress.type !== workInProgress.elementType) {
+ var innerPropTypes = Component.propTypes;
+
+ if (innerPropTypes) {
+ checkPropTypes(innerPropTypes, nextProps, "prop", getComponentName(Component), getCurrentFiberStackInDev);
+ }
+ }
+ }
+ var render = Component.render;
+ var ref = workInProgress.ref;
+ var nextChildren = void 0;
+ prepareToReadContext(workInProgress, renderExpirationTime);
+ {
+ ReactCurrentOwner$3.current = workInProgress;
+ setCurrentPhase("render");
+ nextChildren = renderWithHooks(current$$1, workInProgress, render, nextProps, ref, renderExpirationTime);
+
+ if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
+ if (workInProgress.memoizedState !== null) {
+ nextChildren = renderWithHooks(current$$1, workInProgress, render, nextProps, ref, renderExpirationTime);
+ }
+ }
+
+ setCurrentPhase(null);
+ }
+
+ if (current$$1 !== null && !didReceiveUpdate) {
+ bailoutHooks(current$$1, workInProgress, renderExpirationTime);
+ return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ }
+
+ workInProgress.effectTag |= PerformedWork;
+ reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
+ return workInProgress.child;
+ }
+
+ function updateMemoComponent(current$$1, workInProgress, Component, nextProps, updateExpirationTime, renderExpirationTime) {
+ if (current$$1 === null) {
+ var type = Component.type;
+
+ if (isSimpleFunctionComponent(type) && Component.compare === null && Component.defaultProps === undefined) {
+ workInProgress.tag = SimpleMemoComponent;
+ workInProgress.type = type;
+ {
+ validateFunctionComponentInDev(workInProgress, type);
+ }
+ return updateSimpleMemoComponent(current$$1, workInProgress, type, nextProps, updateExpirationTime, renderExpirationTime);
+ }
+
+ {
+ var innerPropTypes = type.propTypes;
+
+ if (innerPropTypes) {
+ checkPropTypes(innerPropTypes, nextProps, "prop", getComponentName(type), getCurrentFiberStackInDev);
+ }
+ }
+ var child = createFiberFromTypeAndProps(Component.type, null, nextProps, null, workInProgress.mode, renderExpirationTime);
+ child.ref = workInProgress.ref;
+ child.return = workInProgress;
+ workInProgress.child = child;
+ return child;
+ }
+
+ {
+ var _type = Component.type;
+ var _innerPropTypes = _type.propTypes;
+
+ if (_innerPropTypes) {
+ checkPropTypes(_innerPropTypes, nextProps, "prop", getComponentName(_type), getCurrentFiberStackInDev);
+ }
+ }
+ var currentChild = current$$1.child;
+
+ if (updateExpirationTime < renderExpirationTime) {
+ var prevProps = currentChild.memoizedProps;
+ var compare = Component.compare;
+ compare = compare !== null ? compare : shallowEqual;
+
+ if (compare(prevProps, nextProps) && current$$1.ref === workInProgress.ref) {
+ return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ }
+ }
+
+ workInProgress.effectTag |= PerformedWork;
+ var newChild = createWorkInProgress(currentChild, nextProps, renderExpirationTime);
+ newChild.ref = workInProgress.ref;
+ newChild.return = workInProgress;
+ workInProgress.child = newChild;
+ return newChild;
+ }
+
+ function updateSimpleMemoComponent(current$$1, workInProgress, Component, nextProps, updateExpirationTime, renderExpirationTime) {
+ {
+ if (workInProgress.type !== workInProgress.elementType) {
+ var outerMemoType = workInProgress.elementType;
+
+ if (outerMemoType.$$typeof === REACT_LAZY_TYPE) {
+ outerMemoType = refineResolvedLazyComponent(outerMemoType);
+ }
+
+ var outerPropTypes = outerMemoType && outerMemoType.propTypes;
+
+ if (outerPropTypes) {
+ checkPropTypes(outerPropTypes, nextProps, "prop", getComponentName(outerMemoType), getCurrentFiberStackInDev);
+ }
+ }
+ }
+
+ if (current$$1 !== null) {
+ var prevProps = current$$1.memoizedProps;
+
+ if (shallowEqual(prevProps, nextProps) && current$$1.ref === workInProgress.ref) {
+ didReceiveUpdate = false;
+
+ if (updateExpirationTime < renderExpirationTime) {
+ return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ }
+ }
+ }
+
+ return updateFunctionComponent(current$$1, workInProgress, Component, nextProps, renderExpirationTime);
+ }
+
+ function updateFragment(current$$1, workInProgress, renderExpirationTime) {
+ var nextChildren = workInProgress.pendingProps;
+ reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
+ return workInProgress.child;
+ }
+
+ function updateMode(current$$1, workInProgress, renderExpirationTime) {
+ var nextChildren = workInProgress.pendingProps.children;
+ reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
+ return workInProgress.child;
+ }
+
+ function updateProfiler(current$$1, workInProgress, renderExpirationTime) {
+ if (enableProfilerTimer) {
+ workInProgress.effectTag |= Update;
+ }
+
+ var nextProps = workInProgress.pendingProps;
+ var nextChildren = nextProps.children;
+ reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
+ return workInProgress.child;
+ }
+
+ function markRef(current$$1, workInProgress) {
+ var ref = workInProgress.ref;
+
+ if (current$$1 === null && ref !== null || current$$1 !== null && current$$1.ref !== ref) {
+ workInProgress.effectTag |= Ref;
+ }
+ }
+
+ function updateFunctionComponent(current$$1, workInProgress, Component, nextProps, renderExpirationTime) {
+ {
+ if (workInProgress.type !== workInProgress.elementType) {
+ var innerPropTypes = Component.propTypes;
+
+ if (innerPropTypes) {
+ checkPropTypes(innerPropTypes, nextProps, "prop", getComponentName(Component), getCurrentFiberStackInDev);
+ }
+ }
+ }
+ var unmaskedContext = getUnmaskedContext(workInProgress, Component, true);
+ var context = getMaskedContext(workInProgress, unmaskedContext);
+ var nextChildren = void 0;
+ prepareToReadContext(workInProgress, renderExpirationTime);
+ {
+ ReactCurrentOwner$3.current = workInProgress;
+ setCurrentPhase("render");
+ nextChildren = renderWithHooks(current$$1, workInProgress, Component, nextProps, context, renderExpirationTime);
+
+ if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
+ if (workInProgress.memoizedState !== null) {
+ nextChildren = renderWithHooks(current$$1, workInProgress, Component, nextProps, context, renderExpirationTime);
+ }
+ }
+
+ setCurrentPhase(null);
+ }
+
+ if (current$$1 !== null && !didReceiveUpdate) {
+ bailoutHooks(current$$1, workInProgress, renderExpirationTime);
+ return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ }
+
+ workInProgress.effectTag |= PerformedWork;
+ reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
+ return workInProgress.child;
+ }
+
+ function updateClassComponent(current$$1, workInProgress, Component, nextProps, renderExpirationTime) {
+ {
+ if (workInProgress.type !== workInProgress.elementType) {
+ var innerPropTypes = Component.propTypes;
+
+ if (innerPropTypes) {
+ checkPropTypes(innerPropTypes, nextProps, "prop", getComponentName(Component), getCurrentFiberStackInDev);
+ }
+ }
+ }
+ var hasContext = void 0;
+
+ if (isContextProvider(Component)) {
+ hasContext = true;
+ pushContextProvider(workInProgress);
+ } else {
+ hasContext = false;
+ }
+
+ prepareToReadContext(workInProgress, renderExpirationTime);
+ var instance = workInProgress.stateNode;
+ var shouldUpdate = void 0;
+
+ if (instance === null) {
+ if (current$$1 !== null) {
+ current$$1.alternate = null;
+ workInProgress.alternate = null;
+ workInProgress.effectTag |= Placement;
+ }
+
+ constructClassInstance(workInProgress, Component, nextProps, renderExpirationTime);
+ mountClassInstance(workInProgress, Component, nextProps, renderExpirationTime);
+ shouldUpdate = true;
+ } else if (current$$1 === null) {
+ shouldUpdate = resumeMountClassInstance(workInProgress, Component, nextProps, renderExpirationTime);
+ } else {
+ shouldUpdate = updateClassInstance(current$$1, workInProgress, Component, nextProps, renderExpirationTime);
+ }
+
+ var nextUnitOfWork = finishClassComponent(current$$1, workInProgress, Component, shouldUpdate, hasContext, renderExpirationTime);
+ {
+ var inst = workInProgress.stateNode;
+
+ if (inst.props !== nextProps) {
+ !didWarnAboutReassigningProps ? warning$1(false, "It looks like %s is reassigning its own `this.props` while rendering. " + "This is not supported and can lead to confusing bugs.", getComponentName(workInProgress.type) || "a component") : void 0;
+ didWarnAboutReassigningProps = true;
+ }
+ }
+ return nextUnitOfWork;
+ }
+
+ function finishClassComponent(current$$1, workInProgress, Component, shouldUpdate, hasContext, renderExpirationTime) {
+ markRef(current$$1, workInProgress);
+ var didCaptureError = (workInProgress.effectTag & DidCapture) !== NoEffect;
+
+ if (!shouldUpdate && !didCaptureError) {
+ if (hasContext) {
+ invalidateContextProvider(workInProgress, Component, false);
+ }
+
+ return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ }
+
+ var instance = workInProgress.stateNode;
+ ReactCurrentOwner$3.current = workInProgress;
+ var nextChildren = void 0;
+
+ if (didCaptureError && typeof Component.getDerivedStateFromError !== "function") {
+ nextChildren = null;
+
+ if (enableProfilerTimer) {
+ stopProfilerTimerIfRunning(workInProgress);
+ }
+ } else {
+ {
+ setCurrentPhase("render");
+ nextChildren = instance.render();
+
+ if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
+ instance.render();
+ }
+
+ setCurrentPhase(null);
+ }
+ }
+
+ workInProgress.effectTag |= PerformedWork;
+
+ if (current$$1 !== null && didCaptureError) {
+ forceUnmountCurrentAndReconcile(current$$1, workInProgress, nextChildren, renderExpirationTime);
+ } else {
+ reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
+ }
+
+ workInProgress.memoizedState = instance.state;
+
+ if (hasContext) {
+ invalidateContextProvider(workInProgress, Component, true);
+ }
+
+ return workInProgress.child;
+ }
+
+ function pushHostRootContext(workInProgress) {
+ var root = workInProgress.stateNode;
+
+ if (root.pendingContext) {
+ pushTopLevelContextObject(workInProgress, root.pendingContext, root.pendingContext !== root.context);
+ } else if (root.context) {
+ pushTopLevelContextObject(workInProgress, root.context, false);
+ }
+
+ pushHostContainer(workInProgress, root.containerInfo);
+ }
+
+ function updateHostRoot(current$$1, workInProgress, renderExpirationTime) {
+ pushHostRootContext(workInProgress);
+ var updateQueue = workInProgress.updateQueue;
+ invariant(updateQueue !== null, "If the root does not have an updateQueue, we should have already " + "bailed out. This error is likely caused by a bug in React. Please " + "file an issue.");
+ var nextProps = workInProgress.pendingProps;
+ var prevState = workInProgress.memoizedState;
+ var prevChildren = prevState !== null ? prevState.element : null;
+ processUpdateQueue(workInProgress, updateQueue, nextProps, null, renderExpirationTime);
+ var nextState = workInProgress.memoizedState;
+ var nextChildren = nextState.element;
+
+ if (nextChildren === prevChildren) {
+ resetHydrationState();
+ return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ }
+
+ var root = workInProgress.stateNode;
+
+ if ((current$$1 === null || current$$1.child === null) && root.hydrate && enterHydrationState(workInProgress)) {
+ workInProgress.effectTag |= Placement;
+ workInProgress.child = mountChildFibers(workInProgress, null, nextChildren, renderExpirationTime);
+ } else {
+ reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
+ resetHydrationState();
+ }
+
+ return workInProgress.child;
+ }
+
+ function updateHostComponent(current$$1, workInProgress, renderExpirationTime) {
+ pushHostContext(workInProgress);
+
+ if (current$$1 === null) {
+ tryToClaimNextHydratableInstance(workInProgress);
+ }
+
+ var type = workInProgress.type;
+ var nextProps = workInProgress.pendingProps;
+ var prevProps = current$$1 !== null ? current$$1.memoizedProps : null;
+ var nextChildren = nextProps.children;
+ var isDirectTextChild = shouldSetTextContent(type, nextProps);
+
+ if (isDirectTextChild) {
+ nextChildren = null;
+ } else if (prevProps !== null && shouldSetTextContent(type, prevProps)) {
+ workInProgress.effectTag |= ContentReset;
+ }
+
+ markRef(current$$1, workInProgress);
+
+ if (renderExpirationTime !== Never && workInProgress.mode & ConcurrentMode && shouldDeprioritizeSubtree(type, nextProps)) {
+ workInProgress.expirationTime = workInProgress.childExpirationTime = Never;
+ return null;
+ }
+
+ reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
+ return workInProgress.child;
+ }
+
+ function updateHostText(current$$1, workInProgress) {
+ if (current$$1 === null) {
+ tryToClaimNextHydratableInstance(workInProgress);
+ }
+
+ return null;
+ }
+
+ function mountLazyComponent(_current, workInProgress, elementType, updateExpirationTime, renderExpirationTime) {
+ if (_current !== null) {
+ _current.alternate = null;
+ workInProgress.alternate = null;
+ workInProgress.effectTag |= Placement;
+ }
+
+ var props = workInProgress.pendingProps;
+ cancelWorkTimer(workInProgress);
+ var Component = readLazyComponentType(elementType);
+ workInProgress.type = Component;
+ var resolvedTag = workInProgress.tag = resolveLazyComponentTag(Component);
+ startWorkTimer(workInProgress);
+ var resolvedProps = resolveDefaultProps(Component, props);
+ var child = void 0;
+
+ switch (resolvedTag) {
+ case FunctionComponent:
+ {
+ {
+ validateFunctionComponentInDev(workInProgress, Component);
+ }
+ child = updateFunctionComponent(null, workInProgress, Component, resolvedProps, renderExpirationTime);
+ break;
+ }
+
+ case ClassComponent:
+ {
+ child = updateClassComponent(null, workInProgress, Component, resolvedProps, renderExpirationTime);
+ break;
+ }
+
+ case ForwardRef:
+ {
+ child = updateForwardRef(null, workInProgress, Component, resolvedProps, renderExpirationTime);
+ break;
+ }
+
+ case MemoComponent:
+ {
+ {
+ if (workInProgress.type !== workInProgress.elementType) {
+ var outerPropTypes = Component.propTypes;
+
+ if (outerPropTypes) {
+ checkPropTypes(outerPropTypes, resolvedProps, "prop", getComponentName(Component), getCurrentFiberStackInDev);
+ }
+ }
+ }
+ child = updateMemoComponent(null, workInProgress, Component, resolveDefaultProps(Component.type, resolvedProps), updateExpirationTime, renderExpirationTime);
+ break;
+ }
+
+ default:
+ {
+ var hint = "";
+ {
+ if (Component !== null && typeof Component === "object" && Component.$$typeof === REACT_LAZY_TYPE) {
+ hint = " Did you wrap a component in React.lazy() more than once?";
+ }
+ }
+ invariant(false, "Element type is invalid. Received a promise that resolves to: %s. " + "Lazy element type must resolve to a class or function.%s", Component, hint);
+ }
+ }
+
+ return child;
+ }
+
+ function mountIncompleteClassComponent(_current, workInProgress, Component, nextProps, renderExpirationTime) {
+ if (_current !== null) {
+ _current.alternate = null;
+ workInProgress.alternate = null;
+ workInProgress.effectTag |= Placement;
+ }
+
+ workInProgress.tag = ClassComponent;
+ var hasContext = void 0;
+
+ if (isContextProvider(Component)) {
+ hasContext = true;
+ pushContextProvider(workInProgress);
+ } else {
+ hasContext = false;
+ }
+
+ prepareToReadContext(workInProgress, renderExpirationTime);
+ constructClassInstance(workInProgress, Component, nextProps, renderExpirationTime);
+ mountClassInstance(workInProgress, Component, nextProps, renderExpirationTime);
+ return finishClassComponent(null, workInProgress, Component, true, hasContext, renderExpirationTime);
+ }
+
+ function mountIndeterminateComponent(_current, workInProgress, Component, renderExpirationTime) {
+ if (_current !== null) {
+ _current.alternate = null;
+ workInProgress.alternate = null;
+ workInProgress.effectTag |= Placement;
+ }
+
+ var props = workInProgress.pendingProps;
+ var unmaskedContext = getUnmaskedContext(workInProgress, Component, false);
+ var context = getMaskedContext(workInProgress, unmaskedContext);
+ prepareToReadContext(workInProgress, renderExpirationTime);
+ var value = void 0;
+ {
+ if (Component.prototype && typeof Component.prototype.render === "function") {
+ var componentName = getComponentName(Component) || "Unknown";
+
+ if (!didWarnAboutBadClass[componentName]) {
+ warningWithoutStack$1(false, "The <%s /> component appears to have a render method, but doesn't extend React.Component. " + "This is likely to cause errors. Change %s to extend React.Component instead.", componentName, componentName);
+ didWarnAboutBadClass[componentName] = true;
+ }
+ }
+
+ if (workInProgress.mode & StrictMode) {
+ ReactStrictModeWarnings.recordLegacyContextWarning(workInProgress, null);
+ }
+
+ ReactCurrentOwner$3.current = workInProgress;
+ value = renderWithHooks(null, workInProgress, Component, props, context, renderExpirationTime);
+ }
+ workInProgress.effectTag |= PerformedWork;
+
+ if (typeof value === "object" && value !== null && typeof value.render === "function" && value.$$typeof === undefined) {
+ workInProgress.tag = ClassComponent;
+ resetHooks();
+ var hasContext = false;
+
+ if (isContextProvider(Component)) {
+ hasContext = true;
+ pushContextProvider(workInProgress);
+ } else {
+ hasContext = false;
+ }
+
+ workInProgress.memoizedState = value.state !== null && value.state !== undefined ? value.state : null;
+ var getDerivedStateFromProps = Component.getDerivedStateFromProps;
+
+ if (typeof getDerivedStateFromProps === "function") {
+ applyDerivedStateFromProps(workInProgress, Component, getDerivedStateFromProps, props);
+ }
+
+ adoptClassInstance(workInProgress, value);
+ mountClassInstance(workInProgress, Component, props, renderExpirationTime);
+ return finishClassComponent(null, workInProgress, Component, true, hasContext, renderExpirationTime);
+ } else {
+ workInProgress.tag = FunctionComponent;
+ {
+ if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
+ if (workInProgress.memoizedState !== null) {
+ value = renderWithHooks(null, workInProgress, Component, props, context, renderExpirationTime);
+ }
+ }
+ }
+ reconcileChildren(null, workInProgress, value, renderExpirationTime);
+ {
+ validateFunctionComponentInDev(workInProgress, Component);
+ }
+ return workInProgress.child;
+ }
+ }
+
+ function validateFunctionComponentInDev(workInProgress, Component) {
+ if (Component) {
+ !!Component.childContextTypes ? warningWithoutStack$1(false, "%s(...): childContextTypes cannot be defined on a function component.", Component.displayName || Component.name || "Component") : void 0;
+ }
+
+ if (workInProgress.ref !== null) {
+ var info = "";
+ var ownerName = getCurrentFiberOwnerNameInDevOrNull();
+
+ if (ownerName) {
+ info += "\n\nCheck the render method of `" + ownerName + "`.";
+ }
+
+ var warningKey = ownerName || workInProgress._debugID || "";
+ var debugSource = workInProgress._debugSource;
+
+ if (debugSource) {
+ warningKey = debugSource.fileName + ":" + debugSource.lineNumber;
+ }
+
+ if (!didWarnAboutFunctionRefs[warningKey]) {
+ didWarnAboutFunctionRefs[warningKey] = true;
+ warning$1(false, "Function components cannot be given refs. " + "Attempts to access this ref will fail. " + "Did you mean to use React.forwardRef()?%s", info);
+ }
+ }
+
+ if (typeof Component.getDerivedStateFromProps === "function") {
+ var componentName = getComponentName(Component) || "Unknown";
+
+ if (!didWarnAboutGetDerivedStateOnFunctionComponent[componentName]) {
+ warningWithoutStack$1(false, "%s: Function components do not support getDerivedStateFromProps.", componentName);
+ didWarnAboutGetDerivedStateOnFunctionComponent[componentName] = true;
+ }
+ }
+
+ if (typeof Component.contextType === "object" && Component.contextType !== null) {
+ var _componentName = getComponentName(Component) || "Unknown";
+
+ if (!didWarnAboutContextTypeOnFunctionComponent[_componentName]) {
+ warningWithoutStack$1(false, "%s: Function components do not support contextType.", _componentName);
+ didWarnAboutContextTypeOnFunctionComponent[_componentName] = true;
+ }
+ }
+ }
+
+ function updateSuspenseComponent(current$$1, workInProgress, renderExpirationTime) {
+ var mode = workInProgress.mode;
+ var nextProps = workInProgress.pendingProps;
+ var nextState = workInProgress.memoizedState;
+ var nextDidTimeout = void 0;
+
+ if ((workInProgress.effectTag & DidCapture) === NoEffect) {
+ nextState = null;
+ nextDidTimeout = false;
+ } else {
+ nextState = {
+ timedOutAt: nextState !== null ? nextState.timedOutAt : NoWork
+ };
+ nextDidTimeout = true;
+ workInProgress.effectTag &= ~DidCapture;
+ }
+
+ var child = void 0;
+ var next = void 0;
+
+ if (current$$1 === null) {
+ if (enableSuspenseServerRenderer) {
+ if (nextProps.fallback !== undefined) {
+ tryToClaimNextHydratableInstance(workInProgress);
+
+ if (workInProgress.tag === DehydratedSuspenseComponent) {
+ return updateDehydratedSuspenseComponent(null, workInProgress, renderExpirationTime);
+ }
+ }
+ }
+
+ if (nextDidTimeout) {
+ var nextFallbackChildren = nextProps.fallback;
+ var primaryChildFragment = createFiberFromFragment(null, mode, NoWork, null);
+
+ if ((workInProgress.mode & ConcurrentMode) === NoContext) {
+ var progressedState = workInProgress.memoizedState;
+ var progressedPrimaryChild = progressedState !== null ? workInProgress.child.child : workInProgress.child;
+ primaryChildFragment.child = progressedPrimaryChild;
+ }
+
+ var fallbackChildFragment = createFiberFromFragment(nextFallbackChildren, mode, renderExpirationTime, null);
+ primaryChildFragment.sibling = fallbackChildFragment;
+ child = primaryChildFragment;
+ next = fallbackChildFragment;
+ child.return = next.return = workInProgress;
+ } else {
+ var nextPrimaryChildren = nextProps.children;
+ child = next = mountChildFibers(workInProgress, null, nextPrimaryChildren, renderExpirationTime);
+ }
+ } else {
+ var prevState = current$$1.memoizedState;
+ var prevDidTimeout = prevState !== null;
+
+ if (prevDidTimeout) {
+ var currentPrimaryChildFragment = current$$1.child;
+ var currentFallbackChildFragment = currentPrimaryChildFragment.sibling;
+
+ if (nextDidTimeout) {
+ var _nextFallbackChildren = nextProps.fallback;
+
+ var _primaryChildFragment = createWorkInProgress(currentPrimaryChildFragment, currentPrimaryChildFragment.pendingProps, NoWork);
+
+ if ((workInProgress.mode & ConcurrentMode) === NoContext) {
+ var _progressedState = workInProgress.memoizedState;
+
+ var _progressedPrimaryChild = _progressedState !== null ? workInProgress.child.child : workInProgress.child;
+
+ if (_progressedPrimaryChild !== currentPrimaryChildFragment.child) {
+ _primaryChildFragment.child = _progressedPrimaryChild;
+ }
+ }
+
+ if (enableProfilerTimer && workInProgress.mode & ProfileMode) {
+ var treeBaseDuration = 0;
+ var hiddenChild = _primaryChildFragment.child;
+
+ while (hiddenChild !== null) {
+ treeBaseDuration += hiddenChild.treeBaseDuration;
+ hiddenChild = hiddenChild.sibling;
+ }
+
+ _primaryChildFragment.treeBaseDuration = treeBaseDuration;
+ }
+
+ var _fallbackChildFragment = _primaryChildFragment.sibling = createWorkInProgress(currentFallbackChildFragment, _nextFallbackChildren, currentFallbackChildFragment.expirationTime);
+
+ child = _primaryChildFragment;
+ _primaryChildFragment.childExpirationTime = NoWork;
+ next = _fallbackChildFragment;
+ child.return = next.return = workInProgress;
+ } else {
+ var _nextPrimaryChildren = nextProps.children;
+ var currentPrimaryChild = currentPrimaryChildFragment.child;
+ var primaryChild = reconcileChildFibers(workInProgress, currentPrimaryChild, _nextPrimaryChildren, renderExpirationTime);
+ child = next = primaryChild;
+ }
+ } else {
+ var _currentPrimaryChild = current$$1.child;
+
+ if (nextDidTimeout) {
+ var _nextFallbackChildren2 = nextProps.fallback;
+
+ var _primaryChildFragment2 = createFiberFromFragment(null, mode, NoWork, null);
+
+ _primaryChildFragment2.child = _currentPrimaryChild;
+
+ if ((workInProgress.mode & ConcurrentMode) === NoContext) {
+ var _progressedState2 = workInProgress.memoizedState;
+
+ var _progressedPrimaryChild2 = _progressedState2 !== null ? workInProgress.child.child : workInProgress.child;
+
+ _primaryChildFragment2.child = _progressedPrimaryChild2;
+ }
+
+ if (enableProfilerTimer && workInProgress.mode & ProfileMode) {
+ var _treeBaseDuration = 0;
+ var _hiddenChild = _primaryChildFragment2.child;
+
+ while (_hiddenChild !== null) {
+ _treeBaseDuration += _hiddenChild.treeBaseDuration;
+ _hiddenChild = _hiddenChild.sibling;
+ }
+
+ _primaryChildFragment2.treeBaseDuration = _treeBaseDuration;
+ }
+
+ var _fallbackChildFragment2 = _primaryChildFragment2.sibling = createFiberFromFragment(_nextFallbackChildren2, mode, renderExpirationTime, null);
+
+ _fallbackChildFragment2.effectTag |= Placement;
+ child = _primaryChildFragment2;
+ _primaryChildFragment2.childExpirationTime = NoWork;
+ next = _fallbackChildFragment2;
+ child.return = next.return = workInProgress;
+ } else {
+ var _nextPrimaryChildren2 = nextProps.children;
+ next = child = reconcileChildFibers(workInProgress, _currentPrimaryChild, _nextPrimaryChildren2, renderExpirationTime);
+ }
+ }
+
+ workInProgress.stateNode = current$$1.stateNode;
+ }
+
+ workInProgress.memoizedState = nextState;
+ workInProgress.child = child;
+ return next;
+ }
+
+ function updateDehydratedSuspenseComponent(current$$1, workInProgress, renderExpirationTime) {
+ if (current$$1 === null) {
+ workInProgress.expirationTime = Never;
+ return null;
+ }
+
+ if ((workInProgress.effectTag & DidCapture) !== NoEffect) {
+ workInProgress.child = null;
+ return null;
+ }
+
+ var hasContextChanged$$1 = current$$1.childExpirationTime >= renderExpirationTime;
+ var suspenseInstance = current$$1.stateNode;
+
+ if (didReceiveUpdate || hasContextChanged$$1 || isSuspenseInstanceFallback(suspenseInstance)) {
+ current$$1.alternate = null;
+ workInProgress.alternate = null;
+ var returnFiber = workInProgress.return;
+ invariant(returnFiber !== null, "Suspense boundaries are never on the root. " + "This is probably a bug in React.");
+ var last = returnFiber.lastEffect;
+
+ if (last !== null) {
+ last.nextEffect = current$$1;
+ returnFiber.lastEffect = current$$1;
+ } else {
+ returnFiber.firstEffect = returnFiber.lastEffect = current$$1;
+ }
+
+ current$$1.nextEffect = null;
+ current$$1.effectTag = Deletion;
+ workInProgress.tag = SuspenseComponent;
+ workInProgress.stateNode = null;
+ workInProgress.memoizedState = null;
+ workInProgress.effectTag |= Placement;
+ return updateSuspenseComponent(null, workInProgress, renderExpirationTime);
+ } else if (isSuspenseInstancePending(suspenseInstance)) {
+ workInProgress.effectTag |= DidCapture;
+ workInProgress.child = null;
+ registerSuspenseInstanceRetry(suspenseInstance, retryTimedOutBoundary.bind(null, current$$1));
+ return null;
+ } else {
+ reenterHydrationStateFromDehydratedSuspenseInstance(workInProgress);
+ var nextProps = workInProgress.pendingProps;
+ var nextChildren = nextProps.children;
+ workInProgress.child = mountChildFibers(workInProgress, null, nextChildren, renderExpirationTime);
+ return workInProgress.child;
+ }
+ }
+
+ function updatePortalComponent(current$$1, workInProgress, renderExpirationTime) {
+ pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+ var nextChildren = workInProgress.pendingProps;
+
+ if (current$$1 === null) {
+ workInProgress.child = reconcileChildFibers(workInProgress, null, nextChildren, renderExpirationTime);
+ } else {
+ reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
+ }
+
+ return workInProgress.child;
+ }
+
+ function updateContextProvider(current$$1, workInProgress, renderExpirationTime) {
+ var providerType = workInProgress.type;
+ var context = providerType._context;
+ var newProps = workInProgress.pendingProps;
+ var oldProps = workInProgress.memoizedProps;
+ var newValue = newProps.value;
+ {
+ var providerPropTypes = workInProgress.type.propTypes;
+
+ if (providerPropTypes) {
+ checkPropTypes(providerPropTypes, newProps, "prop", "Context.Provider", getCurrentFiberStackInDev);
+ }
+ }
+ pushProvider(workInProgress, newValue);
+
+ if (oldProps !== null) {
+ var oldValue = oldProps.value;
+ var changedBits = calculateChangedBits(context, newValue, oldValue);
+
+ if (changedBits === 0) {
+ if (oldProps.children === newProps.children && !hasContextChanged()) {
+ return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ }
+ } else {
+ propagateContextChange(workInProgress, context, changedBits, renderExpirationTime);
+ }
+ }
+
+ var newChildren = newProps.children;
+ reconcileChildren(current$$1, workInProgress, newChildren, renderExpirationTime);
+ return workInProgress.child;
+ }
+
+ var hasWarnedAboutUsingContextAsConsumer = false;
+
+ function updateContextConsumer(current$$1, workInProgress, renderExpirationTime) {
+ var context = workInProgress.type;
+ {
+ if (context._context === undefined) {
+ if (context !== context.Consumer) {
+ if (!hasWarnedAboutUsingContextAsConsumer) {
+ hasWarnedAboutUsingContextAsConsumer = true;
+ warning$1(false, "Rendering directly is not supported and will be removed in " + "a future major release. Did you mean to render instead?");
+ }
+ }
+ } else {
+ context = context._context;
+ }
+ }
+ var newProps = workInProgress.pendingProps;
+ var render = newProps.children;
+ {
+ !(typeof render === "function") ? warningWithoutStack$1(false, "A context consumer was rendered with multiple children, or a child " + "that isn't a function. A context consumer expects a single child " + "that is a function. If you did pass a function, make sure there " + "is no trailing or leading whitespace around it.") : void 0;
+ }
+ prepareToReadContext(workInProgress, renderExpirationTime);
+
+ var newValue = _readContext(context, newProps.unstable_observedBits);
+
+ var newChildren = void 0;
+ {
+ ReactCurrentOwner$3.current = workInProgress;
+ setCurrentPhase("render");
+ newChildren = render(newValue);
+ setCurrentPhase(null);
+ }
+ workInProgress.effectTag |= PerformedWork;
+ reconcileChildren(current$$1, workInProgress, newChildren, renderExpirationTime);
+ return workInProgress.child;
+ }
+
+ function markWorkInProgressReceivedUpdate() {
+ didReceiveUpdate = true;
+ }
+
+ function bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime) {
+ cancelWorkTimer(workInProgress);
+
+ if (current$$1 !== null) {
+ workInProgress.contextDependencies = current$$1.contextDependencies;
+ }
+
+ if (enableProfilerTimer) {
+ stopProfilerTimerIfRunning(workInProgress);
+ }
+
+ var childExpirationTime = workInProgress.childExpirationTime;
+
+ if (childExpirationTime < renderExpirationTime) {
+ return null;
+ } else {
+ cloneChildFibers(current$$1, workInProgress);
+ return workInProgress.child;
+ }
+ }
+
+ function beginWork(current$$1, workInProgress, renderExpirationTime) {
+ var updateExpirationTime = workInProgress.expirationTime;
+
+ if (current$$1 !== null) {
+ var oldProps = current$$1.memoizedProps;
+ var newProps = workInProgress.pendingProps;
+
+ if (oldProps !== newProps || hasContextChanged()) {
+ didReceiveUpdate = true;
+ } else if (updateExpirationTime < renderExpirationTime) {
+ didReceiveUpdate = false;
+
+ switch (workInProgress.tag) {
+ case HostRoot:
+ pushHostRootContext(workInProgress);
+ resetHydrationState();
+ break;
+
+ case HostComponent:
+ pushHostContext(workInProgress);
+ break;
+
+ case ClassComponent:
+ {
+ var Component = workInProgress.type;
+
+ if (isContextProvider(Component)) {
+ pushContextProvider(workInProgress);
+ }
+
+ break;
+ }
+
+ case HostPortal:
+ pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+ break;
+
+ case ContextProvider:
+ {
+ var newValue = workInProgress.memoizedProps.value;
+ pushProvider(workInProgress, newValue);
+ break;
+ }
+
+ case Profiler:
+ if (enableProfilerTimer) {
+ workInProgress.effectTag |= Update;
+ }
+
+ break;
+
+ case SuspenseComponent:
+ {
+ var state = workInProgress.memoizedState;
+ var didTimeout = state !== null;
+
+ if (didTimeout) {
+ var primaryChildFragment = workInProgress.child;
+ var primaryChildExpirationTime = primaryChildFragment.childExpirationTime;
+
+ if (primaryChildExpirationTime !== NoWork && primaryChildExpirationTime >= renderExpirationTime) {
+ return updateSuspenseComponent(current$$1, workInProgress, renderExpirationTime);
+ } else {
+ var child = bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+
+ if (child !== null) {
+ return child.sibling;
+ } else {
+ return null;
+ }
+ }
+ }
+
+ break;
+ }
+
+ case DehydratedSuspenseComponent:
+ {
+ if (enableSuspenseServerRenderer) {
+ workInProgress.effectTag |= DidCapture;
+ break;
+ }
+ }
+ }
+
+ return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ }
+ } else {
+ didReceiveUpdate = false;
+ }
+
+ workInProgress.expirationTime = NoWork;
+
+ switch (workInProgress.tag) {
+ case IndeterminateComponent:
+ {
+ var elementType = workInProgress.elementType;
+ return mountIndeterminateComponent(current$$1, workInProgress, elementType, renderExpirationTime);
+ }
+
+ case LazyComponent:
+ {
+ var _elementType = workInProgress.elementType;
+ return mountLazyComponent(current$$1, workInProgress, _elementType, updateExpirationTime, renderExpirationTime);
+ }
+
+ case FunctionComponent:
+ {
+ var _Component = workInProgress.type;
+ var unresolvedProps = workInProgress.pendingProps;
+ var resolvedProps = workInProgress.elementType === _Component ? unresolvedProps : resolveDefaultProps(_Component, unresolvedProps);
+ return updateFunctionComponent(current$$1, workInProgress, _Component, resolvedProps, renderExpirationTime);
+ }
+
+ case ClassComponent:
+ {
+ var _Component2 = workInProgress.type;
+ var _unresolvedProps = workInProgress.pendingProps;
+
+ var _resolvedProps = workInProgress.elementType === _Component2 ? _unresolvedProps : resolveDefaultProps(_Component2, _unresolvedProps);
+
+ return updateClassComponent(current$$1, workInProgress, _Component2, _resolvedProps, renderExpirationTime);
+ }
+
+ case HostRoot:
+ return updateHostRoot(current$$1, workInProgress, renderExpirationTime);
+
+ case HostComponent:
+ return updateHostComponent(current$$1, workInProgress, renderExpirationTime);
+
+ case HostText:
+ return updateHostText(current$$1, workInProgress);
+
+ case SuspenseComponent:
+ return updateSuspenseComponent(current$$1, workInProgress, renderExpirationTime);
+
+ case HostPortal:
+ return updatePortalComponent(current$$1, workInProgress, renderExpirationTime);
+
+ case ForwardRef:
+ {
+ var type = workInProgress.type;
+ var _unresolvedProps2 = workInProgress.pendingProps;
+
+ var _resolvedProps2 = workInProgress.elementType === type ? _unresolvedProps2 : resolveDefaultProps(type, _unresolvedProps2);
+
+ return updateForwardRef(current$$1, workInProgress, type, _resolvedProps2, renderExpirationTime);
+ }
+
+ case Fragment:
+ return updateFragment(current$$1, workInProgress, renderExpirationTime);
+
+ case Mode:
+ return updateMode(current$$1, workInProgress, renderExpirationTime);
+
+ case Profiler:
+ return updateProfiler(current$$1, workInProgress, renderExpirationTime);
+
+ case ContextProvider:
+ return updateContextProvider(current$$1, workInProgress, renderExpirationTime);
+
+ case ContextConsumer:
+ return updateContextConsumer(current$$1, workInProgress, renderExpirationTime);
+
+ case MemoComponent:
+ {
+ var _type2 = workInProgress.type;
+ var _unresolvedProps3 = workInProgress.pendingProps;
+
+ var _resolvedProps3 = resolveDefaultProps(_type2, _unresolvedProps3);
+
+ {
+ if (workInProgress.type !== workInProgress.elementType) {
+ var outerPropTypes = _type2.propTypes;
+
+ if (outerPropTypes) {
+ checkPropTypes(outerPropTypes, _resolvedProps3, "prop", getComponentName(_type2), getCurrentFiberStackInDev);
+ }
+ }
+ }
+ _resolvedProps3 = resolveDefaultProps(_type2.type, _resolvedProps3);
+ return updateMemoComponent(current$$1, workInProgress, _type2, _resolvedProps3, updateExpirationTime, renderExpirationTime);
+ }
+
+ case SimpleMemoComponent:
+ {
+ return updateSimpleMemoComponent(current$$1, workInProgress, workInProgress.type, workInProgress.pendingProps, updateExpirationTime, renderExpirationTime);
+ }
+
+ case IncompleteClassComponent:
+ {
+ var _Component3 = workInProgress.type;
+ var _unresolvedProps4 = workInProgress.pendingProps;
+
+ var _resolvedProps4 = workInProgress.elementType === _Component3 ? _unresolvedProps4 : resolveDefaultProps(_Component3, _unresolvedProps4);
+
+ return mountIncompleteClassComponent(current$$1, workInProgress, _Component3, _resolvedProps4, renderExpirationTime);
+ }
+
+ case DehydratedSuspenseComponent:
+ {
+ if (enableSuspenseServerRenderer) {
+ return updateDehydratedSuspenseComponent(current$$1, workInProgress, renderExpirationTime);
+ }
+
+ break;
+ }
+ }
+
+ invariant(false, "Unknown unit of work tag. This error is likely caused by a bug in " + "React. Please file an issue.");
+ }
+
+ var valueCursor = createCursor(null);
+ var rendererSigil = void 0;
+ {
+ rendererSigil = {};
+ }
+ var currentlyRenderingFiber = null;
+ var lastContextDependency = null;
+ var lastContextWithAllBitsObserved = null;
+ var isDisallowedContextReadInDEV = false;
+
+ function resetContextDependences() {
+ currentlyRenderingFiber = null;
+ lastContextDependency = null;
+ lastContextWithAllBitsObserved = null;
+ {
+ isDisallowedContextReadInDEV = false;
+ }
+ }
+
+ function enterDisallowedContextReadInDEV() {
+ {
+ isDisallowedContextReadInDEV = true;
+ }
+ }
+
+ function exitDisallowedContextReadInDEV() {
+ {
+ isDisallowedContextReadInDEV = false;
+ }
+ }
+
+ function pushProvider(providerFiber, nextValue) {
+ var context = providerFiber.type._context;
+
+ if (isPrimaryRenderer) {
+ push(valueCursor, context._currentValue, providerFiber);
+ context._currentValue = nextValue;
+ {
+ !(context._currentRenderer === undefined || context._currentRenderer === null || context._currentRenderer === rendererSigil) ? warningWithoutStack$1(false, "Detected multiple renderers concurrently rendering the " + "same context provider. This is currently unsupported.") : void 0;
+ context._currentRenderer = rendererSigil;
+ }
+ } else {
+ push(valueCursor, context._currentValue2, providerFiber);
+ context._currentValue2 = nextValue;
+ {
+ !(context._currentRenderer2 === undefined || context._currentRenderer2 === null || context._currentRenderer2 === rendererSigil) ? warningWithoutStack$1(false, "Detected multiple renderers concurrently rendering the " + "same context provider. This is currently unsupported.") : void 0;
+ context._currentRenderer2 = rendererSigil;
+ }
+ }
+ }
+
+ function popProvider(providerFiber) {
+ var currentValue = valueCursor.current;
+ pop(valueCursor, providerFiber);
+ var context = providerFiber.type._context;
+
+ if (isPrimaryRenderer) {
+ context._currentValue = currentValue;
+ } else {
+ context._currentValue2 = currentValue;
+ }
+ }
+
+ function calculateChangedBits(context, newValue, oldValue) {
+ if (is(oldValue, newValue)) {
+ return 0;
+ } else {
+ var changedBits = typeof context._calculateChangedBits === "function" ? context._calculateChangedBits(oldValue, newValue) : maxSigned31BitInt;
+ {
+ !((changedBits & maxSigned31BitInt) === changedBits) ? warning$1(false, "calculateChangedBits: Expected the return value to be a " + "31-bit integer. Instead received: %s", changedBits) : void 0;
+ }
+ return changedBits | 0;
+ }
+ }
+
+ function scheduleWorkOnParentPath(parent, renderExpirationTime) {
+ var node = parent;
+
+ while (node !== null) {
+ var alternate = node.alternate;
+
+ if (node.childExpirationTime < renderExpirationTime) {
+ node.childExpirationTime = renderExpirationTime;
+
+ if (alternate !== null && alternate.childExpirationTime < renderExpirationTime) {
+ alternate.childExpirationTime = renderExpirationTime;
+ }
+ } else if (alternate !== null && alternate.childExpirationTime < renderExpirationTime) {
+ alternate.childExpirationTime = renderExpirationTime;
+ } else {
+ break;
+ }
+
+ node = node.return;
+ }
+ }
+
+ function propagateContextChange(workInProgress, context, changedBits, renderExpirationTime) {
+ var fiber = workInProgress.child;
+
+ if (fiber !== null) {
+ fiber.return = workInProgress;
+ }
+
+ while (fiber !== null) {
+ var nextFiber = void 0;
+ var list = fiber.contextDependencies;
+
+ if (list !== null) {
+ nextFiber = fiber.child;
+ var dependency = list.first;
+
+ while (dependency !== null) {
+ if (dependency.context === context && (dependency.observedBits & changedBits) !== 0) {
+ if (fiber.tag === ClassComponent) {
+ var update = createUpdate(renderExpirationTime);
+ update.tag = ForceUpdate;
+ enqueueUpdate(fiber, update);
+ }
+
+ if (fiber.expirationTime < renderExpirationTime) {
+ fiber.expirationTime = renderExpirationTime;
+ }
+
+ var alternate = fiber.alternate;
+
+ if (alternate !== null && alternate.expirationTime < renderExpirationTime) {
+ alternate.expirationTime = renderExpirationTime;
+ }
+
+ scheduleWorkOnParentPath(fiber.return, renderExpirationTime);
+
+ if (list.expirationTime < renderExpirationTime) {
+ list.expirationTime = renderExpirationTime;
+ }
+
+ break;
+ }
+
+ dependency = dependency.next;
+ }
+ } else if (fiber.tag === ContextProvider) {
+ nextFiber = fiber.type === workInProgress.type ? null : fiber.child;
+ } else if (enableSuspenseServerRenderer && fiber.tag === DehydratedSuspenseComponent) {
+ if (fiber.expirationTime < renderExpirationTime) {
+ fiber.expirationTime = renderExpirationTime;
+ }
+
+ var _alternate = fiber.alternate;
+
+ if (_alternate !== null && _alternate.expirationTime < renderExpirationTime) {
+ _alternate.expirationTime = renderExpirationTime;
+ }
+
+ scheduleWorkOnParentPath(fiber, renderExpirationTime);
+ nextFiber = fiber.sibling;
+ } else {
+ nextFiber = fiber.child;
+ }
+
+ if (nextFiber !== null) {
+ nextFiber.return = fiber;
+ } else {
+ nextFiber = fiber;
+
+ while (nextFiber !== null) {
+ if (nextFiber === workInProgress) {
+ nextFiber = null;
+ break;
+ }
+
+ var sibling = nextFiber.sibling;
+
+ if (sibling !== null) {
+ sibling.return = nextFiber.return;
+ nextFiber = sibling;
+ break;
+ }
+
+ nextFiber = nextFiber.return;
+ }
+ }
+
+ fiber = nextFiber;
+ }
+ }
+
+ function prepareToReadContext(workInProgress, renderExpirationTime) {
+ currentlyRenderingFiber = workInProgress;
+ lastContextDependency = null;
+ lastContextWithAllBitsObserved = null;
+ var currentDependencies = workInProgress.contextDependencies;
+
+ if (currentDependencies !== null && currentDependencies.expirationTime >= renderExpirationTime) {
+ markWorkInProgressReceivedUpdate();
+ }
+
+ workInProgress.contextDependencies = null;
+ }
+
+ function _readContext(context, observedBits) {
+ {
+ !!isDisallowedContextReadInDEV ? warning$1(false, "Context can only be read while React is rendering. " + "In classes, you can read it in the render method or getDerivedStateFromProps. " + "In function components, you can read it directly in the function body, but not " + "inside Hooks like useReducer() or useMemo().") : void 0;
+ }
+
+ if (lastContextWithAllBitsObserved === context) {} else if (observedBits === false || observedBits === 0) {} else {
+ var resolvedObservedBits = void 0;
+
+ if (typeof observedBits !== "number" || observedBits === maxSigned31BitInt) {
+ lastContextWithAllBitsObserved = context;
+ resolvedObservedBits = maxSigned31BitInt;
+ } else {
+ resolvedObservedBits = observedBits;
+ }
+
+ var contextItem = {
+ context: context,
+ observedBits: resolvedObservedBits,
+ next: null
+ };
+
+ if (lastContextDependency === null) {
+ invariant(currentlyRenderingFiber !== null, "Context can only be read while React is rendering. " + "In classes, you can read it in the render method or getDerivedStateFromProps. " + "In function components, you can read it directly in the function body, but not " + "inside Hooks like useReducer() or useMemo().");
+ lastContextDependency = contextItem;
+ currentlyRenderingFiber.contextDependencies = {
+ first: contextItem,
+ expirationTime: NoWork
+ };
+ } else {
+ lastContextDependency = lastContextDependency.next = contextItem;
+ }
+ }
+
+ return isPrimaryRenderer ? context._currentValue : context._currentValue2;
+ }
+
+ var UpdateState = 0;
+ var ReplaceState = 1;
+ var ForceUpdate = 2;
+ var CaptureUpdate = 3;
+ var hasForceUpdate = false;
+ var didWarnUpdateInsideUpdate = void 0;
+ var currentlyProcessingQueue = void 0;
+ var resetCurrentlyProcessingQueue = void 0;
+ {
+ didWarnUpdateInsideUpdate = false;
+ currentlyProcessingQueue = null;
+
+ resetCurrentlyProcessingQueue = function resetCurrentlyProcessingQueue() {
+ currentlyProcessingQueue = null;
+ };
+ }
+
+ function createUpdateQueue(baseState) {
+ var queue = {
+ baseState: baseState,
+ firstUpdate: null,
+ lastUpdate: null,
+ firstCapturedUpdate: null,
+ lastCapturedUpdate: null,
+ firstEffect: null,
+ lastEffect: null,
+ firstCapturedEffect: null,
+ lastCapturedEffect: null
+ };
+ return queue;
+ }
+
+ function cloneUpdateQueue(currentQueue) {
+ var queue = {
+ baseState: currentQueue.baseState,
+ firstUpdate: currentQueue.firstUpdate,
+ lastUpdate: currentQueue.lastUpdate,
+ firstCapturedUpdate: null,
+ lastCapturedUpdate: null,
+ firstEffect: null,
+ lastEffect: null,
+ firstCapturedEffect: null,
+ lastCapturedEffect: null
+ };
+ return queue;
+ }
+
+ function createUpdate(expirationTime) {
+ return {
+ expirationTime: expirationTime,
+ tag: UpdateState,
+ payload: null,
+ callback: null,
+ next: null,
+ nextEffect: null
+ };
+ }
+
+ function appendUpdateToQueue(queue, update) {
+ if (queue.lastUpdate === null) {
+ queue.firstUpdate = queue.lastUpdate = update;
+ } else {
+ queue.lastUpdate.next = update;
+ queue.lastUpdate = update;
+ }
+ }
+
+ function enqueueUpdate(fiber, update) {
+ var alternate = fiber.alternate;
+ var queue1 = void 0;
+ var queue2 = void 0;
+
+ if (alternate === null) {
+ queue1 = fiber.updateQueue;
+ queue2 = null;
+
+ if (queue1 === null) {
+ queue1 = fiber.updateQueue = createUpdateQueue(fiber.memoizedState);
+ }
+ } else {
+ queue1 = fiber.updateQueue;
+ queue2 = alternate.updateQueue;
+
+ if (queue1 === null) {
+ if (queue2 === null) {
+ queue1 = fiber.updateQueue = createUpdateQueue(fiber.memoizedState);
+ queue2 = alternate.updateQueue = createUpdateQueue(alternate.memoizedState);
+ } else {
+ queue1 = fiber.updateQueue = cloneUpdateQueue(queue2);
+ }
+ } else {
+ if (queue2 === null) {
+ queue2 = alternate.updateQueue = cloneUpdateQueue(queue1);
+ } else {}
+ }
+ }
+
+ if (queue2 === null || queue1 === queue2) {
+ appendUpdateToQueue(queue1, update);
+ } else {
+ if (queue1.lastUpdate === null || queue2.lastUpdate === null) {
+ appendUpdateToQueue(queue1, update);
+ appendUpdateToQueue(queue2, update);
+ } else {
+ appendUpdateToQueue(queue1, update);
+ queue2.lastUpdate = update;
+ }
+ }
+
+ {
+ if (fiber.tag === ClassComponent && (currentlyProcessingQueue === queue1 || queue2 !== null && currentlyProcessingQueue === queue2) && !didWarnUpdateInsideUpdate) {
+ warningWithoutStack$1(false, "An update (setState, replaceState, or forceUpdate) was scheduled " + "from inside an update function. Update functions should be pure, " + "with zero side-effects. Consider using componentDidUpdate or a " + "callback.");
+ didWarnUpdateInsideUpdate = true;
+ }
+ }
+ }
+
+ function enqueueCapturedUpdate(workInProgress, update) {
+ var workInProgressQueue = workInProgress.updateQueue;
+
+ if (workInProgressQueue === null) {
+ workInProgressQueue = workInProgress.updateQueue = createUpdateQueue(workInProgress.memoizedState);
+ } else {
+ workInProgressQueue = ensureWorkInProgressQueueIsAClone(workInProgress, workInProgressQueue);
+ }
+
+ if (workInProgressQueue.lastCapturedUpdate === null) {
+ workInProgressQueue.firstCapturedUpdate = workInProgressQueue.lastCapturedUpdate = update;
+ } else {
+ workInProgressQueue.lastCapturedUpdate.next = update;
+ workInProgressQueue.lastCapturedUpdate = update;
+ }
+ }
+
+ function ensureWorkInProgressQueueIsAClone(workInProgress, queue) {
+ var current = workInProgress.alternate;
+
+ if (current !== null) {
+ if (queue === current.updateQueue) {
+ queue = workInProgress.updateQueue = cloneUpdateQueue(queue);
+ }
+ }
+
+ return queue;
+ }
+
+ function getStateFromUpdate(workInProgress, queue, update, prevState, nextProps, instance) {
+ switch (update.tag) {
+ case ReplaceState:
+ {
+ var _payload = update.payload;
+
+ if (typeof _payload === "function") {
+ {
+ enterDisallowedContextReadInDEV();
+
+ if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
+ _payload.call(instance, prevState, nextProps);
+ }
+ }
+
+ var nextState = _payload.call(instance, prevState, nextProps);
+
+ {
+ exitDisallowedContextReadInDEV();
+ }
+ return nextState;
+ }
+
+ return _payload;
+ }
+
+ case CaptureUpdate:
+ {
+ workInProgress.effectTag = workInProgress.effectTag & ~ShouldCapture | DidCapture;
+ }
+
+ case UpdateState:
+ {
+ var _payload2 = update.payload;
+ var partialState = void 0;
+
+ if (typeof _payload2 === "function") {
+ {
+ enterDisallowedContextReadInDEV();
+
+ if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
+ _payload2.call(instance, prevState, nextProps);
+ }
+ }
+ partialState = _payload2.call(instance, prevState, nextProps);
+ {
+ exitDisallowedContextReadInDEV();
+ }
+ } else {
+ partialState = _payload2;
+ }
+
+ if (partialState === null || partialState === undefined) {
+ return prevState;
+ }
+
+ return _extends({}, prevState, partialState);
+ }
+
+ case ForceUpdate:
+ {
+ hasForceUpdate = true;
+ return prevState;
+ }
+ }
+
+ return prevState;
+ }
+
+ function processUpdateQueue(workInProgress, queue, props, instance, renderExpirationTime) {
+ hasForceUpdate = false;
+ queue = ensureWorkInProgressQueueIsAClone(workInProgress, queue);
+ {
+ currentlyProcessingQueue = queue;
+ }
+ var newBaseState = queue.baseState;
+ var newFirstUpdate = null;
+ var newExpirationTime = NoWork;
+ var update = queue.firstUpdate;
+ var resultState = newBaseState;
+
+ while (update !== null) {
+ var updateExpirationTime = update.expirationTime;
+
+ if (updateExpirationTime < renderExpirationTime) {
+ if (newFirstUpdate === null) {
+ newFirstUpdate = update;
+ newBaseState = resultState;
+ }
+
+ if (newExpirationTime < updateExpirationTime) {
+ newExpirationTime = updateExpirationTime;
+ }
+ } else {
+ resultState = getStateFromUpdate(workInProgress, queue, update, resultState, props, instance);
+ var _callback = update.callback;
+
+ if (_callback !== null) {
+ workInProgress.effectTag |= Callback;
+ update.nextEffect = null;
+
+ if (queue.lastEffect === null) {
+ queue.firstEffect = queue.lastEffect = update;
+ } else {
+ queue.lastEffect.nextEffect = update;
+ queue.lastEffect = update;
+ }
+ }
+ }
+
+ update = update.next;
+ }
+
+ var newFirstCapturedUpdate = null;
+ update = queue.firstCapturedUpdate;
+
+ while (update !== null) {
+ var _updateExpirationTime = update.expirationTime;
+
+ if (_updateExpirationTime < renderExpirationTime) {
+ if (newFirstCapturedUpdate === null) {
+ newFirstCapturedUpdate = update;
+
+ if (newFirstUpdate === null) {
+ newBaseState = resultState;
+ }
+ }
+
+ if (newExpirationTime < _updateExpirationTime) {
+ newExpirationTime = _updateExpirationTime;
+ }
+ } else {
+ resultState = getStateFromUpdate(workInProgress, queue, update, resultState, props, instance);
+ var _callback2 = update.callback;
+
+ if (_callback2 !== null) {
+ workInProgress.effectTag |= Callback;
+ update.nextEffect = null;
+
+ if (queue.lastCapturedEffect === null) {
+ queue.firstCapturedEffect = queue.lastCapturedEffect = update;
+ } else {
+ queue.lastCapturedEffect.nextEffect = update;
+ queue.lastCapturedEffect = update;
+ }
+ }
+ }
+
+ update = update.next;
+ }
+
+ if (newFirstUpdate === null) {
+ queue.lastUpdate = null;
+ }
+
+ if (newFirstCapturedUpdate === null) {
+ queue.lastCapturedUpdate = null;
+ } else {
+ workInProgress.effectTag |= Callback;
+ }
+
+ if (newFirstUpdate === null && newFirstCapturedUpdate === null) {
+ newBaseState = resultState;
+ }
+
+ queue.baseState = newBaseState;
+ queue.firstUpdate = newFirstUpdate;
+ queue.firstCapturedUpdate = newFirstCapturedUpdate;
+ workInProgress.expirationTime = newExpirationTime;
+ workInProgress.memoizedState = resultState;
+ {
+ currentlyProcessingQueue = null;
+ }
+ }
+
+ function callCallback(callback, context) {
+ 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;
+ }
+
+ commitUpdateEffects(finishedQueue.firstEffect, instance);
+ finishedQueue.firstEffect = finishedQueue.lastEffect = null;
+ commitUpdateEffects(finishedQueue.firstCapturedEffect, instance);
+ finishedQueue.firstCapturedEffect = finishedQueue.lastCapturedEffect = null;
+ }
+
+ function commitUpdateEffects(effect, instance) {
+ while (effect !== null) {
+ var _callback3 = effect.callback;
+
+ if (_callback3 !== null) {
+ effect.callback = null;
+ callCallback(_callback3, instance);
+ }
+
+ effect = effect.nextEffect;
+ }
+ }
+
+ function createCapturedValue(value, source) {
+ return {
+ value: value,
+ source: source,
+ stack: getStackByFiberInDevAndProd(source)
+ };
+ }
+
+ function markUpdate(workInProgress) {
+ workInProgress.effectTag |= Update;
+ }
+
+ function markRef$1(workInProgress) {
+ workInProgress.effectTag |= Ref;
+ }
+
+ var _appendAllChildren = void 0;
+
+ var updateHostContainer = void 0;
+ var updateHostComponent$1 = void 0;
+ var updateHostText$1 = void 0;
+
+ if (supportsMutation) {
+ _appendAllChildren = function appendAllChildren(parent, workInProgress, needsVisibilityToggle, isHidden) {
+ var node = workInProgress.child;
+
+ while (node !== null) {
+ if (node.tag === HostComponent || node.tag === HostText) {
+ appendInitialChild(parent, node.stateNode);
+ } else if (node.tag === HostPortal) {} else if (node.child !== null) {
+ node.child.return = node;
+ node = node.child;
+ continue;
+ }
+
+ if (node === workInProgress) {
+ return;
+ }
+
+ while (node.sibling === null) {
+ if (node.return === null || node.return === workInProgress) {
+ return;
+ }
+
+ node = node.return;
+ }
+
+ node.sibling.return = node.return;
+ node = node.sibling;
+ }
+ };
+
+ updateHostContainer = function updateHostContainer(workInProgress) {};
+
+ updateHostComponent$1 = function updateHostComponent$1(current, workInProgress, type, newProps, rootContainerInstance) {
+ var oldProps = current.memoizedProps;
+
+ if (oldProps === newProps) {
+ return;
+ }
+
+ var instance = workInProgress.stateNode;
+ var currentHostContext = getHostContext();
+ var updatePayload = prepareUpdate(instance, type, oldProps, newProps, rootContainerInstance, currentHostContext);
+ workInProgress.updateQueue = updatePayload;
+
+ if (updatePayload) {
+ markUpdate(workInProgress);
+ }
+ };
+
+ updateHostText$1 = function updateHostText$1(current, workInProgress, oldText, newText) {
+ if (oldText !== newText) {
+ markUpdate(workInProgress);
+ }
+ };
+ } else if (supportsPersistence) {
+ _appendAllChildren = function appendAllChildren(parent, workInProgress, needsVisibilityToggle, isHidden) {
+ var node = workInProgress.child;
+
+ while (node !== null) {
+ branches: if (node.tag === HostComponent) {
+ var instance = node.stateNode;
+
+ if (needsVisibilityToggle) {
+ var props = node.memoizedProps;
+ var type = node.type;
+
+ if (isHidden) {
+ instance = cloneHiddenInstance(instance, type, props, node);
+ } else {
+ instance = cloneUnhiddenInstance(instance, type, props, node);
+ }
+
+ node.stateNode = instance;
+ }
+
+ appendInitialChild(parent, instance);
+ } else if (node.tag === HostText) {
+ var _instance = node.stateNode;
+
+ if (needsVisibilityToggle) {
+ var text = node.memoizedProps;
+ var rootContainerInstance = getRootHostContainer();
+ var currentHostContext = getHostContext();
+
+ if (isHidden) {
+ _instance = createHiddenTextInstance(text, rootContainerInstance, currentHostContext, workInProgress);
+ } else {
+ _instance = createTextInstance(text, rootContainerInstance, currentHostContext, workInProgress);
+ }
+
+ node.stateNode = _instance;
+ }
+
+ appendInitialChild(parent, _instance);
+ } else if (node.tag === HostPortal) {} else if (node.tag === SuspenseComponent) {
+ var current = node.alternate;
+
+ if (current !== null) {
+ var oldState = current.memoizedState;
+ var newState = node.memoizedState;
+ var oldIsHidden = oldState !== null;
+ var newIsHidden = newState !== null;
+
+ if (oldIsHidden !== newIsHidden) {
+ var primaryChildParent = newIsHidden ? node.child : node;
+
+ if (primaryChildParent !== null) {
+ _appendAllChildren(parent, primaryChildParent, true, newIsHidden);
+ }
+
+ break branches;
+ }
+ }
+
+ if (node.child !== null) {
+ node.child.return = node;
+ node = node.child;
+ continue;
+ }
+ } else if (node.child !== null) {
+ node.child.return = node;
+ node = node.child;
+ continue;
+ }
+
+ node = node;
+
+ if (node === workInProgress) {
+ return;
+ }
+
+ while (node.sibling === null) {
+ if (node.return === null || node.return === workInProgress) {
+ return;
+ }
+
+ node = node.return;
+ }
+
+ node.sibling.return = node.return;
+ node = node.sibling;
+ }
+ };
+
+ var appendAllChildrenToContainer = function appendAllChildrenToContainer(containerChildSet, workInProgress, needsVisibilityToggle, isHidden) {
+ var node = workInProgress.child;
+
+ while (node !== null) {
+ branches: if (node.tag === HostComponent) {
+ var instance = node.stateNode;
+
+ if (needsVisibilityToggle) {
+ var props = node.memoizedProps;
+ var type = node.type;
+
+ if (isHidden) {
+ instance = cloneHiddenInstance(instance, type, props, node);
+ } else {
+ instance = cloneUnhiddenInstance(instance, type, props, node);
+ }
+
+ node.stateNode = instance;
+ }
+
+ appendChildToContainerChildSet(containerChildSet, instance);
+ } else if (node.tag === HostText) {
+ var _instance2 = node.stateNode;
+
+ if (needsVisibilityToggle) {
+ var text = node.memoizedProps;
+ var rootContainerInstance = getRootHostContainer();
+ var currentHostContext = getHostContext();
+
+ if (isHidden) {
+ _instance2 = createHiddenTextInstance(text, rootContainerInstance, currentHostContext, workInProgress);
+ } else {
+ _instance2 = createTextInstance(text, rootContainerInstance, currentHostContext, workInProgress);
+ }
+
+ node.stateNode = _instance2;
+ }
+
+ appendChildToContainerChildSet(containerChildSet, _instance2);
+ } else if (node.tag === HostPortal) {} else if (node.tag === SuspenseComponent) {
+ var current = node.alternate;
+
+ if (current !== null) {
+ var oldState = current.memoizedState;
+ var newState = node.memoizedState;
+ var oldIsHidden = oldState !== null;
+ var newIsHidden = newState !== null;
+
+ if (oldIsHidden !== newIsHidden) {
+ var primaryChildParent = newIsHidden ? node.child : node;
+
+ if (primaryChildParent !== null) {
+ appendAllChildrenToContainer(containerChildSet, primaryChildParent, true, newIsHidden);
+ }
+
+ break branches;
+ }
+ }
+
+ if (node.child !== null) {
+ node.child.return = node;
+ node = node.child;
+ continue;
+ }
+ } else if (node.child !== null) {
+ node.child.return = node;
+ node = node.child;
+ continue;
+ }
+
+ node = node;
+
+ if (node === workInProgress) {
+ return;
+ }
+
+ while (node.sibling === null) {
+ if (node.return === null || node.return === workInProgress) {
+ return;
+ }
+
+ node = node.return;
+ }
+
+ node.sibling.return = node.return;
+ node = node.sibling;
+ }
+ };
+
+ updateHostContainer = function updateHostContainer(workInProgress) {
+ var portalOrRoot = workInProgress.stateNode;
+ var childrenUnchanged = workInProgress.firstEffect === null;
+
+ if (childrenUnchanged) {} else {
+ var container = portalOrRoot.containerInfo;
+ var newChildSet = createContainerChildSet(container);
+ appendAllChildrenToContainer(newChildSet, workInProgress, false, false);
+ portalOrRoot.pendingChildren = newChildSet;
+ markUpdate(workInProgress);
+ finalizeContainerChildren(container, newChildSet);
+ }
+ };
+
+ updateHostComponent$1 = function updateHostComponent$1(current, workInProgress, type, newProps, rootContainerInstance) {
+ var currentInstance = current.stateNode;
+ var oldProps = current.memoizedProps;
+ var childrenUnchanged = workInProgress.firstEffect === null;
+
+ if (childrenUnchanged && oldProps === newProps) {
+ workInProgress.stateNode = currentInstance;
+ return;
+ }
+
+ var recyclableInstance = workInProgress.stateNode;
+ var currentHostContext = getHostContext();
+ var updatePayload = null;
+
+ if (oldProps !== newProps) {
+ updatePayload = prepareUpdate(recyclableInstance, type, oldProps, newProps, rootContainerInstance, currentHostContext);
+ }
+
+ if (childrenUnchanged && updatePayload === null) {
+ workInProgress.stateNode = currentInstance;
+ return;
+ }
+
+ var newInstance = cloneInstance(currentInstance, updatePayload, type, oldProps, newProps, workInProgress, childrenUnchanged, recyclableInstance);
+
+ if (finalizeInitialChildren(newInstance, type, newProps, rootContainerInstance, currentHostContext)) {
+ markUpdate(workInProgress);
+ }
+
+ workInProgress.stateNode = newInstance;
+
+ if (childrenUnchanged) {
+ markUpdate(workInProgress);
+ } else {
+ _appendAllChildren(newInstance, workInProgress, false, false);
+ }
+ };
+
+ updateHostText$1 = function updateHostText$1(current, workInProgress, oldText, newText) {
+ if (oldText !== newText) {
+ var rootContainerInstance = getRootHostContainer();
+ var currentHostContext = getHostContext();
+ workInProgress.stateNode = createTextInstance(newText, rootContainerInstance, currentHostContext, workInProgress);
+ markUpdate(workInProgress);
+ }
+ };
+ } else {
+ updateHostContainer = function updateHostContainer(workInProgress) {};
+
+ updateHostComponent$1 = function updateHostComponent$1(current, workInProgress, type, newProps, rootContainerInstance) {};
+
+ updateHostText$1 = function updateHostText$1(current, workInProgress, oldText, newText) {};
+ }
+
+ function completeWork(current, workInProgress, renderExpirationTime) {
+ var newProps = workInProgress.pendingProps;
+
+ switch (workInProgress.tag) {
+ case IndeterminateComponent:
+ break;
+
+ case LazyComponent:
+ break;
+
+ case SimpleMemoComponent:
+ case FunctionComponent:
+ break;
+
+ case ClassComponent:
+ {
+ var Component = workInProgress.type;
+
+ if (isContextProvider(Component)) {
+ popContext(workInProgress);
+ }
+
+ break;
+ }
+
+ case HostRoot:
+ {
+ popHostContainer(workInProgress);
+ popTopLevelContextObject(workInProgress);
+ var fiberRoot = workInProgress.stateNode;
+
+ if (fiberRoot.pendingContext) {
+ fiberRoot.context = fiberRoot.pendingContext;
+ fiberRoot.pendingContext = null;
+ }
+
+ if (current === null || current.child === null) {
+ popHydrationState(workInProgress);
+ workInProgress.effectTag &= ~Placement;
+ }
+
+ updateHostContainer(workInProgress);
+ break;
+ }
+
+ case HostComponent:
+ {
+ popHostContext(workInProgress);
+ var rootContainerInstance = getRootHostContainer();
+ var type = workInProgress.type;
+
+ if (current !== null && workInProgress.stateNode != null) {
+ updateHostComponent$1(current, workInProgress, type, newProps, rootContainerInstance);
+
+ if (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.");
+ break;
+ }
+
+ 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, false, false);
+
+ if (finalizeInitialChildren(instance, type, newProps, rootContainerInstance, currentHostContext)) {
+ markUpdate(workInProgress);
+ }
+
+ workInProgress.stateNode = instance;
+ }
+
+ if (workInProgress.ref !== null) {
+ markRef$1(workInProgress);
+ }
+ }
+
+ break;
+ }
+
+ case HostText:
+ {
+ var newText = newProps;
+
+ if (current && workInProgress.stateNode != null) {
+ var oldText = current.memoizedProps;
+ updateHostText$1(current, workInProgress, oldText, newText);
+ } else {
+ if (typeof newText !== "string") {
+ 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.");
+ }
+
+ var _rootContainerInstance = getRootHostContainer();
+
+ var _currentHostContext = getHostContext();
+
+ var _wasHydrated = popHydrationState(workInProgress);
+
+ if (_wasHydrated) {
+ if (prepareToHydrateHostTextInstance(workInProgress)) {
+ markUpdate(workInProgress);
+ }
+ } else {
+ workInProgress.stateNode = createTextInstance(newText, _rootContainerInstance, _currentHostContext, workInProgress);
+ }
+ }
+
+ break;
+ }
+
+ case ForwardRef:
+ break;
+
+ case SuspenseComponent:
+ {
+ var nextState = workInProgress.memoizedState;
+
+ if ((workInProgress.effectTag & DidCapture) !== NoEffect) {
+ workInProgress.expirationTime = renderExpirationTime;
+ return workInProgress;
+ }
+
+ var nextDidTimeout = nextState !== null;
+ var prevDidTimeout = current !== null && current.memoizedState !== null;
+
+ if (current === null) {
+ popHydrationState(workInProgress);
+ } else if (!nextDidTimeout && prevDidTimeout) {
+ var currentFallbackChild = current.child.sibling;
+
+ if (currentFallbackChild !== null) {
+ var first = workInProgress.firstEffect;
+
+ if (first !== null) {
+ workInProgress.firstEffect = currentFallbackChild;
+ currentFallbackChild.nextEffect = first;
+ } else {
+ workInProgress.firstEffect = workInProgress.lastEffect = currentFallbackChild;
+ currentFallbackChild.nextEffect = null;
+ }
+
+ currentFallbackChild.effectTag = Deletion;
+ }
+ }
+
+ if (nextDidTimeout || prevDidTimeout) {
+ workInProgress.effectTag |= Update;
+ }
+
+ break;
+ }
+
+ case Fragment:
+ break;
+
+ case Mode:
+ break;
+
+ case Profiler:
+ break;
+
+ case HostPortal:
+ popHostContainer(workInProgress);
+ updateHostContainer(workInProgress);
+ break;
+
+ case ContextProvider:
+ popProvider(workInProgress);
+ break;
+
+ case ContextConsumer:
+ break;
+
+ case MemoComponent:
+ break;
+
+ case IncompleteClassComponent:
+ {
+ var _Component = workInProgress.type;
+
+ if (isContextProvider(_Component)) {
+ popContext(workInProgress);
+ }
+
+ break;
+ }
+
+ case DehydratedSuspenseComponent:
+ {
+ if (enableSuspenseServerRenderer) {
+ if (current === null) {
+ var _wasHydrated2 = popHydrationState(workInProgress);
+
+ invariant(_wasHydrated2, "A dehydrated suspense component was completed without a hydrated node. " + "This is probably a bug in React.");
+ skipPastDehydratedSuspenseInstance(workInProgress);
+ } else if ((workInProgress.effectTag & DidCapture) === NoEffect) {
+ current.alternate = null;
+ workInProgress.alternate = null;
+ workInProgress.tag = SuspenseComponent;
+ workInProgress.memoizedState = null;
+ workInProgress.stateNode = null;
+ }
+ }
+
+ break;
+ }
+
+ default:
+ invariant(false, "Unknown unit of work tag. This error is likely caused by a bug in " + "React. Please file an issue.");
+ }
+
+ return null;
+ }
+
+ function shouldCaptureSuspense(workInProgress) {
+ if (workInProgress.memoizedProps.fallback === undefined) {
+ return false;
+ }
+
+ var nextState = workInProgress.memoizedState;
+ return nextState === null;
+ }
+
+ 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 componentName = capturedError.componentName,
+ componentStack = capturedError.componentStack,
+ errorBoundaryName = capturedError.errorBoundaryName,
+ errorBoundaryFound = capturedError.errorBoundaryFound,
+ willRetry = capturedError.willRetry;
+
+ if (error != null && error._suppressLogging) {
+ if (errorBoundaryFound && willRetry) {
+ return;
+ }
+
+ console.error(error);
+ }
+
+ var componentNameMessage = componentName ? "The above error occurred in the <" + componentName + "> component:" : "The above error occurred in one of your React components:";
+ var errorBoundaryMessage = void 0;
+
+ if (errorBoundaryFound && errorBoundaryName) {
+ if (willRetry) {
+ errorBoundaryMessage = "React will try to recreate this component tree from scratch " + ("using the error boundary you provided, " + errorBoundaryName + ".");
+ } else {
+ errorBoundaryMessage = "This error was initially handled by the error boundary " + errorBoundaryName + ".\n" + "Recreating the tree from scratch failed so React will unmount the tree.";
+ }
+ } else {
+ errorBoundaryMessage = "Consider adding an error boundary to your tree to customize error handling behavior.\n" + "Visit https://fb.me/react-error-boundaries to learn more about error boundaries.";
+ }
+
+ var combinedMessage = "" + componentNameMessage + componentStack + "\n\n" + ("" + errorBoundaryMessage);
+ console.error(combinedMessage);
+ }
+ }
+
+ var didWarnAboutUndefinedSnapshotBeforeUpdate = null;
+ {
+ didWarnAboutUndefinedSnapshotBeforeUpdate = new Set();
+ }
+ var PossiblyWeakSet$1 = typeof WeakSet === "function" ? WeakSet : Set;
+
+ function logError(boundary, errorInfo) {
+ var source = errorInfo.source;
+ var stack = errorInfo.stack;
+
+ if (stack === null && source !== null) {
+ stack = getStackByFiberInDevAndProd(source);
+ }
+
+ var capturedError = {
+ componentName: source !== null ? getComponentName(source.type) : null,
+ componentStack: stack !== null ? stack : "",
+ error: errorInfo.value,
+ errorBoundary: null,
+ errorBoundaryName: null,
+ errorBoundaryFound: false,
+ willRetry: false
+ };
+
+ if (boundary !== null && boundary.tag === ClassComponent) {
+ capturedError.errorBoundary = boundary.stateNode;
+ capturedError.errorBoundaryName = getComponentName(boundary.type);
+ capturedError.errorBoundaryFound = true;
+ capturedError.willRetry = true;
+ }
+
+ try {
+ logCapturedError(capturedError);
+ } catch (e) {
+ setTimeout(function () {
+ throw e;
+ });
+ }
+ }
+
+ var callComponentWillUnmountWithTimer = function callComponentWillUnmountWithTimer(current$$1, instance) {
+ startPhaseTimer(current$$1, "componentWillUnmount");
+ instance.props = current$$1.memoizedProps;
+ instance.state = current$$1.memoizedState;
+ instance.componentWillUnmount();
+ stopPhaseTimer();
+ };
+
+ function safelyCallComponentWillUnmount(current$$1, instance) {
+ {
+ invokeGuardedCallback(null, callComponentWillUnmountWithTimer, null, current$$1, instance);
+
+ if (hasCaughtError()) {
+ var unmountError = clearCaughtError();
+ captureCommitPhaseError(current$$1, unmountError);
+ }
+ }
+ }
+
+ function safelyDetachRef(current$$1) {
+ var ref = current$$1.ref;
+
+ if (ref !== null) {
+ if (typeof ref === "function") {
+ {
+ invokeGuardedCallback(null, ref, null, null);
+
+ if (hasCaughtError()) {
+ var refError = clearCaughtError();
+ captureCommitPhaseError(current$$1, refError);
+ }
+ }
+ } else {
+ ref.current = null;
+ }
+ }
+ }
+
+ function safelyCallDestroy(current$$1, destroy) {
+ {
+ invokeGuardedCallback(null, destroy, null);
+
+ if (hasCaughtError()) {
+ var error = clearCaughtError();
+ captureCommitPhaseError(current$$1, error);
+ }
+ }
+ }
+
+ function commitBeforeMutationLifeCycles(current$$1, finishedWork) {
+ switch (finishedWork.tag) {
+ case FunctionComponent:
+ case ForwardRef:
+ case SimpleMemoComponent:
+ {
+ commitHookEffectList(UnmountSnapshot, NoEffect$1, finishedWork);
+ return;
+ }
+
+ case ClassComponent:
+ {
+ if (finishedWork.effectTag & Snapshot) {
+ if (current$$1 !== null) {
+ var prevProps = current$$1.memoizedProps;
+ var prevState = current$$1.memoizedState;
+ startPhaseTimer(finishedWork, "getSnapshotBeforeUpdate");
+ var instance = finishedWork.stateNode;
+ {
+ if (finishedWork.type === finishedWork.elementType && !didWarnAboutReassigningProps) {
+ !(instance.props === finishedWork.memoizedProps) ? warning$1(false, "Expected %s props to match memoized props before " + "getSnapshotBeforeUpdate. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
+ !(instance.state === finishedWork.memoizedState) ? warning$1(false, "Expected %s state to match memoized state before " + "getSnapshotBeforeUpdate. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
+ }
+ }
+ var snapshot = instance.getSnapshotBeforeUpdate(finishedWork.elementType === finishedWork.type ? prevProps : resolveDefaultProps(finishedWork.type, prevProps), prevState);
+ {
+ var didWarnSet = didWarnAboutUndefinedSnapshotBeforeUpdate;
+
+ if (snapshot === undefined && !didWarnSet.has(finishedWork.type)) {
+ didWarnSet.add(finishedWork.type);
+ warningWithoutStack$1(false, "%s.getSnapshotBeforeUpdate(): A snapshot value (or null) " + "must be returned. You have returned undefined.", getComponentName(finishedWork.type));
+ }
+ }
+ instance.__reactInternalSnapshotBeforeUpdate = snapshot;
+ stopPhaseTimer();
+ }
+ }
+
+ return;
+ }
+
+ case HostRoot:
+ case HostComponent:
+ case HostText:
+ case HostPortal:
+ case IncompleteClassComponent:
+ return;
+
+ default:
+ {
+ 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 commitHookEffectList(unmountTag, mountTag, finishedWork) {
+ var updateQueue = finishedWork.updateQueue;
+ var lastEffect = updateQueue !== null ? updateQueue.lastEffect : null;
+
+ if (lastEffect !== null) {
+ var firstEffect = lastEffect.next;
+ var effect = firstEffect;
+
+ do {
+ if ((effect.tag & unmountTag) !== NoEffect$1) {
+ var destroy = effect.destroy;
+ effect.destroy = undefined;
+
+ if (destroy !== undefined) {
+ destroy();
+ }
+ }
+
+ if ((effect.tag & mountTag) !== NoEffect$1) {
+ var create = effect.create;
+ effect.destroy = create();
+ {
+ var _destroy = effect.destroy;
+
+ if (_destroy !== undefined && typeof _destroy !== "function") {
+ var addendum = void 0;
+
+ if (_destroy === null) {
+ addendum = " You returned null. If your effect does not require clean " + "up, return undefined (or nothing).";
+ } else if (typeof _destroy.then === "function") {
+ addendum = "\n\nIt looks like you wrote useEffect(async () => ...) or returned a Promise. " + "Instead, you may write an async function separately " + "and then call it from inside the effect:\n\n" + "async function fetchComment(commentId) {\n" + " // You can await here\n" + "}\n\n" + "useEffect(() => {\n" + " fetchComment(commentId);\n" + "}, [commentId]);\n\n" + "In the future, React will provide a more idiomatic solution for data fetching " + "that doesn't involve writing effects manually.";
+ } else {
+ addendum = " You returned: " + _destroy;
+ }
+
+ warningWithoutStack$1(false, "An Effect function must not return anything besides a function, " + "which is used for clean-up.%s%s", addendum, getStackByFiberInDevAndProd(finishedWork));
+ }
+ }
+ }
+
+ effect = effect.next;
+ } while (effect !== firstEffect);
+ }
+ }
+
+ function commitPassiveHookEffects(finishedWork) {
+ commitHookEffectList(UnmountPassive, NoEffect$1, finishedWork);
+ commitHookEffectList(NoEffect$1, MountPassive, finishedWork);
+ }
+
+ function commitLifeCycles(finishedRoot, current$$1, finishedWork, committedExpirationTime) {
+ switch (finishedWork.tag) {
+ case FunctionComponent:
+ case ForwardRef:
+ case SimpleMemoComponent:
+ {
+ commitHookEffectList(UnmountLayout, MountLayout, finishedWork);
+ break;
+ }
+
+ case ClassComponent:
+ {
+ var instance = finishedWork.stateNode;
+
+ if (finishedWork.effectTag & Update) {
+ if (current$$1 === null) {
+ startPhaseTimer(finishedWork, "componentDidMount");
+ {
+ if (finishedWork.type === finishedWork.elementType && !didWarnAboutReassigningProps) {
+ !(instance.props === finishedWork.memoizedProps) ? warning$1(false, "Expected %s props to match memoized props before " + "componentDidMount. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
+ !(instance.state === finishedWork.memoizedState) ? warning$1(false, "Expected %s state to match memoized state before " + "componentDidMount. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
+ }
+ }
+ instance.componentDidMount();
+ stopPhaseTimer();
+ } else {
+ var prevProps = finishedWork.elementType === finishedWork.type ? current$$1.memoizedProps : resolveDefaultProps(finishedWork.type, current$$1.memoizedProps);
+ var prevState = current$$1.memoizedState;
+ startPhaseTimer(finishedWork, "componentDidUpdate");
+ {
+ if (finishedWork.type === finishedWork.elementType && !didWarnAboutReassigningProps) {
+ !(instance.props === finishedWork.memoizedProps) ? warning$1(false, "Expected %s props to match memoized props before " + "componentDidUpdate. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
+ !(instance.state === finishedWork.memoizedState) ? warning$1(false, "Expected %s state to match memoized state before " + "componentDidUpdate. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
+ }
+ }
+ instance.componentDidUpdate(prevProps, prevState, instance.__reactInternalSnapshotBeforeUpdate);
+ stopPhaseTimer();
+ }
+ }
+
+ var updateQueue = finishedWork.updateQueue;
+
+ if (updateQueue !== null) {
+ {
+ if (finishedWork.type === finishedWork.elementType && !didWarnAboutReassigningProps) {
+ !(instance.props === finishedWork.memoizedProps) ? warning$1(false, "Expected %s props to match memoized props before " + "processing the update queue. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
+ !(instance.state === finishedWork.memoizedState) ? warning$1(false, "Expected %s state to match memoized state before " + "processing the update queue. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
+ }
+ }
+ commitUpdateQueue(finishedWork, updateQueue, instance, committedExpirationTime);
+ }
+
+ return;
+ }
+
+ case HostRoot:
+ {
+ var _updateQueue = finishedWork.updateQueue;
+
+ if (_updateQueue !== null) {
+ var _instance = null;
+
+ if (finishedWork.child !== null) {
+ switch (finishedWork.child.tag) {
+ case HostComponent:
+ _instance = getPublicInstance(finishedWork.child.stateNode);
+ break;
+
+ case ClassComponent:
+ _instance = finishedWork.child.stateNode;
+ break;
+ }
+ }
+
+ commitUpdateQueue(finishedWork, _updateQueue, _instance, committedExpirationTime);
+ }
+
+ return;
+ }
+
+ case HostComponent:
+ {
+ var _instance2 = finishedWork.stateNode;
+
+ if (current$$1 === null && finishedWork.effectTag & Update) {
+ var type = finishedWork.type;
+ var props = finishedWork.memoizedProps;
+ commitMount(_instance2, type, props, finishedWork);
+ }
+
+ return;
+ }
+
+ case HostText:
+ {
+ return;
+ }
+
+ case HostPortal:
+ {
+ return;
+ }
+
+ case Profiler:
+ {
+ if (enableProfilerTimer) {
+ var onRender = finishedWork.memoizedProps.onRender;
+
+ if (enableSchedulerTracing) {
+ onRender(finishedWork.memoizedProps.id, current$$1 === null ? "mount" : "update", finishedWork.actualDuration, finishedWork.treeBaseDuration, finishedWork.actualStartTime, getCommitTime(), finishedRoot.memoizedInteractions);
+ } else {
+ onRender(finishedWork.memoizedProps.id, current$$1 === null ? "mount" : "update", finishedWork.actualDuration, finishedWork.treeBaseDuration, finishedWork.actualStartTime, getCommitTime());
+ }
+ }
+
+ return;
+ }
+
+ case SuspenseComponent:
+ break;
+
+ case IncompleteClassComponent:
+ break;
+
+ 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 hideOrUnhideAllChildren(finishedWork, isHidden) {
+ if (supportsMutation) {
+ var node = finishedWork;
+
+ while (true) {
+ if (node.tag === HostComponent) {
+ var instance = node.stateNode;
+
+ if (isHidden) {
+ hideInstance(instance);
+ } else {
+ unhideInstance(node.stateNode, node.memoizedProps);
+ }
+ } else if (node.tag === HostText) {
+ var _instance3 = node.stateNode;
+
+ if (isHidden) {
+ hideTextInstance(_instance3);
+ } else {
+ unhideTextInstance(_instance3, node.memoizedProps);
+ }
+ } else if (node.tag === SuspenseComponent && node.memoizedState !== null) {
+ var fallbackChildFragment = node.child.sibling;
+ fallbackChildFragment.return = node;
+ node = fallbackChildFragment;
+ continue;
+ } else if (node.child !== null) {
+ node.child.return = node;
+ node = node.child;
+ continue;
+ }
+
+ if (node === finishedWork) {
+ return;
+ }
+
+ while (node.sibling === null) {
+ if (node.return === null || node.return === finishedWork) {
+ return;
+ }
+
+ node = node.return;
+ }
+
+ node.sibling.return = node.return;
+ node = node.sibling;
+ }
+ }
+ }
+
+ function commitAttachRef(finishedWork) {
+ var ref = finishedWork.ref;
+
+ if (ref !== null) {
+ var instance = finishedWork.stateNode;
+ var instanceToUse = void 0;
+
+ switch (finishedWork.tag) {
+ case HostComponent:
+ instanceToUse = getPublicInstance(instance);
+ break;
+
+ default:
+ instanceToUse = instance;
+ }
+
+ if (typeof ref === "function") {
+ ref(instanceToUse);
+ } else {
+ {
+ if (!ref.hasOwnProperty("current")) {
+ warningWithoutStack$1(false, "Unexpected ref object provided for %s. " + "Use either a ref-setter function or React.createRef().%s", getComponentName(finishedWork.type), getStackByFiberInDevAndProd(finishedWork));
+ }
+ }
+ ref.current = instanceToUse;
+ }
+ }
+ }
+
+ function commitDetachRef(current$$1) {
+ var currentRef = current$$1.ref;
+
+ if (currentRef !== null) {
+ if (typeof currentRef === "function") {
+ currentRef(null);
+ } else {
+ currentRef.current = null;
+ }
+ }
+ }
+
+ function commitUnmount(current$$1) {
+ onCommitUnmount(current$$1);
+
+ switch (current$$1.tag) {
+ case FunctionComponent:
+ case ForwardRef:
+ case MemoComponent:
+ case SimpleMemoComponent:
+ {
+ var updateQueue = current$$1.updateQueue;
+
+ if (updateQueue !== null) {
+ var lastEffect = updateQueue.lastEffect;
+
+ if (lastEffect !== null) {
+ var firstEffect = lastEffect.next;
+ var effect = firstEffect;
+
+ do {
+ var destroy = effect.destroy;
+
+ if (destroy !== undefined) {
+ safelyCallDestroy(current$$1, destroy);
+ }
+
+ effect = effect.next;
+ } while (effect !== firstEffect);
+ }
+ }
+
+ break;
+ }
+
+ case ClassComponent:
+ {
+ safelyDetachRef(current$$1);
+ var instance = current$$1.stateNode;
+
+ if (typeof instance.componentWillUnmount === "function") {
+ safelyCallComponentWillUnmount(current$$1, instance);
+ }
+
+ return;
+ }
+
+ case HostComponent:
+ {
+ safelyDetachRef(current$$1);
+ return;
+ }
+
+ case HostPortal:
+ {
+ if (supportsMutation) {
+ unmountHostComponents(current$$1);
+ } else if (supportsPersistence) {
+ emptyPortalContainer(current$$1);
+ }
+
+ 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$$1) {
+ current$$1.return = null;
+ current$$1.child = null;
+ current$$1.memoizedState = null;
+ current$$1.updateQueue = null;
+ var alternate = current$$1.alternate;
+
+ if (alternate !== null) {
+ alternate.return = null;
+ alternate.child = null;
+ alternate.memoizedState = null;
+ alternate.updateQueue = null;
+ }
+ }
+
+ function emptyPortalContainer(current$$1) {
+ if (!supportsPersistence) {
+ return;
+ }
+
+ var portal = current$$1.stateNode;
+ var containerInfo = portal.containerInfo;
+ var emptyChildSet = createContainerChildSet(containerInfo);
+ }
+
+ function commitContainer(finishedWork) {
+ if (!supportsPersistence) {
+ return;
+ }
+
+ switch (finishedWork.tag) {
+ case ClassComponent:
+ {
+ 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 && node.tag !== DehydratedSuspenseComponent) {
+ if (node.effectTag & Placement) {
+ continue siblings;
+ }
+
+ if (node.child === null || node.tag === HostPortal) {
+ continue siblings;
+ } else {
+ node.child.return = node;
+ node = node.child;
+ }
+ }
+
+ if (!(node.effectTag & Placement)) {
+ return node.stateNode;
+ }
+ }
+ }
+
+ function commitPlacement(finishedWork) {
+ if (!supportsMutation) {
+ return;
+ }
+
+ var parentFiber = getHostParentFiber(finishedWork);
+ var parent = void 0;
+ var isContainer = void 0;
+
+ 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$$1) {
+ var node = current$$1;
+ var currentParentIsValid = false;
+ var currentParent = void 0;
+ var currentParentIsContainer = void 0;
+
+ while (true) {
+ if (!currentParentIsValid) {
+ var parent = node.return;
+
+ findParent: while (true) {
+ 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 (enableSuspenseServerRenderer && node.tag === DehydratedSuspenseComponent) {
+ if (currentParentIsContainer) {
+ clearSuspenseBoundaryFromContainer(currentParent, node.stateNode);
+ } else {
+ clearSuspenseBoundary(currentParent, node.stateNode);
+ }
+ } else if (node.tag === HostPortal) {
+ if (node.child !== null) {
+ currentParent = node.stateNode.containerInfo;
+ currentParentIsContainer = true;
+ node.child.return = node;
+ node = node.child;
+ continue;
+ }
+ } else {
+ commitUnmount(node);
+
+ if (node.child !== null) {
+ node.child.return = node;
+ node = node.child;
+ continue;
+ }
+ }
+
+ if (node === current$$1) {
+ return;
+ }
+
+ while (node.sibling === null) {
+ if (node.return === null || node.return === current$$1) {
+ return;
+ }
+
+ node = node.return;
+
+ if (node.tag === HostPortal) {
+ currentParentIsValid = false;
+ }
+ }
+
+ node.sibling.return = node.return;
+ node = node.sibling;
+ }
+ }
+
+ function commitDeletion(current$$1) {
+ if (supportsMutation) {
+ unmountHostComponents(current$$1);
+ } else {
+ commitNestedUnmounts(current$$1);
+ }
+
+ detachFiber(current$$1);
+ }
+
+ function commitWork(current$$1, finishedWork) {
+ if (!supportsMutation) {
+ switch (finishedWork.tag) {
+ case FunctionComponent:
+ case ForwardRef:
+ case MemoComponent:
+ case SimpleMemoComponent:
+ {
+ commitHookEffectList(UnmountMutation, MountMutation, finishedWork);
+ return;
+ }
+ }
+
+ commitContainer(finishedWork);
+ return;
+ }
+
+ switch (finishedWork.tag) {
+ case FunctionComponent:
+ case ForwardRef:
+ case MemoComponent:
+ case SimpleMemoComponent:
+ {
+ commitHookEffectList(UnmountMutation, MountMutation, finishedWork);
+ return;
+ }
+
+ case ClassComponent:
+ {
+ return;
+ }
+
+ case HostComponent:
+ {
+ var instance = finishedWork.stateNode;
+
+ if (instance != null) {
+ var newProps = finishedWork.memoizedProps;
+ var oldProps = current$$1 !== null ? current$$1.memoizedProps : newProps;
+ var type = finishedWork.type;
+ var updatePayload = finishedWork.updateQueue;
+ finishedWork.updateQueue = null;
+
+ if (updatePayload !== null) {
+ commitUpdate(instance, updatePayload, type, oldProps, newProps, finishedWork);
+ }
+ }
+
+ return;
+ }
+
+ case HostText:
+ {
+ 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$$1 !== null ? current$$1.memoizedProps : newText;
+ commitTextUpdate(textInstance, oldText, newText);
+ return;
+ }
+
+ case HostRoot:
+ {
+ return;
+ }
+
+ case Profiler:
+ {
+ return;
+ }
+
+ case SuspenseComponent:
+ {
+ var newState = finishedWork.memoizedState;
+ var newDidTimeout = void 0;
+ var primaryChildParent = finishedWork;
+
+ if (newState === null) {
+ newDidTimeout = false;
+ } else {
+ newDidTimeout = true;
+ primaryChildParent = finishedWork.child;
+
+ if (newState.timedOutAt === NoWork) {
+ newState.timedOutAt = requestCurrentTime();
+ }
+ }
+
+ if (primaryChildParent !== null) {
+ hideOrUnhideAllChildren(primaryChildParent, newDidTimeout);
+ }
+
+ var thenables = finishedWork.updateQueue;
+
+ if (thenables !== null) {
+ finishedWork.updateQueue = null;
+ var retryCache = finishedWork.stateNode;
+
+ if (retryCache === null) {
+ retryCache = finishedWork.stateNode = new PossiblyWeakSet$1();
+ }
+
+ thenables.forEach(function (thenable) {
+ var retry = resolveRetryThenable.bind(null, finishedWork, thenable);
+
+ if (enableSchedulerTracing) {
+ retry = tracing.unstable_wrap(retry);
+ }
+
+ if (!retryCache.has(thenable)) {
+ retryCache.add(thenable);
+ thenable.then(retry, retry);
+ }
+ });
+ }
+
+ return;
+ }
+
+ case IncompleteClassComponent:
+ {
+ 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$$1) {
+ if (!supportsMutation) {
+ return;
+ }
+
+ resetTextContent(current$$1.stateNode);
+ }
+
+ var PossiblyWeakSet = typeof WeakSet === "function" ? WeakSet : Set;
+ var PossiblyWeakMap = typeof WeakMap === "function" ? WeakMap : Map;
+
+ function createRootErrorUpdate(fiber, errorInfo, expirationTime) {
+ var update = createUpdate(expirationTime);
+ 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 getDerivedStateFromError = fiber.type.getDerivedStateFromError;
+
+ if (typeof getDerivedStateFromError === "function") {
+ var error = errorInfo.value;
+
+ update.payload = function () {
+ return getDerivedStateFromError(error);
+ };
+ }
+
+ var inst = fiber.stateNode;
+
+ if (inst !== null && typeof inst.componentDidCatch === "function") {
+ update.callback = function callback() {
+ if (typeof getDerivedStateFromError !== "function") {
+ markLegacyErrorBoundaryAsFailed(this);
+ }
+
+ var error = errorInfo.value;
+ var stack = errorInfo.stack;
+ logError(fiber, errorInfo);
+ this.componentDidCatch(error, {
+ componentStack: stack !== null ? stack : ""
+ });
+ {
+ if (typeof getDerivedStateFromError !== "function") {
+ !(fiber.expirationTime === Sync) ? warningWithoutStack$1(false, "%s: Error boundaries should implement getDerivedStateFromError(). " + "In that method, return a state update to display an error message or fallback UI.", getComponentName(fiber.type) || "Unknown") : void 0;
+ }
+ }
+ };
+ }
+
+ return update;
+ }
+
+ function attachPingListener(root, renderExpirationTime, thenable) {
+ var pingCache = root.pingCache;
+ var threadIDs = void 0;
+
+ if (pingCache === null) {
+ pingCache = root.pingCache = new PossiblyWeakMap();
+ threadIDs = new Set();
+ pingCache.set(thenable, threadIDs);
+ } else {
+ threadIDs = pingCache.get(thenable);
+
+ if (threadIDs === undefined) {
+ threadIDs = new Set();
+ pingCache.set(thenable, threadIDs);
+ }
+ }
+
+ if (!threadIDs.has(renderExpirationTime)) {
+ threadIDs.add(renderExpirationTime);
+ var ping = pingSuspendedRoot.bind(null, root, thenable, renderExpirationTime);
+
+ if (enableSchedulerTracing) {
+ ping = tracing.unstable_wrap(ping);
+ }
+
+ thenable.then(ping, ping);
+ }
+ }
+
+ function throwException(root, returnFiber, sourceFiber, value, renderExpirationTime) {
+ sourceFiber.effectTag |= Incomplete;
+ sourceFiber.firstEffect = sourceFiber.lastEffect = null;
+
+ if (value !== null && typeof value === "object" && typeof value.then === "function") {
+ var thenable = value;
+ var _workInProgress = returnFiber;
+ var earliestTimeoutMs = -1;
+ var startTimeMs = -1;
+
+ do {
+ if (_workInProgress.tag === SuspenseComponent) {
+ var current$$1 = _workInProgress.alternate;
+
+ if (current$$1 !== null) {
+ var currentState = current$$1.memoizedState;
+
+ if (currentState !== null) {
+ var timedOutAt = currentState.timedOutAt;
+ startTimeMs = expirationTimeToMs(timedOutAt);
+ break;
+ }
+ }
+
+ var timeoutPropMs = _workInProgress.pendingProps.maxDuration;
+
+ if (typeof timeoutPropMs === "number") {
+ if (timeoutPropMs <= 0) {
+ earliestTimeoutMs = 0;
+ } else if (earliestTimeoutMs === -1 || timeoutPropMs < earliestTimeoutMs) {
+ earliestTimeoutMs = timeoutPropMs;
+ }
+ }
+ }
+
+ _workInProgress = _workInProgress.return;
+ } while (_workInProgress !== null);
+
+ _workInProgress = returnFiber;
+
+ do {
+ if (_workInProgress.tag === SuspenseComponent && shouldCaptureSuspense(_workInProgress)) {
+ var thenables = _workInProgress.updateQueue;
+
+ if (thenables === null) {
+ var updateQueue = new Set();
+ updateQueue.add(thenable);
+ _workInProgress.updateQueue = updateQueue;
+ } else {
+ thenables.add(thenable);
+ }
+
+ if ((_workInProgress.mode & ConcurrentMode) === NoEffect) {
+ _workInProgress.effectTag |= DidCapture;
+ sourceFiber.effectTag &= ~(LifecycleEffectMask | Incomplete);
+
+ if (sourceFiber.tag === ClassComponent) {
+ var currentSourceFiber = sourceFiber.alternate;
+
+ if (currentSourceFiber === null) {
+ sourceFiber.tag = IncompleteClassComponent;
+ } else {
+ var update = createUpdate(Sync);
+ update.tag = ForceUpdate;
+ enqueueUpdate(sourceFiber, update);
+ }
+ }
+
+ sourceFiber.expirationTime = Sync;
+ return;
+ }
+
+ attachPingListener(root, renderExpirationTime, thenable);
+ var absoluteTimeoutMs = void 0;
+
+ if (earliestTimeoutMs === -1) {
+ absoluteTimeoutMs = maxSigned31BitInt;
+ } else {
+ if (startTimeMs === -1) {
+ var earliestExpirationTime = findEarliestOutstandingPriorityLevel(root, renderExpirationTime);
+ var earliestExpirationTimeMs = expirationTimeToMs(earliestExpirationTime);
+ startTimeMs = earliestExpirationTimeMs - LOW_PRIORITY_EXPIRATION;
+ }
+
+ absoluteTimeoutMs = startTimeMs + earliestTimeoutMs;
+ }
+
+ renderDidSuspend(root, absoluteTimeoutMs, renderExpirationTime);
+ _workInProgress.effectTag |= ShouldCapture;
+ _workInProgress.expirationTime = renderExpirationTime;
+ return;
+ } else if (enableSuspenseServerRenderer && _workInProgress.tag === DehydratedSuspenseComponent) {
+ attachPingListener(root, renderExpirationTime, thenable);
+ var retryCache = _workInProgress.memoizedState;
+
+ if (retryCache === null) {
+ retryCache = _workInProgress.memoizedState = new PossiblyWeakSet();
+ var _current = _workInProgress.alternate;
+ invariant(_current, "A dehydrated suspense boundary must commit before trying to render. " + "This is probably a bug in React.");
+ _current.memoizedState = retryCache;
+ }
+
+ if (!retryCache.has(thenable)) {
+ retryCache.add(thenable);
+ var retry = resolveRetryThenable.bind(null, _workInProgress, thenable);
+
+ if (enableSchedulerTracing) {
+ retry = tracing.unstable_wrap(retry);
+ }
+
+ thenable.then(retry, retry);
+ }
+
+ _workInProgress.effectTag |= ShouldCapture;
+ _workInProgress.expirationTime = renderExpirationTime;
+ return;
+ }
+
+ _workInProgress = _workInProgress.return;
+ } while (_workInProgress !== null);
+
+ value = new Error((getComponentName(sourceFiber.type) || "A React component") + " suspended while rendering, but no fallback UI was specified.\n" + "\n" + "Add a component higher in the tree to " + "provide a loading indicator or placeholder to display." + getStackByFiberInDevAndProd(sourceFiber));
+ }
+
+ renderDidError();
+ value = createCapturedValue(value, sourceFiber);
+ var workInProgress = returnFiber;
+
+ do {
+ switch (workInProgress.tag) {
+ case HostRoot:
+ {
+ var _errorInfo = value;
+ workInProgress.effectTag |= ShouldCapture;
+ workInProgress.expirationTime = renderExpirationTime;
+
+ var _update = createRootErrorUpdate(workInProgress, _errorInfo, renderExpirationTime);
+
+ enqueueCapturedUpdate(workInProgress, _update);
+ return;
+ }
+
+ case ClassComponent:
+ var errorInfo = value;
+ var ctor = workInProgress.type;
+ var instance = workInProgress.stateNode;
+
+ if ((workInProgress.effectTag & DidCapture) === NoEffect && (typeof ctor.getDerivedStateFromError === "function" || instance !== null && typeof instance.componentDidCatch === "function" && !isAlreadyFailedLegacyErrorBoundary(instance))) {
+ workInProgress.effectTag |= ShouldCapture;
+ workInProgress.expirationTime = renderExpirationTime;
+
+ var _update2 = createClassErrorUpdate(workInProgress, errorInfo, renderExpirationTime);
+
+ enqueueCapturedUpdate(workInProgress, _update2);
+ return;
+ }
+
+ break;
+
+ default:
+ break;
+ }
+
+ workInProgress = workInProgress.return;
+ } while (workInProgress !== null);
+ }
+
+ function unwindWork(workInProgress, renderExpirationTime) {
+ switch (workInProgress.tag) {
+ case ClassComponent:
+ {
+ var Component = workInProgress.type;
+
+ if (isContextProvider(Component)) {
+ popContext(workInProgress);
+ }
+
+ var effectTag = workInProgress.effectTag;
+
+ if (effectTag & ShouldCapture) {
+ workInProgress.effectTag = effectTag & ~ShouldCapture | DidCapture;
+ return workInProgress;
+ }
+
+ return null;
+ }
+
+ case HostRoot:
+ {
+ popHostContainer(workInProgress);
+ popTopLevelContextObject(workInProgress);
+ var _effectTag = workInProgress.effectTag;
+ invariant((_effectTag & DidCapture) === NoEffect, "The root failed to unmount after an error. This is likely a bug in " + "React. Please file an issue.");
+ workInProgress.effectTag = _effectTag & ~ShouldCapture | DidCapture;
+ return workInProgress;
+ }
+
+ case HostComponent:
+ {
+ popHostContext(workInProgress);
+ return null;
+ }
+
+ case SuspenseComponent:
+ {
+ var _effectTag2 = workInProgress.effectTag;
+
+ if (_effectTag2 & ShouldCapture) {
+ workInProgress.effectTag = _effectTag2 & ~ShouldCapture | DidCapture;
+ return workInProgress;
+ }
+
+ return null;
+ }
+
+ case DehydratedSuspenseComponent:
+ {
+ if (enableSuspenseServerRenderer) {
+ var _effectTag3 = workInProgress.effectTag;
+
+ if (_effectTag3 & ShouldCapture) {
+ workInProgress.effectTag = _effectTag3 & ~ShouldCapture | DidCapture;
+ return workInProgress;
+ }
+ }
+
+ return null;
+ }
+
+ case HostPortal:
+ popHostContainer(workInProgress);
+ return null;
+
+ case ContextProvider:
+ popProvider(workInProgress);
+ return null;
+
+ default:
+ return null;
+ }
+ }
+
+ function unwindInterruptedWork(interruptedWork) {
+ switch (interruptedWork.tag) {
+ case ClassComponent:
+ {
+ var childContextTypes = interruptedWork.type.childContextTypes;
+
+ if (childContextTypes !== null && childContextTypes !== undefined) {
+ popContext(interruptedWork);
+ }
+
+ break;
+ }
+
+ case HostRoot:
+ {
+ popHostContainer(interruptedWork);
+ popTopLevelContextObject(interruptedWork);
+ break;
+ }
+
+ case HostComponent:
+ {
+ popHostContext(interruptedWork);
+ break;
+ }
+
+ case HostPortal:
+ popHostContainer(interruptedWork);
+ break;
+
+ case ContextProvider:
+ popProvider(interruptedWork);
+ break;
+
+ default:
+ break;
+ }
+ }
+
+ var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+ var ReactCurrentOwner$2 = ReactSharedInternals.ReactCurrentOwner;
+ var didWarnAboutStateTransition = void 0;
+ var didWarnSetStateChildContext = void 0;
+ var warnAboutUpdateOnUnmounted = void 0;
+ var warnAboutInvalidUpdates = void 0;
+
+ if (enableSchedulerTracing) {
+ invariant(tracing.__interactionsRef != null && tracing.__interactionsRef.current != null, "It is not supported to run the profiling version of a renderer (for example, `react-dom/profiling`) " + "without also replacing the `scheduler/tracing` module with `scheduler/tracing-profiling`. " + "Your bundler might have a setting for aliasing both modules. " + "Learn more at http://fb.me/react-profiling");
+ }
+
+ {
+ didWarnAboutStateTransition = false;
+ didWarnSetStateChildContext = false;
+ var didWarnStateUpdateForUnmountedComponent = {};
+
+ warnAboutUpdateOnUnmounted = function warnAboutUpdateOnUnmounted(fiber, isClass) {
+ var componentName = getComponentName(fiber.type) || "ReactComponent";
+
+ if (didWarnStateUpdateForUnmountedComponent[componentName]) {
+ return;
+ }
+
+ warningWithoutStack$1(false, "Can't perform a React state update on an unmounted component. This " + "is a no-op, but it indicates a memory leak in your application. To " + "fix, cancel all subscriptions and asynchronous tasks in %s.%s", isClass ? "the componentWillUnmount method" : "a useEffect cleanup function", getStackByFiberInDevAndProd(fiber));
+ didWarnStateUpdateForUnmountedComponent[componentName] = true;
+ };
+
+ warnAboutInvalidUpdates = function warnAboutInvalidUpdates(instance) {
+ switch (phase) {
+ case "getChildContext":
+ if (didWarnSetStateChildContext) {
+ return;
+ }
+
+ warningWithoutStack$1(false, "setState(...): Cannot call setState() inside getChildContext()");
+ didWarnSetStateChildContext = true;
+ break;
+
+ case "render":
+ if (didWarnAboutStateTransition) {
+ return;
+ }
+
+ warningWithoutStack$1(false, "Cannot update during an existing state transition (such as within " + "`render`). Render methods should be a pure function of props and state.");
+ didWarnAboutStateTransition = true;
+ break;
+ }
+ };
+ }
+ var isWorking = false;
+ var nextUnitOfWork = null;
+ var nextRoot = null;
+ var nextRenderExpirationTime = NoWork;
+ var nextLatestAbsoluteTimeoutMs = -1;
+ var nextRenderDidError = false;
+ var nextEffect = null;
+ var isCommitting$1 = false;
+ var rootWithPendingPassiveEffects = null;
+ var passiveEffectCallbackHandle = null;
+ var passiveEffectCallback = null;
+ var legacyErrorBoundariesThatAlreadyFailed = null;
+ var interruptedBy = null;
+ var stashedWorkInProgressProperties = void 0;
+ var replayUnitOfWork = void 0;
+ var mayReplayFailedUnitOfWork = void 0;
+ var isReplayingFailedUnitOfWork = void 0;
+ var originalReplayError = void 0;
+ var rethrowOriginalError = void 0;
+
+ if (true && replayFailedUnitOfWorkWithInvokeGuardedCallback) {
+ stashedWorkInProgressProperties = null;
+ mayReplayFailedUnitOfWork = true;
+ isReplayingFailedUnitOfWork = false;
+ originalReplayError = null;
+
+ replayUnitOfWork = function replayUnitOfWork(failedUnitOfWork, thrownValue, isYieldy) {
+ if (thrownValue !== null && typeof thrownValue === "object" && typeof thrownValue.then === "function") {
+ return;
+ }
+
+ if (stashedWorkInProgressProperties === null) {
+ warningWithoutStack$1(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:
+ {
+ var Component = failedUnitOfWork.type;
+
+ if (isContextProvider(Component)) {
+ popContext(failedUnitOfWork);
+ }
+
+ break;
+ }
+
+ case HostPortal:
+ popHostContainer(failedUnitOfWork);
+ break;
+
+ case ContextProvider:
+ popProvider(failedUnitOfWork);
+ break;
+ }
+
+ isReplayingFailedUnitOfWork = true;
+ originalReplayError = thrownValue;
+ invokeGuardedCallback(null, workLoop, null, isYieldy);
+ isReplayingFailedUnitOfWork = false;
+ originalReplayError = null;
+
+ if (hasCaughtError()) {
+ var replayError = clearCaughtError();
+
+ if (replayError != null && thrownValue != null) {
+ try {
+ if (replayError._suppressLogging) {
+ thrownValue._suppressLogging = true;
+ }
+ } catch (inner) {}
+ }
+ } 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;
+ nextLatestAbsoluteTimeoutMs = -1;
+ nextRenderDidError = false;
+ nextUnitOfWork = null;
+ }
+
+ function commitAllHostEffects() {
+ while (nextEffect !== null) {
+ {
+ setCurrentFiber(nextEffect);
+ }
+ recordEffect();
+ var effectTag = nextEffect.effectTag;
+
+ if (effectTag & ContentReset) {
+ commitResetTextContent(nextEffect);
+ }
+
+ if (effectTag & Ref) {
+ var current$$1 = nextEffect.alternate;
+
+ if (current$$1 !== null) {
+ commitDetachRef(current$$1);
+ }
+ }
+
+ var primaryEffectTag = effectTag & (Placement | Update | Deletion);
+
+ switch (primaryEffectTag) {
+ case Placement:
+ {
+ commitPlacement(nextEffect);
+ nextEffect.effectTag &= ~Placement;
+ break;
+ }
+
+ case PlacementAndUpdate:
+ {
+ commitPlacement(nextEffect);
+ nextEffect.effectTag &= ~Placement;
+ var _current = nextEffect.alternate;
+ commitWork(_current, nextEffect);
+ break;
+ }
+
+ case Update:
+ {
+ var _current2 = nextEffect.alternate;
+ commitWork(_current2, nextEffect);
+ break;
+ }
+
+ case Deletion:
+ {
+ commitDeletion(nextEffect);
+ break;
+ }
+ }
+
+ nextEffect = nextEffect.nextEffect;
+ }
+
+ {
+ resetCurrentFiber();
+ }
+ }
+
+ function commitBeforeMutationLifecycles() {
+ while (nextEffect !== null) {
+ {
+ setCurrentFiber(nextEffect);
+ }
+ var effectTag = nextEffect.effectTag;
+
+ if (effectTag & Snapshot) {
+ recordEffect();
+ var current$$1 = nextEffect.alternate;
+ commitBeforeMutationLifeCycles(current$$1, nextEffect);
+ }
+
+ nextEffect = nextEffect.nextEffect;
+ }
+
+ {
+ resetCurrentFiber();
+ }
+ }
+
+ function commitAllLifeCycles(finishedRoot, committedExpirationTime) {
+ {
+ ReactStrictModeWarnings.flushPendingUnsafeLifecycleWarnings();
+ ReactStrictModeWarnings.flushLegacyContextWarning();
+
+ if (warnAboutDeprecatedLifecycles) {
+ ReactStrictModeWarnings.flushPendingDeprecationWarnings();
+ }
+ }
+
+ while (nextEffect !== null) {
+ {
+ setCurrentFiber(nextEffect);
+ }
+ var effectTag = nextEffect.effectTag;
+
+ if (effectTag & (Update | Callback)) {
+ recordEffect();
+ var current$$1 = nextEffect.alternate;
+ commitLifeCycles(finishedRoot, current$$1, nextEffect, committedExpirationTime);
+ }
+
+ if (effectTag & Ref) {
+ recordEffect();
+ commitAttachRef(nextEffect);
+ }
+
+ if (effectTag & Passive) {
+ rootWithPendingPassiveEffects = finishedRoot;
+ }
+
+ nextEffect = nextEffect.nextEffect;
+ }
+
+ {
+ resetCurrentFiber();
+ }
+ }
+
+ function commitPassiveEffects(root, firstEffect) {
+ rootWithPendingPassiveEffects = null;
+ passiveEffectCallbackHandle = null;
+ passiveEffectCallback = null;
+ var previousIsRendering = isRendering;
+ isRendering = true;
+ var effect = firstEffect;
+
+ do {
+ {
+ setCurrentFiber(effect);
+ }
+
+ if (effect.effectTag & Passive) {
+ var didError = false;
+ var error = void 0;
+ {
+ invokeGuardedCallback(null, commitPassiveHookEffects, null, effect);
+
+ if (hasCaughtError()) {
+ didError = true;
+ error = clearCaughtError();
+ }
+ }
+
+ if (didError) {
+ captureCommitPhaseError(effect, error);
+ }
+ }
+
+ effect = effect.nextEffect;
+ } while (effect !== null);
+
+ {
+ resetCurrentFiber();
+ }
+ isRendering = previousIsRendering;
+ var rootExpirationTime = root.expirationTime;
+
+ if (rootExpirationTime !== NoWork) {
+ requestWork(root, rootExpirationTime);
+ }
+
+ if (!isBatchingUpdates && !isRendering) {
+ performSyncWork();
+ }
+ }
+
+ function isAlreadyFailedLegacyErrorBoundary(instance) {
+ return legacyErrorBoundariesThatAlreadyFailed !== null && legacyErrorBoundariesThatAlreadyFailed.has(instance);
+ }
+
+ function markLegacyErrorBoundaryAsFailed(instance) {
+ if (legacyErrorBoundariesThatAlreadyFailed === null) {
+ legacyErrorBoundariesThatAlreadyFailed = new Set([instance]);
+ } else {
+ legacyErrorBoundariesThatAlreadyFailed.add(instance);
+ }
+ }
+
+ function flushPassiveEffects() {
+ if (passiveEffectCallbackHandle !== null) {
+ cancelPassiveEffects(passiveEffectCallbackHandle);
+ }
+
+ if (passiveEffectCallback !== null) {
+ passiveEffectCallback();
+ }
+ }
+
+ 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 updateExpirationTimeBeforeCommit = finishedWork.expirationTime;
+ var childExpirationTimeBeforeCommit = finishedWork.childExpirationTime;
+ var earliestRemainingTimeBeforeCommit = childExpirationTimeBeforeCommit > updateExpirationTimeBeforeCommit ? childExpirationTimeBeforeCommit : updateExpirationTimeBeforeCommit;
+ markCommittedPriorityLevels(root, earliestRemainingTimeBeforeCommit);
+ var prevInteractions = null;
+
+ if (enableSchedulerTracing) {
+ prevInteractions = tracing.__interactionsRef.current;
+ tracing.__interactionsRef.current = root.memoizedInteractions;
+ }
+
+ ReactCurrentOwner$2.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(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(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(null, commitAllLifeCycles, null, root, 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 (firstEffect !== null && rootWithPendingPassiveEffects !== null) {
+ var callback = commitPassiveEffects.bind(null, root, firstEffect);
+
+ if (enableSchedulerTracing) {
+ callback = tracing.unstable_wrap(callback);
+ }
+
+ passiveEffectCallbackHandle = scheduler.unstable_runWithPriority(scheduler.unstable_NormalPriority, function () {
+ return schedulePassiveEffects(callback);
+ });
+ passiveEffectCallback = callback;
+ }
+
+ isCommitting$1 = false;
+ isWorking = false;
+ stopCommitLifeCyclesTimer();
+ stopCommitTimer();
+ onCommitRoot(finishedWork.stateNode);
+
+ if (true && ReactFiberInstrumentation_1.debugTool) {
+ ReactFiberInstrumentation_1.debugTool.onCommitWork(finishedWork);
+ }
+
+ var updateExpirationTimeAfterCommit = finishedWork.expirationTime;
+ var childExpirationTimeAfterCommit = finishedWork.childExpirationTime;
+ var earliestRemainingTimeAfterCommit = childExpirationTimeAfterCommit > updateExpirationTimeAfterCommit ? childExpirationTimeAfterCommit : updateExpirationTimeAfterCommit;
+
+ if (earliestRemainingTimeAfterCommit === NoWork) {
+ legacyErrorBoundariesThatAlreadyFailed = null;
+ }
+
+ onCommit(root, earliestRemainingTimeAfterCommit);
+
+ if (enableSchedulerTracing) {
+ tracing.__interactionsRef.current = prevInteractions;
+ var subscriber = void 0;
+
+ try {
+ subscriber = tracing.__subscriberRef.current;
+
+ if (subscriber !== null && root.memoizedInteractions.size > 0) {
+ var threadID = computeThreadID(committedExpirationTime, root.interactionThreadID);
+ subscriber.onWorkStopped(root.memoizedInteractions, threadID);
+ }
+ } catch (error) {
+ if (!hasUnhandledError) {
+ hasUnhandledError = true;
+ unhandledError = error;
+ }
+ } finally {
+ var pendingInteractionMap = root.pendingInteractionMap;
+ pendingInteractionMap.forEach(function (scheduledInteractions, scheduledExpirationTime) {
+ if (scheduledExpirationTime > earliestRemainingTimeAfterCommit) {
+ pendingInteractionMap.delete(scheduledExpirationTime);
+ scheduledInteractions.forEach(function (interaction) {
+ interaction.__count--;
+
+ if (subscriber !== null && interaction.__count === 0) {
+ try {
+ subscriber.onInteractionScheduledWorkCompleted(interaction);
+ } catch (error) {
+ if (!hasUnhandledError) {
+ hasUnhandledError = true;
+ unhandledError = error;
+ }
+ }
+ }
+ });
+ }
+ });
+ }
+ }
+ }
+
+ function resetChildExpirationTime(workInProgress, renderTime) {
+ if (renderTime !== Never && workInProgress.childExpirationTime === Never) {
+ return;
+ }
+
+ var newChildExpirationTime = NoWork;
+
+ if (enableProfilerTimer && workInProgress.mode & ProfileMode) {
+ var actualDuration = workInProgress.actualDuration;
+ var treeBaseDuration = workInProgress.selfBaseDuration;
+ var shouldBubbleActualDurations = workInProgress.alternate === null || workInProgress.child !== workInProgress.alternate.child;
+ var child = workInProgress.child;
+
+ while (child !== null) {
+ var childUpdateExpirationTime = child.expirationTime;
+ var childChildExpirationTime = child.childExpirationTime;
+
+ if (childUpdateExpirationTime > newChildExpirationTime) {
+ newChildExpirationTime = childUpdateExpirationTime;
+ }
+
+ if (childChildExpirationTime > newChildExpirationTime) {
+ newChildExpirationTime = childChildExpirationTime;
+ }
+
+ if (shouldBubbleActualDurations) {
+ actualDuration += child.actualDuration;
+ }
+
+ treeBaseDuration += child.treeBaseDuration;
+ child = child.sibling;
+ }
+
+ workInProgress.actualDuration = actualDuration;
+ workInProgress.treeBaseDuration = treeBaseDuration;
+ } else {
+ var _child = workInProgress.child;
+
+ while (_child !== null) {
+ var _childUpdateExpirationTime = _child.expirationTime;
+ var _childChildExpirationTime = _child.childExpirationTime;
+
+ if (_childUpdateExpirationTime > newChildExpirationTime) {
+ newChildExpirationTime = _childUpdateExpirationTime;
+ }
+
+ if (_childChildExpirationTime > newChildExpirationTime) {
+ newChildExpirationTime = _childChildExpirationTime;
+ }
+
+ _child = _child.sibling;
+ }
+ }
+
+ workInProgress.childExpirationTime = newChildExpirationTime;
+ }
+
+ function completeUnitOfWork(workInProgress) {
+ while (true) {
+ var current$$1 = workInProgress.alternate;
+ {
+ setCurrentFiber(workInProgress);
+ }
+ var returnFiber = workInProgress.return;
+ var siblingFiber = workInProgress.sibling;
+
+ if ((workInProgress.effectTag & Incomplete) === NoEffect) {
+ if (true && replayFailedUnitOfWorkWithInvokeGuardedCallback) {
+ mayReplayFailedUnitOfWork = false;
+ }
+
+ nextUnitOfWork = workInProgress;
+
+ if (enableProfilerTimer) {
+ if (workInProgress.mode & ProfileMode) {
+ startProfilerTimer(workInProgress);
+ }
+
+ nextUnitOfWork = completeWork(current$$1, workInProgress, nextRenderExpirationTime);
+
+ if (workInProgress.mode & ProfileMode) {
+ stopProfilerTimerIfRunningAndRecordDelta(workInProgress, false);
+ }
+ } else {
+ nextUnitOfWork = completeWork(current$$1, workInProgress, nextRenderExpirationTime);
+ }
+
+ if (true && replayFailedUnitOfWorkWithInvokeGuardedCallback) {
+ mayReplayFailedUnitOfWork = true;
+ }
+
+ stopWorkTimer(workInProgress);
+ resetChildExpirationTime(workInProgress, nextRenderExpirationTime);
+ {
+ resetCurrentFiber();
+ }
+
+ if (nextUnitOfWork !== null) {
+ return nextUnitOfWork;
+ }
+
+ 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 {
+ if (enableProfilerTimer && workInProgress.mode & ProfileMode) {
+ stopProfilerTimerIfRunningAndRecordDelta(workInProgress, false);
+ var actualDuration = workInProgress.actualDuration;
+ var child = workInProgress.child;
+
+ while (child !== null) {
+ actualDuration += child.actualDuration;
+ child = child.sibling;
+ }
+
+ workInProgress.actualDuration = actualDuration;
+ }
+
+ var next = unwindWork(workInProgress, nextRenderExpirationTime);
+
+ if (workInProgress.effectTag & DidCapture) {
+ stopFailedWorkTimer(workInProgress);
+ } else {
+ stopWorkTimer(workInProgress);
+ }
+
+ {
+ 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$$1 = workInProgress.alternate;
+ startWorkTimer(workInProgress);
+ {
+ setCurrentFiber(workInProgress);
+ }
+
+ if (true && replayFailedUnitOfWorkWithInvokeGuardedCallback) {
+ stashedWorkInProgressProperties = assignFiberPropertiesInDEV(stashedWorkInProgressProperties, workInProgress);
+ }
+
+ var next = void 0;
+
+ if (enableProfilerTimer) {
+ if (workInProgress.mode & ProfileMode) {
+ startProfilerTimer(workInProgress);
+ }
+
+ next = beginWork(current$$1, workInProgress, nextRenderExpirationTime);
+ workInProgress.memoizedProps = workInProgress.pendingProps;
+
+ if (workInProgress.mode & ProfileMode) {
+ stopProfilerTimerIfRunningAndRecordDelta(workInProgress, true);
+ }
+ } else {
+ next = beginWork(current$$1, workInProgress, nextRenderExpirationTime);
+ workInProgress.memoizedProps = workInProgress.pendingProps;
+ }
+
+ {
+ resetCurrentFiber();
+
+ if (isReplayingFailedUnitOfWork) {
+ rethrowOriginalError();
+ }
+ }
+
+ if (true && ReactFiberInstrumentation_1.debugTool) {
+ ReactFiberInstrumentation_1.debugTool.onBeginWork(workInProgress);
+ }
+
+ if (next === null) {
+ next = completeUnitOfWork(workInProgress);
+ }
+
+ ReactCurrentOwner$2.current = null;
+ return next;
+ }
+
+ function workLoop(isYieldy) {
+ if (!isYieldy) {
+ while (nextUnitOfWork !== null) {
+ nextUnitOfWork = performUnitOfWork(nextUnitOfWork);
+ }
+ } else {
+ while (nextUnitOfWork !== null && !shouldYield$$1()) {
+ nextUnitOfWork = performUnitOfWork(nextUnitOfWork);
+ }
+ }
+ }
+
+ function renderRoot(root, isYieldy) {
+ invariant(!isWorking, "renderRoot was called recursively. This error is likely caused " + "by a bug in React. Please file an issue.");
+ flushPassiveEffects();
+ isWorking = true;
+ var previousDispatcher = ReactCurrentDispatcher.current;
+ ReactCurrentDispatcher.current = ContextOnlyDispatcher;
+ var expirationTime = root.nextExpirationTimeToWorkOn;
+
+ if (expirationTime !== nextRenderExpirationTime || root !== nextRoot || nextUnitOfWork === null) {
+ resetStack();
+ nextRoot = root;
+ nextRenderExpirationTime = expirationTime;
+ nextUnitOfWork = createWorkInProgress(nextRoot.current, null, nextRenderExpirationTime);
+ root.pendingCommitExpirationTime = NoWork;
+
+ if (enableSchedulerTracing) {
+ var interactions = new Set();
+ root.pendingInteractionMap.forEach(function (scheduledInteractions, scheduledExpirationTime) {
+ if (scheduledExpirationTime >= expirationTime) {
+ scheduledInteractions.forEach(function (interaction) {
+ return interactions.add(interaction);
+ });
+ }
+ });
+ root.memoizedInteractions = interactions;
+
+ if (interactions.size > 0) {
+ var subscriber = tracing.__subscriberRef.current;
+
+ if (subscriber !== null) {
+ var threadID = computeThreadID(expirationTime, root.interactionThreadID);
+
+ try {
+ subscriber.onWorkStarted(interactions, threadID);
+ } catch (error) {
+ if (!hasUnhandledError) {
+ hasUnhandledError = true;
+ unhandledError = error;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ var prevInteractions = null;
+
+ if (enableSchedulerTracing) {
+ prevInteractions = tracing.__interactionsRef.current;
+ tracing.__interactionsRef.current = root.memoizedInteractions;
+ }
+
+ var didFatal = false;
+ startWorkLoopTimer(nextUnitOfWork);
+
+ do {
+ try {
+ workLoop(isYieldy);
+ } catch (thrownValue) {
+ resetContextDependences();
+ resetHooks();
+ var mayReplay = void 0;
+
+ if (true && replayFailedUnitOfWorkWithInvokeGuardedCallback) {
+ mayReplay = mayReplayFailedUnitOfWork;
+ mayReplayFailedUnitOfWork = true;
+ }
+
+ if (nextUnitOfWork === null) {
+ didFatal = true;
+ onUncaughtError(thrownValue);
+ } else {
+ if (enableProfilerTimer && nextUnitOfWork.mode & ProfileMode) {
+ stopProfilerTimerIfRunningAndRecordDelta(nextUnitOfWork, true);
+ }
+
+ {
+ resetCurrentlyProcessingQueue();
+ }
+
+ if (true && replayFailedUnitOfWorkWithInvokeGuardedCallback) {
+ if (mayReplay) {
+ var failedUnitOfWork = nextUnitOfWork;
+ 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);
+ } else {
+ throwException(root, returnFiber, sourceFiber, thrownValue, nextRenderExpirationTime);
+ nextUnitOfWork = completeUnitOfWork(sourceFiber);
+ continue;
+ }
+ }
+ }
+
+ break;
+ } while (true);
+
+ if (enableSchedulerTracing) {
+ tracing.__interactionsRef.current = prevInteractions;
+ }
+
+ isWorking = false;
+ ReactCurrentDispatcher.current = previousDispatcher;
+ resetContextDependences();
+ resetHooks();
+
+ if (didFatal) {
+ var _didCompleteRoot = false;
+ stopWorkLoopTimer(interruptedBy, _didCompleteRoot);
+ interruptedBy = null;
+ {
+ resetStackAfterFatalErrorInDev();
+ }
+ nextRoot = null;
+ onFatal(root);
+ return;
+ }
+
+ if (nextUnitOfWork !== null) {
+ var _didCompleteRoot2 = false;
+ stopWorkLoopTimer(interruptedBy, _didCompleteRoot2);
+ interruptedBy = null;
+ onYield(root);
+ return;
+ }
+
+ var didCompleteRoot = true;
+ stopWorkLoopTimer(interruptedBy, didCompleteRoot);
+ 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.");
+ nextRoot = null;
+ interruptedBy = null;
+
+ if (nextRenderDidError) {
+ if (hasLowerPriorityWork(root, expirationTime)) {
+ markSuspendedPriorityLevel(root, expirationTime);
+ var suspendedExpirationTime = expirationTime;
+ var rootExpirationTime = root.expirationTime;
+ onSuspend(root, rootWorkInProgress, suspendedExpirationTime, rootExpirationTime, -1);
+ return;
+ } else if (!root.didError && isYieldy) {
+ root.didError = true;
+
+ var _suspendedExpirationTime = root.nextExpirationTimeToWorkOn = expirationTime;
+
+ var _rootExpirationTime = root.expirationTime = Sync;
+
+ onSuspend(root, rootWorkInProgress, _suspendedExpirationTime, _rootExpirationTime, -1);
+ return;
+ }
+ }
+
+ if (isYieldy && nextLatestAbsoluteTimeoutMs !== -1) {
+ var _suspendedExpirationTime2 = expirationTime;
+ markSuspendedPriorityLevel(root, _suspendedExpirationTime2);
+ var earliestExpirationTime = findEarliestOutstandingPriorityLevel(root, expirationTime);
+ var earliestExpirationTimeMs = expirationTimeToMs(earliestExpirationTime);
+
+ if (earliestExpirationTimeMs < nextLatestAbsoluteTimeoutMs) {
+ nextLatestAbsoluteTimeoutMs = earliestExpirationTimeMs;
+ }
+
+ var currentTimeMs = expirationTimeToMs(requestCurrentTime());
+ var msUntilTimeout = nextLatestAbsoluteTimeoutMs - currentTimeMs;
+ msUntilTimeout = msUntilTimeout < 0 ? 0 : msUntilTimeout;
+ var _rootExpirationTime2 = root.expirationTime;
+ onSuspend(root, rootWorkInProgress, _suspendedExpirationTime2, _rootExpirationTime2, msUntilTimeout);
+ return;
+ }
+
+ onComplete(root, rootWorkInProgress, expirationTime);
+ }
+
+ function captureCommitPhaseError(sourceFiber, value) {
+ var expirationTime = Sync;
+ var fiber = sourceFiber.return;
+
+ while (fiber !== null) {
+ switch (fiber.tag) {
+ case ClassComponent:
+ var ctor = fiber.type;
+ var instance = fiber.stateNode;
+
+ if (typeof ctor.getDerivedStateFromError === "function" || typeof instance.componentDidCatch === "function" && !isAlreadyFailedLegacyErrorBoundary(instance)) {
+ var errorInfo = createCapturedValue(value, sourceFiber);
+ var update = createClassErrorUpdate(fiber, errorInfo, expirationTime);
+ enqueueUpdate(fiber, update);
+ scheduleWork(fiber, expirationTime);
+ return;
+ }
+
+ break;
+
+ case HostRoot:
+ {
+ var _errorInfo = createCapturedValue(value, sourceFiber);
+
+ var _update = createRootErrorUpdate(fiber, _errorInfo, expirationTime);
+
+ enqueueUpdate(fiber, _update);
+ 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);
+ scheduleWork(rootFiber, expirationTime);
+ }
+ }
+
+ function computeThreadID(expirationTime, interactionThreadID) {
+ return expirationTime * 1000 + interactionThreadID;
+ }
+
+ function computeExpirationForFiber(currentTime, fiber) {
+ var priorityLevel = scheduler.unstable_getCurrentPriorityLevel();
+ var expirationTime = void 0;
+
+ if ((fiber.mode & ConcurrentMode) === NoContext) {
+ expirationTime = Sync;
+ } else if (isWorking && !isCommitting$1) {
+ expirationTime = nextRenderExpirationTime;
+ } else {
+ switch (priorityLevel) {
+ case scheduler.unstable_ImmediatePriority:
+ expirationTime = Sync;
+ break;
+
+ case scheduler.unstable_UserBlockingPriority:
+ expirationTime = computeInteractiveExpiration(currentTime);
+ break;
+
+ case scheduler.unstable_NormalPriority:
+ expirationTime = computeAsyncExpiration(currentTime);
+ break;
+
+ case scheduler.unstable_LowPriority:
+ case scheduler.unstable_IdlePriority:
+ expirationTime = Never;
+ break;
+
+ default:
+ invariant(false, "Unknown priority level. This error is likely caused by a bug in " + "React. Please file an issue.");
+ }
+
+ if (nextRoot !== null && expirationTime === nextRenderExpirationTime) {
+ expirationTime -= 1;
+ }
+ }
+
+ if (priorityLevel === scheduler.unstable_UserBlockingPriority && (lowestPriorityPendingInteractiveExpirationTime === NoWork || expirationTime < lowestPriorityPendingInteractiveExpirationTime)) {
+ lowestPriorityPendingInteractiveExpirationTime = expirationTime;
+ }
+
+ return expirationTime;
+ }
+
+ function renderDidSuspend(root, absoluteTimeoutMs, suspendedTime) {
+ if (absoluteTimeoutMs >= 0 && nextLatestAbsoluteTimeoutMs < absoluteTimeoutMs) {
+ nextLatestAbsoluteTimeoutMs = absoluteTimeoutMs;
+ }
+ }
+
+ function renderDidError() {
+ nextRenderDidError = true;
+ }
+
+ function pingSuspendedRoot(root, thenable, pingTime) {
+ var pingCache = root.pingCache;
+
+ if (pingCache !== null) {
+ pingCache.delete(thenable);
+ }
+
+ if (nextRoot !== null && nextRenderExpirationTime === pingTime) {
+ nextRoot = null;
+ } else {
+ if (isPriorityLevelSuspended(root, pingTime)) {
+ markPingedPriorityLevel(root, pingTime);
+ var rootExpirationTime = root.expirationTime;
+
+ if (rootExpirationTime !== NoWork) {
+ requestWork(root, rootExpirationTime);
+ }
+ }
+ }
+ }
+
+ function retryTimedOutBoundary(boundaryFiber) {
+ var currentTime = requestCurrentTime();
+ var retryTime = computeExpirationForFiber(currentTime, boundaryFiber);
+ var root = scheduleWorkToRoot(boundaryFiber, retryTime);
+
+ if (root !== null) {
+ markPendingPriorityLevel(root, retryTime);
+ var rootExpirationTime = root.expirationTime;
+
+ if (rootExpirationTime !== NoWork) {
+ requestWork(root, rootExpirationTime);
+ }
+ }
+ }
+
+ function resolveRetryThenable(boundaryFiber, thenable) {
+ var retryCache = void 0;
+
+ if (enableSuspenseServerRenderer) {
+ switch (boundaryFiber.tag) {
+ case SuspenseComponent:
+ retryCache = boundaryFiber.stateNode;
+ break;
+
+ case DehydratedSuspenseComponent:
+ retryCache = boundaryFiber.memoizedState;
+ break;
+
+ default:
+ invariant(false, "Pinged unknown suspense boundary type. " + "This is probably a bug in React.");
+ }
+ } else {
+ retryCache = boundaryFiber.stateNode;
+ }
+
+ if (retryCache !== null) {
+ retryCache.delete(thenable);
+ }
+
+ retryTimedOutBoundary(boundaryFiber);
+ }
+
+ function scheduleWorkToRoot(fiber, expirationTime) {
+ recordScheduleUpdate();
+ {
+ if (fiber.tag === ClassComponent) {
+ var instance = fiber.stateNode;
+ warnAboutInvalidUpdates(instance);
+ }
+ }
+
+ if (fiber.expirationTime < expirationTime) {
+ fiber.expirationTime = expirationTime;
+ }
+
+ var alternate = fiber.alternate;
+
+ if (alternate !== null && alternate.expirationTime < expirationTime) {
+ alternate.expirationTime = expirationTime;
+ }
+
+ var node = fiber.return;
+ var root = null;
+
+ if (node === null && fiber.tag === HostRoot) {
+ root = fiber.stateNode;
+ } else {
+ while (node !== null) {
+ alternate = node.alternate;
+
+ if (node.childExpirationTime < expirationTime) {
+ node.childExpirationTime = expirationTime;
+
+ if (alternate !== null && alternate.childExpirationTime < expirationTime) {
+ alternate.childExpirationTime = expirationTime;
+ }
+ } else if (alternate !== null && alternate.childExpirationTime < expirationTime) {
+ alternate.childExpirationTime = expirationTime;
+ }
+
+ if (node.return === null && node.tag === HostRoot) {
+ root = node.stateNode;
+ break;
+ }
+
+ node = node.return;
+ }
+ }
+
+ if (enableSchedulerTracing) {
+ if (root !== null) {
+ var interactions = tracing.__interactionsRef.current;
+
+ if (interactions.size > 0) {
+ var pendingInteractionMap = root.pendingInteractionMap;
+ var pendingInteractions = pendingInteractionMap.get(expirationTime);
+
+ if (pendingInteractions != null) {
+ interactions.forEach(function (interaction) {
+ if (!pendingInteractions.has(interaction)) {
+ interaction.__count++;
+ }
+
+ pendingInteractions.add(interaction);
+ });
+ } else {
+ pendingInteractionMap.set(expirationTime, new Set(interactions));
+ interactions.forEach(function (interaction) {
+ interaction.__count++;
+ });
+ }
+
+ var subscriber = tracing.__subscriberRef.current;
+
+ if (subscriber !== null) {
+ var threadID = computeThreadID(expirationTime, root.interactionThreadID);
+ subscriber.onWorkScheduled(interactions, threadID);
+ }
+ }
+ }
+ }
+
+ return root;
+ }
+
+ function warnIfNotCurrentlyBatchingInDev(fiber) {
+ {
+ if (isRendering === false && isBatchingUpdates === false) {
+ warningWithoutStack$1(false, "An update to %s inside a test was not wrapped in act(...).\n\n" + "When testing, code that causes React state updates should be wrapped into act(...):\n\n" + "act(() => {\n" + " /* fire events that update state */\n" + "});\n" + "/* assert on the output */\n\n" + "This ensures that you're testing the behavior the user would see in the browser." + " Learn more at https://fb.me/react-wrap-tests-with-act" + "%s", getComponentName(fiber.type), getStackByFiberInDevAndProd(fiber));
+ }
+ }
+ }
+
+ function scheduleWork(fiber, expirationTime) {
+ var root = scheduleWorkToRoot(fiber, expirationTime);
+
+ if (root === null) {
+ {
+ switch (fiber.tag) {
+ case ClassComponent:
+ warnAboutUpdateOnUnmounted(fiber, true);
+ break;
+
+ case FunctionComponent:
+ case ForwardRef:
+ case MemoComponent:
+ case SimpleMemoComponent:
+ warnAboutUpdateOnUnmounted(fiber, false);
+ break;
+ }
+ }
+ return;
+ }
+
+ 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) {
+ nestedUpdateCount = 0;
+ 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.");
+ }
+ }
+
+ var firstScheduledRoot = null;
+ var lastScheduledRoot = null;
+ var callbackExpirationTime = NoWork;
+ var callbackID = void 0;
+ var isRendering = false;
+ var nextFlushedRoot = null;
+ var nextFlushedExpirationTime = NoWork;
+ var lowestPriorityPendingInteractiveExpirationTime = NoWork;
+ var hasUnhandledError = false;
+ var unhandledError = null;
+ var isBatchingUpdates = false;
+ var isUnbatchingUpdates = false;
+ var completedBatches = null;
+ var originalStartTimeMs = now$$1();
+ var currentRendererTime = msToExpirationTime(originalStartTimeMs);
+ var currentSchedulerTime = currentRendererTime;
+ var NESTED_UPDATE_LIMIT = 50;
+ var nestedUpdateCount = 0;
+ var lastCommittedRootDuringThisBatch = null;
+
+ function recomputeCurrentRendererTime() {
+ var currentTimeMs = now$$1() - originalStartTimeMs;
+ currentRendererTime = msToExpirationTime(currentTimeMs);
+ }
+
+ function scheduleCallbackWithExpirationTime(root, expirationTime) {
+ if (callbackExpirationTime !== NoWork) {
+ if (expirationTime < callbackExpirationTime) {
+ return;
+ } else {
+ if (callbackID !== null) {
+ cancelDeferredCallback$$1(callbackID);
+ }
+ }
+ } else {
+ startRequestCallbackTimer();
+ }
+
+ callbackExpirationTime = expirationTime;
+ var currentMs = now$$1() - originalStartTimeMs;
+ var expirationTimeMs = expirationTimeToMs(expirationTime);
+ var timeout = expirationTimeMs - currentMs;
+ callbackID = scheduleDeferredCallback$$1(performAsyncWork, {
+ timeout: timeout
+ });
+ }
+
+ function onFatal(root) {
+ root.finishedWork = null;
+ }
+
+ function onComplete(root, finishedWork, expirationTime) {
+ root.pendingCommitExpirationTime = expirationTime;
+ root.finishedWork = finishedWork;
+ }
+
+ function onSuspend(root, finishedWork, suspendedExpirationTime, rootExpirationTime, msUntilTimeout) {
+ root.expirationTime = rootExpirationTime;
+
+ if (msUntilTimeout === 0 && !shouldYield$$1()) {
+ root.pendingCommitExpirationTime = suspendedExpirationTime;
+ root.finishedWork = finishedWork;
+ } else if (msUntilTimeout > 0) {
+ root.timeoutHandle = scheduleTimeout(onTimeout.bind(null, root, finishedWork, suspendedExpirationTime), msUntilTimeout);
+ }
+ }
+
+ function onYield(root) {
+ root.finishedWork = null;
+ }
+
+ function onTimeout(root, finishedWork, suspendedExpirationTime) {
+ root.pendingCommitExpirationTime = suspendedExpirationTime;
+ root.finishedWork = finishedWork;
+ recomputeCurrentRendererTime();
+ currentSchedulerTime = currentRendererTime;
+ flushRoot(root, suspendedExpirationTime);
+ }
+
+ function onCommit(root, expirationTime) {
+ root.expirationTime = expirationTime;
+ root.finishedWork = null;
+ }
+
+ function requestCurrentTime() {
+ if (isRendering) {
+ return currentSchedulerTime;
+ }
+
+ findHighestPriorityRoot();
+
+ if (nextFlushedExpirationTime === NoWork || nextFlushedExpirationTime === Never) {
+ recomputeCurrentRendererTime();
+ currentSchedulerTime = currentRendererTime;
+ return currentSchedulerTime;
+ }
+
+ return currentSchedulerTime;
+ }
+
+ 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(root, 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 (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 (remainingExpirationTime > highestPriorityWork) {
+ highestPriorityWork = remainingExpirationTime;
+ highestPriorityRoot = root;
+ }
+
+ if (root === lastScheduledRoot) {
+ break;
+ }
+
+ if (highestPriorityWork === Sync) {
+ break;
+ }
+
+ previousScheduledRoot = root;
+ root = root.nextScheduledRoot;
+ }
+ }
+ }
+
+ nextFlushedRoot = highestPriorityRoot;
+ nextFlushedExpirationTime = highestPriorityWork;
+ }
+
+ function performAsyncWork(didTimeout) {
+ if (didTimeout) {
+ if (firstScheduledRoot !== null) {
+ recomputeCurrentRendererTime();
+ var root = firstScheduledRoot;
+
+ do {
+ didExpireAtExpirationTime(root, currentRendererTime);
+ root = root.nextScheduledRoot;
+ } while (root !== firstScheduledRoot);
+ }
+ }
+
+ performWork(NoWork, true);
+ }
+
+ function performSyncWork() {
+ performWork(Sync, false);
+ }
+
+ function performWork(minExpirationTime, isYieldy) {
+ findHighestPriorityRoot();
+
+ if (isYieldy) {
+ recomputeCurrentRendererTime();
+ currentSchedulerTime = currentRendererTime;
+
+ if (enableUserTimingAPI) {
+ var didExpire = nextFlushedExpirationTime > currentRendererTime;
+ var timeout = expirationTimeToMs(nextFlushedExpirationTime);
+ stopRequestCallbackTimer(didExpire, timeout);
+ }
+
+ while (nextFlushedRoot !== null && nextFlushedExpirationTime !== NoWork && minExpirationTime <= nextFlushedExpirationTime && !(shouldYield$$1() && currentRendererTime > nextFlushedExpirationTime)) {
+ performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, currentRendererTime > nextFlushedExpirationTime);
+ findHighestPriorityRoot();
+ recomputeCurrentRendererTime();
+ currentSchedulerTime = currentRendererTime;
+ }
+ } else {
+ while (nextFlushedRoot !== null && nextFlushedExpirationTime !== NoWork && minExpirationTime <= nextFlushedExpirationTime) {
+ performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, false);
+ findHighestPriorityRoot();
+ }
+ }
+
+ if (isYieldy) {
+ callbackExpirationTime = NoWork;
+ callbackID = null;
+ }
+
+ if (nextFlushedExpirationTime !== NoWork) {
+ scheduleCallbackWithExpirationTime(nextFlushedRoot, nextFlushedExpirationTime);
+ }
+
+ 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();
+ }
+
+ function finishRendering() {
+ nestedUpdateCount = 0;
+ lastCommittedRootDuringThisBatch = null;
+
+ 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;
+ var timeoutHandle = root.timeoutHandle;
+
+ if (timeoutHandle !== noTimeout) {
+ root.timeoutHandle = noTimeout;
+ cancelTimeout(timeoutHandle);
+ }
+
+ renderRoot(root, isYieldy);
+ 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;
+ var _timeoutHandle = root.timeoutHandle;
+
+ if (_timeoutHandle !== noTimeout) {
+ root.timeoutHandle = noTimeout;
+ cancelTimeout(_timeoutHandle);
+ }
+
+ renderRoot(root, isYieldy);
+ _finishedWork = root.finishedWork;
+
+ if (_finishedWork !== null) {
+ if (!shouldYield$$1()) {
+ completeRoot$1(root, _finishedWork, expirationTime);
+ } else {
+ root.finishedWork = _finishedWork;
+ }
+ }
+ }
+ }
+
+ 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;
+
+ if (root === lastCommittedRootDuringThisBatch) {
+ nestedUpdateCount++;
+ } else {
+ lastCommittedRootDuringThisBatch = root;
+ nestedUpdateCount = 0;
+ }
+
+ scheduler.unstable_runWithPriority(scheduler.unstable_ImmediatePriority, function () {
+ commitRoot(root, finishedWork);
+ });
+ }
+
+ 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 interactiveUpdates$1(fn, a, b) {
+ if (!isBatchingUpdates && !isRendering && lowestPriorityPendingInteractiveExpirationTime !== NoWork) {
+ performWork(lowestPriorityPendingInteractiveExpirationTime, false);
+ lowestPriorityPendingInteractiveExpirationTime = NoWork;
+ }
+
+ var previousIsBatchingUpdates = isBatchingUpdates;
+ isBatchingUpdates = true;
+
+ try {
+ return scheduler.unstable_runWithPriority(scheduler.unstable_UserBlockingPriority, function () {
+ return fn(a, b);
+ });
+ } finally {
+ isBatchingUpdates = previousIsBatchingUpdates;
+
+ if (!isBatchingUpdates && !isRendering) {
+ performSyncWork();
+ }
+ }
+ }
+
+ function flushInteractiveUpdates$1() {
+ if (!isRendering && lowestPriorityPendingInteractiveExpirationTime !== NoWork) {
+ performWork(lowestPriorityPendingInteractiveExpirationTime, false);
+ lowestPriorityPendingInteractiveExpirationTime = NoWork;
+ }
+ }
+
+ var didWarnAboutNestedUpdates = void 0;
+ var didWarnAboutFindNodeInStrictMode = void 0;
+ {
+ didWarnAboutNestedUpdates = false;
+ didWarnAboutFindNodeInStrictMode = {};
+ }
+
+ function getContextForSubtree(parentComponent) {
+ if (!parentComponent) {
+ return emptyContextObject;
+ }
+
+ var fiber = get$1(parentComponent);
+ var parentContext = findCurrentUnmaskedContext(fiber);
+
+ if (fiber.tag === ClassComponent) {
+ var Component = fiber.type;
+
+ if (isContextProvider(Component)) {
+ return processChildContext(fiber, Component, parentContext);
+ }
+ }
+
+ return parentContext;
+ }
+
+ function scheduleRootUpdate(current$$1, element, expirationTime, callback) {
+ {
+ if (phase === "render" && current !== null && !didWarnAboutNestedUpdates) {
+ didWarnAboutNestedUpdates = true;
+ warningWithoutStack$1(false, "Render methods should be a pure function of props and state; " + "triggering nested component updates from render is not allowed. " + "If necessary, trigger nested updates in componentDidUpdate.\n\n" + "Check the render method of %s.", getComponentName(current.type) || "Unknown");
+ }
+ }
+ var update = createUpdate(expirationTime);
+ update.payload = {
+ element: element
+ };
+ callback = callback === undefined ? null : callback;
+
+ if (callback !== null) {
+ !(typeof callback === "function") ? warningWithoutStack$1(false, "render(...): Expected the last optional `callback` argument to be a " + "function. Instead received: %s.", callback) : void 0;
+ update.callback = callback;
+ }
+
+ flushPassiveEffects();
+ enqueueUpdate(current$$1, update);
+ scheduleWork(current$$1, expirationTime);
+ return expirationTime;
+ }
+
+ function updateContainerAtExpirationTime(element, container, parentComponent, expirationTime, callback) {
+ var current$$1 = container.current;
+ {
+ if (ReactFiberInstrumentation_1.debugTool) {
+ if (current$$1.alternate === null) {
+ ReactFiberInstrumentation_1.debugTool.onMountContainer(container);
+ } else if (element === null) {
+ ReactFiberInstrumentation_1.debugTool.onUnmountContainer(container);
+ } else {
+ ReactFiberInstrumentation_1.debugTool.onUpdateContainer(container);
+ }
+ }
+ }
+ var context = getContextForSubtree(parentComponent);
+
+ if (container.context === null) {
+ container.context = context;
+ } else {
+ container.pendingContext = context;
+ }
+
+ return scheduleRootUpdate(current$$1, element, expirationTime, callback);
+ }
+
+ function findHostInstance(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 findHostInstanceWithWarning(component, methodName) {
+ {
+ 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;
+ }
+
+ if (hostFiber.mode & StrictMode) {
+ var componentName = getComponentName(fiber.type) || "Component";
+
+ if (!didWarnAboutFindNodeInStrictMode[componentName]) {
+ didWarnAboutFindNodeInStrictMode[componentName] = true;
+
+ if (fiber.mode & StrictMode) {
+ warningWithoutStack$1(false, "%s is deprecated in StrictMode. " + "%s was passed an instance of %s which is inside StrictMode. " + "Instead, add a ref directly to the element you want to reference." + "\n%s" + "\n\nLearn more about using refs safely here:" + "\nhttps://fb.me/react-strict-mode-find-node", methodName, methodName, componentName, getStackByFiberInDevAndProd(hostFiber));
+ } else {
+ warningWithoutStack$1(false, "%s is deprecated in StrictMode. " + "%s was passed an instance of %s which renders StrictMode children. " + "Instead, add a ref directly to the element you want to reference." + "\n%s" + "\n\nLearn more about using refs safely here:" + "\nhttps://fb.me/react-strict-mode-find-node", methodName, methodName, componentName, getStackByFiberInDevAndProd(hostFiber));
+ }
+ }
+ }
+
+ return hostFiber.stateNode;
+ }
+ return findHostInstance(component);
+ }
+
+ function createContainer(containerInfo, isConcurrent, hydrate) {
+ return createFiberRoot(containerInfo, isConcurrent, hydrate);
+ }
+
+ function updateContainer(element, container, parentComponent, callback) {
+ var current$$1 = container.current;
+ var currentTime = requestCurrentTime();
+ var expirationTime = computeExpirationForFiber(currentTime, current$$1);
+ 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;
+ }
+ }
+
+ var overrideProps = null;
+ {
+ var copyWithSetImpl = function copyWithSetImpl(obj, path, idx, value) {
+ if (idx >= path.length) {
+ return value;
+ }
+
+ var key = path[idx];
+ var updated = Array.isArray(obj) ? obj.slice() : _extends({}, obj);
+ updated[key] = copyWithSetImpl(obj[key], path, idx + 1, value);
+ return updated;
+ };
+
+ var copyWithSet = function copyWithSet(obj, path, value) {
+ return copyWithSetImpl(obj, path, 0, value);
+ };
+
+ overrideProps = function overrideProps(fiber, path, value) {
+ flushPassiveEffects();
+ fiber.pendingProps = copyWithSet(fiber.memoizedProps, path, value);
+
+ if (fiber.alternate) {
+ fiber.alternate.pendingProps = fiber.pendingProps;
+ }
+
+ scheduleWork(fiber, Sync);
+ };
+ }
+
+ function injectIntoDevTools(devToolsConfig) {
+ var _findFiberByHostInstance = devToolsConfig.findFiberByHostInstance;
+ var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+ return injectInternals(_extends({}, devToolsConfig, {
+ overrideProps: overrideProps,
+ currentDispatcherRef: ReactCurrentDispatcher,
+ findHostInstanceByFiber: function findHostInstanceByFiber(fiber) {
+ var hostFiber = findCurrentHostFiber(fiber);
+
+ if (hostFiber === null) {
+ return null;
+ }
+
+ return hostFiber.stateNode;
+ },
+ findFiberByHostInstance: function findFiberByHostInstance(instance) {
+ if (!_findFiberByHostInstance) {
+ return null;
+ }
+
+ return _findFiberByHostInstance(instance);
+ }
+ }));
+ }
+
+ function _createPortal(children, containerInfo, implementation) {
+ var key = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
+ return {
+ $$typeof: REACT_PORTAL_TYPE,
+ key: key == null ? null : "" + key,
+ children: children,
+ containerInfo: containerInfo,
+ implementation: implementation
+ };
+ }
+
+ var ReactVersion = "16.8.3";
+
+ var NativeMethodsMixin = function NativeMethodsMixin(findNodeHandle, findHostInstance) {
+ var NativeMethodsMixin = {
+ measure: function measure(callback) {
+ UIManager.measure(findNodeHandle(this), mountSafeCallback_NOT_REALLY_SAFE(this, callback));
+ },
+ measureInWindow: function measureInWindow(callback) {
+ UIManager.measureInWindow(findNodeHandle(this), mountSafeCallback_NOT_REALLY_SAFE(this, callback));
+ },
+ measureLayout: function measureLayout(relativeToNativeNode, onSuccess, onFail) {
+ UIManager.measureLayout(findNodeHandle(this), relativeToNativeNode, mountSafeCallback_NOT_REALLY_SAFE(this, onFail), mountSafeCallback_NOT_REALLY_SAFE(this, onSuccess));
+ },
+ setNativeProps: function setNativeProps(nativeProps) {
+ {
+ if (warnAboutDeprecatedSetNativeProps) {
+ warningWithoutStack$1(false, "Warning: Calling ref.setNativeProps(nativeProps) " + "is deprecated and will be removed in a future release. " + "Use the setNativeProps export from the react-native package instead." + "\n\timport {setNativeProps} from 'react-native';\n\tsetNativeProps(ref, nativeProps);\n");
+ }
+ }
+ var maybeInstance = void 0;
+
+ try {
+ maybeInstance = findHostInstance(this);
+ } catch (error) {}
+
+ if (maybeInstance == null) {
+ return;
+ }
+
+ var nativeTag = maybeInstance._nativeTag || maybeInstance.canonical._nativeTag;
+ var viewConfig = maybeInstance.viewConfig || maybeInstance.canonical.viewConfig;
+ {
+ warnForStyleProps(nativeProps, viewConfig.validAttributes);
+ }
+ var updatePayload = create(nativeProps, viewConfig.validAttributes);
+
+ if (updatePayload != null) {
+ UIManager.updateView(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_NOT_REALLY_SAFE(this, callback));
+ };
+
+ ReactNativeComponent.prototype.measureInWindow = function measureInWindow(callback) {
+ UIManager.measureInWindow(findNodeHandle(this), mountSafeCallback_NOT_REALLY_SAFE(this, callback));
+ };
+
+ ReactNativeComponent.prototype.measureLayout = function measureLayout(relativeToNativeNode, onSuccess, onFail) {
+ UIManager.measureLayout(findNodeHandle(this), relativeToNativeNode, mountSafeCallback_NOT_REALLY_SAFE(this, onFail), mountSafeCallback_NOT_REALLY_SAFE(this, onSuccess));
+ };
+
+ ReactNativeComponent.prototype.setNativeProps = function setNativeProps(nativeProps) {
+ {
+ if (warnAboutDeprecatedSetNativeProps) {
+ warningWithoutStack$1(false, "Warning: Calling ref.setNativeProps(nativeProps) " + "is deprecated and will be removed in a future release. " + "Use the setNativeProps export from the react-native package instead." + "\n\timport {setNativeProps} from 'react-native';\n\tsetNativeProps(ref, nativeProps);\n");
+ }
+ }
+ var maybeInstance = void 0;
+
+ try {
+ maybeInstance = findHostInstance(this);
+ } catch (error) {}
+
+ if (maybeInstance == null) {
+ return;
+ }
+
+ var nativeTag = maybeInstance._nativeTag || maybeInstance.canonical._nativeTag;
+ var viewConfig = maybeInstance.viewConfig || maybeInstance.canonical.viewConfig;
+ var updatePayload = create(nativeProps, viewConfig.validAttributes);
+
+ if (updatePayload != null) {
+ UIManager.updateView(nativeTag, viewConfig.uiViewClassName, updatePayload);
+ }
+ };
+
+ return ReactNativeComponent;
+ }(React.Component);
+
+ return ReactNativeComponent;
+ };
+
+ var instanceCache = {};
+
+ function getInstanceFromTag(tag) {
+ return instanceCache[tag] || null;
+ }
+
+ var emptyObject$1 = {};
+ {
+ Object.freeze(emptyObject$1);
+ }
+ 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$1;
+ }
+
+ return emptyObject$1;
+ };
+
+ var getHostNode = function getHostNode(fiber, findNodeHandle) {
+ var hostNode = void 0;
+
+ while (fiber) {
+ if (fiber.stateNode !== null && fiber.tag === HostComponent) {
+ hostNode = findNodeHandle(fiber.stateNode);
+ }
+
+ if (hostNode) {
+ return hostNode;
+ }
+
+ fiber = fiber.child;
+ }
+
+ return null;
+ };
+
+ var createHierarchy = function createHierarchy(fiberHierarchy) {
+ return fiberHierarchy.map(function (fiber) {
+ return {
+ name: getComponentName(fiber.type),
+ getInspectorData: function getInspectorData(findNodeHandle) {
+ return {
+ measure: function measure(callback) {
+ return 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$1,
+ selection: null,
+ source: null
+ };
+ }
+
+ var fiber = findCurrentFiberUsingSlowPath(closestInstance);
+ var fiberHierarchy = getOwnerHierarchy(fiber);
+ var instance = lastNonHostInstance(fiberHierarchy);
+ var hierarchy = createHierarchy(fiberHierarchy);
+ var props = getHostProps(instance);
+ var source = instance._debugSource;
+ var selection = fiberHierarchy.indexOf(instance);
+ return {
+ hierarchy: hierarchy,
+ props: props,
+ selection: selection,
+ source: source
+ };
+ };
+ }
+
+ function setNativeProps(handle, nativeProps) {
+ if (handle._nativeTag == null) {
+ !(handle._nativeTag != null) ? warningWithoutStack$1(false, "setNativeProps was called with a ref that isn't a " + "native component. Use React.forwardRef to get access to the underlying native component") : void 0;
+ return;
+ }
+
+ {
+ warnForStyleProps(nativeProps, handle.viewConfig.validAttributes);
+ }
+ var updatePayload = create(nativeProps, handle.viewConfig.validAttributes);
+
+ if (updatePayload != null) {
+ UIManager.updateView(handle._nativeTag, handle.viewConfig.uiViewClassName, updatePayload);
+ }
+ }
+
+ var ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner;
+
+ function findNodeHandle(componentOrHandle) {
+ {
+ var owner = ReactCurrentOwner.current;
+
+ if (owner !== null && owner.stateNode !== null) {
+ !owner.stateNode._warnedAboutRefsInRender ? warningWithoutStack$1(false, "%s is accessing findNodeHandle inside its render(). " + "render() should be a pure function of props and state. It should " + "never access something that requires stale data from the previous " + "render, such as refs. Move this logic to componentDidMount and " + "componentDidUpdate instead.", getComponentName(owner.type) || "A component") : void 0;
+ owner.stateNode._warnedAboutRefsInRender = true;
+ }
+ }
+
+ if (componentOrHandle == null) {
+ return null;
+ }
+
+ if (typeof componentOrHandle === "number") {
+ return componentOrHandle;
+ }
+
+ if (componentOrHandle._nativeTag) {
+ return componentOrHandle._nativeTag;
+ }
+
+ if (componentOrHandle.canonical && componentOrHandle.canonical._nativeTag) {
+ return componentOrHandle.canonical._nativeTag;
+ }
+
+ var hostInstance = void 0;
+ {
+ hostInstance = findHostInstanceWithWarning(componentOrHandle, "findNodeHandle");
+ }
+
+ if (hostInstance == null) {
+ return hostInstance;
+ }
+
+ if (hostInstance.canonical) {
+ return hostInstance.canonical._nativeTag;
+ }
+
+ return hostInstance._nativeTag;
+ }
+
+ setBatchingImplementation(batchedUpdates$1, interactiveUpdates$1, flushInteractiveUpdates$1);
+ var roots = new Map();
+ var ReactFabric = {
+ NativeComponent: ReactNativeComponent(findNodeHandle, findHostInstance),
+ findNodeHandle: findNodeHandle,
+ setNativeProps: setNativeProps,
+ 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;
+ module.exports = fabric;
+ })();
+ }
+},381,[14,86,173,71,11,175,80,49,176,382,16,177,180,98],"node_modules\\react-native\\Libraries\\Renderer\\oss\\ReactFabric-dev.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var FabricUIManager = global.nativeFabricUIManager;
+ module.exports = FabricUIManager;
+},382,[],"node_modules\\react-native\\Libraries\\ReactNative\\FabricUIManager.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ "use strict";
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ _$$_REQUIRE(_dependencyMap[1], "InitializeCore");
+
+ var ReactNativeViewConfigRegistry = _$$_REQUIRE(_dependencyMap[2], "ReactNativeViewConfigRegistry"),
+ UIManager = _$$_REQUIRE(_dependencyMap[3], "UIManager"),
+ React = _$$_REQUIRE(_dependencyMap[4], "react"),
+ deepDiffer = _$$_REQUIRE(_dependencyMap[5], "deepDiffer"),
+ flattenStyle = _$$_REQUIRE(_dependencyMap[6], "flattenStyle"),
+ TextInputState = _$$_REQUIRE(_dependencyMap[7], "TextInputState"),
+ FabricUIManager = _$$_REQUIRE(_dependencyMap[8], "FabricUIManager");
+
+ var scheduler = _$$_REQUIRE(_dependencyMap[9], "scheduler"),
+ ExceptionsManager = _$$_REQUIRE(_dependencyMap[10], "ExceptionsManager");
+
+ function invariant(condition, format, a, b, c, d, e, f) {
+ if (!condition) {
+ condition = void 0;
+ if (void 0 === format) condition = 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],
+ argIndex = 0;
+ condition = Error(format.replace(/%s/g, function () {
+ return args[argIndex++];
+ }));
+ condition.name = "Invariant Violation";
+ }
+ condition.framesToPop = 1;
+ throw condition;
+ }
+ }
+
+ function invokeGuardedCallbackImpl(name, func, context, a, b, c, d, e, f) {
+ var funcArgs = Array.prototype.slice.call(arguments, 3);
+
+ try {
+ func.apply(context, funcArgs);
+ } catch (error) {
+ this.onError(error);
+ }
+ }
+
+ var hasError = !1,
+ caughtError = null,
+ hasRethrowError = !1,
+ rethrowError = null,
+ reporter = {
+ onError: function onError(error) {
+ hasError = !0;
+ caughtError = error;
+ }
+ };
+
+ function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
+ hasError = !1;
+ caughtError = null;
+ invokeGuardedCallbackImpl.apply(reporter, arguments);
+ }
+
+ function invokeGuardedCallbackAndCatchFirstError(name, func, context, a, b, c, d, e, f) {
+ invokeGuardedCallback.apply(this, arguments);
+
+ if (hasError) {
+ if (hasError) {
+ var error = caughtError;
+ hasError = !1;
+ caughtError = null;
+ } else invariant(!1, "clearCaughtError was called but no error was captured. This error is likely caused by a bug in React. Please file an issue."), error = void 0;
+
+ hasRethrowError || (hasRethrowError = !0, rethrowError = 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, listener, inst) {
+ var type = event.type || "unknown-event";
+ event.currentTarget = getNodeFromInstance(inst);
+ invokeGuardedCallbackAndCatchFirstError(type, listener, void 0, event);
+ event.currentTarget = null;
+ }
+
+ function executeDirectDispatch(event) {
+ var dispatchListener = event._dispatchListeners,
+ dispatchInstance = event._dispatchInstances;
+ 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, dispatchListeners[i], dispatchInstances[i]);
+ } else dispatchListeners && executeDispatch(e, dispatchListeners, dispatchInstances);
+ e._dispatchListeners = null;
+ e._dispatchInstances = null;
+ e.isPersistent() || e.constructor.release(e);
+ }
+ }
+
+ var injection = {
+ injectEventPluginOrder: function injectEventPluginOrder(injectedEventPluginOrder) {
+ 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));
+ }
+ }
+ }
+
+ function functionThatReturnsTrue() {
+ return !0;
+ }
+
+ function functionThatReturnsFalse() {
+ return !1;
+ }
+
+ function SyntheticEvent(dispatchConfig, targetInst, nativeEvent, nativeEventTarget) {
+ this.dispatchConfig = dispatchConfig;
+ this._targetInst = targetInst;
+ this.nativeEvent = nativeEvent;
+ dispatchConfig = this.constructor.Interface;
+
+ for (var propName in dispatchConfig) {
+ dispatchConfig.hasOwnProperty(propName) && ((targetInst = dispatchConfig[propName]) ? this[propName] = targetInst(nativeEvent) : "target" === propName ? this.target = nativeEventTarget : this[propName] = nativeEvent[propName]);
+ }
+
+ this.isDefaultPrevented = (null != nativeEvent.defaultPrevented ? nativeEvent.defaultPrevented : !1 === nativeEvent.returnValue) ? functionThatReturnsTrue : functionThatReturnsFalse;
+ this.isPropagationStopped = functionThatReturnsFalse;
+ return this;
+ }
+
+ _extends(SyntheticEvent.prototype, {
+ preventDefault: function preventDefault() {
+ this.defaultPrevented = !0;
+ var event = this.nativeEvent;
+ event && (event.preventDefault ? event.preventDefault() : "unknown" !== typeof event.returnValue && (event.returnValue = !1), this.isDefaultPrevented = functionThatReturnsTrue);
+ },
+ stopPropagation: function stopPropagation() {
+ var event = this.nativeEvent;
+ event && (event.stopPropagation ? event.stopPropagation() : "unknown" !== typeof event.cancelBubble && (event.cancelBubble = !0), this.isPropagationStopped = functionThatReturnsTrue);
+ },
+ persist: function persist() {
+ this.isPersistent = functionThatReturnsTrue;
+ },
+ isPersistent: functionThatReturnsFalse,
+ destructor: function destructor() {
+ var Interface = this.constructor.Interface,
+ propName;
+
+ for (propName in Interface) {
+ this[propName] = null;
+ }
+
+ this.nativeEvent = this._targetInst = this.dispatchConfig = null;
+ this.isPropagationStopped = this.isDefaultPrevented = functionThatReturnsFalse;
+ this._dispatchInstances = this._dispatchListeners = null;
+ }
+ });
+
+ SyntheticEvent.Interface = {
+ type: null,
+ target: null,
+ currentTarget: function currentTarget() {
+ return null;
+ },
+ eventPhase: null,
+ bubbles: null,
+ cancelable: null,
+ timeStamp: function timeStamp(event) {
+ return event.timeStamp || Date.now();
+ },
+ defaultPrevented: null,
+ isTrusted: null
+ };
+
+ SyntheticEvent.extend = function (Interface) {
+ function E() {}
+
+ function Class() {
+ return Super.apply(this, arguments);
+ }
+
+ var Super = this;
+ E.prototype = Super.prototype;
+ var prototype = new E();
+
+ _extends(prototype, Class.prototype);
+
+ Class.prototype = prototype;
+ Class.prototype.constructor = Class;
+ Class.Interface = _extends({}, Super.Interface, Interface);
+ Class.extend = Super.extend;
+ addEventPoolingTo(Class);
+ return Class;
+ };
+
+ addEventPoolingTo(SyntheticEvent);
+
+ function getPooledEvent(dispatchConfig, targetInst, nativeEvent, nativeInst) {
+ if (this.eventPool.length) {
+ var instance = this.eventPool.pop();
+ this.call(instance, dispatchConfig, targetInst, nativeEvent, nativeInst);
+ return instance;
+ }
+
+ return new this(dispatchConfig, targetInst, nativeEvent, nativeInst);
+ }
+
+ function releasePooledEvent(event) {
+ 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;
+ }
+ }
+ },
+ ReactNativeBridgeEventPlugin = {
+ eventTypes: ReactNativeViewConfigRegistry.eventTypes,
+ extractEvents: function extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+ if (null == targetInst) return null;
+ var bubbleDispatchConfig = ReactNativeViewConfigRegistry.customBubblingEventTypes[topLevelType],
+ directDispatchConfig = ReactNativeViewConfigRegistry.customDirectEventTypes[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;
+ }
+
+ getFiberCurrentPropsFromNode = function getFiberCurrentPropsFromNode(inst) {
+ return inst.canonical.currentProps;
+ };
+
+ getInstanceFromNode = getInstanceFromInstance;
+
+ getNodeFromInstance = function getNodeFromInstance(inst) {
+ inst = inst.stateNode.canonical._nativeTag;
+ invariant(inst, "All native instances should have a tag.");
+ return inst;
+ };
+
+ ResponderEventPlugin.injection.injectGlobalResponderHandler({
+ onChange: function onChange(from, to, blockNativeResponder) {
+ null !== to ? UIManager.setJSResponder(to.stateNode.canonical._nativeTag, blockNativeResponder) : UIManager.clearJSResponder();
+ }
+ });
+ var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+ ReactSharedInternals.hasOwnProperty("ReactCurrentDispatcher") || (ReactSharedInternals.ReactCurrentDispatcher = {
+ current: null
+ });
+ var hasSymbol = "function" === typeof Symbol && (typeof Symbol === "function" ? Symbol.for : "@@for"),
+ REACT_ELEMENT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.element") : 60103,
+ REACT_PORTAL_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.portal") : 60106,
+ REACT_FRAGMENT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.fragment") : 60107,
+ REACT_STRICT_MODE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.strict_mode") : 60108,
+ REACT_PROFILER_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.profiler") : 60114,
+ REACT_PROVIDER_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.provider") : 60109,
+ REACT_CONTEXT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.context") : 60110,
+ REACT_CONCURRENT_MODE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.concurrent_mode") : 60111,
+ REACT_FORWARD_REF_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.forward_ref") : 60112,
+ REACT_SUSPENSE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.suspense") : 60113,
+ REACT_MEMO_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.memo") : 60115,
+ REACT_LAZY_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.lazy") : 60116,
+ MAYBE_ITERATOR_SYMBOL = "function" === typeof Symbol && (typeof Symbol === "function" ? Symbol.iterator : "@@iterator");
+
+ function getIteratorFn(maybeIterable) {
+ if (null === maybeIterable || "object" !== typeof maybeIterable) return null;
+ maybeIterable = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable["@@iterator"];
+ return "function" === typeof maybeIterable ? maybeIterable : null;
+ }
+
+ function getComponentName(type) {
+ if (null == type) return null;
+ if ("function" === typeof type) return type.displayName || type.name || null;
+ if ("string" === typeof type) return type;
+
+ switch (type) {
+ case REACT_CONCURRENT_MODE_TYPE:
+ return "ConcurrentMode";
+
+ case REACT_FRAGMENT_TYPE:
+ return "Fragment";
+
+ case REACT_PORTAL_TYPE:
+ return "Portal";
+
+ case REACT_PROFILER_TYPE:
+ return "Profiler";
+
+ case REACT_STRICT_MODE_TYPE:
+ return "StrictMode";
+
+ case REACT_SUSPENSE_TYPE:
+ return "Suspense";
+ }
+
+ if ("object" === typeof type) switch (type.$$typeof) {
+ case REACT_CONTEXT_TYPE:
+ return "Context.Consumer";
+
+ case REACT_PROVIDER_TYPE:
+ return "Context.Provider";
+
+ case REACT_FORWARD_REF_TYPE:
+ var innerType = type.render;
+ innerType = innerType.displayName || innerType.name || "";
+ return type.displayName || ("" !== innerType ? "ForwardRef(" + innerType + ")" : "ForwardRef");
+
+ case REACT_MEMO_TYPE:
+ return getComponentName(type.type);
+
+ case REACT_LAZY_TYPE:
+ if (type = 1 === type._status ? type._result : null) return getComponentName(type);
+ }
+ return null;
+ }
+
+ function isFiberMountedImpl(fiber) {
+ var node = fiber;
+ if (fiber.alternate) for (; node.return;) {
+ node = node.return;
+ } else {
+ if (0 !== (node.effectTag & 2)) return 1;
+
+ for (; node.return;) {
+ if (node = node.return, 0 !== (node.effectTag & 2)) return 1;
+ }
+ }
+ return 3 === node.tag ? 2 : 3;
+ }
+
+ function assertIsMounted(fiber) {
+ 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 mountSafeCallback_NOT_REALLY_SAFE(context, callback) {
+ return function () {
+ if (callback && ("boolean" !== typeof context.__isMounted || context.__isMounted)) return callback.apply(context, arguments);
+ };
+ }
+
+ var emptyObject = {},
+ removedKeys = null,
+ removedKeyCount = 0;
+
+ function restoreDeletedValuesInNestedArray(updatePayload, node, validAttributes) {
+ if (Array.isArray(node)) for (var i = node.length; i-- && 0 < removedKeyCount;) {
+ restoreDeletedValuesInNestedArray(updatePayload, node[i], validAttributes);
+ } else if (node && 0 < removedKeyCount) for (i in removedKeys) {
+ if (removedKeys[i]) {
+ var nextProp = node[i];
+
+ if (void 0 !== nextProp) {
+ var attributeConfig = validAttributes[i];
+
+ if (attributeConfig) {
+ "function" === typeof nextProp && (nextProp = !0);
+ "undefined" === typeof nextProp && (nextProp = null);
+ if ("object" !== typeof attributeConfig) updatePayload[i] = nextProp;else if ("function" === typeof attributeConfig.diff || "function" === typeof attributeConfig.process) nextProp = "function" === typeof attributeConfig.process ? attributeConfig.process(nextProp) : nextProp, updatePayload[i] = nextProp;
+ removedKeys[i] = !1;
+ removedKeyCount--;
+ }
+ }
+ }
+ }
+ }
+
+ function diffNestedProperty(updatePayload, prevProp, nextProp, validAttributes) {
+ if (!updatePayload && prevProp === nextProp) return updatePayload;
+ if (!prevProp || !nextProp) return nextProp ? addNestedProperty(updatePayload, nextProp, validAttributes) : prevProp ? clearNestedProperty(updatePayload, prevProp, validAttributes) : updatePayload;
+ if (!Array.isArray(prevProp) && !Array.isArray(nextProp)) return diffProperties(updatePayload, prevProp, nextProp, validAttributes);
+
+ if (Array.isArray(prevProp) && Array.isArray(nextProp)) {
+ var minLength = prevProp.length < nextProp.length ? prevProp.length : nextProp.length,
+ i;
+
+ for (i = 0; i < minLength; i++) {
+ updatePayload = diffNestedProperty(updatePayload, prevProp[i], nextProp[i], validAttributes);
+ }
+
+ for (; i < prevProp.length; i++) {
+ updatePayload = clearNestedProperty(updatePayload, prevProp[i], validAttributes);
+ }
+
+ for (; i < nextProp.length; i++) {
+ updatePayload = addNestedProperty(updatePayload, nextProp[i], validAttributes);
+ }
+
+ return updatePayload;
+ }
+
+ return Array.isArray(prevProp) ? diffProperties(updatePayload, 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, nextProp, validAttributes);
+
+ for (var i = 0; i < nextProp.length; i++) {
+ updatePayload = addNestedProperty(updatePayload, nextProp[i], validAttributes);
+ }
+
+ return updatePayload;
+ }
+
+ function clearNestedProperty(updatePayload, prevProp, validAttributes) {
+ if (!prevProp) return updatePayload;
+ if (!Array.isArray(prevProp)) return diffProperties(updatePayload, prevProp, emptyObject, validAttributes);
+
+ for (var i = 0; i < prevProp.length; i++) {
+ updatePayload = clearNestedProperty(updatePayload, prevProp[i], validAttributes);
+ }
+
+ return updatePayload;
+ }
+
+ function diffProperties(updatePayload, prevProps, nextProps, validAttributes) {
+ var attributeConfig, propKey;
+
+ for (propKey in nextProps) {
+ if (attributeConfig = validAttributes[propKey]) {
+ var prevProp = prevProps[propKey];
+ var nextProp = nextProps[propKey];
+ "function" === typeof nextProp && (nextProp = !0, "function" === typeof prevProp && (prevProp = !0));
+ "undefined" === typeof nextProp && (nextProp = null, "undefined" === typeof prevProp && (prevProp = null));
+ removedKeys && (removedKeys[propKey] = !1);
+ if (updatePayload && void 0 !== updatePayload[propKey]) {
+ if ("object" !== typeof attributeConfig) updatePayload[propKey] = nextProp;else {
+ if ("function" === typeof attributeConfig.diff || "function" === typeof attributeConfig.process) attributeConfig = "function" === typeof attributeConfig.process ? attributeConfig.process(nextProp) : nextProp, updatePayload[propKey] = attributeConfig;
+ }
+ } else if (prevProp !== nextProp) if ("object" !== typeof attributeConfig) ("object" !== typeof nextProp || null === nextProp || 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;
+
+ function setTimeoutCallback() {
+ frameDeadline = now$1() + 5;
+ var callback = scheduledCallback;
+ scheduledCallback = null;
+ null !== callback && callback();
+ }
+
+ function scheduleDeferredCallback$1(callback) {
+ scheduledCallback = callback;
+ return setTimeout(setTimeoutCallback, 1);
+ }
+
+ var restoreTarget = null,
+ restoreQueue = null;
+
+ function restoreStateOfTarget(target) {
+ if (target = getInstanceFromNode(target)) {
+ invariant(!1, "setRestoreImplementation() needs to be called to handle a target for controlled events. This error is likely caused by a bug in React. Please file an issue.");
+ var props = getFiberCurrentPropsFromNode(target.stateNode);
+ null(target.stateNode, target.type, props);
+ }
+ }
+
+ function _batchedUpdatesImpl(fn, bookkeeping) {
+ return fn(bookkeeping);
+ }
+
+ function _flushInteractiveUpdatesImpl() {}
+
+ var isBatching = !1;
+
+ function batchedUpdates(fn, bookkeeping) {
+ if (isBatching) return fn(bookkeeping);
+ isBatching = !0;
+
+ try {
+ return _batchedUpdatesImpl(fn, bookkeeping);
+ } finally {
+ if (isBatching = !1, null !== restoreTarget || null !== restoreQueue) if (_flushInteractiveUpdatesImpl(), 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;
+ if (events && (forEachAccumulated(events, executeDispatchesAndReleaseTopLevel), invariant(!eventQueue, "processEventQueue(): Additional events were enqueued while processing an event queue. Support for this has not yet been implemented."), hasRethrowError)) throw events = rethrowError, hasRethrowError = !1, rethrowError = null, events;
+ });
+ }
+
+ function shim$1() {
+ invariant(!1, "The current renderer does not support hydration. 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_NOT_REALLY_SAFE(this, callback));
+ };
+
+ ReactFabricHostComponent.prototype.measureInWindow = function (callback) {
+ UIManager.measureInWindow(this._nativeTag, mountSafeCallback_NOT_REALLY_SAFE(this, callback));
+ };
+
+ ReactFabricHostComponent.prototype.measureLayout = function (relativeToNativeNode, onSuccess, onFail) {
+ UIManager.measureLayout(this._nativeTag, relativeToNativeNode, mountSafeCallback_NOT_REALLY_SAFE(this, onFail), mountSafeCallback_NOT_REALLY_SAFE(this, onSuccess));
+ };
+
+ ReactFabricHostComponent.prototype.setNativeProps = function (nativeProps) {
+ nativeProps = diffProperties(null, emptyObject, 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 component.");
+ hostContext = nextReactTag;
+ nextReactTag += 2;
+ return {
+ node: FabricUIManager.createNode(hostContext, "RCTRawText", rootContainerInstance, {
+ text: text
+ }, internalInstanceHandle)
+ };
+ }
+
+ var scheduleTimeout = setTimeout,
+ cancelTimeout = clearTimeout;
+
+ function cloneHiddenInstance(instance) {
+ var node = instance.node;
+ var updatePayload = diffProperties(null, emptyObject, {
+ style: {
+ display: "none"
+ }
+ }, instance.canonical.viewConfig.validAttributes);
+ return {
+ node: FabricUIManager.cloneNodeWithNewProps(node, updatePayload),
+ canonical: instance.canonical
+ };
+ }
+
+ function cloneUnhiddenInstance(instance, type, props) {
+ var viewConfig = instance.canonical.viewConfig;
+ type = instance.node;
+
+ var prevProps = _extends({}, props, {
+ style: [props.style, {
+ display: "none"
+ }]
+ });
+
+ props = diffProperties(null, prevProps, props, viewConfig.validAttributes);
+ return {
+ node: FabricUIManager.cloneNodeWithNewProps(type, props),
+ canonical: instance.canonical
+ };
+ }
+
+ var BEFORE_SLASH_RE = /^(.*)[\\\/]/;
+
+ function getStackByFiberInDevAndProd(workInProgress) {
+ var info = "";
+
+ do {
+ a: switch (workInProgress.tag) {
+ case 3:
+ case 4:
+ case 6:
+ case 7:
+ case 10:
+ case 9:
+ var JSCompiler_inline_result = "";
+ break a;
+
+ default:
+ var owner = workInProgress._debugOwner,
+ source = workInProgress._debugSource,
+ name = getComponentName(workInProgress.type);
+ JSCompiler_inline_result = null;
+ owner && (JSCompiler_inline_result = getComponentName(owner.type));
+ owner = name;
+ name = "";
+ source ? name = " (at " + source.fileName.replace(BEFORE_SLASH_RE, "") + ":" + source.lineNumber + ")" : JSCompiler_inline_result && (name = " (created by " + JSCompiler_inline_result + ")");
+ JSCompiler_inline_result = "\n in " + (owner || "Unknown") + name;
+ }
+
+ info += JSCompiler_inline_result;
+ workInProgress = workInProgress.return;
+ } while (workInProgress);
+
+ return info;
+ }
+
+ new Set();
+ var valueStack = [],
+ index = -1;
+
+ function pop(cursor) {
+ 0 > index || (cursor.current = valueStack[index], valueStack[index] = null, index--);
+ }
+
+ function push(cursor, value) {
+ index++;
+ valueStack[index] = cursor.current;
+ cursor.current = value;
+ }
+
+ var emptyContextObject = {},
+ contextStackCursor = {
+ current: emptyContextObject
+ },
+ didPerformWorkStackCursor = {
+ current: !1
+ },
+ previousContext = emptyContextObject;
+
+ function getMaskedContext(workInProgress, unmaskedContext) {
+ var contextTypes = workInProgress.type.contextTypes;
+ if (!contextTypes) return emptyContextObject;
+ var instance = workInProgress.stateNode;
+ if (instance && instance.__reactInternalMemoizedUnmaskedChildContext === unmaskedContext) return instance.__reactInternalMemoizedMaskedChildContext;
+ var context = {},
+ key;
+
+ for (key in contextTypes) {
+ context[key] = unmaskedContext[key];
+ }
+
+ instance && (workInProgress = workInProgress.stateNode, workInProgress.__reactInternalMemoizedUnmaskedChildContext = unmaskedContext, workInProgress.__reactInternalMemoizedMaskedChildContext = context);
+ return context;
+ }
+
+ function isContextProvider(type) {
+ type = type.childContextTypes;
+ return null !== type && void 0 !== type;
+ }
+
+ function popContext(fiber) {
+ pop(didPerformWorkStackCursor, fiber);
+ pop(contextStackCursor, fiber);
+ }
+
+ function popTopLevelContextObject(fiber) {
+ pop(didPerformWorkStackCursor, fiber);
+ pop(contextStackCursor, fiber);
+ }
+
+ function pushTopLevelContextObject(fiber, context, didChange) {
+ invariant(contextStackCursor.current === emptyContextObject, "Unexpected context found on stack. This error is likely caused by a bug in React. Please file an issue.");
+ push(contextStackCursor, context, fiber);
+ push(didPerformWorkStackCursor, didChange, fiber);
+ }
+
+ function processChildContext(fiber, type, parentContext) {
+ var instance = fiber.stateNode;
+ fiber = type.childContextTypes;
+ if ("function" !== typeof instance.getChildContext) return parentContext;
+ instance = instance.getChildContext();
+
+ for (var contextKey in instance) {
+ invariant(contextKey in fiber, '%s.getChildContext(): key "%s" is not defined in childContextTypes.', getComponentName(type) || "Unknown", contextKey);
+ }
+
+ return _extends({}, parentContext, instance);
+ }
+
+ function pushContextProvider(workInProgress) {
+ var instance = workInProgress.stateNode;
+ instance = instance && instance.__reactInternalMemoizedMergedChildContext || emptyContextObject;
+ previousContext = contextStackCursor.current;
+ push(contextStackCursor, instance, workInProgress);
+ push(didPerformWorkStackCursor, didPerformWorkStackCursor.current, workInProgress);
+ return !0;
+ }
+
+ function invalidateContextProvider(workInProgress, type, didChange) {
+ var instance = workInProgress.stateNode;
+ invariant(instance, "Expected to have an instance by this point. This error is likely caused by a bug in React. Please file an issue.");
+ didChange ? (type = processChildContext(workInProgress, type, previousContext), instance.__reactInternalMemoizedMergedChildContext = type, pop(didPerformWorkStackCursor, workInProgress), pop(contextStackCursor, workInProgress), push(contextStackCursor, type, workInProgress)) : pop(didPerformWorkStackCursor, workInProgress);
+ push(didPerformWorkStackCursor, didChange, workInProgress);
+ }
+
+ var 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 FiberNode(tag, pendingProps, key, mode) {
+ this.tag = tag;
+ this.key = key;
+ this.sibling = this.child = this.return = this.stateNode = this.type = this.elementType = null;
+ this.index = 0;
+ this.ref = null;
+ this.pendingProps = pendingProps;
+ this.contextDependencies = this.memoizedState = this.updateQueue = this.memoizedProps = null;
+ this.mode = mode;
+ this.effectTag = 0;
+ this.lastEffect = this.firstEffect = this.nextEffect = null;
+ this.childExpirationTime = this.expirationTime = 0;
+ this.alternate = null;
+ }
+
+ function createFiber(tag, pendingProps, key, mode) {
+ return new FiberNode(tag, pendingProps, key, mode);
+ }
+
+ function shouldConstruct(Component) {
+ Component = Component.prototype;
+ return !(!Component || !Component.isReactComponent);
+ }
+
+ function resolveLazyComponentTag(Component) {
+ if ("function" === typeof Component) return shouldConstruct(Component) ? 1 : 0;
+
+ if (void 0 !== Component && null !== Component) {
+ Component = Component.$$typeof;
+ if (Component === REACT_FORWARD_REF_TYPE) return 11;
+ if (Component === REACT_MEMO_TYPE) return 14;
+ }
+
+ return 2;
+ }
+
+ function createWorkInProgress(current, pendingProps) {
+ var workInProgress = current.alternate;
+ null === workInProgress ? (workInProgress = createFiber(current.tag, pendingProps, current.key, current.mode), workInProgress.elementType = current.elementType, workInProgress.type = current.type, workInProgress.stateNode = current.stateNode, workInProgress.alternate = current, current.alternate = workInProgress) : (workInProgress.pendingProps = pendingProps, workInProgress.effectTag = 0, workInProgress.nextEffect = null, workInProgress.firstEffect = null, workInProgress.lastEffect = null);
+ workInProgress.childExpirationTime = current.childExpirationTime;
+ workInProgress.expirationTime = current.expirationTime;
+ workInProgress.child = current.child;
+ workInProgress.memoizedProps = current.memoizedProps;
+ workInProgress.memoizedState = current.memoizedState;
+ workInProgress.updateQueue = current.updateQueue;
+ workInProgress.contextDependencies = current.contextDependencies;
+ workInProgress.sibling = current.sibling;
+ workInProgress.index = current.index;
+ workInProgress.ref = current.ref;
+ return workInProgress;
+ }
+
+ function createFiberFromTypeAndProps(type, key, pendingProps, owner, mode, expirationTime) {
+ var fiberTag = 2;
+ owner = type;
+ if ("function" === typeof type) shouldConstruct(type) && (fiberTag = 1);else if ("string" === typeof type) fiberTag = 5;else a: switch (type) {
+ case REACT_FRAGMENT_TYPE:
+ return createFiberFromFragment(pendingProps.children, mode, expirationTime, key);
+
+ case REACT_CONCURRENT_MODE_TYPE:
+ return createFiberFromMode(pendingProps, mode | 3, expirationTime, key);
+
+ case REACT_STRICT_MODE_TYPE:
+ return createFiberFromMode(pendingProps, mode | 2, expirationTime, key);
+
+ case REACT_PROFILER_TYPE:
+ return type = createFiber(12, pendingProps, key, mode | 4), type.elementType = REACT_PROFILER_TYPE, type.type = REACT_PROFILER_TYPE, type.expirationTime = expirationTime, type;
+
+ case REACT_SUSPENSE_TYPE:
+ return type = createFiber(13, pendingProps, key, mode), type.elementType = REACT_SUSPENSE_TYPE, type.type = REACT_SUSPENSE_TYPE, type.expirationTime = expirationTime, type;
+
+ default:
+ if ("object" === typeof type && null !== type) switch (type.$$typeof) {
+ case REACT_PROVIDER_TYPE:
+ fiberTag = 10;
+ break a;
+
+ case REACT_CONTEXT_TYPE:
+ fiberTag = 9;
+ break a;
+
+ case REACT_FORWARD_REF_TYPE:
+ fiberTag = 11;
+ break a;
+
+ case REACT_MEMO_TYPE:
+ fiberTag = 14;
+ break a;
+
+ case REACT_LAZY_TYPE:
+ fiberTag = 16;
+ owner = null;
+ break a;
+ }
+ 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, "");
+ }
+ key = createFiber(fiberTag, pendingProps, key, mode);
+ key.elementType = type;
+ key.type = owner;
+ key.expirationTime = expirationTime;
+ return key;
+ }
+
+ function createFiberFromFragment(elements, mode, expirationTime, key) {
+ elements = createFiber(7, elements, key, mode);
+ elements.expirationTime = expirationTime;
+ return elements;
+ }
+
+ function createFiberFromMode(pendingProps, mode, expirationTime, key) {
+ pendingProps = createFiber(8, pendingProps, key, mode);
+ mode = 0 === (mode & 1) ? REACT_STRICT_MODE_TYPE : REACT_CONCURRENT_MODE_TYPE;
+ pendingProps.elementType = mode;
+ pendingProps.type = mode;
+ pendingProps.expirationTime = expirationTime;
+ return pendingProps;
+ }
+
+ function createFiberFromText(content, mode, expirationTime) {
+ content = createFiber(6, content, null, mode);
+ content.expirationTime = expirationTime;
+ return content;
+ }
+
+ function createFiberFromPortal(portal, mode, expirationTime) {
+ mode = createFiber(4, null !== portal.children ? portal.children : [], portal.key, mode);
+ mode.expirationTime = expirationTime;
+ mode.stateNode = {
+ containerInfo: portal.containerInfo,
+ pendingChildren: null,
+ implementation: portal.implementation
+ };
+ return mode;
+ }
+
+ function 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);
+ findNextExpirationTimeToWorkOn(expirationTime, root);
+ }
+
+ function markCommittedPriorityLevels(root, earliestRemainingTime) {
+ root.didError = !1;
+ if (0 === earliestRemainingTime) root.earliestPendingTime = 0, root.latestPendingTime = 0, root.earliestSuspendedTime = 0, root.latestSuspendedTime = 0, root.latestPingedTime = 0;else {
+ earliestRemainingTime < root.latestPingedTime && (root.latestPingedTime = 0);
+ var latestPendingTime = root.latestPendingTime;
+ 0 !== latestPendingTime && (latestPendingTime > earliestRemainingTime ? root.earliestPendingTime = root.latestPendingTime = 0 : root.earliestPendingTime > earliestRemainingTime && (root.earliestPendingTime = root.latestPendingTime));
+ latestPendingTime = root.earliestSuspendedTime;
+ 0 === latestPendingTime ? markPendingPriorityLevel(root, earliestRemainingTime) : earliestRemainingTime < root.latestSuspendedTime ? (root.earliestSuspendedTime = 0, root.latestSuspendedTime = 0, root.latestPingedTime = 0, markPendingPriorityLevel(root, earliestRemainingTime)) : earliestRemainingTime > latestPendingTime && markPendingPriorityLevel(root, earliestRemainingTime);
+ }
+ findNextExpirationTimeToWorkOn(0, root);
+ }
+
+ function markSuspendedPriorityLevel(root, suspendedTime) {
+ root.didError = !1;
+ root.latestPingedTime >= suspendedTime && (root.latestPingedTime = 0);
+ var earliestPendingTime = root.earliestPendingTime,
+ latestPendingTime = root.latestPendingTime;
+ earliestPendingTime === suspendedTime ? root.earliestPendingTime = latestPendingTime === suspendedTime ? root.latestPendingTime = 0 : latestPendingTime : latestPendingTime === suspendedTime && (root.latestPendingTime = earliestPendingTime);
+ earliestPendingTime = root.earliestSuspendedTime;
+ latestPendingTime = root.latestSuspendedTime;
+ 0 === earliestPendingTime ? root.earliestSuspendedTime = root.latestSuspendedTime = suspendedTime : earliestPendingTime < suspendedTime ? root.earliestSuspendedTime = suspendedTime : latestPendingTime > suspendedTime && (root.latestSuspendedTime = suspendedTime);
+ findNextExpirationTimeToWorkOn(suspendedTime, root);
+ }
+
+ function findEarliestOutstandingPriorityLevel(root, renderExpirationTime) {
+ var earliestPendingTime = root.earliestPendingTime;
+ root = root.earliestSuspendedTime;
+ earliestPendingTime > renderExpirationTime && (renderExpirationTime = earliestPendingTime);
+ root > renderExpirationTime && (renderExpirationTime = root);
+ return renderExpirationTime;
+ }
+
+ function findNextExpirationTimeToWorkOn(completedExpirationTime, root) {
+ var earliestSuspendedTime = root.earliestSuspendedTime,
+ latestSuspendedTime = root.latestSuspendedTime,
+ earliestPendingTime = root.earliestPendingTime,
+ latestPingedTime = root.latestPingedTime;
+ earliestPendingTime = 0 !== earliestPendingTime ? earliestPendingTime : latestPingedTime;
+ 0 === earliestPendingTime && (0 === completedExpirationTime || latestSuspendedTime < completedExpirationTime) && (earliestPendingTime = latestSuspendedTime);
+ completedExpirationTime = earliestPendingTime;
+ 0 !== completedExpirationTime && earliestSuspendedTime > completedExpirationTime && (completedExpirationTime = earliestSuspendedTime);
+ root.nextExpirationTimeToWorkOn = earliestPendingTime;
+ root.expirationTime = completedExpirationTime;
+ }
+
+ function is(x, y) {
+ return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
+ }
+
+ var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+ function shallowEqual(objA, objB) {
+ if (is(objA, objB)) return !0;
+ if ("object" !== typeof objA || null === objA || "object" !== typeof objB || null === objB) return !1;
+ var keysA = Object.keys(objA),
+ keysB = Object.keys(objB);
+ if (keysA.length !== keysB.length) return !1;
+
+ for (keysB = 0; keysB < keysA.length; keysB++) {
+ if (!hasOwnProperty.call(objB, keysA[keysB]) || !is(objA[keysA[keysB]], objB[keysA[keysB]])) return !1;
+ }
+
+ return !0;
+ }
+
+ function resolveDefaultProps(Component, baseProps) {
+ if (Component && Component.defaultProps) {
+ baseProps = _extends({}, baseProps);
+ Component = Component.defaultProps;
+
+ for (var propName in Component) {
+ void 0 === baseProps[propName] && (baseProps[propName] = Component[propName]);
+ }
+ }
+
+ return baseProps;
+ }
+
+ function readLazyComponentType(lazyComponent) {
+ var result = lazyComponent._result;
+
+ switch (lazyComponent._status) {
+ case 1:
+ return result;
+
+ case 2:
+ throw result;
+
+ case 0:
+ throw result;
+
+ default:
+ lazyComponent._status = 0;
+ result = lazyComponent._ctor;
+ result = result();
+ result.then(function (moduleObject) {
+ 0 === lazyComponent._status && (moduleObject = moduleObject.default, lazyComponent._status = 1, lazyComponent._result = moduleObject);
+ }, function (error) {
+ 0 === lazyComponent._status && (lazyComponent._status = 2, lazyComponent._result = error);
+ });
+
+ switch (lazyComponent._status) {
+ case 1:
+ return lazyComponent._result;
+
+ case 2:
+ throw lazyComponent._result;
+ }
+
+ lazyComponent._result = result;
+ throw result;
+ }
+ }
+
+ var emptyRefsObject = new React.Component().refs;
+
+ function applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, nextProps) {
+ ctor = workInProgress.memoizedState;
+ getDerivedStateFromProps = getDerivedStateFromProps(nextProps, ctor);
+ getDerivedStateFromProps = null === getDerivedStateFromProps || void 0 === getDerivedStateFromProps ? ctor : _extends({}, ctor, getDerivedStateFromProps);
+ workInProgress.memoizedState = getDerivedStateFromProps;
+ nextProps = workInProgress.updateQueue;
+ null !== nextProps && 0 === workInProgress.expirationTime && (nextProps.baseState = getDerivedStateFromProps);
+ }
+
+ var classComponentUpdater = {
+ isMounted: function isMounted(component) {
+ return (component = component._reactInternalFiber) ? 2 === isFiberMountedImpl(component) : !1;
+ },
+ enqueueSetState: function enqueueSetState(inst, payload, callback) {
+ inst = inst._reactInternalFiber;
+ var currentTime = requestCurrentTime();
+ currentTime = computeExpirationForFiber(currentTime, inst);
+ var update = createUpdate(currentTime);
+ update.payload = payload;
+ void 0 !== callback && null !== callback && (update.callback = callback);
+ flushPassiveEffects();
+ enqueueUpdate(inst, update);
+ scheduleWork(inst, currentTime);
+ },
+ enqueueReplaceState: function enqueueReplaceState(inst, payload, callback) {
+ inst = inst._reactInternalFiber;
+ var currentTime = requestCurrentTime();
+ currentTime = computeExpirationForFiber(currentTime, inst);
+ var update = createUpdate(currentTime);
+ update.tag = ReplaceState;
+ update.payload = payload;
+ void 0 !== callback && null !== callback && (update.callback = callback);
+ flushPassiveEffects();
+ enqueueUpdate(inst, update);
+ scheduleWork(inst, currentTime);
+ },
+ enqueueForceUpdate: function enqueueForceUpdate(inst, callback) {
+ inst = inst._reactInternalFiber;
+ var currentTime = requestCurrentTime();
+ currentTime = computeExpirationForFiber(currentTime, inst);
+ var update = createUpdate(currentTime);
+ update.tag = ForceUpdate;
+ void 0 !== callback && null !== callback && (update.callback = callback);
+ flushPassiveEffects();
+ enqueueUpdate(inst, update);
+ scheduleWork(inst, currentTime);
+ }
+ };
+
+ function checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext) {
+ workInProgress = workInProgress.stateNode;
+ return "function" === typeof workInProgress.shouldComponentUpdate ? workInProgress.shouldComponentUpdate(newProps, newState, nextContext) : ctor.prototype && ctor.prototype.isPureReactComponent ? !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState) : !0;
+ }
+
+ function constructClassInstance(workInProgress, ctor, props) {
+ var isLegacyContextConsumer = !1,
+ unmaskedContext = emptyContextObject;
+ var context = ctor.contextType;
+ "object" === typeof context && null !== context ? context = readContext(context) : (unmaskedContext = isContextProvider(ctor) ? previousContext : contextStackCursor.current, isLegacyContextConsumer = ctor.contextTypes, context = (isLegacyContextConsumer = null !== isLegacyContextConsumer && void 0 !== isLegacyContextConsumer) ? getMaskedContext(workInProgress, unmaskedContext) : emptyContextObject);
+ ctor = new ctor(props, context);
+ workInProgress.memoizedState = null !== ctor.state && void 0 !== ctor.state ? ctor.state : null;
+ ctor.updater = classComponentUpdater;
+ workInProgress.stateNode = ctor;
+ ctor._reactInternalFiber = workInProgress;
+ isLegacyContextConsumer && (workInProgress = workInProgress.stateNode, workInProgress.__reactInternalMemoizedUnmaskedChildContext = unmaskedContext, workInProgress.__reactInternalMemoizedMaskedChildContext = context);
+ return ctor;
+ }
+
+ function callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext) {
+ workInProgress = instance.state;
+ "function" === typeof instance.componentWillReceiveProps && instance.componentWillReceiveProps(newProps, nextContext);
+ "function" === typeof instance.UNSAFE_componentWillReceiveProps && instance.UNSAFE_componentWillReceiveProps(newProps, nextContext);
+ instance.state !== workInProgress && classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
+ }
+
+ function mountClassInstance(workInProgress, ctor, newProps, renderExpirationTime) {
+ var instance = workInProgress.stateNode;
+ instance.props = newProps;
+ instance.state = workInProgress.memoizedState;
+ instance.refs = emptyRefsObject;
+ var contextType = ctor.contextType;
+ "object" === typeof contextType && null !== contextType ? instance.context = readContext(contextType) : (contextType = isContextProvider(ctor) ? previousContext : contextStackCursor.current, instance.context = getMaskedContext(workInProgress, contextType));
+ contextType = workInProgress.updateQueue;
+ null !== contextType && (processUpdateQueue(workInProgress, contextType, newProps, instance, renderExpirationTime), instance.state = workInProgress.memoizedState);
+ contextType = ctor.getDerivedStateFromProps;
+ "function" === typeof contextType && (applyDerivedStateFromProps(workInProgress, ctor, contextType, newProps), instance.state = workInProgress.memoizedState);
+ "function" === typeof ctor.getDerivedStateFromProps || "function" === typeof instance.getSnapshotBeforeUpdate || "function" !== typeof instance.UNSAFE_componentWillMount && "function" !== typeof instance.componentWillMount || (ctor = instance.state, "function" === typeof instance.componentWillMount && instance.componentWillMount(), "function" === typeof instance.UNSAFE_componentWillMount && instance.UNSAFE_componentWillMount(), ctor !== instance.state && classComponentUpdater.enqueueReplaceState(instance, instance.state, null), contextType = workInProgress.updateQueue, null !== contextType && (processUpdateQueue(workInProgress, contextType, newProps, instance, renderExpirationTime), instance.state = workInProgress.memoizedState));
+ "function" === typeof instance.componentDidMount && (workInProgress.effectTag |= 4);
+ }
+
+ var isArray = Array.isArray;
+
+ function coerceRef(returnFiber, current$$1, element) {
+ returnFiber = element.ref;
+
+ if (null !== returnFiber && "function" !== typeof returnFiber && "object" !== typeof returnFiber) {
+ if (element._owner) {
+ element = element._owner;
+ var inst = void 0;
+ element && (invariant(1 === element.tag, "Function components cannot have refs. Did you mean to use React.forwardRef()?"), 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$$1 && null !== current$$1.ref && "function" === typeof current$$1.ref && current$$1.ref._stringRef === stringRef) return current$$1.ref;
+
+ current$$1 = function current$$1(value) {
+ var refs = inst.refs;
+ refs === emptyRefsObject && (refs = inst.refs = {});
+ null === value ? delete refs[stringRef] : refs[stringRef] = value;
+ };
+
+ current$$1._stringRef = stringRef;
+ return current$$1;
+ }
+
+ invariant("string" === typeof returnFiber, "Expected ref to be a function, a string, an object returned by React.createRef(), or null.");
+ 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 function component\n2. You may be adding a ref to a component that was not created inside a component's render method\n3. You have multiple copies of React loaded\nSee https://fb.me/react-refs-must-have-owner for more information.", 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$$1, textContent, expirationTime) {
+ if (null === current$$1 || 6 !== current$$1.tag) return current$$1 = createFiberFromText(textContent, returnFiber.mode, expirationTime), current$$1.return = returnFiber, current$$1;
+ current$$1 = useFiber(current$$1, textContent, expirationTime);
+ current$$1.return = returnFiber;
+ return current$$1;
+ }
+
+ function updateElement(returnFiber, current$$1, element, expirationTime) {
+ if (null !== current$$1 && current$$1.elementType === element.type) return expirationTime = useFiber(current$$1, element.props, expirationTime), expirationTime.ref = coerceRef(returnFiber, current$$1, element), expirationTime.return = returnFiber, expirationTime;
+ expirationTime = createFiberFromTypeAndProps(element.type, element.key, element.props, null, returnFiber.mode, expirationTime);
+ expirationTime.ref = coerceRef(returnFiber, current$$1, element);
+ expirationTime.return = returnFiber;
+ return expirationTime;
+ }
+
+ function updatePortal(returnFiber, current$$1, portal, expirationTime) {
+ if (null === current$$1 || 4 !== current$$1.tag || current$$1.stateNode.containerInfo !== portal.containerInfo || current$$1.stateNode.implementation !== portal.implementation) return current$$1 = createFiberFromPortal(portal, returnFiber.mode, expirationTime), current$$1.return = returnFiber, current$$1;
+ current$$1 = useFiber(current$$1, portal.children || [], expirationTime);
+ current$$1.return = returnFiber;
+ return current$$1;
+ }
+
+ function updateFragment(returnFiber, current$$1, fragment, expirationTime, key) {
+ if (null === current$$1 || 7 !== current$$1.tag) return current$$1 = createFiberFromFragment(fragment, returnFiber.mode, expirationTime, key), current$$1.return = returnFiber, current$$1;
+ current$$1 = useFiber(current$$1, fragment, expirationTime);
+ current$$1.return = returnFiber;
+ return current$$1;
+ }
+
+ function createChild(returnFiber, newChild, expirationTime) {
+ if ("string" === typeof newChild || "number" === typeof newChild) return newChild = createFiberFromText("" + newChild, returnFiber.mode, expirationTime), newChild.return = returnFiber, newChild;
+
+ if ("object" === typeof newChild && null !== newChild) {
+ switch (newChild.$$typeof) {
+ case REACT_ELEMENT_TYPE:
+ return expirationTime = createFiberFromTypeAndProps(newChild.type, newChild.key, newChild.props, null, returnFiber.mode, expirationTime), expirationTime.ref = coerceRef(returnFiber, null, newChild), expirationTime.return = returnFiber, expirationTime;
+
+ case REACT_PORTAL_TYPE:
+ return newChild = createFiberFromPortal(newChild, returnFiber.mode, expirationTime), newChild.return = returnFiber, newChild;
+ }
+
+ if (isArray(newChild) || getIteratorFn(newChild)) return newChild = createFiberFromFragment(newChild, returnFiber.mode, expirationTime, null), newChild.return = returnFiber, newChild;
+ throwOnInvalidObjectType(returnFiber, newChild);
+ }
+
+ return null;
+ }
+
+ function updateSlot(returnFiber, oldFiber, newChild, expirationTime) {
+ var key = null !== oldFiber ? oldFiber.key : null;
+ if ("string" === typeof newChild || "number" === typeof newChild) return null !== key ? null : updateTextNode(returnFiber, oldFiber, "" + newChild, expirationTime);
+
+ if ("object" === typeof newChild && null !== newChild) {
+ switch (newChild.$$typeof) {
+ case REACT_ELEMENT_TYPE:
+ return newChild.key === key ? newChild.type === REACT_FRAGMENT_TYPE ? updateFragment(returnFiber, oldFiber, newChild.props.children, expirationTime, key) : updateElement(returnFiber, oldFiber, newChild, expirationTime) : null;
+
+ case REACT_PORTAL_TYPE:
+ return newChild.key === key ? updatePortal(returnFiber, oldFiber, newChild, expirationTime) : null;
+ }
+
+ if (isArray(newChild) || getIteratorFn(newChild)) return null !== key ? null : updateFragment(returnFiber, oldFiber, newChild, expirationTime, null);
+ throwOnInvalidObjectType(returnFiber, newChild);
+ }
+
+ return null;
+ }
+
+ function updateFromMap(existingChildren, returnFiber, newIdx, newChild, expirationTime) {
+ if ("string" === typeof newChild || "number" === typeof newChild) return existingChildren = existingChildren.get(newIdx) || null, updateTextNode(returnFiber, existingChildren, "" + newChild, expirationTime);
+
+ if ("object" === typeof newChild && null !== newChild) {
+ switch (newChild.$$typeof) {
+ case REACT_ELEMENT_TYPE:
+ return existingChildren = existingChildren.get(null === newChild.key ? newIdx : newChild.key) || null, newChild.type === REACT_FRAGMENT_TYPE ? updateFragment(returnFiber, existingChildren, newChild.props.children, expirationTime, newChild.key) : updateElement(returnFiber, existingChildren, newChild, expirationTime);
+
+ case REACT_PORTAL_TYPE:
+ return existingChildren = existingChildren.get(null === newChild.key ? newIdx : newChild.key) || null, updatePortal(returnFiber, existingChildren, newChild, expirationTime);
+ }
+
+ if (isArray(newChild) || getIteratorFn(newChild)) return existingChildren = existingChildren.get(newIdx) || null, updateFragment(returnFiber, existingChildren, newChild, expirationTime, null);
+ throwOnInvalidObjectType(returnFiber, newChild);
+ }
+
+ return null;
+ }
+
+ function reconcileChildrenArray(returnFiber, currentFirstChild, newChildren, expirationTime) {
+ for (var resultingFirstChild = null, previousNewFiber = null, oldFiber = currentFirstChild, newIdx = currentFirstChild = 0, nextOldFiber = null; null !== oldFiber && newIdx < newChildren.length; newIdx++) {
+ oldFiber.index > newIdx ? (nextOldFiber = oldFiber, oldFiber = null) : nextOldFiber = oldFiber.sibling;
+ var newFiber = updateSlot(returnFiber, oldFiber, newChildren[newIdx], expirationTime);
+
+ if (null === newFiber) {
+ null === oldFiber && (oldFiber = nextOldFiber);
+ break;
+ }
+
+ shouldTrackSideEffects && oldFiber && null === newFiber.alternate && deleteChild(returnFiber, oldFiber);
+ currentFirstChild = placeChild(newFiber, currentFirstChild, newIdx);
+ null === previousNewFiber ? resultingFirstChild = newFiber : previousNewFiber.sibling = newFiber;
+ previousNewFiber = newFiber;
+ oldFiber = nextOldFiber;
+ }
+
+ if (newIdx === newChildren.length) return deleteRemainingChildren(returnFiber, oldFiber), resultingFirstChild;
+
+ if (null === oldFiber) {
+ for (; newIdx < newChildren.length; newIdx++) {
+ 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 (7 === isUnkeyedTopLevelFragment.tag ? newChild.type === REACT_FRAGMENT_TYPE : isUnkeyedTopLevelFragment.elementType === newChild.type) {
+ deleteRemainingChildren(returnFiber, isUnkeyedTopLevelFragment.sibling);
+ currentFirstChild = useFiber(isUnkeyedTopLevelFragment, newChild.type === REACT_FRAGMENT_TYPE ? newChild.props.children : newChild.props, expirationTime);
+ currentFirstChild.ref = coerceRef(returnFiber, isUnkeyedTopLevelFragment, newChild);
+ currentFirstChild.return = returnFiber;
+ returnFiber = currentFirstChild;
+ break a;
+ } 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 = createFiberFromTypeAndProps(newChild.type, newChild.key, newChild.props, null, returnFiber.mode, expirationTime), expirationTime.ref = coerceRef(returnFiber, currentFirstChild, newChild), expirationTime.return = returnFiber, returnFiber = expirationTime);
+ }
+
+ return placeSingleChild(returnFiber);
+
+ case REACT_PORTAL_TYPE:
+ a: {
+ for (isUnkeyedTopLevelFragment = newChild.key; null !== currentFirstChild;) {
+ if (currentFirstChild.key === isUnkeyedTopLevelFragment) {
+ if (4 === currentFirstChild.tag && currentFirstChild.stateNode.containerInfo === newChild.containerInfo && currentFirstChild.stateNode.implementation === newChild.implementation) {
+ deleteRemainingChildren(returnFiber, currentFirstChild.sibling);
+ currentFirstChild = useFiber(currentFirstChild, newChild.children || [], expirationTime);
+ currentFirstChild.return = returnFiber;
+ returnFiber = currentFirstChild;
+ break a;
+ } 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(newChild)) return reconcileChildrenArray(returnFiber, currentFirstChild, newChild, expirationTime);
+ if (getIteratorFn(newChild)) return reconcileChildrenIterator(returnFiber, currentFirstChild, newChild, expirationTime);
+ isObject && throwOnInvalidObjectType(returnFiber, newChild);
+ if ("undefined" === typeof newChild && !isUnkeyedTopLevelFragment) switch (returnFiber.tag) {
+ case 1:
+ case 0:
+ 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),
+ NO_CONTEXT = {},
+ contextStackCursor$1 = {
+ current: NO_CONTEXT
+ },
+ contextFiberStackCursor = {
+ current: NO_CONTEXT
+ },
+ rootInstanceStackCursor = {
+ current: 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 pushHostContext(fiber) {
+ requiredContext(rootInstanceStackCursor.current);
+ var context = requiredContext(contextStackCursor$1.current);
+ var nextContext = fiber.type;
+ nextContext = "AndroidTextInput" === nextContext || "RCTMultilineTextInputView" === nextContext || "RCTSinglelineTextInputView" === nextContext || "RCTText" === nextContext || "RCTVirtualText" === nextContext;
+ nextContext = context.isInAParentText !== nextContext ? {
+ isInAParentText: nextContext
+ } : context;
+ context !== nextContext && (push(contextFiberStackCursor, fiber, fiber), push(contextStackCursor$1, nextContext, fiber));
+ }
+
+ function popHostContext(fiber) {
+ contextFiberStackCursor.current === fiber && (pop(contextStackCursor$1, fiber), pop(contextFiberStackCursor, fiber));
+ }
+
+ var NoEffect$1 = 0,
+ UnmountSnapshot = 2,
+ UnmountMutation = 4,
+ MountMutation = 8,
+ UnmountLayout = 16,
+ MountLayout = 32,
+ MountPassive = 64,
+ UnmountPassive = 128,
+ ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher,
+ renderExpirationTime = 0,
+ currentlyRenderingFiber$1 = null,
+ currentHook = null,
+ nextCurrentHook = null,
+ firstWorkInProgressHook = null,
+ workInProgressHook = null,
+ nextWorkInProgressHook = null,
+ remainingExpirationTime = 0,
+ componentUpdateQueue = null,
+ sideEffectTag = 0,
+ didScheduleRenderPhaseUpdate = !1,
+ renderPhaseUpdates = null,
+ numberOfReRenders = 0;
+
+ function throwInvalidHookError() {
+ invariant(!1, "Hooks can only be called inside the body of a function component. (https://fb.me/react-invalid-hook-call)");
+ }
+
+ function areHookInputsEqual(nextDeps, prevDeps) {
+ if (null === prevDeps) return !1;
+
+ for (var i = 0; i < prevDeps.length && i < nextDeps.length; i++) {
+ if (!is(nextDeps[i], prevDeps[i])) return !1;
+ }
+
+ return !0;
+ }
+
+ function renderWithHooks(current, workInProgress, Component, props, refOrContext, nextRenderExpirationTime) {
+ renderExpirationTime = nextRenderExpirationTime;
+ currentlyRenderingFiber$1 = workInProgress;
+ nextCurrentHook = null !== current ? current.memoizedState : null;
+ ReactCurrentDispatcher$1.current = null === nextCurrentHook ? HooksDispatcherOnMount : HooksDispatcherOnUpdate;
+ workInProgress = Component(props, refOrContext);
+
+ if (didScheduleRenderPhaseUpdate) {
+ do {
+ didScheduleRenderPhaseUpdate = !1, numberOfReRenders += 1, nextCurrentHook = null !== current ? current.memoizedState : null, nextWorkInProgressHook = firstWorkInProgressHook, componentUpdateQueue = workInProgressHook = currentHook = null, ReactCurrentDispatcher$1.current = HooksDispatcherOnUpdate, workInProgress = Component(props, refOrContext);
+ } while (didScheduleRenderPhaseUpdate);
+
+ renderPhaseUpdates = null;
+ numberOfReRenders = 0;
+ }
+
+ ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
+ current = currentlyRenderingFiber$1;
+ current.memoizedState = firstWorkInProgressHook;
+ current.expirationTime = remainingExpirationTime;
+ current.updateQueue = componentUpdateQueue;
+ current.effectTag |= sideEffectTag;
+ current = null !== currentHook && null !== currentHook.next;
+ renderExpirationTime = 0;
+ nextWorkInProgressHook = workInProgressHook = firstWorkInProgressHook = nextCurrentHook = currentHook = currentlyRenderingFiber$1 = null;
+ remainingExpirationTime = 0;
+ componentUpdateQueue = null;
+ sideEffectTag = 0;
+ invariant(!current, "Rendered fewer hooks than expected. This may be caused by an accidental early return statement.");
+ return workInProgress;
+ }
+
+ function resetHooks() {
+ ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
+ renderExpirationTime = 0;
+ nextWorkInProgressHook = workInProgressHook = firstWorkInProgressHook = nextCurrentHook = currentHook = currentlyRenderingFiber$1 = null;
+ remainingExpirationTime = 0;
+ componentUpdateQueue = null;
+ sideEffectTag = 0;
+ didScheduleRenderPhaseUpdate = !1;
+ renderPhaseUpdates = null;
+ numberOfReRenders = 0;
+ }
+
+ function mountWorkInProgressHook() {
+ var hook = {
+ memoizedState: null,
+ baseState: null,
+ queue: null,
+ baseUpdate: null,
+ next: null
+ };
+ null === workInProgressHook ? firstWorkInProgressHook = workInProgressHook = hook : workInProgressHook = workInProgressHook.next = hook;
+ return workInProgressHook;
+ }
+
+ function updateWorkInProgressHook() {
+ if (null !== nextWorkInProgressHook) workInProgressHook = nextWorkInProgressHook, nextWorkInProgressHook = workInProgressHook.next, currentHook = nextCurrentHook, nextCurrentHook = null !== currentHook ? currentHook.next : null;else {
+ invariant(null !== nextCurrentHook, "Rendered more hooks than during the previous render.");
+ currentHook = nextCurrentHook;
+ var newHook = {
+ memoizedState: currentHook.memoizedState,
+ baseState: currentHook.baseState,
+ queue: currentHook.queue,
+ baseUpdate: currentHook.baseUpdate,
+ next: null
+ };
+ workInProgressHook = null === workInProgressHook ? firstWorkInProgressHook = newHook : workInProgressHook.next = newHook;
+ nextCurrentHook = currentHook.next;
+ }
+ return workInProgressHook;
+ }
+
+ function basicStateReducer(state, action) {
+ return "function" === typeof action ? action(state) : action;
+ }
+
+ function updateReducer(reducer) {
+ var hook = updateWorkInProgressHook(),
+ queue = hook.queue;
+ invariant(null !== queue, "Should have a queue. This is likely a bug in React. Please file an issue.");
+
+ if (0 < numberOfReRenders) {
+ var _dispatch = queue.dispatch;
+
+ if (null !== renderPhaseUpdates) {
+ var firstRenderPhaseUpdate = renderPhaseUpdates.get(queue);
+
+ if (void 0 !== firstRenderPhaseUpdate) {
+ renderPhaseUpdates.delete(queue);
+ var newState = hook.memoizedState;
+
+ do {
+ newState = reducer(newState, firstRenderPhaseUpdate.action), firstRenderPhaseUpdate = firstRenderPhaseUpdate.next;
+ } while (null !== firstRenderPhaseUpdate);
+
+ is(newState, hook.memoizedState) || (didReceiveUpdate = !0);
+ hook.memoizedState = newState;
+ hook.baseUpdate === queue.last && (hook.baseState = newState);
+ queue.eagerReducer = reducer;
+ queue.eagerState = newState;
+ return [newState, _dispatch];
+ }
+ }
+
+ return [hook.memoizedState, _dispatch];
+ }
+
+ _dispatch = queue.last;
+ var baseUpdate = hook.baseUpdate;
+ newState = hook.baseState;
+ null !== baseUpdate ? (null !== _dispatch && (_dispatch.next = null), _dispatch = baseUpdate.next) : _dispatch = null !== _dispatch ? _dispatch.next : null;
+
+ if (null !== _dispatch) {
+ var newBaseUpdate = firstRenderPhaseUpdate = null,
+ _update = _dispatch,
+ didSkip = !1;
+
+ do {
+ var updateExpirationTime = _update.expirationTime;
+ updateExpirationTime < renderExpirationTime ? (didSkip || (didSkip = !0, newBaseUpdate = baseUpdate, firstRenderPhaseUpdate = newState), updateExpirationTime > remainingExpirationTime && (remainingExpirationTime = updateExpirationTime)) : newState = _update.eagerReducer === reducer ? _update.eagerState : reducer(newState, _update.action);
+ baseUpdate = _update;
+ _update = _update.next;
+ } while (null !== _update && _update !== _dispatch);
+
+ didSkip || (newBaseUpdate = baseUpdate, firstRenderPhaseUpdate = newState);
+ is(newState, hook.memoizedState) || (didReceiveUpdate = !0);
+ hook.memoizedState = newState;
+ hook.baseUpdate = newBaseUpdate;
+ hook.baseState = firstRenderPhaseUpdate;
+ queue.eagerReducer = reducer;
+ queue.eagerState = newState;
+ }
+
+ return [hook.memoizedState, queue.dispatch];
+ }
+
+ function pushEffect(tag, create, destroy, deps) {
+ tag = {
+ tag: tag,
+ create: create,
+ destroy: destroy,
+ deps: deps,
+ next: null
+ };
+ null === componentUpdateQueue ? (componentUpdateQueue = {
+ lastEffect: null
+ }, componentUpdateQueue.lastEffect = tag.next = tag) : (create = componentUpdateQueue.lastEffect, null === create ? componentUpdateQueue.lastEffect = tag.next = tag : (destroy = create.next, create.next = tag, tag.next = destroy, componentUpdateQueue.lastEffect = tag));
+ return tag;
+ }
+
+ function mountEffectImpl(fiberEffectTag, hookEffectTag, create, deps) {
+ var hook = mountWorkInProgressHook();
+ sideEffectTag |= fiberEffectTag;
+ hook.memoizedState = pushEffect(hookEffectTag, create, void 0, void 0 === deps ? null : deps);
+ }
+
+ function updateEffectImpl(fiberEffectTag, hookEffectTag, create, deps) {
+ var hook = updateWorkInProgressHook();
+ deps = void 0 === deps ? null : deps;
+ var destroy = void 0;
+
+ if (null !== currentHook) {
+ var prevEffect = currentHook.memoizedState;
+ destroy = prevEffect.destroy;
+
+ if (null !== deps && areHookInputsEqual(deps, prevEffect.deps)) {
+ pushEffect(NoEffect$1, create, destroy, deps);
+ return;
+ }
+ }
+
+ sideEffectTag |= fiberEffectTag;
+ hook.memoizedState = pushEffect(hookEffectTag, create, destroy, deps);
+ }
+
+ function imperativeHandleEffect(create, ref) {
+ if ("function" === typeof ref) return create = create(), ref(create), function () {
+ ref(null);
+ };
+ if (null !== ref && void 0 !== ref) return create = create(), ref.current = create, function () {
+ ref.current = null;
+ };
+ }
+
+ function mountDebugValue() {}
+
+ function dispatchAction(fiber, queue, action) {
+ invariant(25 > numberOfReRenders, "Too many re-renders. React limits the number of renders to prevent an infinite loop.");
+ var alternate = fiber.alternate;
+ if (fiber === currentlyRenderingFiber$1 || null !== alternate && alternate === currentlyRenderingFiber$1) {
+ if (didScheduleRenderPhaseUpdate = !0, fiber = {
+ expirationTime: renderExpirationTime,
+ action: action,
+ eagerReducer: null,
+ eagerState: null,
+ next: null
+ }, null === renderPhaseUpdates && (renderPhaseUpdates = new Map()), action = renderPhaseUpdates.get(queue), void 0 === action) renderPhaseUpdates.set(queue, fiber);else {
+ for (queue = action; null !== queue.next;) {
+ queue = queue.next;
+ }
+
+ queue.next = fiber;
+ }
+ } else {
+ flushPassiveEffects();
+ var currentTime = requestCurrentTime();
+ currentTime = computeExpirationForFiber(currentTime, fiber);
+ var _update2 = {
+ expirationTime: currentTime,
+ action: action,
+ eagerReducer: null,
+ eagerState: null,
+ next: null
+ },
+ _last = queue.last;
+ if (null === _last) _update2.next = _update2;else {
+ var first = _last.next;
+ null !== first && (_update2.next = first);
+ _last.next = _update2;
+ }
+ queue.last = _update2;
+ if (0 === fiber.expirationTime && (null === alternate || 0 === alternate.expirationTime) && (alternate = queue.eagerReducer, null !== alternate)) try {
+ var currentState = queue.eagerState,
+ _eagerState = alternate(currentState, action);
+
+ _update2.eagerReducer = alternate;
+ _update2.eagerState = _eagerState;
+ if (is(_eagerState, currentState)) return;
+ } catch (error) {} finally {}
+ scheduleWork(fiber, currentTime);
+ }
+ }
+
+ var ContextOnlyDispatcher = {
+ readContext: readContext,
+ useCallback: throwInvalidHookError,
+ useContext: throwInvalidHookError,
+ useEffect: throwInvalidHookError,
+ useImperativeHandle: throwInvalidHookError,
+ useLayoutEffect: throwInvalidHookError,
+ useMemo: throwInvalidHookError,
+ useReducer: throwInvalidHookError,
+ useRef: throwInvalidHookError,
+ useState: throwInvalidHookError,
+ useDebugValue: throwInvalidHookError
+ },
+ HooksDispatcherOnMount = {
+ readContext: readContext,
+ useCallback: function useCallback(callback, deps) {
+ mountWorkInProgressHook().memoizedState = [callback, void 0 === deps ? null : deps];
+ return callback;
+ },
+ useContext: readContext,
+ useEffect: function useEffect(create, deps) {
+ return mountEffectImpl(516, UnmountPassive | MountPassive, create, deps);
+ },
+ useImperativeHandle: function useImperativeHandle(ref, create, deps) {
+ deps = null !== deps && void 0 !== deps ? deps.concat([ref]) : null;
+ return mountEffectImpl(4, UnmountMutation | MountLayout, imperativeHandleEffect.bind(null, create, ref), deps);
+ },
+ useLayoutEffect: function useLayoutEffect(create, deps) {
+ return mountEffectImpl(4, UnmountMutation | MountLayout, create, deps);
+ },
+ useMemo: function useMemo(nextCreate, deps) {
+ var hook = mountWorkInProgressHook();
+ deps = void 0 === deps ? null : deps;
+ nextCreate = nextCreate();
+ hook.memoizedState = [nextCreate, deps];
+ return nextCreate;
+ },
+ useReducer: function useReducer(reducer, initialArg, init) {
+ var hook = mountWorkInProgressHook();
+ initialArg = void 0 !== init ? init(initialArg) : initialArg;
+ hook.memoizedState = hook.baseState = initialArg;
+ reducer = hook.queue = {
+ last: null,
+ dispatch: null,
+ eagerReducer: reducer,
+ eagerState: initialArg
+ };
+ reducer = reducer.dispatch = dispatchAction.bind(null, currentlyRenderingFiber$1, reducer);
+ return [hook.memoizedState, reducer];
+ },
+ useRef: function useRef(initialValue) {
+ var hook = mountWorkInProgressHook();
+ initialValue = {
+ current: initialValue
+ };
+ return hook.memoizedState = initialValue;
+ },
+ useState: function useState(initialState) {
+ var hook = mountWorkInProgressHook();
+ "function" === typeof initialState && (initialState = initialState());
+ hook.memoizedState = hook.baseState = initialState;
+ initialState = hook.queue = {
+ last: null,
+ dispatch: null,
+ eagerReducer: basicStateReducer,
+ eagerState: initialState
+ };
+ initialState = initialState.dispatch = dispatchAction.bind(null, currentlyRenderingFiber$1, initialState);
+ return [hook.memoizedState, initialState];
+ },
+ useDebugValue: mountDebugValue
+ },
+ HooksDispatcherOnUpdate = {
+ readContext: readContext,
+ useCallback: function useCallback(callback, deps) {
+ var hook = updateWorkInProgressHook();
+ deps = void 0 === deps ? null : deps;
+ var prevState = hook.memoizedState;
+ if (null !== prevState && null !== deps && areHookInputsEqual(deps, prevState[1])) return prevState[0];
+ hook.memoizedState = [callback, deps];
+ return callback;
+ },
+ useContext: readContext,
+ useEffect: function useEffect(create, deps) {
+ return updateEffectImpl(516, UnmountPassive | MountPassive, create, deps);
+ },
+ useImperativeHandle: function useImperativeHandle(ref, create, deps) {
+ deps = null !== deps && void 0 !== deps ? deps.concat([ref]) : null;
+ return updateEffectImpl(4, UnmountMutation | MountLayout, imperativeHandleEffect.bind(null, create, ref), deps);
+ },
+ useLayoutEffect: function useLayoutEffect(create, deps) {
+ return updateEffectImpl(4, UnmountMutation | MountLayout, create, deps);
+ },
+ useMemo: function useMemo(nextCreate, deps) {
+ var hook = updateWorkInProgressHook();
+ deps = void 0 === deps ? null : deps;
+ var prevState = hook.memoizedState;
+ if (null !== prevState && null !== deps && areHookInputsEqual(deps, prevState[1])) return prevState[0];
+ nextCreate = nextCreate();
+ hook.memoizedState = [nextCreate, deps];
+ return nextCreate;
+ },
+ useReducer: updateReducer,
+ useRef: function useRef() {
+ return updateWorkInProgressHook().memoizedState;
+ },
+ useState: function useState(initialState) {
+ return updateReducer(basicStateReducer, initialState);
+ },
+ useDebugValue: mountDebugValue
+ },
+ hydrationParentFiber = null,
+ nextHydratableInstance = null,
+ isHydrating = !1;
+
+ function tryHydrate(fiber, nextInstance) {
+ switch (fiber.tag) {
+ case 5:
+ return nextInstance = shim$1(nextInstance, fiber.type, fiber.pendingProps), null !== nextInstance ? (fiber.stateNode = nextInstance, !0) : !1;
+
+ case 6:
+ return nextInstance = shim$1(nextInstance, fiber.pendingProps), null !== nextInstance ? (fiber.stateNode = nextInstance, !0) : !1;
+
+ case 13:
+ return !1;
+
+ default:
+ return !1;
+ }
+ }
+
+ function tryToClaimNextHydratableInstance(fiber$jscomp$0) {
+ if (isHydrating) {
+ var nextInstance = nextHydratableInstance;
+
+ if (nextInstance) {
+ var firstAttemptedInstance = nextInstance;
+
+ if (!tryHydrate(fiber$jscomp$0, nextInstance)) {
+ nextInstance = shim$1(firstAttemptedInstance);
+
+ if (!nextInstance || !tryHydrate(fiber$jscomp$0, nextInstance)) {
+ fiber$jscomp$0.effectTag |= 2;
+ isHydrating = !1;
+ hydrationParentFiber = fiber$jscomp$0;
+ return;
+ }
+
+ var returnFiber = hydrationParentFiber,
+ fiber = createFiber(5, null, null, 0);
+ fiber.elementType = "DELETED";
+ fiber.type = "DELETED";
+ fiber.stateNode = firstAttemptedInstance;
+ fiber.return = returnFiber;
+ fiber.effectTag = 8;
+ null !== returnFiber.lastEffect ? (returnFiber.lastEffect.nextEffect = fiber, returnFiber.lastEffect = fiber) : returnFiber.firstEffect = returnFiber.lastEffect = fiber;
+ }
+
+ hydrationParentFiber = fiber$jscomp$0;
+ nextHydratableInstance = shim$1(nextInstance);
+ } else fiber$jscomp$0.effectTag |= 2, isHydrating = !1, hydrationParentFiber = fiber$jscomp$0;
+ }
+ }
+
+ var ReactCurrentOwner$3 = ReactSharedInternals.ReactCurrentOwner,
+ didReceiveUpdate = !1;
+
+ function reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime) {
+ workInProgress.child = null === current$$1 ? mountChildFibers(workInProgress, null, nextChildren, renderExpirationTime) : reconcileChildFibers(workInProgress, current$$1.child, nextChildren, renderExpirationTime);
+ }
+
+ function updateForwardRef(current$$1, workInProgress, Component, nextProps, renderExpirationTime) {
+ Component = Component.render;
+ var ref = workInProgress.ref;
+ prepareToReadContext(workInProgress, renderExpirationTime);
+ nextProps = renderWithHooks(current$$1, workInProgress, Component, nextProps, ref, renderExpirationTime);
+ if (null !== current$$1 && !didReceiveUpdate) return workInProgress.updateQueue = current$$1.updateQueue, workInProgress.effectTag &= -517, current$$1.expirationTime <= renderExpirationTime && (current$$1.expirationTime = 0), bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ workInProgress.effectTag |= 1;
+ reconcileChildren(current$$1, workInProgress, nextProps, renderExpirationTime);
+ return workInProgress.child;
+ }
+
+ function updateMemoComponent(current$$1, workInProgress, Component, nextProps, updateExpirationTime, renderExpirationTime) {
+ if (null === current$$1) {
+ var type = Component.type;
+ if ("function" === typeof type && !shouldConstruct(type) && void 0 === type.defaultProps && null === Component.compare && void 0 === Component.defaultProps) return workInProgress.tag = 15, workInProgress.type = type, updateSimpleMemoComponent(current$$1, workInProgress, type, nextProps, updateExpirationTime, renderExpirationTime);
+ current$$1 = createFiberFromTypeAndProps(Component.type, null, nextProps, null, workInProgress.mode, renderExpirationTime);
+ current$$1.ref = workInProgress.ref;
+ current$$1.return = workInProgress;
+ return workInProgress.child = current$$1;
+ }
+
+ type = current$$1.child;
+ if (updateExpirationTime < renderExpirationTime && (updateExpirationTime = type.memoizedProps, Component = Component.compare, Component = null !== Component ? Component : shallowEqual, Component(updateExpirationTime, nextProps) && current$$1.ref === workInProgress.ref)) return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ workInProgress.effectTag |= 1;
+ current$$1 = createWorkInProgress(type, nextProps, renderExpirationTime);
+ current$$1.ref = workInProgress.ref;
+ current$$1.return = workInProgress;
+ return workInProgress.child = current$$1;
+ }
+
+ function updateSimpleMemoComponent(current$$1, workInProgress, Component, nextProps, updateExpirationTime, renderExpirationTime) {
+ return null !== current$$1 && shallowEqual(current$$1.memoizedProps, nextProps) && current$$1.ref === workInProgress.ref && (didReceiveUpdate = !1, updateExpirationTime < renderExpirationTime) ? bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime) : updateFunctionComponent(current$$1, workInProgress, Component, nextProps, renderExpirationTime);
+ }
+
+ function markRef(current$$1, workInProgress) {
+ var ref = workInProgress.ref;
+ if (null === current$$1 && null !== ref || null !== current$$1 && current$$1.ref !== ref) workInProgress.effectTag |= 128;
+ }
+
+ function updateFunctionComponent(current$$1, workInProgress, Component, nextProps, renderExpirationTime) {
+ var unmaskedContext = isContextProvider(Component) ? previousContext : contextStackCursor.current;
+ unmaskedContext = getMaskedContext(workInProgress, unmaskedContext);
+ prepareToReadContext(workInProgress, renderExpirationTime);
+ Component = renderWithHooks(current$$1, workInProgress, Component, nextProps, unmaskedContext, renderExpirationTime);
+ if (null !== current$$1 && !didReceiveUpdate) return workInProgress.updateQueue = current$$1.updateQueue, workInProgress.effectTag &= -517, current$$1.expirationTime <= renderExpirationTime && (current$$1.expirationTime = 0), bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ workInProgress.effectTag |= 1;
+ reconcileChildren(current$$1, workInProgress, Component, renderExpirationTime);
+ return workInProgress.child;
+ }
+
+ function updateClassComponent(current$$1, workInProgress, Component, nextProps, renderExpirationTime) {
+ if (isContextProvider(Component)) {
+ var hasContext = !0;
+ pushContextProvider(workInProgress);
+ } else hasContext = !1;
+
+ prepareToReadContext(workInProgress, renderExpirationTime);
+ if (null === workInProgress.stateNode) null !== current$$1 && (current$$1.alternate = null, workInProgress.alternate = null, workInProgress.effectTag |= 2), constructClassInstance(workInProgress, Component, nextProps, renderExpirationTime), mountClassInstance(workInProgress, Component, nextProps, renderExpirationTime), nextProps = !0;else if (null === current$$1) {
+ var instance = workInProgress.stateNode,
+ oldProps = workInProgress.memoizedProps;
+ instance.props = oldProps;
+ var oldContext = instance.context,
+ contextType = Component.contextType;
+ "object" === typeof contextType && null !== contextType ? contextType = readContext(contextType) : (contextType = isContextProvider(Component) ? previousContext : contextStackCursor.current, contextType = getMaskedContext(workInProgress, contextType));
+ var getDerivedStateFromProps = Component.getDerivedStateFromProps,
+ hasNewLifecycles = "function" === typeof getDerivedStateFromProps || "function" === typeof instance.getSnapshotBeforeUpdate;
+ hasNewLifecycles || "function" !== typeof instance.UNSAFE_componentWillReceiveProps && "function" !== typeof instance.componentWillReceiveProps || (oldProps !== nextProps || oldContext !== contextType) && callComponentWillReceiveProps(workInProgress, instance, nextProps, contextType);
+ hasForceUpdate = !1;
+ var oldState = workInProgress.memoizedState;
+ oldContext = instance.state = oldState;
+ var updateQueue = workInProgress.updateQueue;
+ null !== updateQueue && (processUpdateQueue(workInProgress, updateQueue, nextProps, instance, renderExpirationTime), oldContext = workInProgress.memoizedState);
+ oldProps !== nextProps || oldState !== oldContext || didPerformWorkStackCursor.current || hasForceUpdate ? ("function" === typeof getDerivedStateFromProps && (applyDerivedStateFromProps(workInProgress, Component, getDerivedStateFromProps, nextProps), oldContext = workInProgress.memoizedState), (oldProps = hasForceUpdate || checkShouldComponentUpdate(workInProgress, Component, oldProps, nextProps, oldState, oldContext, contextType)) ? (hasNewLifecycles || "function" !== typeof instance.UNSAFE_componentWillMount && "function" !== typeof instance.componentWillMount || ("function" === typeof instance.componentWillMount && instance.componentWillMount(), "function" === typeof instance.UNSAFE_componentWillMount && instance.UNSAFE_componentWillMount()), "function" === typeof instance.componentDidMount && (workInProgress.effectTag |= 4)) : ("function" === typeof instance.componentDidMount && (workInProgress.effectTag |= 4), workInProgress.memoizedProps = nextProps, workInProgress.memoizedState = oldContext), instance.props = nextProps, instance.state = oldContext, instance.context = contextType, nextProps = oldProps) : ("function" === typeof instance.componentDidMount && (workInProgress.effectTag |= 4), nextProps = !1);
+ } else instance = workInProgress.stateNode, oldProps = workInProgress.memoizedProps, instance.props = workInProgress.type === workInProgress.elementType ? oldProps : resolveDefaultProps(workInProgress.type, oldProps), oldContext = instance.context, contextType = Component.contextType, "object" === typeof contextType && null !== contextType ? contextType = readContext(contextType) : (contextType = isContextProvider(Component) ? previousContext : contextStackCursor.current, contextType = getMaskedContext(workInProgress, contextType)), getDerivedStateFromProps = Component.getDerivedStateFromProps, (hasNewLifecycles = "function" === typeof getDerivedStateFromProps || "function" === typeof instance.getSnapshotBeforeUpdate) || "function" !== typeof instance.UNSAFE_componentWillReceiveProps && "function" !== typeof instance.componentWillReceiveProps || (oldProps !== nextProps || oldContext !== contextType) && callComponentWillReceiveProps(workInProgress, instance, nextProps, contextType), hasForceUpdate = !1, oldContext = workInProgress.memoizedState, oldState = instance.state = oldContext, updateQueue = workInProgress.updateQueue, null !== updateQueue && (processUpdateQueue(workInProgress, updateQueue, nextProps, instance, renderExpirationTime), oldState = workInProgress.memoizedState), oldProps !== nextProps || oldContext !== oldState || didPerformWorkStackCursor.current || hasForceUpdate ? ("function" === typeof getDerivedStateFromProps && (applyDerivedStateFromProps(workInProgress, Component, getDerivedStateFromProps, nextProps), oldState = workInProgress.memoizedState), (getDerivedStateFromProps = hasForceUpdate || checkShouldComponentUpdate(workInProgress, Component, oldProps, nextProps, oldContext, oldState, contextType)) ? (hasNewLifecycles || "function" !== typeof instance.UNSAFE_componentWillUpdate && "function" !== typeof instance.componentWillUpdate || ("function" === typeof instance.componentWillUpdate && instance.componentWillUpdate(nextProps, oldState, contextType), "function" === typeof instance.UNSAFE_componentWillUpdate && instance.UNSAFE_componentWillUpdate(nextProps, oldState, contextType)), "function" === typeof instance.componentDidUpdate && (workInProgress.effectTag |= 4), "function" === typeof instance.getSnapshotBeforeUpdate && (workInProgress.effectTag |= 256)) : ("function" !== typeof instance.componentDidUpdate || oldProps === current$$1.memoizedProps && oldContext === current$$1.memoizedState || (workInProgress.effectTag |= 4), "function" !== typeof instance.getSnapshotBeforeUpdate || oldProps === current$$1.memoizedProps && oldContext === current$$1.memoizedState || (workInProgress.effectTag |= 256), workInProgress.memoizedProps = nextProps, workInProgress.memoizedState = oldState), instance.props = nextProps, instance.state = oldState, instance.context = contextType, nextProps = getDerivedStateFromProps) : ("function" !== typeof instance.componentDidUpdate || oldProps === current$$1.memoizedProps && oldContext === current$$1.memoizedState || (workInProgress.effectTag |= 4), "function" !== typeof instance.getSnapshotBeforeUpdate || oldProps === current$$1.memoizedProps && oldContext === current$$1.memoizedState || (workInProgress.effectTag |= 256), nextProps = !1);
+ return finishClassComponent(current$$1, workInProgress, Component, nextProps, hasContext, renderExpirationTime);
+ }
+
+ function finishClassComponent(current$$1, workInProgress, Component, shouldUpdate, hasContext, renderExpirationTime) {
+ markRef(current$$1, workInProgress);
+ var didCaptureError = 0 !== (workInProgress.effectTag & 64);
+ if (!shouldUpdate && !didCaptureError) return hasContext && invalidateContextProvider(workInProgress, Component, !1), bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ shouldUpdate = workInProgress.stateNode;
+ ReactCurrentOwner$3.current = workInProgress;
+ var nextChildren = didCaptureError && "function" !== typeof Component.getDerivedStateFromError ? null : shouldUpdate.render();
+ workInProgress.effectTag |= 1;
+ null !== current$$1 && didCaptureError ? (workInProgress.child = reconcileChildFibers(workInProgress, current$$1.child, null, renderExpirationTime), workInProgress.child = reconcileChildFibers(workInProgress, null, nextChildren, renderExpirationTime)) : reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
+ workInProgress.memoizedState = shouldUpdate.state;
+ hasContext && invalidateContextProvider(workInProgress, Component, !0);
+ return workInProgress.child;
+ }
+
+ function pushHostRootContext(workInProgress) {
+ var root = workInProgress.stateNode;
+ root.pendingContext ? pushTopLevelContextObject(workInProgress, root.pendingContext, root.pendingContext !== root.context) : root.context && pushTopLevelContextObject(workInProgress, root.context, !1);
+ pushHostContainer(workInProgress, root.containerInfo);
+ }
+
+ function updateSuspenseComponent(current$$1, workInProgress, renderExpirationTime) {
+ var mode = workInProgress.mode,
+ nextProps = workInProgress.pendingProps,
+ nextState = workInProgress.memoizedState;
+
+ if (0 === (workInProgress.effectTag & 64)) {
+ nextState = null;
+ var nextDidTimeout = !1;
+ } else nextState = {
+ timedOutAt: null !== nextState ? nextState.timedOutAt : 0
+ }, nextDidTimeout = !0, workInProgress.effectTag &= -65;
+
+ if (null === current$$1) {
+ if (nextDidTimeout) {
+ var nextFallbackChildren = nextProps.fallback;
+ current$$1 = createFiberFromFragment(null, mode, 0, null);
+ 0 === (workInProgress.mode & 1) && (current$$1.child = null !== workInProgress.memoizedState ? workInProgress.child.child : workInProgress.child);
+ mode = createFiberFromFragment(nextFallbackChildren, mode, renderExpirationTime, null);
+ current$$1.sibling = mode;
+ renderExpirationTime = current$$1;
+ renderExpirationTime.return = mode.return = workInProgress;
+ } else renderExpirationTime = mode = mountChildFibers(workInProgress, null, nextProps.children, renderExpirationTime);
+ } else null !== current$$1.memoizedState ? (mode = current$$1.child, nextFallbackChildren = mode.sibling, nextDidTimeout ? (renderExpirationTime = nextProps.fallback, nextProps = createWorkInProgress(mode, mode.pendingProps, 0), 0 === (workInProgress.mode & 1) && (nextDidTimeout = null !== workInProgress.memoizedState ? workInProgress.child.child : workInProgress.child, nextDidTimeout !== mode.child && (nextProps.child = nextDidTimeout)), mode = nextProps.sibling = createWorkInProgress(nextFallbackChildren, renderExpirationTime, nextFallbackChildren.expirationTime), renderExpirationTime = nextProps, nextProps.childExpirationTime = 0, renderExpirationTime.return = mode.return = workInProgress) : renderExpirationTime = mode = reconcileChildFibers(workInProgress, mode.child, nextProps.children, renderExpirationTime)) : (nextFallbackChildren = current$$1.child, nextDidTimeout ? (nextDidTimeout = nextProps.fallback, nextProps = createFiberFromFragment(null, mode, 0, null), nextProps.child = nextFallbackChildren, 0 === (workInProgress.mode & 1) && (nextProps.child = null !== workInProgress.memoizedState ? workInProgress.child.child : workInProgress.child), mode = nextProps.sibling = createFiberFromFragment(nextDidTimeout, mode, renderExpirationTime, null), mode.effectTag |= 2, renderExpirationTime = nextProps, nextProps.childExpirationTime = 0, renderExpirationTime.return = mode.return = workInProgress) : mode = renderExpirationTime = reconcileChildFibers(workInProgress, nextFallbackChildren, nextProps.children, renderExpirationTime)), workInProgress.stateNode = current$$1.stateNode;
+ workInProgress.memoizedState = nextState;
+ workInProgress.child = renderExpirationTime;
+ return mode;
+ }
+
+ function bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime) {
+ null !== current$$1 && (workInProgress.contextDependencies = current$$1.contextDependencies);
+ if (workInProgress.childExpirationTime < renderExpirationTime) return null;
+ invariant(null === current$$1 || workInProgress.child === current$$1.child, "Resuming work not yet implemented.");
+
+ if (null !== workInProgress.child) {
+ current$$1 = workInProgress.child;
+ renderExpirationTime = createWorkInProgress(current$$1, current$$1.pendingProps, current$$1.expirationTime);
+ workInProgress.child = renderExpirationTime;
+
+ for (renderExpirationTime.return = workInProgress; null !== current$$1.sibling;) {
+ current$$1 = current$$1.sibling, renderExpirationTime = renderExpirationTime.sibling = createWorkInProgress(current$$1, current$$1.pendingProps, current$$1.expirationTime), renderExpirationTime.return = workInProgress;
+ }
+
+ renderExpirationTime.sibling = null;
+ }
+
+ return workInProgress.child;
+ }
+
+ function beginWork(current$$1, workInProgress, renderExpirationTime) {
+ var updateExpirationTime = workInProgress.expirationTime;
+ if (null !== current$$1) {
+ if (current$$1.memoizedProps !== workInProgress.pendingProps || didPerformWorkStackCursor.current) didReceiveUpdate = !0;else {
+ if (updateExpirationTime < renderExpirationTime) {
+ didReceiveUpdate = !1;
+
+ switch (workInProgress.tag) {
+ case 3:
+ pushHostRootContext(workInProgress);
+ break;
+
+ case 5:
+ pushHostContext(workInProgress);
+ break;
+
+ case 1:
+ isContextProvider(workInProgress.type) && pushContextProvider(workInProgress);
+ break;
+
+ case 4:
+ pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+ break;
+
+ case 10:
+ pushProvider(workInProgress, workInProgress.memoizedProps.value);
+ break;
+
+ case 13:
+ if (null !== workInProgress.memoizedState) {
+ updateExpirationTime = workInProgress.child.childExpirationTime;
+ if (0 !== updateExpirationTime && updateExpirationTime >= renderExpirationTime) return updateSuspenseComponent(current$$1, workInProgress, renderExpirationTime);
+ workInProgress = bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ return null !== workInProgress ? workInProgress.sibling : null;
+ }
+
+ }
+
+ return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ }
+ }
+ } else didReceiveUpdate = !1;
+ workInProgress.expirationTime = 0;
+
+ switch (workInProgress.tag) {
+ case 2:
+ updateExpirationTime = workInProgress.elementType;
+ null !== current$$1 && (current$$1.alternate = null, workInProgress.alternate = null, workInProgress.effectTag |= 2);
+ current$$1 = workInProgress.pendingProps;
+ var context = getMaskedContext(workInProgress, contextStackCursor.current);
+ prepareToReadContext(workInProgress, renderExpirationTime);
+ context = renderWithHooks(null, workInProgress, updateExpirationTime, current$$1, context, renderExpirationTime);
+ workInProgress.effectTag |= 1;
+
+ if ("object" === typeof context && null !== context && "function" === typeof context.render && void 0 === context.$$typeof) {
+ workInProgress.tag = 1;
+ resetHooks();
+
+ if (isContextProvider(updateExpirationTime)) {
+ var hasContext = !0;
+ pushContextProvider(workInProgress);
+ } else hasContext = !1;
+
+ workInProgress.memoizedState = null !== context.state && void 0 !== context.state ? context.state : null;
+ var getDerivedStateFromProps = updateExpirationTime.getDerivedStateFromProps;
+ "function" === typeof getDerivedStateFromProps && applyDerivedStateFromProps(workInProgress, updateExpirationTime, getDerivedStateFromProps, current$$1);
+ context.updater = classComponentUpdater;
+ workInProgress.stateNode = context;
+ context._reactInternalFiber = workInProgress;
+ mountClassInstance(workInProgress, updateExpirationTime, current$$1, renderExpirationTime);
+ workInProgress = finishClassComponent(null, workInProgress, updateExpirationTime, !0, hasContext, renderExpirationTime);
+ } else workInProgress.tag = 0, reconcileChildren(null, workInProgress, context, renderExpirationTime), workInProgress = workInProgress.child;
+
+ return workInProgress;
+
+ case 16:
+ context = workInProgress.elementType;
+ null !== current$$1 && (current$$1.alternate = null, workInProgress.alternate = null, workInProgress.effectTag |= 2);
+ hasContext = workInProgress.pendingProps;
+ current$$1 = readLazyComponentType(context);
+ workInProgress.type = current$$1;
+ context = workInProgress.tag = resolveLazyComponentTag(current$$1);
+ hasContext = resolveDefaultProps(current$$1, hasContext);
+ getDerivedStateFromProps = void 0;
+
+ switch (context) {
+ case 0:
+ getDerivedStateFromProps = updateFunctionComponent(null, workInProgress, current$$1, hasContext, renderExpirationTime);
+ break;
+
+ case 1:
+ getDerivedStateFromProps = updateClassComponent(null, workInProgress, current$$1, hasContext, renderExpirationTime);
+ break;
+
+ case 11:
+ getDerivedStateFromProps = updateForwardRef(null, workInProgress, current$$1, hasContext, renderExpirationTime);
+ break;
+
+ case 14:
+ getDerivedStateFromProps = updateMemoComponent(null, workInProgress, current$$1, resolveDefaultProps(current$$1.type, hasContext), updateExpirationTime, renderExpirationTime);
+ break;
+
+ default:
+ invariant(!1, "Element type is invalid. Received a promise that resolves to: %s. Lazy element type must resolve to a class or function.%s", current$$1, "");
+ }
+
+ return getDerivedStateFromProps;
+
+ case 0:
+ return updateExpirationTime = workInProgress.type, context = workInProgress.pendingProps, context = workInProgress.elementType === updateExpirationTime ? context : resolveDefaultProps(updateExpirationTime, context), updateFunctionComponent(current$$1, workInProgress, updateExpirationTime, context, renderExpirationTime);
+
+ case 1:
+ return updateExpirationTime = workInProgress.type, context = workInProgress.pendingProps, context = workInProgress.elementType === updateExpirationTime ? context : resolveDefaultProps(updateExpirationTime, context), updateClassComponent(current$$1, workInProgress, updateExpirationTime, context, renderExpirationTime);
+
+ case 3:
+ return pushHostRootContext(workInProgress), updateExpirationTime = workInProgress.updateQueue, invariant(null !== updateExpirationTime, "If the root does not have an updateQueue, we should have already bailed out. This error is likely caused by a bug in React. Please file an issue."), context = workInProgress.memoizedState, context = null !== context ? context.element : null, processUpdateQueue(workInProgress, updateExpirationTime, workInProgress.pendingProps, null, renderExpirationTime), updateExpirationTime = workInProgress.memoizedState.element, updateExpirationTime === context ? workInProgress = bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime) : (reconcileChildren(current$$1, workInProgress, updateExpirationTime, renderExpirationTime), workInProgress = workInProgress.child), workInProgress;
+
+ case 5:
+ return pushHostContext(workInProgress), null === current$$1 && tryToClaimNextHydratableInstance(workInProgress), updateExpirationTime = workInProgress.pendingProps.children, markRef(current$$1, workInProgress), reconcileChildren(current$$1, workInProgress, updateExpirationTime, renderExpirationTime), workInProgress = workInProgress.child, workInProgress;
+
+ case 6:
+ return null === current$$1 && tryToClaimNextHydratableInstance(workInProgress), null;
+
+ case 13:
+ return updateSuspenseComponent(current$$1, workInProgress, renderExpirationTime);
+
+ case 4:
+ return pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo), updateExpirationTime = workInProgress.pendingProps, null === current$$1 ? workInProgress.child = reconcileChildFibers(workInProgress, null, updateExpirationTime, renderExpirationTime) : reconcileChildren(current$$1, workInProgress, updateExpirationTime, renderExpirationTime), workInProgress.child;
+
+ case 11:
+ return updateExpirationTime = workInProgress.type, context = workInProgress.pendingProps, context = workInProgress.elementType === updateExpirationTime ? context : resolveDefaultProps(updateExpirationTime, context), updateForwardRef(current$$1, workInProgress, updateExpirationTime, context, renderExpirationTime);
+
+ case 7:
+ return reconcileChildren(current$$1, workInProgress, workInProgress.pendingProps, renderExpirationTime), workInProgress.child;
+
+ case 8:
+ return reconcileChildren(current$$1, workInProgress, workInProgress.pendingProps.children, renderExpirationTime), workInProgress.child;
+
+ case 12:
+ return reconcileChildren(current$$1, workInProgress, workInProgress.pendingProps.children, renderExpirationTime), workInProgress.child;
+
+ case 10:
+ a: {
+ updateExpirationTime = workInProgress.type._context;
+ context = workInProgress.pendingProps;
+ getDerivedStateFromProps = workInProgress.memoizedProps;
+ hasContext = context.value;
+ pushProvider(workInProgress, hasContext);
+
+ if (null !== getDerivedStateFromProps) {
+ var oldValue = getDerivedStateFromProps.value;
+ hasContext = is(oldValue, hasContext) ? 0 : ("function" === typeof updateExpirationTime._calculateChangedBits ? updateExpirationTime._calculateChangedBits(oldValue, hasContext) : 1073741823) | 0;
+
+ if (0 === hasContext) {
+ if (getDerivedStateFromProps.children === context.children && !didPerformWorkStackCursor.current) {
+ workInProgress = bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ break a;
+ }
+ } else for (oldValue = workInProgress.child, null !== oldValue && (oldValue.return = workInProgress); null !== oldValue;) {
+ var list = oldValue.contextDependencies;
+
+ if (null !== list) {
+ getDerivedStateFromProps = oldValue.child;
+
+ for (var dependency = list.first; null !== dependency;) {
+ if (dependency.context === updateExpirationTime && 0 !== (dependency.observedBits & hasContext)) {
+ 1 === oldValue.tag && (dependency = createUpdate(renderExpirationTime), dependency.tag = ForceUpdate, enqueueUpdate(oldValue, dependency));
+ oldValue.expirationTime < renderExpirationTime && (oldValue.expirationTime = renderExpirationTime);
+ dependency = oldValue.alternate;
+ null !== dependency && dependency.expirationTime < renderExpirationTime && (dependency.expirationTime = renderExpirationTime);
+ dependency = renderExpirationTime;
+
+ for (var node = oldValue.return; null !== node;) {
+ var alternate = node.alternate;
+ if (node.childExpirationTime < dependency) node.childExpirationTime = dependency, null !== alternate && alternate.childExpirationTime < dependency && (alternate.childExpirationTime = dependency);else if (null !== alternate && alternate.childExpirationTime < dependency) alternate.childExpirationTime = dependency;else break;
+ node = node.return;
+ }
+
+ list.expirationTime < renderExpirationTime && (list.expirationTime = renderExpirationTime);
+ break;
+ }
+
+ dependency = dependency.next;
+ }
+ } else getDerivedStateFromProps = 10 === oldValue.tag ? oldValue.type === workInProgress.type ? null : oldValue.child : oldValue.child;
+
+ if (null !== getDerivedStateFromProps) getDerivedStateFromProps.return = oldValue;else for (getDerivedStateFromProps = oldValue; null !== getDerivedStateFromProps;) {
+ if (getDerivedStateFromProps === workInProgress) {
+ getDerivedStateFromProps = null;
+ break;
+ }
+
+ oldValue = getDerivedStateFromProps.sibling;
+
+ if (null !== oldValue) {
+ oldValue.return = getDerivedStateFromProps.return;
+ getDerivedStateFromProps = oldValue;
+ break;
+ }
+
+ getDerivedStateFromProps = getDerivedStateFromProps.return;
+ }
+ oldValue = getDerivedStateFromProps;
+ }
+ }
+
+ reconcileChildren(current$$1, workInProgress, context.children, renderExpirationTime);
+ workInProgress = workInProgress.child;
+ }
+
+ return workInProgress;
+
+ case 9:
+ return context = workInProgress.type, hasContext = workInProgress.pendingProps, updateExpirationTime = hasContext.children, prepareToReadContext(workInProgress, renderExpirationTime), context = readContext(context, hasContext.unstable_observedBits), updateExpirationTime = updateExpirationTime(context), workInProgress.effectTag |= 1, reconcileChildren(current$$1, workInProgress, updateExpirationTime, renderExpirationTime), workInProgress.child;
+
+ case 14:
+ return context = workInProgress.type, hasContext = resolveDefaultProps(context, workInProgress.pendingProps), hasContext = resolveDefaultProps(context.type, hasContext), updateMemoComponent(current$$1, workInProgress, context, hasContext, updateExpirationTime, renderExpirationTime);
+
+ case 15:
+ return updateSimpleMemoComponent(current$$1, workInProgress, workInProgress.type, workInProgress.pendingProps, updateExpirationTime, renderExpirationTime);
+
+ case 17:
+ return updateExpirationTime = workInProgress.type, context = workInProgress.pendingProps, context = workInProgress.elementType === updateExpirationTime ? context : resolveDefaultProps(updateExpirationTime, context), null !== current$$1 && (current$$1.alternate = null, workInProgress.alternate = null, workInProgress.effectTag |= 2), workInProgress.tag = 1, isContextProvider(updateExpirationTime) ? (current$$1 = !0, pushContextProvider(workInProgress)) : current$$1 = !1, prepareToReadContext(workInProgress, renderExpirationTime), constructClassInstance(workInProgress, updateExpirationTime, context, renderExpirationTime), mountClassInstance(workInProgress, updateExpirationTime, context, renderExpirationTime), finishClassComponent(null, workInProgress, updateExpirationTime, !0, current$$1, renderExpirationTime);
+ }
+
+ invariant(!1, "Unknown unit of work tag. This error is likely caused by a bug in React. Please file an issue.");
+ }
+
+ var valueCursor = {
+ current: null
+ },
+ currentlyRenderingFiber = null,
+ lastContextDependency = null,
+ lastContextWithAllBitsObserved = null;
+
+ function pushProvider(providerFiber, nextValue) {
+ var context = providerFiber.type._context;
+ push(valueCursor, context._currentValue2, providerFiber);
+ context._currentValue2 = nextValue;
+ }
+
+ function popProvider(providerFiber) {
+ var currentValue = valueCursor.current;
+ pop(valueCursor, providerFiber);
+ providerFiber.type._context._currentValue2 = currentValue;
+ }
+
+ function prepareToReadContext(workInProgress, renderExpirationTime) {
+ currentlyRenderingFiber = workInProgress;
+ lastContextWithAllBitsObserved = lastContextDependency = null;
+ var currentDependencies = workInProgress.contextDependencies;
+ null !== currentDependencies && currentDependencies.expirationTime >= renderExpirationTime && (didReceiveUpdate = !0);
+ workInProgress.contextDependencies = null;
+ }
+
+ function readContext(context, observedBits) {
+ if (lastContextWithAllBitsObserved !== context && !1 !== observedBits && 0 !== observedBits) {
+ if ("number" !== typeof observedBits || 1073741823 === observedBits) lastContextWithAllBitsObserved = context, observedBits = 1073741823;
+ observedBits = {
+ context: context,
+ observedBits: observedBits,
+ next: null
+ };
+ null === lastContextDependency ? (invariant(null !== currentlyRenderingFiber, "Context can only be read while React is rendering. In classes, you can read it in the render method or getDerivedStateFromProps. In function components, you can read it directly in the function body, but not inside Hooks like useReducer() or useMemo()."), lastContextDependency = observedBits, currentlyRenderingFiber.contextDependencies = {
+ first: observedBits,
+ expirationTime: 0
+ }) : lastContextDependency = lastContextDependency.next = observedBits;
+ }
+
+ return context._currentValue2;
+ }
+
+ var UpdateState = 0,
+ ReplaceState = 1,
+ ForceUpdate = 2,
+ CaptureUpdate = 3,
+ hasForceUpdate = !1;
+
+ function createUpdateQueue(baseState) {
+ return {
+ baseState: baseState,
+ firstUpdate: null,
+ lastUpdate: null,
+ firstCapturedUpdate: null,
+ lastCapturedUpdate: null,
+ firstEffect: null,
+ lastEffect: null,
+ firstCapturedEffect: null,
+ lastCapturedEffect: null
+ };
+ }
+
+ function cloneUpdateQueue(currentQueue) {
+ return {
+ baseState: currentQueue.baseState,
+ firstUpdate: currentQueue.firstUpdate,
+ lastUpdate: currentQueue.lastUpdate,
+ firstCapturedUpdate: null,
+ lastCapturedUpdate: null,
+ firstEffect: null,
+ lastEffect: null,
+ firstCapturedEffect: null,
+ lastCapturedEffect: null
+ };
+ }
+
+ function createUpdate(expirationTime) {
+ return {
+ expirationTime: expirationTime,
+ tag: UpdateState,
+ payload: null,
+ callback: null,
+ next: null,
+ nextEffect: null
+ };
+ }
+
+ function appendUpdateToQueue(queue, update) {
+ null === queue.lastUpdate ? queue.firstUpdate = queue.lastUpdate = update : (queue.lastUpdate.next = update, queue.lastUpdate = update);
+ }
+
+ function enqueueUpdate(fiber, update) {
+ var alternate = fiber.alternate;
+
+ if (null === alternate) {
+ var queue1 = fiber.updateQueue;
+ var queue2 = null;
+ null === queue1 && (queue1 = fiber.updateQueue = createUpdateQueue(fiber.memoizedState));
+ } else queue1 = fiber.updateQueue, queue2 = alternate.updateQueue, null === queue1 ? null === queue2 ? (queue1 = fiber.updateQueue = createUpdateQueue(fiber.memoizedState), queue2 = alternate.updateQueue = createUpdateQueue(alternate.memoizedState)) : queue1 = fiber.updateQueue = cloneUpdateQueue(queue2) : null === queue2 && (queue2 = alternate.updateQueue = cloneUpdateQueue(queue1));
+
+ null === queue2 || queue1 === queue2 ? appendUpdateToQueue(queue1, update) : null === queue1.lastUpdate || null === queue2.lastUpdate ? (appendUpdateToQueue(queue1, update), appendUpdateToQueue(queue2, update)) : (appendUpdateToQueue(queue1, update), queue2.lastUpdate = update);
+ }
+
+ function enqueueCapturedUpdate(workInProgress, update) {
+ var workInProgressQueue = workInProgress.updateQueue;
+ workInProgressQueue = null === workInProgressQueue ? workInProgress.updateQueue = createUpdateQueue(workInProgress.memoizedState) : ensureWorkInProgressQueueIsAClone(workInProgress, workInProgressQueue);
+ null === workInProgressQueue.lastCapturedUpdate ? workInProgressQueue.firstCapturedUpdate = workInProgressQueue.lastCapturedUpdate = update : (workInProgressQueue.lastCapturedUpdate.next = update, workInProgressQueue.lastCapturedUpdate = update);
+ }
+
+ function ensureWorkInProgressQueueIsAClone(workInProgress, queue) {
+ var current = workInProgress.alternate;
+ null !== current && queue === current.updateQueue && (queue = workInProgress.updateQueue = cloneUpdateQueue(queue));
+ return queue;
+ }
+
+ function getStateFromUpdate(workInProgress, queue, update, prevState, nextProps, instance) {
+ switch (update.tag) {
+ case ReplaceState:
+ return workInProgress = update.payload, "function" === typeof workInProgress ? workInProgress.call(instance, prevState, nextProps) : workInProgress;
+
+ case CaptureUpdate:
+ workInProgress.effectTag = workInProgress.effectTag & -2049 | 64;
+
+ case UpdateState:
+ 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 ForceUpdate:
+ hasForceUpdate = !0;
+ }
+
+ return prevState;
+ }
+
+ function processUpdateQueue(workInProgress, queue, props, instance, renderExpirationTime) {
+ hasForceUpdate = !1;
+ queue = ensureWorkInProgressQueueIsAClone(workInProgress, queue);
+
+ for (var newBaseState = queue.baseState, newFirstUpdate = null, newExpirationTime = 0, update = queue.firstUpdate, resultState = newBaseState; null !== update;) {
+ var updateExpirationTime = update.expirationTime;
+ updateExpirationTime < renderExpirationTime ? (null === newFirstUpdate && (newFirstUpdate = update, newBaseState = resultState), newExpirationTime < updateExpirationTime && (newExpirationTime = updateExpirationTime)) : (resultState = getStateFromUpdate(workInProgress, queue, update, resultState, props, instance), null !== update.callback && (workInProgress.effectTag |= 32, update.nextEffect = null, null === queue.lastEffect ? queue.firstEffect = queue.lastEffect = update : (queue.lastEffect.nextEffect = update, queue.lastEffect = update)));
+ update = update.next;
+ }
+
+ updateExpirationTime = null;
+
+ for (update = queue.firstCapturedUpdate; null !== update;) {
+ var _updateExpirationTime = update.expirationTime;
+ _updateExpirationTime < renderExpirationTime ? (null === updateExpirationTime && (updateExpirationTime = update, null === newFirstUpdate && (newBaseState = resultState)), newExpirationTime < _updateExpirationTime && (newExpirationTime = _updateExpirationTime)) : (resultState = getStateFromUpdate(workInProgress, queue, update, resultState, props, instance), null !== update.callback && (workInProgress.effectTag |= 32, update.nextEffect = null, null === queue.lastCapturedEffect ? queue.firstCapturedEffect = queue.lastCapturedEffect = update : (queue.lastCapturedEffect.nextEffect = update, queue.lastCapturedEffect = update)));
+ update = update.next;
+ }
+
+ null === newFirstUpdate && (queue.lastUpdate = null);
+ null === updateExpirationTime ? queue.lastCapturedUpdate = null : workInProgress.effectTag |= 32;
+ null === newFirstUpdate && null === updateExpirationTime && (newBaseState = resultState);
+ queue.baseState = newBaseState;
+ queue.firstUpdate = newFirstUpdate;
+ queue.firstCapturedUpdate = updateExpirationTime;
+ workInProgress.expirationTime = newExpirationTime;
+ workInProgress.memoizedState = resultState;
+ }
+
+ function commitUpdateQueue(finishedWork, finishedQueue, instance) {
+ null !== finishedQueue.firstCapturedUpdate && (null !== finishedQueue.lastUpdate && (finishedQueue.lastUpdate.next = finishedQueue.firstCapturedUpdate, finishedQueue.lastUpdate = finishedQueue.lastCapturedUpdate), finishedQueue.firstCapturedUpdate = finishedQueue.lastCapturedUpdate = null);
+ commitUpdateEffects(finishedQueue.firstEffect, instance);
+ finishedQueue.firstEffect = finishedQueue.lastEffect = null;
+ commitUpdateEffects(finishedQueue.firstCapturedEffect, instance);
+ finishedQueue.firstCapturedEffect = finishedQueue.lastCapturedEffect = null;
+ }
+
+ function commitUpdateEffects(effect, instance) {
+ for (; null !== effect;) {
+ var _callback3 = effect.callback;
+
+ if (null !== _callback3) {
+ effect.callback = null;
+ var context = instance;
+ invariant("function" === typeof _callback3, "Invalid argument passed as callback. Expected a function. Instead received: %s", _callback3);
+
+ _callback3.call(context);
+ }
+
+ effect = effect.nextEffect;
+ }
+ }
+
+ function createCapturedValue(value, source) {
+ return {
+ value: value,
+ source: source,
+ stack: getStackByFiberInDevAndProd(source)
+ };
+ }
+
+ var _appendAllChildren = void 0,
+ updateHostContainer = void 0,
+ updateHostComponent$1 = void 0,
+ updateHostText$1 = void 0;
+
+ _appendAllChildren = function appendAllChildren(parent, workInProgress, needsVisibilityToggle, isHidden) {
+ for (var node = workInProgress.child; null !== node;) {
+ a: if (5 === node.tag) {
+ var instance = node.stateNode;
+
+ if (needsVisibilityToggle) {
+ var props = node.memoizedProps,
+ type = node.type;
+ instance = isHidden ? cloneHiddenInstance(instance, type, props, node) : cloneUnhiddenInstance(instance, type, props, node);
+ node.stateNode = instance;
+ }
+
+ FabricUIManager.appendChild(parent.node, instance.node);
+ } else if (6 === node.tag) {
+ instance = node.stateNode;
+
+ if (needsVisibilityToggle) {
+ instance = node.memoizedProps;
+ props = requiredContext(rootInstanceStackCursor.current);
+ type = requiredContext(contextStackCursor$1.current);
+ if (isHidden) throw Error("Not yet implemented.");
+ instance = createTextInstance(instance, props, type, workInProgress);
+ node.stateNode = instance;
+ }
+
+ FabricUIManager.appendChild(parent.node, instance.node);
+ } else if (4 !== node.tag) {
+ if (13 === node.tag && (props = node.alternate, null !== props && (instance = null !== node.memoizedState, null !== props.memoizedState !== instance))) {
+ props = instance ? node.child : node;
+ null !== props && _appendAllChildren(parent, props, !0, instance);
+ break a;
+ }
+
+ if (null !== node.child) {
+ node.child.return = node;
+ node = node.child;
+ continue;
+ }
+ }
+
+ if (node === workInProgress) break;
+
+ for (; null === node.sibling;) {
+ if (null === node.return || node.return === workInProgress) return;
+ node = node.return;
+ }
+
+ node.sibling.return = node.return;
+ node = node.sibling;
+ }
+ };
+
+ function appendAllChildrenToContainer(containerChildSet, workInProgress, needsVisibilityToggle, isHidden) {
+ for (var node = workInProgress.child; null !== node;) {
+ a: if (5 === node.tag) {
+ var instance = node.stateNode;
+
+ if (needsVisibilityToggle) {
+ var props = node.memoizedProps,
+ type = node.type;
+ instance = isHidden ? cloneHiddenInstance(instance, type, props, node) : cloneUnhiddenInstance(instance, type, props, node);
+ node.stateNode = instance;
+ }
+
+ FabricUIManager.appendChildToSet(containerChildSet, instance.node);
+ } else if (6 === node.tag) {
+ instance = node.stateNode;
+
+ if (needsVisibilityToggle) {
+ instance = node.memoizedProps;
+ props = requiredContext(rootInstanceStackCursor.current);
+ type = requiredContext(contextStackCursor$1.current);
+ if (isHidden) throw Error("Not yet implemented.");
+ instance = createTextInstance(instance, props, type, workInProgress);
+ node.stateNode = instance;
+ }
+
+ FabricUIManager.appendChildToSet(containerChildSet, instance.node);
+ } else if (4 !== node.tag) {
+ if (13 === node.tag && (props = node.alternate, null !== props && (instance = null !== node.memoizedState, null !== props.memoizedState !== instance))) {
+ props = instance ? node.child : node;
+ null !== props && appendAllChildrenToContainer(containerChildSet, props, !0, instance);
+ break a;
+ }
+
+ if (null !== node.child) {
+ node.child.return = node;
+ node = node.child;
+ continue;
+ }
+ }
+
+ if (node === workInProgress) break;
+
+ for (; null === node.sibling;) {
+ if (null === node.return || node.return === workInProgress) return;
+ node = node.return;
+ }
+
+ node.sibling.return = node.return;
+ node = node.sibling;
+ }
+ }
+
+ updateHostContainer = function updateHostContainer(workInProgress) {
+ var portalOrRoot = workInProgress.stateNode;
+
+ if (null !== workInProgress.firstEffect) {
+ var container = portalOrRoot.containerInfo,
+ newChildSet = FabricUIManager.createChildSet(container);
+ appendAllChildrenToContainer(newChildSet, workInProgress, !1, !1);
+ portalOrRoot.pendingChildren = newChildSet;
+ workInProgress.effectTag |= 4;
+ FabricUIManager.completeRoot(container, newChildSet);
+ }
+ };
+
+ updateHostComponent$1 = function updateHostComponent$1(current, workInProgress, type, newProps) {
+ type = current.stateNode;
+ var oldProps = current.memoizedProps;
+ if ((current = null === workInProgress.firstEffect) && oldProps === newProps) workInProgress.stateNode = type;else {
+ var recyclableInstance = workInProgress.stateNode;
+ requiredContext(contextStackCursor$1.current);
+ var updatePayload = null;
+ oldProps !== newProps && (oldProps = diffProperties(null, oldProps, newProps, recyclableInstance.canonical.viewConfig.validAttributes), recyclableInstance.canonical.currentProps = newProps, updatePayload = oldProps);
+ current && null === updatePayload ? workInProgress.stateNode = type : (newProps = updatePayload, recyclableInstance = type.node, type = {
+ node: current ? null !== newProps ? FabricUIManager.cloneNodeWithNewProps(recyclableInstance, newProps) : FabricUIManager.cloneNode(recyclableInstance) : null !== newProps ? FabricUIManager.cloneNodeWithNewChildrenAndProps(recyclableInstance, newProps) : FabricUIManager.cloneNodeWithNewChildren(recyclableInstance),
+ canonical: type.canonical
+ }, workInProgress.stateNode = type, current ? workInProgress.effectTag |= 4 : _appendAllChildren(type, workInProgress, !1, !1));
+ }
+ };
+
+ updateHostText$1 = function updateHostText$1(current, workInProgress, oldText, newText) {
+ oldText !== newText && (current = requiredContext(rootInstanceStackCursor.current), oldText = requiredContext(contextStackCursor$1.current), workInProgress.stateNode = createTextInstance(newText, current, oldText, workInProgress), workInProgress.effectTag |= 4);
+ };
+
+ function logCapturedError(capturedError) {
+ var componentStack = capturedError.componentStack,
+ error = capturedError.error;
+
+ if (error instanceof Error) {
+ capturedError = error.message;
+ var name = error.name;
+
+ try {
+ error.message = (capturedError ? name + ": " + capturedError : name) + "\n\nThis error is located at:" + componentStack;
+ } catch (e) {}
+ } else error = "string" === typeof error ? Error(error + "\n\nThis error is located at:" + componentStack) : Error("Unspecified error at:" + componentStack);
+
+ ExceptionsManager.handleException(error, !1);
+ }
+
+ function logError(boundary, errorInfo) {
+ var source = errorInfo.source,
+ stack = errorInfo.stack;
+ null === stack && null !== source && (stack = getStackByFiberInDevAndProd(source));
+ errorInfo = {
+ componentName: null !== source ? getComponentName(source.type) : null,
+ componentStack: null !== stack ? stack : "",
+ error: errorInfo.value,
+ errorBoundary: null,
+ errorBoundaryName: null,
+ errorBoundaryFound: !1,
+ willRetry: !1
+ };
+ null !== boundary && 1 === boundary.tag && (errorInfo.errorBoundary = boundary.stateNode, errorInfo.errorBoundaryName = getComponentName(boundary.type), errorInfo.errorBoundaryFound = !0, errorInfo.willRetry = !0);
+
+ try {
+ logCapturedError(errorInfo);
+ } catch (e) {
+ setTimeout(function () {
+ throw e;
+ });
+ }
+ }
+
+ function safelyDetachRef(current$$1) {
+ var ref = current$$1.ref;
+ if (null !== ref) if ("function" === typeof ref) try {
+ ref(null);
+ } catch (refError) {
+ captureCommitPhaseError(current$$1, refError);
+ } else ref.current = null;
+ }
+
+ function commitHookEffectList(unmountTag, mountTag, finishedWork) {
+ finishedWork = finishedWork.updateQueue;
+ finishedWork = null !== finishedWork ? finishedWork.lastEffect : null;
+
+ if (null !== finishedWork) {
+ var effect = finishedWork = finishedWork.next;
+
+ do {
+ if ((effect.tag & unmountTag) !== NoEffect$1) {
+ var destroy = effect.destroy;
+ effect.destroy = void 0;
+ void 0 !== destroy && destroy();
+ }
+
+ (effect.tag & mountTag) !== NoEffect$1 && (destroy = effect.create, effect.destroy = destroy());
+ effect = effect.next;
+ } while (effect !== finishedWork);
+ }
+ }
+
+ function commitWork(current$$1, finishedWork) {
+ switch (finishedWork.tag) {
+ case 0:
+ case 11:
+ case 14:
+ case 15:
+ commitHookEffectList(UnmountMutation, MountMutation, finishedWork);
+ return;
+ }
+
+ switch (finishedWork.tag) {
+ case 1:
+ 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.");
+ }
+ }
+
+ var PossiblyWeakMap = "function" === typeof WeakMap ? WeakMap : Map;
+
+ function createRootErrorUpdate(fiber, errorInfo, expirationTime) {
+ expirationTime = createUpdate(expirationTime);
+ expirationTime.tag = CaptureUpdate;
+ 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 = CaptureUpdate;
+ var getDerivedStateFromError = fiber.type.getDerivedStateFromError;
+
+ if ("function" === typeof getDerivedStateFromError) {
+ var error$jscomp$0 = errorInfo.value;
+
+ expirationTime.payload = function () {
+ return getDerivedStateFromError(error$jscomp$0);
+ };
+ }
+
+ var inst = fiber.stateNode;
+ null !== inst && "function" === typeof inst.componentDidCatch && (expirationTime.callback = function () {
+ "function" !== typeof getDerivedStateFromError && (null === legacyErrorBoundariesThatAlreadyFailed ? legacyErrorBoundariesThatAlreadyFailed = new Set([this]) : legacyErrorBoundariesThatAlreadyFailed.add(this));
+ 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 1:
+ isContextProvider(workInProgress.type) && popContext(workInProgress);
+ var effectTag = workInProgress.effectTag;
+ return effectTag & 2048 ? (workInProgress.effectTag = effectTag & -2049 | 64, workInProgress) : null;
+
+ case 3:
+ return popHostContainer(workInProgress), popTopLevelContextObject(workInProgress), effectTag = workInProgress.effectTag, invariant(0 === (effectTag & 64), "The root failed to unmount after an error. This is likely a bug in React. Please file an issue."), workInProgress.effectTag = effectTag & -2049 | 64, workInProgress;
+
+ case 5:
+ return popHostContext(workInProgress), null;
+
+ case 13:
+ return effectTag = workInProgress.effectTag, effectTag & 2048 ? (workInProgress.effectTag = effectTag & -2049 | 64, workInProgress) : null;
+
+ case 18:
+ return null;
+
+ case 4:
+ return popHostContainer(workInProgress), null;
+
+ case 10:
+ return popProvider(workInProgress), null;
+
+ default:
+ return null;
+ }
+ }
+
+ var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher,
+ ReactCurrentOwner$2 = ReactSharedInternals.ReactCurrentOwner,
+ isWorking = !1,
+ nextUnitOfWork = null,
+ nextRoot = null,
+ nextRenderExpirationTime = 0,
+ nextLatestAbsoluteTimeoutMs = -1,
+ nextRenderDidError = !1,
+ nextEffect = null,
+ isCommitting$1 = !1,
+ rootWithPendingPassiveEffects = null,
+ passiveEffectCallbackHandle = null,
+ passiveEffectCallback = null,
+ 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 1:
+ var childContextTypes = interruptedWork$jscomp$0.type.childContextTypes;
+ null !== childContextTypes && void 0 !== childContextTypes && popContext(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 10:
+ popProvider(interruptedWork$jscomp$0);
+ }
+
+ interruptedWork = interruptedWork.return;
+ }
+ nextRoot = null;
+ nextRenderExpirationTime = 0;
+ nextLatestAbsoluteTimeoutMs = -1;
+ nextRenderDidError = !1;
+ nextUnitOfWork = null;
+ }
+
+ function commitAllHostEffects() {
+ for (; null !== nextEffect;) {
+ var effectTag = nextEffect.effectTag;
+
+ if (effectTag & 128) {
+ var current$$1 = nextEffect.alternate;
+ null !== current$$1 && (current$$1 = current$$1.ref, null !== current$$1 && ("function" === typeof current$$1 ? current$$1(null) : current$$1.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:
+ effectTag = nextEffect;
+
+ a: for (var node = current$$1 = effectTag;;) {
+ var current$$1$jscomp$0 = node;
+ "function" === typeof onCommitFiberUnmount && onCommitFiberUnmount(current$$1$jscomp$0);
+
+ switch (current$$1$jscomp$0.tag) {
+ case 0:
+ case 11:
+ case 14:
+ case 15:
+ var updateQueue = current$$1$jscomp$0.updateQueue;
+
+ if (null !== updateQueue && (updateQueue = updateQueue.lastEffect, null !== updateQueue)) {
+ var effect = updateQueue = updateQueue.next;
+
+ do {
+ var destroy = effect.destroy;
+
+ if (void 0 !== destroy) {
+ var current$$1$jscomp$1 = current$$1$jscomp$0;
+
+ try {
+ destroy();
+ } catch (error) {
+ captureCommitPhaseError(current$$1$jscomp$1, error);
+ }
+ }
+
+ effect = effect.next;
+ } while (effect !== updateQueue);
+ }
+
+ break;
+
+ case 1:
+ safelyDetachRef(current$$1$jscomp$0);
+ updateQueue = current$$1$jscomp$0.stateNode;
+ if ("function" === typeof updateQueue.componentWillUnmount) try {
+ updateQueue.props = current$$1$jscomp$0.memoizedProps, updateQueue.state = current$$1$jscomp$0.memoizedState, updateQueue.componentWillUnmount();
+ } catch (unmountError) {
+ captureCommitPhaseError(current$$1$jscomp$0, unmountError);
+ }
+ break;
+
+ case 5:
+ safelyDetachRef(current$$1$jscomp$0);
+ break;
+
+ case 4:
+ FabricUIManager.createChildSet(current$$1$jscomp$0.stateNode.containerInfo);
+ }
+
+ if (null !== node.child) node.child.return = node, node = node.child;else {
+ if (node === current$$1) break;
+
+ for (; null === node.sibling;) {
+ if (null === node.return || node.return === current$$1) break a;
+ node = node.return;
+ }
+
+ node.sibling.return = node.return;
+ node = node.sibling;
+ }
+ }
+
+ effectTag.return = null;
+ effectTag.child = null;
+ effectTag.memoizedState = null;
+ effectTag.updateQueue = null;
+ effectTag = effectTag.alternate;
+ null !== effectTag && (effectTag.return = null, effectTag.child = null, effectTag.memoizedState = null, effectTag.updateQueue = null);
+ }
+
+ nextEffect = nextEffect.nextEffect;
+ }
+ }
+
+ function commitBeforeMutationLifecycles() {
+ for (; null !== nextEffect;) {
+ if (nextEffect.effectTag & 256) a: {
+ var current$$1 = nextEffect.alternate,
+ finishedWork = nextEffect;
+
+ switch (finishedWork.tag) {
+ case 0:
+ case 11:
+ case 15:
+ commitHookEffectList(UnmountSnapshot, NoEffect$1, finishedWork);
+ break a;
+
+ case 1:
+ if (finishedWork.effectTag & 256 && null !== current$$1) {
+ var prevProps = current$$1.memoizedProps,
+ prevState = current$$1.memoizedState;
+ current$$1 = finishedWork.stateNode;
+ finishedWork = current$$1.getSnapshotBeforeUpdate(finishedWork.elementType === finishedWork.type ? prevProps : resolveDefaultProps(finishedWork.type, prevProps), prevState);
+ current$$1.__reactInternalSnapshotBeforeUpdate = finishedWork;
+ }
+
+ break a;
+
+ case 3:
+ case 5:
+ case 6:
+ case 4:
+ case 17:
+ break a;
+
+ 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;
+ }
+ }
+
+ function commitAllLifeCycles(finishedRoot, committedExpirationTime$jscomp$0) {
+ for (; null !== nextEffect;) {
+ var effectTag = nextEffect.effectTag;
+
+ if (effectTag & 36) {
+ var current$$1 = nextEffect.alternate,
+ finishedWork = nextEffect,
+ committedExpirationTime = committedExpirationTime$jscomp$0;
+
+ switch (finishedWork.tag) {
+ case 0:
+ case 11:
+ case 15:
+ commitHookEffectList(UnmountLayout, MountLayout, finishedWork);
+ break;
+
+ case 1:
+ var instance = finishedWork.stateNode;
+ if (finishedWork.effectTag & 4) if (null === current$$1) instance.componentDidMount();else {
+ var prevProps = finishedWork.elementType === finishedWork.type ? current$$1.memoizedProps : resolveDefaultProps(finishedWork.type, current$$1.memoizedProps);
+ instance.componentDidUpdate(prevProps, current$$1.memoizedState, instance.__reactInternalSnapshotBeforeUpdate);
+ }
+ current$$1 = finishedWork.updateQueue;
+ null !== current$$1 && commitUpdateQueue(finishedWork, current$$1, instance, committedExpirationTime);
+ break;
+
+ case 3:
+ instance = finishedWork.updateQueue;
+
+ if (null !== instance) {
+ current$$1 = null;
+ if (null !== finishedWork.child) switch (finishedWork.child.tag) {
+ case 5:
+ current$$1 = finishedWork.child.stateNode.canonical;
+ break;
+
+ case 1:
+ current$$1 = finishedWork.child.stateNode;
+ }
+ commitUpdateQueue(finishedWork, instance, current$$1, committedExpirationTime);
+ }
+
+ break;
+
+ case 5:
+ null === current$$1 && finishedWork.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 12:
+ break;
+
+ case 13:
+ break;
+
+ case 17:
+ 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 & 128 && (finishedWork = nextEffect.ref, null !== finishedWork)) {
+ committedExpirationTime = nextEffect.stateNode;
+
+ switch (nextEffect.tag) {
+ case 5:
+ committedExpirationTime = committedExpirationTime.canonical;
+ }
+
+ "function" === typeof finishedWork ? finishedWork(committedExpirationTime) : finishedWork.current = committedExpirationTime;
+ }
+
+ effectTag & 512 && (rootWithPendingPassiveEffects = finishedRoot);
+ nextEffect = nextEffect.nextEffect;
+ }
+ }
+
+ function commitPassiveEffects(root, firstEffect) {
+ passiveEffectCallback = passiveEffectCallbackHandle = rootWithPendingPassiveEffects = null;
+ var previousIsRendering = isRendering;
+ isRendering = !0;
+
+ do {
+ if (firstEffect.effectTag & 512) {
+ var didError = !1,
+ error = void 0;
+
+ try {
+ var finishedWork = firstEffect;
+ commitHookEffectList(UnmountPassive, NoEffect$1, finishedWork);
+ commitHookEffectList(NoEffect$1, MountPassive, finishedWork);
+ } catch (e) {
+ didError = !0, error = e;
+ }
+
+ didError && captureCommitPhaseError(firstEffect, error);
+ }
+
+ firstEffect = firstEffect.nextEffect;
+ } while (null !== firstEffect);
+
+ isRendering = previousIsRendering;
+ previousIsRendering = root.expirationTime;
+ 0 !== previousIsRendering && requestWork(root, previousIsRendering);
+ isBatchingUpdates || isRendering || performWork(1073741823, !1);
+ }
+
+ function flushPassiveEffects() {
+ if (null !== passiveEffectCallbackHandle) {
+ var callbackID = passiveEffectCallbackHandle;
+ scheduledCallback = null;
+ clearTimeout(callbackID);
+ }
+
+ null !== passiveEffectCallback && passiveEffectCallback();
+ }
+
+ function commitRoot(root, finishedWork) {
+ isCommitting$1 = isWorking = !0;
+ 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(0 !== committedExpirationTime, "Cannot commit an incomplete root. This error is likely caused by a bug in React. Please file an issue.");
+ root.pendingCommitExpirationTime = 0;
+ var updateExpirationTimeBeforeCommit = finishedWork.expirationTime,
+ childExpirationTimeBeforeCommit = finishedWork.childExpirationTime;
+ markCommittedPriorityLevels(root, childExpirationTimeBeforeCommit > updateExpirationTimeBeforeCommit ? childExpirationTimeBeforeCommit : updateExpirationTimeBeforeCommit);
+ ReactCurrentOwner$2.current = null;
+ updateExpirationTimeBeforeCommit = void 0;
+ 1 < finishedWork.effectTag ? null !== finishedWork.lastEffect ? (finishedWork.lastEffect.nextEffect = finishedWork, updateExpirationTimeBeforeCommit = finishedWork.firstEffect) : updateExpirationTimeBeforeCommit = finishedWork : updateExpirationTimeBeforeCommit = finishedWork.firstEffect;
+
+ for (nextEffect = updateExpirationTimeBeforeCommit; null !== nextEffect;) {
+ childExpirationTimeBeforeCommit = !1;
+ var error = void 0;
+
+ try {
+ commitBeforeMutationLifecycles();
+ } catch (e) {
+ childExpirationTimeBeforeCommit = !0, error = e;
+ }
+
+ childExpirationTimeBeforeCommit && (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 = updateExpirationTimeBeforeCommit; null !== nextEffect;) {
+ childExpirationTimeBeforeCommit = !1;
+ error = void 0;
+
+ try {
+ commitAllHostEffects();
+ } catch (e) {
+ childExpirationTimeBeforeCommit = !0, error = e;
+ }
+
+ childExpirationTimeBeforeCommit && (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));
+ }
+
+ root.current = finishedWork;
+
+ for (nextEffect = updateExpirationTimeBeforeCommit; null !== nextEffect;) {
+ childExpirationTimeBeforeCommit = !1;
+ error = void 0;
+
+ try {
+ commitAllLifeCycles(root, committedExpirationTime);
+ } catch (e) {
+ childExpirationTimeBeforeCommit = !0, error = e;
+ }
+
+ childExpirationTimeBeforeCommit && (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));
+ }
+
+ if (null !== updateExpirationTimeBeforeCommit && null !== rootWithPendingPassiveEffects) {
+ var callback = commitPassiveEffects.bind(null, root, updateExpirationTimeBeforeCommit);
+ passiveEffectCallbackHandle = scheduler.unstable_runWithPriority(scheduler.unstable_NormalPriority, function () {
+ return scheduleDeferredCallback$1(callback);
+ });
+ passiveEffectCallback = callback;
+ }
+
+ isWorking = isCommitting$1 = !1;
+ "function" === typeof onCommitFiberRoot && onCommitFiberRoot(finishedWork.stateNode);
+ committedExpirationTime = finishedWork.expirationTime;
+ finishedWork = finishedWork.childExpirationTime;
+ finishedWork = finishedWork > committedExpirationTime ? finishedWork : committedExpirationTime;
+ 0 === finishedWork && (legacyErrorBoundariesThatAlreadyFailed = null);
+ onCommit(root, finishedWork);
+ }
+
+ function completeUnitOfWork(workInProgress) {
+ for (;;) {
+ var current$$1 = workInProgress.alternate,
+ returnFiber = workInProgress.return,
+ siblingFiber = workInProgress.sibling;
+
+ if (0 === (workInProgress.effectTag & 1024)) {
+ nextUnitOfWork = workInProgress;
+
+ a: {
+ var current = current$$1;
+ current$$1 = workInProgress;
+ var renderExpirationTime = nextRenderExpirationTime;
+ var instance = current$$1.pendingProps;
+
+ switch (current$$1.tag) {
+ case 2:
+ break;
+
+ case 16:
+ break;
+
+ case 15:
+ case 0:
+ break;
+
+ case 1:
+ isContextProvider(current$$1.type) && popContext(current$$1);
+ break;
+
+ case 3:
+ popHostContainer(current$$1);
+ popTopLevelContextObject(current$$1);
+ instance = current$$1.stateNode;
+ instance.pendingContext && (instance.context = instance.pendingContext, instance.pendingContext = null);
+ if (null === current || null === current.child) current$$1.effectTag &= -3;
+ updateHostContainer(current$$1);
+ break;
+
+ case 5:
+ popHostContext(current$$1);
+ renderExpirationTime = requiredContext(rootInstanceStackCursor.current);
+ var type = current$$1.type;
+ if (null !== current && null != current$$1.stateNode) updateHostComponent$1(current, current$$1, type, instance, renderExpirationTime), current.ref !== current$$1.ref && (current$$1.effectTag |= 128);else if (instance) {
+ var currentHostContext = requiredContext(contextStackCursor$1.current),
+ internalInstanceHandle = current$$1;
+ current = nextReactTag;
+ nextReactTag += 2;
+ var viewConfig = ReactNativeViewConfigRegistry.get(type);
+ invariant("RCTView" !== type || !currentHostContext.isInAParentText, "Nesting of within is not currently supported.");
+ type = diffProperties(null, emptyObject, instance, viewConfig.validAttributes);
+ renderExpirationTime = FabricUIManager.createNode(current, viewConfig.uiViewClassName, renderExpirationTime, type, internalInstanceHandle);
+ instance = new ReactFabricHostComponent(current, viewConfig, instance);
+ instance = {
+ node: renderExpirationTime,
+ canonical: instance
+ };
+
+ _appendAllChildren(instance, current$$1, !1, !1);
+
+ current$$1.stateNode = instance;
+ null !== current$$1.ref && (current$$1.effectTag |= 128);
+ } else invariant(null !== current$$1.stateNode, "We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue.");
+ break;
+
+ case 6:
+ current && null != current$$1.stateNode ? updateHostText$1(current, current$$1, current.memoizedProps, instance) : ("string" !== typeof instance && invariant(null !== current$$1.stateNode, "We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue."), current = requiredContext(rootInstanceStackCursor.current), renderExpirationTime = requiredContext(contextStackCursor$1.current), current$$1.stateNode = createTextInstance(instance, current, renderExpirationTime, current$$1));
+ break;
+
+ case 11:
+ break;
+
+ case 13:
+ instance = current$$1.memoizedState;
+
+ if (0 !== (current$$1.effectTag & 64)) {
+ current$$1.expirationTime = renderExpirationTime;
+ nextUnitOfWork = current$$1;
+ break a;
+ }
+
+ instance = null !== instance;
+ renderExpirationTime = null !== current && null !== current.memoizedState;
+ null !== current && !instance && renderExpirationTime && (current = current.child.sibling, null !== current && (viewConfig = current$$1.firstEffect, null !== viewConfig ? (current$$1.firstEffect = current, current.nextEffect = viewConfig) : (current$$1.firstEffect = current$$1.lastEffect = current, current.nextEffect = null), current.effectTag = 8));
+ if (instance || renderExpirationTime) current$$1.effectTag |= 4;
+ break;
+
+ case 7:
+ break;
+
+ case 8:
+ break;
+
+ case 12:
+ break;
+
+ case 4:
+ popHostContainer(current$$1);
+ updateHostContainer(current$$1);
+ break;
+
+ case 10:
+ popProvider(current$$1);
+ break;
+
+ case 9:
+ break;
+
+ case 14:
+ break;
+
+ case 17:
+ isContextProvider(current$$1.type) && popContext(current$$1);
+ break;
+
+ case 18:
+ break;
+
+ default:
+ invariant(!1, "Unknown unit of work tag. This error is likely caused by a bug in React. Please file an issue.");
+ }
+
+ nextUnitOfWork = null;
+ }
+
+ current$$1 = workInProgress;
+
+ if (1 === nextRenderExpirationTime || 1 !== current$$1.childExpirationTime) {
+ instance = 0;
+
+ for (current = current$$1.child; null !== current;) {
+ renderExpirationTime = current.expirationTime, viewConfig = current.childExpirationTime, renderExpirationTime > instance && (instance = renderExpirationTime), viewConfig > instance && (instance = viewConfig), current = current.sibling;
+ }
+
+ current$$1.childExpirationTime = instance;
+ }
+
+ if (null !== nextUnitOfWork) return nextUnitOfWork;
+ null !== returnFiber && 0 === (returnFiber.effectTag & 1024) && (null === returnFiber.firstEffect && (returnFiber.firstEffect = workInProgress.firstEffect), null !== workInProgress.lastEffect && (null !== returnFiber.lastEffect && (returnFiber.lastEffect.nextEffect = workInProgress.firstEffect), returnFiber.lastEffect = workInProgress.lastEffect), 1 < workInProgress.effectTag && (null !== returnFiber.lastEffect ? returnFiber.lastEffect.nextEffect = workInProgress : returnFiber.firstEffect = workInProgress, returnFiber.lastEffect = workInProgress));
+ } else {
+ workInProgress = unwindWork(workInProgress, nextRenderExpirationTime);
+ if (null !== workInProgress) return workInProgress.effectTag &= 1023, workInProgress;
+ null !== returnFiber && (returnFiber.firstEffect = returnFiber.lastEffect = null, returnFiber.effectTag |= 1024);
+ }
+
+ if (null !== siblingFiber) return siblingFiber;
+ if (null !== returnFiber) workInProgress = returnFiber;else break;
+ }
+
+ return null;
+ }
+
+ function performUnitOfWork(workInProgress) {
+ var next = beginWork(workInProgress.alternate, workInProgress, nextRenderExpirationTime);
+ workInProgress.memoizedProps = workInProgress.pendingProps;
+ null === next && (next = completeUnitOfWork(workInProgress));
+ ReactCurrentOwner$2.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.");
+ flushPassiveEffects();
+ isWorking = !0;
+ var previousDispatcher = ReactCurrentDispatcher.current;
+ ReactCurrentDispatcher.current = ContextOnlyDispatcher;
+ var expirationTime = root$jscomp$0.nextExpirationTimeToWorkOn;
+ if (expirationTime !== nextRenderExpirationTime || root$jscomp$0 !== nextRoot || null === nextUnitOfWork) resetStack(), nextRoot = root$jscomp$0, nextRenderExpirationTime = expirationTime, nextUnitOfWork = createWorkInProgress(nextRoot.current, null, nextRenderExpirationTime), root$jscomp$0.pendingCommitExpirationTime = 0;
+ var didFatal = !1;
+
+ do {
+ try {
+ if (isYieldy) for (; null !== nextUnitOfWork && !(frameDeadline <= now$1());) {
+ nextUnitOfWork = performUnitOfWork(nextUnitOfWork);
+ } else for (; null !== nextUnitOfWork;) {
+ nextUnitOfWork = performUnitOfWork(nextUnitOfWork);
+ }
+ } catch (thrownValue) {
+ if (lastContextWithAllBitsObserved = lastContextDependency = currentlyRenderingFiber = null, resetHooks(), 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.");
+ var sourceFiber = nextUnitOfWork,
+ returnFiber = sourceFiber.return;
+ if (null === returnFiber) didFatal = !0, onUncaughtError(thrownValue);else {
+ a: {
+ var root = root$jscomp$0,
+ returnFiber$jscomp$0 = returnFiber,
+ sourceFiber$jscomp$0 = sourceFiber,
+ value = thrownValue;
+ returnFiber = nextRenderExpirationTime;
+ sourceFiber$jscomp$0.effectTag |= 1024;
+ sourceFiber$jscomp$0.firstEffect = sourceFiber$jscomp$0.lastEffect = null;
+
+ if (null !== value && "object" === typeof value && "function" === typeof value.then) {
+ var thenable = value;
+ value = returnFiber$jscomp$0;
+ var earliestTimeoutMs = -1,
+ startTimeMs = -1;
+
+ do {
+ if (13 === value.tag) {
+ var current$$1 = value.alternate;
+
+ if (null !== current$$1 && (current$$1 = current$$1.memoizedState, null !== current$$1)) {
+ startTimeMs = 10 * (1073741822 - current$$1.timedOutAt);
+ break;
+ }
+
+ current$$1 = value.pendingProps.maxDuration;
+ if ("number" === typeof current$$1) if (0 >= current$$1) earliestTimeoutMs = 0;else if (-1 === earliestTimeoutMs || current$$1 < earliestTimeoutMs) earliestTimeoutMs = current$$1;
+ }
+
+ value = value.return;
+ } while (null !== value);
+
+ value = returnFiber$jscomp$0;
+
+ do {
+ if (current$$1 = 13 === value.tag) current$$1 = void 0 === value.memoizedProps.fallback ? !1 : null === value.memoizedState;
+
+ if (current$$1) {
+ returnFiber$jscomp$0 = value.updateQueue;
+ null === returnFiber$jscomp$0 ? (returnFiber$jscomp$0 = new Set(), returnFiber$jscomp$0.add(thenable), value.updateQueue = returnFiber$jscomp$0) : returnFiber$jscomp$0.add(thenable);
+
+ if (0 === (value.mode & 1)) {
+ value.effectTag |= 64;
+ sourceFiber$jscomp$0.effectTag &= -1957;
+ 1 === sourceFiber$jscomp$0.tag && (null === sourceFiber$jscomp$0.alternate ? sourceFiber$jscomp$0.tag = 17 : (returnFiber = createUpdate(1073741823), returnFiber.tag = ForceUpdate, enqueueUpdate(sourceFiber$jscomp$0, returnFiber)));
+ sourceFiber$jscomp$0.expirationTime = 1073741823;
+ break a;
+ }
+
+ sourceFiber$jscomp$0 = root;
+ returnFiber$jscomp$0 = returnFiber;
+ var pingCache = sourceFiber$jscomp$0.pingCache;
+ null === pingCache ? (pingCache = sourceFiber$jscomp$0.pingCache = new PossiblyWeakMap(), current$$1 = new Set(), pingCache.set(thenable, current$$1)) : (current$$1 = pingCache.get(thenable), void 0 === current$$1 && (current$$1 = new Set(), pingCache.set(thenable, current$$1)));
+ current$$1.has(returnFiber$jscomp$0) || (current$$1.add(returnFiber$jscomp$0), sourceFiber$jscomp$0 = pingSuspendedRoot.bind(null, sourceFiber$jscomp$0, thenable, returnFiber$jscomp$0), thenable.then(sourceFiber$jscomp$0, sourceFiber$jscomp$0));
+ -1 === earliestTimeoutMs ? root = 1073741823 : (-1 === startTimeMs && (startTimeMs = 10 * (1073741822 - findEarliestOutstandingPriorityLevel(root, returnFiber)) - 5e3), root = startTimeMs + earliestTimeoutMs);
+ 0 <= root && nextLatestAbsoluteTimeoutMs < root && (nextLatestAbsoluteTimeoutMs = root);
+ value.effectTag |= 2048;
+ value.expirationTime = returnFiber;
+ break a;
+ }
+
+ value = value.return;
+ } while (null !== value);
+
+ value = Error((getComponentName(sourceFiber$jscomp$0.type) || "A React component") + " suspended while rendering, but no fallback UI was specified.\n\nAdd a component higher in the tree to provide a loading indicator or placeholder to display." + getStackByFiberInDevAndProd(sourceFiber$jscomp$0));
+ }
+
+ nextRenderDidError = !0;
+ value = createCapturedValue(value, sourceFiber$jscomp$0);
+ root = returnFiber$jscomp$0;
+
+ do {
+ switch (root.tag) {
+ case 3:
+ root.effectTag |= 2048;
+ root.expirationTime = returnFiber;
+ returnFiber = createRootErrorUpdate(root, value, returnFiber);
+ enqueueCapturedUpdate(root, returnFiber);
+ break a;
+
+ case 1:
+ if (earliestTimeoutMs = value, startTimeMs = root.type, sourceFiber$jscomp$0 = root.stateNode, 0 === (root.effectTag & 64) && ("function" === typeof startTimeMs.getDerivedStateFromError || null !== sourceFiber$jscomp$0 && "function" === typeof sourceFiber$jscomp$0.componentDidCatch && (null === legacyErrorBoundariesThatAlreadyFailed || !legacyErrorBoundariesThatAlreadyFailed.has(sourceFiber$jscomp$0)))) {
+ root.effectTag |= 2048;
+ root.expirationTime = returnFiber;
+ returnFiber = createClassErrorUpdate(root, earliestTimeoutMs, returnFiber);
+ enqueueCapturedUpdate(root, returnFiber);
+ break a;
+ }
+
+ }
+
+ root = root.return;
+ } while (null !== root);
+ }
+
+ nextUnitOfWork = completeUnitOfWork(sourceFiber);
+ continue;
+ }
+ }
+ }
+
+ break;
+ } while (1);
+
+ isWorking = !1;
+ ReactCurrentDispatcher.current = previousDispatcher;
+ lastContextWithAllBitsObserved = lastContextDependency = currentlyRenderingFiber = null;
+ resetHooks();
+ if (didFatal) nextRoot = null, root$jscomp$0.finishedWork = null;else if (null !== nextUnitOfWork) root$jscomp$0.finishedWork = null;else {
+ previousDispatcher = root$jscomp$0.current.alternate;
+ invariant(null !== previousDispatcher, "Finished root should have a work-in-progress. This error is likely caused by a bug in React. Please file an issue.");
+ nextRoot = null;
+
+ if (nextRenderDidError) {
+ didFatal = root$jscomp$0.latestPendingTime;
+ sourceFiber = root$jscomp$0.latestSuspendedTime;
+ returnFiber = root$jscomp$0.latestPingedTime;
+
+ if (0 !== didFatal && didFatal < expirationTime || 0 !== sourceFiber && sourceFiber < expirationTime || 0 !== returnFiber && returnFiber < expirationTime) {
+ markSuspendedPriorityLevel(root$jscomp$0, expirationTime);
+ onSuspend(root$jscomp$0, previousDispatcher, expirationTime, root$jscomp$0.expirationTime, -1);
+ return;
+ }
+
+ if (!root$jscomp$0.didError && isYieldy) {
+ root$jscomp$0.didError = !0;
+ expirationTime = root$jscomp$0.nextExpirationTimeToWorkOn = expirationTime;
+ isYieldy = root$jscomp$0.expirationTime = 1073741823;
+ onSuspend(root$jscomp$0, previousDispatcher, expirationTime, isYieldy, -1);
+ return;
+ }
+ }
+
+ isYieldy && -1 !== nextLatestAbsoluteTimeoutMs ? (markSuspendedPriorityLevel(root$jscomp$0, expirationTime), isYieldy = 10 * (1073741822 - findEarliestOutstandingPriorityLevel(root$jscomp$0, expirationTime)), isYieldy < nextLatestAbsoluteTimeoutMs && (nextLatestAbsoluteTimeoutMs = isYieldy), isYieldy = 10 * (1073741822 - requestCurrentTime()), isYieldy = nextLatestAbsoluteTimeoutMs - isYieldy, onSuspend(root$jscomp$0, previousDispatcher, expirationTime, root$jscomp$0.expirationTime, 0 > isYieldy ? 0 : isYieldy)) : (root$jscomp$0.pendingCommitExpirationTime = expirationTime, root$jscomp$0.finishedWork = previousDispatcher);
+ }
+ }
+
+ function captureCommitPhaseError(sourceFiber, value) {
+ for (var fiber = sourceFiber.return; null !== fiber;) {
+ switch (fiber.tag) {
+ case 1:
+ var instance = fiber.stateNode;
+
+ if ("function" === typeof fiber.type.getDerivedStateFromError || "function" === typeof instance.componentDidCatch && (null === legacyErrorBoundariesThatAlreadyFailed || !legacyErrorBoundariesThatAlreadyFailed.has(instance))) {
+ sourceFiber = createCapturedValue(value, sourceFiber);
+ sourceFiber = createClassErrorUpdate(fiber, sourceFiber, 1073741823);
+ enqueueUpdate(fiber, sourceFiber);
+ scheduleWork(fiber, 1073741823);
+ return;
+ }
+
+ break;
+
+ case 3:
+ sourceFiber = createCapturedValue(value, sourceFiber);
+ sourceFiber = createRootErrorUpdate(fiber, sourceFiber, 1073741823);
+ enqueueUpdate(fiber, sourceFiber);
+ scheduleWork(fiber, 1073741823);
+ return;
+ }
+
+ fiber = fiber.return;
+ }
+
+ 3 === sourceFiber.tag && (fiber = createCapturedValue(value, sourceFiber), fiber = createRootErrorUpdate(sourceFiber, fiber, 1073741823), enqueueUpdate(sourceFiber, fiber), scheduleWork(sourceFiber, 1073741823));
+ }
+
+ function computeExpirationForFiber(currentTime, fiber) {
+ var priorityLevel = scheduler.unstable_getCurrentPriorityLevel(),
+ expirationTime = void 0;
+ if (0 === (fiber.mode & 1)) expirationTime = 1073741823;else if (isWorking && !isCommitting$1) expirationTime = nextRenderExpirationTime;else {
+ switch (priorityLevel) {
+ case scheduler.unstable_ImmediatePriority:
+ expirationTime = 1073741823;
+ break;
+
+ case scheduler.unstable_UserBlockingPriority:
+ expirationTime = 1073741822 - 10 * (((1073741822 - currentTime + 15) / 10 | 0) + 1);
+ break;
+
+ case scheduler.unstable_NormalPriority:
+ expirationTime = 1073741822 - 25 * (((1073741822 - currentTime + 500) / 25 | 0) + 1);
+ break;
+
+ case scheduler.unstable_LowPriority:
+ case scheduler.unstable_IdlePriority:
+ expirationTime = 1;
+ break;
+
+ default:
+ invariant(!1, "Unknown priority level. This error is likely caused by a bug in React. Please file an issue.");
+ }
+
+ null !== nextRoot && expirationTime === nextRenderExpirationTime && --expirationTime;
+ }
+ priorityLevel === scheduler.unstable_UserBlockingPriority && (0 === lowestPriorityPendingInteractiveExpirationTime || expirationTime < lowestPriorityPendingInteractiveExpirationTime) && (lowestPriorityPendingInteractiveExpirationTime = expirationTime);
+ return expirationTime;
+ }
+
+ function pingSuspendedRoot(root, thenable, pingTime) {
+ var pingCache = root.pingCache;
+ null !== pingCache && pingCache.delete(thenable);
+ if (null !== nextRoot && nextRenderExpirationTime === pingTime) nextRoot = null;else if (thenable = root.earliestSuspendedTime, pingCache = root.latestSuspendedTime, 0 !== thenable && pingTime <= thenable && pingTime >= pingCache) {
+ root.didError = !1;
+ thenable = root.latestPingedTime;
+ if (0 === thenable || thenable > pingTime) root.latestPingedTime = pingTime;
+ findNextExpirationTimeToWorkOn(pingTime, root);
+ pingTime = root.expirationTime;
+ 0 !== pingTime && requestWork(root, pingTime);
+ }
+ }
+
+ function scheduleWork(fiber, expirationTime) {
+ fiber.expirationTime < expirationTime && (fiber.expirationTime = expirationTime);
+ var alternate = fiber.alternate;
+ null !== alternate && alternate.expirationTime < expirationTime && (alternate.expirationTime = expirationTime);
+ var node = fiber.return,
+ root = null;
+ if (null === node && 3 === fiber.tag) root = fiber.stateNode;else for (; null !== node;) {
+ alternate = node.alternate;
+ node.childExpirationTime < expirationTime && (node.childExpirationTime = expirationTime);
+ null !== alternate && alternate.childExpirationTime < expirationTime && (alternate.childExpirationTime = expirationTime);
+
+ if (null === node.return && 3 === node.tag) {
+ root = node.stateNode;
+ break;
+ }
+
+ node = node.return;
+ }
+ fiber = root;
+ null !== fiber && (!isWorking && 0 !== nextRenderExpirationTime && expirationTime > nextRenderExpirationTime && resetStack(), markPendingPriorityLevel(fiber, expirationTime), isWorking && !isCommitting$1 && nextRoot === fiber || requestWork(fiber, fiber.expirationTime), nestedUpdateCount > NESTED_UPDATE_LIMIT && (nestedUpdateCount = 0, 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.")));
+ }
+
+ var firstScheduledRoot = null,
+ lastScheduledRoot = null,
+ callbackExpirationTime = 0,
+ callbackID = void 0,
+ isRendering = !1,
+ nextFlushedRoot = null,
+ nextFlushedExpirationTime = 0,
+ lowestPriorityPendingInteractiveExpirationTime = 0,
+ hasUnhandledError = !1,
+ unhandledError = null,
+ isBatchingUpdates = !1,
+ isUnbatchingUpdates = !1,
+ completedBatches = null,
+ originalStartTimeMs = now$1(),
+ currentRendererTime = 1073741822 - (originalStartTimeMs / 10 | 0),
+ currentSchedulerTime = currentRendererTime,
+ NESTED_UPDATE_LIMIT = 50,
+ nestedUpdateCount = 0,
+ lastCommittedRootDuringThisBatch = null;
+
+ function recomputeCurrentRendererTime() {
+ currentRendererTime = 1073741822 - ((now$1() - originalStartTimeMs) / 10 | 0);
+ }
+
+ function scheduleCallbackWithExpirationTime(root, expirationTime) {
+ if (0 !== callbackExpirationTime) {
+ if (expirationTime < callbackExpirationTime) return;
+ null !== callbackID && (root = callbackID, scheduledCallback = null, clearTimeout(root));
+ }
+
+ callbackExpirationTime = expirationTime;
+ root = now$1() - originalStartTimeMs;
+ callbackID = scheduleDeferredCallback$1(performAsyncWork, {
+ timeout: 10 * (1073741822 - expirationTime) - root
+ });
+ }
+
+ function onSuspend(root, finishedWork, suspendedExpirationTime, rootExpirationTime, msUntilTimeout) {
+ root.expirationTime = rootExpirationTime;
+ 0 !== msUntilTimeout || frameDeadline <= now$1() ? 0 < msUntilTimeout && (root.timeoutHandle = scheduleTimeout(onTimeout.bind(null, root, finishedWork, suspendedExpirationTime), msUntilTimeout)) : (root.pendingCommitExpirationTime = suspendedExpirationTime, root.finishedWork = finishedWork);
+ }
+
+ function onTimeout(root, finishedWork, suspendedExpirationTime) {
+ root.pendingCommitExpirationTime = suspendedExpirationTime;
+ root.finishedWork = finishedWork;
+ recomputeCurrentRendererTime();
+ currentSchedulerTime = currentRendererTime;
+ invariant(!isRendering, "work.commit(): Cannot commit while already rendering. This likely means you attempted to commit from inside a lifecycle method.");
+ nextFlushedRoot = root;
+ nextFlushedExpirationTime = suspendedExpirationTime;
+ performWorkOnRoot(root, suspendedExpirationTime, !1);
+ performWork(1073741823, !1);
+ }
+
+ function onCommit(root, expirationTime) {
+ root.expirationTime = expirationTime;
+ root.finishedWork = null;
+ }
+
+ function requestCurrentTime() {
+ if (isRendering) return currentSchedulerTime;
+ findHighestPriorityRoot();
+ if (0 === nextFlushedExpirationTime || 1 === nextFlushedExpirationTime) recomputeCurrentRendererTime(), currentSchedulerTime = currentRendererTime;
+ return currentSchedulerTime;
+ }
+
+ function requestWork(root, expirationTime) {
+ null === root.nextScheduledRoot ? (root.expirationTime = expirationTime, null === lastScheduledRoot ? (firstScheduledRoot = lastScheduledRoot = root, root.nextScheduledRoot = root) : (lastScheduledRoot = lastScheduledRoot.nextScheduledRoot = root, lastScheduledRoot.nextScheduledRoot = firstScheduledRoot)) : expirationTime > root.expirationTime && (root.expirationTime = expirationTime);
+ isRendering || (isBatchingUpdates ? isUnbatchingUpdates && (nextFlushedRoot = root, nextFlushedExpirationTime = 1073741823, performWorkOnRoot(root, 1073741823, !1)) : 1073741823 === expirationTime ? performWork(1073741823, !1) : scheduleCallbackWithExpirationTime(root, 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 {
+ remainingExpirationTime > highestPriorityWork && (highestPriorityWork = remainingExpirationTime, highestPriorityRoot = root);
+ if (root === lastScheduledRoot) break;
+ if (1073741823 === highestPriorityWork) break;
+ previousScheduledRoot = root;
+ root = root.nextScheduledRoot;
+ }
+ }
+ nextFlushedRoot = highestPriorityRoot;
+ nextFlushedExpirationTime = highestPriorityWork;
+ }
+
+ function performAsyncWork(didTimeout) {
+ if (didTimeout && null !== firstScheduledRoot) {
+ recomputeCurrentRendererTime();
+ didTimeout = firstScheduledRoot;
+
+ do {
+ var expirationTime = didTimeout.expirationTime;
+ 0 !== expirationTime && currentRendererTime <= expirationTime && (didTimeout.nextExpirationTimeToWorkOn = currentRendererTime);
+ didTimeout = didTimeout.nextScheduledRoot;
+ } while (didTimeout !== firstScheduledRoot);
+ }
+
+ performWork(0, !0);
+ }
+
+ function performWork(minExpirationTime, isYieldy) {
+ findHighestPriorityRoot();
+ if (isYieldy) for (recomputeCurrentRendererTime(), currentSchedulerTime = currentRendererTime; null !== nextFlushedRoot && 0 !== nextFlushedExpirationTime && minExpirationTime <= nextFlushedExpirationTime && !(frameDeadline <= now$1() && currentRendererTime > nextFlushedExpirationTime);) {
+ performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, currentRendererTime > nextFlushedExpirationTime), findHighestPriorityRoot(), recomputeCurrentRendererTime(), currentSchedulerTime = currentRendererTime;
+ } else for (; null !== nextFlushedRoot && 0 !== nextFlushedExpirationTime && minExpirationTime <= nextFlushedExpirationTime;) {
+ performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, !1), findHighestPriorityRoot();
+ }
+ isYieldy && (callbackExpirationTime = 0, callbackID = null);
+ 0 !== nextFlushedExpirationTime && scheduleCallbackWithExpirationTime(nextFlushedRoot, nextFlushedExpirationTime);
+ nestedUpdateCount = 0;
+ lastCommittedRootDuringThisBatch = null;
+ if (null !== completedBatches) for (minExpirationTime = completedBatches, completedBatches = null, isYieldy = 0; isYieldy < minExpirationTime.length; isYieldy++) {
+ var batch = minExpirationTime[isYieldy];
+
+ try {
+ batch._onComplete();
+ } catch (error) {
+ hasUnhandledError || (hasUnhandledError = !0, unhandledError = error);
+ }
+ }
+ if (hasUnhandledError) throw minExpirationTime = unhandledError, unhandledError = null, hasUnhandledError = !1, minExpirationTime;
+ }
+
+ 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;
+
+ if (isYieldy) {
+ var _finishedWork = root.finishedWork;
+ null !== _finishedWork ? completeRoot$1(root, _finishedWork, expirationTime) : (root.finishedWork = null, _finishedWork = root.timeoutHandle, -1 !== _finishedWork && (root.timeoutHandle = -1, cancelTimeout(_finishedWork)), renderRoot(root, isYieldy), _finishedWork = root.finishedWork, null !== _finishedWork && (frameDeadline <= now$1() ? root.finishedWork = _finishedWork : completeRoot$1(root, _finishedWork, expirationTime)));
+ } else _finishedWork = root.finishedWork, null !== _finishedWork ? completeRoot$1(root, _finishedWork, expirationTime) : (root.finishedWork = null, _finishedWork = root.timeoutHandle, -1 !== _finishedWork && (root.timeoutHandle = -1, cancelTimeout(_finishedWork)), renderRoot(root, isYieldy), _finishedWork = root.finishedWork, null !== _finishedWork && completeRoot$1(root, _finishedWork, expirationTime));
+
+ isRendering = !1;
+ }
+
+ function completeRoot$1(root, finishedWork, expirationTime) {
+ var firstBatch = root.firstBatch;
+
+ if (null !== firstBatch && firstBatch._expirationTime >= expirationTime && (null === completedBatches ? completedBatches = [firstBatch] : completedBatches.push(firstBatch), firstBatch._defer)) {
+ root.finishedWork = finishedWork;
+ root.expirationTime = 0;
+ return;
+ }
+
+ root.finishedWork = null;
+ root === lastCommittedRootDuringThisBatch ? nestedUpdateCount++ : (lastCommittedRootDuringThisBatch = root, nestedUpdateCount = 0);
+ scheduler.unstable_runWithPriority(scheduler.unstable_ImmediatePriority, function () {
+ commitRoot(root, finishedWork);
+ });
+ }
+
+ 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 findHostInstance(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$$1 = container.current,
+ currentTime = requestCurrentTime();
+ current$$1 = computeExpirationForFiber(currentTime, current$$1);
+ currentTime = container.current;
+
+ a: if (parentComponent) {
+ parentComponent = parentComponent._reactInternalFiber;
+
+ b: {
+ invariant(2 === isFiberMountedImpl(parentComponent) && 1 === 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.");
+ var parentContext = parentComponent;
+
+ do {
+ switch (parentContext.tag) {
+ case 3:
+ parentContext = parentContext.stateNode.context;
+ break b;
+
+ case 1:
+ if (isContextProvider(parentContext.type)) {
+ parentContext = parentContext.stateNode.__reactInternalMemoizedMergedChildContext;
+ break b;
+ }
+
+ }
+
+ parentContext = parentContext.return;
+ } while (null !== parentContext);
+
+ invariant(!1, "Found unexpected detached subtree parent. This error is likely caused by a bug in React. Please file an issue.");
+ parentContext = void 0;
+ }
+
+ if (1 === parentComponent.tag) {
+ var Component = parentComponent.type;
+
+ if (isContextProvider(Component)) {
+ parentComponent = processChildContext(parentComponent, Component, parentContext);
+ break a;
+ }
+ }
+
+ parentComponent = parentContext;
+ } else parentComponent = emptyContextObject;
+
+ null === container.context ? container.context = parentComponent : container.pendingContext = parentComponent;
+ container = callback;
+ callback = createUpdate(current$$1);
+ callback.payload = {
+ element: element
+ };
+ container = void 0 === container ? null : container;
+ null !== container && (callback.callback = container);
+ flushPassiveEffects();
+ enqueueUpdate(currentTime, callback);
+ scheduleWork(currentTime, current$$1);
+ return current$$1;
+ }
+
+ function _createPortal(children, containerInfo, implementation) {
+ var key = 3 < arguments.length && void 0 !== arguments[3] ? arguments[3] : null;
+ return {
+ $$typeof: REACT_PORTAL_TYPE,
+ key: null == key ? null : "" + key,
+ children: children,
+ containerInfo: containerInfo,
+ implementation: implementation
+ };
+ }
+
+ function _inherits(subClass, superClass) {
+ if ("function" !== typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+ subClass.prototype = Object.create(superClass && superClass.prototype, {
+ constructor: {
+ value: subClass,
+ enumerable: !1,
+ writable: !0,
+ configurable: !0
+ }
+ });
+ superClass && (Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass);
+ }
+
+ var getInspectorDataForViewTag = void 0;
+
+ getInspectorDataForViewTag = function getInspectorDataForViewTag() {
+ 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(componentOrHandle);
+ return null == componentOrHandle ? componentOrHandle : componentOrHandle.canonical ? componentOrHandle.canonical._nativeTag : componentOrHandle._nativeTag;
+ }
+
+ _batchedUpdatesImpl = function _batchedUpdatesImpl(fn, a) {
+ var previousIsBatchingUpdates = isBatchingUpdates;
+ isBatchingUpdates = !0;
+
+ try {
+ return fn(a);
+ } finally {
+ (isBatchingUpdates = previousIsBatchingUpdates) || isRendering || performWork(1073741823, !1);
+ }
+ };
+
+ _flushInteractiveUpdatesImpl = function _flushInteractiveUpdatesImpl() {
+ isRendering || 0 === lowestPriorityPendingInteractiveExpirationTime || (performWork(lowestPriorityPendingInteractiveExpirationTime, !1), lowestPriorityPendingInteractiveExpirationTime = 0);
+ };
+
+ 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_NOT_REALLY_SAFE(this, callback));
+ };
+
+ ReactNativeComponent.prototype.measureInWindow = function (callback) {
+ UIManager.measureInWindow(findNodeHandle(this), mountSafeCallback_NOT_REALLY_SAFE(this, callback));
+ };
+
+ ReactNativeComponent.prototype.measureLayout = function (relativeToNativeNode, onSuccess, onFail) {
+ UIManager.measureLayout(findNodeHandle(this), relativeToNativeNode, mountSafeCallback_NOT_REALLY_SAFE(this, onFail), mountSafeCallback_NOT_REALLY_SAFE(this, onSuccess));
+ };
+
+ ReactNativeComponent.prototype.setNativeProps = function (nativeProps) {
+ var maybeInstance = void 0;
+
+ try {
+ maybeInstance = findHostInstance(this);
+ } catch (error) {}
+
+ if (null != maybeInstance) {
+ var nativeTag = maybeInstance._nativeTag || maybeInstance.canonical._nativeTag;
+ maybeInstance = maybeInstance.viewConfig || maybeInstance.canonical.viewConfig;
+ nativeProps = diffProperties(null, emptyObject, nativeProps, maybeInstance.validAttributes);
+ null != nativeProps && UIManager.updateView(nativeTag, maybeInstance.uiViewClassName, nativeProps);
+ }
+ };
+
+ return ReactNativeComponent;
+ }(React.Component);
+ }(findNodeHandle, findHostInstance),
+ findNodeHandle: findNodeHandle,
+ setNativeProps: function setNativeProps(handle, nativeProps) {
+ null != handle._nativeTag && (nativeProps = diffProperties(null, emptyObject, nativeProps, handle.viewConfig.validAttributes), null != nativeProps && UIManager.updateView(handle._nativeTag, handle.viewConfig.uiViewClassName, nativeProps));
+ },
+ render: function render(element, containerTag, callback) {
+ var root = roots.get(containerTag);
+
+ if (!root) {
+ root = createFiber(3, null, null, 0);
+ var root$jscomp$0 = {
+ current: root,
+ containerInfo: containerTag,
+ pendingChildren: null,
+ pingCache: null,
+ earliestPendingTime: 0,
+ latestPendingTime: 0,
+ earliestSuspendedTime: 0,
+ latestSuspendedTime: 0,
+ latestPingedTime: 0,
+ didError: !1,
+ pendingCommitExpirationTime: 0,
+ finishedWork: null,
+ timeoutHandle: -1,
+ context: null,
+ pendingContext: null,
+ hydrate: !1,
+ nextExpirationTimeToWorkOn: 0,
+ expirationTime: 0,
+ firstBatch: null,
+ nextScheduledRoot: null
+ };
+ root = root.stateNode = root$jscomp$0;
+ roots.set(containerTag, root);
+ }
+
+ updateContainer(element, root, null, callback);
+
+ a: if (element = root.current, element.child) switch (element.child.tag) {
+ case 5:
+ element = element.child.stateNode.canonical;
+ break a;
+
+ default:
+ element = element.child.stateNode;
+ } else element = null;
+
+ return element;
+ },
+ unmountComponentAtNode: function unmountComponentAtNode(containerTag) {
+ var root = roots.get(containerTag);
+ root && updateContainer(null, root, null, function () {
+ roots.delete(containerTag);
+ });
+ },
+ createPortal: function createPortal(children, containerTag) {
+ return _createPortal(children, containerTag, null, 2 < arguments.length && void 0 !== arguments[2] ? arguments[2] : null);
+ },
+ __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: {
+ NativeMethodsMixin: function (findNodeHandle, findHostInstance) {
+ return {
+ measure: function measure(callback) {
+ UIManager.measure(findNodeHandle(this), mountSafeCallback_NOT_REALLY_SAFE(this, callback));
+ },
+ measureInWindow: function measureInWindow(callback) {
+ UIManager.measureInWindow(findNodeHandle(this), mountSafeCallback_NOT_REALLY_SAFE(this, callback));
+ },
+ measureLayout: function measureLayout(relativeToNativeNode, onSuccess, onFail) {
+ UIManager.measureLayout(findNodeHandle(this), relativeToNativeNode, mountSafeCallback_NOT_REALLY_SAFE(this, onFail), mountSafeCallback_NOT_REALLY_SAFE(this, onSuccess));
+ },
+ setNativeProps: function setNativeProps(nativeProps) {
+ var maybeInstance = void 0;
+
+ try {
+ maybeInstance = findHostInstance(this);
+ } catch (error) {}
+
+ if (null != maybeInstance) {
+ var nativeTag = maybeInstance._nativeTag || maybeInstance.canonical._nativeTag;
+ maybeInstance = maybeInstance.viewConfig || maybeInstance.canonical.viewConfig;
+ nativeProps = diffProperties(null, emptyObject, nativeProps, maybeInstance.validAttributes);
+ null != nativeProps && UIManager.updateView(nativeTag, maybeInstance.uiViewClassName, nativeProps);
+ }
+ },
+ focus: function focus() {
+ TextInputState.focusTextInput(findNodeHandle(this));
+ },
+ blur: function blur() {
+ TextInputState.blurTextInput(findNodeHandle(this));
+ }
+ };
+ }(findNodeHandle, findHostInstance)
+ }
+ };
+
+ (function (devToolsConfig) {
+ var _findFiberByHostInstance = devToolsConfig.findFiberByHostInstance;
+ return injectInternals(_extends({}, devToolsConfig, {
+ overrideProps: null,
+ currentDispatcherRef: ReactSharedInternals.ReactCurrentDispatcher,
+ findHostInstanceByFiber: function findHostInstanceByFiber(fiber) {
+ fiber = findCurrentHostFiber(fiber);
+ return null === fiber ? null : fiber.stateNode;
+ },
+ findFiberByHostInstance: function findFiberByHostInstance(instance) {
+ return _findFiberByHostInstance ? _findFiberByHostInstance(instance) : null;
+ }
+ }));
+ })({
+ findFiberByHostInstance: getInstanceFromInstance,
+ getInspectorDataForViewTag: getInspectorDataForViewTag,
+ bundleType: 0,
+ version: "16.8.3",
+ rendererPackageName: "react-native-renderer"
+ });
+
+ var ReactFabric$2 = {
+ default: ReactFabric
+ },
+ ReactFabric$3 = ReactFabric$2 && ReactFabric || ReactFabric$2;
+ module.exports = ReactFabric$3.default || ReactFabric$3;
+},383,[14,86,173,71,11,175,80,176,382,180,98],"node_modules\\react-native\\Libraries\\Renderer\\oss\\ReactFabric-prod.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _slicedToArray = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/slicedToArray");
+
+ var NativeModules = _$$_REQUIRE(_dependencyMap[1], "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;
+},384,[37,36],"node_modules\\react-native\\Libraries\\Storage\\AsyncStorage.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var PropTypes = _$$_REQUIRE(_dependencyMap[2], "prop-types");
+
+ var checkPropTypes = PropTypes.checkPropTypes;
+
+ var RCTCameraRollManager = _$$_REQUIRE(_dependencyMap[3], "NativeModules").CameraRollManager;
+
+ var deprecatedCreateStrictShapeTypeChecker = _$$_REQUIRE(_dependencyMap[4], "deprecatedCreateStrictShapeTypeChecker");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[5], "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 = deprecatedCreateStrictShapeTypeChecker({
+ 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 = deprecatedCreateStrictShapeTypeChecker({
+ edges: PropTypes.arrayOf(deprecatedCreateStrictShapeTypeChecker({
+ node: deprecatedCreateStrictShapeTypeChecker({
+ type: PropTypes.string.isRequired,
+ group_name: PropTypes.string.isRequired,
+ image: deprecatedCreateStrictShapeTypeChecker({
+ 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: deprecatedCreateStrictShapeTypeChecker({
+ latitude: PropTypes.number,
+ longitude: PropTypes.number,
+ altitude: PropTypes.number,
+ heading: PropTypes.number,
+ speed: PropTypes.number
+ })
+ }).isRequired
+ })).isRequired,
+ page_info: deprecatedCreateStrictShapeTypeChecker({
+ 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;
+},385,[3,4,62,36,212,19],"node_modules\\react-native\\Libraries\\CameraRoll\\CameraRoll.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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);
+ }
+ };
+},386,[36],"node_modules\\react-native\\Libraries\\Components\\Clipboard\\Clipboard.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "UnimplementedView");
+},387,[196],"Libraries\\Components\\DatePickerAndroid\\DatePickerAndroid.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "UnimplementedView");
+},388,[196],"Libraries\\Components\\DatePickerMacOS\\DatePickerMacOS.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var RCTImagePicker = _$$_REQUIRE(_dependencyMap[1], "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;
+},389,[32,36],"node_modules\\react-native\\Libraries\\CameraRoll\\ImagePickerIOS.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var NativeEventEmitter = _$$_REQUIRE(_dependencyMap[5], "NativeEventEmitter");
+
+ var NativeModules = _$$_REQUIRE(_dependencyMap[6], "NativeModules");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[7], "Platform");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[8], "invariant");
+
+ var LinkingManager = Platform.OS === 'android' ? NativeModules.IntentAndroid : NativeModules.LinkingManager;
+
+ var Linking = function (_NativeEventEmitter) {
+ _inherits(Linking, _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: "sendIntent",
+ value: function sendIntent(action, extras) {
+ return LinkingManager.sendIntent(action, extras);
+ }
+ }, {
+ key: "_validateURL",
+ value: function _validateURL(url) {
+ invariant(typeof url === 'string', 'Invalid URL: should be a string. Was: ' + url);
+ invariant(url, 'Invalid URL: cannot be empty');
+ }
+ }]);
+
+ return Linking;
+ }(NativeEventEmitter);
+
+ module.exports = new Linking();
+},390,[3,4,5,8,9,131,36,35,19],"node_modules\\react-native\\Libraries\\Linking\\Linking.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var NativeEventEmitter = _$$_REQUIRE(_dependencyMap[0], "NativeEventEmitter");
+
+ var NativeModules = _$$_REQUIRE(_dependencyMap[1], "NativeModules");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[2], "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' || Platform.OS === 'macos') {
+ _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 only supported on android'));
+ }
+ };
+ module.exports = NetInfo;
+},391,[131,36,35],"node_modules\\react-native\\Libraries\\Network\\NetInfo.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var NativeEventEmitter = _$$_REQUIRE(_dependencyMap[2], "NativeEventEmitter");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[3], "Platform");
+
+ var RCTPushNotificationManager = _$$_REQUIRE(_dependencyMap[4], "NativeModules").PushNotificationManager;
+
+ var invariant = _$$_REQUIRE(_dependencyMap[5], "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 || Platform.OS === 'macos') {
+ 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;
+},392,[3,4,131,35,36,19],"node_modules\\react-native\\Libraries\\PushNotificationIOS\\PushNotificationIOS.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var Settings = {
+ get: function get(key) {
+ console.warn('Settings is not yet supported on UWP');
+ return null;
+ },
+ set: function set(settings) {
+ console.warn('Settings is not yet supported on UWP');
+ },
+ watchKeys: function watchKeys(keys, callback) {
+ console.warn('Settings is not yet supported on UWP');
+ return -1;
+ },
+ clearWatch: function clearWatch(watchId) {
+ console.warn('Settings is not yet supported on UWP');
+ }
+ };
+ module.exports = Settings;
+},393,[],"Libraries\\Settings\\Settings.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var Platform = _$$_REQUIRE(_dependencyMap[3], "Platform");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[4], "invariant");
+
+ var processColor = _$$_REQUIRE(_dependencyMap[5], "processColor");
+
+ var _require = _$$_REQUIRE(_dependencyMap[6], "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;
+},394,[32,3,4,35,19,75,36],"node_modules\\react-native\\Libraries\\Share\\Share.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "UnimplementedView");
+},395,[196],"Libraries\\Components\\StatusBar\\StatusBarIOS.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "UnimplementedView");
+},396,[196],"Libraries\\Components\\TimePickerAndroid\\TimePickerAndroid.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "UnimplementedView");
+},397,[196],"Libraries\\Components\\ToastAndroid\\ToastAndroid.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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;
+},398,[36,35],"node_modules\\react-native\\Libraries\\Vibration\\Vibration.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "UnimplementedView");
+},399,[196],"Libraries\\Vibration\\VibrationIOS.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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);
+ };
+},400,[84,71],"node_modules\\react-native\\Libraries\\ReactNative\\takeSnapshot.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var PropTypes = _$$_REQUIRE(_dependencyMap[0], "prop-types");
+
+ var PointPropType = PropTypes.shape({
+ x: PropTypes.number,
+ y: PropTypes.number
+ });
+ module.exports = PointPropType;
+},401,[62],"node_modules\\react-native\\Libraries\\DeprecatedPropTypes\\DeprecatedPointPropType.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+
+ var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireWildcard");
+
+ Object.defineProperty(exports, "__esModule", {
+ value: true
+ });
+ exports.default = void 0;
+
+ var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));
+
+ var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));
+
+ var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn"));
+
+ var _getPrototypeOf3 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf"));
+
+ var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));
+
+ var _react = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[7], "react"));
+
+ var _reactNativeWindows = _$$_REQUIRE(_dependencyMap[8], "react-native-windows");
+
+ var _ToDoItemList = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "./ToDoItemList"));
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\ToDoList.js";
+
+ var ToDoList = function (_Component) {
+ (0, _inherits2.default)(ToDoList, _Component);
+
+ function ToDoList() {
+ var _getPrototypeOf2;
+
+ var _this;
+
+ (0, _classCallCheck2.default)(this, ToDoList);
+
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ _this = (0, _possibleConstructorReturn2.default)(this, (_getPrototypeOf2 = (0, _getPrototypeOf3.default)(ToDoList)).call.apply(_getPrototypeOf2, [this].concat(args)));
+ _this.state = {
+ tasks: _this.props.tasks
+ };
+ return _this;
+ }
+
+ (0, _createClass2.default)(ToDoList, [{
+ key: "render",
+ value: function render() {
+ return _react.default.createElement(_reactNativeWindows.StackPanel, {
+ Orientation: "Vertical",
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 19
+ }
+ }, this.renderToDoList());
+ }
+ }, {
+ key: "renderToDoList",
+ value: function renderToDoList() {
+ var items = [];
+ var tasks = this.state.tasks;
+
+ for (var i = 0; i < tasks.length; i++) {
+ items.push(_react.default.createElement(_ToDoItemList.default, {
+ key: i,
+ taskList: tasks[i],
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 27
+ }
+ }));
+ }
+
+ return items;
+ }
+ }]);
+ return ToDoList;
+ }(_react.Component);
+
+ exports.default = ToDoList;
+},402,[1,2,3,4,5,8,9,11,0,403],"ToDoList.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+
+ var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireWildcard");
+
+ Object.defineProperty(exports, "__esModule", {
+ value: true
+ });
+ exports.default = void 0;
+
+ var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));
+
+ var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));
+
+ var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn"));
+
+ var _getPrototypeOf3 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf"));
+
+ var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));
+
+ var _react = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[7], "react"));
+
+ var _reactNativeWindows = _$$_REQUIRE(_dependencyMap[8], "react-native-windows");
+
+ var _ToDoItem = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "./ToDoItem"));
+
+ var _TaskList = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "./data/TaskList"));
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\ToDoItemList.js";
+
+ var ToDoItemList = function (_Component) {
+ (0, _inherits2.default)(ToDoItemList, _Component);
+
+ function ToDoItemList() {
+ var _getPrototypeOf2;
+
+ var _this;
+
+ (0, _classCallCheck2.default)(this, ToDoItemList);
+
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ _this = (0, _possibleConstructorReturn2.default)(this, (_getPrototypeOf2 = (0, _getPrototypeOf3.default)(ToDoItemList)).call.apply(_getPrototypeOf2, [this].concat(args)));
+ _this.state = {
+ name: _this.props.taskList.name,
+ completionRate: _this.props.taskList.completionRate,
+ pointerPressed: false,
+ expanded: true
+ };
+
+ _this.updateTaskList = function () {
+ _this.setState({
+ completionRate: _this.props.taskList.completionRate
+ });
+ };
+
+ _this.onPointerPressed = function () {
+ _this.setState({
+ pointerPressed: true
+ });
+ };
+
+ _this.onPointerReleased = function () {
+ if (_this.state.pointerPressed) {
+ _this.setState({
+ expanded: !_this.state.expanded
+ });
+ }
+ };
+
+ return _this;
+ }
+
+ (0, _createClass2.default)(ToDoItemList, [{
+ key: "toPercentage",
+ value: function toPercentage(value) {
+ return (100 * value).toFixed(0).toString() + '%';
+ }
+ }, {
+ key: "render",
+ value: function render() {
+ return _react.default.createElement(_reactNativeWindows.StackPanel, {
+ Orientation: "Vertical",
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 47
+ }
+ }, _react.default.createElement(_reactNativeWindows.Grid, {
+ Orientation: "Horizontal",
+ Background: this.state.completionRate === 0 ? 'Red' : this.state.completionRate < 1.0 ? 'Yellow' : 'Green',
+ PointerPressed: this.onPointerPressed,
+ PointerReleased: this.onPointerReleased,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 48
+ }
+ }, _react.default.createElement(_reactNativeWindows.TextBlock, {
+ FontSize: "24",
+ Text: this.state.name,
+ HorizontalAlignment: "Left",
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 59
+ }
+ }), _react.default.createElement(_reactNativeWindows.TextBlock, {
+ FontSize: "24",
+ Text: this.toPercentage(this.state.completionRate),
+ HorizontalAlignment: "Right",
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 64
+ }
+ })), this.state.expanded && this.renderItems());
+ }
+ }, {
+ key: "renderItems",
+ value: function renderItems() {
+ var items = [];
+ var tasks = this.props.taskList.tasks;
+
+ for (var i = 0; i < tasks.length; i++) {
+ items.push(_react.default.createElement(_ToDoItem.default, {
+ key: i,
+ task: tasks[i],
+ updateTaskList: this.updateTaskList,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 80
+ }
+ }));
+ }
+
+ return items;
+ }
+ }]);
+ return ToDoItemList;
+ }(_react.Component);
+
+ exports.default = ToDoItemList;
+},403,[1,2,3,4,5,8,9,11,0,404,406],"ToDoItemList.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+
+ var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireWildcard");
+
+ Object.defineProperty(exports, "__esModule", {
+ value: true
+ });
+ exports.default = void 0;
+
+ var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));
+
+ var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));
+
+ var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn"));
+
+ var _getPrototypeOf3 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf"));
+
+ var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));
+
+ var _react = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[7], "react"));
+
+ var _reactNativeWindows = _$$_REQUIRE(_dependencyMap[8], "react-native-windows");
+
+ var _ToggleSwitch = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "./Controls/ToggleSwitch"));
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\ToDoItem.js";
+
+ var ToDoItem = function (_Component) {
+ (0, _inherits2.default)(ToDoItem, _Component);
+
+ function ToDoItem() {
+ var _getPrototypeOf2;
+
+ var _this;
+
+ (0, _classCallCheck2.default)(this, ToDoItem);
+
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ _this = (0, _possibleConstructorReturn2.default)(this, (_getPrototypeOf2 = (0, _getPrototypeOf3.default)(ToDoItem)).call.apply(_getPrototypeOf2, [this].concat(args)));
+ _this.state = {
+ name: _this.props.task.name
+ };
+
+ _this.onToggleSwitchChanged = function (value) {
+ _this.props.task.isCompleted = value;
+
+ _this.props.updateTaskList();
+ };
+
+ _this.onPointerEntered = function () {
+ _this.setState({
+ showHover: true
+ });
+ };
+
+ _this.onPointerExited = function () {
+ _this.setState({
+ showHover: false
+ });
+ };
+
+ return _this;
+ }
+
+ (0, _createClass2.default)(ToDoItem, [{
+ key: "render",
+ value: function render() {
+ return _react.default.createElement(_reactNativeWindows.StackPanel, {
+ Orientation: "Horizontal",
+ Background: this.state.showHover ? 'AliceBlue' : 'Transparent',
+ BorderBrush: this.state.showHover ? 'Blue' : 'Transparent',
+ BorderThickness: "1",
+ PointerEntered: this.onPointerEntered,
+ PointerExited: this.onPointerExited,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 25
+ }
+ }, _react.default.createElement(_ToggleSwitch.default, {
+ onToggleSwitchChanged: this.onToggleSwitchChanged,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 32
+ }
+ }), _react.default.createElement(_reactNativeWindows.TextBlock, {
+ Text: this.state.name,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 33
+ }
+ }));
+ }
+ }]);
+ return ToDoItem;
+ }(_react.Component);
+
+ exports.default = ToDoItem;
+},404,[1,2,3,4,5,8,9,11,0,405],"ToDoItem.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+
+ var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireWildcard");
+
+ Object.defineProperty(exports, "__esModule", {
+ value: true
+ });
+ exports.default = void 0;
+
+ var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));
+
+ var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));
+
+ var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn"));
+
+ var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf"));
+
+ var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));
+
+ var _react = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[7], "react"));
+
+ var _reactNativeWindows = _$$_REQUIRE(_dependencyMap[8], "react-native-windows");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\Controls\\ToggleSwitch.js";
+
+ var ToggleSwitch = function (_Component) {
+ (0, _inherits2.default)(ToggleSwitch, _Component);
+
+ function ToggleSwitch() {
+ var _this;
+
+ (0, _classCallCheck2.default)(this, ToggleSwitch);
+ _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(ToggleSwitch).call(this));
+
+ _this.onPointerPressed = function () {
+ _this.setState({
+ pointerDown: true
+ });
+ };
+
+ _this.onPointerReleased = function () {
+ if (_this.state.pointerDown) {
+ _this.updateToggleState(!_this.state.on);
+ }
+
+ _this.setState({
+ pointerDown: false
+ });
+ };
+
+ _this.state = {
+ on: false,
+ pointerDown: false
+ };
+ return _this;
+ }
+
+ (0, _createClass2.default)(ToggleSwitch, [{
+ key: "render",
+ value: function render() {
+ return _react.default.createElement(_reactNativeWindows.Grid, {
+ Width: "50",
+ Height: "20",
+ Background: this.state.on ? 'Blue' : 'Transparent',
+ BorderBrush: this.state.on ? 'Blue' : 'Black',
+ BorderThickness: "2",
+ CornerRadius: "10",
+ PointerPressed: this.onPointerPressed,
+ PointerReleased: this.onPointerReleased,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 22
+ }
+ }, _react.default.createElement(_reactNativeWindows.Rectangle, {
+ HorizontalAlignment: "Left",
+ Translation: this.state.on ? '33,0,0' : '3,0,0',
+ Fill: this.state.on ? 'White' : 'Black',
+ Width: "10",
+ Height: "10",
+ RadiusX: "5",
+ RadiusY: "5",
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 31
+ }
+ }));
+ }
+ }, {
+ key: "updateToggleState",
+ value: function updateToggleState(toggleState) {
+ this.setState({
+ on: toggleState
+ });
+ this.props.onToggleSwitchChanged(toggleState);
+ }
+ }]);
+ return ToggleSwitch;
+ }(_react.Component);
+
+ exports.default = ToggleSwitch;
+},405,[1,2,3,4,5,8,9,11,0],"Controls\\ToggleSwitch.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+
+ Object.defineProperty(exports, "__esModule", {
+ value: true
+ });
+ exports.default = void 0;
+
+ var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+
+ var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+
+ var _Task = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "./Task"));
+
+ var TaskList = function () {
+ function TaskList(name) {
+ (0, _classCallCheck2.default)(this, TaskList);
+ this.name = name;
+ this.tasks = [];
+ }
+
+ (0, _createClass2.default)(TaskList, [{
+ key: "addTask",
+ value: function addTask(name) {
+ var task = new _Task.default(name);
+ this.tasks.push(task);
+ }
+ }, {
+ key: "completionRate",
+ get: function get() {
+ if (this.tasks.length == 0) {
+ return 1.0;
+ }
+
+ return this.tasks.filter(function (t) {
+ return t.isCompleted;
+ }).length / this.tasks.length;
+ }
+ }]);
+ return TaskList;
+ }();
+
+ exports.default = TaskList;
+},406,[1,3,4,407],"data\\TaskList.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+
+ Object.defineProperty(exports, "__esModule", {
+ value: true
+ });
+ exports.default = void 0;
+
+ var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+
+ var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+
+ var Task = function () {
+ function Task(name) {
+ (0, _classCallCheck2.default)(this, Task);
+ this.name = name;
+ this.isCompleted = false;
+ }
+
+ (0, _createClass2.default)(Task, [{
+ key: "toggleCompleted",
+ value: function toggleCompleted() {
+ this.isCompleted = !this.isCompleted;
+ }
+ }]);
+ return Task;
+ }();
+
+ exports.default = Task;
+},407,[1,3,4],"data\\Task.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+
+ var _TaskList = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./TaskList"));
+
+ var tolkien = new _TaskList.default('J.R.R. Tolkien');
+ tolkien.addTask('Finish work on Recipes of Middle Earth');
+ tolkien.addTask('Continue Orc experiments');
+ tolkien.addTask('Replenish pipe tabacco supplies');
+ var columbus = new _TaskList.default('Christopher Columbus');
+ columbus.addTask('Investor meeting to secure funding');
+ columbus.addTask('Practice sea navigation techniques');
+ columbus.addTask('Test whether dining table is round or flat');
+ columbus.addTask('Attend geography class');
+ var caesar = new _TaskList.default('Julius Caesar');
+ caesar.addTask('Work on Senate speech (due Mar 15)');
+ caesar.addTask('Experiment with various salad dressings');
+ caesar.addTask('Pose for sculpture');
+ caesar.addTask('Coffee with Brutus');
+ var vader = new _TaskList.default('Darth Vader');
+ vader.addTask('Meet with color consultant for Death Star decor');
+ vader.addTask('Attend anger management class');
+ vader.addTask('Lead troops in deep breathing exercises');
+ var tasks = [tolkien, columbus, caesar, vader];
+ module.exports = {
+ getTasks: function getTasks() {
+ return tasks.concat();
+ }
+ };
+},408,[1,406],"data\\SampleData.js");
+__r(86);
+__r(0);
\ No newline at end of file
diff --git a/vnext/Playground/Playground/Assets/index.uwp.bundle b/vnext/Playground/Playground/Assets/index.uwp.bundle
new file mode 100644
index 00000000000..b04eaac15fb
--- /dev/null
+++ b/vnext/Playground/Playground/Assets/index.uwp.bundle
@@ -0,0 +1,86300 @@
+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";
+
+ global.__r = metroRequire;
+ global.__d = define;
+ global.__c = clear;
+ global.__registerSegment = registerSegment;
+ var modules = clear();
+ var EMPTY = {};
+ var _ref = {},
+ hasOwnProperty = _ref.hasOwnProperty;
+
+ function clear() {
+ modules = typeof __NUM_MODULES__ === "number" ? Array(__NUM_MODULES__ | 0) : Object.create(null);
+ return modules;
+ }
+
+ if (__DEV__) {
+ var verboseNamesToModuleIds = Object.create(null);
+ var initializingModuleIds = [];
+ }
+
+ function define(factory, moduleId, dependencyMap) {
+ if (modules[moduleId] != null) {
+ if (__DEV__) {
+ var inverseDependencies = arguments[4];
+
+ if (inverseDependencies) {
+ global.__accept(moduleId, factory, dependencyMap, inverseDependencies);
+ }
+ }
+
+ return;
+ }
+
+ modules[moduleId] = {
+ dependencyMap: dependencyMap,
+ factory: factory,
+ hasError: false,
+ importedAll: EMPTY,
+ importedDefault: EMPTY,
+ isInitialized: false,
+ publicModule: {
+ exports: {}
+ }
+ };
+
+ 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: "'.concat(verboseName, '"'));
+ } else {
+ console.warn('Requiring module "'.concat(verboseName, '" by name is only supported for ') + "debugging purposes and will BREAK IN PRODUCTION!");
+ }
+ }
+
+ var moduleIdReallyIsNumber = moduleId;
+
+ if (__DEV__) {
+ var initializingIndex = initializingModuleIds.indexOf(moduleIdReallyIsNumber);
+
+ if (initializingIndex !== -1) {
+ var cycle = initializingModuleIds.slice(initializingIndex).map(function (id) {
+ return modules[id].verboseName;
+ });
+ cycle.push(cycle[0]);
+ console.warn("Require cycle: ".concat(cycle.join(" -> "), "\n\n") + "Require cycles are allowed, but can result in uninitialized values. " + "Consider refactoring to remove the need for a cycle.");
+ }
+ }
+
+ var module = modules[moduleIdReallyIsNumber];
+ return module && module.isInitialized ? module.publicModule.exports : guardedLoadModule(moduleIdReallyIsNumber, module);
+ }
+
+ function metroImportDefault(moduleId) {
+ if (__DEV__ && typeof moduleId === "string") {
+ var verboseName = moduleId;
+ moduleId = verboseNamesToModuleIds[verboseName];
+ }
+
+ var moduleIdReallyIsNumber = moduleId;
+
+ if (modules[moduleIdReallyIsNumber] && modules[moduleIdReallyIsNumber].importedDefault !== EMPTY) {
+ return modules[moduleIdReallyIsNumber].importedDefault;
+ }
+
+ var exports = metroRequire(moduleIdReallyIsNumber);
+ var importedDefault = exports && exports.__esModule ? exports.default : exports;
+ return modules[moduleIdReallyIsNumber].importedDefault = importedDefault;
+ }
+
+ metroRequire.importDefault = metroImportDefault;
+
+ function metroImportAll(moduleId) {
+ if (__DEV__ && typeof moduleId === "string") {
+ var verboseName = moduleId;
+ moduleId = verboseNamesToModuleIds[verboseName];
+ }
+
+ var moduleIdReallyIsNumber = moduleId;
+
+ if (modules[moduleIdReallyIsNumber] && modules[moduleIdReallyIsNumber].importedAll !== EMPTY) {
+ return modules[moduleIdReallyIsNumber].importedAll;
+ }
+
+ var exports = metroRequire(moduleIdReallyIsNumber);
+ var importedAll;
+
+ if (exports && exports.__esModule) {
+ importedAll = exports;
+ } else {
+ importedAll = {};
+
+ if (exports) {
+ for (var _key in exports) {
+ if (hasOwnProperty.call(exports, _key)) {
+ importedAll[_key] = exports[_key];
+ }
+ }
+ }
+
+ importedAll.default = exports;
+ }
+
+ return modules[moduleIdReallyIsNumber].importedAll = importedAll;
+ }
+
+ metroRequire.importAll = metroImportAll;
+ var inGuard = false;
+
+ function guardedLoadModule(moduleId, module) {
+ if (!inGuard && global.ErrorUtils) {
+ inGuard = true;
+ var returnValue;
+
+ try {
+ returnValue = loadModuleImplementation(moduleId, module);
+ } catch (e) {
+ global.ErrorUtils.reportFatalError(e);
+ }
+
+ inGuard = false;
+ return returnValue;
+ } else {
+ return loadModuleImplementation(moduleId, module);
+ }
+ }
+
+ var ID_MASK_SHIFT = 16;
+ var LOCAL_ID_MASK = ~0 >>> ID_MASK_SHIFT;
+
+ function unpackModuleId(moduleId) {
+ var segmentId = moduleId >>> ID_MASK_SHIFT;
+ var localId = moduleId & LOCAL_ID_MASK;
+ return {
+ segmentId: segmentId,
+ localId: localId
+ };
+ }
+
+ metroRequire.unpackModuleId = unpackModuleId;
+
+ function packModuleId(value) {
+ return (value.segmentId << ID_MASK_SHIFT) + value.localId;
+ }
+
+ metroRequire.packModuleId = packModuleId;
+ var hooks = [];
+
+ function registerHook(cb) {
+ var hook = {
+ cb: cb
+ };
+ hooks.push(hook);
+ return {
+ release: function release() {
+ for (var i = 0; i < hooks.length; ++i) {
+ if (hooks[i] === hook) {
+ hooks.splice(i, 1);
+ break;
+ }
+ }
+ }
+ };
+ }
+
+ metroRequire.registerHook = registerHook;
+ var moduleDefinersBySegmentID = [];
+
+ function registerSegment(segmentID, moduleDefiner) {
+ moduleDefinersBySegmentID[segmentID] = moduleDefiner;
+ }
+
+ function loadModuleImplementation(moduleId, module) {
+ if (!module && moduleDefinersBySegmentID.length > 0) {
+ var _unpackModuleId = unpackModuleId(moduleId),
+ segmentId = _unpackModuleId.segmentId,
+ localId = _unpackModuleId.localId;
+
+ var definer = moduleDefinersBySegmentID[segmentId];
+
+ if (definer != null) {
+ definer(localId);
+ module = modules[moduleId];
+ }
+ }
+
+ var nativeRequire = global.nativeRequire;
+
+ if (!module && nativeRequire) {
+ var _unpackModuleId2 = unpackModuleId(moduleId),
+ _segmentId = _unpackModuleId2.segmentId,
+ _localId = _unpackModuleId2.localId;
+
+ nativeRequire(_localId, _segmentId);
+ module = modules[moduleId];
+ }
+
+ if (!module) {
+ throw unknownModuleError(moduleId);
+ }
+
+ if (module.hasError) {
+ throw moduleThrewError(moduleId, module.error);
+ }
+
+ if (__DEV__) {
+ var Systrace = metroRequire.Systrace;
+ }
+
+ module.isInitialized = true;
+ var _module = module,
+ factory = _module.factory,
+ dependencyMap = _module.dependencyMap;
+
+ if (__DEV__) {
+ initializingModuleIds.push(moduleId);
+ }
+
+ try {
+ if (__DEV__) {
+ Systrace.beginEvent("JS_require_" + (module.verboseName || moduleId));
+ }
+
+ var _moduleObject = module.publicModule;
+
+ if (__DEV__) {
+ if (module.hot) {
+ _moduleObject.hot = module.hot;
+ }
+ }
+
+ _moduleObject.id = moduleId;
+
+ if (hooks.length > 0) {
+ for (var i = 0; i < hooks.length; ++i) {
+ hooks[i].cb(moduleId, _moduleObject);
+ }
+ }
+
+ factory(global, metroRequire, metroImportDefault, metroImportAll, _moduleObject, _moduleObject.exports, dependencyMap);
+
+ if (!__DEV__) {
+ module.factory = undefined;
+ module.dependencyMap = undefined;
+ }
+
+ if (__DEV__) {
+ Systrace.endEvent();
+ }
+
+ return _moduleObject.exports;
+ } catch (e) {
+ module.hasError = true;
+ module.error = e;
+ module.isInitialized = false;
+ module.publicModule.exports = undefined;
+ throw e;
+ } finally {
+ if (__DEV__) {
+ if (initializingModuleIds.pop() !== moduleId) {
+ throw new Error("initializingModuleIds is corrupt; something is terribly wrong");
+ }
+ }
+ }
+ }
+
+ 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 ".concat(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 ".concat(id, ": "), error);
+ }
+ }
+
+ if (!inverseDependencies) {
+ throw new Error("Undefined `inverseDependencies`");
+ }
+
+ return metroAcceptAll(inverseDependencies[id], inverseDependencies, patchedModules);
+ };
+
+ global.__accept = metroAccept;
+ }
+})(typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : this);
+(function (global) {
+ if (typeof Object.assign !== 'function') {
+ Object.defineProperty(Object, 'assign', {
+ value: function assign(target, varArgs) {
+ 'use strict';
+
+ if (target == null) {
+ throw new TypeError('Cannot convert undefined or null to object');
+ }
+
+ var to = Object(target);
+
+ for (var index = 1; index < arguments.length; index++) {
+ var nextSource = arguments[index];
+
+ if (nextSource != null) {
+ for (var nextKey in nextSource) {
+ if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {
+ to[nextKey] = nextSource[nextKey];
+ }
+ }
+ }
+ }
+
+ return to;
+ },
+ writable: true,
+ configurable: true
+ });
+ }
+})(typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : 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 objectToString(o) {
+ return Object.prototype.toString.call(o);
+ }
+
+ function hasOwnProperty(obj, prop) {
+ return Object.prototype.hasOwnProperty.call(obj, prop);
+ }
+
+ return inspect;
+ }();
+
+ var OBJECT_COLUMN_NAME = '(index)';
+ var LOG_LEVELS = {
+ trace: 0,
+ info: 1,
+ warn: 2,
+ error: 3
+ };
+ var INSPECTOR_LEVELS = [];
+ INSPECTOR_LEVELS[LOG_LEVELS.trace] = 'debug';
+ INSPECTOR_LEVELS[LOG_LEVELS.info] = 'log';
+ INSPECTOR_LEVELS[LOG_LEVELS.warn] = 'warning';
+ INSPECTOR_LEVELS[LOG_LEVELS.error] = 'error';
+ var INSPECTOR_FRAMES_TO_SKIP = __DEV__ ? 2 : 1;
+
+ function getNativeLogFunction(level) {
+ return function () {
+ var str;
+
+ if (arguments.length === 1 && typeof arguments[0] === 'string') {
+ str = arguments[0];
+ } else {
+ str = Array.prototype.map.call(arguments, function (arg) {
+ return inspect(arg, {
+ depth: 10
+ });
+ }).join(', ');
+ }
+
+ var logLevel = level;
+
+ if (str.slice(0, 9) === 'Warning: ' && logLevel >= LOG_LEVELS.error) {
+ logLevel = LOG_LEVELS.warn;
+ }
+
+ if (global.__inspectorLog) {
+ global.__inspectorLog(INSPECTOR_LEVELS[logLevel], str, [].slice.call(arguments), INSPECTOR_FRAMES_TO_SKIP);
+ }
+
+ if (groupStack.length) {
+ str = groupFormat('', str);
+ }
+
+ global.nativeLoggingHook(str, logLevel);
+ };
+ }
+
+ function repeat(element, n) {
+ return Array.apply(null, Array(n)).map(function () {
+ return element;
+ });
+ }
+
+ function consoleTablePolyfill(rows) {
+ if (!Array.isArray(rows)) {
+ var data = rows;
+ rows = [];
+
+ for (var key in data) {
+ if (data.hasOwnProperty(key)) {
+ var row = data[key];
+ row[OBJECT_COLUMN_NAME] = key;
+ rows.push(row);
+ }
+ }
+ }
+
+ if (rows.length === 0) {
+ global.nativeLoggingHook('', LOG_LEVELS.info);
+ return;
+ }
+
+ var columns = Object.keys(rows[0]).sort();
+ var stringRows = [];
+ var columnWidths = [];
+ columns.forEach(function (k, i) {
+ columnWidths[i] = k.length;
+
+ for (var j = 0; j < rows.length; j++) {
+ var cellStr = (rows[j][k] || '?').toString();
+ stringRows[j] = stringRows[j] || [];
+ stringRows[j][i] = cellStr;
+ columnWidths[i] = Math.max(columnWidths[i], cellStr.length);
+ }
+ });
+
+ function joinRow(row, space) {
+ var cells = row.map(function (cell, i) {
+ var extraSpaces = repeat(' ', columnWidths[i] - cell.length).join('');
+ return cell + extraSpaces;
+ });
+ space = space || ' ';
+ return cells.join(space + '|' + space);
+ }
+
+ var separators = columnWidths.map(function (columnWidth) {
+ return repeat('-', columnWidth).join('');
+ });
+ var separatorRow = joinRow(separators, '-');
+ var header = joinRow(columns);
+ var table = [header, separatorRow];
+
+ for (var i = 0; i < rows.length; i++) {
+ table.push(joinRow(stringRows[i]));
+ }
+
+ global.nativeLoggingHook('\n' + table.join('\n'), LOG_LEVELS.info);
+ }
+
+ var GROUP_PAD = "\u2502";
+ var GROUP_OPEN = "\u2510";
+ var GROUP_CLOSE = "\u2518";
+ var groupStack = [];
+
+ function groupFormat(prefix, msg) {
+ return groupStack.join('') + prefix + ' ' + (msg || '');
+ }
+
+ function consoleGroupPolyfill(label) {
+ global.nativeLoggingHook(groupFormat(GROUP_OPEN, label), LOG_LEVELS.info);
+ groupStack.push(GROUP_PAD);
+ }
+
+ function consoleGroupCollapsedPolyfill(label) {
+ global.nativeLoggingHook(groupFormat(GROUP_CLOSE, label), LOG_LEVELS.info);
+ groupStack.push(GROUP_PAD);
+ }
+
+ function consoleGroupEndPolyfill() {
+ groupStack.pop();
+ global.nativeLoggingHook(groupFormat(GROUP_CLOSE), LOG_LEVELS.info);
+ }
+
+ if (global.nativeLoggingHook) {
+ var originalConsole = global.console;
+
+ if (__DEV__ && originalConsole) {
+ var descriptor = Object.getOwnPropertyDescriptor(global, 'console');
+
+ if (descriptor) {
+ Object.defineProperty(global, 'originalConsole', descriptor);
+ }
+ }
+
+ global.console = {
+ error: getNativeLogFunction(LOG_LEVELS.error),
+ info: getNativeLogFunction(LOG_LEVELS.info),
+ log: getNativeLogFunction(LOG_LEVELS.info),
+ warn: getNativeLogFunction(LOG_LEVELS.warn),
+ trace: getNativeLogFunction(LOG_LEVELS.trace),
+ debug: getNativeLogFunction(LOG_LEVELS.trace),
+ table: consoleTablePolyfill,
+ group: consoleGroupPolyfill,
+ groupEnd: consoleGroupEndPolyfill,
+ groupCollapsed: consoleGroupCollapsedPolyfill
+ };
+
+ if (__DEV__ && originalConsole) {
+ 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);
+ };
+ }
+ });
+ ['assert', 'clear', 'dir', 'dirxml', 'groupCollapsed', 'profile', 'profileEnd'].forEach(function (methodName) {
+ if (typeof originalConsole[methodName] === 'function') {
+ console[methodName] = function () {
+ originalConsole[methodName].apply(originalConsole, arguments);
+ };
+ }
+ });
+ }
+ } else if (!global.console) {
+ var log = global.print || function consoleLoggingStub() {};
+
+ global.console = {
+ error: log,
+ info: log,
+ log: log,
+ warn: log,
+ trace: log,
+ debug: log,
+ table: log
+ };
+ }
+})(typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : 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 || '';
+
+ function guarded() {
+ return ErrorUtils.applyWithGuard(fun, context || this, arguments, null, name);
+ }
+
+ return guarded;
+ }
+ };
+ global.ErrorUtils = ErrorUtils;
+})(typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : 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
+ });
+ }
+})(typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : 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;
+ };
+ }
+
+ if (!String.prototype.padEnd) {
+ String.prototype.padEnd = function padEnd(targetLength, padString) {
+ targetLength = targetLength >> 0;
+ padString = String(typeof padString !== 'undefined' ? padString : ' ');
+
+ if (this.length > targetLength) {
+ return String(this);
+ } else {
+ targetLength = targetLength - this.length;
+
+ if (targetLength > padString.length) {
+ padString += padString.repeat(targetLength / padString.length);
+ }
+
+ return String(this) + padString.slice(0, targetLength);
+ }
+ };
+ }
+
+ if (!String.prototype.padStart) {
+ String.prototype.padStart = function padStart(targetLength, padString) {
+ targetLength = targetLength >> 0;
+ padString = String(typeof padString !== 'undefined' ? padString : ' ');
+
+ if (this.length > targetLength) {
+ return String(this);
+ } else {
+ targetLength = targetLength - this.length;
+
+ if (targetLength > padString.length) {
+ padString += padString.repeat(targetLength / padString.length);
+ }
+
+ return padString.slice(0, targetLength) + String(this);
+ }
+ };
+ }
+})(typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : 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;
+ }
+ });
+ }
+})(typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : 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;
+ };
+ }
+})(typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : this);
+(function (global) {
+ (function () {
+ 'use strict';
+
+ var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+ if (typeof Object.entries !== 'function') {
+ Object.entries = function (object) {
+ if (object == null) {
+ throw new TypeError('Object.entries called on non-object');
+ }
+
+ var entries = [];
+
+ for (var key in object) {
+ if (hasOwnProperty.call(object, key)) {
+ entries.push([key, object[key]]);
+ }
+ }
+
+ return entries;
+ };
+ }
+
+ if (typeof Object.values !== 'function') {
+ Object.values = function (object) {
+ if (object == null) {
+ throw new TypeError('Object.values called on non-object');
+ }
+
+ var values = [];
+
+ for (var key in object) {
+ if (hasOwnProperty.call(object, key)) {
+ values.push(object[key]);
+ }
+ }
+
+ return values;
+ };
+ }
+ })();
+})(typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : this);
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+
+ var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireWildcard");
+
+ Object.defineProperty(exports, "__esModule", {
+ value: true
+ });
+ exports.default = void 0;
+
+ var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));
+
+ var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));
+
+ var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn"));
+
+ var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf"));
+
+ var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));
+
+ var _react = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[7], "react"));
+
+ var _reactNative = _$$_REQUIRE(_dependencyMap[8], "react-native");
+
+ var _reactNativeWindows = _$$_REQUIRE(_dependencyMap[9], "react-native-windows");
+
+ var _ToDoList = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "./ToDoList"));
+
+ var _SampleData = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[11], "./data/SampleData"));
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\index.uwp.js";
+ var initialState = {
+ tasks: _SampleData.default.getTasks()
+ };
+
+ var ToDoListApp = function (_Component) {
+ (0, _inherits2.default)(ToDoListApp, _Component);
+
+ function ToDoListApp() {
+ var _this;
+
+ (0, _classCallCheck2.default)(this, ToDoListApp);
+ _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(ToDoListApp).call(this));
+ _this.state = initialState;
+ return _this;
+ }
+
+ (0, _createClass2.default)(ToDoListApp, [{
+ key: "render",
+ value: function render() {
+ return _react.default.createElement(_reactNativeWindows.StackPanel, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 26
+ }
+ }, _react.default.createElement(_ToDoList.default, {
+ tasks: this.state.tasks,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 27
+ }
+ }));
+ }
+ }, {
+ key: "toggleSwitchChanged",
+ value: function toggleSwitchChanged(toggleState) {
+ this.setState({
+ dude: toggleState
+ });
+ }
+ }]);
+ return ToDoListApp;
+ }(_react.Component);
+
+ exports.default = ToDoListApp;
+
+ _reactNative.AppRegistry.registerComponent('ToDoListApp', function () {
+ return ToDoListApp;
+ });
+},0,[1,2,3,4,5,8,9,11,18,0,402,408],"index.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ function _interopRequireDefault(obj) {
+ return obj && obj.__esModule ? obj : {
+ "default": obj
+ };
+ }
+
+ module.exports = _interopRequireDefault;
+},1,[],"node_modules\\@babel\\runtime\\helpers\\interopRequireDefault.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 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;
+ }
+ }
+
+ module.exports = _interopRequireWildcard;
+},2,[],"node_modules\\@babel\\runtime\\helpers\\interopRequireWildcard.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ function _classCallCheck(instance, Constructor) {
+ if (!(instance instanceof Constructor)) {
+ throw new TypeError("Cannot call a class as a function");
+ }
+ }
+
+ module.exports = _classCallCheck;
+},3,[],"node_modules\\@babel\\runtime\\helpers\\classCallCheck.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ function _defineProperties(target, props) {
+ for (var i = 0; i < props.length; i++) {
+ var descriptor = props[i];
+ descriptor.enumerable = descriptor.enumerable || false;
+ descriptor.configurable = true;
+ if ("value" in descriptor) descriptor.writable = true;
+ Object.defineProperty(target, descriptor.key, descriptor);
+ }
+ }
+
+ function _createClass(Constructor, protoProps, staticProps) {
+ if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+ if (staticProps) _defineProperties(Constructor, staticProps);
+ return Constructor;
+ }
+
+ module.exports = _createClass;
+},4,[],"node_modules\\@babel\\runtime\\helpers\\createClass.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var _typeof = _$$_REQUIRE(_dependencyMap[0], "../helpers/typeof");
+
+ var assertThisInitialized = _$$_REQUIRE(_dependencyMap[1], "./assertThisInitialized");
+
+ function _possibleConstructorReturn(self, call) {
+ if (call && (_typeof(call) === "object" || typeof call === "function")) {
+ return call;
+ }
+
+ return assertThisInitialized(self);
+ }
+
+ module.exports = _possibleConstructorReturn;
+},5,[6,7],"node_modules\\@babel\\runtime\\helpers\\possibleConstructorReturn.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ function _typeof2(obj) {
+ if (typeof Symbol === "function" && typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") === "symbol") {
+ _typeof2 = function _typeof2(obj) {
+ return typeof obj;
+ };
+ } else {
+ _typeof2 = function _typeof2(obj) {
+ return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof obj;
+ };
+ }
+
+ return _typeof2(obj);
+ }
+
+ function _typeof(obj) {
+ if (typeof Symbol === "function" && _typeof2(typeof Symbol === "function" ? Symbol.iterator : "@@iterator") === "symbol") {
+ module.exports = _typeof = function _typeof(obj) {
+ return _typeof2(obj);
+ };
+ } else {
+ module.exports = _typeof = function _typeof(obj) {
+ return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : _typeof2(obj);
+ };
+ }
+
+ return _typeof(obj);
+ }
+
+ module.exports = _typeof;
+},6,[],"node_modules\\@babel\\runtime\\helpers\\typeof.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ function _assertThisInitialized(self) {
+ if (self === void 0) {
+ throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+ }
+
+ return self;
+ }
+
+ module.exports = _assertThisInitialized;
+},7,[],"node_modules\\@babel\\runtime\\helpers\\assertThisInitialized.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ function _getPrototypeOf(o) {
+ module.exports = _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+ return o.__proto__ || Object.getPrototypeOf(o);
+ };
+ return _getPrototypeOf(o);
+ }
+
+ module.exports = _getPrototypeOf;
+},8,[],"node_modules\\@babel\\runtime\\helpers\\getPrototypeOf.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var setPrototypeOf = _$$_REQUIRE(_dependencyMap[0], "./setPrototypeOf");
+
+ function _inherits(subClass, superClass) {
+ if (typeof superClass !== "function" && superClass !== null) {
+ throw new TypeError("Super expression must either be null or a function");
+ }
+
+ subClass.prototype = Object.create(superClass && superClass.prototype, {
+ constructor: {
+ value: subClass,
+ writable: true,
+ configurable: true
+ }
+ });
+ if (superClass) setPrototypeOf(subClass, superClass);
+ }
+
+ module.exports = _inherits;
+},9,[10],"node_modules\\@babel\\runtime\\helpers\\inherits.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ function _setPrototypeOf(o, p) {
+ module.exports = _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+ o.__proto__ = p;
+ return o;
+ };
+
+ return _setPrototypeOf(o, p);
+ }
+
+ module.exports = _setPrototypeOf;
+},10,[],"node_modules\\@babel\\runtime\\helpers\\setPrototypeOf.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ if (process.env.NODE_ENV === 'production') {
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "./cjs/react.production.min.js");
+ } else {
+ module.exports = _$$_REQUIRE(_dependencyMap[1], "./cjs/react.development.js");
+ }
+},11,[12,15],"node_modules\\react\\index.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ /** @license React v16.8.3
+ * react.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+ 'use strict';
+
+ var k = _$$_REQUIRE(_dependencyMap[0], "object-assign"),
+ n = "function" === typeof Symbol && (typeof Symbol === "function" ? Symbol.for : "@@for"),
+ p = n ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.element") : 60103,
+ q = n ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.portal") : 60106,
+ r = n ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.fragment") : 60107,
+ t = n ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.strict_mode") : 60108,
+ u = n ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.profiler") : 60114,
+ v = n ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.provider") : 60109,
+ w = n ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.context") : 60110,
+ x = n ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.concurrent_mode") : 60111,
+ y = n ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.forward_ref") : 60112,
+ z = n ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.suspense") : 60113,
+ aa = n ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.memo") : 60115,
+ ba = n ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.lazy") : 60116,
+ A = "function" === typeof Symbol && (typeof Symbol === "function" ? Symbol.iterator : "@@iterator");
+
+ function ca(a, b, d, c, e, g, h, f) {
+ if (!a) {
+ a = void 0;
+ if (void 0 === b) a = Error("Minified exception occurred; use the non-minified dev environment for the full error message and additional helpful warnings.");else {
+ var l = [d, c, e, g, h, f],
+ m = 0;
+ a = Error(b.replace(/%s/g, function () {
+ return l[m++];
+ }));
+ a.name = "Invariant Violation";
+ }
+ a.framesToPop = 1;
+ throw a;
+ }
+ }
+
+ function B(a) {
+ for (var b = arguments.length - 1, d = "https://reactjs.org/docs/error-decoder.html?invariant=" + a, c = 0; c < b; c++) {
+ d += "&args[]=" + encodeURIComponent(arguments[c + 1]);
+ }
+
+ ca(!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. ", d);
+ }
+
+ var C = {
+ isMounted: function isMounted() {
+ return !1;
+ },
+ enqueueForceUpdate: function enqueueForceUpdate() {},
+ enqueueReplaceState: function enqueueReplaceState() {},
+ enqueueSetState: function enqueueSetState() {}
+ },
+ D = {};
+
+ function E(a, b, d) {
+ this.props = a;
+ this.context = b;
+ this.refs = D;
+ this.updater = d || C;
+ }
+
+ E.prototype.isReactComponent = {};
+
+ E.prototype.setState = function (a, b) {
+ "object" !== typeof a && "function" !== typeof a && null != a ? B("85") : void 0;
+ this.updater.enqueueSetState(this, a, b, "setState");
+ };
+
+ E.prototype.forceUpdate = function (a) {
+ this.updater.enqueueForceUpdate(this, a, "forceUpdate");
+ };
+
+ function F() {}
+
+ F.prototype = E.prototype;
+
+ function G(a, b, d) {
+ this.props = a;
+ this.context = b;
+ this.refs = D;
+ this.updater = d || C;
+ }
+
+ var H = G.prototype = new F();
+ H.constructor = G;
+ k(H, E.prototype);
+ H.isPureReactComponent = !0;
+ var I = {
+ current: null
+ },
+ J = {
+ current: null
+ },
+ K = Object.prototype.hasOwnProperty,
+ L = {
+ key: !0,
+ ref: !0,
+ __self: !0,
+ __source: !0
+ };
+
+ function M(a, b, d) {
+ var c = void 0,
+ e = {},
+ g = null,
+ 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) && (e[c] = b[c]);
+ }
+ var f = arguments.length - 2;
+ if (1 === f) e.children = d;else if (1 < f) {
+ for (var l = Array(f), m = 0; m < f; m++) {
+ l[m] = arguments[m + 2];
+ }
+
+ e.children = l;
+ }
+ if (a && a.defaultProps) for (c in f = a.defaultProps, f) {
+ void 0 === e[c] && (e[c] = f[c]);
+ }
+ return {
+ $$typeof: p,
+ type: a,
+ key: g,
+ ref: h,
+ props: e,
+ _owner: J.current
+ };
+ }
+
+ function da(a, b) {
+ return {
+ $$typeof: p,
+ type: a.type,
+ key: b,
+ ref: a.ref,
+ props: a.props,
+ _owner: a._owner
+ };
+ }
+
+ function N(a) {
+ return "object" === typeof a && null !== a && a.$$typeof === p;
+ }
+
+ function escape(a) {
+ var b = {
+ "=": "=0",
+ ":": "=2"
+ };
+ return "$" + ("" + a).replace(/[=:]/g, function (a) {
+ return b[a];
+ });
+ }
+
+ var O = /\/+/g,
+ P = [];
+
+ function Q(a, b, d, c) {
+ if (P.length) {
+ var e = P.pop();
+ e.result = a;
+ e.keyPrefix = b;
+ e.func = d;
+ e.context = c;
+ e.count = 0;
+ return e;
+ }
+
+ return {
+ result: a,
+ keyPrefix: b,
+ func: d,
+ context: c,
+ count: 0
+ };
+ }
+
+ function R(a) {
+ a.result = null;
+ a.keyPrefix = null;
+ a.func = null;
+ a.context = null;
+ a.count = 0;
+ 10 > P.length && P.push(a);
+ }
+
+ function S(a, b, d, c) {
+ var e = typeof a;
+ if ("undefined" === e || "boolean" === e) a = null;
+ var g = !1;
+ if (null === a) g = !0;else switch (e) {
+ case "string":
+ case "number":
+ g = !0;
+ break;
+
+ case "object":
+ switch (a.$$typeof) {
+ case p:
+ case q:
+ g = !0;
+ }
+
+ }
+ if (g) return d(c, a, "" === b ? "." + T(a, 0) : b), 1;
+ g = 0;
+ b = "" === b ? "." : b + ":";
+ if (Array.isArray(a)) for (var h = 0; h < a.length; h++) {
+ e = a[h];
+ var f = b + T(e, h);
+ g += S(e, f, d, c);
+ } else if (null === a || "object" !== typeof a ? f = null : (f = A && a[A] || a["@@iterator"], f = "function" === typeof f ? f : null), "function" === typeof f) for (a = f.call(a), h = 0; !(e = a.next()).done;) {
+ e = e.value, f = b + T(e, h++), g += S(e, f, d, c);
+ } else "object" === e && (d = "" + a, B("31", "[object Object]" === d ? "object with keys {" + Object.keys(a).join(", ") + "}" : d, ""));
+ return g;
+ }
+
+ function U(a, b, d) {
+ return null == a ? 0 : S(a, "", b, d);
+ }
+
+ function T(a, b) {
+ return "object" === typeof a && null !== a && null != a.key ? escape(a.key) : b.toString(36);
+ }
+
+ function ea(a, b) {
+ a.func.call(a.context, b, a.count++);
+ }
+
+ function fa(a, b, d) {
+ var c = a.result,
+ e = a.keyPrefix;
+ a = a.func.call(a.context, b, a.count++);
+ Array.isArray(a) ? V(a, c, d, function (a) {
+ return a;
+ }) : null != a && (N(a) && (a = da(a, e + (!a.key || b && b.key === a.key ? "" : ("" + a.key).replace(O, "$&/") + "/") + d)), c.push(a));
+ }
+
+ function V(a, b, d, c, e) {
+ var g = "";
+ null != d && (g = ("" + d).replace(O, "$&/") + "/");
+ b = Q(b, g, c, e);
+ U(a, fa, b);
+ R(b);
+ }
+
+ function W() {
+ var a = I.current;
+ null === a ? B("307") : void 0;
+ return a;
+ }
+
+ var X = {
+ Children: {
+ map: function map(a, b, d) {
+ if (null == a) return a;
+ var c = [];
+ V(a, c, null, b, d);
+ return c;
+ },
+ forEach: function forEach(a, b, d) {
+ if (null == a) return a;
+ b = Q(null, null, b, d);
+ U(a, ea, b);
+ R(b);
+ },
+ count: function count(a) {
+ return U(a, function () {
+ return null;
+ }, null);
+ },
+ toArray: function toArray(a) {
+ var b = [];
+ V(a, b, null, function (a) {
+ return a;
+ });
+ return b;
+ },
+ only: function only(a) {
+ N(a) ? void 0 : B("143");
+ return a;
+ }
+ },
+ createRef: function createRef() {
+ return {
+ current: null
+ };
+ },
+ Component: E,
+ PureComponent: G,
+ createContext: function createContext(a, b) {
+ void 0 === b && (b = null);
+ a = {
+ $$typeof: w,
+ _calculateChangedBits: b,
+ _currentValue: a,
+ _currentValue2: a,
+ _threadCount: 0,
+ Provider: null,
+ Consumer: null
+ };
+ a.Provider = {
+ $$typeof: v,
+ _context: a
+ };
+ return a.Consumer = a;
+ },
+ forwardRef: function forwardRef(a) {
+ return {
+ $$typeof: y,
+ render: a
+ };
+ },
+ lazy: function lazy(a) {
+ return {
+ $$typeof: ba,
+ _ctor: a,
+ _status: -1,
+ _result: null
+ };
+ },
+ memo: function memo(a, b) {
+ return {
+ $$typeof: aa,
+ type: a,
+ compare: void 0 === b ? null : b
+ };
+ },
+ useCallback: function useCallback(a, b) {
+ return W().useCallback(a, b);
+ },
+ useContext: function useContext(a, b) {
+ return W().useContext(a, b);
+ },
+ useEffect: function useEffect(a, b) {
+ return W().useEffect(a, b);
+ },
+ useImperativeHandle: function useImperativeHandle(a, b, d) {
+ return W().useImperativeHandle(a, b, d);
+ },
+ useDebugValue: function useDebugValue() {},
+ useLayoutEffect: function useLayoutEffect(a, b) {
+ return W().useLayoutEffect(a, b);
+ },
+ useMemo: function useMemo(a, b) {
+ return W().useMemo(a, b);
+ },
+ useReducer: function useReducer(a, b, d) {
+ return W().useReducer(a, b, d);
+ },
+ useRef: function useRef(a) {
+ return W().useRef(a);
+ },
+ useState: function useState(a) {
+ return W().useState(a);
+ },
+ Fragment: r,
+ StrictMode: t,
+ Suspense: z,
+ createElement: M,
+ cloneElement: function cloneElement(a, b, d) {
+ null === a || void 0 === a ? B("267", a) : void 0;
+ var c = void 0,
+ e = 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) && (e[c] = void 0 === b[c] && void 0 !== l ? l[c] : b[c]);
+ }
+ }
+
+ c = arguments.length - 2;
+ if (1 === c) e.children = d;else if (1 < c) {
+ l = Array(c);
+
+ for (var m = 0; m < c; m++) {
+ l[m] = arguments[m + 2];
+ }
+
+ e.children = l;
+ }
+ return {
+ $$typeof: p,
+ type: a.type,
+ key: g,
+ ref: h,
+ props: e,
+ _owner: f
+ };
+ },
+ createFactory: function createFactory(a) {
+ var b = M.bind(null, a);
+ b.type = a;
+ return b;
+ },
+ isValidElement: N,
+ version: "16.8.3",
+ unstable_ConcurrentMode: x,
+ unstable_Profiler: u,
+ __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: {
+ ReactCurrentDispatcher: I,
+ ReactCurrentOwner: J,
+ assign: k
+ }
+ },
+ Y = {
+ default: X
+ },
+ Z = Y && X || Y;
+ module.exports = Z.default || Z;
+},12,[13],"node_modules\\react\\cjs\\react.production.min.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ /*
+ object-assign
+ (c) Sindre Sorhus
+ @license MIT
+ */
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+ var hasOwnProperty = Object.prototype.hasOwnProperty;
+ var propIsEnumerable = Object.prototype.propertyIsEnumerable;
+
+ function toObject(val) {
+ if (val === null || val === undefined) {
+ throw new TypeError('Object.assign cannot be called with null or undefined');
+ }
+
+ return Object(val);
+ }
+
+ function shouldUseNative() {
+ try {
+ if (!Object.assign) {
+ return false;
+ }
+
+ var test1 = new String('abc');
+ test1[5] = 'de';
+
+ if (Object.getOwnPropertyNames(test1)[0] === '5') {
+ return false;
+ }
+
+ var test2 = {};
+
+ for (var i = 0; i < 10; i++) {
+ test2['_' + String.fromCharCode(i)] = i;
+ }
+
+ var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
+ return test2[n];
+ });
+
+ if (order2.join('') !== '0123456789') {
+ return false;
+ }
+
+ var test3 = {};
+ 'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
+ test3[letter] = letter;
+ });
+
+ if (Object.keys(_extends({}, test3)).join('') !== 'abcdefghijklmnopqrst') {
+ return false;
+ }
+
+ return true;
+ } catch (err) {
+ return false;
+ }
+ }
+
+ module.exports = shouldUseNative() ? Object.assign : function (target, source) {
+ var from;
+ var to = toObject(target);
+ var symbols;
+
+ for (var s = 1; s < arguments.length; s++) {
+ from = Object(arguments[s]);
+
+ for (var key in from) {
+ if (hasOwnProperty.call(from, key)) {
+ to[key] = from[key];
+ }
+ }
+
+ if (getOwnPropertySymbols) {
+ symbols = getOwnPropertySymbols(from);
+
+ for (var i = 0; i < symbols.length; i++) {
+ if (propIsEnumerable.call(from, symbols[i])) {
+ to[symbols[i]] = from[symbols[i]];
+ }
+ }
+ }
+ }
+
+ return to;
+ };
+},13,[14],"node_modules\\object-assign\\index.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ function _extends() {
+ module.exports = _extends = Object.assign || function (target) {
+ for (var i = 1; i < arguments.length; i++) {
+ var source = arguments[i];
+
+ for (var key in source) {
+ if (Object.prototype.hasOwnProperty.call(source, key)) {
+ target[key] = source[key];
+ }
+ }
+ }
+
+ return target;
+ };
+
+ return _extends.apply(this, arguments);
+ }
+
+ module.exports = _extends;
+},14,[],"node_modules\\@babel\\runtime\\helpers\\extends.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ /** @license React v16.8.3
+ * react.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+ 'use strict';
+
+ if (process.env.NODE_ENV !== "production") {
+ (function () {
+ 'use strict';
+
+ var _assign = _$$_REQUIRE(_dependencyMap[0], "object-assign");
+
+ var checkPropTypes = _$$_REQUIRE(_dependencyMap[1], "prop-types/checkPropTypes");
+
+ var ReactVersion = '16.8.3';
+ var hasSymbol = typeof Symbol === 'function' && (typeof Symbol === "function" ? Symbol.for : "@@for");
+ var REACT_ELEMENT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.element') : 0xeac7;
+ var REACT_PORTAL_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.portal') : 0xeaca;
+ var REACT_FRAGMENT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.fragment') : 0xeacb;
+ var REACT_STRICT_MODE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.strict_mode') : 0xeacc;
+ var REACT_PROFILER_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.profiler') : 0xead2;
+ var REACT_PROVIDER_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.provider') : 0xeacd;
+ var REACT_CONTEXT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.context') : 0xeace;
+ var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.concurrent_mode') : 0xeacf;
+ var REACT_FORWARD_REF_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.forward_ref') : 0xead0;
+ var REACT_SUSPENSE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.suspense') : 0xead1;
+ var REACT_MEMO_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.memo') : 0xead3;
+ var REACT_LAZY_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.lazy') : 0xead4;
+ var MAYBE_ITERATOR_SYMBOL = typeof Symbol === 'function' && (typeof Symbol === "function" ? Symbol.iterator : "@@iterator");
+ var FAUX_ITERATOR_SYMBOL = '@@iterator';
+
+ function getIteratorFn(maybeIterable) {
+ if (maybeIterable === null || typeof maybeIterable !== 'object') {
+ return null;
+ }
+
+ var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+ if (typeof maybeIterator === 'function') {
+ return maybeIterator;
+ }
+
+ return null;
+ }
+
+ var validateFormat = function validateFormat() {};
+
+ {
+ 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 = void 0;
+
+ 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;
+ }
+ }
+
+ var lowPriorityWarning = function lowPriorityWarning() {};
+
+ {
+ var printWarning = function printWarning(format) {
+ for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+ args[_key - 1] = arguments[_key];
+ }
+
+ var argIndex = 0;
+ var message = 'Warning: ' + format.replace(/%s/g, function () {
+ return args[argIndex++];
+ });
+
+ if (typeof console !== 'undefined') {
+ console.warn(message);
+ }
+
+ try {
+ throw new Error(message);
+ } catch (x) {}
+ };
+
+ lowPriorityWarning = function lowPriorityWarning(condition, format) {
+ if (format === undefined) {
+ throw new Error('`lowPriorityWarning(condition, format, ...args)` requires a warning ' + 'message argument');
+ }
+
+ if (!condition) {
+ for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
+ args[_key2 - 2] = arguments[_key2];
+ }
+
+ printWarning.apply(undefined, [format].concat(args));
+ }
+ };
+ }
+ var lowPriorityWarning$1 = lowPriorityWarning;
+
+ var warningWithoutStack = function warningWithoutStack() {};
+
+ {
+ warningWithoutStack = function warningWithoutStack(condition, format) {
+ for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+ args[_key - 2] = arguments[_key];
+ }
+
+ if (format === undefined) {
+ throw new Error('`warningWithoutStack(condition, format, ...args)` requires a warning ' + 'message argument');
+ }
+
+ if (args.length > 8) {
+ throw new Error('warningWithoutStack() currently supports at most 8 arguments.');
+ }
+
+ if (condition) {
+ return;
+ }
+
+ if (typeof console !== 'undefined') {
+ var argsWithFormat = args.map(function (item) {
+ return '' + item;
+ });
+ argsWithFormat.unshift('Warning: ' + format);
+ Function.prototype.apply.call(console.error, console, argsWithFormat);
+ }
+
+ try {
+ var argIndex = 0;
+ var message = 'Warning: ' + format.replace(/%s/g, function () {
+ return args[argIndex++];
+ });
+ throw new Error(message);
+ } catch (x) {}
+ };
+ }
+ var warningWithoutStack$1 = warningWithoutStack;
+ var didWarnStateUpdateForUnmountedComponent = {};
+
+ function warnNoop(publicInstance, callerName) {
+ {
+ var _constructor = publicInstance.constructor;
+ var componentName = _constructor && (_constructor.displayName || _constructor.name) || 'ReactClass';
+ var warningKey = componentName + '.' + callerName;
+
+ if (didWarnStateUpdateForUnmountedComponent[warningKey]) {
+ return;
+ }
+
+ warningWithoutStack$1(false, "Can't call %s on a component that is not yet mounted. " + 'This is a no-op, but it might indicate a bug in your application. ' + 'Instead, assign to `this.state` directly or define a `state = {};` ' + 'class property with the desired state in the %s component.', callerName, componentName);
+ didWarnStateUpdateForUnmountedComponent[warningKey] = true;
+ }
+ }
+
+ var ReactNoopUpdateQueue = {
+ isMounted: function isMounted(publicInstance) {
+ return false;
+ },
+ enqueueForceUpdate: function enqueueForceUpdate(publicInstance, callback, callerName) {
+ warnNoop(publicInstance, 'forceUpdate');
+ },
+ enqueueReplaceState: function enqueueReplaceState(publicInstance, completeState, callback, callerName) {
+ warnNoop(publicInstance, 'replaceState');
+ },
+ enqueueSetState: function enqueueSetState(publicInstance, partialState, callback, callerName) {
+ warnNoop(publicInstance, 'setState');
+ }
+ };
+ var emptyObject = {};
+ {
+ Object.freeze(emptyObject);
+ }
+
+ function Component(props, context, updater) {
+ this.props = props;
+ this.context = context;
+ this.refs = emptyObject;
+ this.updater = updater || ReactNoopUpdateQueue;
+ }
+
+ Component.prototype.isReactComponent = {};
+
+ Component.prototype.setState = function (partialState, callback) {
+ !(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 ReactCurrentDispatcher = {
+ current: null
+ };
+ var ReactCurrentOwner = {
+ current: null
+ };
+ var BEFORE_SLASH_RE = /^(.*)[\\\/]/;
+
+ var describeComponentFrame = function describeComponentFrame(name, source, ownerName) {
+ var sourceInfo = '';
+
+ if (source) {
+ var path = source.fileName;
+ var fileName = path.replace(BEFORE_SLASH_RE, '');
+ {
+ if (/^index\./.test(fileName)) {
+ var match = path.match(BEFORE_SLASH_RE);
+
+ if (match) {
+ var pathBeforeSlash = match[1];
+
+ if (pathBeforeSlash) {
+ var folderName = pathBeforeSlash.replace(BEFORE_SLASH_RE, '');
+ fileName = folderName + '/' + fileName;
+ }
+ }
+ }
+ }
+ sourceInfo = ' (at ' + fileName + ':' + source.lineNumber + ')';
+ } else if (ownerName) {
+ sourceInfo = ' (created by ' + ownerName + ')';
+ }
+
+ return '\n in ' + (name || 'Unknown') + sourceInfo;
+ };
+
+ var Resolved = 1;
+
+ function refineResolvedLazyComponent(lazyComponent) {
+ return lazyComponent._status === Resolved ? lazyComponent._result : null;
+ }
+
+ function getWrappedName(outerType, innerType, wrapperName) {
+ var functionName = innerType.displayName || innerType.name || '';
+ return outerType.displayName || (functionName !== '' ? wrapperName + '(' + functionName + ')' : wrapperName);
+ }
+
+ function getComponentName(type) {
+ if (type == null) {
+ return null;
+ }
+
+ {
+ if (typeof type.tag === 'number') {
+ warningWithoutStack$1(false, 'Received an unexpected object in getComponentName(). ' + 'This is likely a bug in React. Please file an issue.');
+ }
+ }
+
+ if (typeof type === 'function') {
+ return type.displayName || type.name || null;
+ }
+
+ if (typeof type === 'string') {
+ return type;
+ }
+
+ switch (type) {
+ case REACT_CONCURRENT_MODE_TYPE:
+ return 'ConcurrentMode';
+
+ case REACT_FRAGMENT_TYPE:
+ return 'Fragment';
+
+ case REACT_PORTAL_TYPE:
+ return 'Portal';
+
+ case REACT_PROFILER_TYPE:
+ return 'Profiler';
+
+ case REACT_STRICT_MODE_TYPE:
+ return 'StrictMode';
+
+ case REACT_SUSPENSE_TYPE:
+ return 'Suspense';
+ }
+
+ if (typeof type === 'object') {
+ switch (type.$$typeof) {
+ case REACT_CONTEXT_TYPE:
+ return 'Context.Consumer';
+
+ case REACT_PROVIDER_TYPE:
+ return 'Context.Provider';
+
+ case REACT_FORWARD_REF_TYPE:
+ return getWrappedName(type, type.render, 'ForwardRef');
+
+ case REACT_MEMO_TYPE:
+ return getComponentName(type.type);
+
+ case REACT_LAZY_TYPE:
+ {
+ var thenable = type;
+ var resolvedThenable = refineResolvedLazyComponent(thenable);
+
+ if (resolvedThenable) {
+ return getComponentName(resolvedThenable);
+ }
+ }
+ }
+ }
+
+ return null;
+ }
+
+ var ReactDebugCurrentFrame = {};
+ var currentlyValidatingElement = null;
+
+ function setCurrentlyValidatingElement(element) {
+ {
+ currentlyValidatingElement = element;
+ }
+ }
+
+ {
+ ReactDebugCurrentFrame.getCurrentStack = null;
+
+ ReactDebugCurrentFrame.getStackAddendum = function () {
+ var stack = '';
+
+ if (currentlyValidatingElement) {
+ var name = getComponentName(currentlyValidatingElement.type);
+ var owner = currentlyValidatingElement._owner;
+ stack += describeComponentFrame(name, currentlyValidatingElement._source, owner && getComponentName(owner.type));
+ }
+
+ var impl = ReactDebugCurrentFrame.getCurrentStack;
+
+ if (impl) {
+ stack += impl() || '';
+ }
+
+ return stack;
+ };
+ }
+ var ReactSharedInternals = {
+ ReactCurrentDispatcher: ReactCurrentDispatcher,
+ ReactCurrentOwner: ReactCurrentOwner,
+ assign: _assign
+ };
+ {
+ _assign(ReactSharedInternals, {
+ ReactDebugCurrentFrame: ReactDebugCurrentFrame,
+ ReactComponentTreeHook: {}
+ });
+ }
+ var warning = warningWithoutStack$1;
+ {
+ warning = function warning(condition, format) {
+ if (condition) {
+ return;
+ }
+
+ var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+ var stack = ReactDebugCurrentFrame.getStackAddendum();
+
+ for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+ args[_key - 2] = arguments[_key];
+ }
+
+ warningWithoutStack$1.apply(undefined, [false, format + '%s'].concat(args, [stack]));
+ };
+ }
+ var warning$1 = warning;
+ var hasOwnProperty = Object.prototype.hasOwnProperty;
+ var RESERVED_PROPS = {
+ key: true,
+ ref: true,
+ __self: true,
+ __source: true
+ };
+ var specialPropKeyWarningShown = void 0;
+ var specialPropRefWarningShown = void 0;
+
+ function hasValidRef(config) {
+ {
+ if (hasOwnProperty.call(config, 'ref')) {
+ var getter = Object.getOwnPropertyDescriptor(config, 'ref').get;
+
+ if (getter && getter.isReactWarning) {
+ return false;
+ }
+ }
+ }
+ return config.ref !== undefined;
+ }
+
+ function hasValidKey(config) {
+ {
+ if (hasOwnProperty.call(config, 'key')) {
+ var getter = Object.getOwnPropertyDescriptor(config, 'key').get;
+
+ if (getter && getter.isReactWarning) {
+ return false;
+ }
+ }
+ }
+ return config.key !== undefined;
+ }
+
+ function defineKeyPropWarningGetter(props, displayName) {
+ var warnAboutAccessingKey = function warnAboutAccessingKey() {
+ if (!specialPropKeyWarningShown) {
+ specialPropKeyWarningShown = true;
+ warningWithoutStack$1(false, '%s: `key` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://fb.me/react-special-props)', displayName);
+ }
+ };
+
+ warnAboutAccessingKey.isReactWarning = true;
+ Object.defineProperty(props, 'key', {
+ get: warnAboutAccessingKey,
+ configurable: true
+ });
+ }
+
+ function defineRefPropWarningGetter(props, displayName) {
+ var warnAboutAccessingRef = function warnAboutAccessingRef() {
+ if (!specialPropRefWarningShown) {
+ specialPropRefWarningShown = true;
+ warningWithoutStack$1(false, '%s: `ref` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://fb.me/react-special-props)', displayName);
+ }
+ };
+
+ warnAboutAccessingRef.isReactWarning = true;
+ Object.defineProperty(props, 'ref', {
+ get: warnAboutAccessingRef,
+ configurable: true
+ });
+ }
+
+ var ReactElement = function ReactElement(type, key, ref, self, source, owner, props) {
+ var element = {
+ $$typeof: REACT_ELEMENT_TYPE,
+ type: type,
+ key: key,
+ ref: ref,
+ props: props,
+ _owner: owner
+ };
+ {
+ element._store = {};
+ Object.defineProperty(element._store, 'validated', {
+ configurable: false,
+ enumerable: false,
+ writable: true,
+ value: false
+ });
+ Object.defineProperty(element, '_self', {
+ configurable: false,
+ enumerable: false,
+ writable: false,
+ value: self
+ });
+ Object.defineProperty(element, '_source', {
+ configurable: false,
+ enumerable: false,
+ writable: false,
+ value: source
+ });
+
+ if (Object.freeze) {
+ Object.freeze(element.props);
+ Object.freeze(element);
+ }
+ }
+ return element;
+ };
+
+ function createElement(type, config, children) {
+ var propName = void 0;
+ var props = {};
+ var key = null;
+ var ref = null;
+ var self = null;
+ var source = null;
+
+ if (config != null) {
+ if (hasValidRef(config)) {
+ ref = config.ref;
+ }
+
+ if (hasValidKey(config)) {
+ key = '' + config.key;
+ }
+
+ self = config.__self === undefined ? null : config.__self;
+ source = config.__source === undefined ? null : config.__source;
+
+ for (propName in config) {
+ if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
+ props[propName] = config[propName];
+ }
+ }
+ }
+
+ var childrenLength = arguments.length - 2;
+
+ if (childrenLength === 1) {
+ props.children = children;
+ } else if (childrenLength > 1) {
+ var childArray = Array(childrenLength);
+
+ for (var i = 0; i < childrenLength; i++) {
+ childArray[i] = arguments[i + 2];
+ }
+
+ {
+ if (Object.freeze) {
+ Object.freeze(childArray);
+ }
+ }
+ props.children = childArray;
+ }
+
+ if (type && type.defaultProps) {
+ var defaultProps = type.defaultProps;
+
+ for (propName in defaultProps) {
+ if (props[propName] === undefined) {
+ props[propName] = defaultProps[propName];
+ }
+ }
+ }
+
+ {
+ if (key || ref) {
+ var displayName = typeof type === 'function' ? type.displayName || type.name || 'Unknown' : type;
+
+ if (key) {
+ defineKeyPropWarningGetter(props, displayName);
+ }
+
+ if (ref) {
+ defineRefPropWarningGetter(props, displayName);
+ }
+ }
+ }
+ return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);
+ }
+
+ function cloneAndReplaceKey(oldElement, newKey) {
+ var newElement = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props);
+ return newElement;
+ }
+
+ function cloneElement(element, config, children) {
+ !!(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 SEPARATOR = '.';
+ var SUBSEPARATOR = ':';
+
+ function escape(key) {
+ var escapeRegex = /[=:]/g;
+ var escaperLookup = {
+ '=': '=0',
+ ':': '=2'
+ };
+ var escapedString = ('' + key).replace(escapeRegex, function (match) {
+ return escaperLookup[match];
+ });
+ return '$' + escapedString;
+ }
+
+ var didWarnAboutMaps = false;
+ var userProvidedKeyEscapeRegex = /\/+/g;
+
+ function escapeUserProvidedKey(text) {
+ return ('' + text).replace(userProvidedKeyEscapeRegex, '$&/');
+ }
+
+ var POOL_SIZE = 10;
+ var traverseContextPool = [];
+
+ function getPooledTraverseContext(mapResult, keyPrefix, mapFunction, mapContext) {
+ if (traverseContextPool.length) {
+ var traverseContext = traverseContextPool.pop();
+ traverseContext.result = mapResult;
+ traverseContext.keyPrefix = keyPrefix;
+ traverseContext.func = mapFunction;
+ traverseContext.context = mapContext;
+ traverseContext.count = 0;
+ return traverseContext;
+ } else {
+ return {
+ result: mapResult,
+ keyPrefix: keyPrefix,
+ func: mapFunction,
+ context: mapContext,
+ count: 0
+ };
+ }
+ }
+
+ function releaseTraverseContext(traverseContext) {
+ traverseContext.result = null;
+ traverseContext.keyPrefix = null;
+ traverseContext.func = null;
+ traverseContext.context = null;
+ traverseContext.count = 0;
+
+ if (traverseContextPool.length < POOL_SIZE) {
+ traverseContextPool.push(traverseContext);
+ }
+ }
+
+ function traverseAllChildrenImpl(children, nameSoFar, callback, traverseContext) {
+ var type = typeof children;
+
+ if (type === 'undefined' || type === 'boolean') {
+ children = null;
+ }
+
+ var invokeCallback = false;
+
+ if (children === null) {
+ invokeCallback = true;
+ } else {
+ switch (type) {
+ case 'string':
+ case 'number':
+ invokeCallback = true;
+ break;
+
+ case 'object':
+ switch (children.$$typeof) {
+ case REACT_ELEMENT_TYPE:
+ case REACT_PORTAL_TYPE:
+ invokeCallback = true;
+ }
+
+ }
+ }
+
+ if (invokeCallback) {
+ callback(traverseContext, children, nameSoFar === '' ? SEPARATOR + getComponentKey(children, 0) : nameSoFar);
+ return 1;
+ }
+
+ var child = void 0;
+ var nextName = void 0;
+ var subtreeCount = 0;
+ var nextNamePrefix = nameSoFar === '' ? SEPARATOR : nameSoFar + SUBSEPARATOR;
+
+ if (Array.isArray(children)) {
+ for (var i = 0; i < children.length; i++) {
+ child = children[i];
+ nextName = nextNamePrefix + getComponentKey(child, i);
+ subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);
+ }
+ } else {
+ var iteratorFn = getIteratorFn(children);
+
+ if (typeof iteratorFn === 'function') {
+ {
+ if (iteratorFn === children.entries) {
+ !didWarnAboutMaps ? warning$1(false, 'Using Maps as children is unsupported and will likely yield ' + 'unexpected results. Convert it to a sequence/iterable of keyed ' + 'ReactElements instead.') : void 0;
+ didWarnAboutMaps = true;
+ }
+ }
+ var iterator = iteratorFn.call(children);
+ var step = void 0;
+ var ii = 0;
+
+ while (!(step = iterator.next()).done) {
+ child = step.value;
+ nextName = nextNamePrefix + getComponentKey(child, ii++);
+ subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);
+ }
+ } else if (type === 'object') {
+ var addendum = '';
+ {
+ addendum = ' If you meant to render a collection of children, use an array ' + 'instead.' + ReactDebugCurrentFrame.getStackAddendum();
+ }
+ var childrenString = '' + children;
+ 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, function (c) {
+ return c;
+ });
+ } else if (mappedChild != null) {
+ if (isValidElement(mappedChild)) {
+ mappedChild = cloneAndReplaceKey(mappedChild, keyPrefix + (mappedChild.key && (!child || child.key !== mappedChild.key) ? escapeUserProvidedKey(mappedChild.key) + '/' : '') + childKey);
+ }
+
+ result.push(mappedChild);
+ }
+ }
+
+ function mapIntoWithKeyPrefixInternal(children, array, prefix, func, context) {
+ var escapedPrefix = '';
+
+ if (prefix != null) {
+ escapedPrefix = escapeUserProvidedKey(prefix) + '/';
+ }
+
+ var traverseContext = getPooledTraverseContext(array, escapedPrefix, func, context);
+ traverseAllChildren(children, mapSingleChildIntoContext, traverseContext);
+ releaseTraverseContext(traverseContext);
+ }
+
+ function mapChildren(children, func, context) {
+ if (children == null) {
+ return children;
+ }
+
+ var result = [];
+ mapIntoWithKeyPrefixInternal(children, result, null, func, context);
+ return result;
+ }
+
+ function countChildren(children) {
+ return traverseAllChildren(children, function () {
+ return null;
+ }, null);
+ }
+
+ function toArray(children) {
+ var result = [];
+ mapIntoWithKeyPrefixInternal(children, result, null, function (child) {
+ return child;
+ });
+ return result;
+ }
+
+ function onlyChild(children) {
+ !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') ? warningWithoutStack$1(false, 'createContext: Expected the optional second argument to be a ' + 'function. Instead received: %s', calculateChangedBits) : void 0;
+ }
+ }
+
+ var context = {
+ $$typeof: REACT_CONTEXT_TYPE,
+ _calculateChangedBits: calculateChangedBits,
+ _currentValue: defaultValue,
+ _currentValue2: defaultValue,
+ _threadCount: 0,
+ Provider: null,
+ Consumer: null
+ };
+ context.Provider = {
+ $$typeof: REACT_PROVIDER_TYPE,
+ _context: context
+ };
+ var hasWarnedAboutUsingNestedContextConsumers = false;
+ var hasWarnedAboutUsingConsumerProvider = false;
+ {
+ var Consumer = {
+ $$typeof: REACT_CONTEXT_TYPE,
+ _context: context,
+ _calculateChangedBits: context._calculateChangedBits
+ };
+ Object.defineProperties(Consumer, {
+ Provider: {
+ get: function get() {
+ if (!hasWarnedAboutUsingConsumerProvider) {
+ hasWarnedAboutUsingConsumerProvider = true;
+ warning$1(false, 'Rendering is not supported and will be removed in ' + 'a future major release. Did you mean to render instead?');
+ }
+
+ return context.Provider;
+ },
+ set: function set(_Provider) {
+ context.Provider = _Provider;
+ }
+ },
+ _currentValue: {
+ get: function get() {
+ return context._currentValue;
+ },
+ set: function set(_currentValue) {
+ context._currentValue = _currentValue;
+ }
+ },
+ _currentValue2: {
+ get: function get() {
+ return context._currentValue2;
+ },
+ set: function set(_currentValue2) {
+ context._currentValue2 = _currentValue2;
+ }
+ },
+ _threadCount: {
+ get: function get() {
+ return context._threadCount;
+ },
+ set: function set(_threadCount) {
+ context._threadCount = _threadCount;
+ }
+ },
+ Consumer: {
+ get: function get() {
+ if (!hasWarnedAboutUsingNestedContextConsumers) {
+ hasWarnedAboutUsingNestedContextConsumers = true;
+ warning$1(false, 'Rendering is not supported and will be removed in ' + 'a future major release. Did you mean to render instead?');
+ }
+
+ return context.Consumer;
+ }
+ }
+ });
+ context.Consumer = Consumer;
+ }
+ {
+ context._currentRenderer = null;
+ context._currentRenderer2 = null;
+ }
+ return context;
+ }
+
+ function lazy(ctor) {
+ var lazyType = {
+ $$typeof: REACT_LAZY_TYPE,
+ _ctor: ctor,
+ _status: -1,
+ _result: null
+ };
+ {
+ var defaultProps = void 0;
+ var propTypes = void 0;
+ Object.defineProperties(lazyType, {
+ defaultProps: {
+ configurable: true,
+ get: function get() {
+ return defaultProps;
+ },
+ set: function set(newDefaultProps) {
+ warning$1(false, 'React.lazy(...): It is not supported to assign `defaultProps` to ' + 'a lazy component import. Either specify them where the component ' + 'is defined, or create a wrapping component around it.');
+ defaultProps = newDefaultProps;
+ Object.defineProperty(lazyType, 'defaultProps', {
+ enumerable: true
+ });
+ }
+ },
+ propTypes: {
+ configurable: true,
+ get: function get() {
+ return propTypes;
+ },
+ set: function set(newPropTypes) {
+ warning$1(false, 'React.lazy(...): It is not supported to assign `propTypes` to ' + 'a lazy component import. Either specify them where the component ' + 'is defined, or create a wrapping component around it.');
+ propTypes = newPropTypes;
+ Object.defineProperty(lazyType, 'propTypes', {
+ enumerable: true
+ });
+ }
+ }
+ });
+ }
+ return lazyType;
+ }
+
+ function forwardRef(render) {
+ {
+ if (render != null && render.$$typeof === REACT_MEMO_TYPE) {
+ warningWithoutStack$1(false, 'forwardRef requires a render function but received a `memo` ' + 'component. Instead of forwardRef(memo(...)), use ' + 'memo(forwardRef(...)).');
+ } else if (typeof render !== 'function') {
+ warningWithoutStack$1(false, 'forwardRef requires a render function but was given %s.', render === null ? 'null' : typeof render);
+ } else {
+ !(render.length === 0 || render.length === 2) ? warningWithoutStack$1(false, 'forwardRef render functions accept exactly two parameters: props and ref. %s', render.length === 1 ? 'Did you forget to use the ref parameter?' : 'Any additional parameter will be undefined.') : void 0;
+ }
+
+ if (render != null) {
+ !(render.defaultProps == null && render.propTypes == null) ? warningWithoutStack$1(false, 'forwardRef render functions do not support propTypes or defaultProps. ' + 'Did you accidentally pass a React component?') : void 0;
+ }
+ }
+ return {
+ $$typeof: REACT_FORWARD_REF_TYPE,
+ render: render
+ };
+ }
+
+ function isValidElementType(type) {
+ return typeof type === 'string' || typeof type === 'function' || type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || typeof type === 'object' && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE);
+ }
+
+ function memo(type, compare) {
+ {
+ if (!isValidElementType(type)) {
+ warningWithoutStack$1(false, 'memo: The first argument must be a component. Instead ' + 'received: %s', type === null ? 'null' : typeof type);
+ }
+ }
+ return {
+ $$typeof: REACT_MEMO_TYPE,
+ type: type,
+ compare: compare === undefined ? null : compare
+ };
+ }
+
+ function resolveDispatcher() {
+ var dispatcher = ReactCurrentDispatcher.current;
+ !(dispatcher !== null) ? invariant(false, 'Hooks can only be called inside the body of a function component. (https://fb.me/react-invalid-hook-call)') : void 0;
+ return dispatcher;
+ }
+
+ function useContext(Context, unstable_observedBits) {
+ var dispatcher = resolveDispatcher();
+ {
+ !(unstable_observedBits === undefined) ? warning$1(false, 'useContext() second argument is reserved for future ' + 'use in React. Passing it is not supported. ' + 'You passed: %s.%s', unstable_observedBits, typeof unstable_observedBits === 'number' && Array.isArray(arguments[2]) ? '\n\nDid you call array.map(useContext)? ' + 'Calling Hooks inside a loop is not supported. ' + 'Learn more at https://fb.me/rules-of-hooks' : '') : void 0;
+
+ if (Context._context !== undefined) {
+ var realContext = Context._context;
+
+ if (realContext.Consumer === Context) {
+ warning$1(false, 'Calling useContext(Context.Consumer) is not supported, may cause bugs, and will be ' + 'removed in a future major release. Did you mean to call useContext(Context) instead?');
+ } else if (realContext.Provider === Context) {
+ warning$1(false, 'Calling useContext(Context.Provider) is not supported. ' + 'Did you mean to call useContext(Context) instead?');
+ }
+ }
+ }
+ return dispatcher.useContext(Context, unstable_observedBits);
+ }
+
+ function useState(initialState) {
+ var dispatcher = resolveDispatcher();
+ return dispatcher.useState(initialState);
+ }
+
+ function useReducer(reducer, initialArg, init) {
+ var dispatcher = resolveDispatcher();
+ return dispatcher.useReducer(reducer, initialArg, init);
+ }
+
+ function useRef(initialValue) {
+ var dispatcher = resolveDispatcher();
+ return dispatcher.useRef(initialValue);
+ }
+
+ function useEffect(create, inputs) {
+ var dispatcher = resolveDispatcher();
+ return dispatcher.useEffect(create, inputs);
+ }
+
+ function useLayoutEffect(create, inputs) {
+ var dispatcher = resolveDispatcher();
+ return dispatcher.useLayoutEffect(create, inputs);
+ }
+
+ function useCallback(callback, inputs) {
+ var dispatcher = resolveDispatcher();
+ return dispatcher.useCallback(callback, inputs);
+ }
+
+ function useMemo(create, inputs) {
+ var dispatcher = resolveDispatcher();
+ return dispatcher.useMemo(create, inputs);
+ }
+
+ function useImperativeHandle(ref, create, inputs) {
+ var dispatcher = resolveDispatcher();
+ return dispatcher.useImperativeHandle(ref, create, inputs);
+ }
+
+ function useDebugValue(value, formatterFn) {
+ {
+ var dispatcher = resolveDispatcher();
+ return dispatcher.useDebugValue(value, formatterFn);
+ }
+ }
+
+ var propTypesMisspellWarningShown = void 0;
+ {
+ propTypesMisspellWarningShown = false;
+ }
+
+ function getDeclarationErrorAddendum() {
+ if (ReactCurrentOwner.current) {
+ var name = getComponentName(ReactCurrentOwner.current.type);
+
+ if (name) {
+ return '\n\nCheck the render method of `' + name + '`.';
+ }
+ }
+
+ return '';
+ }
+
+ function getSourceInfoErrorAddendum(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.type) + '.';
+ }
+
+ setCurrentlyValidatingElement(element);
+ {
+ warning$1(false, 'Each child in a list should have a unique "key" prop.' + '%s%s See https://fb.me/react-warning-keys for more information.', currentComponentErrorInfo, childOwner);
+ }
+ setCurrentlyValidatingElement(null);
+ }
+
+ function validateChildKeys(node, parentType) {
+ if (typeof node !== 'object') {
+ return;
+ }
+
+ if (Array.isArray(node)) {
+ for (var i = 0; i < node.length; i++) {
+ var child = node[i];
+
+ if (isValidElement(child)) {
+ validateExplicitKey(child, parentType);
+ }
+ }
+ } else if (isValidElement(node)) {
+ if (node._store) {
+ node._store.validated = true;
+ }
+ } else if (node) {
+ var iteratorFn = getIteratorFn(node);
+
+ if (typeof iteratorFn === 'function') {
+ if (iteratorFn !== node.entries) {
+ var iterator = iteratorFn.call(node);
+ var step = void 0;
+
+ while (!(step = iterator.next()).done) {
+ if (isValidElement(step.value)) {
+ validateExplicitKey(step.value, parentType);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ function validatePropTypes(element) {
+ var type = element.type;
+
+ if (type === null || type === undefined || typeof type === 'string') {
+ return;
+ }
+
+ var name = getComponentName(type);
+ var propTypes = void 0;
+
+ if (typeof type === 'function') {
+ propTypes = type.propTypes;
+ } else if (typeof type === 'object' && (type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_MEMO_TYPE)) {
+ propTypes = type.propTypes;
+ } else {
+ return;
+ }
+
+ if (propTypes) {
+ setCurrentlyValidatingElement(element);
+ checkPropTypes(propTypes, element.props, 'prop', name, ReactDebugCurrentFrame.getStackAddendum);
+ setCurrentlyValidatingElement(null);
+ } else if (type.PropTypes !== undefined && !propTypesMisspellWarningShown) {
+ propTypesMisspellWarningShown = true;
+ warningWithoutStack$1(false, 'Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?', name || 'Unknown');
+ }
+
+ if (typeof type.getDefaultProps === 'function') {
+ !type.getDefaultProps.isReactClassApproved ? warningWithoutStack$1(false, 'getDefaultProps is only used on classic React.createClass ' + 'definitions. Use a static property named `defaultProps` instead.') : void 0;
+ }
+ }
+
+ function validateFragmentProps(fragment) {
+ setCurrentlyValidatingElement(fragment);
+ var keys = Object.keys(fragment.props);
+
+ for (var i = 0; i < keys.length; i++) {
+ var key = keys[i];
+
+ if (key !== 'children' && key !== 'key') {
+ warning$1(false, 'Invalid prop `%s` supplied to `React.Fragment`. ' + 'React.Fragment can only have `key` and `children` props.', key);
+ break;
+ }
+ }
+
+ if (fragment.ref !== null) {
+ warning$1(false, 'Invalid attribute `ref` supplied to `React.Fragment`.');
+ }
+
+ setCurrentlyValidatingElement(null);
+ }
+
+ function 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();
+ }
+
+ var typeString = void 0;
+
+ if (type === null) {
+ typeString = 'null';
+ } else if (Array.isArray(type)) {
+ typeString = 'array';
+ } else if (type !== undefined && type.$$typeof === REACT_ELEMENT_TYPE) {
+ typeString = '<' + (getComponentName(type.type) || 'Unknown') + ' />';
+ info = ' Did you accidentally export a JSX literal instead of a component?';
+ } else {
+ typeString = typeof type;
+ }
+
+ warning$1(false, 'React.createElement: type is invalid -- expected a string (for ' + 'built-in components) or a class/function (for composite ' + 'components) but got: %s.%s', typeString, info);
+ }
+
+ var element = createElement.apply(this, arguments);
+
+ if (element == null) {
+ return element;
+ }
+
+ if (validType) {
+ for (var i = 2; i < arguments.length; i++) {
+ validateChildKeys(arguments[i], type);
+ }
+ }
+
+ if (type === REACT_FRAGMENT_TYPE) {
+ validateFragmentProps(element);
+ } else {
+ validatePropTypes(element);
+ }
+
+ return element;
+ }
+
+ function createFactoryWithValidation(type) {
+ var validatedFactory = createElementWithValidation.bind(null, type);
+ validatedFactory.type = type;
+ {
+ Object.defineProperty(validatedFactory, 'type', {
+ enumerable: false,
+ get: function get() {
+ lowPriorityWarning$1(false, 'Factory.type is deprecated. Access the class directly ' + 'before passing it to createFactory.');
+ Object.defineProperty(this, 'type', {
+ value: type
+ });
+ return type;
+ }
+ });
+ }
+ return validatedFactory;
+ }
+
+ function cloneElementWithValidation(element, props, children) {
+ var newElement = cloneElement.apply(this, arguments);
+
+ for (var i = 2; i < arguments.length; i++) {
+ validateChildKeys(arguments[i], newElement.type);
+ }
+
+ validatePropTypes(newElement);
+ return newElement;
+ }
+
+ var enableStableConcurrentModeAPIs = false;
+ var React = {
+ Children: {
+ map: mapChildren,
+ forEach: forEachChildren,
+ count: countChildren,
+ toArray: toArray,
+ only: onlyChild
+ },
+ createRef: createRef,
+ Component: Component,
+ PureComponent: PureComponent,
+ createContext: createContext,
+ forwardRef: forwardRef,
+ lazy: lazy,
+ memo: memo,
+ useCallback: useCallback,
+ useContext: useContext,
+ useEffect: useEffect,
+ useImperativeHandle: useImperativeHandle,
+ useDebugValue: useDebugValue,
+ useLayoutEffect: useLayoutEffect,
+ useMemo: useMemo,
+ useReducer: useReducer,
+ useRef: useRef,
+ useState: useState,
+ Fragment: REACT_FRAGMENT_TYPE,
+ StrictMode: REACT_STRICT_MODE_TYPE,
+ Suspense: REACT_SUSPENSE_TYPE,
+ createElement: createElementWithValidation,
+ cloneElement: cloneElementWithValidation,
+ createFactory: createFactoryWithValidation,
+ isValidElement: isValidElement,
+ version: ReactVersion,
+ unstable_ConcurrentMode: REACT_CONCURRENT_MODE_TYPE,
+ unstable_Profiler: REACT_PROFILER_TYPE,
+ __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: ReactSharedInternals
+ };
+
+ if (enableStableConcurrentModeAPIs) {
+ React.ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
+ React.Profiler = REACT_PROFILER_TYPE;
+ React.unstable_ConcurrentMode = undefined;
+ React.unstable_Profiler = undefined;
+ }
+
+ var React$2 = Object.freeze({
+ default: React
+ });
+ var React$3 = React$2 && React || React$2;
+ var react = React$3.default || React$3;
+ module.exports = react;
+ })();
+ }
+},15,[13,16],"node_modules\\react\\cjs\\react.development.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var printWarning = function printWarning() {};
+
+ if (process.env.NODE_ENV !== 'production') {
+ var ReactPropTypesSecret = _$$_REQUIRE(_dependencyMap[0], "./lib/ReactPropTypesSecret");
+
+ var loggedTypeFailures = {};
+ var has = Function.call.bind(Object.prototype.hasOwnProperty);
+
+ printWarning = function printWarning(text) {
+ var message = 'Warning: ' + text;
+
+ if (typeof console !== 'undefined') {
+ console.error(message);
+ }
+
+ try {
+ throw new Error(message);
+ } catch (x) {}
+ };
+ }
+
+ function checkPropTypes(typeSpecs, values, location, componentName, getStack) {
+ if (process.env.NODE_ENV !== 'production') {
+ for (var typeSpecName in typeSpecs) {
+ if (has(typeSpecs, typeSpecName)) {
+ var error;
+
+ try {
+ if (typeof typeSpecs[typeSpecName] !== 'function') {
+ var err = Error((componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' + 'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.');
+ err.name = 'Invariant Violation';
+ throw err;
+ }
+
+ error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);
+ } catch (ex) {
+ error = ex;
+ }
+
+ if (error && !(error instanceof Error)) {
+ printWarning((componentName || 'React class') + ': type specification of ' + location + ' `' + typeSpecName + '` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a ' + typeof error + '. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).');
+ }
+
+ if (error instanceof Error && !(error.message in loggedTypeFailures)) {
+ loggedTypeFailures[error.message] = true;
+ var stack = getStack ? getStack() : '';
+ printWarning('Failed ' + location + ' type: ' + error.message + (stack != null ? stack : ''));
+ }
+ }
+ }
+ }
+ }
+
+ checkPropTypes.resetWarningCache = function () {
+ if (process.env.NODE_ENV !== 'production') {
+ loggedTypeFailures = {};
+ }
+ };
+
+ module.exports = checkPropTypes;
+},16,[17],"node_modules\\prop-types\\checkPropTypes.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';
+ module.exports = ReactPropTypesSecret;
+},17,[],"node_modules\\prop-types\\lib\\ReactPropTypesSecret.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var invariant = _$$_REQUIRE(_dependencyMap[0], "invariant");
+
+ var warnOnce = _$$_REQUIRE(_dependencyMap[1], "warnOnce");
+
+ module.exports = {
+ get AccessibilityInfo() {
+ return _$$_REQUIRE(_dependencyMap[2], "AccessibilityInfo");
+ },
+
+ get ActivityIndicator() {
+ return _$$_REQUIRE(_dependencyMap[3], "ActivityIndicator");
+ },
+
+ get ART() {
+ return _$$_REQUIRE(_dependencyMap[4], "ReactNativeART");
+ },
+
+ get Button() {
+ return _$$_REQUIRE(_dependencyMap[5], "Button");
+ },
+
+ get CheckBox() {
+ return _$$_REQUIRE(_dependencyMap[6], "CheckBox");
+ },
+
+ get DatePickerIOS() {
+ return _$$_REQUIRE(_dependencyMap[7], "DatePickerIOS");
+ },
+
+ get DrawerLayoutAndroid() {
+ return _$$_REQUIRE(_dependencyMap[8], "DrawerLayoutAndroid");
+ },
+
+ get FlatList() {
+ return _$$_REQUIRE(_dependencyMap[9], "FlatList");
+ },
+
+ get Image() {
+ return _$$_REQUIRE(_dependencyMap[10], "Image");
+ },
+
+ get ImageBackground() {
+ return _$$_REQUIRE(_dependencyMap[11], "ImageBackground");
+ },
+
+ get ImageEditor() {
+ return _$$_REQUIRE(_dependencyMap[12], "ImageEditor");
+ },
+
+ get ImageStore() {
+ warnOnce('imagestore-deprecation', 'ImageStore is deprecated and will be removed in a future release. ' + 'To get a base64-encoded string from a local image use either of the following third-party libraries:' + "* expo-file-system: `readAsStringAsync(filepath, 'base64')`" + "* react-native-fs: `readFile(filepath, 'base64')`");
+ return _$$_REQUIRE(_dependencyMap[13], "ImageStore");
+ },
+
+ get InputAccessoryView() {
+ return _$$_REQUIRE(_dependencyMap[14], "InputAccessoryView");
+ },
+
+ get KeyboardAvoidingView() {
+ return _$$_REQUIRE(_dependencyMap[15], "KeyboardAvoidingView");
+ },
+
+ get ListView() {
+ warnOnce('listview-deprecation', 'ListView is deprecated and will be removed in a future release. ' + 'See https://fb.me/nolistview for more information');
+ return _$$_REQUIRE(_dependencyMap[16], "ListView");
+ },
+
+ get MaskedViewIOS() {
+ warnOnce('maskedviewios-moved', 'MaskedViewIOS has been extracted from react-native core and will be removed in a future release. ' + "It can now be installed and imported from '@react-native-community/masked-view' instead of 'react-native'. " + 'See https://github.com/react-native-community/react-native-masked-view');
+ return _$$_REQUIRE(_dependencyMap[17], "MaskedViewIOS");
+ },
+
+ get Modal() {
+ return _$$_REQUIRE(_dependencyMap[18], "Modal");
+ },
+
+ 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() {
+ warnOnce('slider-moved', 'Slider has been extracted from react-native core and will be removed in a future release. ' + "It can now be installed and imported from '@react-native-community/slider' instead of 'react-native'. " + 'See https://github.com/react-native-community/react-native-slider');
+ return _$$_REQUIRE(_dependencyMap[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() {
+ warnOnce('swipablelistview-deprecation', 'ListView and SwipeableListView are deprecated and will be removed in a future release. ' + 'See https://fb.me/nolistview for more information');
+ return _$$_REQUIRE(_dependencyMap[33], "SwipeableListView");
+ },
+
+ get Text() {
+ return _$$_REQUIRE(_dependencyMap[34], "Text");
+ },
+
+ get TextInput() {
+ return _$$_REQUIRE(_dependencyMap[35], "TextInput");
+ },
+
+ get ToolbarAndroid() {
+ return _$$_REQUIRE(_dependencyMap[36], "ToolbarAndroid");
+ },
+
+ get Touchable() {
+ return _$$_REQUIRE(_dependencyMap[37], "Touchable");
+ },
+
+ get TouchableHighlight() {
+ return _$$_REQUIRE(_dependencyMap[38], "TouchableHighlight");
+ },
+
+ get TouchableNativeFeedback() {
+ return _$$_REQUIRE(_dependencyMap[39], "TouchableNativeFeedback");
+ },
+
+ get TouchableOpacity() {
+ return _$$_REQUIRE(_dependencyMap[40], "TouchableOpacity");
+ },
+
+ get TouchableWithoutFeedback() {
+ return _$$_REQUIRE(_dependencyMap[41], "TouchableWithoutFeedback");
+ },
+
+ get View() {
+ return _$$_REQUIRE(_dependencyMap[42], "View");
+ },
+
+ get ViewPagerAndroid() {
+ warnOnce('viewpager-moved', 'ViewPagerAndroid has been extracted from react-native core and will be removed in a future release. ' + "It can now be installed and imported from '@react-native-community/viewpager' instead of 'react-native'. " + 'See https://github.com/react-native-community/react-native-viewpager');
+ return _$$_REQUIRE(_dependencyMap[43], "ViewPagerAndroid");
+ },
+
+ get VirtualizedList() {
+ return _$$_REQUIRE(_dependencyMap[44], "VirtualizedList");
+ },
+
+ get WebView() {
+ warnOnce('webview-moved', 'WebView has been extracted from react-native core and will be removed in a future release. ' + "It can now be installed and imported from 'react-native-webview' instead of 'react-native'. " + 'See https://github.com/react-native-community/react-native-webview');
+ return _$$_REQUIRE(_dependencyMap[45], "WebView");
+ },
+
+ get ActionSheetIOS() {
+ return _$$_REQUIRE(_dependencyMap[46], "ActionSheetIOS");
+ },
+
+ get Alert() {
+ return _$$_REQUIRE(_dependencyMap[47], "Alert");
+ },
+
+ get AlertIOS() {
+ warnOnce('alert-ios', 'AlertIOS is deprecated. Use the `Alert` module directly instead.');
+ return _$$_REQUIRE(_dependencyMap[47], "Alert");
+ },
+
+ get AlertMacOS() {
+ return _$$_REQUIRE(_dependencyMap[48], "AlertMacOS");
+ },
+
+ get Animated() {
+ return _$$_REQUIRE(_dependencyMap[49], "Animated");
+ },
+
+ get AppRegistry() {
+ return _$$_REQUIRE(_dependencyMap[50], "AppRegistry");
+ },
+
+ get AppState() {
+ return _$$_REQUIRE(_dependencyMap[51], "AppState");
+ },
+
+ get AsyncStorage() {
+ warnOnce('async-storage-moved', 'Async Storage has been extracted from react-native core and will be removed in a future release. ' + "It can now be installed and imported from '@react-native-community/async-storage' instead of 'react-native'. " + 'See https://github.com/react-native-community/react-native-async-storage');
+ return _$$_REQUIRE(_dependencyMap[52], "AsyncStorage");
+ },
+
+ get BackHandler() {
+ return _$$_REQUIRE(_dependencyMap[53], "BackHandler");
+ },
+
+ get CameraRoll() {
+ return _$$_REQUIRE(_dependencyMap[54], "CameraRoll");
+ },
+
+ get Clipboard() {
+ return _$$_REQUIRE(_dependencyMap[55], "Clipboard");
+ },
+
+ get DatePickerAndroid() {
+ return _$$_REQUIRE(_dependencyMap[56], "DatePickerAndroid");
+ },
+
+ get DatePickerMacOS() {
+ return _$$_REQUIRE(_dependencyMap[57], "DatePickerMacOS");
+ },
+
+ get DeviceInfo() {
+ return _$$_REQUIRE(_dependencyMap[58], "DeviceInfo");
+ },
+
+ get Dimensions() {
+ return _$$_REQUIRE(_dependencyMap[59], "Dimensions");
+ },
+
+ get Easing() {
+ return _$$_REQUIRE(_dependencyMap[60], "Easing");
+ },
+
+ get findNodeHandle() {
+ return _$$_REQUIRE(_dependencyMap[61], "ReactNative").findNodeHandle;
+ },
+
+ get I18nManager() {
+ return _$$_REQUIRE(_dependencyMap[62], "I18nManager");
+ },
+
+ get ImagePickerIOS() {
+ return _$$_REQUIRE(_dependencyMap[63], "ImagePickerIOS");
+ },
+
+ get InteractionManager() {
+ return _$$_REQUIRE(_dependencyMap[64], "InteractionManager");
+ },
+
+ get Keyboard() {
+ return _$$_REQUIRE(_dependencyMap[65], "Keyboard");
+ },
+
+ get LayoutAnimation() {
+ return _$$_REQUIRE(_dependencyMap[66], "LayoutAnimation");
+ },
+
+ get Linking() {
+ return _$$_REQUIRE(_dependencyMap[67], "Linking");
+ },
+
+ get NativeEventEmitter() {
+ return _$$_REQUIRE(_dependencyMap[68], "NativeEventEmitter");
+ },
+
+ get NetInfo() {
+ warnOnce('netinfo-moved', 'NetInfo has been extracted from react-native core and will be removed in a future release. ' + "It can now be installed and imported from '@react-native-community/netinfo' instead of 'react-native'. " + 'See https://github.com/react-native-community/react-native-netinfo');
+ return _$$_REQUIRE(_dependencyMap[69], "NetInfo");
+ },
+
+ get PanResponder() {
+ return _$$_REQUIRE(_dependencyMap[70], "PanResponder");
+ },
+
+ get PermissionsAndroid() {
+ return _$$_REQUIRE(_dependencyMap[71], "PermissionsAndroid");
+ },
+
+ get PixelRatio() {
+ return _$$_REQUIRE(_dependencyMap[72], "PixelRatio");
+ },
+
+ get PushNotificationIOS() {
+ return _$$_REQUIRE(_dependencyMap[73], "PushNotificationIOS");
+ },
+
+ get Settings() {
+ return _$$_REQUIRE(_dependencyMap[74], "Settings");
+ },
+
+ get Share() {
+ return _$$_REQUIRE(_dependencyMap[75], "Share");
+ },
+
+ get StatusBarIOS() {
+ return _$$_REQUIRE(_dependencyMap[76], "StatusBarIOS");
+ },
+
+ get StyleSheet() {
+ return _$$_REQUIRE(_dependencyMap[77], "StyleSheet");
+ },
+
+ get Systrace() {
+ return _$$_REQUIRE(_dependencyMap[78], "Systrace");
+ },
+
+ get TimePickerAndroid() {
+ return _$$_REQUIRE(_dependencyMap[79], "TimePickerAndroid");
+ },
+
+ get ToastAndroid() {
+ return _$$_REQUIRE(_dependencyMap[80], "ToastAndroid");
+ },
+
+ get TVEventHandler() {
+ return _$$_REQUIRE(_dependencyMap[81], "TVEventHandler");
+ },
+
+ get UIManager() {
+ return _$$_REQUIRE(_dependencyMap[82], "UIManager");
+ },
+
+ get unstable_batchedUpdates() {
+ return _$$_REQUIRE(_dependencyMap[61], "ReactNative").unstable_batchedUpdates;
+ },
+
+ get UTFSequence() {
+ return _$$_REQUIRE(_dependencyMap[83], "UTFSequence");
+ },
+
+ 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], "DeprecatedColorPropType");
+ },
+
+ get EdgeInsetsPropType() {
+ return _$$_REQUIRE(_dependencyMap[95], "DeprecatedEdgeInsetsPropType");
+ },
+
+ get PointPropType() {
+ return _$$_REQUIRE(_dependencyMap[96], "DeprecatedPointPropType");
+ },
+
+ get ViewPropTypes() {
+ return _$$_REQUIRE(_dependencyMap[97], "DeprecatedViewPropTypes");
+ },
+
+ get BackAndroid() {
+ invariant(false, 'BackAndroid is deprecated and has been removed from this package. ' + 'Use BackHandler instead');
+ },
+
+ 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');
+ },
+
+ get NavigatorIOS() {
+ invariant(false, 'NavigatorIOS is deprecated and has been removed from this package. ' + 'Learn about alternative navigation solutions at http://facebook.github.io/react-native/docs/navigation.html');
+ }
+
+ };
+},18,[19,20,23,31,197,207,296,297,298,268,287,299,301,302,303,305,306,312,313,350,352,195,353,333,275,292,354,355,357,358,272,360,361,365,208,367,369,213,221,235,236,226,81,370,269,371,372,145,146,237,373,168,384,379,385,386,387,388,56,55,264,84,320,389,245,278,279,390,131,391,363,150,54,392,393,394,395,53,48,396,397,217,71,339,398,399,331,24,155,36,35,75,184,400,59,210,401,222],"node_modules\\react-native\\Libraries\\react-native\\react-native-implementation.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var invariant = function invariant(condition, format, a, b, c, d, e, f) {
+ if (process.env.NODE_ENV !== 'production') {
+ if (format === undefined) {
+ throw new Error('invariant requires an error message argument');
+ }
+ }
+
+ if (!condition) {
+ var error;
+
+ if (format === undefined) {
+ error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');
+ } else {
+ var args = [a, b, c, d, e, f];
+ var argIndex = 0;
+ error = new Error(format.replace(/%s/g, function () {
+ return args[argIndex++];
+ }));
+ error.name = 'Invariant Violation';
+ }
+
+ error.framesToPop = 1;
+ throw error;
+ }
+ };
+
+ module.exports = invariant;
+},19,[],"node_modules\\invariant\\browser.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var warning = _$$_REQUIRE(_dependencyMap[0], "fbjs/lib/warning");
+
+ var warnedKeys = {};
+
+ function warnOnce(key, message) {
+ if (warnedKeys[key]) {
+ return;
+ }
+
+ warning(false, message);
+ warnedKeys[key] = true;
+ }
+
+ module.exports = warnOnce;
+},20,[21],"node_modules\\react-native\\Libraries\\Utilities\\warnOnce.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var emptyFunction = _$$_REQUIRE(_dependencyMap[0], "./emptyFunction");
+
+ function printWarning(format) {
+ for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+ args[_key - 1] = arguments[_key];
+ }
+
+ var argIndex = 0;
+ var message = 'Warning: ' + format.replace(/%s/g, function () {
+ return args[argIndex++];
+ });
+
+ if (typeof console !== 'undefined') {
+ console.error(message);
+ }
+
+ try {
+ throw new Error(message);
+ } catch (x) {}
+ }
+
+ var warning = process.env.NODE_ENV !== "production" ? function (condition, format) {
+ if (format === undefined) {
+ throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument');
+ }
+
+ if (!condition) {
+ for (var _len2 = arguments.length, args = new Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
+ args[_key2 - 2] = arguments[_key2];
+ }
+
+ printWarning.apply(void 0, [format].concat(args));
+ }
+ } : emptyFunction;
+ module.exports = warning;
+},21,[22],"node_modules\\fbjs\\lib\\warning.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ "use strict";
+
+ function makeEmptyFunction(arg) {
+ return function () {
+ return arg;
+ };
+ }
+
+ var emptyFunction = function emptyFunction() {};
+
+ emptyFunction.thatReturns = makeEmptyFunction;
+ emptyFunction.thatReturnsFalse = makeEmptyFunction(false);
+ emptyFunction.thatReturnsTrue = makeEmptyFunction(true);
+ emptyFunction.thatReturnsNull = makeEmptyFunction(null);
+
+ emptyFunction.thatReturnsThis = function () {
+ return this;
+ };
+
+ emptyFunction.thatReturnsArgument = function (arg) {
+ return arg;
+ };
+
+ module.exports = emptyFunction;
+},22,[],"node_modules\\fbjs\\lib\\emptyFunction.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var RCTDeviceEventEmitter = _$$_REQUIRE(_dependencyMap[0], "RCTDeviceEventEmitter");
+
+ var TOUCH_EXPLORATION_EVENT = 'touchExplorationDidChange';
+
+ var _subscriptions = new Map();
+
+ var AccessibilityInfo = {
+ fetch: function fetch() {
+ return new Promise(function (_resolve, _reject) {
+ return false;
+ });
+ },
+ addEventListener: function addEventListener(eventName, handler) {
+ var listener = RCTDeviceEventEmitter.addListener(TOUCH_EXPLORATION_EVENT, function (enabledInner) {
+ handler(enabledInner);
+ });
+
+ _subscriptions.set(handler, listener);
+ },
+ removeEventListener: function removeEventListener(eventName, handler) {
+ var listener = _subscriptions.get(handler);
+
+ if (!listener) {
+ return;
+ }
+
+ listener.remove();
+
+ _subscriptions.delete(handler);
+ }
+ };
+ module.exports = AccessibilityInfo;
+},23,[24],"Libraries\\Components\\AccessibilityInfo\\AccessibilityInfo.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _get = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/get");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var EventEmitter = _$$_REQUIRE(_dependencyMap[6], "EventEmitter");
+
+ var EventSubscriptionVendor = _$$_REQUIRE(_dependencyMap[7], "EventSubscriptionVendor");
+
+ function checkNativeEventModule(eventType) {
+ if (eventType) {
+ if (eventType.lastIndexOf('statusBar', 0) === 0) {
+ throw new Error('`' + eventType + '` event should be registered via the StatusBarIOS module');
+ }
+
+ if (eventType.lastIndexOf('keyboard', 0) === 0) {
+ throw new Error('`' + eventType + '` event should be registered via the Keyboard module');
+ }
+
+ if (eventType === 'appStateDidChange' || eventType === 'memoryWarning') {
+ throw new Error('`' + eventType + '` event should be registered via the AppState module');
+ }
+ }
+ }
+
+ var RCTDeviceEventEmitter = function (_EventEmitter) {
+ _inherits(RCTDeviceEventEmitter, _EventEmitter);
+
+ function RCTDeviceEventEmitter() {
+ var _this;
+
+ _classCallCheck(this, RCTDeviceEventEmitter);
+
+ var sharedSubscriber = new EventSubscriptionVendor();
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(RCTDeviceEventEmitter).call(this, sharedSubscriber));
+ _this.sharedSubscriber = sharedSubscriber;
+ return _this;
+ }
+
+ _createClass(RCTDeviceEventEmitter, [{
+ key: "addListener",
+ value: function addListener(eventType, listener, context) {
+ if (__DEV__) {
+ checkNativeEventModule(eventType);
+ }
+
+ return _get(_getPrototypeOf(RCTDeviceEventEmitter.prototype), "addListener", this).call(this, eventType, listener, context);
+ }
+ }, {
+ key: "removeAllListeners",
+ value: function removeAllListeners(eventType) {
+ if (__DEV__) {
+ checkNativeEventModule(eventType);
+ }
+
+ _get(_getPrototypeOf(RCTDeviceEventEmitter.prototype), "removeAllListeners", this).call(this, eventType);
+ }
+ }, {
+ key: "removeSubscription",
+ value: function removeSubscription(subscription) {
+ if (subscription.emitter !== this) {
+ subscription.emitter.removeSubscription(subscription);
+ } else {
+ _get(_getPrototypeOf(RCTDeviceEventEmitter.prototype), "removeSubscription", this).call(this, subscription);
+ }
+ }
+ }]);
+
+ return RCTDeviceEventEmitter;
+ }(EventEmitter);
+
+ module.exports = new RCTDeviceEventEmitter();
+},24,[3,4,5,8,25,9,27,30],"node_modules\\react-native\\Libraries\\EventEmitter\\RCTDeviceEventEmitter.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var superPropBase = _$$_REQUIRE(_dependencyMap[0], "./superPropBase");
+
+ function _get(target, property, receiver) {
+ if (typeof Reflect !== "undefined" && Reflect.get) {
+ module.exports = _get = Reflect.get;
+ } else {
+ module.exports = _get = function _get(target, property, receiver) {
+ var base = superPropBase(target, property);
+ if (!base) return;
+ var desc = Object.getOwnPropertyDescriptor(base, property);
+
+ if (desc.get) {
+ return desc.get.call(receiver);
+ }
+
+ return desc.value;
+ };
+ }
+
+ return _get(target, property, receiver || target);
+ }
+
+ module.exports = _get;
+},25,[26],"node_modules\\@babel\\runtime\\helpers\\get.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var getPrototypeOf = _$$_REQUIRE(_dependencyMap[0], "./getPrototypeOf");
+
+ function _superPropBase(object, property) {
+ while (!Object.prototype.hasOwnProperty.call(object, property)) {
+ object = getPrototypeOf(object);
+ if (object === null) break;
+ }
+
+ return object;
+ }
+
+ module.exports = _superPropBase;
+},26,[8],"node_modules\\@babel\\runtime\\helpers\\superPropBase.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var EmitterSubscription = _$$_REQUIRE(_dependencyMap[2], "EmitterSubscription");
+
+ var EventSubscriptionVendor = _$$_REQUIRE(_dependencyMap[3], "EventSubscriptionVendor");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[4], "invariant");
+
+ var 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.map(function (subscription) {
+ return subscription.listener;
+ }) : [];
+ }
+ }, {
+ key: "emit",
+ value: function emit(eventType) {
+ var subscriptions = this._subscriber.getSubscriptionsForType(eventType);
+
+ if (subscriptions) {
+ for (var i = 0, l = subscriptions.length; i < l; i++) {
+ var subscription = subscriptions[i];
+
+ if (subscription && subscription.listener) {
+ this._currentSubscription = subscription;
+ subscription.listener.apply(subscription.context, Array.prototype.slice.call(arguments, 1));
+ }
+ }
+
+ this._currentSubscription = null;
+ }
+ }
+ }, {
+ key: "removeListener",
+ value: function removeListener(eventType, listener) {
+ var subscriptions = this._subscriber.getSubscriptionsForType(eventType);
+
+ if (subscriptions) {
+ for (var i = 0, l = subscriptions.length; i < l; i++) {
+ var subscription = subscriptions[i];
+
+ if (subscription && subscription.listener === listener) {
+ subscription.remove();
+ }
+ }
+ }
+ }
+ }]);
+
+ return EventEmitter;
+ }();
+
+ module.exports = EventEmitter;
+},27,[3,4,28,30,19],"node_modules\\react-native\\Libraries\\vendor\\emitter\\EventEmitter.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var EventSubscription = _$$_REQUIRE(_dependencyMap[5], "EventSubscription");
+
+ var EmitterSubscription = function (_EventSubscription) {
+ _inherits(EmitterSubscription, _EventSubscription);
+
+ function EmitterSubscription(emitter, subscriber, listener, context) {
+ var _this;
+
+ _classCallCheck(this, EmitterSubscription);
+
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(EmitterSubscription).call(this, subscriber));
+ _this.emitter = emitter;
+ _this.listener = listener;
+ _this.context = context;
+ return _this;
+ }
+
+ _createClass(EmitterSubscription, [{
+ key: "remove",
+ value: function remove() {
+ this.emitter.removeSubscription(this);
+ }
+ }]);
+
+ return EmitterSubscription;
+ }(EventSubscription);
+
+ module.exports = EmitterSubscription;
+},28,[3,4,5,8,9,29],"node_modules\\react-native\\Libraries\\vendor\\emitter\\EmitterSubscription.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var EventSubscription = function () {
+ function EventSubscription(subscriber) {
+ _classCallCheck(this, EventSubscription);
+
+ this.subscriber = subscriber;
+ }
+
+ _createClass(EventSubscription, [{
+ key: "remove",
+ value: function remove() {
+ this.subscriber.removeSubscription(this);
+ }
+ }]);
+
+ return EventSubscription;
+ }();
+
+ module.exports = EventSubscription;
+},29,[3,4],"node_modules\\react-native\\Libraries\\vendor\\emitter\\EventSubscription.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[2], "invariant");
+
+ var EventSubscriptionVendor = function () {
+ function EventSubscriptionVendor() {
+ _classCallCheck(this, EventSubscriptionVendor);
+
+ this._subscriptionsForType = {};
+ this._currentSubscription = null;
+ }
+
+ _createClass(EventSubscriptionVendor, [{
+ key: "addSubscription",
+ value: function addSubscription(eventType, subscription) {
+ invariant(subscription.subscriber === this, 'The subscriber of the subscription is incorrectly set.');
+
+ if (!this._subscriptionsForType[eventType]) {
+ this._subscriptionsForType[eventType] = [];
+ }
+
+ var key = this._subscriptionsForType[eventType].length;
+
+ this._subscriptionsForType[eventType].push(subscription);
+
+ subscription.eventType = eventType;
+ subscription.key = key;
+ return subscription;
+ }
+ }, {
+ key: "removeAllSubscriptions",
+ value: function removeAllSubscriptions(eventType) {
+ if (eventType === undefined) {
+ this._subscriptionsForType = {};
+ } else {
+ delete this._subscriptionsForType[eventType];
+ }
+ }
+ }, {
+ key: "removeSubscription",
+ value: function removeSubscription(subscription) {
+ var eventType = subscription.eventType;
+ var key = subscription.key;
+ var subscriptionsForType = this._subscriptionsForType[eventType];
+
+ if (subscriptionsForType) {
+ delete subscriptionsForType[key];
+ }
+ }
+ }, {
+ key: "getSubscriptionsForType",
+ value: function getSubscriptionsForType(eventType) {
+ return this._subscriptionsForType[eventType];
+ }
+ }]);
+
+ return EventSubscriptionVendor;
+ }();
+
+ module.exports = EventSubscriptionVendor;
+},30,[3,4,19],"node_modules\\react-native\\Libraries\\vendor\\emitter\\EventSubscriptionVendor.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/defineProperty");
+
+ var _objectWithoutProperties = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/objectWithoutProperties");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Components\\ActivityIndicator\\ActivityIndicator.js";
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var Platform = _$$_REQUIRE(_dependencyMap[3], "Platform");
+
+ var React = _$$_REQUIRE(_dependencyMap[4], "React");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[5], "StyleSheet");
+
+ var View = _$$_REQUIRE(_dependencyMap[6], "View");
+
+ var RCTActivityIndicatorViewNativeComponent = _$$_REQUIRE(_dependencyMap[7], "RCTActivityIndicatorViewNativeComponent");
+
+ var RCTActivityIndicator = Platform.OS === 'android' ? _$$_REQUIRE(_dependencyMap[8], "ProgressBarAndroid") : RCTActivityIndicatorViewNativeComponent;
+ var GRAY = '#999999';
+
+ var ActivityIndicator = function ActivityIndicator(props, forwardedRef) {
+ var onLayout = props.onLayout,
+ style = props.style,
+ restProps = _objectWithoutProperties(props, ["onLayout", "style"]);
+
+ 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: StyleSheet.compose(styles.container, style),
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 98
+ }
+ }, React.createElement(RCTActivityIndicator, _extends({}, nativeProps, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 106
+ }
+ })));
+ };
+
+ var ActivityIndicatorWithRef = React.forwardRef(ActivityIndicator);
+ ActivityIndicatorWithRef.displayName = 'ActivityIndicator';
+ ActivityIndicatorWithRef.defaultProps = {
+ animating: true,
+ color: Platform.OS === 'ios' ? GRAY : null,
+ hidesWhenStopped: true,
+ size: 'small'
+ };
+ var styles = StyleSheet.create({
+ container: {
+ alignItems: 'center',
+ justifyContent: 'center'
+ },
+ sizeSmall: {
+ width: 20,
+ height: 20
+ },
+ sizeLarge: {
+ width: 36,
+ height: 36
+ }
+ });
+ module.exports = ActivityIndicatorWithRef;
+},31,[14,32,33,35,52,53,81,194,195],"node_modules\\react-native\\Libraries\\Components\\ActivityIndicator\\ActivityIndicator.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ function _defineProperty(obj, key, value) {
+ if (key in obj) {
+ Object.defineProperty(obj, key, {
+ value: value,
+ enumerable: true,
+ configurable: true,
+ writable: true
+ });
+ } else {
+ obj[key] = value;
+ }
+
+ return obj;
+ }
+
+ module.exports = _defineProperty;
+},32,[],"node_modules\\@babel\\runtime\\helpers\\defineProperty.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var objectWithoutPropertiesLoose = _$$_REQUIRE(_dependencyMap[0], "./objectWithoutPropertiesLoose");
+
+ function _objectWithoutProperties(source, excluded) {
+ if (source == null) return {};
+ var target = objectWithoutPropertiesLoose(source, excluded);
+ var key, i;
+
+ if (Object.getOwnPropertySymbols) {
+ var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+
+ for (i = 0; i < sourceSymbolKeys.length; i++) {
+ key = sourceSymbolKeys[i];
+ if (excluded.indexOf(key) >= 0) continue;
+ if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+ target[key] = source[key];
+ }
+ }
+
+ return target;
+ }
+
+ module.exports = _objectWithoutProperties;
+},33,[34],"node_modules\\@babel\\runtime\\helpers\\objectWithoutProperties.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ function _objectWithoutPropertiesLoose(source, excluded) {
+ if (source == null) return {};
+ var target = {};
+ var sourceKeys = Object.keys(source);
+ var key, i;
+
+ for (i = 0; i < sourceKeys.length; i++) {
+ key = sourceKeys[i];
+ if (excluded.indexOf(key) >= 0) continue;
+ target[key] = source[key];
+ }
+
+ return target;
+ }
+
+ module.exports = _objectWithoutPropertiesLoose;
+},34,[],"node_modules\\@babel\\runtime\\helpers\\objectWithoutPropertiesLoose.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var NativeModules = _$$_REQUIRE(_dependencyMap[0], "NativeModules");
+
+ var Platform = {
+ OS: 'uwp',
+
+ get Version() {
+ var constants = NativeModules.PlatformConstants;
+ return constants && constants.Version;
+ },
+
+ get isTesting() {
+ var constants = NativeModules.PlatformConstants;
+ return constants && constants.isTesting;
+ },
+
+ select: function select(obj) {
+ return 'uwp' in obj ? obj.uwp : obj.default;
+ }
+ };
+ module.exports = Platform;
+},35,[36],"Libraries\\Utilities\\Platform.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _objectWithoutProperties = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/objectWithoutProperties");
+
+ var _extends = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/extends");
+
+ var _slicedToArray = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/slicedToArray");
+
+ var BatchedBridge = _$$_REQUIRE(_dependencyMap[3], "BatchedBridge");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[4], "invariant");
+
+ function genModule(config, moduleID) {
+ if (!config) {
+ return null;
+ }
+
+ var _config = _slicedToArray(config, 5),
+ moduleName = _config[0],
+ constants = _config[1],
+ methods = _config[2],
+ promiseMethods = _config[3],
+ syncMethods = _config[4];
+
+ invariant(!moduleName.startsWith('RCT') && !moduleName.startsWith('RK'), "Module name prefixes should've been stripped by the native side " + "but wasn't for " + moduleName);
+
+ if (!constants && !methods) {
+ return {
+ name: moduleName
+ };
+ }
+
+ var module = {};
+ methods && methods.forEach(function (methodName, methodID) {
+ var isPromise = promiseMethods && arrayContains(promiseMethods, methodID);
+ var isSync = syncMethods && arrayContains(syncMethods, methodID);
+ invariant(!isPromise || !isSync, 'Cannot have a method that is both async and a sync hook');
+ var methodType = isPromise ? 'promise' : isSync ? 'sync' : 'async';
+ module[methodName] = genMethod(moduleID, methodID, methodType);
+ });
+
+ _extends(module, constants);
+
+ if (module.getConstants == null) {
+ module.getConstants = function () {
+ return constants;
+ };
+ } else {
+ console.warn("Unable to define method 'getConstants()' on NativeModule '" + moduleName + "'. NativeModule '" + moduleName + "' already has a constant or method called 'getConstants'. Please remove it.");
+ }
+
+ if (__DEV__) {
+ BatchedBridge.createDebugLookup(moduleID, moduleName, methods);
+ }
+
+ return {
+ name: moduleName,
+ module: module
+ };
+ }
+
+ global.__fbGenNativeModule = genModule;
+
+ function loadModule(name, moduleID) {
+ invariant(global.nativeRequireModuleConfig, "Can't lazily create module without nativeRequireModuleConfig");
+ var config = global.nativeRequireModuleConfig(name);
+ var info = genModule(config, moduleID);
+ return info && info.module;
+ }
+
+ function genMethod(moduleID, methodID, type) {
+ var fn = null;
+
+ if (type === 'promise') {
+ fn = function fn() {
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ 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[5], "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;
+},36,[33,14,37,41,19,51],"node_modules\\react-native\\Libraries\\BatchedBridge\\NativeModules.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var arrayWithHoles = _$$_REQUIRE(_dependencyMap[0], "./arrayWithHoles");
+
+ var iterableToArrayLimit = _$$_REQUIRE(_dependencyMap[1], "./iterableToArrayLimit");
+
+ var nonIterableRest = _$$_REQUIRE(_dependencyMap[2], "./nonIterableRest");
+
+ function _slicedToArray(arr, i) {
+ return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || nonIterableRest();
+ }
+
+ module.exports = _slicedToArray;
+},37,[38,39,40],"node_modules\\@babel\\runtime\\helpers\\slicedToArray.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ function _arrayWithHoles(arr) {
+ if (Array.isArray(arr)) return arr;
+ }
+
+ module.exports = _arrayWithHoles;
+},38,[],"node_modules\\@babel\\runtime\\helpers\\arrayWithHoles.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 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;
+ }
+
+ module.exports = _iterableToArrayLimit;
+},39,[],"node_modules\\@babel\\runtime\\helpers\\iterableToArrayLimit.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ function _nonIterableRest() {
+ throw new TypeError("Invalid attempt to destructure non-iterable instance");
+ }
+
+ module.exports = _nonIterableRest;
+},40,[],"node_modules\\@babel\\runtime\\helpers\\nonIterableRest.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var MessageQueue = _$$_REQUIRE(_dependencyMap[0], "MessageQueue");
+
+ var BatchedBridge = new MessageQueue();
+ Object.defineProperty(global, '__fbBatchedBridge', {
+ configurable: true,
+ value: BatchedBridge
+ });
+ module.exports = BatchedBridge;
+},41,[42],"node_modules\\react-native\\Libraries\\BatchedBridge\\BatchedBridge.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _toConsumableArray = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/toConsumableArray");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ var ErrorUtils = _$$_REQUIRE(_dependencyMap[3], "ErrorUtils");
+
+ var Systrace = _$$_REQUIRE(_dependencyMap[4], "Systrace");
+
+ var deepFreezeAndThrowOnMutationInDev = _$$_REQUIRE(_dependencyMap[5], "deepFreezeAndThrowOnMutationInDev");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[6], "invariant");
+
+ var stringifySafe = _$$_REQUIRE(_dependencyMap[7], "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 MessageQueue = function () {
+ function MessageQueue() {
+ _classCallCheck(this, MessageQueue);
+
+ this._lazyCallableModules = {};
+ this._queue = [[], [], [], 0];
+ this._successCallbacks = {};
+ this._failureCallbacks = {};
+ this._callID = 0;
+ this._lastFlush = 0;
+ this._eventLoopStartTime = Date.now();
+ this._immediatesCallback = null;
+
+ if (__DEV__) {
+ this._debugInfo = {};
+ this._remoteModuleTable = {};
+ this._remoteMethodTable = {};
+ }
+
+ this.callFunctionReturnFlushedQueue = this.callFunctionReturnFlushedQueue.bind(this);
+ this.callFunctionReturnResultAndFlushedQueue = this.callFunctionReturnResultAndFlushedQueue.bind(this);
+ this.flushedQueue = this.flushedQueue.bind(this);
+ this.invokeCallbackAndReturnFlushedQueue = this.invokeCallbackAndReturnFlushedQueue.bind(this);
+ }
+
+ _createClass(MessageQueue, [{
+ key: "callFunctionReturnFlushedQueue",
+ value: function callFunctionReturnFlushedQueue(module, method, args) {
+ var _this = this;
+
+ this.__guard(function () {
+ _this.__callFunction(module, method, args);
+ });
+
+ return this.flushedQueue();
+ }
+ }, {
+ key: "callFunctionReturnResultAndFlushedQueue",
+ value: function callFunctionReturnResultAndFlushedQueue(module, method, args) {
+ var _this2 = this;
+
+ var result;
+
+ this.__guard(function () {
+ result = _this2.__callFunction(module, method, args);
+ });
+
+ return [result, this.flushedQueue()];
+ }
+ }, {
+ key: "invokeCallbackAndReturnFlushedQueue",
+ value: function invokeCallbackAndReturnFlushedQueue(cbID, args) {
+ var _this3 = this;
+
+ this.__guard(function () {
+ _this3.__invokeCallback(cbID, args);
+ });
+
+ return this.flushedQueue();
+ }
+ }, {
+ key: "flushedQueue",
+ value: function flushedQueue() {
+ var _this4 = this;
+
+ this.__guard(function () {
+ _this4.__callImmediates();
+ });
+
+ var queue = this._queue;
+ this._queue = [[], [], [], this._callID];
+ return queue[0].length ? queue : null;
+ }
+ }, {
+ key: "getEventLoopRunningTime",
+ value: function getEventLoopRunningTime() {
+ return Date.now() - this._eventLoopStartTime;
+ }
+ }, {
+ key: "registerCallableModule",
+ value: function registerCallableModule(name, module) {
+ this._lazyCallableModules[name] = function () {
+ return module;
+ };
+ }
+ }, {
+ key: "registerLazyCallableModule",
+ value: function registerLazyCallableModule(name, factory) {
+ var module;
+ var getValue = factory;
+
+ this._lazyCallableModules[name] = function () {
+ if (getValue) {
+ module = getValue();
+ getValue = null;
+ }
+
+ return module;
+ };
+ }
+ }, {
+ key: "getCallableModule",
+ value: function getCallableModule(name) {
+ var getValue = this._lazyCallableModules[name];
+ return getValue ? getValue() : null;
+ }
+ }, {
+ key: "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 === 'string') {
+ return true;
+ }
+
+ if (t === 'number') {
+ return isFinite(val);
+ }
+
+ if (t === 'function' || t !== 'object') {
+ return false;
+ }
+
+ if (Array.isArray(val)) {
+ return val.every(isValidArgument);
+ }
+
+ for (var k in val) {
+ if (typeof val[k] !== 'function' && !isValidArgument(val[k])) {
+ return false;
+ }
+ }
+
+ return true;
+ };
+
+ var replacer = function replacer(key, val) {
+ var t = typeof val;
+
+ if (t === 'function') {
+ return '<>';
+ } else if (t === 'number' && !isFinite(val)) {
+ return '<<' + val.toString() + '>>';
+ } else {
+ return val;
+ }
+ };
+
+ invariant(isValidArgument(params), '%s is not usable as a native method argument', JSON.stringify(params, replacer));
+ deepFreezeAndThrowOnMutationInDev(params);
+ }
+
+ this._queue[PARAMS].push(params);
+
+ var now = Date.now();
+
+ if (global.nativeFlushQueueImmediate && now - this._lastFlush >= MIN_TIME_BETWEEN_FLUSHES_MS) {
+ var queue = this._queue;
+ this._queue = [[], [], [], this._callID];
+ this._lastFlush = now;
+ global.nativeFlushQueueImmediate(queue);
+ }
+
+ Systrace.counterEvent('pending_js_to_native_queue', this._queue[0].length);
+
+ if (__DEV__ && this.__spy && isFinite(moduleID)) {
+ this.__spy({
+ type: TO_NATIVE,
+ module: this._remoteModuleTable[moduleID],
+ method: this._remoteMethodTable[moduleID][methodID],
+ args: params
+ });
+ } else if (this.__spy) {
+ this.__spy({
+ type: TO_NATIVE,
+ module: moduleID + '',
+ method: methodID,
+ args: params
+ });
+ }
+ }
+ }, {
+ key: "createDebugLookup",
+ value: function createDebugLookup(moduleID, name, methods) {
+ if (__DEV__) {
+ this._remoteModuleTable[moduleID] = name;
+ this._remoteMethodTable[moduleID] = methods;
+ }
+ }
+ }, {
+ key: "setImmediatesCallback",
+ value: function setImmediatesCallback(fn) {
+ this._immediatesCallback = fn;
+ }
+ }, {
+ key: "__guard",
+ value: function __guard(fn) {
+ if (this.__shouldPauseOnThrow()) {
+ fn();
+ } else {
+ try {
+ fn();
+ } catch (error) {
+ ErrorUtils.reportFatalError(error);
+ }
+ }
+ }
+ }, {
+ key: "__shouldPauseOnThrow",
+ value: function __shouldPauseOnThrow() {
+ return typeof DebuggerInternal !== 'undefined' && DebuggerInternal.shouldPauseOnThrow === true;
+ }
+ }, {
+ key: "__callImmediates",
+ value: function __callImmediates() {
+ Systrace.beginEvent('JSTimers.callImmediates()');
+
+ if (this._immediatesCallback != null) {
+ this._immediatesCallback();
+ }
+
+ Systrace.endEvent();
+ }
+ }, {
+ key: "__callFunction",
+ value: function __callFunction(module, method, args) {
+ this._lastFlush = Date.now();
+ this._eventLoopStartTime = this._lastFlush;
+
+ if (__DEV__ || this.__spy) {
+ Systrace.beginEvent(module + "." + method + "(" + stringifySafe(args) + ")");
+ } else {
+ Systrace.beginEvent(module + "." + method + "(...)");
+ }
+
+ if (this.__spy) {
+ this.__spy({
+ type: TO_JS,
+ module: module,
+ method: method,
+ args: args
+ });
+ }
+
+ var moduleMethods = this.getCallableModule(module);
+ invariant(!!moduleMethods, 'Module %s is not a registered callable module (calling %s)', module, method);
+ invariant(!!moduleMethods[method], 'Method %s does not exist on module %s', method, module);
+ var result = moduleMethods[method].apply(moduleMethods, args);
+ Systrace.endEvent();
+ return result;
+ }
+ }, {
+ key: "__invokeCallback",
+ value: function __invokeCallback(cbID, args) {
+ this._lastFlush = Date.now();
+ this._eventLoopStartTime = this._lastFlush;
+ var callID = cbID >>> 1;
+ var isSuccess = cbID & 1;
+ var callback = isSuccess ? this._successCallbacks[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 ? '' : 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;
+},42,[43,3,4,47,48,49,19,50],"node_modules\\react-native\\Libraries\\BatchedBridge\\MessageQueue.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var arrayWithoutHoles = _$$_REQUIRE(_dependencyMap[0], "./arrayWithoutHoles");
+
+ var iterableToArray = _$$_REQUIRE(_dependencyMap[1], "./iterableToArray");
+
+ var nonIterableSpread = _$$_REQUIRE(_dependencyMap[2], "./nonIterableSpread");
+
+ function _toConsumableArray(arr) {
+ return arrayWithoutHoles(arr) || iterableToArray(arr) || nonIterableSpread();
+ }
+
+ module.exports = _toConsumableArray;
+},43,[44,45,46],"node_modules\\@babel\\runtime\\helpers\\toConsumableArray.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ function _arrayWithoutHoles(arr) {
+ if (Array.isArray(arr)) {
+ for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) {
+ arr2[i] = arr[i];
+ }
+
+ return arr2;
+ }
+ }
+
+ module.exports = _arrayWithoutHoles;
+},44,[],"node_modules\\@babel\\runtime\\helpers\\arrayWithoutHoles.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ function _iterableToArray(iter) {
+ if ((typeof Symbol === "function" ? Symbol.iterator : "@@iterator") in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
+ }
+
+ module.exports = _iterableToArray;
+},45,[],"node_modules\\@babel\\runtime\\helpers\\iterableToArray.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ function _nonIterableSpread() {
+ throw new TypeError("Invalid attempt to spread non-iterable instance");
+ }
+
+ module.exports = _nonIterableSpread;
+},46,[],"node_modules\\@babel\\runtime\\helpers\\nonIterableSpread.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ module.exports = global.ErrorUtils;
+},47,[],"node_modules\\react-native\\Libraries\\vendor\\core\\ErrorUtils.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var invariant = _$$_REQUIRE(_dependencyMap[0], "invariant");
+
+ var TRACE_TAG_REACT_APPS = 1 << 17;
+ var TRACE_TAG_JS_VM_CALLS = 1 << 27;
+ var _enabled = false;
+ var _asyncCookie = 0;
+ var _markStack = [];
+
+ var _markStackIndex = -1;
+
+ var _canInstallReactHook = false;
+ var REACT_MARKER = "\u269B";
+ var userTimingPolyfill = __DEV__ ? {
+ mark: function mark(markName) {
+ if (_enabled) {
+ _markStackIndex++;
+ _markStack[_markStackIndex] = markName;
+ var systraceLabel = markName;
+
+ if (markName[0] === REACT_MARKER) {
+ var indexOfId = markName.lastIndexOf(' (#');
+ var cutoffIndex = indexOfId !== -1 ? indexOfId : markName.length;
+ systraceLabel = markName.slice(2, cutoffIndex);
+ }
+
+ Systrace.beginEvent(systraceLabel);
+ }
+ },
+ measure: function measure(measureName, startMark, endMark) {
+ if (_enabled) {
+ invariant(typeof measureName === 'string' && typeof startMark === 'string' && typeof endMark === 'undefined', 'Only performance.measure(string, string) overload is supported.');
+ var topMark = _markStack[_markStackIndex];
+ invariant(startMark === topMark, 'There was a mismatching performance.measure() call. ' + 'Expected "%s" but got "%s."', topMark, startMark);
+ _markStackIndex--;
+ Systrace.endEvent();
+ }
+ },
+ clearMarks: function clearMarks(markName) {
+ if (_enabled) {
+ if (_markStackIndex === -1) {
+ return;
+ }
+
+ if (markName === _markStack[_markStackIndex]) {
+ if (userTimingPolyfill != null) {
+ userTimingPolyfill.measure(markName, markName);
+ }
+ }
+ }
+ },
+ clearMeasures: function clearMeasures() {}
+ } : null;
+ var Systrace = {
+ installReactHook: function installReactHook() {
+ if (_enabled) {
+ if (__DEV__) {
+ global.performance = userTimingPolyfill;
+ }
+ }
+
+ _canInstallReactHook = true;
+ },
+ setEnabled: function setEnabled(enabled) {
+ if (_enabled !== enabled) {
+ if (__DEV__) {
+ if (enabled) {
+ global.nativeTraceBeginLegacy && global.nativeTraceBeginLegacy(TRACE_TAG_JS_VM_CALLS);
+ } else {
+ global.nativeTraceEndLegacy && global.nativeTraceEndLegacy(TRACE_TAG_JS_VM_CALLS);
+ }
+
+ if (_canInstallReactHook) {
+ if (enabled && global.performance === undefined) {
+ global.performance = userTimingPolyfill;
+ }
+ }
+ }
+
+ _enabled = enabled;
+ }
+ },
+ isEnabled: function isEnabled() {
+ return _enabled;
+ },
+ beginEvent: function beginEvent(profileName, args) {
+ if (_enabled) {
+ profileName = typeof profileName === 'function' ? profileName() : profileName;
+ global.nativeTraceBeginSection(TRACE_TAG_REACT_APPS, profileName, args);
+ }
+ },
+ endEvent: function endEvent() {
+ if (_enabled) {
+ global.nativeTraceEndSection(TRACE_TAG_REACT_APPS);
+ }
+ },
+ beginAsyncEvent: function beginAsyncEvent(profileName) {
+ var cookie = _asyncCookie;
+
+ if (_enabled) {
+ _asyncCookie++;
+ profileName = typeof profileName === 'function' ? profileName() : profileName;
+ global.nativeTraceBeginAsyncSection(TRACE_TAG_REACT_APPS, profileName, cookie);
+ }
+
+ return cookie;
+ },
+ endAsyncEvent: function endAsyncEvent(profileName, cookie) {
+ if (_enabled) {
+ profileName = typeof profileName === 'function' ? profileName() : profileName;
+ global.nativeTraceEndAsyncSection(TRACE_TAG_REACT_APPS, profileName, cookie);
+ }
+ },
+ counterEvent: function counterEvent(profileName, value) {
+ if (_enabled) {
+ profileName = typeof profileName === 'function' ? profileName() : profileName;
+ global.nativeTraceCounter && global.nativeTraceCounter(TRACE_TAG_REACT_APPS, profileName, value);
+ }
+ }
+ };
+
+ if (__DEV__) {
+ _$$_REQUIRE.Systrace = Systrace;
+ }
+
+ module.exports = Systrace;
+},48,[19],"node_modules\\react-native\\Libraries\\Performance\\Systrace.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ function deepFreezeAndThrowOnMutationInDev(object) {
+ if (__DEV__) {
+ if (typeof object !== 'object' || object === null || Object.isFrozen(object) || Object.isSealed(object)) {
+ return object;
+ }
+
+ var keys = Object.keys(object);
+ var _hasOwnProperty = Object.prototype.hasOwnProperty;
+
+ for (var i = 0; i < keys.length; i++) {
+ var key = keys[i];
+
+ if (_hasOwnProperty.call(object, key)) {
+ Object.defineProperty(object, key, {
+ get: identity.bind(null, object[key])
+ });
+ Object.defineProperty(object, key, {
+ set: throwOnImmutableMutation.bind(null, key)
+ });
+ }
+ }
+
+ Object.freeze(object);
+ Object.seal(object);
+
+ for (var _i = 0; _i < keys.length; _i++) {
+ var _key = keys[_i];
+
+ if (_hasOwnProperty.call(object, _key)) {
+ deepFreezeAndThrowOnMutationInDev(object[_key]);
+ }
+ }
+ }
+
+ return object;
+ }
+
+ function throwOnImmutableMutation(key, value) {
+ throw Error('You attempted to set the key `' + key + '` with the value `' + JSON.stringify(value) + '` on an object that is meant to be immutable ' + 'and has been frozen.');
+ }
+
+ function identity(value) {
+ return value;
+ }
+
+ module.exports = deepFreezeAndThrowOnMutationInDev;
+},49,[],"node_modules\\react-native\\Libraries\\Utilities\\deepFreezeAndThrowOnMutationInDev.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ function stringifySafe(arg) {
+ var ret;
+ var type = typeof arg;
+
+ if (arg === undefined) {
+ ret = 'undefined';
+ } else if (arg === null) {
+ ret = 'null';
+ } else if (type === 'string') {
+ ret = '"' + arg + '"';
+ } else if (type === 'function') {
+ try {
+ ret = arg.toString();
+ } catch (e) {
+ ret = '[function unknown]';
+ }
+ } else {
+ 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;
+},50,[],"node_modules\\react-native\\Libraries\\Utilities\\stringifySafe.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ function defineLazyObjectProperty(object, name, descriptor) {
+ var get = descriptor.get;
+ var enumerable = descriptor.enumerable !== false;
+ var writable = descriptor.writable !== false;
+ var value;
+ var valueSet = false;
+
+ function getValue() {
+ if (!valueSet) {
+ valueSet = true;
+ setValue(get());
+ }
+
+ return value;
+ }
+
+ function setValue(newValue) {
+ value = newValue;
+ valueSet = true;
+ Object.defineProperty(object, name, {
+ value: newValue,
+ configurable: true,
+ enumerable: enumerable,
+ writable: writable
+ });
+ }
+
+ Object.defineProperty(object, name, {
+ get: getValue,
+ set: setValue,
+ configurable: true,
+ enumerable: enumerable
+ });
+ }
+
+ module.exports = defineLazyObjectProperty;
+},51,[],"node_modules\\react-native\\Libraries\\Utilities\\defineLazyObjectProperty.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "react");
+},52,[11],"node_modules\\react-native\\Libraries\\react-native\\React.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var PixelRatio = _$$_REQUIRE(_dependencyMap[1], "PixelRatio");
+
+ var ReactNativeStyleAttributes = _$$_REQUIRE(_dependencyMap[2], "ReactNativeStyleAttributes");
+
+ var StyleSheetValidation = _$$_REQUIRE(_dependencyMap[3], "StyleSheetValidation");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[4], "Platform");
+
+ var flatten = _$$_REQUIRE(_dependencyMap[5], "flattenStyle");
+
+ var hairlineWidth = Platform.OS === 'win32' || Platform.OS === 'windesktop' ? 0.5 : PixelRatio.roundToNearestPixel(0.4);
+
+ if (hairlineWidth === 0) {
+ hairlineWidth = 1 / PixelRatio.get();
+ }
+
+ var absoluteFill = {
+ position: 'absolute',
+ left: 0,
+ right: 0,
+ top: 0,
+ bottom: 0
+ };
+
+ if (__DEV__) {
+ Object.freeze(absoluteFill);
+ }
+
+ module.exports = {
+ hairlineWidth: hairlineWidth,
+ absoluteFill: absoluteFill,
+ absoluteFillObject: absoluteFill,
+ compose: function compose(style1, style2) {
+ if (style1 != null && style2 != null) {
+ return [style1, style2];
+ } else {
+ return style1 != null ? style1 : style2;
+ }
+ },
+ flatten: flatten,
+ setStyleAttributePreprocessor: function setStyleAttributePreprocessor(property, process) {
+ var value;
+
+ if (ReactNativeStyleAttributes[property] === true) {
+ value = {};
+ } else if (typeof ReactNativeStyleAttributes[property] === 'object') {
+ value = ReactNativeStyleAttributes[property];
+ } else {
+ console.error(property + " is not a valid style attribute");
+ return;
+ }
+
+ if (__DEV__ && typeof value.process === 'function') {
+ console.warn("Overwriting " + property + " style attribute preprocessor");
+ }
+
+ ReactNativeStyleAttributes[property] = _objectSpread({}, value, {
+ process: process
+ });
+ },
+ create: function create(obj) {
+ if (__DEV__) {
+ for (var _key in obj) {
+ StyleSheetValidation.validateStyle(_key, obj);
+
+ if (obj[_key]) {
+ Object.freeze(obj[_key]);
+ }
+ }
+ }
+
+ return obj;
+ }
+ };
+},53,[32,54,57,79,35,80],"node_modules\\react-native\\Libraries\\StyleSheet\\StyleSheet.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var Dimensions = _$$_REQUIRE(_dependencyMap[2], "Dimensions");
+
+ var PixelRatio = function () {
+ function PixelRatio() {
+ _classCallCheck(this, PixelRatio);
+ }
+
+ _createClass(PixelRatio, null, [{
+ key: "get",
+ value: function get() {
+ return Dimensions.get('window').scale;
+ }
+ }, {
+ key: "getFontScale",
+ value: function getFontScale() {
+ return Dimensions.get('window').fontScale || PixelRatio.get();
+ }
+ }, {
+ key: "getPixelSizeForLayoutSize",
+ value: function getPixelSizeForLayoutSize(layoutSize) {
+ return Math.round(layoutSize * PixelRatio.get());
+ }
+ }, {
+ key: "roundToNearestPixel",
+ value: function roundToNearestPixel(layoutSize) {
+ var ratio = PixelRatio.get();
+ return Math.round(layoutSize * ratio) / ratio;
+ }
+ }, {
+ key: "startDetecting",
+ value: function startDetecting() {}
+ }]);
+
+ return PixelRatio;
+ }();
+
+ module.exports = PixelRatio;
+},54,[3,4,55],"node_modules\\react-native\\Libraries\\Utilities\\PixelRatio.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ var EventEmitter = _$$_REQUIRE(_dependencyMap[3], "EventEmitter");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[4], "Platform");
+
+ var RCTDeviceEventEmitter = _$$_REQUIRE(_dependencyMap[5], "RCTDeviceEventEmitter");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[6], "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[7], "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;
+},55,[14,3,4,27,35,24,19,56],"node_modules\\react-native\\Libraries\\Utilities\\Dimensions.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var DeviceInfo = _$$_REQUIRE(_dependencyMap[0], "NativeModules").DeviceInfo;
+
+ var invariant = _$$_REQUIRE(_dependencyMap[1], "invariant");
+
+ invariant(DeviceInfo, 'DeviceInfo native module is not installed correctly');
+ module.exports = DeviceInfo;
+},56,[36,19],"node_modules\\react-native\\Libraries\\Utilities\\DeviceInfo.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var DeprecatedImageStylePropTypes = _$$_REQUIRE(_dependencyMap[1], "DeprecatedImageStylePropTypes");
+
+ var TextStylePropTypes = _$$_REQUIRE(_dependencyMap[2], "TextStylePropTypes");
+
+ var DeprecatedViewStylePropTypes = _$$_REQUIRE(_dependencyMap[3], "DeprecatedViewStylePropTypes");
+
+ var processColor = _$$_REQUIRE(_dependencyMap[4], "processColor");
+
+ var processTransform = _$$_REQUIRE(_dependencyMap[5], "processTransform");
+
+ var sizesDiffer = _$$_REQUIRE(_dependencyMap[6], "sizesDiffer");
+
+ var ReactNativeStyleAttributes = {};
+
+ for (var _i = 0, _Object$keys = Object.keys(_objectSpread({}, DeprecatedViewStylePropTypes, {}, TextStylePropTypes, {}, DeprecatedImageStylePropTypes)); _i < _Object$keys.length; _i++) {
+ var attributeName = _Object$keys[_i];
+ ReactNativeStyleAttributes[attributeName] = true;
+ }
+
+ ReactNativeStyleAttributes.transform = {
+ process: processTransform
+ };
+ ReactNativeStyleAttributes.shadowOffset = {
+ diff: sizesDiffer
+ };
+ var colorAttributes = {
+ process: processColor
+ };
+ ReactNativeStyleAttributes.backgroundColor = colorAttributes;
+ ReactNativeStyleAttributes.borderBottomColor = colorAttributes;
+ ReactNativeStyleAttributes.borderColor = colorAttributes;
+ ReactNativeStyleAttributes.borderLeftColor = colorAttributes;
+ ReactNativeStyleAttributes.borderRightColor = colorAttributes;
+ ReactNativeStyleAttributes.borderTopColor = colorAttributes;
+ ReactNativeStyleAttributes.borderStartColor = colorAttributes;
+ ReactNativeStyleAttributes.borderEndColor = colorAttributes;
+ ReactNativeStyleAttributes.color = colorAttributes;
+ ReactNativeStyleAttributes.shadowColor = colorAttributes;
+ ReactNativeStyleAttributes.textDecorationColor = colorAttributes;
+ ReactNativeStyleAttributes.tintColor = colorAttributes;
+ ReactNativeStyleAttributes.textShadowColor = colorAttributes;
+ ReactNativeStyleAttributes.overlayColor = colorAttributes;
+ module.exports = ReactNativeStyleAttributes;
+},57,[32,58,73,74,75,76,78],"node_modules\\react-native\\Libraries\\Components\\View\\ReactNativeStyleAttributes.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var DeprecatedColorPropType = _$$_REQUIRE(_dependencyMap[1], "DeprecatedColorPropType");
+
+ var DeprecatedLayoutPropTypes = _$$_REQUIRE(_dependencyMap[2], "DeprecatedLayoutPropTypes");
+
+ var ReactPropTypes = _$$_REQUIRE(_dependencyMap[3], "prop-types");
+
+ var DeprecatedShadowPropTypesIOS = _$$_REQUIRE(_dependencyMap[4], "DeprecatedShadowPropTypesIOS");
+
+ var DeprecatedTransformPropTypes = _$$_REQUIRE(_dependencyMap[5], "DeprecatedTransformPropTypes");
+
+ var ImageStylePropTypes = _objectSpread({}, DeprecatedLayoutPropTypes, {}, DeprecatedShadowPropTypesIOS, {}, DeprecatedTransformPropTypes, {
+ resizeMode: ReactPropTypes.oneOf(['center', 'contain', 'cover', 'repeat', 'stretch']),
+ backfaceVisibility: ReactPropTypes.oneOf(['visible', 'hidden']),
+ backgroundColor: DeprecatedColorPropType,
+ borderColor: DeprecatedColorPropType,
+ borderWidth: ReactPropTypes.number,
+ borderRadius: ReactPropTypes.number,
+ overflow: ReactPropTypes.oneOf(['visible', 'hidden']),
+ tintColor: DeprecatedColorPropType,
+ opacity: ReactPropTypes.number,
+ overlayColor: ReactPropTypes.string,
+ borderTopLeftRadius: ReactPropTypes.number,
+ borderTopRightRadius: ReactPropTypes.number,
+ borderBottomLeftRadius: ReactPropTypes.number,
+ borderBottomRightRadius: ReactPropTypes.number
+ });
+
+ module.exports = ImageStylePropTypes;
+},58,[32,59,61,62,68,69],"node_modules\\react-native\\Libraries\\DeprecatedPropTypes\\DeprecatedImageStylePropTypes.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var normalizeColor = _$$_REQUIRE(_dependencyMap[0], "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;
+},59,[60],"node_modules\\react-native\\Libraries\\DeprecatedPropTypes\\DeprecatedColorPropType.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var Platform = _$$_REQUIRE(_dependencyMap[0], "Platform");
+
+ 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 (typeof color === 'object' && color !== null && Platform.OS === 'macos') {
+ if ('semantic' in color) {
+ return color;
+ } else if ('dynamic' in color && color.dynamic !== undefined) {
+ var dynamic = color.dynamic;
+ var dynamicColor = {
+ dynamic: {
+ light: normalizeColor(dynamic.light),
+ dark: normalizeColor(dynamic.dark)
+ }
+ };
+ return dynamicColor;
+ }
+ }
+
+ if (typeof color !== 'string') {
+ 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;
+},60,[35],"node_modules\\react-native\\Libraries\\Color\\normalizeColor.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var ReactPropTypes = _$$_REQUIRE(_dependencyMap[0], "prop-types");
+
+ var LayoutPropTypes = {
+ display: ReactPropTypes.oneOf(['none', 'flex']),
+ width: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ height: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ start: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ end: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ top: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ left: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ right: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ bottom: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ minWidth: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ maxWidth: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ minHeight: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ maxHeight: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ margin: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ marginVertical: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ marginHorizontal: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ marginTop: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ marginBottom: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ marginLeft: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ marginRight: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ marginStart: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ marginEnd: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ padding: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ paddingVertical: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ paddingHorizontal: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ paddingTop: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ paddingBottom: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ paddingLeft: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ paddingRight: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ paddingStart: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ paddingEnd: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ borderWidth: ReactPropTypes.number,
+ borderTopWidth: ReactPropTypes.number,
+ borderStartWidth: ReactPropTypes.number,
+ borderEndWidth: ReactPropTypes.number,
+ borderRightWidth: ReactPropTypes.number,
+ borderBottomWidth: ReactPropTypes.number,
+ borderLeftWidth: ReactPropTypes.number,
+ position: ReactPropTypes.oneOf(['absolute', 'relative']),
+ flexDirection: ReactPropTypes.oneOf(['row', 'row-reverse', 'column', 'column-reverse']),
+ flexWrap: ReactPropTypes.oneOf(['wrap', 'nowrap', 'wrap-reverse']),
+ justifyContent: ReactPropTypes.oneOf(['flex-start', 'flex-end', 'center', 'space-between', 'space-around', 'space-evenly']),
+ alignItems: ReactPropTypes.oneOf(['flex-start', 'flex-end', 'center', 'stretch', 'baseline']),
+ alignSelf: ReactPropTypes.oneOf(['auto', 'flex-start', 'flex-end', 'center', 'stretch', 'baseline']),
+ alignContent: ReactPropTypes.oneOf(['flex-start', 'flex-end', 'center', 'stretch', 'space-between', 'space-around']),
+ overflow: ReactPropTypes.oneOf(['visible', 'hidden', 'scroll']),
+ flex: ReactPropTypes.number,
+ flexGrow: ReactPropTypes.number,
+ flexShrink: ReactPropTypes.number,
+ flexBasis: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
+ aspectRatio: ReactPropTypes.number,
+ zIndex: ReactPropTypes.number,
+ direction: ReactPropTypes.oneOf(['inherit', 'ltr', 'rtl'])
+ };
+ module.exports = LayoutPropTypes;
+},61,[62],"node_modules\\react-native\\Libraries\\DeprecatedPropTypes\\DeprecatedLayoutPropTypes.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ if (process.env.NODE_ENV !== 'production') {
+ var ReactIs = _$$_REQUIRE(_dependencyMap[0], "react-is");
+
+ var throwOnDirectAccess = true;
+ module.exports = _$$_REQUIRE(_dependencyMap[1], "./factoryWithTypeCheckers")(ReactIs.isElement, throwOnDirectAccess);
+ } else {
+ module.exports = _$$_REQUIRE(_dependencyMap[2], "./factoryWithThrowingShims")();
+ }
+},62,[63,66,67],"node_modules\\prop-types\\index.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ if (process.env.NODE_ENV === 'production') {
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "./cjs/react-is.production.min.js");
+ } else {
+ module.exports = _$$_REQUIRE(_dependencyMap[1], "./cjs/react-is.development.js");
+ }
+},63,[64,65],"node_modules\\react-is\\index.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ /** @license React v16.8.6
+ * react-is.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+ 'use strict';
+
+ Object.defineProperty(exports, "__esModule", {
+ value: !0
+ });
+ var b = "function" === typeof Symbol && (typeof Symbol === "function" ? Symbol.for : "@@for"),
+ c = b ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.element") : 60103,
+ d = b ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.portal") : 60106,
+ e = b ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.fragment") : 60107,
+ f = b ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.strict_mode") : 60108,
+ g = b ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.profiler") : 60114,
+ h = b ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.provider") : 60109,
+ k = b ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.context") : 60110,
+ l = b ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.async_mode") : 60111,
+ m = b ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.concurrent_mode") : 60111,
+ n = b ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.forward_ref") : 60112,
+ p = b ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.suspense") : 60113,
+ q = b ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.memo") : 60115,
+ r = b ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.lazy") : 60116;
+
+ function t(a) {
+ if ("object" === typeof a && null !== a) {
+ var u = a.$$typeof;
+
+ switch (u) {
+ case c:
+ switch (a = a.type, a) {
+ case l:
+ case m:
+ case e:
+ case g:
+ case f:
+ case p:
+ return a;
+
+ default:
+ switch (a = a && a.$$typeof, a) {
+ case k:
+ case n:
+ case h:
+ return a;
+
+ default:
+ return u;
+ }
+
+ }
+
+ case r:
+ case q:
+ case d:
+ return u;
+ }
+ }
+ }
+
+ function v(a) {
+ return t(a) === m;
+ }
+
+ exports.typeOf = t;
+ exports.AsyncMode = l;
+ exports.ConcurrentMode = m;
+ exports.ContextConsumer = k;
+ exports.ContextProvider = h;
+ exports.Element = c;
+ exports.ForwardRef = n;
+ exports.Fragment = e;
+ exports.Lazy = r;
+ exports.Memo = q;
+ exports.Portal = d;
+ exports.Profiler = g;
+ exports.StrictMode = f;
+ exports.Suspense = p;
+
+ exports.isValidElementType = function (a) {
+ return "string" === typeof a || "function" === typeof a || a === e || a === m || a === g || a === f || a === p || "object" === typeof a && null !== a && (a.$$typeof === r || a.$$typeof === q || a.$$typeof === h || a.$$typeof === k || a.$$typeof === n);
+ };
+
+ exports.isAsyncMode = function (a) {
+ return v(a) || t(a) === l;
+ };
+
+ exports.isConcurrentMode = v;
+
+ exports.isContextConsumer = function (a) {
+ return t(a) === k;
+ };
+
+ exports.isContextProvider = function (a) {
+ return t(a) === h;
+ };
+
+ exports.isElement = function (a) {
+ return "object" === typeof a && null !== a && a.$$typeof === c;
+ };
+
+ exports.isForwardRef = function (a) {
+ return t(a) === n;
+ };
+
+ exports.isFragment = function (a) {
+ return t(a) === e;
+ };
+
+ exports.isLazy = function (a) {
+ return t(a) === r;
+ };
+
+ exports.isMemo = function (a) {
+ return t(a) === q;
+ };
+
+ exports.isPortal = function (a) {
+ return t(a) === d;
+ };
+
+ exports.isProfiler = function (a) {
+ return t(a) === g;
+ };
+
+ exports.isStrictMode = function (a) {
+ return t(a) === f;
+ };
+
+ exports.isSuspense = function (a) {
+ return t(a) === p;
+ };
+},64,[],"node_modules\\react-is\\cjs\\react-is.production.min.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ /** @license React v16.8.6
+ * react-is.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+ 'use strict';
+
+ if (process.env.NODE_ENV !== "production") {
+ (function () {
+ 'use strict';
+
+ Object.defineProperty(exports, '__esModule', {
+ value: true
+ });
+ var hasSymbol = typeof Symbol === 'function' && (typeof Symbol === "function" ? Symbol.for : "@@for");
+ var REACT_ELEMENT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.element') : 0xeac7;
+ var REACT_PORTAL_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.portal') : 0xeaca;
+ var REACT_FRAGMENT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.fragment') : 0xeacb;
+ var REACT_STRICT_MODE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.strict_mode') : 0xeacc;
+ var REACT_PROFILER_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.profiler') : 0xead2;
+ var REACT_PROVIDER_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.provider') : 0xeacd;
+ var REACT_CONTEXT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.context') : 0xeace;
+ var REACT_ASYNC_MODE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.async_mode') : 0xeacf;
+ var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.concurrent_mode') : 0xeacf;
+ var REACT_FORWARD_REF_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.forward_ref') : 0xead0;
+ var REACT_SUSPENSE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.suspense') : 0xead1;
+ var REACT_MEMO_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.memo') : 0xead3;
+ var REACT_LAZY_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.lazy') : 0xead4;
+
+ function isValidElementType(type) {
+ return typeof type === 'string' || typeof type === 'function' || type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || typeof type === 'object' && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE);
+ }
+
+ var lowPriorityWarning = function lowPriorityWarning() {};
+
+ {
+ var printWarning = function printWarning(format) {
+ for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+ args[_key - 1] = arguments[_key];
+ }
+
+ var argIndex = 0;
+ var message = 'Warning: ' + format.replace(/%s/g, function () {
+ return args[argIndex++];
+ });
+
+ if (typeof console !== 'undefined') {
+ console.warn(message);
+ }
+
+ try {
+ throw new Error(message);
+ } catch (x) {}
+ };
+
+ lowPriorityWarning = function lowPriorityWarning(condition, format) {
+ if (format === undefined) {
+ throw new Error('`lowPriorityWarning(condition, format, ...args)` requires a warning ' + 'message argument');
+ }
+
+ if (!condition) {
+ for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
+ args[_key2 - 2] = arguments[_key2];
+ }
+
+ printWarning.apply(undefined, [format].concat(args));
+ }
+ };
+ }
+ var lowPriorityWarning$1 = lowPriorityWarning;
+
+ function typeOf(object) {
+ if (typeof object === 'object' && object !== null) {
+ var $$typeof = object.$$typeof;
+
+ switch ($$typeof) {
+ case REACT_ELEMENT_TYPE:
+ var type = object.type;
+
+ switch (type) {
+ case REACT_ASYNC_MODE_TYPE:
+ case REACT_CONCURRENT_MODE_TYPE:
+ case REACT_FRAGMENT_TYPE:
+ case REACT_PROFILER_TYPE:
+ case REACT_STRICT_MODE_TYPE:
+ case REACT_SUSPENSE_TYPE:
+ return type;
+
+ default:
+ var $$typeofType = type && type.$$typeof;
+
+ switch ($$typeofType) {
+ case REACT_CONTEXT_TYPE:
+ case REACT_FORWARD_REF_TYPE:
+ case REACT_PROVIDER_TYPE:
+ return $$typeofType;
+
+ default:
+ return $$typeof;
+ }
+
+ }
+
+ case REACT_LAZY_TYPE:
+ case REACT_MEMO_TYPE:
+ case REACT_PORTAL_TYPE:
+ return $$typeof;
+ }
+ }
+
+ return undefined;
+ }
+
+ var AsyncMode = REACT_ASYNC_MODE_TYPE;
+ var ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
+ var ContextConsumer = REACT_CONTEXT_TYPE;
+ var ContextProvider = REACT_PROVIDER_TYPE;
+ var Element = REACT_ELEMENT_TYPE;
+ var ForwardRef = REACT_FORWARD_REF_TYPE;
+ var Fragment = REACT_FRAGMENT_TYPE;
+ var Lazy = REACT_LAZY_TYPE;
+ var Memo = REACT_MEMO_TYPE;
+ var Portal = REACT_PORTAL_TYPE;
+ var Profiler = REACT_PROFILER_TYPE;
+ var StrictMode = REACT_STRICT_MODE_TYPE;
+ var Suspense = REACT_SUSPENSE_TYPE;
+ var hasWarnedAboutDeprecatedIsAsyncMode = false;
+
+ function isAsyncMode(object) {
+ {
+ if (!hasWarnedAboutDeprecatedIsAsyncMode) {
+ hasWarnedAboutDeprecatedIsAsyncMode = true;
+ lowPriorityWarning$1(false, 'The ReactIs.isAsyncMode() alias has been deprecated, ' + 'and will be removed in React 17+. Update your code to use ' + 'ReactIs.isConcurrentMode() instead. It has the exact same API.');
+ }
+ }
+ return isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE;
+ }
+
+ function isConcurrentMode(object) {
+ return typeOf(object) === REACT_CONCURRENT_MODE_TYPE;
+ }
+
+ function isContextConsumer(object) {
+ return typeOf(object) === REACT_CONTEXT_TYPE;
+ }
+
+ function isContextProvider(object) {
+ return typeOf(object) === REACT_PROVIDER_TYPE;
+ }
+
+ function isElement(object) {
+ return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+ }
+
+ function isForwardRef(object) {
+ return typeOf(object) === REACT_FORWARD_REF_TYPE;
+ }
+
+ function isFragment(object) {
+ return typeOf(object) === REACT_FRAGMENT_TYPE;
+ }
+
+ function isLazy(object) {
+ return typeOf(object) === REACT_LAZY_TYPE;
+ }
+
+ function isMemo(object) {
+ return typeOf(object) === REACT_MEMO_TYPE;
+ }
+
+ function isPortal(object) {
+ return typeOf(object) === REACT_PORTAL_TYPE;
+ }
+
+ function isProfiler(object) {
+ return typeOf(object) === REACT_PROFILER_TYPE;
+ }
+
+ function isStrictMode(object) {
+ return typeOf(object) === REACT_STRICT_MODE_TYPE;
+ }
+
+ function isSuspense(object) {
+ return typeOf(object) === REACT_SUSPENSE_TYPE;
+ }
+
+ exports.typeOf = typeOf;
+ exports.AsyncMode = AsyncMode;
+ exports.ConcurrentMode = ConcurrentMode;
+ exports.ContextConsumer = ContextConsumer;
+ exports.ContextProvider = ContextProvider;
+ exports.Element = Element;
+ exports.ForwardRef = ForwardRef;
+ exports.Fragment = Fragment;
+ exports.Lazy = Lazy;
+ exports.Memo = Memo;
+ exports.Portal = Portal;
+ exports.Profiler = Profiler;
+ exports.StrictMode = StrictMode;
+ exports.Suspense = Suspense;
+ exports.isValidElementType = isValidElementType;
+ exports.isAsyncMode = isAsyncMode;
+ exports.isConcurrentMode = isConcurrentMode;
+ exports.isContextConsumer = isContextConsumer;
+ exports.isContextProvider = isContextProvider;
+ exports.isElement = isElement;
+ exports.isForwardRef = isForwardRef;
+ exports.isFragment = isFragment;
+ exports.isLazy = isLazy;
+ exports.isMemo = isMemo;
+ exports.isPortal = isPortal;
+ exports.isProfiler = isProfiler;
+ exports.isStrictMode = isStrictMode;
+ exports.isSuspense = isSuspense;
+ })();
+ }
+},65,[],"node_modules\\react-is\\cjs\\react-is.development.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var ReactIs = _$$_REQUIRE(_dependencyMap[0], "react-is");
+
+ var assign = _$$_REQUIRE(_dependencyMap[1], "object-assign");
+
+ var ReactPropTypesSecret = _$$_REQUIRE(_dependencyMap[2], "./lib/ReactPropTypesSecret");
+
+ var checkPropTypes = _$$_REQUIRE(_dependencyMap[3], "./checkPropTypes");
+
+ var has = Function.call.bind(Object.prototype.hasOwnProperty);
+
+ var printWarning = function printWarning() {};
+
+ if (process.env.NODE_ENV !== 'production') {
+ printWarning = function printWarning(text) {
+ var message = 'Warning: ' + text;
+
+ if (typeof console !== 'undefined') {
+ console.error(message);
+ }
+
+ try {
+ throw new Error(message);
+ } catch (x) {}
+ };
+ }
+
+ function emptyFunctionThatReturnsNull() {
+ return null;
+ }
+
+ module.exports = function (isValidElement, throwOnDirectAccess) {
+ var ITERATOR_SYMBOL = typeof Symbol === 'function' && (typeof Symbol === "function" ? Symbol.iterator : "@@iterator");
+ var FAUX_ITERATOR_SYMBOL = '@@iterator';
+
+ function getIteratorFn(maybeIterable) {
+ var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);
+
+ if (typeof iteratorFn === 'function') {
+ return iteratorFn;
+ }
+ }
+
+ var ANONYMOUS = '<>';
+ var ReactPropTypes = {
+ array: createPrimitiveTypeChecker('array'),
+ bool: createPrimitiveTypeChecker('boolean'),
+ func: createPrimitiveTypeChecker('function'),
+ number: createPrimitiveTypeChecker('number'),
+ object: createPrimitiveTypeChecker('object'),
+ string: createPrimitiveTypeChecker('string'),
+ symbol: createPrimitiveTypeChecker('symbol'),
+ any: createAnyTypeChecker(),
+ arrayOf: createArrayOfTypeChecker,
+ element: createElementTypeChecker(),
+ elementType: createElementTypeTypeChecker(),
+ instanceOf: createInstanceTypeChecker,
+ node: createNodeChecker(),
+ objectOf: createObjectOfTypeChecker,
+ oneOf: createEnumTypeChecker,
+ oneOfType: createUnionTypeChecker,
+ shape: createShapeTypeChecker,
+ exact: createStrictShapeTypeChecker
+ };
+
+ function is(x, y) {
+ if (x === y) {
+ return x !== 0 || 1 / x === 1 / y;
+ } else {
+ return x !== x && y !== y;
+ }
+ }
+
+ function PropTypeError(message) {
+ this.message = message;
+ this.stack = '';
+ }
+
+ PropTypeError.prototype = Error.prototype;
+
+ function createChainableTypeChecker(validate) {
+ if (process.env.NODE_ENV !== 'production') {
+ var manualPropTypeCallCache = {};
+ var manualPropTypeWarningCount = 0;
+ }
+
+ function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {
+ componentName = componentName || ANONYMOUS;
+ propFullName = propFullName || propName;
+
+ if (secret !== ReactPropTypesSecret) {
+ if (throwOnDirectAccess) {
+ var err = new Error('Calling PropTypes validators directly is not supported by the `prop-types` package. ' + 'Use `PropTypes.checkPropTypes()` to call them. ' + 'Read more at http://fb.me/use-check-prop-types');
+ err.name = 'Invariant Violation';
+ throw err;
+ } else if (process.env.NODE_ENV !== 'production' && typeof console !== 'undefined') {
+ var cacheKey = componentName + ':' + propName;
+
+ if (!manualPropTypeCallCache[cacheKey] && manualPropTypeWarningCount < 3) {
+ printWarning('You are manually calling a React.PropTypes validation ' + 'function for the `' + propFullName + '` prop on `' + componentName + '`. This is deprecated ' + 'and will throw in the standalone `prop-types` package. ' + 'You may be seeing this warning due to a third-party PropTypes ' + 'library. See https://fb.me/react-warning-dont-call-proptypes ' + 'for details.');
+ manualPropTypeCallCache[cacheKey] = true;
+ manualPropTypeWarningCount++;
+ }
+ }
+ }
+
+ if (props[propName] == null) {
+ if (isRequired) {
+ if (props[propName] === null) {
+ return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required ' + ('in `' + componentName + '`, but its value is `null`.'));
+ }
+
+ return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required in ' + ('`' + componentName + '`, but its value is `undefined`.'));
+ }
+
+ return null;
+ } else {
+ return validate(props, propName, componentName, location, propFullName);
+ }
+ }
+
+ var chainedCheckType = checkType.bind(null, false);
+ chainedCheckType.isRequired = checkType.bind(null, true);
+ return chainedCheckType;
+ }
+
+ function createPrimitiveTypeChecker(expectedType) {
+ function validate(props, propName, componentName, location, propFullName, secret) {
+ var propValue = props[propName];
+ var propType = getPropType(propValue);
+
+ if (propType !== expectedType) {
+ var preciseType = getPreciseType(propValue);
+ return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + preciseType + '` supplied to `' + componentName + '`, expected ') + ('`' + expectedType + '`.'));
+ }
+
+ return null;
+ }
+
+ return createChainableTypeChecker(validate);
+ }
+
+ function createAnyTypeChecker() {
+ return createChainableTypeChecker(emptyFunctionThatReturnsNull);
+ }
+
+ function createArrayOfTypeChecker(typeChecker) {
+ function validate(props, propName, componentName, location, propFullName) {
+ if (typeof typeChecker !== 'function') {
+ return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside arrayOf.');
+ }
+
+ var propValue = props[propName];
+
+ if (!Array.isArray(propValue)) {
+ var propType = getPropType(propValue);
+ return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an array.'));
+ }
+
+ for (var i = 0; i < propValue.length; i++) {
+ var error = typeChecker(propValue, i, componentName, location, propFullName + '[' + i + ']', ReactPropTypesSecret);
+
+ if (error instanceof Error) {
+ return error;
+ }
+ }
+
+ return null;
+ }
+
+ return createChainableTypeChecker(validate);
+ }
+
+ function createElementTypeChecker() {
+ function validate(props, propName, componentName, location, propFullName) {
+ var propValue = props[propName];
+
+ if (!isValidElement(propValue)) {
+ var propType = getPropType(propValue);
+ return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement.'));
+ }
+
+ return null;
+ }
+
+ return createChainableTypeChecker(validate);
+ }
+
+ function createElementTypeTypeChecker() {
+ function validate(props, propName, componentName, location, propFullName) {
+ var propValue = props[propName];
+
+ if (!ReactIs.isValidElementType(propValue)) {
+ var propType = getPropType(propValue);
+ return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement type.'));
+ }
+
+ return null;
+ }
+
+ return createChainableTypeChecker(validate);
+ }
+
+ function createInstanceTypeChecker(expectedClass) {
+ function validate(props, propName, componentName, location, propFullName) {
+ if (!(props[propName] instanceof expectedClass)) {
+ var expectedClassName = expectedClass.name || ANONYMOUS;
+ var actualClassName = getClassName(props[propName]);
+ return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + actualClassName + '` supplied to `' + componentName + '`, expected ') + ('instance of `' + expectedClassName + '`.'));
+ }
+
+ return null;
+ }
+
+ return createChainableTypeChecker(validate);
+ }
+
+ function createEnumTypeChecker(expectedValues) {
+ if (!Array.isArray(expectedValues)) {
+ if (process.env.NODE_ENV !== 'production') {
+ if (arguments.length > 1) {
+ printWarning('Invalid arguments supplied to oneOf, expected an array, got ' + arguments.length + ' arguments. ' + 'A common mistake is to write oneOf(x, y, z) instead of oneOf([x, y, z]).');
+ } else {
+ printWarning('Invalid argument supplied to oneOf, expected an array.');
+ }
+ }
+
+ return emptyFunctionThatReturnsNull;
+ }
+
+ function validate(props, propName, componentName, location, propFullName) {
+ var propValue = props[propName];
+
+ for (var i = 0; i < expectedValues.length; i++) {
+ if (is(propValue, expectedValues[i])) {
+ return null;
+ }
+ }
+
+ var valuesString = JSON.stringify(expectedValues, function replacer(key, value) {
+ var type = getPreciseType(value);
+
+ if (type === 'symbol') {
+ return String(value);
+ }
+
+ return value;
+ });
+ return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of value `' + String(propValue) + '` ' + ('supplied to `' + componentName + '`, expected one of ' + valuesString + '.'));
+ }
+
+ return createChainableTypeChecker(validate);
+ }
+
+ function createObjectOfTypeChecker(typeChecker) {
+ function validate(props, propName, componentName, location, propFullName) {
+ if (typeof typeChecker !== 'function') {
+ return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside objectOf.');
+ }
+
+ var propValue = props[propName];
+ var propType = getPropType(propValue);
+
+ if (propType !== 'object') {
+ return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an object.'));
+ }
+
+ for (var key in propValue) {
+ if (has(propValue, key)) {
+ var error = typeChecker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
+
+ if (error instanceof Error) {
+ return error;
+ }
+ }
+ }
+
+ return null;
+ }
+
+ return createChainableTypeChecker(validate);
+ }
+
+ function createUnionTypeChecker(arrayOfTypeCheckers) {
+ if (!Array.isArray(arrayOfTypeCheckers)) {
+ process.env.NODE_ENV !== 'production' ? printWarning('Invalid argument supplied to oneOfType, expected an instance of array.') : void 0;
+ return emptyFunctionThatReturnsNull;
+ }
+
+ for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
+ var checker = arrayOfTypeCheckers[i];
+
+ if (typeof checker !== 'function') {
+ printWarning('Invalid argument supplied to oneOfType. Expected an array of check functions, but ' + 'received ' + getPostfixForTypeWarning(checker) + ' at index ' + i + '.');
+ return emptyFunctionThatReturnsNull;
+ }
+ }
+
+ function validate(props, propName, componentName, location, propFullName) {
+ for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
+ var checker = arrayOfTypeCheckers[i];
+
+ if (checker(props, propName, componentName, location, propFullName, ReactPropTypesSecret) == null) {
+ return null;
+ }
+ }
+
+ return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`.'));
+ }
+
+ return createChainableTypeChecker(validate);
+ }
+
+ function createNodeChecker() {
+ function validate(props, propName, componentName, location, propFullName) {
+ if (!isNode(props[propName])) {
+ return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`, expected a ReactNode.'));
+ }
+
+ return null;
+ }
+
+ return createChainableTypeChecker(validate);
+ }
+
+ function createShapeTypeChecker(shapeTypes) {
+ function validate(props, propName, componentName, location, propFullName) {
+ var propValue = props[propName];
+ var propType = getPropType(propValue);
+
+ if (propType !== 'object') {
+ return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));
+ }
+
+ for (var key in shapeTypes) {
+ var checker = shapeTypes[key];
+
+ if (!checker) {
+ continue;
+ }
+
+ var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
+
+ if (error) {
+ return error;
+ }
+ }
+
+ return null;
+ }
+
+ return createChainableTypeChecker(validate);
+ }
+
+ function createStrictShapeTypeChecker(shapeTypes) {
+ function validate(props, propName, componentName, location, propFullName) {
+ var propValue = props[propName];
+ var propType = getPropType(propValue);
+
+ if (propType !== 'object') {
+ return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));
+ }
+
+ var allKeys = assign({}, props[propName], shapeTypes);
+
+ for (var key in allKeys) {
+ var checker = shapeTypes[key];
+
+ if (!checker) {
+ return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` key `' + key + '` supplied to `' + componentName + '`.' + '\nBad object: ' + JSON.stringify(props[propName], null, ' ') + '\nValid keys: ' + JSON.stringify(Object.keys(shapeTypes), null, ' '));
+ }
+
+ var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
+
+ if (error) {
+ return error;
+ }
+ }
+
+ return null;
+ }
+
+ return createChainableTypeChecker(validate);
+ }
+
+ function isNode(propValue) {
+ switch (typeof propValue) {
+ case 'number':
+ case 'string':
+ case 'undefined':
+ return true;
+
+ case 'boolean':
+ return !propValue;
+
+ case 'object':
+ if (Array.isArray(propValue)) {
+ return propValue.every(isNode);
+ }
+
+ if (propValue === null || isValidElement(propValue)) {
+ return true;
+ }
+
+ var iteratorFn = getIteratorFn(propValue);
+
+ if (iteratorFn) {
+ var iterator = iteratorFn.call(propValue);
+ var step;
+
+ if (iteratorFn !== propValue.entries) {
+ while (!(step = iterator.next()).done) {
+ if (!isNode(step.value)) {
+ return false;
+ }
+ }
+ } else {
+ while (!(step = iterator.next()).done) {
+ var entry = step.value;
+
+ if (entry) {
+ if (!isNode(entry[1])) {
+ return false;
+ }
+ }
+ }
+ }
+ } else {
+ return false;
+ }
+
+ return true;
+
+ default:
+ return false;
+ }
+ }
+
+ function isSymbol(propType, propValue) {
+ if (propType === 'symbol') {
+ return true;
+ }
+
+ if (!propValue) {
+ return false;
+ }
+
+ if (propValue['@@toStringTag'] === 'Symbol') {
+ return true;
+ }
+
+ if (typeof Symbol === 'function' && propValue instanceof Symbol) {
+ return true;
+ }
+
+ return false;
+ }
+
+ function getPropType(propValue) {
+ var propType = typeof propValue;
+
+ if (Array.isArray(propValue)) {
+ return 'array';
+ }
+
+ if (propValue instanceof RegExp) {
+ return 'object';
+ }
+
+ if (isSymbol(propType, propValue)) {
+ return 'symbol';
+ }
+
+ return propType;
+ }
+
+ function getPreciseType(propValue) {
+ if (typeof propValue === 'undefined' || propValue === null) {
+ return '' + propValue;
+ }
+
+ var propType = getPropType(propValue);
+
+ if (propType === 'object') {
+ if (propValue instanceof Date) {
+ return 'date';
+ } else if (propValue instanceof RegExp) {
+ return 'regexp';
+ }
+ }
+
+ return propType;
+ }
+
+ function getPostfixForTypeWarning(value) {
+ var type = getPreciseType(value);
+
+ switch (type) {
+ case 'array':
+ case 'object':
+ return 'an ' + type;
+
+ case 'boolean':
+ case 'date':
+ case 'regexp':
+ return 'a ' + type;
+
+ default:
+ return type;
+ }
+ }
+
+ function getClassName(propValue) {
+ if (!propValue.constructor || !propValue.constructor.name) {
+ return ANONYMOUS;
+ }
+
+ return propValue.constructor.name;
+ }
+
+ ReactPropTypes.checkPropTypes = checkPropTypes;
+ ReactPropTypes.resetWarningCache = checkPropTypes.resetWarningCache;
+ ReactPropTypes.PropTypes = ReactPropTypes;
+ return ReactPropTypes;
+ };
+},66,[63,13,17,16],"node_modules\\prop-types\\factoryWithTypeCheckers.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var ReactPropTypesSecret = _$$_REQUIRE(_dependencyMap[0], "./lib/ReactPropTypesSecret");
+
+ function emptyFunction() {}
+
+ function emptyFunctionWithReset() {}
+
+ emptyFunctionWithReset.resetWarningCache = emptyFunction;
+
+ module.exports = function () {
+ function shim(props, propName, componentName, location, propFullName, secret) {
+ if (secret === ReactPropTypesSecret) {
+ return;
+ }
+
+ var err = new Error('Calling PropTypes validators directly is not supported by the `prop-types` package. ' + 'Use PropTypes.checkPropTypes() to call them. ' + 'Read more at http://fb.me/use-check-prop-types');
+ err.name = 'Invariant Violation';
+ throw err;
+ }
+
+ ;
+ shim.isRequired = shim;
+
+ function getShim() {
+ return shim;
+ }
+
+ ;
+ var ReactPropTypes = {
+ array: shim,
+ bool: shim,
+ func: shim,
+ number: shim,
+ object: shim,
+ string: shim,
+ symbol: shim,
+ any: shim,
+ arrayOf: getShim,
+ element: shim,
+ elementType: shim,
+ instanceOf: getShim,
+ node: shim,
+ objectOf: getShim,
+ oneOf: getShim,
+ oneOfType: getShim,
+ shape: getShim,
+ exact: getShim,
+ checkPropTypes: emptyFunctionWithReset,
+ resetWarningCache: emptyFunction
+ };
+ ReactPropTypes.PropTypes = ReactPropTypes;
+ return ReactPropTypes;
+ };
+},67,[17],"node_modules\\prop-types\\factoryWithThrowingShims.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var DeprecatedColorPropType = _$$_REQUIRE(_dependencyMap[0], "DeprecatedColorPropType");
+
+ var ReactPropTypes = _$$_REQUIRE(_dependencyMap[1], "prop-types");
+
+ var DeprecatedShadowPropTypesIOS = {
+ shadowColor: DeprecatedColorPropType,
+ shadowOffset: ReactPropTypes.shape({
+ width: ReactPropTypes.number,
+ height: ReactPropTypes.number
+ }),
+ shadowOpacity: ReactPropTypes.number,
+ shadowRadius: ReactPropTypes.number
+ };
+ module.exports = DeprecatedShadowPropTypesIOS;
+},68,[59,62],"node_modules\\react-native\\Libraries\\DeprecatedPropTypes\\DeprecatedShadowPropTypesIOS.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var ReactPropTypes = _$$_REQUIRE(_dependencyMap[0], "prop-types");
+
+ var deprecatedPropType = _$$_REQUIRE(_dependencyMap[1], "deprecatedPropType");
+
+ var TransformMatrixPropType = function TransformMatrixPropType(props, propName, componentName) {
+ if (props[propName]) {
+ return new Error('The transformMatrix style property is deprecated. ' + 'Use `transform: [{ matrix: ... }]` instead.');
+ }
+ };
+
+ var DecomposedMatrixPropType = function DecomposedMatrixPropType(props, propName, componentName) {
+ if (props[propName]) {
+ return new Error('The decomposedMatrix style property is deprecated. ' + 'Use `transform: [...]` instead.');
+ }
+ };
+
+ var DeprecatedTransformPropTypes = {
+ transform: ReactPropTypes.arrayOf(ReactPropTypes.oneOfType([ReactPropTypes.shape({
+ perspective: ReactPropTypes.number
+ }), ReactPropTypes.shape({
+ rotate: ReactPropTypes.string
+ }), ReactPropTypes.shape({
+ rotateX: ReactPropTypes.string
+ }), ReactPropTypes.shape({
+ rotateY: ReactPropTypes.string
+ }), ReactPropTypes.shape({
+ rotateZ: ReactPropTypes.string
+ }), ReactPropTypes.shape({
+ scale: ReactPropTypes.number
+ }), ReactPropTypes.shape({
+ scaleX: ReactPropTypes.number
+ }), ReactPropTypes.shape({
+ scaleY: ReactPropTypes.number
+ }), ReactPropTypes.shape({
+ translateX: ReactPropTypes.number
+ }), ReactPropTypes.shape({
+ translateY: ReactPropTypes.number
+ }), ReactPropTypes.shape({
+ skewX: ReactPropTypes.string
+ }), ReactPropTypes.shape({
+ skewY: ReactPropTypes.string
+ })])),
+ transformMatrix: TransformMatrixPropType,
+ decomposedMatrix: DecomposedMatrixPropType,
+ scaleX: deprecatedPropType(ReactPropTypes.number, 'Use the transform prop instead.'),
+ scaleY: deprecatedPropType(ReactPropTypes.number, 'Use the transform prop instead.'),
+ rotation: deprecatedPropType(ReactPropTypes.number, 'Use the transform prop instead.'),
+ translateX: deprecatedPropType(ReactPropTypes.number, 'Use the transform prop instead.'),
+ translateY: deprecatedPropType(ReactPropTypes.number, 'Use the transform prop instead.')
+ };
+ module.exports = DeprecatedTransformPropTypes;
+},69,[62,70],"node_modules\\react-native\\Libraries\\DeprecatedPropTypes\\DeprecatedTransformPropTypes.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var UIManager = _$$_REQUIRE(_dependencyMap[0], "UIManager");
+
+ function deprecatedPropType(propType, explanation) {
+ return function validate(props, propName, componentName) {
+ if (!UIManager.getViewManagerConfig(componentName) && props[propName] !== undefined) {
+ console.warn("`" + propName + "` supplied to `" + componentName + "` has been deprecated. " + explanation);
+ }
+
+ for (var _len = arguments.length, rest = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {
+ rest[_key - 3] = arguments[_key];
+ }
+
+ return propType.apply(void 0, [props, propName, componentName].concat(rest));
+ };
+ }
+
+ module.exports = deprecatedPropType;
+},70,[71],"node_modules\\react-native\\Libraries\\Utilities\\deprecatedPropType.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var NativeModules = _$$_REQUIRE(_dependencyMap[0], "NativeModules");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[1], "Platform");
+
+ var UIManagerProperties = _$$_REQUIRE(_dependencyMap[2], "UIManagerProperties");
+
+ var defineLazyObjectProperty = _$$_REQUIRE(_dependencyMap[3], "defineLazyObjectProperty");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[4], "invariant");
+
+ var UIManager = NativeModules.UIManager;
+ var viewManagerConfigs = {};
+ 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.');
+ };
+
+ var triedLoadingConfig = new Set();
+
+ UIManager.getViewManagerConfig = function (viewManagerName) {
+ if (viewManagerConfigs[viewManagerName] === undefined && UIManager.getConstantsForViewManager) {
+ try {
+ viewManagerConfigs[viewManagerName] = UIManager.getConstantsForViewManager(viewManagerName);
+ } catch (e) {
+ viewManagerConfigs[viewManagerName] = null;
+ }
+ }
+
+ var config = viewManagerConfigs[viewManagerName];
+
+ if (config) {
+ return config;
+ }
+
+ if (!global.nativeCallSyncHook) {
+ return config;
+ }
+
+ if (UIManager.lazilyLoadView && !triedLoadingConfig.has(viewManagerName)) {
+ var result = UIManager.lazilyLoadView(viewManagerName);
+ triedLoadingConfig.add(viewManagerName);
+
+ if (result.viewConfig) {
+ UIManager[viewManagerName] = result.viewConfig;
+ lazifyViewManagerConfig(viewManagerName);
+ }
+ }
+
+ return viewManagerConfigs[viewManagerName];
+ };
+
+ function lazifyViewManagerConfig(viewName) {
+ var viewConfig = UIManager[viewName];
+
+ if (viewConfig.Manager) {
+ viewManagerConfigs[viewName] = viewConfig;
+ defineLazyObjectProperty(viewConfig, 'Constants', {
+ get: function get() {
+ var viewManager = NativeModules[viewConfig.Manager];
+ var constants = {};
+ viewManager && Object.keys(viewManager).forEach(function (key) {
+ var value = viewManager[key];
+
+ if (typeof value !== 'function') {
+ constants[key] = value;
+ }
+ });
+ return constants;
+ }
+ });
+ defineLazyObjectProperty(viewConfig, 'Commands', {
+ get: function get() {
+ var viewManager = NativeModules[viewConfig.Manager];
+ var commands = {};
+ var index = 0;
+ viewManager && Object.keys(viewManager).forEach(function (key) {
+ var value = viewManager[key];
+
+ if (typeof value === 'function') {
+ commands[key] = index++;
+ }
+ });
+ return commands;
+ }
+ });
+ }
+ }
+
+ if (Platform.OS === 'ios' || Platform.OS === 'macos') {
+ Object.keys(UIManager).forEach(function (viewName) {
+ lazifyViewManagerConfig(viewName);
+ });
+ } 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);
+ }
+ }
+
+ if (!global.nativeCallSyncHook) {
+ Object.keys(UIManager).forEach(function (viewManagerName) {
+ if (!UIManagerProperties.includes(viewManagerName)) {
+ if (!viewManagerConfigs[viewManagerName]) {
+ viewManagerConfigs[viewManagerName] = UIManager[viewManagerName];
+ }
+
+ defineLazyObjectProperty(UIManager, viewManagerName, {
+ get: function get() {
+ console.warn("Accessing view manager configs directly off UIManager via UIManager['" + viewManagerName + "'] " + ("is no longer supported. Use UIManager.getViewManagerConfig('" + viewManagerName + "') instead."));
+ return UIManager.getViewManagerConfig(viewManagerName);
+ }
+ });
+ }
+ });
+ }
+
+ module.exports = UIManager;
+},71,[36,35,72,51,19],"node_modules\\react-native\\Libraries\\ReactNative\\UIManager.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ module.exports = ['clearJSResponder', 'configureNextLayoutAnimation', 'createView', 'dismissPopupMenu', 'dispatchViewManagerCommand', 'findSubviewIn', 'getConstantsForViewManager', 'getDefaultEventTypes', 'manageChildren', 'measure', 'measureInWindow', 'measureLayout', 'measureLayoutRelativeToParent', 'playTouchSound', 'removeRootView', 'removeSubviewsFromContainerWithID', 'replaceExistingNonRootView', 'sendAccessibilityEvent', 'setChildren', 'setJSResponder', 'setLayoutAnimationEnabledExperimental', 'showPopupMenu', 'updateView', 'viewIsDescendantOf', 'PopupMenu', 'LazyViewManagersEnabled', 'ViewManagerNames', 'StyleConstants', 'AccessibilityEventTypes', 'UIView', '__takeSnapshot', 'takeSnapshot', 'getViewManagerConfig', 'blur', 'focus', 'genericBubblingEventTypes', 'genericDirectEventTypes', 'lazilyLoadView'];
+},72,[],"node_modules\\react-native\\Libraries\\ReactNative\\UIManagerProperties.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var DeprecatedColorPropType = _$$_REQUIRE(_dependencyMap[1], "DeprecatedColorPropType");
+
+ var ReactPropTypes = _$$_REQUIRE(_dependencyMap[2], "prop-types");
+
+ var DeprecatedViewStylePropTypes = _$$_REQUIRE(_dependencyMap[3], "DeprecatedViewStylePropTypes");
+
+ var TextStylePropTypes = _objectSpread({}, DeprecatedViewStylePropTypes, {
+ color: DeprecatedColorPropType,
+ fontFamily: ReactPropTypes.string,
+ fontPath: ReactPropTypes.string,
+ fontSize: ReactPropTypes.number,
+ fontStyle: ReactPropTypes.oneOf(['normal', 'italic']),
+ fontWeight: ReactPropTypes.oneOf(['normal', 'bold', '100', '200', '300', '400', '500', '600', '700', '800', '900']),
+ fontVariant: ReactPropTypes.arrayOf(ReactPropTypes.oneOf(['small-caps', 'oldstyle-nums', 'lining-nums', 'tabular-nums', 'proportional-nums'])),
+ textShadowOffset: ReactPropTypes.shape({
+ width: ReactPropTypes.number,
+ height: ReactPropTypes.number
+ }),
+ textShadowRadius: ReactPropTypes.number,
+ textShadowColor: DeprecatedColorPropType,
+ letterSpacing: ReactPropTypes.number,
+ lineHeight: ReactPropTypes.number,
+ textAlign: ReactPropTypes.oneOf(['auto', 'left', 'right', 'center', 'justify']),
+ textAlignVertical: ReactPropTypes.oneOf(['auto', 'top', 'bottom', 'center']),
+ includeFontPadding: ReactPropTypes.bool,
+ textDecorationLine: ReactPropTypes.oneOf(['none', 'underline', 'line-through', 'underline line-through']),
+ textDecorationStyle: ReactPropTypes.oneOf(['solid', 'double', 'dotted', 'dashed']),
+ textDecorationColor: DeprecatedColorPropType,
+ textTransform: ReactPropTypes.oneOf(['none', 'capitalize', 'uppercase', 'lowercase']),
+ writingDirection: ReactPropTypes.oneOf(['auto', 'ltr', 'rtl'])
+ });
+
+ module.exports = TextStylePropTypes;
+},73,[32,59,62,74],"node_modules\\react-native\\Libraries\\Text\\TextStylePropTypes.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var DeprecatedColorPropType = _$$_REQUIRE(_dependencyMap[1], "DeprecatedColorPropType");
+
+ var DeprecatedLayoutPropTypes = _$$_REQUIRE(_dependencyMap[2], "DeprecatedLayoutPropTypes");
+
+ var ReactPropTypes = _$$_REQUIRE(_dependencyMap[3], "prop-types");
+
+ var DeprecatedShadowPropTypesIOS = _$$_REQUIRE(_dependencyMap[4], "DeprecatedShadowPropTypesIOS");
+
+ var DeprecatedTransformPropTypes = _$$_REQUIRE(_dependencyMap[5], "DeprecatedTransformPropTypes");
+
+ var DeprecatedViewStylePropTypes = _objectSpread({}, DeprecatedLayoutPropTypes, {}, DeprecatedShadowPropTypesIOS, {}, DeprecatedTransformPropTypes, {
+ backfaceVisibility: ReactPropTypes.oneOf(['visible', 'hidden']),
+ backgroundColor: DeprecatedColorPropType,
+ borderColor: DeprecatedColorPropType,
+ borderTopColor: DeprecatedColorPropType,
+ borderRightColor: DeprecatedColorPropType,
+ borderBottomColor: DeprecatedColorPropType,
+ borderLeftColor: DeprecatedColorPropType,
+ borderStartColor: DeprecatedColorPropType,
+ borderEndColor: DeprecatedColorPropType,
+ borderRadius: ReactPropTypes.number,
+ borderTopLeftRadius: ReactPropTypes.number,
+ borderTopRightRadius: ReactPropTypes.number,
+ borderTopStartRadius: ReactPropTypes.number,
+ borderTopEndRadius: ReactPropTypes.number,
+ borderBottomLeftRadius: ReactPropTypes.number,
+ borderBottomRightRadius: ReactPropTypes.number,
+ borderBottomStartRadius: ReactPropTypes.number,
+ borderBottomEndRadius: ReactPropTypes.number,
+ borderStyle: ReactPropTypes.oneOf(['solid', 'dotted', 'dashed']),
+ borderWidth: ReactPropTypes.number,
+ borderTopWidth: ReactPropTypes.number,
+ borderRightWidth: ReactPropTypes.number,
+ borderBottomWidth: ReactPropTypes.number,
+ borderLeftWidth: ReactPropTypes.number,
+ opacity: ReactPropTypes.number,
+ elevation: ReactPropTypes.number
+ });
+
+ module.exports = DeprecatedViewStylePropTypes;
+},74,[32,59,61,62,68,69],"node_modules\\react-native\\Libraries\\DeprecatedPropTypes\\DeprecatedViewStylePropTypes.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var Platform = _$$_REQUIRE(_dependencyMap[0], "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;
+ }
+
+ if (typeof int32Color === 'object' && Platform.OS === 'macos') {
+ if ('dynamic' in int32Color && int32Color.dynamic !== undefined) {
+ var dynamic = int32Color.dynamic;
+ var dynamicColor = {
+ dynamic: {
+ light: processColor(dynamic.light),
+ dark: processColor(dynamic.dark)
+ }
+ };
+ return dynamicColor;
+ }
+
+ return int32Color;
+ }
+
+ if (typeof int32Color !== 'number') {
+ return null;
+ }
+
+ int32Color = (int32Color << 24 | int32Color >>> 8) >>> 0;
+
+ if (Platform.OS === 'android') {
+ int32Color = int32Color | 0x0;
+ }
+
+ return int32Color;
+ }
+
+ module.exports = processColor;
+},75,[35,60],"node_modules\\react-native\\Libraries\\StyleSheet\\processColor.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var MatrixMath = _$$_REQUIRE(_dependencyMap[0], "MatrixMath");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[1], "Platform");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[2], "invariant");
+
+ var stringifySafe = _$$_REQUIRE(_dependencyMap[3], "stringifySafe");
+
+ function processTransform(transform) {
+ if (__DEV__) {
+ _validateTransforms(transform);
+ }
+
+ if (Platform.OS === 'android' || Platform.OS === 'ios' || Platform.OS === 'macos') {
+ 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 by .');
+ 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;
+},76,[77,35,19,50],"node_modules\\react-native\\Libraries\\StyleSheet\\processTransform.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _slicedToArray = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/slicedToArray");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[1], "invariant");
+
+ var MatrixMath = {
+ createIdentityMatrix: function createIdentityMatrix() {
+ return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+ },
+ createCopy: function createCopy(m) {
+ return [m[0], m[1], m[2], m[3], m[4], m[5], m[6], m[7], m[8], m[9], m[10], m[11], m[12], m[13], m[14], m[15]];
+ },
+ createOrthographic: function createOrthographic(left, right, bottom, top, near, far) {
+ var a = 2 / (right - left);
+ var b = 2 / (top - bottom);
+ var c = -2 / (far - near);
+ var tx = -(right + left) / (right - left);
+ var ty = -(top + bottom) / (top - bottom);
+ var tz = -(far + near) / (far - near);
+ return [a, 0, 0, 0, 0, b, 0, 0, 0, 0, c, 0, tx, ty, tz, 1];
+ },
+ createFrustum: function createFrustum(left, right, bottom, top, near, far) {
+ var r_width = 1 / (right - left);
+ var r_height = 1 / (top - bottom);
+ var r_depth = 1 / (near - far);
+ var x = 2 * (near * r_width);
+ var y = 2 * (near * r_height);
+ var A = (right + left) * r_width;
+ var B = (top + bottom) * r_height;
+ var C = (far + near) * r_depth;
+ var D = 2 * (far * near * r_depth);
+ return [x, 0, 0, 0, 0, y, 0, 0, A, B, C, -1, 0, 0, D, 0];
+ },
+ createPerspective: function createPerspective(fovInRadians, aspect, near, far) {
+ var h = 1 / Math.tan(fovInRadians / 2);
+ var r_depth = 1 / (near - far);
+ var C = (far + near) * r_depth;
+ var D = 2 * (far * near * r_depth);
+ return [h / aspect, 0, 0, 0, 0, h, 0, 0, 0, 0, C, -1, 0, 0, D, 0];
+ },
+ createTranslate2d: function createTranslate2d(x, y) {
+ var mat = MatrixMath.createIdentityMatrix();
+ MatrixMath.reuseTranslate2dCommand(mat, x, y);
+ return mat;
+ },
+ reuseTranslate2dCommand: function reuseTranslate2dCommand(matrixCommand, x, y) {
+ matrixCommand[12] = x;
+ matrixCommand[13] = y;
+ },
+ reuseTranslate3dCommand: function reuseTranslate3dCommand(matrixCommand, x, y, z) {
+ matrixCommand[12] = x;
+ matrixCommand[13] = y;
+ matrixCommand[14] = z;
+ },
+ createScale: function createScale(factor) {
+ var mat = MatrixMath.createIdentityMatrix();
+ MatrixMath.reuseScaleCommand(mat, factor);
+ return mat;
+ },
+ reuseScaleCommand: function reuseScaleCommand(matrixCommand, factor) {
+ matrixCommand[0] = factor;
+ matrixCommand[5] = factor;
+ },
+ reuseScale3dCommand: function reuseScale3dCommand(matrixCommand, x, y, z) {
+ matrixCommand[0] = x;
+ matrixCommand[5] = y;
+ matrixCommand[10] = z;
+ },
+ reusePerspectiveCommand: function reusePerspectiveCommand(matrixCommand, p) {
+ matrixCommand[11] = -1 / p;
+ },
+ reuseScaleXCommand: function reuseScaleXCommand(matrixCommand, factor) {
+ matrixCommand[0] = factor;
+ },
+ reuseScaleYCommand: function reuseScaleYCommand(matrixCommand, factor) {
+ matrixCommand[5] = factor;
+ },
+ reuseScaleZCommand: function reuseScaleZCommand(matrixCommand, factor) {
+ matrixCommand[10] = factor;
+ },
+ reuseRotateXCommand: function reuseRotateXCommand(matrixCommand, radians) {
+ matrixCommand[5] = Math.cos(radians);
+ matrixCommand[6] = Math.sin(radians);
+ matrixCommand[9] = -Math.sin(radians);
+ matrixCommand[10] = Math.cos(radians);
+ },
+ reuseRotateYCommand: function reuseRotateYCommand(matrixCommand, amount) {
+ matrixCommand[0] = Math.cos(amount);
+ matrixCommand[2] = -Math.sin(amount);
+ matrixCommand[8] = Math.sin(amount);
+ matrixCommand[10] = Math.cos(amount);
+ },
+ reuseRotateZCommand: function reuseRotateZCommand(matrixCommand, radians) {
+ matrixCommand[0] = Math.cos(radians);
+ matrixCommand[1] = Math.sin(radians);
+ matrixCommand[4] = -Math.sin(radians);
+ matrixCommand[5] = Math.cos(radians);
+ },
+ createRotateZ: function createRotateZ(radians) {
+ var mat = MatrixMath.createIdentityMatrix();
+ MatrixMath.reuseRotateZCommand(mat, radians);
+ return mat;
+ },
+ reuseSkewXCommand: function reuseSkewXCommand(matrixCommand, radians) {
+ matrixCommand[4] = Math.tan(radians);
+ },
+ reuseSkewYCommand: function reuseSkewYCommand(matrixCommand, radians) {
+ matrixCommand[1] = Math.tan(radians);
+ },
+ multiplyInto: function multiplyInto(out, a, b) {
+ var a00 = a[0],
+ a01 = a[1],
+ a02 = a[2],
+ a03 = a[3],
+ a10 = a[4],
+ a11 = a[5],
+ a12 = a[6],
+ a13 = a[7],
+ a20 = a[8],
+ a21 = a[9],
+ a22 = a[10],
+ a23 = a[11],
+ a30 = a[12],
+ a31 = a[13],
+ a32 = a[14],
+ a33 = a[15];
+ var b0 = b[0],
+ b1 = b[1],
+ b2 = b[2],
+ b3 = b[3];
+ out[0] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+ out[1] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+ out[2] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+ out[3] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+ b0 = b[4];
+ b1 = b[5];
+ b2 = b[6];
+ b3 = b[7];
+ out[4] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+ out[5] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+ out[6] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+ out[7] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+ b0 = b[8];
+ b1 = b[9];
+ b2 = b[10];
+ b3 = b[11];
+ out[8] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+ out[9] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+ out[10] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+ out[11] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+ b0 = b[12];
+ b1 = b[13];
+ b2 = b[14];
+ b3 = b[15];
+ out[12] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+ out[13] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+ out[14] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+ out[15] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+ },
+ determinant: function determinant(matrix) {
+ var _matrix = _slicedToArray(matrix, 16),
+ m00 = _matrix[0],
+ m01 = _matrix[1],
+ m02 = _matrix[2],
+ m03 = _matrix[3],
+ m10 = _matrix[4],
+ m11 = _matrix[5],
+ m12 = _matrix[6],
+ m13 = _matrix[7],
+ m20 = _matrix[8],
+ m21 = _matrix[9],
+ m22 = _matrix[10],
+ m23 = _matrix[11],
+ m30 = _matrix[12],
+ m31 = _matrix[13],
+ m32 = _matrix[14],
+ m33 = _matrix[15];
+
+ return m03 * m12 * m21 * m30 - m02 * m13 * m21 * m30 - m03 * m11 * m22 * m30 + m01 * m13 * m22 * m30 + m02 * m11 * m23 * m30 - m01 * m12 * m23 * m30 - m03 * m12 * m20 * m31 + m02 * m13 * m20 * m31 + m03 * m10 * m22 * m31 - m00 * m13 * m22 * m31 - m02 * m10 * m23 * m31 + m00 * m12 * m23 * m31 + m03 * m11 * m20 * m32 - m01 * m13 * m20 * m32 - m03 * m10 * m21 * m32 + m00 * m13 * m21 * m32 + m01 * m10 * m23 * m32 - m00 * m11 * m23 * m32 - m02 * m11 * m20 * m33 + m01 * m12 * m20 * m33 + m02 * m10 * m21 * m33 - m00 * m12 * m21 * m33 - m01 * m10 * m22 * m33 + m00 * m11 * m22 * m33;
+ },
+ inverse: function inverse(matrix) {
+ var det = MatrixMath.determinant(matrix);
+
+ if (!det) {
+ return matrix;
+ }
+
+ var _matrix2 = _slicedToArray(matrix, 16),
+ m00 = _matrix2[0],
+ m01 = _matrix2[1],
+ m02 = _matrix2[2],
+ m03 = _matrix2[3],
+ m10 = _matrix2[4],
+ m11 = _matrix2[5],
+ m12 = _matrix2[6],
+ m13 = _matrix2[7],
+ m20 = _matrix2[8],
+ m21 = _matrix2[9],
+ m22 = _matrix2[10],
+ m23 = _matrix2[11],
+ m30 = _matrix2[12],
+ m31 = _matrix2[13],
+ m32 = _matrix2[14],
+ m33 = _matrix2[15];
+
+ return [(m12 * m23 * m31 - m13 * m22 * m31 + m13 * m21 * m32 - m11 * m23 * m32 - m12 * m21 * m33 + m11 * m22 * m33) / det, (m03 * m22 * m31 - m02 * m23 * m31 - m03 * m21 * m32 + m01 * m23 * m32 + m02 * m21 * m33 - m01 * m22 * m33) / det, (m02 * m13 * m31 - m03 * m12 * m31 + m03 * m11 * m32 - m01 * m13 * m32 - m02 * m11 * m33 + m01 * m12 * m33) / det, (m03 * m12 * m21 - m02 * m13 * m21 - m03 * m11 * m22 + m01 * m13 * m22 + m02 * m11 * m23 - m01 * m12 * m23) / det, (m13 * m22 * m30 - m12 * m23 * m30 - m13 * m20 * m32 + m10 * m23 * m32 + m12 * m20 * m33 - m10 * m22 * m33) / det, (m02 * m23 * m30 - m03 * m22 * m30 + m03 * m20 * m32 - m00 * m23 * m32 - m02 * m20 * m33 + m00 * m22 * m33) / det, (m03 * m12 * m30 - m02 * m13 * m30 - m03 * m10 * m32 + m00 * m13 * m32 + m02 * m10 * m33 - m00 * m12 * m33) / det, (m02 * m13 * m20 - m03 * m12 * m20 + m03 * m10 * m22 - m00 * m13 * m22 - m02 * m10 * m23 + m00 * m12 * m23) / det, (m11 * m23 * m30 - m13 * m21 * m30 + m13 * m20 * m31 - m10 * m23 * m31 - m11 * m20 * m33 + m10 * m21 * m33) / det, (m03 * m21 * m30 - m01 * m23 * m30 - m03 * m20 * m31 + m00 * m23 * m31 + m01 * m20 * m33 - m00 * m21 * m33) / det, (m01 * m13 * m30 - m03 * m11 * m30 + m03 * m10 * m31 - m00 * m13 * m31 - m01 * m10 * m33 + m00 * m11 * m33) / det, (m03 * m11 * m20 - m01 * m13 * m20 - m03 * m10 * m21 + m00 * m13 * m21 + m01 * m10 * m23 - m00 * m11 * m23) / det, (m12 * m21 * m30 - m11 * m22 * m30 - m12 * m20 * m31 + m10 * m22 * m31 + m11 * m20 * m32 - m10 * m21 * m32) / det, (m01 * m22 * m30 - m02 * m21 * m30 + m02 * m20 * m31 - m00 * m22 * m31 - m01 * m20 * m32 + m00 * m21 * m32) / det, (m02 * m11 * m30 - m01 * m12 * m30 - m02 * m10 * m31 + m00 * m12 * m31 + m01 * m10 * m32 - m00 * m11 * m32) / det, (m01 * m12 * m20 - m02 * m11 * m20 + m02 * m10 * m21 - m00 * m12 * m21 - m01 * m10 * m22 + m00 * m11 * m22) / det];
+ },
+ transpose: function transpose(m) {
+ return [m[0], m[4], m[8], m[12], m[1], m[5], m[9], m[13], m[2], m[6], m[10], m[14], m[3], m[7], m[11], m[15]];
+ },
+ multiplyVectorByMatrix: function multiplyVectorByMatrix(v, m) {
+ var _v = _slicedToArray(v, 4),
+ vx = _v[0],
+ vy = _v[1],
+ vz = _v[2],
+ vw = _v[3];
+
+ return [vx * m[0] + vy * m[4] + vz * m[8] + vw * m[12], vx * m[1] + vy * m[5] + vz * m[9] + vw * m[13], vx * m[2] + vy * m[6] + vz * m[10] + vw * m[14], vx * m[3] + vy * m[7] + vz * m[11] + vw * m[15]];
+ },
+ v3Length: function v3Length(a) {
+ return Math.sqrt(a[0] * a[0] + a[1] * a[1] + a[2] * a[2]);
+ },
+ v3Normalize: function v3Normalize(vector, v3Length) {
+ var im = 1 / (v3Length || MatrixMath.v3Length(vector));
+ return [vector[0] * im, vector[1] * im, vector[2] * im];
+ },
+ v3Dot: function v3Dot(a, b) {
+ return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+ },
+ v3Combine: function v3Combine(a, b, aScale, bScale) {
+ return [aScale * a[0] + bScale * b[0], aScale * a[1] + bScale * b[1], aScale * a[2] + bScale * b[2]];
+ },
+ v3Cross: function v3Cross(a, b) {
+ return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+ },
+ quaternionToDegreesXYZ: function quaternionToDegreesXYZ(q, matrix, row) {
+ var _q = _slicedToArray(q, 4),
+ qx = _q[0],
+ qy = _q[1],
+ qz = _q[2],
+ qw = _q[3];
+
+ var qw2 = qw * qw;
+ var qx2 = qx * qx;
+ var qy2 = qy * qy;
+ var qz2 = qz * qz;
+ var test = qx * qy + qz * qw;
+ var unit = qw2 + qx2 + qy2 + qz2;
+ var conv = 180 / Math.PI;
+
+ if (test > 0.49999 * unit) {
+ return [0, 2 * Math.atan2(qx, qw) * conv, 90];
+ }
+
+ if (test < -0.49999 * unit) {
+ return [0, -2 * Math.atan2(qx, qw) * conv, -90];
+ }
+
+ return [MatrixMath.roundTo3Places(Math.atan2(2 * qx * qw - 2 * qy * qz, 1 - 2 * qx2 - 2 * qz2) * conv), MatrixMath.roundTo3Places(Math.atan2(2 * qy * qw - 2 * qx * qz, 1 - 2 * qy2 - 2 * qz2) * conv), MatrixMath.roundTo3Places(Math.asin(2 * qx * qy + 2 * qz * qw) * conv)];
+ },
+ roundTo3Places: function roundTo3Places(n) {
+ var arr = n.toString().split('e');
+ return Math.round(arr[0] + 'e' + (arr[1] ? +arr[1] - 3 : 3)) * 0.001;
+ },
+ decomposeMatrix: function decomposeMatrix(transformMatrix) {
+ invariant(transformMatrix.length === 16, 'Matrix decomposition needs a list of 3d matrix values, received %s', transformMatrix);
+ var perspective = [];
+ var quaternion = [];
+ var scale = [];
+ var skew = [];
+ var translation = [];
+
+ if (!transformMatrix[15]) {
+ return;
+ }
+
+ var matrix = [];
+ var perspectiveMatrix = [];
+
+ for (var i = 0; i < 4; i++) {
+ matrix.push([]);
+
+ for (var j = 0; j < 4; j++) {
+ var value = transformMatrix[i * 4 + j] / transformMatrix[15];
+ matrix[i].push(value);
+ perspectiveMatrix.push(j === 3 ? 0 : value);
+ }
+ }
+
+ perspectiveMatrix[15] = 1;
+
+ if (!MatrixMath.determinant(perspectiveMatrix)) {
+ return;
+ }
+
+ if (matrix[0][3] !== 0 || matrix[1][3] !== 0 || matrix[2][3] !== 0) {
+ var rightHandSide = [matrix[0][3], matrix[1][3], matrix[2][3], matrix[3][3]];
+ var inversePerspectiveMatrix = MatrixMath.inverse(perspectiveMatrix);
+ var transposedInversePerspectiveMatrix = MatrixMath.transpose(inversePerspectiveMatrix);
+ perspective = MatrixMath.multiplyVectorByMatrix(rightHandSide, transposedInversePerspectiveMatrix);
+ } else {
+ perspective[0] = perspective[1] = perspective[2] = 0;
+ perspective[3] = 1;
+ }
+
+ for (var _i = 0; _i < 3; _i++) {
+ translation[_i] = matrix[3][_i];
+ }
+
+ var row = [];
+
+ for (var _i2 = 0; _i2 < 3; _i2++) {
+ row[_i2] = [matrix[_i2][0], matrix[_i2][1], matrix[_i2][2]];
+ }
+
+ scale[0] = MatrixMath.v3Length(row[0]);
+ row[0] = MatrixMath.v3Normalize(row[0], scale[0]);
+ skew[0] = MatrixMath.v3Dot(row[0], row[1]);
+ row[1] = MatrixMath.v3Combine(row[1], row[0], 1.0, -skew[0]);
+ skew[0] = MatrixMath.v3Dot(row[0], row[1]);
+ row[1] = MatrixMath.v3Combine(row[1], row[0], 1.0, -skew[0]);
+ scale[1] = MatrixMath.v3Length(row[1]);
+ row[1] = MatrixMath.v3Normalize(row[1], scale[1]);
+ skew[0] /= scale[1];
+ skew[1] = MatrixMath.v3Dot(row[0], row[2]);
+ row[2] = MatrixMath.v3Combine(row[2], row[0], 1.0, -skew[1]);
+ skew[2] = MatrixMath.v3Dot(row[1], row[2]);
+ row[2] = MatrixMath.v3Combine(row[2], row[1], 1.0, -skew[2]);
+ scale[2] = MatrixMath.v3Length(row[2]);
+ row[2] = MatrixMath.v3Normalize(row[2], scale[2]);
+ skew[1] /= scale[2];
+ skew[2] /= scale[2];
+ var pdum3 = MatrixMath.v3Cross(row[1], row[2]);
+
+ if (MatrixMath.v3Dot(row[0], pdum3) < 0) {
+ for (var _i3 = 0; _i3 < 3; _i3++) {
+ scale[_i3] *= -1;
+ row[_i3][0] *= -1;
+ row[_i3][1] *= -1;
+ row[_i3][2] *= -1;
+ }
+ }
+
+ quaternion[0] = 0.5 * Math.sqrt(Math.max(1 + row[0][0] - row[1][1] - row[2][2], 0));
+ quaternion[1] = 0.5 * Math.sqrt(Math.max(1 - row[0][0] + row[1][1] - row[2][2], 0));
+ quaternion[2] = 0.5 * Math.sqrt(Math.max(1 - row[0][0] - row[1][1] + row[2][2], 0));
+ quaternion[3] = 0.5 * Math.sqrt(Math.max(1 + row[0][0] + row[1][1] + row[2][2], 0));
+
+ if (row[2][1] > row[1][2]) {
+ quaternion[0] = -quaternion[0];
+ }
+
+ if (row[0][2] > row[2][0]) {
+ quaternion[1] = -quaternion[1];
+ }
+
+ if (row[1][0] > row[0][1]) {
+ quaternion[2] = -quaternion[2];
+ }
+
+ var rotationDegrees;
+
+ if (quaternion[0] < 0.001 && quaternion[0] >= 0 && quaternion[1] < 0.001 && quaternion[1] >= 0) {
+ rotationDegrees = [0, 0, MatrixMath.roundTo3Places(Math.atan2(row[0][1], row[0][0]) * 180 / Math.PI)];
+ } else {
+ rotationDegrees = MatrixMath.quaternionToDegreesXYZ(quaternion, matrix, row);
+ }
+
+ return {
+ rotationDegrees: rotationDegrees,
+ perspective: perspective,
+ quaternion: quaternion,
+ scale: scale,
+ skew: skew,
+ translation: translation,
+ rotate: rotationDegrees[2],
+ rotateX: rotationDegrees[0],
+ rotateY: rotationDegrees[1],
+ scaleX: scale[0],
+ scaleY: scale[1],
+ translateX: translation[0],
+ translateY: translation[1]
+ };
+ }
+ };
+ module.exports = MatrixMath;
+},77,[37,19],"node_modules\\react-native\\Libraries\\Utilities\\MatrixMath.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var dummySize = {
+ width: undefined,
+ height: undefined
+ };
+
+ var sizesDiffer = function sizesDiffer(one, two) {
+ one = one || dummySize;
+ two = two || dummySize;
+ return one !== two && (one.width !== two.width || one.height !== two.height);
+ };
+
+ module.exports = sizesDiffer;
+},78,[],"node_modules\\react-native\\Libraries\\Utilities\\differ\\sizesDiffer.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var DeprecatedImageStylePropTypes = _$$_REQUIRE(_dependencyMap[2], "DeprecatedImageStylePropTypes");
+
+ var TextStylePropTypes = _$$_REQUIRE(_dependencyMap[3], "TextStylePropTypes");
+
+ var DeprecatedViewStylePropTypes = _$$_REQUIRE(_dependencyMap[4], "DeprecatedViewStylePropTypes");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[5], "invariant");
+
+ var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';
+
+ var StyleSheetValidation = function () {
+ function StyleSheetValidation() {
+ _classCallCheck(this, StyleSheetValidation);
+ }
+
+ _createClass(StyleSheetValidation, null, [{
+ key: "validateStyleProp",
+ value: function validateStyleProp(prop, style, caller) {
+ if (!__DEV__ || global.__RCTProfileIsProfiling) {
+ return;
+ }
+
+ if (allStylePropTypes[prop] === undefined) {
+ var message1 = '"' + prop + '" is not a valid style property.';
+ var message2 = '\nValid style props: ' + JSON.stringify(Object.keys(allStylePropTypes).sort(), null, ' ');
+ styleError(message1, style, caller, message2);
+ }
+
+ var error = allStylePropTypes[prop](style, prop, caller, 'prop', null, ReactPropTypesSecret);
+
+ if (error) {
+ styleError(error.message, style, caller);
+ }
+ }
+ }, {
+ key: "validateStyle",
+ value: function validateStyle(name, styles) {
+ if (!__DEV__ || global.__RCTProfileIsProfiling) {
+ return;
+ }
+
+ for (var prop in styles[name]) {
+ StyleSheetValidation.validateStyleProp(prop, styles[name], 'StyleSheet ' + name);
+ }
+ }
+ }, {
+ key: "addValidStylePropTypes",
+ value: function addValidStylePropTypes(stylePropTypes) {
+ if (!__DEV__ || global.__RCTProfileIsProfiling) {
+ return;
+ }
+
+ for (var key in stylePropTypes) {
+ allStylePropTypes[key] = stylePropTypes[key];
+ }
+ }
+ }]);
+
+ return StyleSheetValidation;
+ }();
+
+ var styleError = function styleError(message1, style, caller, message2) {
+ invariant(false, message1 + '\n' + (caller || '<>') + ': ' + JSON.stringify(style, null, ' ') + (message2 || ''));
+ };
+
+ var allStylePropTypes = {};
+
+ if (__DEV__ && !global.__RCTProfileIsProfiling) {
+ StyleSheetValidation.addValidStylePropTypes(DeprecatedImageStylePropTypes);
+ StyleSheetValidation.addValidStylePropTypes(TextStylePropTypes);
+ StyleSheetValidation.addValidStylePropTypes(DeprecatedViewStylePropTypes);
+ }
+
+ module.exports = StyleSheetValidation;
+},79,[3,4,58,73,74,19],"node_modules\\react-native\\Libraries\\StyleSheet\\StyleSheetValidation.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ function flattenStyle(style) {
+ if (style === null || typeof style !== 'object') {
+ return undefined;
+ }
+
+ if (!Array.isArray(style)) {
+ return style;
+ }
+
+ var result = {};
+
+ for (var i = 0, styleLength = style.length; i < styleLength; ++i) {
+ var computedStyle = flattenStyle(style[i]);
+
+ if (computedStyle) {
+ for (var key in computedStyle) {
+ result[key] = computedStyle[key];
+ }
+ }
+ }
+
+ return result;
+ }
+
+ module.exports = flattenStyle;
+},80,[],"node_modules\\react-native\\Libraries\\StyleSheet\\flattenStyle.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Components\\View\\View.js";
+
+ var React = _$$_REQUIRE(_dependencyMap[1], "React");
+
+ var TextAncestor = _$$_REQUIRE(_dependencyMap[2], "TextAncestor");
+
+ var ViewNativeComponent = _$$_REQUIRE(_dependencyMap[3], "ViewNativeComponent");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[4], "invariant");
+
+ var ViewToExport = ViewNativeComponent;
+
+ if (__DEV__) {
+ if (!global.__RCTProfileIsProfiling) {
+ var View = function View(props, forwardedRef) {
+ return React.createElement(TextAncestor.Consumer, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 39
+ }
+ }, function (hasTextAncestor) {
+ invariant(!hasTextAncestor, 'Nesting of within is not currently supported.');
+ return React.createElement(ViewNativeComponent, _extends({}, props, {
+ ref: forwardedRef,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 45
+ }
+ }));
+ });
+ };
+
+ ViewToExport = React.forwardRef(View);
+ ViewToExport.displayName = 'View';
+ }
+ }
+
+ module.exports = ViewToExport;
+},81,[14,52,82,83,19],"node_modules\\react-native\\Libraries\\Components\\View\\View.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var React = _$$_REQUIRE(_dependencyMap[0], "React");
+
+ module.exports = React.createContext(false);
+},82,[52],"node_modules\\react-native\\Libraries\\Text\\TextAncestor.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var ReactNative = _$$_REQUIRE(_dependencyMap[0], "ReactNative");
+
+ var requireNativeComponent = _$$_REQUIRE(_dependencyMap[1], "requireNativeComponent");
+
+ var NativeViewComponent = requireNativeComponent('RCTView');
+ module.exports = NativeViewComponent;
+},83,[84,184],"node_modules\\react-native\\Libraries\\Components\\View\\ViewNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var ReactNative;
+
+ if (__DEV__) {
+ ReactNative = _$$_REQUIRE(_dependencyMap[0], "ReactNativeRenderer-dev");
+ } else {
+ ReactNative = _$$_REQUIRE(_dependencyMap[1], "ReactNativeRenderer-prod");
+ }
+
+ module.exports = ReactNative;
+},84,[85,183],"node_modules\\react-native\\Libraries\\Renderer\\shims\\ReactNative.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ if (__DEV__) {
+ (function () {
+ "use strict";
+
+ _$$_REQUIRE(_dependencyMap[1], "InitializeCore");
+
+ var ReactNativeViewConfigRegistry = _$$_REQUIRE(_dependencyMap[2], "ReactNativeViewConfigRegistry");
+
+ var UIManager = _$$_REQUIRE(_dependencyMap[3], "UIManager");
+
+ var RCTEventEmitter = _$$_REQUIRE(_dependencyMap[4], "RCTEventEmitter");
+
+ var React = _$$_REQUIRE(_dependencyMap[5], "react");
+
+ var deepFreezeAndThrowOnMutationInDev = _$$_REQUIRE(_dependencyMap[6], "deepFreezeAndThrowOnMutationInDev");
+
+ var deepDiffer = _$$_REQUIRE(_dependencyMap[7], "deepDiffer");
+
+ var flattenStyle = _$$_REQUIRE(_dependencyMap[8], "flattenStyle");
+
+ var TextInputState = _$$_REQUIRE(_dependencyMap[9], "TextInputState");
+
+ var checkPropTypes = _$$_REQUIRE(_dependencyMap[10], "prop-types/checkPropTypes");
+
+ var tracing = _$$_REQUIRE(_dependencyMap[11], "scheduler/tracing");
+
+ var scheduler = _$$_REQUIRE(_dependencyMap[12], "scheduler");
+
+ var ExceptionsManager = _$$_REQUIRE(_dependencyMap[13], "ExceptionsManager");
+
+ var validateFormat = function validateFormat() {};
+
+ {
+ 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 = void 0;
+
+ 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;
+ }
+ }
+
+ var invokeGuardedCallbackImpl = function invokeGuardedCallbackImpl(name, func, context, a, b, c, d, e, f) {
+ var funcArgs = Array.prototype.slice.call(arguments, 3);
+
+ try {
+ func.apply(context, funcArgs);
+ } catch (error) {
+ this.onError(error);
+ }
+ };
+
+ {
+ if (typeof window !== "undefined" && typeof window.dispatchEvent === "function" && typeof document !== "undefined" && typeof document.createEvent === "function") {
+ var fakeNode = document.createElement("react");
+
+ var invokeGuardedCallbackDev = function invokeGuardedCallbackDev(name, func, context, a, b, c, d, e, f) {
+ 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 windowEvent = window.event;
+ var windowEventDescriptor = Object.getOwnPropertyDescriptor(window, "event");
+ var funcArgs = Array.prototype.slice.call(arguments, 3);
+
+ function callCallback() {
+ fakeNode.removeEventListener(evtType, callCallback, false);
+
+ if (typeof window.event !== "undefined" && window.hasOwnProperty("event")) {
+ window.event = windowEvent;
+ }
+
+ func.apply(context, funcArgs);
+ didError = false;
+ }
+
+ var error = void 0;
+ var didSetError = false;
+ var isCrossOriginError = false;
+
+ function handleWindowError(event) {
+ error = event.error;
+ didSetError = true;
+
+ if (error === null && event.colno === 0 && event.lineno === 0) {
+ isCrossOriginError = true;
+ }
+
+ if (event.defaultPrevented) {
+ if (error != null && typeof error === "object") {
+ try {
+ error._suppressLogging = true;
+ } catch (inner) {}
+ }
+ }
+ }
+
+ var evtType = "react-" + (name ? name : "invokeguardedcallback");
+ window.addEventListener("error", handleWindowError);
+ fakeNode.addEventListener(evtType, callCallback, false);
+ evt.initEvent(evtType, false, false);
+ fakeNode.dispatchEvent(evt);
+
+ if (windowEventDescriptor) {
+ Object.defineProperty(window, "event", windowEventDescriptor);
+ }
+
+ if (didError) {
+ if (!didSetError) {
+ error = new Error("An error was thrown inside one of your components, but React " + "doesn't know what it was. This is likely due to browser " + 'flakiness. React does its best to preserve the "Pause on ' + 'exceptions" behavior of the DevTools, which requires some ' + "DEV-mode only tricks. It's possible that these don't work in " + "your browser. Try triggering the error in production mode, " + "or switching to a modern browser. If you suspect that this is " + "actually an issue with React, please file an issue.");
+ } else if (isCrossOriginError) {
+ error = new Error("A cross-origin error was thrown. React doesn't have access to " + "the actual error object in development. " + "See https://fb.me/react-crossorigin-error for more information.");
+ }
+
+ this.onError(error);
+ }
+
+ window.removeEventListener("error", handleWindowError);
+ };
+
+ invokeGuardedCallbackImpl = invokeGuardedCallbackDev;
+ }
+ }
+ var invokeGuardedCallbackImpl$1 = invokeGuardedCallbackImpl;
+ var hasError = false;
+ var caughtError = null;
+ var hasRethrowError = false;
+ var rethrowError = null;
+ var reporter = {
+ onError: function onError(error) {
+ hasError = true;
+ caughtError = error;
+ }
+ };
+
+ function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
+ hasError = false;
+ caughtError = null;
+ invokeGuardedCallbackImpl$1.apply(reporter, arguments);
+ }
+
+ function invokeGuardedCallbackAndCatchFirstError(name, func, context, a, b, c, d, e, f) {
+ invokeGuardedCallback.apply(this, arguments);
+
+ if (hasError) {
+ var error = clearCaughtError();
+
+ if (!hasRethrowError) {
+ hasRethrowError = true;
+ rethrowError = error;
+ }
+ }
+ }
+
+ function rethrowCaughtError() {
+ if (hasRethrowError) {
+ var error = rethrowError;
+ hasRethrowError = false;
+ rethrowError = null;
+ throw error;
+ }
+ }
+
+ function hasCaughtError() {
+ return hasError;
+ }
+
+ function clearCaughtError() {
+ if (hasError) {
+ var error = caughtError;
+ hasError = false;
+ caughtError = null;
+ return error;
+ } else {
+ 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 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 warningWithoutStack = function warningWithoutStack() {};
+
+ {
+ warningWithoutStack = function warningWithoutStack(condition, format) {
+ for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+ args[_key - 2] = arguments[_key];
+ }
+
+ if (format === undefined) {
+ throw new Error("`warningWithoutStack(condition, format, ...args)` requires a warning " + "message argument");
+ }
+
+ if (args.length > 8) {
+ throw new Error("warningWithoutStack() currently supports at most 8 arguments.");
+ }
+
+ if (condition) {
+ return;
+ }
+
+ if (typeof console !== "undefined") {
+ var argsWithFormat = args.map(function (item) {
+ return "" + item;
+ });
+ argsWithFormat.unshift("Warning: " + format);
+ Function.prototype.apply.call(console.error, console, argsWithFormat);
+ }
+
+ try {
+ var argIndex = 0;
+ var message = "Warning: " + format.replace(/%s/g, function () {
+ return args[argIndex++];
+ });
+ throw new Error(message);
+ } catch (x) {}
+ };
+ }
+ var warningWithoutStack$1 = warningWithoutStack;
+ var getFiberCurrentPropsFromNode = null;
+ var getInstanceFromNode = null;
+ var getNodeFromInstance = null;
+
+ function setComponentTree(getFiberCurrentPropsFromNodeImpl, getInstanceFromNodeImpl, getNodeFromInstanceImpl) {
+ getFiberCurrentPropsFromNode = getFiberCurrentPropsFromNodeImpl;
+ getInstanceFromNode = getInstanceFromNodeImpl;
+ getNodeFromInstance = getNodeFromInstanceImpl;
+ {
+ !(getNodeFromInstance && getInstanceFromNode) ? warningWithoutStack$1(false, "EventPluginUtils.setComponentTree(...): Injected " + "module is missing getNodeFromInstance or getInstanceFromNode.") : void 0;
+ }
+ }
+
+ var validateEventDispatches = void 0;
+ {
+ validateEventDispatches = function validateEventDispatches(event) {
+ var dispatchListeners = event._dispatchListeners;
+ var dispatchInstances = event._dispatchInstances;
+ var listenersIsArr = Array.isArray(dispatchListeners);
+ var listenersLen = listenersIsArr ? dispatchListeners.length : dispatchListeners ? 1 : 0;
+ var instancesIsArr = Array.isArray(dispatchInstances);
+ var instancesLen = instancesIsArr ? dispatchInstances.length : dispatchInstances ? 1 : 0;
+ !(instancesIsArr === listenersIsArr && instancesLen === listenersLen) ? warningWithoutStack$1(false, "EventPluginUtils: Invalid `event`.") : void 0;
+ };
+ }
+
+ function executeDispatch(event, listener, inst) {
+ var type = event.type || "unknown-event";
+ event.currentTarget = getNodeFromInstance(inst);
+ invokeGuardedCallbackAndCatchFirstError(type, listener, undefined, event);
+ event.currentTarget = null;
+ }
+
+ function executeDispatchesInOrder(event) {
+ var dispatchListeners = event._dispatchListeners;
+ var dispatchInstances = event._dispatchInstances;
+ {
+ validateEventDispatches(event);
+ }
+
+ if (Array.isArray(dispatchListeners)) {
+ for (var i = 0; i < dispatchListeners.length; i++) {
+ if (event.isPropagationStopped()) {
+ break;
+ }
+
+ executeDispatch(event, dispatchListeners[i], dispatchInstances[i]);
+ }
+ } else if (dispatchListeners) {
+ executeDispatch(event, dispatchListeners, dispatchInstances);
+ }
+
+ event._dispatchListeners = null;
+ event._dispatchInstances = null;
+ }
+
+ function executeDispatchesInOrderStopAtTrueImpl(event) {
+ var dispatchListeners = event._dispatchListeners;
+ var dispatchInstances = event._dispatchInstances;
+ {
+ validateEventDispatches(event);
+ }
+
+ if (Array.isArray(dispatchListeners)) {
+ for (var i = 0; i < dispatchListeners.length; i++) {
+ if (event.isPropagationStopped()) {
+ break;
+ }
+
+ if (dispatchListeners[i](event, dispatchInstances[i])) {
+ return dispatchInstances[i];
+ }
+ }
+ } else if (dispatchListeners) {
+ if (dispatchListeners(event, dispatchInstances)) {
+ return dispatchInstances;
+ }
+ }
+
+ return null;
+ }
+
+ function executeDispatchesInOrderStopAtTrue(event) {
+ var ret = executeDispatchesInOrderStopAtTrueImpl(event);
+ event._dispatchInstances = null;
+ event._dispatchListeners = null;
+ return ret;
+ }
+
+ function executeDirectDispatch(event) {
+ {
+ validateEventDispatches(event);
+ }
+ var dispatchListener = event._dispatchListeners;
+ var dispatchInstance = event._dispatchInstances;
+ 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) {
+ if (event) {
+ executeDispatchesInOrder(event);
+
+ if (!event.isPersistent()) {
+ event.constructor.release(event);
+ }
+ }
+ };
+
+ var executeDispatchesAndReleaseTopLevel = function executeDispatchesAndReleaseTopLevel(e) {
+ return executeDispatchesAndRelease(e);
+ };
+
+ 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) {
+ if (events !== null) {
+ eventQueue = accumulateInto(eventQueue, events);
+ }
+
+ var processingEventQueue = eventQueue;
+ eventQueue = null;
+
+ if (!processingEventQueue) {
+ return;
+ }
+
+ forEachAccumulated(processingEventQueue, executeDispatchesAndReleaseTopLevel);
+ invariant(!eventQueue, "processEventQueue(): Additional events were enqueued while processing " + "an event queue. Support for this has not yet been implemented.");
+ rethrowCaughtError();
+ }
+
+ function runExtractedEventsInBatch(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+ var events = extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget);
+ runEventsInBatch(events);
+ }
+
+ var FunctionComponent = 0;
+ var ClassComponent = 1;
+ var IndeterminateComponent = 2;
+ var HostRoot = 3;
+ var HostPortal = 4;
+ var HostComponent = 5;
+ var HostText = 6;
+ var Fragment = 7;
+ var Mode = 8;
+ var ContextConsumer = 9;
+ var ContextProvider = 10;
+ var ForwardRef = 11;
+ var Profiler = 12;
+ var SuspenseComponent = 13;
+ var MemoComponent = 14;
+ var SimpleMemoComponent = 15;
+ var LazyComponent = 16;
+ var IncompleteClassComponent = 17;
+ var DehydratedSuspenseComponent = 18;
+
+ function getParent(inst) {
+ do {
+ inst = inst.return;
+ } while (inst && inst.tag !== HostComponent);
+
+ if (inst) {
+ return inst;
+ }
+
+ return null;
+ }
+
+ function getLowestCommonAncestor(instA, instB) {
+ var depthA = 0;
+
+ for (var tempA = instA; tempA; tempA = getParent(tempA)) {
+ depthA++;
+ }
+
+ var depthB = 0;
+
+ for (var tempB = instB; tempB; tempB = getParent(tempB)) {
+ depthB++;
+ }
+
+ while (depthA - depthB > 0) {
+ instA = getParent(instA);
+ depthA--;
+ }
+
+ while (depthB - depthA > 0) {
+ instB = getParent(instB);
+ depthB--;
+ }
+
+ var depth = depthA;
+
+ while (depth--) {
+ if (instA === instB || instA === instB.alternate) {
+ return instA;
+ }
+
+ instA = getParent(instA);
+ instB = getParent(instB);
+ }
+
+ return null;
+ }
+
+ function isAncestor(instA, instB) {
+ while (instB) {
+ if (instA === instB || instA === instB.alternate) {
+ return true;
+ }
+
+ instB = getParent(instB);
+ }
+
+ return false;
+ }
+
+ function getParentInstance(inst) {
+ return getParent(inst);
+ }
+
+ function traverseTwoPhase(inst, fn, arg) {
+ var path = [];
+
+ while (inst) {
+ path.push(inst);
+ inst = getParent(inst);
+ }
+
+ var i = void 0;
+
+ for (i = path.length; i-- > 0;) {
+ fn(path[i], "captured", arg);
+ }
+
+ for (i = 0; i < path.length; i++) {
+ fn(path[i], "bubbled", arg);
+ }
+ }
+
+ function listenerAtPhase(inst, event, propagationPhase) {
+ var registrationName = event.dispatchConfig.phasedRegistrationNames[propagationPhase];
+ return getListener(inst, registrationName);
+ }
+
+ function accumulateDirectionalDispatches(inst, phase, event) {
+ {
+ !inst ? warningWithoutStack$1(false, "Dispatching inst must not be null") : void 0;
+ }
+ var listener = listenerAtPhase(inst, event, phase);
+
+ if (listener) {
+ event._dispatchListeners = accumulateInto(event._dispatchListeners, listener);
+ event._dispatchInstances = accumulateInto(event._dispatchInstances, inst);
+ }
+ }
+
+ function accumulateTwoPhaseDispatchesSingle(event) {
+ if (event && event.dispatchConfig.phasedRegistrationNames) {
+ traverseTwoPhase(event._targetInst, accumulateDirectionalDispatches, event);
+ }
+ }
+
+ function accumulateTwoPhaseDispatchesSingleSkipTarget(event) {
+ if (event && event.dispatchConfig.phasedRegistrationNames) {
+ var targetInst = event._targetInst;
+ var parentInst = targetInst ? getParentInstance(targetInst) : null;
+ traverseTwoPhase(parentInst, accumulateDirectionalDispatches, event);
+ }
+ }
+
+ function accumulateDispatches(inst, ignoredDirection, event) {
+ if (inst && event && event.dispatchConfig.registrationName) {
+ var registrationName = event.dispatchConfig.registrationName;
+ var listener = getListener(inst, registrationName);
+
+ if (listener) {
+ event._dispatchListeners = accumulateInto(event._dispatchListeners, listener);
+ event._dispatchInstances = accumulateInto(event._dispatchInstances, inst);
+ }
+ }
+ }
+
+ function accumulateDirectDispatchesSingle(event) {
+ if (event && event.dispatchConfig.registrationName) {
+ accumulateDispatches(event._targetInst, null, event);
+ }
+ }
+
+ function accumulateTwoPhaseDispatches(events) {
+ forEachAccumulated(events, accumulateTwoPhaseDispatchesSingle);
+ }
+
+ function accumulateTwoPhaseDispatchesSkipTarget(events) {
+ forEachAccumulated(events, accumulateTwoPhaseDispatchesSingleSkipTarget);
+ }
+
+ function accumulateDirectDispatches(events) {
+ forEachAccumulated(events, accumulateDirectDispatchesSingle);
+ }
+
+ var EVENT_POOL_SIZE = 10;
+ var EventInterface = {
+ type: null,
+ target: null,
+ currentTarget: function currentTarget() {
+ return null;
+ },
+ eventPhase: null,
+ bubbles: null,
+ cancelable: null,
+ timeStamp: function timeStamp(event) {
+ return event.timeStamp || Date.now();
+ },
+ defaultPrevented: null,
+ isTrusted: null
+ };
+
+ function functionThatReturnsTrue() {
+ return true;
+ }
+
+ function functionThatReturnsFalse() {
+ return false;
+ }
+
+ function SyntheticEvent(dispatchConfig, targetInst, nativeEvent, nativeEventTarget) {
+ {
+ delete this.nativeEvent;
+ delete this.preventDefault;
+ delete this.stopPropagation;
+ delete this.isDefaultPrevented;
+ delete this.isPropagationStopped;
+ }
+ this.dispatchConfig = dispatchConfig;
+ this._targetInst = targetInst;
+ this.nativeEvent = nativeEvent;
+ var Interface = this.constructor.Interface;
+
+ for (var propName in Interface) {
+ if (!Interface.hasOwnProperty(propName)) {
+ continue;
+ }
+
+ {
+ delete this[propName];
+ }
+ var normalize = Interface[propName];
+
+ if (normalize) {
+ this[propName] = normalize(nativeEvent);
+ } else {
+ if (propName === "target") {
+ this.target = nativeEventTarget;
+ } else {
+ this[propName] = nativeEvent[propName];
+ }
+ }
+ }
+
+ var defaultPrevented = nativeEvent.defaultPrevented != null ? nativeEvent.defaultPrevented : nativeEvent.returnValue === false;
+
+ if (defaultPrevented) {
+ this.isDefaultPrevented = functionThatReturnsTrue;
+ } else {
+ this.isDefaultPrevented = functionThatReturnsFalse;
+ }
+
+ this.isPropagationStopped = functionThatReturnsFalse;
+ return this;
+ }
+
+ _extends(SyntheticEvent.prototype, {
+ preventDefault: function preventDefault() {
+ this.defaultPrevented = true;
+ var event = this.nativeEvent;
+
+ if (!event) {
+ return;
+ }
+
+ if (event.preventDefault) {
+ event.preventDefault();
+ } else if (typeof event.returnValue !== "unknown") {
+ event.returnValue = false;
+ }
+
+ this.isDefaultPrevented = functionThatReturnsTrue;
+ },
+ stopPropagation: function stopPropagation() {
+ var event = this.nativeEvent;
+
+ if (!event) {
+ return;
+ }
+
+ if (event.stopPropagation) {
+ event.stopPropagation();
+ } else if (typeof event.cancelBubble !== "unknown") {
+ event.cancelBubble = true;
+ }
+
+ this.isPropagationStopped = functionThatReturnsTrue;
+ },
+ persist: function persist() {
+ this.isPersistent = functionThatReturnsTrue;
+ },
+ isPersistent: functionThatReturnsFalse,
+ destructor: function destructor() {
+ var Interface = this.constructor.Interface;
+
+ for (var propName in Interface) {
+ {
+ Object.defineProperty(this, propName, getPooledWarningPropertyDefinition(propName, Interface[propName]));
+ }
+ }
+
+ this.dispatchConfig = null;
+ this._targetInst = null;
+ this.nativeEvent = null;
+ this.isDefaultPrevented = functionThatReturnsFalse;
+ this.isPropagationStopped = functionThatReturnsFalse;
+ this._dispatchListeners = null;
+ this._dispatchInstances = null;
+ {
+ Object.defineProperty(this, "nativeEvent", getPooledWarningPropertyDefinition("nativeEvent", null));
+ Object.defineProperty(this, "isDefaultPrevented", getPooledWarningPropertyDefinition("isDefaultPrevented", functionThatReturnsFalse));
+ Object.defineProperty(this, "isPropagationStopped", getPooledWarningPropertyDefinition("isPropagationStopped", functionThatReturnsFalse));
+ Object.defineProperty(this, "preventDefault", getPooledWarningPropertyDefinition("preventDefault", function () {}));
+ Object.defineProperty(this, "stopPropagation", getPooledWarningPropertyDefinition("stopPropagation", function () {}));
+ }
+ }
+ });
+
+ SyntheticEvent.Interface = EventInterface;
+
+ SyntheticEvent.extend = function (Interface) {
+ var Super = this;
+
+ var E = function E() {};
+
+ E.prototype = Super.prototype;
+ var prototype = new E();
+
+ function Class() {
+ return Super.apply(this, arguments);
+ }
+
+ _extends(prototype, Class.prototype);
+
+ Class.prototype = prototype;
+ Class.prototype.constructor = Class;
+ Class.Interface = _extends({}, Super.Interface, Interface);
+ Class.extend = Super.extend;
+ addEventPoolingTo(Class);
+ return Class;
+ };
+
+ addEventPoolingTo(SyntheticEvent);
+
+ function getPooledWarningPropertyDefinition(propName, getVal) {
+ var isFunction = typeof getVal === "function";
+ return {
+ configurable: true,
+ set: set,
+ get: get$$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 ? warningWithoutStack$1(false, "This synthetic event is reused for performance reasons. If you're seeing this, " + "you're %s `%s` on a released/nullified synthetic event. %s. " + "If you must keep the original synthetic event around, use event.persist(). " + "See https://fb.me/react-event-pooling for more information.", action, propName, result) : void 0;
+ }
+ }
+
+ function getPooledEvent(dispatchConfig, targetInst, nativeEvent, nativeInst) {
+ var EventConstructor = this;
+
+ if (EventConstructor.eventPool.length) {
+ var instance = EventConstructor.eventPool.pop();
+ EventConstructor.call(instance, dispatchConfig, targetInst, nativeEvent, nativeInst);
+ return instance;
+ }
+
+ return new EventConstructor(dispatchConfig, targetInst, nativeEvent, nativeInst);
+ }
+
+ function releasePooledEvent(event) {
+ var EventConstructor = this;
+ 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 ResponderSyntheticEvent = SyntheticEvent.extend({
+ touchHistory: function touchHistory(nativeEvent) {
+ return null;
+ }
+ });
+ var TOP_TOUCH_START = "topTouchStart";
+ var TOP_TOUCH_MOVE = "topTouchMove";
+ var TOP_TOUCH_END = "topTouchEnd";
+ var TOP_TOUCH_CANCEL = "topTouchCancel";
+ var TOP_SCROLL = "topScroll";
+ var TOP_SELECTION_CHANGE = "topSelectionChange";
+
+ function isStartish(topLevelType) {
+ return topLevelType === TOP_TOUCH_START;
+ }
+
+ function isMoveish(topLevelType) {
+ return topLevelType === TOP_TOUCH_MOVE;
+ }
+
+ function isEndish(topLevelType) {
+ return topLevelType === TOP_TOUCH_END || topLevelType === TOP_TOUCH_CANCEL;
+ }
+
+ var startDependencies = [TOP_TOUCH_START];
+ var moveDependencies = [TOP_TOUCH_MOVE];
+ var endDependencies = [TOP_TOUCH_CANCEL, TOP_TOUCH_END];
+ var MAX_TOUCH_BANK = 20;
+ var touchBank = [];
+ var touchHistory = {
+ touchBank: touchBank,
+ numberActiveTouches: 0,
+ indexOfSingleActiveTouch: -1,
+ mostRecentTimeStamp: 0
+ };
+
+ function timestampForTouch(touch) {
+ return touch.timeStamp || touch.timestamp;
+ }
+
+ function createTouchRecord(touch) {
+ return {
+ touchActive: true,
+ startPageX: touch.pageX,
+ startPageY: touch.pageY,
+ startTimeStamp: timestampForTouch(touch),
+ currentPageX: touch.pageX,
+ currentPageY: touch.pageY,
+ currentTimeStamp: timestampForTouch(touch),
+ previousPageX: touch.pageX,
+ previousPageY: touch.pageY,
+ previousTimeStamp: timestampForTouch(touch)
+ };
+ }
+
+ function resetTouchRecord(touchRecord, touch) {
+ touchRecord.touchActive = true;
+ touchRecord.startPageX = touch.pageX;
+ touchRecord.startPageY = touch.pageY;
+ touchRecord.startTimeStamp = timestampForTouch(touch);
+ touchRecord.currentPageX = touch.pageX;
+ touchRecord.currentPageY = touch.pageY;
+ touchRecord.currentTimeStamp = timestampForTouch(touch);
+ touchRecord.previousPageX = touch.pageX;
+ touchRecord.previousPageY = touch.pageY;
+ touchRecord.previousTimeStamp = timestampForTouch(touch);
+ }
+
+ function getTouchIdentifier(_ref) {
+ var identifier = _ref.identifier;
+ invariant(identifier != null, "Touch object is missing identifier.");
+ {
+ !(identifier <= MAX_TOUCH_BANK) ? warningWithoutStack$1(false, "Touch identifier %s is greater than maximum supported %s which causes " + "performance issues backfilling array locations for all of the indices.", identifier, MAX_TOUCH_BANK) : void 0;
+ }
+ return identifier;
+ }
+
+ function recordTouchStart(touch) {
+ var identifier = getTouchIdentifier(touch);
+ var touchRecord = touchBank[identifier];
+
+ if (touchRecord) {
+ resetTouchRecord(touchRecord, touch);
+ } else {
+ touchBank[identifier] = createTouchRecord(touch);
+ }
+
+ touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
+ }
+
+ function recordTouchMove(touch) {
+ var touchRecord = touchBank[getTouchIdentifier(touch)];
+
+ if (touchRecord) {
+ touchRecord.touchActive = true;
+ touchRecord.previousPageX = touchRecord.currentPageX;
+ touchRecord.previousPageY = touchRecord.currentPageY;
+ touchRecord.previousTimeStamp = touchRecord.currentTimeStamp;
+ touchRecord.currentPageX = touch.pageX;
+ touchRecord.currentPageY = touch.pageY;
+ touchRecord.currentTimeStamp = timestampForTouch(touch);
+ touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
+ } else {
+ console.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) ? warningWithoutStack$1(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 ReactNativeBridgeEventPlugin = {
+ eventTypes: ReactNativeViewConfigRegistry.eventTypes,
+ extractEvents: function extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+ if (targetInst == null) {
+ return null;
+ }
+
+ var bubbleDispatchConfig = ReactNativeViewConfigRegistry.customBubblingEventTypes[topLevelType];
+ var directDispatchConfig = ReactNativeViewConfigRegistry.customDirectEventTypes[topLevelType];
+ invariant(bubbleDispatchConfig || directDispatchConfig, 'Unsupported top level event type "%s" dispatched', topLevelType);
+ var event = SyntheticEvent.getPooled(bubbleDispatchConfig || directDispatchConfig, targetInst, nativeEvent, nativeEventTarget);
+
+ if (bubbleDispatchConfig) {
+ accumulateTwoPhaseDispatches(event);
+ } else if (directDispatchConfig) {
+ accumulateDirectDispatches(event);
+ } else {
+ return null;
+ }
+
+ return event;
+ }
+ };
+ var ReactNativeEventPluginOrder = ["ResponderEventPlugin", "ReactNativeBridgeEventPlugin"];
+ injection.injectEventPluginOrder(ReactNativeEventPluginOrder);
+ injection.injectEventPluginsByName({
+ ResponderEventPlugin: ResponderEventPlugin,
+ ReactNativeBridgeEventPlugin: ReactNativeBridgeEventPlugin
+ });
+ var instanceCache = {};
+ 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 restoreImpl = null;
+ var restoreTarget = null;
+ var restoreQueue = null;
+
+ function restoreStateOfTarget(target) {
+ var internalInstance = getInstanceFromNode(target);
+
+ if (!internalInstance) {
+ return;
+ }
+
+ invariant(typeof restoreImpl === "function", "setRestoreImplementation() needs to be called to handle a target for controlled " + "events. This error is likely caused by a bug in React. Please file an issue.");
+ var props = getFiberCurrentPropsFromNode(internalInstance.stateNode);
+ restoreImpl(internalInstance.stateNode, internalInstance.type, props);
+ }
+
+ function needsStateRestore() {
+ return restoreTarget !== null || restoreQueue !== null;
+ }
+
+ function restoreStateIfNeeded() {
+ if (!restoreTarget) {
+ return;
+ }
+
+ var target = restoreTarget;
+ var queuedTargets = restoreQueue;
+ restoreTarget = null;
+ restoreQueue = null;
+ restoreStateOfTarget(target);
+
+ if (queuedTargets) {
+ for (var i = 0; i < queuedTargets.length; i++) {
+ restoreStateOfTarget(queuedTargets[i]);
+ }
+ }
+ }
+
+ var _batchedUpdatesImpl = function _batchedUpdatesImpl(fn, bookkeeping) {
+ return fn(bookkeeping);
+ };
+
+ var _flushInteractiveUpdatesImpl = function _flushInteractiveUpdatesImpl() {};
+
+ var isBatching = false;
+
+ function batchedUpdates(fn, bookkeeping) {
+ if (isBatching) {
+ return fn(bookkeeping);
+ }
+
+ isBatching = true;
+
+ try {
+ return _batchedUpdatesImpl(fn, bookkeeping);
+ } finally {
+ isBatching = false;
+ var controlledComponentsHavePendingUpdates = needsStateRestore();
+
+ if (controlledComponentsHavePendingUpdates) {
+ _flushInteractiveUpdatesImpl();
+
+ restoreStateIfNeeded();
+ }
+ }
+ }
+
+ function setBatchingImplementation(batchedUpdatesImpl, interactiveUpdatesImpl, flushInteractiveUpdatesImpl) {
+ _batchedUpdatesImpl = batchedUpdatesImpl;
+ _flushInteractiveUpdatesImpl = flushInteractiveUpdatesImpl;
+ }
+
+ 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) {
+ {
+ warningWithoutStack$1(false, "A view is reporting that a touch occurred on tag zero.");
+ }
+ } else {
+ rootNodeID = target;
+ }
+ }
+
+ _receiveRootNodeIDEvent(rootNodeID, eventTopLevelType, nativeEvent);
+ }
+ }
+
+ var ReactNativeGlobalResponderHandler = {
+ onChange: function onChange(from, to, blockNativeResponder) {
+ if (to !== null) {
+ var tag = to.stateNode._nativeTag;
+ UIManager.setJSResponder(tag, blockNativeResponder);
+ } else {
+ UIManager.clearJSResponder();
+ }
+ }
+ };
+ RCTEventEmitter.register({
+ receiveEvent: receiveEvent,
+ receiveTouches: receiveTouches
+ });
+ setComponentTree(getFiberCurrentPropsFromNode$1, getInstanceFromTag, getTagFromInstance);
+ ResponderEventPlugin.injection.injectGlobalResponderHandler(ReactNativeGlobalResponderHandler);
+
+ function get$1(key) {
+ return key._reactInternalFiber;
+ }
+
+ function set(key, value) {
+ key._reactInternalFiber = value;
+ }
+
+ var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+ if (!ReactSharedInternals.hasOwnProperty("ReactCurrentDispatcher")) {
+ ReactSharedInternals.ReactCurrentDispatcher = {
+ current: null
+ };
+ }
+
+ var hasSymbol = typeof Symbol === "function" && (typeof Symbol === "function" ? Symbol.for : "@@for");
+ var REACT_ELEMENT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.element") : 0xeac7;
+ var REACT_PORTAL_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.portal") : 0xeaca;
+ var REACT_FRAGMENT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.fragment") : 0xeacb;
+ var REACT_STRICT_MODE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.strict_mode") : 0xeacc;
+ var REACT_PROFILER_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.profiler") : 0xead2;
+ var REACT_PROVIDER_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.provider") : 0xeacd;
+ var REACT_CONTEXT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.context") : 0xeace;
+ var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.concurrent_mode") : 0xeacf;
+ var REACT_FORWARD_REF_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.forward_ref") : 0xead0;
+ var REACT_SUSPENSE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.suspense") : 0xead1;
+ var REACT_MEMO_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.memo") : 0xead3;
+ var REACT_LAZY_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.lazy") : 0xead4;
+ var MAYBE_ITERATOR_SYMBOL = typeof Symbol === "function" && (typeof Symbol === "function" ? Symbol.iterator : "@@iterator");
+ var FAUX_ITERATOR_SYMBOL = "@@iterator";
+
+ function getIteratorFn(maybeIterable) {
+ if (maybeIterable === null || typeof maybeIterable !== "object") {
+ return null;
+ }
+
+ var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+ if (typeof maybeIterator === "function") {
+ return maybeIterator;
+ }
+
+ return null;
+ }
+
+ var Pending = 0;
+ var Resolved = 1;
+ var Rejected = 2;
+
+ function refineResolvedLazyComponent(lazyComponent) {
+ return lazyComponent._status === Resolved ? lazyComponent._result : null;
+ }
+
+ function getWrappedName(outerType, innerType, wrapperName) {
+ var functionName = innerType.displayName || innerType.name || "";
+ return outerType.displayName || (functionName !== "" ? wrapperName + "(" + functionName + ")" : wrapperName);
+ }
+
+ function getComponentName(type) {
+ if (type == null) {
+ return null;
+ }
+
+ {
+ if (typeof type.tag === "number") {
+ warningWithoutStack$1(false, "Received an unexpected object in getComponentName(). " + "This is likely a bug in React. Please file an issue.");
+ }
+ }
+
+ if (typeof type === "function") {
+ return type.displayName || type.name || null;
+ }
+
+ if (typeof type === "string") {
+ return type;
+ }
+
+ switch (type) {
+ case REACT_CONCURRENT_MODE_TYPE:
+ return "ConcurrentMode";
+
+ case REACT_FRAGMENT_TYPE:
+ return "Fragment";
+
+ case REACT_PORTAL_TYPE:
+ return "Portal";
+
+ case REACT_PROFILER_TYPE:
+ return "Profiler";
+
+ case REACT_STRICT_MODE_TYPE:
+ return "StrictMode";
+
+ case REACT_SUSPENSE_TYPE:
+ return "Suspense";
+ }
+
+ if (typeof type === "object") {
+ switch (type.$$typeof) {
+ case REACT_CONTEXT_TYPE:
+ return "Context.Consumer";
+
+ case REACT_PROVIDER_TYPE:
+ return "Context.Provider";
+
+ case REACT_FORWARD_REF_TYPE:
+ return getWrappedName(type, type.render, "ForwardRef");
+
+ case REACT_MEMO_TYPE:
+ return getComponentName(type.type);
+
+ case REACT_LAZY_TYPE:
+ {
+ var thenable = type;
+ var resolvedThenable = refineResolvedLazyComponent(thenable);
+
+ if (resolvedThenable) {
+ return getComponentName(resolvedThenable);
+ }
+ }
+ }
+ }
+
+ return null;
+ }
+
+ var NoEffect = 0;
+ var PerformedWork = 1;
+ var Placement = 2;
+ var Update = 4;
+ var PlacementAndUpdate = 6;
+ var Deletion = 8;
+ var ContentReset = 16;
+ var Callback = 32;
+ var DidCapture = 64;
+ var Ref = 128;
+ var Snapshot = 256;
+ var Passive = 512;
+ var LifecycleEffectMask = 932;
+ var HostEffectMask = 1023;
+ var Incomplete = 1024;
+ var ShouldCapture = 2048;
+ var ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner;
+ var MOUNTING = 1;
+ var MOUNTED = 2;
+ var UNMOUNTED = 3;
+
+ function isFiberMountedImpl(fiber) {
+ var node = fiber;
+
+ if (!fiber.alternate) {
+ if ((node.effectTag & Placement) !== NoEffect) {
+ return MOUNTING;
+ }
+
+ while (node.return) {
+ node = node.return;
+
+ if ((node.effectTag & Placement) !== NoEffect) {
+ return MOUNTING;
+ }
+ }
+ } else {
+ while (node.return) {
+ node = node.return;
+ }
+ }
+
+ if (node.tag === HostRoot) {
+ return MOUNTED;
+ }
+
+ return UNMOUNTED;
+ }
+
+ function isFiberMounted(fiber) {
+ return isFiberMountedImpl(fiber) === MOUNTED;
+ }
+
+ function isMounted(component) {
+ {
+ var owner = ReactCurrentOwner$1.current;
+
+ if (owner !== null && owner.tag === ClassComponent) {
+ var ownerFiber = owner;
+ var instance = ownerFiber.stateNode;
+ !instance._warnedAboutRefsInRender ? warningWithoutStack$1(false, "%s is accessing isMounted inside its render() function. " + "render() should be a pure function of props and state. It should " + "never access something that requires stale data from the previous " + "render, such as refs. Move this logic to componentDidMount and " + "componentDidUpdate instead.", getComponentName(ownerFiber.type) || "A component") : void 0;
+ instance._warnedAboutRefsInRender = true;
+ }
+ }
+ var fiber = get$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;
+ }
+
+ var emptyObject = {};
+ 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, props, validAttributes);
+ }
+
+ function clearProperties(updatePayload, prevProps, validAttributes) {
+ return diffProperties(updatePayload, prevProps, emptyObject, validAttributes);
+ }
+
+ function create(props, validAttributes) {
+ return addProperties(null, props, validAttributes);
+ }
+
+ function diff(prevProps, nextProps, validAttributes) {
+ return diffProperties(null, prevProps, nextProps, validAttributes);
+ }
+
+ function mountSafeCallback_NOT_REALLY_SAFE(context, callback) {
+ return function () {
+ if (!callback) {
+ return undefined;
+ }
+
+ if (typeof context.__isMounted === "boolean") {
+ if (!context.__isMounted) {
+ return undefined;
+ }
+ }
+
+ return callback.apply(context, arguments);
+ };
+ }
+
+ function throwOnStylesProp(component, props) {
+ if (props.styles !== undefined) {
+ var owner = component._owner || null;
+ var name = component.constructor.displayName;
+ var msg = "`styles` is not a supported property of `" + name + "`, did " + "you mean `style` (singular)?";
+
+ if (owner && owner.constructor && owner.constructor.displayName) {
+ msg += "\n\nCheck the `" + owner.constructor.displayName + "` parent " + " component.";
+ }
+
+ throw new Error(msg);
+ }
+ }
+
+ function warnForStyleProps(props, validAttributes) {
+ for (var key in validAttributes.style) {
+ if (!(validAttributes[key] || props[key] === undefined)) {
+ console.error("You are setting the style `{ " + key + ": ... }` as a prop. You " + "should nest it in a style object. " + "E.g. `{ style: { " + key + ": ... } }`");
+ }
+ }
+ }
+
+ var debugRenderPhaseSideEffects = false;
+ var debugRenderPhaseSideEffectsForStrictMode = false;
+ var enableUserTimingAPI = true;
+ var replayFailedUnitOfWorkWithInvokeGuardedCallback = true;
+ var warnAboutDeprecatedLifecycles = false;
+ var enableProfilerTimer = true;
+ var enableSchedulerTracing = true;
+ var enableSuspenseServerRenderer = false;
+ var warnAboutDeprecatedSetNativeProps = false;
+
+ 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_NOT_REALLY_SAFE(this, callback));
+ };
+
+ ReactNativeFiberHostComponent.prototype.measureInWindow = function measureInWindow(callback) {
+ UIManager.measureInWindow(this._nativeTag, mountSafeCallback_NOT_REALLY_SAFE(this, callback));
+ };
+
+ ReactNativeFiberHostComponent.prototype.measureLayout = function measureLayout(relativeToNativeNode, onSuccess, onFail) {
+ UIManager.measureLayout(this._nativeTag, relativeToNativeNode, mountSafeCallback_NOT_REALLY_SAFE(this, onFail), mountSafeCallback_NOT_REALLY_SAFE(this, onSuccess));
+ };
+
+ ReactNativeFiberHostComponent.prototype.setNativeProps = function setNativeProps(nativeProps) {
+ {
+ if (warnAboutDeprecatedSetNativeProps) {
+ warningWithoutStack$1(false, "Warning: Calling ref.setNativeProps(nativeProps) " + "is deprecated and will be removed in a future release. " + "Use the setNativeProps export from the react-native package instead." + "\n\timport {setNativeProps} from 'react-native';\n\tsetNativeProps(ref, nativeProps);\n");
+ }
+
+ warnForStyleProps(nativeProps, this.viewConfig.validAttributes);
+ }
+ var updatePayload = create(nativeProps, this.viewConfig.validAttributes);
+
+ if (updatePayload != null) {
+ 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;
+
+ function setTimeoutCallback() {
+ frameDeadline = now$1() + 5;
+ var callback = scheduledCallback;
+ scheduledCallback = null;
+
+ if (callback !== null) {
+ callback();
+ }
+ }
+
+ function scheduleDeferredCallback$1(callback, options) {
+ scheduledCallback = callback;
+ var timeoutId = setTimeout(setTimeoutCallback, 1);
+ return timeoutId;
+ }
+
+ function cancelDeferredCallback$1(callbackID) {
+ scheduledCallback = null;
+ clearTimeout(callbackID);
+ }
+
+ function shouldYield$1() {
+ return frameDeadline <= now$1();
+ }
+
+ 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;
+ var cloneHiddenInstance = shim;
+ var cloneUnhiddenInstance = shim;
+ var createHiddenTextInstance = shim;
+
+ function shim$1() {
+ invariant(false, "The current renderer does not support hydration. " + "This error is likely caused by a bug in React. " + "Please file an issue.");
+ }
+
+ var supportsHydration = false;
+ var canHydrateInstance = shim$1;
+ var canHydrateTextInstance = shim$1;
+ var canHydrateSuspenseInstance = shim$1;
+ var isSuspenseInstancePending = shim$1;
+ var isSuspenseInstanceFallback = shim$1;
+ var registerSuspenseInstanceRetry = shim$1;
+ var getNextHydratableSibling = shim$1;
+ var getFirstHydratableChild = shim$1;
+ var hydrateInstance = shim$1;
+ var hydrateTextInstance = shim$1;
+ var getNextHydratableInstanceAfterSuspenseInstance = shim$1;
+ var clearSuspenseBoundary = shim$1;
+ var clearSuspenseBoundaryFromContainer = shim$1;
+ var didNotMatchHydratedContainerTextInstance = shim$1;
+ var didNotMatchHydratedTextInstance = shim$1;
+ var didNotHydrateContainerInstance = shim$1;
+ var didNotHydrateInstance = shim$1;
+ var didNotFindHydratableContainerInstance = shim$1;
+ var didNotFindHydratableContainerTextInstance = shim$1;
+ var didNotFindHydratableContainerSuspenseInstance = shim$1;
+ var didNotFindHydratableInstance = shim$1;
+ var didNotFindHydratableTextInstance = shim$1;
+ var didNotFindHydratableSuspenseInstance = shim$1;
+ var UPDATE_SIGNAL = {};
+ {
+ Object.freeze(UPDATE_SIGNAL);
+ }
+ var nextReactTag = 3;
+
+ function allocateTag() {
+ var tag = nextReactTag;
+
+ if (tag % 10 === 1) {
+ tag += 2;
+ }
+
+ nextReactTag = tag + 2;
+ return tag;
+ }
+
+ function recursivelyUncacheFiberNode(node) {
+ if (typeof node === "number") {
+ uncacheFiberNode(node);
+ } else {
+ uncacheFiberNode(node._nativeTag);
+
+ node._children.forEach(recursivelyUncacheFiberNode);
+ }
+ }
+
+ function appendInitialChild(parentInstance, child) {
+ parentInstance._children.push(child);
+ }
+
+ function createInstance(type, props, rootContainerInstance, hostContext, internalInstanceHandle) {
+ var tag = allocateTag();
+ var viewConfig = ReactNativeViewConfigRegistry.get(type);
+ {
+ for (var key in viewConfig.validAttributes) {
+ if (props.hasOwnProperty(key)) {
+ deepFreezeAndThrowOnMutationInDev(props[key]);
+ }
+ }
+ }
+ invariant(type !== "RCTView" || !hostContext.isInAParentText, "Nesting of within 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 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 UPDATE_SIGNAL;
+ }
+
+ function resetAfterCommit(containerInfo) {}
+
+ var now$$1 = now$1;
+ var isPrimaryRenderer = true;
+ var scheduleDeferredCallback$$1 = scheduleDeferredCallback$1;
+ var cancelDeferredCallback$$1 = cancelDeferredCallback$1;
+ var shouldYield$$1 = shouldYield$1;
+ var scheduleTimeout = setTimeout;
+ var cancelTimeout = clearTimeout;
+ var noTimeout = -1;
+ var schedulePassiveEffects = scheduleDeferredCallback$$1;
+ var cancelPassiveEffects = 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) {}
+
+ function hideInstance(instance) {
+ var viewConfig = instance.viewConfig;
+ var updatePayload = create({
+ style: {
+ display: "none"
+ }
+ }, viewConfig.validAttributes);
+ UIManager.updateView(instance._nativeTag, viewConfig.uiViewClassName, updatePayload);
+ }
+
+ function hideTextInstance(textInstance) {
+ throw new Error("Not yet implemented.");
+ }
+
+ function unhideInstance(instance, props) {
+ var viewConfig = instance.viewConfig;
+ var updatePayload = diff(_extends({}, props, {
+ style: [props.style, {
+ display: "none"
+ }]
+ }), props, viewConfig.validAttributes);
+ UIManager.updateView(instance._nativeTag, viewConfig.uiViewClassName, updatePayload);
+ }
+
+ function unhideTextInstance(textInstance, text) {
+ throw new Error("Not yet implemented.");
+ }
+
+ var BEFORE_SLASH_RE = /^(.*)[\\\/]/;
+
+ var describeComponentFrame = function describeComponentFrame(name, source, ownerName) {
+ var sourceInfo = "";
+
+ if (source) {
+ var path = source.fileName;
+ var fileName = path.replace(BEFORE_SLASH_RE, "");
+ {
+ if (/^index\./.test(fileName)) {
+ var match = path.match(BEFORE_SLASH_RE);
+
+ if (match) {
+ var pathBeforeSlash = match[1];
+
+ if (pathBeforeSlash) {
+ var folderName = pathBeforeSlash.replace(BEFORE_SLASH_RE, "");
+ fileName = folderName + "/" + fileName;
+ }
+ }
+ }
+ }
+ sourceInfo = " (at " + fileName + ":" + source.lineNumber + ")";
+ } else if (ownerName) {
+ sourceInfo = " (created by " + ownerName + ")";
+ }
+
+ return "\n in " + (name || "Unknown") + sourceInfo;
+ };
+
+ var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+
+ function describeFiber(fiber) {
+ switch (fiber.tag) {
+ case HostRoot:
+ case HostPortal:
+ case HostText:
+ case Fragment:
+ case ContextProvider:
+ case ContextConsumer:
+ return "";
+
+ default:
+ var owner = fiber._debugOwner;
+ var source = fiber._debugSource;
+ var name = getComponentName(fiber.type);
+ var ownerName = null;
+
+ if (owner) {
+ ownerName = getComponentName(owner.type);
+ }
+
+ return describeComponentFrame(name, source, ownerName);
+ }
+ }
+
+ function getStackByFiberInDevAndProd(workInProgress) {
+ var info = "";
+ var node = workInProgress;
+
+ do {
+ info += describeFiber(node);
+ node = node.return;
+ } while (node);
+
+ return info;
+ }
+
+ var current = null;
+ var phase = null;
+
+ function getCurrentFiberOwnerNameInDevOrNull() {
+ {
+ if (current === null) {
+ return null;
+ }
+
+ var owner = current._debugOwner;
+
+ if (owner !== null && typeof owner !== "undefined") {
+ return getComponentName(owner.type);
+ }
+ }
+ return null;
+ }
+
+ function getCurrentFiberStackInDev() {
+ {
+ if (current === null) {
+ return "";
+ }
+
+ return getStackByFiberInDevAndProd(current);
+ }
+ return "";
+ }
+
+ function resetCurrentFiber() {
+ {
+ ReactDebugCurrentFrame.getCurrentStack = null;
+ current = null;
+ phase = null;
+ }
+ }
+
+ function setCurrentFiber(fiber) {
+ {
+ ReactDebugCurrentFrame.getCurrentStack = getCurrentFiberStackInDev;
+ current = fiber;
+ phase = null;
+ }
+ }
+
+ function setCurrentPhase(lifeCyclePhase) {
+ {
+ phase = lifeCyclePhase;
+ }
+ }
+
+ var reactEmoji = "\u269B";
+ var warningEmoji = "\u26D4";
+ var supportsUserTiming = typeof performance !== "undefined" && typeof performance.mark === "function" && typeof performance.clearMarks === "function" && typeof performance.measure === "function" && typeof performance.clearMeasures === "function";
+ var currentFiber = null;
+ var currentPhase = null;
+ var currentPhaseFiber = null;
+ var isCommitting = false;
+ var hasScheduledUpdateInCurrentCommit = false;
+ var hasScheduledUpdateInCurrentPhase = false;
+ var commitCountInCurrentWorkLoop = 0;
+ var effectCountInCurrentCommit = 0;
+ var isWaitingForCallback = false;
+ var labelsInCurrentCommit = new Set();
+
+ var formatMarkName = function formatMarkName(markName) {
+ return reactEmoji + " " + markName;
+ };
+
+ var formatLabel = function formatLabel(label, warning) {
+ var prefix = warning ? warningEmoji + " " : reactEmoji + " ";
+ var suffix = warning ? " Warning: " + warning : "";
+ return "" + prefix + label + suffix;
+ };
+
+ var beginMark = function beginMark(markName) {
+ performance.mark(formatMarkName(markName));
+ };
+
+ var clearMark = function clearMark(markName) {
+ performance.clearMarks(formatMarkName(markName));
+ };
+
+ var endMark = function endMark(label, markName, warning) {
+ var formattedMarkName = formatMarkName(markName);
+ var formattedLabel = formatLabel(label, warning);
+
+ try {
+ performance.measure(formattedLabel, formattedMarkName);
+ } catch (err) {}
+
+ performance.clearMarks(formattedMarkName);
+ performance.clearMeasures(formattedLabel);
+ };
+
+ var getFiberMarkName = function getFiberMarkName(label, debugID) {
+ return label + " (#" + debugID + ")";
+ };
+
+ var getFiberLabel = function getFiberLabel(componentName, isMounted, phase) {
+ if (phase === null) {
+ return componentName + " [" + (isMounted ? "update" : "mount") + "]";
+ } else {
+ return componentName + "." + phase;
+ }
+ };
+
+ var beginFiberMark = function beginFiberMark(fiber, phase) {
+ var componentName = getComponentName(fiber.type) || "Unknown";
+ var debugID = fiber._debugID;
+ var isMounted = fiber.alternate !== null;
+ var label = getFiberLabel(componentName, isMounted, phase);
+
+ if (isCommitting && labelsInCurrentCommit.has(label)) {
+ return false;
+ }
+
+ labelsInCurrentCommit.add(label);
+ var markName = getFiberMarkName(label, debugID);
+ beginMark(markName);
+ return true;
+ };
+
+ var clearFiberMark = function clearFiberMark(fiber, phase) {
+ var componentName = getComponentName(fiber.type) || "Unknown";
+ var debugID = fiber._debugID;
+ var isMounted = fiber.alternate !== null;
+ var label = getFiberLabel(componentName, isMounted, phase);
+ var markName = getFiberMarkName(label, debugID);
+ clearMark(markName);
+ };
+
+ var endFiberMark = function endFiberMark(fiber, phase, warning) {
+ var componentName = getComponentName(fiber.type) || "Unknown";
+ var debugID = fiber._debugID;
+ var isMounted = fiber.alternate !== null;
+ var label = getFiberLabel(componentName, isMounted, phase);
+ var markName = getFiberMarkName(label, debugID);
+ endMark(label, markName, warning);
+ };
+
+ var shouldIgnoreFiber = function shouldIgnoreFiber(fiber) {
+ switch (fiber.tag) {
+ case HostRoot:
+ case HostComponent:
+ case HostText:
+ case HostPortal:
+ case Fragment:
+ case ContextProvider:
+ case ContextConsumer:
+ case Mode:
+ return true;
+
+ default:
+ return false;
+ }
+ };
+
+ var clearPendingPhaseMeasurement = function clearPendingPhaseMeasurement() {
+ if (currentPhase !== null && currentPhaseFiber !== null) {
+ clearFiberMark(currentPhaseFiber, currentPhase);
+ }
+
+ currentPhaseFiber = null;
+ currentPhase = null;
+ hasScheduledUpdateInCurrentPhase = false;
+ };
+
+ var pauseTimers = function pauseTimers() {
+ var fiber = currentFiber;
+
+ while (fiber) {
+ if (fiber._debugIsCurrentlyTiming) {
+ endFiberMark(fiber, null, null);
+ }
+
+ fiber = fiber.return;
+ }
+ };
+
+ var resumeTimersRecursively = function resumeTimersRecursively(fiber) {
+ if (fiber.return !== null) {
+ resumeTimersRecursively(fiber.return);
+ }
+
+ if (fiber._debugIsCurrentlyTiming) {
+ beginFiberMark(fiber, null);
+ }
+ };
+
+ var resumeTimers = function resumeTimers() {
+ if (currentFiber !== null) {
+ resumeTimersRecursively(currentFiber);
+ }
+ };
+
+ function recordEffect() {
+ if (enableUserTimingAPI) {
+ effectCountInCurrentCommit++;
+ }
+ }
+
+ function recordScheduleUpdate() {
+ if (enableUserTimingAPI) {
+ if (isCommitting) {
+ hasScheduledUpdateInCurrentCommit = true;
+ }
+
+ if (currentPhase !== null && currentPhase !== "componentWillMount" && currentPhase !== "componentWillReceiveProps") {
+ hasScheduledUpdateInCurrentPhase = true;
+ }
+ }
+ }
+
+ function startRequestCallbackTimer() {
+ if (enableUserTimingAPI) {
+ if (supportsUserTiming && !isWaitingForCallback) {
+ isWaitingForCallback = true;
+ beginMark("(Waiting for async callback...)");
+ }
+ }
+ }
+
+ function stopRequestCallbackTimer(didExpire, expirationTime) {
+ if (enableUserTimingAPI) {
+ if (supportsUserTiming) {
+ isWaitingForCallback = false;
+ var warning = didExpire ? "React was blocked by main thread" : null;
+ endMark("(Waiting for async callback... will force flush in " + expirationTime + " ms)", "(Waiting for async callback...)", warning);
+ }
+ }
+ }
+
+ function startWorkTimer(fiber) {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming || shouldIgnoreFiber(fiber)) {
+ return;
+ }
+
+ currentFiber = fiber;
+
+ if (!beginFiberMark(fiber, null)) {
+ return;
+ }
+
+ fiber._debugIsCurrentlyTiming = true;
+ }
+ }
+
+ function cancelWorkTimer(fiber) {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming || shouldIgnoreFiber(fiber)) {
+ return;
+ }
+
+ fiber._debugIsCurrentlyTiming = false;
+ clearFiberMark(fiber, null);
+ }
+ }
+
+ function stopWorkTimer(fiber) {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming || shouldIgnoreFiber(fiber)) {
+ return;
+ }
+
+ currentFiber = fiber.return;
+
+ if (!fiber._debugIsCurrentlyTiming) {
+ return;
+ }
+
+ fiber._debugIsCurrentlyTiming = false;
+ endFiberMark(fiber, null, null);
+ }
+ }
+
+ function stopFailedWorkTimer(fiber) {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming || shouldIgnoreFiber(fiber)) {
+ return;
+ }
+
+ currentFiber = fiber.return;
+
+ if (!fiber._debugIsCurrentlyTiming) {
+ return;
+ }
+
+ fiber._debugIsCurrentlyTiming = false;
+ var warning = fiber.tag === SuspenseComponent || fiber.tag === DehydratedSuspenseComponent ? "Rendering was suspended" : "An error was thrown inside this error boundary";
+ endFiberMark(fiber, null, warning);
+ }
+ }
+
+ function startPhaseTimer(fiber, phase) {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ clearPendingPhaseMeasurement();
+
+ if (!beginFiberMark(fiber, phase)) {
+ return;
+ }
+
+ currentPhaseFiber = fiber;
+ currentPhase = phase;
+ }
+ }
+
+ function stopPhaseTimer() {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ if (currentPhase !== null && currentPhaseFiber !== null) {
+ var warning = hasScheduledUpdateInCurrentPhase ? "Scheduled a cascading update" : null;
+ endFiberMark(currentPhaseFiber, currentPhase, warning);
+ }
+
+ currentPhase = null;
+ currentPhaseFiber = null;
+ }
+ }
+
+ function startWorkLoopTimer(nextUnitOfWork) {
+ if (enableUserTimingAPI) {
+ currentFiber = nextUnitOfWork;
+
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ commitCountInCurrentWorkLoop = 0;
+ beginMark("(React Tree Reconciliation)");
+ resumeTimers();
+ }
+ }
+
+ function stopWorkLoopTimer(interruptedBy, didCompleteRoot) {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ var warning = null;
+
+ if (interruptedBy !== null) {
+ if (interruptedBy.tag === HostRoot) {
+ warning = "A top-level update interrupted the previous render";
+ } else {
+ var componentName = getComponentName(interruptedBy.type) || "Unknown";
+ warning = "An update to " + componentName + " interrupted the previous render";
+ }
+ } else if (commitCountInCurrentWorkLoop > 1) {
+ warning = "There were cascading updates";
+ }
+
+ commitCountInCurrentWorkLoop = 0;
+ var label = didCompleteRoot ? "(React Tree Reconciliation: Completed Root)" : "(React Tree Reconciliation: Yielded)";
+ pauseTimers();
+ endMark(label, "(React Tree Reconciliation)", warning);
+ }
+ }
+
+ function startCommitTimer() {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ isCommitting = true;
+ hasScheduledUpdateInCurrentCommit = false;
+ labelsInCurrentCommit.clear();
+ beginMark("(Committing Changes)");
+ }
+ }
+
+ function stopCommitTimer() {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ var warning = null;
+
+ if (hasScheduledUpdateInCurrentCommit) {
+ warning = "Lifecycle hook scheduled a cascading update";
+ } else if (commitCountInCurrentWorkLoop > 0) {
+ warning = "Caused by a cascading update in earlier commit";
+ }
+
+ hasScheduledUpdateInCurrentCommit = false;
+ commitCountInCurrentWorkLoop++;
+ isCommitting = false;
+ labelsInCurrentCommit.clear();
+ endMark("(Committing Changes)", "(Committing Changes)", warning);
+ }
+ }
+
+ function startCommitSnapshotEffectsTimer() {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ effectCountInCurrentCommit = 0;
+ beginMark("(Committing Snapshot Effects)");
+ }
+ }
+
+ function stopCommitSnapshotEffectsTimer() {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ var count = effectCountInCurrentCommit;
+ effectCountInCurrentCommit = 0;
+ endMark("(Committing Snapshot Effects: " + count + " Total)", "(Committing Snapshot Effects)", null);
+ }
+ }
+
+ function startCommitHostEffectsTimer() {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ effectCountInCurrentCommit = 0;
+ beginMark("(Committing Host Effects)");
+ }
+ }
+
+ function stopCommitHostEffectsTimer() {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ var count = effectCountInCurrentCommit;
+ effectCountInCurrentCommit = 0;
+ endMark("(Committing Host Effects: " + count + " Total)", "(Committing Host Effects)", null);
+ }
+ }
+
+ function startCommitLifeCyclesTimer() {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ effectCountInCurrentCommit = 0;
+ beginMark("(Calling Lifecycle Methods)");
+ }
+ }
+
+ function stopCommitLifeCyclesTimer() {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ var count = effectCountInCurrentCommit;
+ effectCountInCurrentCommit = 0;
+ endMark("(Calling Lifecycle Methods: " + count + " Total)", "(Calling Lifecycle Methods)", null);
+ }
+ }
+
+ var valueStack = [];
+ var fiberStack = void 0;
+ {
+ fiberStack = [];
+ }
+ var index = -1;
+
+ function createCursor(defaultValue) {
+ return {
+ current: defaultValue
+ };
+ }
+
+ function pop(cursor, fiber) {
+ if (index < 0) {
+ {
+ warningWithoutStack$1(false, "Unexpected pop.");
+ }
+ return;
+ }
+
+ {
+ if (fiber !== fiberStack[index]) {
+ warningWithoutStack$1(false, "Unexpected Fiber popped.");
+ }
+ }
+ cursor.current = valueStack[index];
+ valueStack[index] = null;
+ {
+ fiberStack[index] = null;
+ }
+ index--;
+ }
+
+ function push(cursor, value, fiber) {
+ index++;
+ valueStack[index] = cursor.current;
+ {
+ fiberStack[index] = fiber;
+ }
+ cursor.current = value;
+ }
+
+ function checkThatStackIsEmpty() {
+ {
+ if (index !== -1) {
+ warningWithoutStack$1(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 emptyContextObject = {};
+ {
+ Object.freeze(emptyContextObject);
+ }
+ var contextStackCursor = createCursor(emptyContextObject);
+ var didPerformWorkStackCursor = createCursor(false);
+ var previousContext = emptyContextObject;
+
+ function getUnmaskedContext(workInProgress, Component, didPushOwnContextIfProvider) {
+ if (didPushOwnContextIfProvider && isContextProvider(Component)) {
+ 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 emptyContextObject;
+ }
+
+ var instance = workInProgress.stateNode;
+
+ if (instance && instance.__reactInternalMemoizedUnmaskedChildContext === unmaskedContext) {
+ return instance.__reactInternalMemoizedMaskedChildContext;
+ }
+
+ var context = {};
+
+ for (var key in contextTypes) {
+ context[key] = unmaskedContext[key];
+ }
+
+ {
+ var name = getComponentName(type) || "Unknown";
+ checkPropTypes(contextTypes, context, "context", name, getCurrentFiberStackInDev);
+ }
+
+ if (instance) {
+ cacheContext(workInProgress, unmaskedContext, context);
+ }
+
+ return context;
+ }
+
+ function hasContextChanged() {
+ return didPerformWorkStackCursor.current;
+ }
+
+ function isContextProvider(type) {
+ var childContextTypes = type.childContextTypes;
+ return childContextTypes !== null && childContextTypes !== undefined;
+ }
+
+ function popContext(fiber) {
+ pop(didPerformWorkStackCursor, fiber);
+ pop(contextStackCursor, fiber);
+ }
+
+ function popTopLevelContextObject(fiber) {
+ pop(didPerformWorkStackCursor, fiber);
+ pop(contextStackCursor, fiber);
+ }
+
+ function pushTopLevelContextObject(fiber, context, didChange) {
+ invariant(contextStackCursor.current === emptyContextObject, "Unexpected context found on stack. " + "This error is likely caused by a bug in React. Please file an issue.");
+ push(contextStackCursor, context, fiber);
+ push(didPerformWorkStackCursor, didChange, fiber);
+ }
+
+ function processChildContext(fiber, type, parentContext) {
+ var instance = fiber.stateNode;
+ var childContextTypes = type.childContextTypes;
+
+ if (typeof instance.getChildContext !== "function") {
+ {
+ var componentName = getComponentName(type) || "Unknown";
+
+ if (!warnedAboutMissingGetChildContext[componentName]) {
+ warnedAboutMissingGetChildContext[componentName] = true;
+ warningWithoutStack$1(false, "%s.childContextTypes is specified but there is no getChildContext() method " + "on the instance. You can either define getChildContext() on %s or remove " + "childContextTypes from it.", componentName, componentName);
+ }
+ }
+ return parentContext;
+ }
+
+ var childContext = void 0;
+ {
+ setCurrentPhase("getChildContext");
+ }
+ startPhaseTimer(fiber, "getChildContext");
+ childContext = instance.getChildContext();
+ stopPhaseTimer();
+ {
+ setCurrentPhase(null);
+ }
+
+ for (var contextKey in childContext) {
+ invariant(contextKey in childContextTypes, '%s.getChildContext(): key "%s" is not defined in childContextTypes.', getComponentName(type) || "Unknown", contextKey);
+ }
+
+ {
+ var name = getComponentName(type) || "Unknown";
+ checkPropTypes(childContextTypes, childContext, "child context", name, getCurrentFiberStackInDev);
+ }
+ return _extends({}, parentContext, childContext);
+ }
+
+ function pushContextProvider(workInProgress) {
+ var instance = workInProgress.stateNode;
+ var memoizedMergedChildContext = instance && instance.__reactInternalMemoizedMergedChildContext || emptyContextObject;
+ previousContext = contextStackCursor.current;
+ push(contextStackCursor, memoizedMergedChildContext, workInProgress);
+ push(didPerformWorkStackCursor, didPerformWorkStackCursor.current, workInProgress);
+ return true;
+ }
+
+ function invalidateContextProvider(workInProgress, type, didChange) {
+ 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, type, previousContext);
+ instance.__reactInternalMemoizedMergedChildContext = mergedContext;
+ pop(didPerformWorkStackCursor, workInProgress);
+ pop(contextStackCursor, workInProgress);
+ push(contextStackCursor, mergedContext, workInProgress);
+ push(didPerformWorkStackCursor, didChange, workInProgress);
+ } else {
+ pop(didPerformWorkStackCursor, workInProgress);
+ push(didPerformWorkStackCursor, didChange, workInProgress);
+ }
+ }
+
+ function findCurrentUnmaskedContext(fiber) {
+ 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;
+
+ do {
+ switch (node.tag) {
+ case HostRoot:
+ return node.stateNode.context;
+
+ case ClassComponent:
+ {
+ var Component = node.type;
+
+ if (isContextProvider(Component)) {
+ return node.stateNode.__reactInternalMemoizedMergedChildContext;
+ }
+
+ break;
+ }
+ }
+
+ node = node.return;
+ } while (node !== null);
+
+ invariant(false, "Found unexpected detached subtree parent. " + "This error is likely caused by a bug in React. Please file an issue.");
+ }
+
+ 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;
+ warningWithoutStack$1(false, "React DevTools encountered an error: %s", err);
+ }
+ }
+ };
+ }
+
+ var isDevToolsPresent = typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined";
+
+ function injectInternals(internals) {
+ if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === "undefined") {
+ return false;
+ }
+
+ var hook = __REACT_DEVTOOLS_GLOBAL_HOOK__;
+
+ if (hook.isDisabled) {
+ return true;
+ }
+
+ if (!hook.supportsFiber) {
+ {
+ warningWithoutStack$1(false, "The installed version of React DevTools is too old and will not work " + "with the current version of React. Please update React DevTools. " + "https://fb.me/react-devtools");
+ }
+ return true;
+ }
+
+ try {
+ var rendererID = hook.inject(internals);
+ onCommitFiberRoot = catchErrors(function (root) {
+ return hook.onCommitFiberRoot(rendererID, root);
+ });
+ onCommitFiberUnmount = catchErrors(function (fiber) {
+ return hook.onCommitFiberUnmount(rendererID, fiber);
+ });
+ } catch (err) {
+ {
+ warningWithoutStack$1(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 maxSigned31BitInt = 1073741823;
+ var NoWork = 0;
+ var Never = 1;
+ var Sync = maxSigned31BitInt;
+ var UNIT_SIZE = 10;
+ var MAGIC_NUMBER_OFFSET = maxSigned31BitInt - 1;
+
+ function msToExpirationTime(ms) {
+ return MAGIC_NUMBER_OFFSET - (ms / UNIT_SIZE | 0);
+ }
+
+ function expirationTimeToMs(expirationTime) {
+ return (MAGIC_NUMBER_OFFSET - expirationTime) * UNIT_SIZE;
+ }
+
+ function ceiling(num, precision) {
+ return ((num / precision | 0) + 1) * precision;
+ }
+
+ function computeExpirationBucket(currentTime, expirationInMs, bucketSizeMs) {
+ return MAGIC_NUMBER_OFFSET - ceiling(MAGIC_NUMBER_OFFSET - currentTime + expirationInMs / UNIT_SIZE, bucketSizeMs / UNIT_SIZE);
+ }
+
+ var LOW_PRIORITY_EXPIRATION = 5000;
+ var LOW_PRIORITY_BATCH_SIZE = 250;
+
+ function computeAsyncExpiration(currentTime) {
+ return computeExpirationBucket(currentTime, LOW_PRIORITY_EXPIRATION, LOW_PRIORITY_BATCH_SIZE);
+ }
+
+ var HIGH_PRIORITY_EXPIRATION = 500;
+ var HIGH_PRIORITY_BATCH_SIZE = 100;
+
+ function computeInteractiveExpiration(currentTime) {
+ return computeExpirationBucket(currentTime, HIGH_PRIORITY_EXPIRATION, HIGH_PRIORITY_BATCH_SIZE);
+ }
+
+ var NoContext = 0;
+ var ConcurrentMode = 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.elementType = null;
+ this.type = null;
+ this.stateNode = null;
+ this.return = null;
+ this.child = null;
+ this.sibling = null;
+ this.index = 0;
+ this.ref = null;
+ this.pendingProps = pendingProps;
+ this.memoizedProps = null;
+ this.updateQueue = null;
+ this.memoizedState = null;
+ this.contextDependencies = null;
+ this.mode = mode;
+ this.effectTag = NoEffect;
+ this.nextEffect = null;
+ this.firstEffect = null;
+ this.lastEffect = null;
+ this.expirationTime = NoWork;
+ this.childExpirationTime = NoWork;
+ this.alternate = null;
+
+ if (enableProfilerTimer) {
+ this.actualDuration = Number.NaN;
+ this.actualStartTime = Number.NaN;
+ this.selfBaseDuration = Number.NaN;
+ this.treeBaseDuration = Number.NaN;
+ this.actualDuration = 0;
+ this.actualStartTime = -1;
+ this.selfBaseDuration = 0;
+ this.treeBaseDuration = 0;
+ }
+
+ {
+ this._debugID = debugCounter++;
+ this._debugSource = null;
+ this._debugOwner = null;
+ this._debugIsCurrentlyTiming = false;
+
+ if (!hasBadMapPolyfill && typeof Object.preventExtensions === "function") {
+ Object.preventExtensions(this);
+ }
+ }
+ }
+
+ var createFiber = function createFiber(tag, pendingProps, key, mode) {
+ return new FiberNode(tag, pendingProps, key, mode);
+ };
+
+ function shouldConstruct(Component) {
+ var prototype = Component.prototype;
+ return !!(prototype && prototype.isReactComponent);
+ }
+
+ function isSimpleFunctionComponent(type) {
+ return typeof type === "function" && !shouldConstruct(type) && type.defaultProps === undefined;
+ }
+
+ function resolveLazyComponentTag(Component) {
+ if (typeof Component === "function") {
+ return shouldConstruct(Component) ? ClassComponent : FunctionComponent;
+ } else if (Component !== undefined && Component !== null) {
+ var $$typeof = Component.$$typeof;
+
+ if ($$typeof === REACT_FORWARD_REF_TYPE) {
+ return ForwardRef;
+ }
+
+ if ($$typeof === REACT_MEMO_TYPE) {
+ return MemoComponent;
+ }
+ }
+
+ return IndeterminateComponent;
+ }
+
+ function createWorkInProgress(current, pendingProps, expirationTime) {
+ var workInProgress = current.alternate;
+
+ if (workInProgress === null) {
+ workInProgress = createFiber(current.tag, pendingProps, current.key, current.mode);
+ workInProgress.elementType = current.elementType;
+ workInProgress.type = current.type;
+ workInProgress.stateNode = current.stateNode;
+ {
+ workInProgress._debugID = current._debugID;
+ workInProgress._debugSource = current._debugSource;
+ workInProgress._debugOwner = current._debugOwner;
+ }
+ workInProgress.alternate = current;
+ current.alternate = workInProgress;
+ } else {
+ workInProgress.pendingProps = pendingProps;
+ workInProgress.effectTag = NoEffect;
+ workInProgress.nextEffect = null;
+ workInProgress.firstEffect = null;
+ workInProgress.lastEffect = null;
+
+ if (enableProfilerTimer) {
+ workInProgress.actualDuration = 0;
+ workInProgress.actualStartTime = -1;
+ }
+ }
+
+ workInProgress.childExpirationTime = current.childExpirationTime;
+ workInProgress.expirationTime = current.expirationTime;
+ workInProgress.child = current.child;
+ workInProgress.memoizedProps = current.memoizedProps;
+ workInProgress.memoizedState = current.memoizedState;
+ workInProgress.updateQueue = current.updateQueue;
+ workInProgress.contextDependencies = current.contextDependencies;
+ workInProgress.sibling = current.sibling;
+ workInProgress.index = current.index;
+ workInProgress.ref = current.ref;
+
+ if (enableProfilerTimer) {
+ workInProgress.selfBaseDuration = current.selfBaseDuration;
+ workInProgress.treeBaseDuration = current.treeBaseDuration;
+ }
+
+ return workInProgress;
+ }
+
+ function createHostRootFiber(isConcurrent) {
+ var mode = isConcurrent ? ConcurrentMode | StrictMode : NoContext;
+
+ if (enableProfilerTimer && isDevToolsPresent) {
+ mode |= ProfileMode;
+ }
+
+ return createFiber(HostRoot, null, null, mode);
+ }
+
+ function createFiberFromTypeAndProps(type, key, pendingProps, owner, mode, expirationTime) {
+ var fiber = void 0;
+ var fiberTag = IndeterminateComponent;
+ var resolvedType = type;
+
+ if (typeof type === "function") {
+ if (shouldConstruct(type)) {
+ fiberTag = ClassComponent;
+ }
+ } else if (typeof type === "string") {
+ fiberTag = HostComponent;
+ } else {
+ getTag: switch (type) {
+ case REACT_FRAGMENT_TYPE:
+ return createFiberFromFragment(pendingProps.children, mode, expirationTime, key);
+
+ case REACT_CONCURRENT_MODE_TYPE:
+ return createFiberFromMode(pendingProps, mode | ConcurrentMode | StrictMode, expirationTime, key);
+
+ case REACT_STRICT_MODE_TYPE:
+ return createFiberFromMode(pendingProps, mode | StrictMode, expirationTime, key);
+
+ case REACT_PROFILER_TYPE:
+ return createFiberFromProfiler(pendingProps, mode, expirationTime, key);
+
+ case REACT_SUSPENSE_TYPE:
+ return createFiberFromSuspense(pendingProps, mode, expirationTime, key);
+
+ default:
+ {
+ if (typeof type === "object" && type !== null) {
+ switch (type.$$typeof) {
+ case REACT_PROVIDER_TYPE:
+ fiberTag = ContextProvider;
+ break getTag;
+
+ case REACT_CONTEXT_TYPE:
+ fiberTag = ContextConsumer;
+ break getTag;
+
+ case REACT_FORWARD_REF_TYPE:
+ fiberTag = ForwardRef;
+ break getTag;
+
+ case REACT_MEMO_TYPE:
+ fiberTag = MemoComponent;
+ break getTag;
+
+ case REACT_LAZY_TYPE:
+ fiberTag = LazyComponent;
+ resolvedType = null;
+ break getTag;
+ }
+ }
+
+ var info = "";
+ {
+ if (type === undefined || typeof type === "object" && type !== null && Object.keys(type).length === 0) {
+ info += " You likely forgot to export your component from the file " + "it's defined in, or you might have mixed up default and " + "named imports.";
+ }
+
+ var ownerName = owner ? getComponentName(owner.type) : null;
+
+ if (ownerName) {
+ info += "\n\nCheck the render method of `" + ownerName + "`.";
+ }
+ }
+ 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);
+ }
+ }
+ }
+
+ fiber = createFiber(fiberTag, pendingProps, key, mode);
+ fiber.elementType = type;
+ fiber.type = resolvedType;
+ fiber.expirationTime = expirationTime;
+ return fiber;
+ }
+
+ function createFiberFromElement(element, mode, expirationTime) {
+ var owner = null;
+ {
+ owner = element._owner;
+ }
+ var type = element.type;
+ var key = element.key;
+ var pendingProps = element.props;
+ var fiber = createFiberFromTypeAndProps(type, key, pendingProps, owner, mode, expirationTime);
+ {
+ fiber._debugSource = element._source;
+ fiber._debugOwner = element._owner;
+ }
+ return fiber;
+ }
+
+ function createFiberFromFragment(elements, mode, expirationTime, key) {
+ var fiber = createFiber(Fragment, elements, key, mode);
+ fiber.expirationTime = expirationTime;
+ return fiber;
+ }
+
+ function createFiberFromProfiler(pendingProps, mode, expirationTime, key) {
+ {
+ if (typeof pendingProps.id !== "string" || typeof pendingProps.onRender !== "function") {
+ warningWithoutStack$1(false, 'Profiler must specify an "id" string and "onRender" function as props');
+ }
+ }
+ var fiber = createFiber(Profiler, pendingProps, key, mode | ProfileMode);
+ fiber.elementType = REACT_PROFILER_TYPE;
+ fiber.type = REACT_PROFILER_TYPE;
+ fiber.expirationTime = expirationTime;
+ return fiber;
+ }
+
+ function createFiberFromMode(pendingProps, mode, expirationTime, key) {
+ var fiber = createFiber(Mode, pendingProps, key, mode);
+ var type = (mode & ConcurrentMode) === NoContext ? REACT_STRICT_MODE_TYPE : REACT_CONCURRENT_MODE_TYPE;
+ fiber.elementType = type;
+ fiber.type = type;
+ fiber.expirationTime = expirationTime;
+ return fiber;
+ }
+
+ function createFiberFromSuspense(pendingProps, mode, expirationTime, key) {
+ var fiber = createFiber(SuspenseComponent, pendingProps, key, mode);
+ var type = REACT_SUSPENSE_TYPE;
+ fiber.elementType = type;
+ fiber.type = 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.elementType = "DELETED";
+ fiber.type = "DELETED";
+ return fiber;
+ }
+
+ function createFiberFromPortal(portal, mode, expirationTime) {
+ var pendingProps = portal.children !== null ? portal.children : [];
+ var fiber = createFiber(HostPortal, pendingProps, portal.key, mode);
+ fiber.expirationTime = expirationTime;
+ fiber.stateNode = {
+ containerInfo: portal.containerInfo,
+ pendingChildren: null,
+ implementation: portal.implementation
+ };
+ return fiber;
+ }
+
+ function assignFiberPropertiesInDEV(target, source) {
+ if (target === null) {
+ target = createFiber(IndeterminateComponent, null, null, NoContext);
+ }
+
+ target.tag = source.tag;
+ target.key = source.key;
+ target.elementType = source.elementType;
+ target.type = source.type;
+ target.stateNode = source.stateNode;
+ target.return = source.return;
+ target.child = source.child;
+ target.sibling = source.sibling;
+ target.index = source.index;
+ target.ref = source.ref;
+ target.pendingProps = source.pendingProps;
+ target.memoizedProps = source.memoizedProps;
+ target.updateQueue = source.updateQueue;
+ target.memoizedState = source.memoizedState;
+ target.contextDependencies = source.contextDependencies;
+ target.mode = source.mode;
+ target.effectTag = source.effectTag;
+ target.nextEffect = source.nextEffect;
+ target.firstEffect = source.firstEffect;
+ target.lastEffect = source.lastEffect;
+ target.expirationTime = source.expirationTime;
+ target.childExpirationTime = source.childExpirationTime;
+ target.alternate = source.alternate;
+
+ if (enableProfilerTimer) {
+ target.actualDuration = source.actualDuration;
+ target.actualStartTime = source.actualStartTime;
+ target.selfBaseDuration = source.selfBaseDuration;
+ target.treeBaseDuration = source.treeBaseDuration;
+ }
+
+ target._debugID = source._debugID;
+ target._debugSource = source._debugSource;
+ target._debugOwner = source._debugOwner;
+ target._debugIsCurrentlyTiming = source._debugIsCurrentlyTiming;
+ return target;
+ }
+
+ function createFiberRoot(containerInfo, isConcurrent, hydrate) {
+ var uninitializedFiber = createHostRootFiber(isConcurrent);
+ var root = void 0;
+
+ if (enableSchedulerTracing) {
+ root = {
+ current: uninitializedFiber,
+ containerInfo: containerInfo,
+ pendingChildren: null,
+ earliestPendingTime: NoWork,
+ latestPendingTime: NoWork,
+ earliestSuspendedTime: NoWork,
+ latestSuspendedTime: NoWork,
+ latestPingedTime: NoWork,
+ pingCache: null,
+ didError: false,
+ pendingCommitExpirationTime: NoWork,
+ finishedWork: null,
+ timeoutHandle: noTimeout,
+ context: null,
+ pendingContext: null,
+ hydrate: hydrate,
+ nextExpirationTimeToWorkOn: NoWork,
+ expirationTime: NoWork,
+ firstBatch: null,
+ nextScheduledRoot: null,
+ interactionThreadID: tracing.unstable_getThreadID(),
+ memoizedInteractions: new Set(),
+ pendingInteractionMap: new Map()
+ };
+ } else {
+ root = {
+ current: uninitializedFiber,
+ containerInfo: containerInfo,
+ pendingChildren: null,
+ pingCache: null,
+ earliestPendingTime: NoWork,
+ latestPendingTime: NoWork,
+ earliestSuspendedTime: NoWork,
+ latestSuspendedTime: NoWork,
+ latestPingedTime: NoWork,
+ didError: false,
+ pendingCommitExpirationTime: NoWork,
+ finishedWork: null,
+ timeoutHandle: noTimeout,
+ context: null,
+ pendingContext: null,
+ hydrate: hydrate,
+ nextExpirationTimeToWorkOn: NoWork,
+ expirationTime: NoWork,
+ firstBatch: null,
+ nextScheduledRoot: null
+ };
+ }
+
+ uninitializedFiber.stateNode = root;
+ return root;
+ }
+
+ var lowPriorityWarning = function lowPriorityWarning() {};
+
+ {
+ var printWarning = function printWarning(format) {
+ for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+ args[_key - 1] = arguments[_key];
+ }
+
+ var argIndex = 0;
+ var message = "Warning: " + format.replace(/%s/g, function () {
+ return args[argIndex++];
+ });
+
+ if (typeof console !== "undefined") {
+ console.warn(message);
+ }
+
+ try {
+ throw new Error(message);
+ } catch (x) {}
+ };
+
+ lowPriorityWarning = function lowPriorityWarning(condition, format) {
+ if (format === undefined) {
+ throw new Error("`lowPriorityWarning(condition, format, ...args)` requires a warning " + "message argument");
+ }
+
+ if (!condition) {
+ for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
+ args[_key2 - 2] = arguments[_key2];
+ }
+
+ printWarning.apply(undefined, [format].concat(args));
+ }
+ };
+ }
+ var lowPriorityWarning$1 = lowPriorityWarning;
+ var ReactStrictModeWarnings = {
+ 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 lifecyclesWarningMessages = [];
+ 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.type) || "Component");
+ didWarnAboutUnsafeLifecycles.add(fiber.type);
+ });
+ var formatted = lifecycle.replace("UNSAFE_", "");
+ var suggestion = LIFECYCLE_SUGGESTIONS[lifecycle];
+ var sortedComponentNames = setToSortedString(componentNames);
+ lifecyclesWarningMessages.push(formatted + ": Please update the following components to use " + (suggestion + " instead: " + sortedComponentNames));
+ }
+ });
+
+ if (lifecyclesWarningMessages.length > 0) {
+ var strictRootComponentStack = getStackByFiberInDevAndProd(strictRoot);
+ warningWithoutStack$1(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, lifecyclesWarningMessages.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.type) || "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.type) || "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.type) || "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) {
+ warningWithoutStack$1(false, "Expected to find a StrictMode component in a strict mode tree. " + "This error is likely caused by a bug in React. Please file an issue.");
+ return;
+ }
+
+ if (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) {
+ warningWithoutStack$1(false, "Expected to find a StrictMode component in a strict mode tree. " + "This error is likely caused by a bug in React. Please file an issue.");
+ return;
+ }
+
+ if (didWarnAboutLegacyContext.has(fiber.type)) {
+ return;
+ }
+
+ var warningsForRoot = pendingLegacyContextWarning.get(strictRoot);
+
+ if (fiber.type.contextTypes != null || fiber.type.childContextTypes != null || instance !== null && typeof instance.getChildContext === "function") {
+ if (warningsForRoot === undefined) {
+ warningsForRoot = [];
+ pendingLegacyContextWarning.set(strictRoot, warningsForRoot);
+ }
+
+ warningsForRoot.push(fiber);
+ }
+ };
+
+ ReactStrictModeWarnings.flushLegacyContextWarning = function () {
+ pendingLegacyContextWarning.forEach(function (fiberArray, strictRoot) {
+ var uniqueNames = new Set();
+ fiberArray.forEach(function (fiber) {
+ uniqueNames.add(getComponentName(fiber.type) || "Component");
+ didWarnAboutLegacyContext.add(fiber.type);
+ });
+ var sortedNames = setToSortedString(uniqueNames);
+ var strictRootComponentStack = getStackByFiberInDevAndProd(strictRoot);
+ warningWithoutStack$1(false, "Legacy context API has been detected within a strict-mode tree: %s" + "\n\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;
+ }
+ }
+ }
+
+ findNextExpirationTimeToWorkOn(expirationTime, root);
+ }
+
+ function markCommittedPriorityLevels(root, earliestRemainingTime) {
+ root.didError = false;
+
+ if (earliestRemainingTime === NoWork) {
+ root.earliestPendingTime = NoWork;
+ root.latestPendingTime = NoWork;
+ root.earliestSuspendedTime = NoWork;
+ root.latestSuspendedTime = NoWork;
+ root.latestPingedTime = NoWork;
+ findNextExpirationTimeToWorkOn(NoWork, root);
+ return;
+ }
+
+ if (earliestRemainingTime < root.latestPingedTime) {
+ root.latestPingedTime = NoWork;
+ }
+
+ 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);
+ findNextExpirationTimeToWorkOn(NoWork, root);
+ return;
+ }
+
+ var latestSuspendedTime = root.latestSuspendedTime;
+
+ if (earliestRemainingTime < latestSuspendedTime) {
+ root.earliestSuspendedTime = NoWork;
+ root.latestSuspendedTime = NoWork;
+ root.latestPingedTime = NoWork;
+ markPendingPriorityLevel(root, earliestRemainingTime);
+ findNextExpirationTimeToWorkOn(NoWork, root);
+ return;
+ }
+
+ if (earliestRemainingTime > earliestSuspendedTime) {
+ markPendingPriorityLevel(root, earliestRemainingTime);
+ findNextExpirationTimeToWorkOn(NoWork, root);
+ return;
+ }
+
+ findNextExpirationTimeToWorkOn(NoWork, root);
+ }
+
+ function hasLowerPriorityWork(root, erroredExpirationTime) {
+ var latestPendingTime = root.latestPendingTime;
+ var latestSuspendedTime = root.latestSuspendedTime;
+ var latestPingedTime = root.latestPingedTime;
+ return latestPendingTime !== NoWork && latestPendingTime < erroredExpirationTime || latestSuspendedTime !== NoWork && latestSuspendedTime < erroredExpirationTime || latestPingedTime !== NoWork && latestPingedTime < erroredExpirationTime;
+ }
+
+ function isPriorityLevelSuspended(root, expirationTime) {
+ var earliestSuspendedTime = root.earliestSuspendedTime;
+ var latestSuspendedTime = root.latestSuspendedTime;
+ return earliestSuspendedTime !== NoWork && expirationTime <= earliestSuspendedTime && expirationTime >= latestSuspendedTime;
+ }
+
+ function markSuspendedPriorityLevel(root, suspendedTime) {
+ root.didError = false;
+ clearPing(root, suspendedTime);
+ 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 earliestSuspendedTime = root.earliestSuspendedTime;
+ var latestSuspendedTime = root.latestSuspendedTime;
+
+ if (earliestSuspendedTime === NoWork) {
+ root.earliestSuspendedTime = root.latestSuspendedTime = suspendedTime;
+ } else {
+ if (earliestSuspendedTime < suspendedTime) {
+ root.earliestSuspendedTime = suspendedTime;
+ } else if (latestSuspendedTime > suspendedTime) {
+ root.latestSuspendedTime = suspendedTime;
+ }
+ }
+
+ findNextExpirationTimeToWorkOn(suspendedTime, root);
+ }
+
+ function markPingedPriorityLevel(root, pingedTime) {
+ root.didError = false;
+ var latestPingedTime = root.latestPingedTime;
+
+ if (latestPingedTime === NoWork || latestPingedTime > pingedTime) {
+ root.latestPingedTime = pingedTime;
+ }
+
+ findNextExpirationTimeToWorkOn(pingedTime, root);
+ }
+
+ function clearPing(root, completedTime) {
+ var latestPingedTime = root.latestPingedTime;
+
+ if (latestPingedTime >= completedTime) {
+ root.latestPingedTime = NoWork;
+ }
+ }
+
+ function findEarliestOutstandingPriorityLevel(root, renderExpirationTime) {
+ var earliestExpirationTime = renderExpirationTime;
+ var earliestPendingTime = root.earliestPendingTime;
+ var earliestSuspendedTime = root.earliestSuspendedTime;
+
+ if (earliestPendingTime > earliestExpirationTime) {
+ earliestExpirationTime = earliestPendingTime;
+ }
+
+ if (earliestSuspendedTime > earliestExpirationTime) {
+ earliestExpirationTime = earliestSuspendedTime;
+ }
+
+ return earliestExpirationTime;
+ }
+
+ function didExpireAtExpirationTime(root, currentTime) {
+ var expirationTime = root.expirationTime;
+
+ if (expirationTime !== NoWork && currentTime <= expirationTime) {
+ root.nextExpirationTimeToWorkOn = currentTime;
+ }
+ }
+
+ function findNextExpirationTimeToWorkOn(completedExpirationTime, root) {
+ var earliestSuspendedTime = root.earliestSuspendedTime;
+ var latestSuspendedTime = root.latestSuspendedTime;
+ var earliestPendingTime = root.earliestPendingTime;
+ var latestPingedTime = root.latestPingedTime;
+ var nextExpirationTimeToWorkOn = earliestPendingTime !== NoWork ? earliestPendingTime : latestPingedTime;
+
+ if (nextExpirationTimeToWorkOn === NoWork && (completedExpirationTime === NoWork || latestSuspendedTime < completedExpirationTime)) {
+ nextExpirationTimeToWorkOn = latestSuspendedTime;
+ }
+
+ var expirationTime = nextExpirationTimeToWorkOn;
+
+ if (expirationTime !== NoWork && earliestSuspendedTime > expirationTime) {
+ expirationTime = earliestSuspendedTime;
+ }
+
+ root.nextExpirationTimeToWorkOn = nextExpirationTimeToWorkOn;
+ root.expirationTime = expirationTime;
+ }
+
+ var warning = warningWithoutStack$1;
+ {
+ warning = function warning(condition, format) {
+ if (condition) {
+ return;
+ }
+
+ var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+ var stack = ReactDebugCurrentFrame.getStackAddendum();
+
+ for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+ args[_key - 2] = arguments[_key];
+ }
+
+ warningWithoutStack$1.apply(undefined, [false, format + "%s"].concat(args, [stack]));
+ };
+ }
+ var warning$1 = warning;
+
+ function is(x, y) {
+ return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y;
+ }
+
+ var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+ function shallowEqual(objA, objB) {
+ if (is(objA, objB)) {
+ return true;
+ }
+
+ if (typeof objA !== "object" || objA === null || typeof objB !== "object" || objB === null) {
+ return false;
+ }
+
+ var keysA = Object.keys(objA);
+ var keysB = Object.keys(objB);
+
+ if (keysA.length !== keysB.length) {
+ return false;
+ }
+
+ for (var i = 0; i < keysA.length; i++) {
+ if (!hasOwnProperty.call(objB, keysA[i]) || !is(objA[keysA[i]], objB[keysA[i]])) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ function resolveDefaultProps(Component, baseProps) {
+ if (Component && Component.defaultProps) {
+ var props = _extends({}, baseProps);
+
+ var defaultProps = Component.defaultProps;
+
+ for (var propName in defaultProps) {
+ if (props[propName] === undefined) {
+ props[propName] = defaultProps[propName];
+ }
+ }
+
+ return props;
+ }
+
+ return baseProps;
+ }
+
+ function readLazyComponentType(lazyComponent) {
+ var status = lazyComponent._status;
+ var result = lazyComponent._result;
+
+ switch (status) {
+ case Resolved:
+ {
+ var Component = result;
+ return Component;
+ }
+
+ case Rejected:
+ {
+ var error = result;
+ throw error;
+ }
+
+ case Pending:
+ {
+ var thenable = result;
+ throw thenable;
+ }
+
+ default:
+ {
+ lazyComponent._status = Pending;
+ var ctor = lazyComponent._ctor;
+
+ var _thenable = ctor();
+
+ _thenable.then(function (moduleObject) {
+ if (lazyComponent._status === Pending) {
+ var defaultExport = moduleObject.default;
+ {
+ if (defaultExport === undefined) {
+ warning$1(false, "lazy: Expected the result of a dynamic import() call. " + "Instead received: %s\n\nYour code should look like: \n " + "const MyComponent = lazy(() => import('./MyComponent'))", moduleObject);
+ }
+ }
+ lazyComponent._status = Resolved;
+ lazyComponent._result = defaultExport;
+ }
+ }, function (error) {
+ if (lazyComponent._status === Pending) {
+ lazyComponent._status = Rejected;
+ lazyComponent._result = error;
+ }
+ });
+
+ switch (lazyComponent._status) {
+ case Resolved:
+ return lazyComponent._result;
+
+ case Rejected:
+ throw lazyComponent._result;
+ }
+
+ lazyComponent._result = _thenable;
+ throw _thenable;
+ }
+ }
+ }
+
+ var fakeInternalInstance = {};
+ var isArray$1 = Array.isArray;
+ var emptyRefsObject = new React.Component().refs;
+ var didWarnAboutStateAssignmentForComponent = void 0;
+ var didWarnAboutUninitializedState = void 0;
+ var didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate = void 0;
+ var didWarnAboutLegacyLifecyclesAndDerivedState = void 0;
+ var didWarnAboutUndefinedDerivedState = void 0;
+ var warnOnUndefinedDerivedState = void 0;
+ var warnOnInvalidCallback = void 0;
+ var didWarnAboutDirectlyAssigningPropsToState = void 0;
+ var didWarnAboutContextTypeAndContextTypes = void 0;
+ var didWarnAboutInvalidateContextType = void 0;
+ {
+ didWarnAboutStateAssignmentForComponent = new Set();
+ didWarnAboutUninitializedState = new Set();
+ didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate = new Set();
+ didWarnAboutLegacyLifecyclesAndDerivedState = new Set();
+ didWarnAboutDirectlyAssigningPropsToState = new Set();
+ didWarnAboutUndefinedDerivedState = new Set();
+ didWarnAboutContextTypeAndContextTypes = new Set();
+ didWarnAboutInvalidateContextType = new Set();
+ var didWarnOnInvalidCallback = new Set();
+
+ warnOnInvalidCallback = function warnOnInvalidCallback(callback, callerName) {
+ if (callback === null || typeof callback === "function") {
+ return;
+ }
+
+ var key = callerName + "_" + callback;
+
+ if (!didWarnOnInvalidCallback.has(key)) {
+ didWarnOnInvalidCallback.add(key);
+ warningWithoutStack$1(false, "%s(...): Expected the last optional `callback` argument to be a " + "function. Instead received: %s.", callerName, callback);
+ }
+ };
+
+ warnOnUndefinedDerivedState = function warnOnUndefinedDerivedState(type, partialState) {
+ if (partialState === undefined) {
+ var componentName = getComponentName(type) || "Component";
+
+ if (!didWarnAboutUndefinedDerivedState.has(componentName)) {
+ didWarnAboutUndefinedDerivedState.add(componentName);
+ warningWithoutStack$1(false, "%s.getDerivedStateFromProps(): A valid state object (or null) must be returned. " + "You have returned undefined.", componentName);
+ }
+ }
+ };
+
+ Object.defineProperty(fakeInternalInstance, "_processChildContext", {
+ enumerable: false,
+ value: function value() {
+ 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, ctor, getDerivedStateFromProps, nextProps) {
+ var prevState = workInProgress.memoizedState;
+ {
+ if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
+ getDerivedStateFromProps(nextProps, prevState);
+ }
+ }
+ var partialState = getDerivedStateFromProps(nextProps, prevState);
+ {
+ warnOnUndefinedDerivedState(ctor, partialState);
+ }
+ var memoizedState = partialState === null || partialState === undefined ? prevState : _extends({}, prevState, partialState);
+ workInProgress.memoizedState = memoizedState;
+ var updateQueue = workInProgress.updateQueue;
+
+ if (updateQueue !== null && workInProgress.expirationTime === NoWork) {
+ updateQueue.baseState = memoizedState;
+ }
+ }
+
+ var classComponentUpdater = {
+ isMounted: isMounted,
+ enqueueSetState: function enqueueSetState(inst, payload, callback) {
+ var fiber = get$1(inst);
+ var currentTime = requestCurrentTime();
+ var expirationTime = computeExpirationForFiber(currentTime, fiber);
+ var update = createUpdate(expirationTime);
+ update.payload = payload;
+
+ if (callback !== undefined && callback !== null) {
+ {
+ warnOnInvalidCallback(callback, "setState");
+ }
+ update.callback = callback;
+ }
+
+ flushPassiveEffects();
+ enqueueUpdate(fiber, update);
+ scheduleWork(fiber, expirationTime);
+ },
+ enqueueReplaceState: function enqueueReplaceState(inst, payload, callback) {
+ var fiber = get$1(inst);
+ var currentTime = requestCurrentTime();
+ 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;
+ }
+
+ flushPassiveEffects();
+ enqueueUpdate(fiber, update);
+ scheduleWork(fiber, expirationTime);
+ },
+ enqueueForceUpdate: function enqueueForceUpdate(inst, callback) {
+ var fiber = get$1(inst);
+ var currentTime = requestCurrentTime();
+ var expirationTime = computeExpirationForFiber(currentTime, fiber);
+ var update = createUpdate(expirationTime);
+ update.tag = ForceUpdate;
+
+ if (callback !== undefined && callback !== null) {
+ {
+ warnOnInvalidCallback(callback, "forceUpdate");
+ }
+ update.callback = callback;
+ }
+
+ flushPassiveEffects();
+ enqueueUpdate(fiber, update);
+ scheduleWork(fiber, expirationTime);
+ }
+ };
+
+ function checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext) {
+ var instance = workInProgress.stateNode;
+
+ if (typeof instance.shouldComponentUpdate === "function") {
+ startPhaseTimer(workInProgress, "shouldComponentUpdate");
+ var shouldUpdate = instance.shouldComponentUpdate(newProps, newState, nextContext);
+ stopPhaseTimer();
+ {
+ !(shouldUpdate !== undefined) ? warningWithoutStack$1(false, "%s.shouldComponentUpdate(): Returned undefined instead of a " + "boolean value. Make sure to return true or false.", getComponentName(ctor) || "Component") : void 0;
+ }
+ return shouldUpdate;
+ }
+
+ if (ctor.prototype && ctor.prototype.isPureReactComponent) {
+ return !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState);
+ }
+
+ return true;
+ }
+
+ function checkClassInstance(workInProgress, ctor, newProps) {
+ var instance = workInProgress.stateNode;
+ {
+ var name = getComponentName(ctor) || "Component";
+ var renderPresent = instance.render;
+
+ if (!renderPresent) {
+ if (ctor.prototype && typeof ctor.prototype.render === "function") {
+ warningWithoutStack$1(false, "%s(...): No `render` method found on the returned component " + "instance: did you accidentally return an object from the constructor?", name);
+ } else {
+ warningWithoutStack$1(false, "%s(...): No `render` method found on the returned component " + "instance: you may have forgotten to define `render`.", name);
+ }
+ }
+
+ var noGetInitialStateOnES6 = !instance.getInitialState || instance.getInitialState.isReactClassApproved || instance.state;
+ !noGetInitialStateOnES6 ? warningWithoutStack$1(false, "getInitialState was defined on %s, a plain JavaScript class. " + "This is only supported for classes created using React.createClass. " + "Did you mean to define a state property instead?", name) : void 0;
+ var noGetDefaultPropsOnES6 = !instance.getDefaultProps || instance.getDefaultProps.isReactClassApproved;
+ !noGetDefaultPropsOnES6 ? warningWithoutStack$1(false, "getDefaultProps was defined on %s, a plain JavaScript class. " + "This is only supported for classes created using React.createClass. " + "Use a static property to define defaultProps instead.", name) : void 0;
+ var noInstancePropTypes = !instance.propTypes;
+ !noInstancePropTypes ? warningWithoutStack$1(false, "propTypes was defined as an instance property on %s. Use a static " + "property to define propTypes instead.", name) : void 0;
+ var noInstanceContextType = !instance.contextType;
+ !noInstanceContextType ? warningWithoutStack$1(false, "contextType was defined as an instance property on %s. Use a static " + "property to define contextType instead.", name) : void 0;
+ var noInstanceContextTypes = !instance.contextTypes;
+ !noInstanceContextTypes ? warningWithoutStack$1(false, "contextTypes was defined as an instance property on %s. Use a static " + "property to define contextTypes instead.", name) : void 0;
+
+ if (ctor.contextType && ctor.contextTypes && !didWarnAboutContextTypeAndContextTypes.has(ctor)) {
+ didWarnAboutContextTypeAndContextTypes.add(ctor);
+ warningWithoutStack$1(false, "%s declares both contextTypes and contextType static properties. " + "The legacy contextTypes property will be ignored.", name);
+ }
+
+ var noComponentShouldUpdate = typeof instance.componentShouldUpdate !== "function";
+ !noComponentShouldUpdate ? warningWithoutStack$1(false, "%s has a method called " + "componentShouldUpdate(). Did you mean shouldComponentUpdate()? " + "The name is phrased as a question because the function is " + "expected to return a value.", name) : void 0;
+
+ if (ctor.prototype && ctor.prototype.isPureReactComponent && typeof instance.shouldComponentUpdate !== "undefined") {
+ warningWithoutStack$1(false, "%s has a method called shouldComponentUpdate(). " + "shouldComponentUpdate should not be used when extending React.PureComponent. " + "Please extend React.Component if shouldComponentUpdate is used.", getComponentName(ctor) || "A pure component");
+ }
+
+ var noComponentDidUnmount = typeof instance.componentDidUnmount !== "function";
+ !noComponentDidUnmount ? warningWithoutStack$1(false, "%s has a method called " + "componentDidUnmount(). But there is no such lifecycle method. " + "Did you mean componentWillUnmount()?", name) : void 0;
+ var noComponentDidReceiveProps = typeof instance.componentDidReceiveProps !== "function";
+ !noComponentDidReceiveProps ? warningWithoutStack$1(false, "%s has a method called " + "componentDidReceiveProps(). But there is no such lifecycle method. " + "If you meant to update the state in response to changing props, " + "use componentWillReceiveProps(). If you meant to fetch data or " + "run side-effects or mutations after React has updated the UI, use componentDidUpdate().", name) : void 0;
+ var noComponentWillRecieveProps = typeof instance.componentWillRecieveProps !== "function";
+ !noComponentWillRecieveProps ? warningWithoutStack$1(false, "%s has a method called " + "componentWillRecieveProps(). Did you mean componentWillReceiveProps()?", name) : void 0;
+ var noUnsafeComponentWillRecieveProps = typeof instance.UNSAFE_componentWillRecieveProps !== "function";
+ !noUnsafeComponentWillRecieveProps ? warningWithoutStack$1(false, "%s has a method called " + "UNSAFE_componentWillRecieveProps(). Did you mean UNSAFE_componentWillReceiveProps()?", name) : void 0;
+ var hasMutatedProps = instance.props !== newProps;
+ !(instance.props === undefined || !hasMutatedProps) ? warningWithoutStack$1(false, "%s(...): When calling super() in `%s`, make sure to pass " + "up the same props that your component's constructor was passed.", name, name) : void 0;
+ var noInstanceDefaultProps = !instance.defaultProps;
+ !noInstanceDefaultProps ? warningWithoutStack$1(false, "Setting defaultProps as an instance property on %s is not supported and will be ignored." + " Instead, define defaultProps as a static property on %s.", name, name) : void 0;
+
+ if (typeof instance.getSnapshotBeforeUpdate === "function" && typeof instance.componentDidUpdate !== "function" && !didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.has(ctor)) {
+ didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.add(ctor);
+ warningWithoutStack$1(false, "%s: getSnapshotBeforeUpdate() should be used with componentDidUpdate(). " + "This component defines getSnapshotBeforeUpdate() only.", getComponentName(ctor));
+ }
+
+ var noInstanceGetDerivedStateFromProps = typeof instance.getDerivedStateFromProps !== "function";
+ !noInstanceGetDerivedStateFromProps ? warningWithoutStack$1(false, "%s: getDerivedStateFromProps() is defined as an instance method " + "and will be ignored. Instead, declare it as a static method.", name) : void 0;
+ var noInstanceGetDerivedStateFromCatch = typeof instance.getDerivedStateFromError !== "function";
+ !noInstanceGetDerivedStateFromCatch ? warningWithoutStack$1(false, "%s: getDerivedStateFromError() is defined as an instance method " + "and will be ignored. Instead, declare it as a static method.", name) : void 0;
+ var noStaticGetSnapshotBeforeUpdate = typeof ctor.getSnapshotBeforeUpdate !== "function";
+ !noStaticGetSnapshotBeforeUpdate ? warningWithoutStack$1(false, "%s: getSnapshotBeforeUpdate() is defined as a static method " + "and will be ignored. Instead, declare it as an instance method.", name) : void 0;
+ var _state = instance.state;
+
+ if (_state && (typeof _state !== "object" || isArray$1(_state))) {
+ warningWithoutStack$1(false, "%s.state: must be set to an object or null", name);
+ }
+
+ if (typeof instance.getChildContext === "function") {
+ !(typeof ctor.childContextTypes === "object") ? warningWithoutStack$1(false, "%s.getChildContext(): childContextTypes must be defined in order to " + "use getChildContext().", name) : void 0;
+ }
+ }
+ }
+
+ function adoptClassInstance(workInProgress, instance) {
+ instance.updater = classComponentUpdater;
+ workInProgress.stateNode = instance;
+ set(instance, workInProgress);
+ {
+ instance._reactInternalInstance = fakeInternalInstance;
+ }
+ }
+
+ function constructClassInstance(workInProgress, ctor, props, renderExpirationTime) {
+ var isLegacyContextConsumer = false;
+ var unmaskedContext = emptyContextObject;
+ var context = null;
+ var contextType = ctor.contextType;
+
+ if (typeof contextType === "object" && contextType !== null) {
+ {
+ if (contextType.$$typeof !== REACT_CONTEXT_TYPE && !didWarnAboutInvalidateContextType.has(ctor)) {
+ didWarnAboutInvalidateContextType.add(ctor);
+ warningWithoutStack$1(false, "%s defines an invalid contextType. " + "contextType should point to the Context object returned by React.createContext(). " + "Did you accidentally pass the Context.Provider instead?", getComponentName(ctor) || "Component");
+ }
+ }
+ context = _readContext(contextType);
+ } else {
+ unmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
+ var contextTypes = ctor.contextTypes;
+ isLegacyContextConsumer = contextTypes !== null && contextTypes !== undefined;
+ context = isLegacyContextConsumer ? getMaskedContext(workInProgress, unmaskedContext) : emptyContextObject;
+ }
+
+ {
+ if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
+ new ctor(props, context);
+ }
+ }
+ var instance = new ctor(props, context);
+ var state = workInProgress.memoizedState = instance.state !== null && instance.state !== undefined ? instance.state : null;
+ adoptClassInstance(workInProgress, instance);
+ {
+ if (typeof ctor.getDerivedStateFromProps === "function" && state === null) {
+ var componentName = getComponentName(ctor) || "Component";
+
+ if (!didWarnAboutUninitializedState.has(componentName)) {
+ didWarnAboutUninitializedState.add(componentName);
+ warningWithoutStack$1(false, "`%s` uses `getDerivedStateFromProps` but its initial state is " + "%s. This is not recommended. Instead, define the initial state by " + "assigning an object to `this.state` in the constructor of `%s`. " + "This ensures that `getDerivedStateFromProps` arguments have a consistent shape.", componentName, instance.state === null ? "null" : "undefined", componentName);
+ }
+ }
+
+ if (typeof ctor.getDerivedStateFromProps === "function" || typeof instance.getSnapshotBeforeUpdate === "function") {
+ var foundWillMountName = null;
+ var foundWillReceivePropsName = null;
+ var foundWillUpdateName = null;
+
+ if (typeof instance.componentWillMount === "function" && instance.componentWillMount.__suppressDeprecationWarning !== true) {
+ foundWillMountName = "componentWillMount";
+ } else if (typeof instance.UNSAFE_componentWillMount === "function") {
+ foundWillMountName = "UNSAFE_componentWillMount";
+ }
+
+ if (typeof instance.componentWillReceiveProps === "function" && instance.componentWillReceiveProps.__suppressDeprecationWarning !== true) {
+ foundWillReceivePropsName = "componentWillReceiveProps";
+ } else if (typeof instance.UNSAFE_componentWillReceiveProps === "function") {
+ foundWillReceivePropsName = "UNSAFE_componentWillReceiveProps";
+ }
+
+ if (typeof instance.componentWillUpdate === "function" && instance.componentWillUpdate.__suppressDeprecationWarning !== true) {
+ foundWillUpdateName = "componentWillUpdate";
+ } else if (typeof instance.UNSAFE_componentWillUpdate === "function") {
+ foundWillUpdateName = "UNSAFE_componentWillUpdate";
+ }
+
+ if (foundWillMountName !== null || foundWillReceivePropsName !== null || foundWillUpdateName !== null) {
+ var _componentName = getComponentName(ctor) || "Component";
+
+ var newApiName = typeof ctor.getDerivedStateFromProps === "function" ? "getDerivedStateFromProps()" : "getSnapshotBeforeUpdate()";
+
+ if (!didWarnAboutLegacyLifecyclesAndDerivedState.has(_componentName)) {
+ didWarnAboutLegacyLifecyclesAndDerivedState.add(_componentName);
+ warningWithoutStack$1(false, "Unsafe legacy lifecycles will not be called for components using new component APIs.\n\n" + "%s uses %s but also contains the following legacy lifecycles:%s%s%s\n\n" + "The above lifecycles should be removed. Learn more about this warning here:\n" + "https://fb.me/react-async-component-lifecycle-hooks", _componentName, newApiName, foundWillMountName !== null ? "\n " + foundWillMountName : "", foundWillReceivePropsName !== null ? "\n " + foundWillReceivePropsName : "", foundWillUpdateName !== null ? "\n " + foundWillUpdateName : "");
+ }
+ }
+ }
+ }
+
+ if (isLegacyContextConsumer) {
+ cacheContext(workInProgress, unmaskedContext, context);
+ }
+
+ return instance;
+ }
+
+ function callComponentWillMount(workInProgress, instance) {
+ startPhaseTimer(workInProgress, "componentWillMount");
+ var oldState = instance.state;
+
+ if (typeof instance.componentWillMount === "function") {
+ instance.componentWillMount();
+ }
+
+ if (typeof instance.UNSAFE_componentWillMount === "function") {
+ instance.UNSAFE_componentWillMount();
+ }
+
+ stopPhaseTimer();
+
+ if (oldState !== instance.state) {
+ {
+ warningWithoutStack$1(false, "%s.componentWillMount(): Assigning directly to this.state is " + "deprecated (except inside a component's " + "constructor). Use setState instead.", getComponentName(workInProgress.type) || "Component");
+ }
+ classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
+ }
+ }
+
+ function callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext) {
+ var oldState = instance.state;
+ startPhaseTimer(workInProgress, "componentWillReceiveProps");
+
+ if (typeof instance.componentWillReceiveProps === "function") {
+ instance.componentWillReceiveProps(newProps, nextContext);
+ }
+
+ if (typeof instance.UNSAFE_componentWillReceiveProps === "function") {
+ instance.UNSAFE_componentWillReceiveProps(newProps, nextContext);
+ }
+
+ stopPhaseTimer();
+
+ if (instance.state !== oldState) {
+ {
+ var componentName = getComponentName(workInProgress.type) || "Component";
+
+ if (!didWarnAboutStateAssignmentForComponent.has(componentName)) {
+ didWarnAboutStateAssignmentForComponent.add(componentName);
+ warningWithoutStack$1(false, "%s.componentWillReceiveProps(): Assigning directly to " + "this.state is deprecated (except inside a component's " + "constructor). Use setState instead.", componentName);
+ }
+ }
+ classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
+ }
+ }
+
+ function mountClassInstance(workInProgress, ctor, newProps, renderExpirationTime) {
+ {
+ checkClassInstance(workInProgress, ctor, newProps);
+ }
+ var instance = workInProgress.stateNode;
+ instance.props = newProps;
+ instance.state = workInProgress.memoizedState;
+ instance.refs = emptyRefsObject;
+ var contextType = ctor.contextType;
+
+ if (typeof contextType === "object" && contextType !== null) {
+ instance.context = _readContext(contextType);
+ } else {
+ var unmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
+ instance.context = getMaskedContext(workInProgress, unmaskedContext);
+ }
+
+ {
+ if (instance.state === newProps) {
+ var componentName = getComponentName(ctor) || "Component";
+
+ if (!didWarnAboutDirectlyAssigningPropsToState.has(componentName)) {
+ didWarnAboutDirectlyAssigningPropsToState.add(componentName);
+ warningWithoutStack$1(false, "%s: It is not recommended to assign props directly to state " + "because updates to props won't be reflected in state. " + "In most cases, it is better to use props directly.", componentName);
+ }
+ }
+
+ if (workInProgress.mode & StrictMode) {
+ ReactStrictModeWarnings.recordUnsafeLifecycleWarnings(workInProgress, instance);
+ ReactStrictModeWarnings.recordLegacyContextWarning(workInProgress, instance);
+ }
+
+ if (warnAboutDeprecatedLifecycles) {
+ ReactStrictModeWarnings.recordDeprecationWarnings(workInProgress, instance);
+ }
+ }
+ var updateQueue = workInProgress.updateQueue;
+
+ if (updateQueue !== null) {
+ processUpdateQueue(workInProgress, updateQueue, newProps, instance, renderExpirationTime);
+ instance.state = workInProgress.memoizedState;
+ }
+
+ var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+
+ if (typeof getDerivedStateFromProps === "function") {
+ applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, newProps);
+ instance.state = workInProgress.memoizedState;
+ }
+
+ if (typeof ctor.getDerivedStateFromProps !== "function" && typeof instance.getSnapshotBeforeUpdate !== "function" && (typeof instance.UNSAFE_componentWillMount === "function" || typeof instance.componentWillMount === "function")) {
+ callComponentWillMount(workInProgress, instance);
+ updateQueue = workInProgress.updateQueue;
+
+ if (updateQueue !== null) {
+ processUpdateQueue(workInProgress, updateQueue, newProps, instance, renderExpirationTime);
+ instance.state = workInProgress.memoizedState;
+ }
+ }
+
+ if (typeof instance.componentDidMount === "function") {
+ workInProgress.effectTag |= Update;
+ }
+ }
+
+ function resumeMountClassInstance(workInProgress, ctor, newProps, renderExpirationTime) {
+ var instance = workInProgress.stateNode;
+ var oldProps = workInProgress.memoizedProps;
+ instance.props = oldProps;
+ var oldContext = instance.context;
+ var contextType = ctor.contextType;
+ var nextContext = void 0;
+
+ if (typeof contextType === "object" && contextType !== null) {
+ nextContext = _readContext(contextType);
+ } else {
+ var nextLegacyUnmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
+ nextContext = getMaskedContext(workInProgress, nextLegacyUnmaskedContext);
+ }
+
+ var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+ var hasNewLifecycles = typeof getDerivedStateFromProps === "function" || typeof instance.getSnapshotBeforeUpdate === "function";
+
+ if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillReceiveProps === "function" || typeof instance.componentWillReceiveProps === "function")) {
+ if (oldProps !== newProps || oldContext !== nextContext) {
+ callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext);
+ }
+ }
+
+ resetHasForceUpdateBeforeProcessing();
+ var oldState = workInProgress.memoizedState;
+ var newState = instance.state = oldState;
+ var updateQueue = workInProgress.updateQueue;
+
+ if (updateQueue !== null) {
+ processUpdateQueue(workInProgress, updateQueue, newProps, instance, renderExpirationTime);
+ newState = workInProgress.memoizedState;
+ }
+
+ if (oldProps === newProps && oldState === newState && !hasContextChanged() && !checkHasForceUpdateAfterProcessing()) {
+ if (typeof instance.componentDidMount === "function") {
+ workInProgress.effectTag |= Update;
+ }
+
+ return false;
+ }
+
+ if (typeof getDerivedStateFromProps === "function") {
+ applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, newProps);
+ newState = workInProgress.memoizedState;
+ }
+
+ var shouldUpdate = checkHasForceUpdateAfterProcessing() || checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext);
+
+ if (shouldUpdate) {
+ if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillMount === "function" || typeof instance.componentWillMount === "function")) {
+ startPhaseTimer(workInProgress, "componentWillMount");
+
+ if (typeof instance.componentWillMount === "function") {
+ instance.componentWillMount();
+ }
+
+ if (typeof instance.UNSAFE_componentWillMount === "function") {
+ instance.UNSAFE_componentWillMount();
+ }
+
+ stopPhaseTimer();
+ }
+
+ if (typeof instance.componentDidMount === "function") {
+ workInProgress.effectTag |= Update;
+ }
+ } else {
+ if (typeof instance.componentDidMount === "function") {
+ workInProgress.effectTag |= Update;
+ }
+
+ workInProgress.memoizedProps = newProps;
+ workInProgress.memoizedState = newState;
+ }
+
+ instance.props = newProps;
+ instance.state = newState;
+ instance.context = nextContext;
+ return shouldUpdate;
+ }
+
+ function updateClassInstance(current, workInProgress, ctor, newProps, renderExpirationTime) {
+ var instance = workInProgress.stateNode;
+ var oldProps = workInProgress.memoizedProps;
+ instance.props = workInProgress.type === workInProgress.elementType ? oldProps : resolveDefaultProps(workInProgress.type, oldProps);
+ var oldContext = instance.context;
+ var contextType = ctor.contextType;
+ var nextContext = void 0;
+
+ if (typeof contextType === "object" && contextType !== null) {
+ nextContext = _readContext(contextType);
+ } else {
+ var nextUnmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
+ nextContext = getMaskedContext(workInProgress, nextUnmaskedContext);
+ }
+
+ var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+ var hasNewLifecycles = typeof getDerivedStateFromProps === "function" || typeof instance.getSnapshotBeforeUpdate === "function";
+
+ if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillReceiveProps === "function" || typeof instance.componentWillReceiveProps === "function")) {
+ if (oldProps !== newProps || oldContext !== nextContext) {
+ callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext);
+ }
+ }
+
+ resetHasForceUpdateBeforeProcessing();
+ var oldState = workInProgress.memoizedState;
+ var newState = instance.state = oldState;
+ var updateQueue = workInProgress.updateQueue;
+
+ if (updateQueue !== null) {
+ processUpdateQueue(workInProgress, updateQueue, newProps, instance, renderExpirationTime);
+ newState = workInProgress.memoizedState;
+ }
+
+ if (oldProps === newProps && oldState === newState && !hasContextChanged() && !checkHasForceUpdateAfterProcessing()) {
+ if (typeof instance.componentDidUpdate === "function") {
+ if (oldProps !== current.memoizedProps || oldState !== current.memoizedState) {
+ workInProgress.effectTag |= Update;
+ }
+ }
+
+ if (typeof instance.getSnapshotBeforeUpdate === "function") {
+ if (oldProps !== current.memoizedProps || oldState !== current.memoizedState) {
+ workInProgress.effectTag |= Snapshot;
+ }
+ }
+
+ return false;
+ }
+
+ if (typeof getDerivedStateFromProps === "function") {
+ applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, newProps);
+ newState = workInProgress.memoizedState;
+ }
+
+ var shouldUpdate = checkHasForceUpdateAfterProcessing() || checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext);
+
+ if (shouldUpdate) {
+ if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillUpdate === "function" || typeof instance.componentWillUpdate === "function")) {
+ startPhaseTimer(workInProgress, "componentWillUpdate");
+
+ if (typeof instance.componentWillUpdate === "function") {
+ instance.componentWillUpdate(newProps, newState, nextContext);
+ }
+
+ if (typeof instance.UNSAFE_componentWillUpdate === "function") {
+ instance.UNSAFE_componentWillUpdate(newProps, newState, nextContext);
+ }
+
+ stopPhaseTimer();
+ }
+
+ if (typeof instance.componentDidUpdate === "function") {
+ workInProgress.effectTag |= Update;
+ }
+
+ if (typeof instance.getSnapshotBeforeUpdate === "function") {
+ workInProgress.effectTag |= Snapshot;
+ }
+ } else {
+ if (typeof instance.componentDidUpdate === "function") {
+ if (oldProps !== current.memoizedProps || oldState !== current.memoizedState) {
+ workInProgress.effectTag |= Update;
+ }
+ }
+
+ if (typeof instance.getSnapshotBeforeUpdate === "function") {
+ if (oldProps !== current.memoizedProps || oldState !== current.memoizedState) {
+ workInProgress.effectTag |= Snapshot;
+ }
+ }
+
+ workInProgress.memoizedProps = newProps;
+ workInProgress.memoizedState = newState;
+ }
+
+ instance.props = newProps;
+ instance.state = newState;
+ instance.context = nextContext;
+ return shouldUpdate;
+ }
+
+ var didWarnAboutMaps = void 0;
+ var didWarnAboutGenerators = void 0;
+ var didWarnAboutStringRefInStrictMode = void 0;
+ var ownerHasKeyUseWarning = void 0;
+ var ownerHasFunctionTypeWarning = void 0;
+
+ var warnForMissingKey = function warnForMissingKey(child) {};
+
+ {
+ didWarnAboutMaps = false;
+ didWarnAboutGenerators = 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 a list should have a unique " + '"key" prop. See https://fb.me/react-warning-keys for ' + "more information." + getCurrentFiberStackInDev();
+
+ if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {
+ return;
+ }
+
+ ownerHasKeyUseWarning[currentComponentErrorInfo] = true;
+ warning$1(false, "Each child in a list should have a unique " + '"key" prop. See https://fb.me/react-warning-keys for ' + "more information.");
+ };
+ }
+ var isArray = Array.isArray;
+
+ function coerceRef(returnFiber, current$$1, element) {
+ var mixedRef = element.ref;
+
+ if (mixedRef !== null && typeof mixedRef !== "function" && typeof mixedRef !== "object") {
+ {
+ if (returnFiber.mode & StrictMode) {
+ var componentName = getComponentName(returnFiber.type) || "Component";
+
+ if (!didWarnAboutStringRefInStrictMode[componentName]) {
+ warningWithoutStack$1(false, 'A string ref, "%s", has been found within a strict mode tree. ' + "String refs are a source of potential bugs and should be avoided. " + "We recommend using createRef() instead." + "\n%s" + "\n\nLearn more about using refs safely here:" + "\nhttps://fb.me/react-strict-mode-string-ref", mixedRef, getStackByFiberInDevAndProd(returnFiber));
+ didWarnAboutStringRefInStrictMode[componentName] = true;
+ }
+ }
+ }
+
+ if (element._owner) {
+ var owner = element._owner;
+ var inst = void 0;
+
+ if (owner) {
+ var ownerFiber = owner;
+ invariant(ownerFiber.tag === ClassComponent, "Function components cannot have refs. " + "Did you mean to use React.forwardRef()?");
+ 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$$1 !== null && current$$1.ref !== null && typeof current$$1.ref === "function" && current$$1.ref._stringRef === stringRef) {
+ return current$$1.ref;
+ }
+
+ var ref = function ref(value) {
+ var refs = inst.refs;
+
+ if (refs === emptyRefsObject) {
+ refs = inst.refs = {};
+ }
+
+ if (value === null) {
+ delete refs[stringRef];
+ } else {
+ refs[stringRef] = value;
+ }
+ };
+
+ ref._stringRef = stringRef;
+ return ref;
+ } else {
+ invariant(typeof mixedRef === "string", "Expected ref to be a function, a string, an object returned by React.createRef(), or null.");
+ 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 function 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." + getCurrentFiberStackInDev();
+ }
+ 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 from render. " + "Or maybe you meant to call this function rather than return it." + getCurrentFiberStackInDev();
+
+ if (ownerHasFunctionTypeWarning[currentComponentErrorInfo]) {
+ return;
+ }
+
+ ownerHasFunctionTypeWarning[currentComponentErrorInfo] = true;
+ warning$1(false, "Functions are not valid as a React child. This may happen if " + "you return a Component instead of from render. " + "Or maybe you meant to call this function rather than return it.");
+ }
+
+ function ChildReconciler(shouldTrackSideEffects) {
+ function deleteChild(returnFiber, childToDelete) {
+ if (!shouldTrackSideEffects) {
+ return;
+ }
+
+ var last = returnFiber.lastEffect;
+
+ if (last !== null) {
+ last.nextEffect = childToDelete;
+ returnFiber.lastEffect = childToDelete;
+ } else {
+ returnFiber.firstEffect = returnFiber.lastEffect = childToDelete;
+ }
+
+ childToDelete.nextEffect = null;
+ childToDelete.effectTag = Deletion;
+ }
+
+ function deleteRemainingChildren(returnFiber, currentFirstChild) {
+ if (!shouldTrackSideEffects) {
+ return null;
+ }
+
+ var childToDelete = currentFirstChild;
+
+ while (childToDelete !== null) {
+ deleteChild(returnFiber, childToDelete);
+ childToDelete = childToDelete.sibling;
+ }
+
+ return null;
+ }
+
+ function mapRemainingChildren(returnFiber, currentFirstChild) {
+ var existingChildren = new Map();
+ var existingChild = currentFirstChild;
+
+ while (existingChild !== null) {
+ if (existingChild.key !== null) {
+ existingChildren.set(existingChild.key, existingChild);
+ } else {
+ existingChildren.set(existingChild.index, existingChild);
+ }
+
+ existingChild = existingChild.sibling;
+ }
+
+ return existingChildren;
+ }
+
+ function useFiber(fiber, pendingProps, expirationTime) {
+ var clone = createWorkInProgress(fiber, pendingProps, expirationTime);
+ clone.index = 0;
+ clone.sibling = null;
+ return clone;
+ }
+
+ function placeChild(newFiber, lastPlacedIndex, newIndex) {
+ newFiber.index = newIndex;
+
+ if (!shouldTrackSideEffects) {
+ return lastPlacedIndex;
+ }
+
+ var current$$1 = newFiber.alternate;
+
+ if (current$$1 !== null) {
+ var oldIndex = current$$1.index;
+
+ if (oldIndex < lastPlacedIndex) {
+ newFiber.effectTag = Placement;
+ return lastPlacedIndex;
+ } else {
+ return oldIndex;
+ }
+ } else {
+ newFiber.effectTag = Placement;
+ return lastPlacedIndex;
+ }
+ }
+
+ function placeSingleChild(newFiber) {
+ if (shouldTrackSideEffects && newFiber.alternate === null) {
+ newFiber.effectTag = Placement;
+ }
+
+ return newFiber;
+ }
+
+ function updateTextNode(returnFiber, current$$1, textContent, expirationTime) {
+ if (current$$1 === null || current$$1.tag !== HostText) {
+ var created = createFiberFromText(textContent, returnFiber.mode, expirationTime);
+ created.return = returnFiber;
+ return created;
+ } else {
+ var existing = useFiber(current$$1, textContent, expirationTime);
+ existing.return = returnFiber;
+ return existing;
+ }
+ }
+
+ function updateElement(returnFiber, current$$1, element, expirationTime) {
+ if (current$$1 !== null && current$$1.elementType === element.type) {
+ var existing = useFiber(current$$1, element.props, expirationTime);
+ existing.ref = coerceRef(returnFiber, current$$1, element);
+ existing.return = returnFiber;
+ {
+ existing._debugSource = element._source;
+ existing._debugOwner = element._owner;
+ }
+ return existing;
+ } else {
+ var created = createFiberFromElement(element, returnFiber.mode, expirationTime);
+ created.ref = coerceRef(returnFiber, current$$1, element);
+ created.return = returnFiber;
+ return created;
+ }
+ }
+
+ function updatePortal(returnFiber, current$$1, portal, expirationTime) {
+ if (current$$1 === null || current$$1.tag !== HostPortal || current$$1.stateNode.containerInfo !== portal.containerInfo || current$$1.stateNode.implementation !== portal.implementation) {
+ var created = createFiberFromPortal(portal, returnFiber.mode, expirationTime);
+ created.return = returnFiber;
+ return created;
+ } else {
+ var existing = useFiber(current$$1, portal.children || [], expirationTime);
+ existing.return = returnFiber;
+ return existing;
+ }
+ }
+
+ function updateFragment(returnFiber, current$$1, fragment, expirationTime, key) {
+ if (current$$1 === null || current$$1.tag !== Fragment) {
+ var created = createFiberFromFragment(fragment, returnFiber.mode, expirationTime, key);
+ created.return = returnFiber;
+ return created;
+ } else {
+ var existing = useFiber(current$$1, fragment, expirationTime);
+ existing.return = returnFiber;
+ return existing;
+ }
+ }
+
+ function createChild(returnFiber, newChild, expirationTime) {
+ if (typeof newChild === "string" || typeof newChild === "number") {
+ var created = createFiberFromText("" + newChild, returnFiber.mode, expirationTime);
+ created.return = returnFiber;
+ return created;
+ }
+
+ if (typeof newChild === "object" && newChild !== null) {
+ switch (newChild.$$typeof) {
+ case REACT_ELEMENT_TYPE:
+ {
+ var _created = createFiberFromElement(newChild, returnFiber.mode, expirationTime);
+
+ _created.ref = coerceRef(returnFiber, null, newChild);
+ _created.return = returnFiber;
+ return _created;
+ }
+
+ case REACT_PORTAL_TYPE:
+ {
+ var _created2 = createFiberFromPortal(newChild, returnFiber.mode, expirationTime);
+
+ _created2.return = returnFiber;
+ return _created2;
+ }
+ }
+
+ if (isArray(newChild) || getIteratorFn(newChild)) {
+ var _created3 = createFiberFromFragment(newChild, returnFiber.mode, expirationTime, null);
+
+ _created3.return = returnFiber;
+ return _created3;
+ }
+
+ throwOnInvalidObjectType(returnFiber, newChild);
+ }
+
+ {
+ if (typeof newChild === "function") {
+ warnOnFunctionType();
+ }
+ }
+ return null;
+ }
+
+ function updateSlot(returnFiber, oldFiber, newChild, expirationTime) {
+ var key = oldFiber !== null ? oldFiber.key : null;
+
+ if (typeof newChild === "string" || typeof newChild === "number") {
+ if (key !== null) {
+ return null;
+ }
+
+ return updateTextNode(returnFiber, oldFiber, "" + newChild, expirationTime);
+ }
+
+ if (typeof newChild === "object" && newChild !== null) {
+ switch (newChild.$$typeof) {
+ case REACT_ELEMENT_TYPE:
+ {
+ if (newChild.key === key) {
+ if (newChild.type === REACT_FRAGMENT_TYPE) {
+ return updateFragment(returnFiber, oldFiber, newChild.props.children, expirationTime, key);
+ }
+
+ return updateElement(returnFiber, oldFiber, newChild, expirationTime);
+ } else {
+ return null;
+ }
+ }
+
+ case REACT_PORTAL_TYPE:
+ {
+ if (newChild.key === key) {
+ return updatePortal(returnFiber, oldFiber, newChild, expirationTime);
+ } else {
+ return null;
+ }
+ }
+ }
+
+ if (isArray(newChild) || getIteratorFn(newChild)) {
+ if (key !== null) {
+ return null;
+ }
+
+ return updateFragment(returnFiber, oldFiber, newChild, expirationTime, null);
+ }
+
+ throwOnInvalidObjectType(returnFiber, newChild);
+ }
+
+ {
+ if (typeof newChild === "function") {
+ warnOnFunctionType();
+ }
+ }
+ return null;
+ }
+
+ function updateFromMap(existingChildren, returnFiber, newIdx, newChild, expirationTime) {
+ if (typeof newChild === "string" || typeof newChild === "number") {
+ var matchedFiber = existingChildren.get(newIdx) || null;
+ return updateTextNode(returnFiber, matchedFiber, "" + newChild, expirationTime);
+ }
+
+ if (typeof newChild === "object" && newChild !== null) {
+ switch (newChild.$$typeof) {
+ case REACT_ELEMENT_TYPE:
+ {
+ var _matchedFiber = existingChildren.get(newChild.key === null ? newIdx : newChild.key) || null;
+
+ if (newChild.type === REACT_FRAGMENT_TYPE) {
+ return updateFragment(returnFiber, _matchedFiber, newChild.props.children, expirationTime, newChild.key);
+ }
+
+ return updateElement(returnFiber, _matchedFiber, newChild, expirationTime);
+ }
+
+ case REACT_PORTAL_TYPE:
+ {
+ var _matchedFiber2 = existingChildren.get(newChild.key === null ? newIdx : newChild.key) || null;
+
+ return updatePortal(returnFiber, _matchedFiber2, newChild, expirationTime);
+ }
+ }
+
+ if (isArray(newChild) || getIteratorFn(newChild)) {
+ var _matchedFiber3 = existingChildren.get(newIdx) || null;
+
+ return updateFragment(returnFiber, _matchedFiber3, newChild, expirationTime, null);
+ }
+
+ throwOnInvalidObjectType(returnFiber, newChild);
+ }
+
+ {
+ if (typeof newChild === "function") {
+ warnOnFunctionType();
+ }
+ }
+ return null;
+ }
+
+ function warnOnInvalidKey(child, knownKeys) {
+ {
+ if (typeof child !== "object" || child === null) {
+ return knownKeys;
+ }
+
+ switch (child.$$typeof) {
+ case REACT_ELEMENT_TYPE:
+ case REACT_PORTAL_TYPE:
+ warnForMissingKey(child);
+ var key = child.key;
+
+ if (typeof key !== "string") {
+ break;
+ }
+
+ if (knownKeys === null) {
+ knownKeys = new Set();
+ knownKeys.add(key);
+ break;
+ }
+
+ if (!knownKeys.has(key)) {
+ knownKeys.add(key);
+ break;
+ }
+
+ warning$1(false, "Encountered two children with the same key, `%s`. " + "Keys should be unique so that components maintain their identity " + "across updates. Non-unique keys may cause children to be " + "duplicated and/or omitted — the behavior is unsupported and " + "could change in a future version.", key);
+ break;
+
+ default:
+ break;
+ }
+ }
+ return knownKeys;
+ }
+
+ function reconcileChildrenArray(returnFiber, currentFirstChild, newChildren, expirationTime) {
+ {
+ var knownKeys = null;
+
+ for (var i = 0; i < newChildren.length; i++) {
+ var child = newChildren[i];
+ knownKeys = warnOnInvalidKey(child, knownKeys);
+ }
+ }
+ var resultingFirstChild = null;
+ var previousNewFiber = null;
+ var oldFiber = currentFirstChild;
+ var lastPlacedIndex = 0;
+ var newIdx = 0;
+ var nextOldFiber = null;
+
+ for (; oldFiber !== null && newIdx < newChildren.length; newIdx++) {
+ if (oldFiber.index > newIdx) {
+ nextOldFiber = oldFiber;
+ oldFiber = null;
+ } else {
+ nextOldFiber = oldFiber.sibling;
+ }
+
+ var newFiber = updateSlot(returnFiber, oldFiber, newChildren[newIdx], expirationTime);
+
+ if (newFiber === null) {
+ if (oldFiber === null) {
+ oldFiber = nextOldFiber;
+ }
+
+ break;
+ }
+
+ if (shouldTrackSideEffects) {
+ if (oldFiber && newFiber.alternate === null) {
+ deleteChild(returnFiber, oldFiber);
+ }
+ }
+
+ lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
+
+ if (previousNewFiber === null) {
+ resultingFirstChild = newFiber;
+ } else {
+ previousNewFiber.sibling = newFiber;
+ }
+
+ previousNewFiber = newFiber;
+ oldFiber = nextOldFiber;
+ }
+
+ if (newIdx === newChildren.length) {
+ deleteRemainingChildren(returnFiber, oldFiber);
+ return resultingFirstChild;
+ }
+
+ if (oldFiber === null) {
+ for (; newIdx < newChildren.length; newIdx++) {
+ var _newFiber = createChild(returnFiber, newChildren[newIdx], expirationTime);
+
+ if (!_newFiber) {
+ 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 (typeof Symbol === "function" && newChildrenIterable[typeof Symbol === "function" ? Symbol.toStringTag : "@@toStringTag"] === "Generator") {
+ !didWarnAboutGenerators ? warning$1(false, "Using Generators as children is unsupported and will likely yield " + "unexpected results because enumerating a generator mutates it. " + "You may convert it to an array with `Array.from()` or the " + "`[...spread]` operator before rendering. Keep in mind " + "you might need to polyfill these features for older browsers.") : void 0;
+ didWarnAboutGenerators = true;
+ }
+
+ if (newChildrenIterable.entries === iteratorFn) {
+ !didWarnAboutMaps ? warning$1(false, "Using Maps as children is unsupported and will likely yield " + "unexpected results. Convert it to a sequence/iterable of keyed " + "ReactElements instead.") : void 0;
+ didWarnAboutMaps = true;
+ }
+
+ var _newChildren = iteratorFn.call(newChildrenIterable);
+
+ if (_newChildren) {
+ var knownKeys = null;
+
+ var _step = _newChildren.next();
+
+ for (; !_step.done; _step = _newChildren.next()) {
+ var child = _step.value;
+ knownKeys = warnOnInvalidKey(child, knownKeys);
+ }
+ }
+ }
+ var newChildren = iteratorFn.call(newChildrenIterable);
+ 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.elementType === 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(newChild)) {
+ return reconcileChildrenArray(returnFiber, currentFirstChild, newChild, expirationTime);
+ }
+
+ if (getIteratorFn(newChild)) {
+ return reconcileChildrenIterator(returnFiber, currentFirstChild, newChild, expirationTime);
+ }
+
+ if (isObject) {
+ throwOnInvalidObjectType(returnFiber, newChild);
+ }
+
+ {
+ if (typeof newChild === "function") {
+ warnOnFunctionType();
+ }
+ }
+
+ if (typeof newChild === "undefined" && !isUnkeyedTopLevelFragment) {
+ switch (returnFiber.tag) {
+ case ClassComponent:
+ {
+ {
+ var instance = returnFiber.stateNode;
+
+ if (instance.render._isMockFunction) {
+ break;
+ }
+ }
+ }
+
+ case FunctionComponent:
+ {
+ var Component = returnFiber.type;
+ 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$$1, workInProgress) {
+ invariant(current$$1 === null || workInProgress.child === current$$1.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 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 NoEffect$1 = 0;
+ var UnmountSnapshot = 2;
+ var UnmountMutation = 4;
+ var MountMutation = 8;
+ var UnmountLayout = 16;
+ var MountLayout = 32;
+ var MountPassive = 64;
+ var UnmountPassive = 128;
+ var ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher;
+ var didWarnAboutMismatchedHooksForComponent = void 0;
+ {
+ didWarnAboutMismatchedHooksForComponent = new Set();
+ }
+ var renderExpirationTime = NoWork;
+ var currentlyRenderingFiber$1 = null;
+ var firstCurrentHook = null;
+ var currentHook = null;
+ var nextCurrentHook = null;
+ var firstWorkInProgressHook = null;
+ var workInProgressHook = null;
+ var nextWorkInProgressHook = null;
+ var remainingExpirationTime = NoWork;
+ var componentUpdateQueue = null;
+ var sideEffectTag = 0;
+ var didScheduleRenderPhaseUpdate = false;
+ var renderPhaseUpdates = null;
+ var numberOfReRenders = 0;
+ var RE_RENDER_LIMIT = 25;
+ var currentHookNameInDev = null;
+
+ function warnOnHookMismatchInDev() {
+ {
+ var componentName = getComponentName(currentlyRenderingFiber$1.type);
+
+ if (!didWarnAboutMismatchedHooksForComponent.has(componentName)) {
+ didWarnAboutMismatchedHooksForComponent.add(componentName);
+ var secondColumnStart = 22;
+ var table = "";
+ var prevHook = firstCurrentHook;
+ var nextHook = firstWorkInProgressHook;
+ var n = 1;
+
+ while (prevHook !== null && nextHook !== null) {
+ var oldHookName = prevHook._debugType;
+ var newHookName = nextHook._debugType;
+ var row = n + ". " + oldHookName;
+
+ while (row.length < secondColumnStart) {
+ row += " ";
+ }
+
+ row += newHookName + "\n";
+ table += row;
+ prevHook = prevHook.next;
+ nextHook = nextHook.next;
+ n++;
+ }
+
+ warning$1(false, "React has detected a change in the order of Hooks called by %s. " + "This will lead to bugs and errors if not fixed. " + "For more information, read the Rules of Hooks: https://fb.me/rules-of-hooks\n\n" + " Previous render Next render\n" + " -------------------------------\n" + "%s" + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", componentName, table);
+ }
+ }
+ }
+
+ function throwInvalidHookError() {
+ invariant(false, "Hooks can only be called inside the body of a function component. " + "(https://fb.me/react-invalid-hook-call)");
+ }
+
+ function areHookInputsEqual(nextDeps, prevDeps) {
+ if (prevDeps === null) {
+ {
+ warning$1(false, "%s received a final argument during this render, but not during " + "the previous render. Even though the final argument is optional, " + "its type cannot change between renders.", currentHookNameInDev);
+ }
+ return false;
+ }
+
+ {
+ if (nextDeps.length !== prevDeps.length) {
+ warning$1(false, "The final argument passed to %s changed size between renders. The " + "order and size of this array must remain constant.\n\n" + "Previous: %s\n" + "Incoming: %s", currentHookNameInDev, "[" + nextDeps.join(", ") + "]", "[" + prevDeps.join(", ") + "]");
+ }
+ }
+
+ for (var i = 0; i < prevDeps.length && i < nextDeps.length; i++) {
+ if (is(nextDeps[i], prevDeps[i])) {
+ continue;
+ }
+
+ return false;
+ }
+
+ return true;
+ }
+
+ function renderWithHooks(current, workInProgress, Component, props, refOrContext, nextRenderExpirationTime) {
+ renderExpirationTime = nextRenderExpirationTime;
+ currentlyRenderingFiber$1 = workInProgress;
+ firstCurrentHook = nextCurrentHook = current !== null ? current.memoizedState : null;
+ {
+ ReactCurrentDispatcher$1.current = nextCurrentHook === null ? HooksDispatcherOnMountInDEV : HooksDispatcherOnUpdateInDEV;
+ }
+ var children = Component(props, refOrContext);
+
+ if (didScheduleRenderPhaseUpdate) {
+ do {
+ didScheduleRenderPhaseUpdate = false;
+ numberOfReRenders += 1;
+ firstCurrentHook = nextCurrentHook = current !== null ? current.memoizedState : null;
+ nextWorkInProgressHook = firstWorkInProgressHook;
+ currentHook = null;
+ workInProgressHook = null;
+ componentUpdateQueue = null;
+ ReactCurrentDispatcher$1.current = HooksDispatcherOnUpdateInDEV;
+ children = Component(props, refOrContext);
+ } while (didScheduleRenderPhaseUpdate);
+
+ renderPhaseUpdates = null;
+ numberOfReRenders = 0;
+ }
+
+ {
+ currentHookNameInDev = null;
+ }
+ ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
+ var renderedWork = currentlyRenderingFiber$1;
+ renderedWork.memoizedState = firstWorkInProgressHook;
+ renderedWork.expirationTime = remainingExpirationTime;
+ renderedWork.updateQueue = componentUpdateQueue;
+ renderedWork.effectTag |= sideEffectTag;
+ var didRenderTooFewHooks = currentHook !== null && currentHook.next !== null;
+ renderExpirationTime = NoWork;
+ currentlyRenderingFiber$1 = null;
+ firstCurrentHook = null;
+ currentHook = null;
+ nextCurrentHook = null;
+ firstWorkInProgressHook = null;
+ workInProgressHook = null;
+ nextWorkInProgressHook = null;
+ remainingExpirationTime = NoWork;
+ componentUpdateQueue = null;
+ sideEffectTag = 0;
+ invariant(!didRenderTooFewHooks, "Rendered fewer hooks than expected. This may be caused by an accidental " + "early return statement.");
+ return children;
+ }
+
+ function bailoutHooks(current, workInProgress, expirationTime) {
+ workInProgress.updateQueue = current.updateQueue;
+ workInProgress.effectTag &= ~(Passive | Update);
+
+ if (current.expirationTime <= expirationTime) {
+ current.expirationTime = NoWork;
+ }
+ }
+
+ function resetHooks() {
+ ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
+ renderExpirationTime = NoWork;
+ currentlyRenderingFiber$1 = null;
+ firstCurrentHook = null;
+ currentHook = null;
+ nextCurrentHook = null;
+ firstWorkInProgressHook = null;
+ workInProgressHook = null;
+ nextWorkInProgressHook = null;
+ remainingExpirationTime = NoWork;
+ componentUpdateQueue = null;
+ sideEffectTag = 0;
+ {
+ currentHookNameInDev = null;
+ }
+ didScheduleRenderPhaseUpdate = false;
+ renderPhaseUpdates = null;
+ numberOfReRenders = 0;
+ }
+
+ function mountWorkInProgressHook() {
+ var hook = {
+ memoizedState: null,
+ baseState: null,
+ queue: null,
+ baseUpdate: null,
+ next: null
+ };
+ {
+ hook._debugType = currentHookNameInDev;
+ }
+
+ if (workInProgressHook === null) {
+ firstWorkInProgressHook = workInProgressHook = hook;
+ } else {
+ workInProgressHook = workInProgressHook.next = hook;
+ }
+
+ return workInProgressHook;
+ }
+
+ function updateWorkInProgressHook() {
+ if (nextWorkInProgressHook !== null) {
+ workInProgressHook = nextWorkInProgressHook;
+ nextWorkInProgressHook = workInProgressHook.next;
+ currentHook = nextCurrentHook;
+ nextCurrentHook = currentHook !== null ? currentHook.next : null;
+ } else {
+ invariant(nextCurrentHook !== null, "Rendered more hooks than during the previous render.");
+ currentHook = nextCurrentHook;
+ var newHook = {
+ memoizedState: currentHook.memoizedState,
+ baseState: currentHook.baseState,
+ queue: currentHook.queue,
+ baseUpdate: currentHook.baseUpdate,
+ next: null
+ };
+
+ if (workInProgressHook === null) {
+ workInProgressHook = firstWorkInProgressHook = newHook;
+ } else {
+ workInProgressHook = workInProgressHook.next = newHook;
+ }
+
+ nextCurrentHook = currentHook.next;
+ {
+ newHook._debugType = currentHookNameInDev;
+
+ if (currentHookNameInDev !== currentHook._debugType) {
+ warnOnHookMismatchInDev();
+ }
+ }
+ }
+
+ return workInProgressHook;
+ }
+
+ function createFunctionComponentUpdateQueue() {
+ return {
+ lastEffect: null
+ };
+ }
+
+ function basicStateReducer(state, action) {
+ return typeof action === "function" ? action(state) : action;
+ }
+
+ function mountContext(context, observedBits) {
+ {
+ mountWorkInProgressHook();
+ }
+ return _readContext(context, observedBits);
+ }
+
+ function updateContext(context, observedBits) {
+ {
+ updateWorkInProgressHook();
+ }
+ return _readContext(context, observedBits);
+ }
+
+ function mountReducer(reducer, initialArg, init) {
+ var hook = mountWorkInProgressHook();
+ var initialState = void 0;
+
+ if (init !== undefined) {
+ initialState = init(initialArg);
+ } else {
+ initialState = initialArg;
+ }
+
+ hook.memoizedState = hook.baseState = initialState;
+ var queue = hook.queue = {
+ last: null,
+ dispatch: null,
+ eagerReducer: reducer,
+ eagerState: initialState
+ };
+ var dispatch = queue.dispatch = dispatchAction.bind(null, currentlyRenderingFiber$1, queue);
+ return [hook.memoizedState, dispatch];
+ }
+
+ function updateReducer(reducer, initialArg, init) {
+ var hook = updateWorkInProgressHook();
+ var queue = hook.queue;
+ invariant(queue !== null, "Should have a queue. This is likely a bug in React. Please file an issue.");
+
+ if (numberOfReRenders > 0) {
+ var _dispatch = queue.dispatch;
+
+ if (renderPhaseUpdates !== null) {
+ var firstRenderPhaseUpdate = renderPhaseUpdates.get(queue);
+
+ if (firstRenderPhaseUpdate !== undefined) {
+ renderPhaseUpdates.delete(queue);
+ var newState = hook.memoizedState;
+ var update = firstRenderPhaseUpdate;
+
+ do {
+ var _action = update.action;
+ newState = reducer(newState, _action);
+ update = update.next;
+ } while (update !== null);
+
+ if (!is(newState, hook.memoizedState)) {
+ markWorkInProgressReceivedUpdate();
+ }
+
+ hook.memoizedState = newState;
+
+ if (hook.baseUpdate === queue.last) {
+ hook.baseState = newState;
+ }
+
+ queue.eagerReducer = reducer;
+ queue.eagerState = newState;
+ return [newState, _dispatch];
+ }
+ }
+
+ return [hook.memoizedState, _dispatch];
+ }
+
+ var last = queue.last;
+ var baseUpdate = hook.baseUpdate;
+ var baseState = hook.baseState;
+ var first = void 0;
+
+ if (baseUpdate !== null) {
+ if (last !== null) {
+ last.next = null;
+ }
+
+ first = baseUpdate.next;
+ } else {
+ first = last !== null ? last.next : null;
+ }
+
+ if (first !== null) {
+ var _newState = baseState;
+ var newBaseState = null;
+ var newBaseUpdate = null;
+ var prevUpdate = baseUpdate;
+ var _update = first;
+ var didSkip = false;
+
+ do {
+ var updateExpirationTime = _update.expirationTime;
+
+ if (updateExpirationTime < renderExpirationTime) {
+ if (!didSkip) {
+ didSkip = true;
+ newBaseUpdate = prevUpdate;
+ newBaseState = _newState;
+ }
+
+ if (updateExpirationTime > remainingExpirationTime) {
+ remainingExpirationTime = updateExpirationTime;
+ }
+ } else {
+ if (_update.eagerReducer === reducer) {
+ _newState = _update.eagerState;
+ } else {
+ var _action2 = _update.action;
+ _newState = reducer(_newState, _action2);
+ }
+ }
+
+ prevUpdate = _update;
+ _update = _update.next;
+ } while (_update !== null && _update !== first);
+
+ if (!didSkip) {
+ newBaseUpdate = prevUpdate;
+ newBaseState = _newState;
+ }
+
+ if (!is(_newState, hook.memoizedState)) {
+ markWorkInProgressReceivedUpdate();
+ }
+
+ hook.memoizedState = _newState;
+ hook.baseUpdate = newBaseUpdate;
+ hook.baseState = newBaseState;
+ queue.eagerReducer = reducer;
+ queue.eagerState = _newState;
+ }
+
+ var dispatch = queue.dispatch;
+ return [hook.memoizedState, dispatch];
+ }
+
+ function mountState(initialState) {
+ var hook = mountWorkInProgressHook();
+
+ if (typeof initialState === "function") {
+ initialState = initialState();
+ }
+
+ hook.memoizedState = hook.baseState = initialState;
+ var queue = hook.queue = {
+ last: null,
+ dispatch: null,
+ eagerReducer: basicStateReducer,
+ eagerState: initialState
+ };
+ var dispatch = queue.dispatch = dispatchAction.bind(null, currentlyRenderingFiber$1, queue);
+ return [hook.memoizedState, dispatch];
+ }
+
+ function updateState(initialState) {
+ return updateReducer(basicStateReducer, initialState);
+ }
+
+ function pushEffect(tag, create, destroy, deps) {
+ var effect = {
+ tag: tag,
+ create: create,
+ destroy: destroy,
+ deps: deps,
+ next: null
+ };
+
+ if (componentUpdateQueue === null) {
+ componentUpdateQueue = createFunctionComponentUpdateQueue();
+ componentUpdateQueue.lastEffect = effect.next = effect;
+ } else {
+ var _lastEffect = componentUpdateQueue.lastEffect;
+
+ if (_lastEffect === null) {
+ componentUpdateQueue.lastEffect = effect.next = effect;
+ } else {
+ var firstEffect = _lastEffect.next;
+ _lastEffect.next = effect;
+ effect.next = firstEffect;
+ componentUpdateQueue.lastEffect = effect;
+ }
+ }
+
+ return effect;
+ }
+
+ function mountRef(initialValue) {
+ var hook = mountWorkInProgressHook();
+ var ref = {
+ current: initialValue
+ };
+ {
+ Object.seal(ref);
+ }
+ hook.memoizedState = ref;
+ return ref;
+ }
+
+ function updateRef(initialValue) {
+ var hook = updateWorkInProgressHook();
+ return hook.memoizedState;
+ }
+
+ function mountEffectImpl(fiberEffectTag, hookEffectTag, create, deps) {
+ var hook = mountWorkInProgressHook();
+ var nextDeps = deps === undefined ? null : deps;
+ sideEffectTag |= fiberEffectTag;
+ hook.memoizedState = pushEffect(hookEffectTag, create, undefined, nextDeps);
+ }
+
+ function updateEffectImpl(fiberEffectTag, hookEffectTag, create, deps) {
+ var hook = updateWorkInProgressHook();
+ var nextDeps = deps === undefined ? null : deps;
+ var destroy = undefined;
+
+ if (currentHook !== null) {
+ var prevEffect = currentHook.memoizedState;
+ destroy = prevEffect.destroy;
+
+ if (nextDeps !== null) {
+ var prevDeps = prevEffect.deps;
+
+ if (areHookInputsEqual(nextDeps, prevDeps)) {
+ pushEffect(NoEffect$1, create, destroy, nextDeps);
+ return;
+ }
+ }
+ }
+
+ sideEffectTag |= fiberEffectTag;
+ hook.memoizedState = pushEffect(hookEffectTag, create, destroy, nextDeps);
+ }
+
+ function mountEffect(create, deps) {
+ return mountEffectImpl(Update | Passive, UnmountPassive | MountPassive, create, deps);
+ }
+
+ function updateEffect(create, deps) {
+ return updateEffectImpl(Update | Passive, UnmountPassive | MountPassive, create, deps);
+ }
+
+ function mountLayoutEffect(create, deps) {
+ return mountEffectImpl(Update, UnmountMutation | MountLayout, create, deps);
+ }
+
+ function updateLayoutEffect(create, deps) {
+ return updateEffectImpl(Update, UnmountMutation | MountLayout, create, deps);
+ }
+
+ function imperativeHandleEffect(create, ref) {
+ if (typeof ref === "function") {
+ var refCallback = ref;
+
+ var _inst = create();
+
+ refCallback(_inst);
+ return function () {
+ refCallback(null);
+ };
+ } else if (ref !== null && ref !== undefined) {
+ var refObject = ref;
+ {
+ !refObject.hasOwnProperty("current") ? warning$1(false, "Expected useImperativeHandle() first argument to either be a " + "ref callback or React.createRef() object. Instead received: %s.", "an object with keys {" + Object.keys(refObject).join(", ") + "}") : void 0;
+ }
+
+ var _inst2 = create();
+
+ refObject.current = _inst2;
+ return function () {
+ refObject.current = null;
+ };
+ }
+ }
+
+ function mountImperativeHandle(ref, create, deps) {
+ {
+ !(typeof create === "function") ? warning$1(false, "Expected useImperativeHandle() second argument to be a function " + "that creates a handle. Instead received: %s.", create !== null ? typeof create : "null") : void 0;
+ }
+ var effectDeps = deps !== null && deps !== undefined ? deps.concat([ref]) : null;
+ return mountEffectImpl(Update, UnmountMutation | MountLayout, imperativeHandleEffect.bind(null, create, ref), effectDeps);
+ }
+
+ function updateImperativeHandle(ref, create, deps) {
+ {
+ !(typeof create === "function") ? warning$1(false, "Expected useImperativeHandle() second argument to be a function " + "that creates a handle. Instead received: %s.", create !== null ? typeof create : "null") : void 0;
+ }
+ var effectDeps = deps !== null && deps !== undefined ? deps.concat([ref]) : null;
+ return updateEffectImpl(Update, UnmountMutation | MountLayout, imperativeHandleEffect.bind(null, create, ref), effectDeps);
+ }
+
+ function mountDebugValue(value, formatterFn) {}
+
+ var updateDebugValue = mountDebugValue;
+
+ function mountCallback(callback, deps) {
+ var hook = mountWorkInProgressHook();
+ var nextDeps = deps === undefined ? null : deps;
+ hook.memoizedState = [callback, nextDeps];
+ return callback;
+ }
+
+ function updateCallback(callback, deps) {
+ var hook = updateWorkInProgressHook();
+ var nextDeps = deps === undefined ? null : deps;
+ var prevState = hook.memoizedState;
+
+ if (prevState !== null) {
+ if (nextDeps !== null) {
+ var prevDeps = prevState[1];
+
+ if (areHookInputsEqual(nextDeps, prevDeps)) {
+ return prevState[0];
+ }
+ }
+ }
+
+ hook.memoizedState = [callback, nextDeps];
+ return callback;
+ }
+
+ function mountMemo(nextCreate, deps) {
+ var hook = mountWorkInProgressHook();
+ var nextDeps = deps === undefined ? null : deps;
+ var nextValue = nextCreate();
+ hook.memoizedState = [nextValue, nextDeps];
+ return nextValue;
+ }
+
+ function updateMemo(nextCreate, deps) {
+ var hook = updateWorkInProgressHook();
+ var nextDeps = deps === undefined ? null : deps;
+ var prevState = hook.memoizedState;
+
+ if (prevState !== null) {
+ if (nextDeps !== null) {
+ var prevDeps = prevState[1];
+
+ if (areHookInputsEqual(nextDeps, prevDeps)) {
+ return prevState[0];
+ }
+ }
+ }
+
+ var nextValue = nextCreate();
+ hook.memoizedState = [nextValue, nextDeps];
+ return nextValue;
+ }
+
+ var shouldWarnForUnbatchedSetState = false;
+ {
+ if ("undefined" !== typeof jest) {
+ shouldWarnForUnbatchedSetState = true;
+ }
+ }
+
+ function dispatchAction(fiber, queue, action) {
+ invariant(numberOfReRenders < RE_RENDER_LIMIT, "Too many re-renders. React limits the number of renders to prevent " + "an infinite loop.");
+ {
+ !(arguments.length <= 3) ? warning$1(false, "State updates from the useState() and useReducer() Hooks don't support the " + "second callback argument. To execute a side effect after " + "rendering, declare it in the component body with useEffect().") : void 0;
+ }
+ var alternate = fiber.alternate;
+
+ if (fiber === currentlyRenderingFiber$1 || alternate !== null && alternate === currentlyRenderingFiber$1) {
+ didScheduleRenderPhaseUpdate = true;
+ var update = {
+ expirationTime: renderExpirationTime,
+ action: action,
+ eagerReducer: null,
+ eagerState: null,
+ next: null
+ };
+
+ if (renderPhaseUpdates === null) {
+ renderPhaseUpdates = new Map();
+ }
+
+ var firstRenderPhaseUpdate = renderPhaseUpdates.get(queue);
+
+ if (firstRenderPhaseUpdate === undefined) {
+ renderPhaseUpdates.set(queue, update);
+ } else {
+ var lastRenderPhaseUpdate = firstRenderPhaseUpdate;
+
+ while (lastRenderPhaseUpdate.next !== null) {
+ lastRenderPhaseUpdate = lastRenderPhaseUpdate.next;
+ }
+
+ lastRenderPhaseUpdate.next = update;
+ }
+ } else {
+ flushPassiveEffects();
+ var currentTime = requestCurrentTime();
+
+ var _expirationTime = computeExpirationForFiber(currentTime, fiber);
+
+ var _update2 = {
+ expirationTime: _expirationTime,
+ action: action,
+ eagerReducer: null,
+ eagerState: null,
+ next: null
+ };
+ var _last = queue.last;
+
+ if (_last === null) {
+ _update2.next = _update2;
+ } else {
+ var first = _last.next;
+
+ if (first !== null) {
+ _update2.next = first;
+ }
+
+ _last.next = _update2;
+ }
+
+ queue.last = _update2;
+
+ if (fiber.expirationTime === NoWork && (alternate === null || alternate.expirationTime === NoWork)) {
+ var _eagerReducer = queue.eagerReducer;
+
+ if (_eagerReducer !== null) {
+ var prevDispatcher = void 0;
+ {
+ prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;
+ }
+
+ try {
+ var currentState = queue.eagerState;
+
+ var _eagerState = _eagerReducer(currentState, action);
+
+ _update2.eagerReducer = _eagerReducer;
+ _update2.eagerState = _eagerState;
+
+ if (is(_eagerState, currentState)) {
+ return;
+ }
+ } catch (error) {} finally {
+ {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ }
+ }
+ }
+
+ {
+ if (shouldWarnForUnbatchedSetState === true) {
+ warnIfNotCurrentlyBatchingInDev(fiber);
+ }
+ }
+ scheduleWork(fiber, _expirationTime);
+ }
+ }
+
+ var ContextOnlyDispatcher = {
+ readContext: _readContext,
+ useCallback: throwInvalidHookError,
+ useContext: throwInvalidHookError,
+ useEffect: throwInvalidHookError,
+ useImperativeHandle: throwInvalidHookError,
+ useLayoutEffect: throwInvalidHookError,
+ useMemo: throwInvalidHookError,
+ useReducer: throwInvalidHookError,
+ useRef: throwInvalidHookError,
+ useState: throwInvalidHookError,
+ useDebugValue: throwInvalidHookError
+ };
+ var HooksDispatcherOnMountInDEV = null;
+ var HooksDispatcherOnUpdateInDEV = null;
+ var InvalidNestedHooksDispatcherOnMountInDEV = null;
+ var InvalidNestedHooksDispatcherOnUpdateInDEV = null;
+ {
+ var warnInvalidContextAccess = function warnInvalidContextAccess() {
+ warning$1(false, "Context can only be read while React is rendering. " + "In classes, you can read it in the render method or getDerivedStateFromProps. " + "In function components, you can read it directly in the function body, but not " + "inside Hooks like useReducer() or useMemo().");
+ };
+
+ var warnInvalidHookAccess = function warnInvalidHookAccess() {
+ warning$1(false, "Do not call Hooks inside useEffect(...), useMemo(...), or other built-in Hooks. " + "You can only call Hooks at the top level of your React function. " + "For more information, see " + "https://fb.me/rules-of-hooks");
+ };
+
+ HooksDispatcherOnMountInDEV = {
+ readContext: function readContext(context, observedBits) {
+ return _readContext(context, observedBits);
+ },
+ useCallback: function useCallback(callback, deps) {
+ currentHookNameInDev = "useCallback";
+ return mountCallback(callback, deps);
+ },
+ useContext: function useContext(context, observedBits) {
+ currentHookNameInDev = "useContext";
+ return mountContext(context, observedBits);
+ },
+ useEffect: function useEffect(create, deps) {
+ currentHookNameInDev = "useEffect";
+ return mountEffect(create, deps);
+ },
+ useImperativeHandle: function useImperativeHandle(ref, create, deps) {
+ currentHookNameInDev = "useImperativeHandle";
+ return mountImperativeHandle(ref, create, deps);
+ },
+ useLayoutEffect: function useLayoutEffect(create, deps) {
+ currentHookNameInDev = "useLayoutEffect";
+ return mountLayoutEffect(create, deps);
+ },
+ useMemo: function useMemo(create, deps) {
+ currentHookNameInDev = "useMemo";
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;
+
+ try {
+ return mountMemo(create, deps);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useReducer: function useReducer(reducer, initialArg, init) {
+ currentHookNameInDev = "useReducer";
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;
+
+ try {
+ return mountReducer(reducer, initialArg, init);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useRef: function useRef(initialValue) {
+ currentHookNameInDev = "useRef";
+ return mountRef(initialValue);
+ },
+ useState: function useState(initialState) {
+ currentHookNameInDev = "useState";
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;
+
+ try {
+ return mountState(initialState);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useDebugValue: function useDebugValue(value, formatterFn) {
+ currentHookNameInDev = "useDebugValue";
+ return mountDebugValue(value, formatterFn);
+ }
+ };
+ HooksDispatcherOnUpdateInDEV = {
+ readContext: function readContext(context, observedBits) {
+ return _readContext(context, observedBits);
+ },
+ useCallback: function useCallback(callback, deps) {
+ currentHookNameInDev = "useCallback";
+ return updateCallback(callback, deps);
+ },
+ useContext: function useContext(context, observedBits) {
+ currentHookNameInDev = "useContext";
+ return updateContext(context, observedBits);
+ },
+ useEffect: function useEffect(create, deps) {
+ currentHookNameInDev = "useEffect";
+ return updateEffect(create, deps);
+ },
+ useImperativeHandle: function useImperativeHandle(ref, create, deps) {
+ currentHookNameInDev = "useImperativeHandle";
+ return updateImperativeHandle(ref, create, deps);
+ },
+ useLayoutEffect: function useLayoutEffect(create, deps) {
+ currentHookNameInDev = "useLayoutEffect";
+ return updateLayoutEffect(create, deps);
+ },
+ useMemo: function useMemo(create, deps) {
+ currentHookNameInDev = "useMemo";
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;
+
+ try {
+ return updateMemo(create, deps);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useReducer: function useReducer(reducer, initialArg, init) {
+ currentHookNameInDev = "useReducer";
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;
+
+ try {
+ return updateReducer(reducer, initialArg, init);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useRef: function useRef(initialValue) {
+ currentHookNameInDev = "useRef";
+ return updateRef(initialValue);
+ },
+ useState: function useState(initialState) {
+ currentHookNameInDev = "useState";
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;
+
+ try {
+ return updateState(initialState);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useDebugValue: function useDebugValue(value, formatterFn) {
+ currentHookNameInDev = "useDebugValue";
+ return updateDebugValue(value, formatterFn);
+ }
+ };
+ InvalidNestedHooksDispatcherOnMountInDEV = {
+ readContext: function readContext(context, observedBits) {
+ warnInvalidContextAccess();
+ return _readContext(context, observedBits);
+ },
+ useCallback: function useCallback(callback, deps) {
+ currentHookNameInDev = "useCallback";
+ warnInvalidHookAccess();
+ return mountCallback(callback, deps);
+ },
+ useContext: function useContext(context, observedBits) {
+ currentHookNameInDev = "useContext";
+ warnInvalidHookAccess();
+ return mountContext(context, observedBits);
+ },
+ useEffect: function useEffect(create, deps) {
+ currentHookNameInDev = "useEffect";
+ warnInvalidHookAccess();
+ return mountEffect(create, deps);
+ },
+ useImperativeHandle: function useImperativeHandle(ref, create, deps) {
+ currentHookNameInDev = "useImperativeHandle";
+ warnInvalidHookAccess();
+ return mountImperativeHandle(ref, create, deps);
+ },
+ useLayoutEffect: function useLayoutEffect(create, deps) {
+ currentHookNameInDev = "useLayoutEffect";
+ warnInvalidHookAccess();
+ return mountLayoutEffect(create, deps);
+ },
+ useMemo: function useMemo(create, deps) {
+ currentHookNameInDev = "useMemo";
+ warnInvalidHookAccess();
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;
+
+ try {
+ return mountMemo(create, deps);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useReducer: function useReducer(reducer, initialArg, init) {
+ currentHookNameInDev = "useReducer";
+ warnInvalidHookAccess();
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;
+
+ try {
+ return mountReducer(reducer, initialArg, init);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useRef: function useRef(initialValue) {
+ currentHookNameInDev = "useRef";
+ warnInvalidHookAccess();
+ return mountRef(initialValue);
+ },
+ useState: function useState(initialState) {
+ currentHookNameInDev = "useState";
+ warnInvalidHookAccess();
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;
+
+ try {
+ return mountState(initialState);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useDebugValue: function useDebugValue(value, formatterFn) {
+ currentHookNameInDev = "useDebugValue";
+ warnInvalidHookAccess();
+ return mountDebugValue(value, formatterFn);
+ }
+ };
+ InvalidNestedHooksDispatcherOnUpdateInDEV = {
+ readContext: function readContext(context, observedBits) {
+ warnInvalidContextAccess();
+ return _readContext(context, observedBits);
+ },
+ useCallback: function useCallback(callback, deps) {
+ currentHookNameInDev = "useCallback";
+ warnInvalidHookAccess();
+ return updateCallback(callback, deps);
+ },
+ useContext: function useContext(context, observedBits) {
+ currentHookNameInDev = "useContext";
+ warnInvalidHookAccess();
+ return updateContext(context, observedBits);
+ },
+ useEffect: function useEffect(create, deps) {
+ currentHookNameInDev = "useEffect";
+ warnInvalidHookAccess();
+ return updateEffect(create, deps);
+ },
+ useImperativeHandle: function useImperativeHandle(ref, create, deps) {
+ currentHookNameInDev = "useImperativeHandle";
+ warnInvalidHookAccess();
+ return updateImperativeHandle(ref, create, deps);
+ },
+ useLayoutEffect: function useLayoutEffect(create, deps) {
+ currentHookNameInDev = "useLayoutEffect";
+ warnInvalidHookAccess();
+ return updateLayoutEffect(create, deps);
+ },
+ useMemo: function useMemo(create, deps) {
+ currentHookNameInDev = "useMemo";
+ warnInvalidHookAccess();
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;
+
+ try {
+ return updateMemo(create, deps);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useReducer: function useReducer(reducer, initialArg, init) {
+ currentHookNameInDev = "useReducer";
+ warnInvalidHookAccess();
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;
+
+ try {
+ return updateReducer(reducer, initialArg, init);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useRef: function useRef(initialValue) {
+ currentHookNameInDev = "useRef";
+ warnInvalidHookAccess();
+ return updateRef(initialValue);
+ },
+ useState: function useState(initialState) {
+ currentHookNameInDev = "useState";
+ warnInvalidHookAccess();
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;
+
+ try {
+ return updateState(initialState);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useDebugValue: function useDebugValue(value, formatterFn) {
+ currentHookNameInDev = "useDebugValue";
+ warnInvalidHookAccess();
+ return updateDebugValue(value, formatterFn);
+ }
+ };
+ }
+ var commitTime = 0;
+ var profilerStartTime = -1;
+
+ function getCommitTime() {
+ return commitTime;
+ }
+
+ function recordCommitTime() {
+ if (!enableProfilerTimer) {
+ return;
+ }
+
+ commitTime = now$$1();
+ }
+
+ function startProfilerTimer(fiber) {
+ if (!enableProfilerTimer) {
+ return;
+ }
+
+ profilerStartTime = now$$1();
+
+ if (fiber.actualStartTime < 0) {
+ fiber.actualStartTime = now$$1();
+ }
+ }
+
+ function stopProfilerTimerIfRunning(fiber) {
+ if (!enableProfilerTimer) {
+ return;
+ }
+
+ profilerStartTime = -1;
+ }
+
+ function stopProfilerTimerIfRunningAndRecordDelta(fiber, overrideBaseTime) {
+ if (!enableProfilerTimer) {
+ return;
+ }
+
+ if (profilerStartTime >= 0) {
+ var elapsedTime = now$$1() - profilerStartTime;
+ fiber.actualDuration += elapsedTime;
+
+ if (overrideBaseTime) {
+ fiber.selfBaseDuration = elapsedTime;
+ }
+
+ profilerStartTime = -1;
+ }
+ }
+
+ var hydrationParentFiber = null;
+ var nextHydratableInstance = null;
+ var isHydrating = false;
+
+ function enterHydrationState(fiber) {
+ if (!supportsHydration) {
+ return false;
+ }
+
+ var parentInstance = fiber.stateNode.containerInfo;
+ nextHydratableInstance = getFirstHydratableChild(parentInstance);
+ hydrationParentFiber = fiber;
+ isHydrating = true;
+ return true;
+ }
+
+ function reenterHydrationStateFromDehydratedSuspenseInstance(fiber) {
+ if (!supportsHydration) {
+ return false;
+ }
+
+ var suspenseInstance = fiber.stateNode;
+ nextHydratableInstance = getNextHydratableSibling(suspenseInstance);
+ popToNextHostParent(fiber);
+ isHydrating = true;
+ return true;
+ }
+
+ function deleteHydratableInstance(returnFiber, instance) {
+ {
+ switch (returnFiber.tag) {
+ case HostRoot:
+ didNotHydrateContainerInstance(returnFiber.stateNode.containerInfo, instance);
+ break;
+
+ case HostComponent:
+ didNotHydrateInstance(returnFiber.type, returnFiber.memoizedProps, returnFiber.stateNode, instance);
+ break;
+ }
+ }
+ var childToDelete = createFiberFromHostInstanceForDeletion();
+ childToDelete.stateNode = instance;
+ childToDelete.return = returnFiber;
+ childToDelete.effectTag = Deletion;
+
+ if (returnFiber.lastEffect !== null) {
+ returnFiber.lastEffect.nextEffect = childToDelete;
+ returnFiber.lastEffect = childToDelete;
+ } else {
+ returnFiber.firstEffect = returnFiber.lastEffect = childToDelete;
+ }
+ }
+
+ function insertNonHydratedInstance(returnFiber, fiber) {
+ fiber.effectTag |= Placement;
+ {
+ switch (returnFiber.tag) {
+ case HostRoot:
+ {
+ var parentContainer = returnFiber.stateNode.containerInfo;
+
+ switch (fiber.tag) {
+ case HostComponent:
+ var type = fiber.type;
+ var props = fiber.pendingProps;
+ didNotFindHydratableContainerInstance(parentContainer, type, props);
+ break;
+
+ case HostText:
+ var text = fiber.pendingProps;
+ didNotFindHydratableContainerTextInstance(parentContainer, text);
+ break;
+
+ case SuspenseComponent:
+ didNotFindHydratableContainerSuspenseInstance(parentContainer);
+ break;
+ }
+
+ break;
+ }
+
+ case HostComponent:
+ {
+ var parentType = returnFiber.type;
+ var parentProps = returnFiber.memoizedProps;
+ var parentInstance = returnFiber.stateNode;
+
+ switch (fiber.tag) {
+ case HostComponent:
+ var _type = fiber.type;
+ var _props = fiber.pendingProps;
+ didNotFindHydratableInstance(parentType, parentProps, parentInstance, _type, _props);
+ break;
+
+ case HostText:
+ var _text = fiber.pendingProps;
+ didNotFindHydratableTextInstance(parentType, parentProps, parentInstance, _text);
+ break;
+
+ case SuspenseComponent:
+ didNotFindHydratableSuspenseInstance(parentType, parentProps, parentInstance);
+ break;
+ }
+
+ break;
+ }
+
+ default:
+ return;
+ }
+ }
+ }
+
+ function tryHydrate(fiber, nextInstance) {
+ switch (fiber.tag) {
+ case HostComponent:
+ {
+ var type = fiber.type;
+ var props = fiber.pendingProps;
+ var instance = canHydrateInstance(nextInstance, type, props);
+
+ if (instance !== null) {
+ fiber.stateNode = instance;
+ return true;
+ }
+
+ return false;
+ }
+
+ case HostText:
+ {
+ var text = fiber.pendingProps;
+ var textInstance = canHydrateTextInstance(nextInstance, text);
+
+ if (textInstance !== null) {
+ fiber.stateNode = textInstance;
+ return true;
+ }
+
+ return false;
+ }
+
+ case SuspenseComponent:
+ {
+ if (enableSuspenseServerRenderer) {
+ var suspenseInstance = canHydrateSuspenseInstance(nextInstance);
+
+ if (suspenseInstance !== null) {
+ fiber.tag = DehydratedSuspenseComponent;
+ fiber.stateNode = suspenseInstance;
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ default:
+ return false;
+ }
+ }
+
+ function tryToClaimNextHydratableInstance(fiber) {
+ if (!isHydrating) {
+ return;
+ }
+
+ var nextInstance = nextHydratableInstance;
+
+ if (!nextInstance) {
+ insertNonHydratedInstance(hydrationParentFiber, fiber);
+ isHydrating = false;
+ hydrationParentFiber = fiber;
+ return;
+ }
+
+ var firstAttemptedInstance = nextInstance;
+
+ if (!tryHydrate(fiber, nextInstance)) {
+ nextInstance = getNextHydratableSibling(firstAttemptedInstance);
+
+ if (!nextInstance || !tryHydrate(fiber, nextInstance)) {
+ insertNonHydratedInstance(hydrationParentFiber, fiber);
+ isHydrating = false;
+ hydrationParentFiber = fiber;
+ return;
+ }
+
+ deleteHydratableInstance(hydrationParentFiber, firstAttemptedInstance);
+ }
+
+ hydrationParentFiber = fiber;
+ nextHydratableInstance = getFirstHydratableChild(nextInstance);
+ }
+
+ function prepareToHydrateHostInstance(fiber, rootContainerInstance, hostContext) {
+ if (!supportsHydration) {
+ 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 skipPastDehydratedSuspenseInstance(fiber) {
+ if (!supportsHydration) {
+ invariant(false, "Expected skipPastDehydratedSuspenseInstance() to never be called. " + "This error is likely caused by a bug in React. Please file an issue.");
+ }
+
+ var suspenseInstance = fiber.stateNode;
+ invariant(suspenseInstance, "Expected to have a hydrated suspense instance. " + "This error is likely caused by a bug in React. Please file an issue.");
+ nextHydratableInstance = getNextHydratableInstanceAfterSuspenseInstance(suspenseInstance);
+ }
+
+ function popToNextHostParent(fiber) {
+ var parent = fiber.return;
+
+ while (parent !== null && parent.tag !== HostComponent && parent.tag !== HostRoot && parent.tag !== DehydratedSuspenseComponent) {
+ parent = parent.return;
+ }
+
+ hydrationParentFiber = parent;
+ }
+
+ function popHydrationState(fiber) {
+ if (!supportsHydration) {
+ return false;
+ }
+
+ if (fiber !== hydrationParentFiber) {
+ return false;
+ }
+
+ if (!isHydrating) {
+ popToNextHostParent(fiber);
+ isHydrating = true;
+ return false;
+ }
+
+ var type = fiber.type;
+
+ if (fiber.tag !== HostComponent || type !== "head" && type !== "body" && !shouldSetTextContent(type, fiber.memoizedProps)) {
+ var nextInstance = nextHydratableInstance;
+
+ while (nextInstance) {
+ deleteHydratableInstance(fiber, nextInstance);
+ nextInstance = getNextHydratableSibling(nextInstance);
+ }
+ }
+
+ popToNextHostParent(fiber);
+ nextHydratableInstance = hydrationParentFiber ? getNextHydratableSibling(fiber.stateNode) : null;
+ return true;
+ }
+
+ function resetHydrationState() {
+ if (!supportsHydration) {
+ return;
+ }
+
+ hydrationParentFiber = null;
+ nextHydratableInstance = null;
+ isHydrating = false;
+ }
+
+ var ReactCurrentOwner$3 = ReactSharedInternals.ReactCurrentOwner;
+ var didReceiveUpdate = false;
+ var didWarnAboutBadClass = void 0;
+ var didWarnAboutContextTypeOnFunctionComponent = void 0;
+ var didWarnAboutGetDerivedStateOnFunctionComponent = void 0;
+ var didWarnAboutFunctionRefs = void 0;
+ var didWarnAboutReassigningProps = void 0;
+ {
+ didWarnAboutBadClass = {};
+ didWarnAboutContextTypeOnFunctionComponent = {};
+ didWarnAboutGetDerivedStateOnFunctionComponent = {};
+ didWarnAboutFunctionRefs = {};
+ didWarnAboutReassigningProps = false;
+ }
+
+ function reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime) {
+ if (current$$1 === null) {
+ workInProgress.child = mountChildFibers(workInProgress, null, nextChildren, renderExpirationTime);
+ } else {
+ workInProgress.child = reconcileChildFibers(workInProgress, current$$1.child, nextChildren, renderExpirationTime);
+ }
+ }
+
+ function forceUnmountCurrentAndReconcile(current$$1, workInProgress, nextChildren, renderExpirationTime) {
+ workInProgress.child = reconcileChildFibers(workInProgress, current$$1.child, null, renderExpirationTime);
+ workInProgress.child = reconcileChildFibers(workInProgress, null, nextChildren, renderExpirationTime);
+ }
+
+ function updateForwardRef(current$$1, workInProgress, Component, nextProps, renderExpirationTime) {
+ {
+ if (workInProgress.type !== workInProgress.elementType) {
+ var innerPropTypes = Component.propTypes;
+
+ if (innerPropTypes) {
+ checkPropTypes(innerPropTypes, nextProps, "prop", getComponentName(Component), getCurrentFiberStackInDev);
+ }
+ }
+ }
+ var render = Component.render;
+ var ref = workInProgress.ref;
+ var nextChildren = void 0;
+ prepareToReadContext(workInProgress, renderExpirationTime);
+ {
+ ReactCurrentOwner$3.current = workInProgress;
+ setCurrentPhase("render");
+ nextChildren = renderWithHooks(current$$1, workInProgress, render, nextProps, ref, renderExpirationTime);
+
+ if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
+ if (workInProgress.memoizedState !== null) {
+ nextChildren = renderWithHooks(current$$1, workInProgress, render, nextProps, ref, renderExpirationTime);
+ }
+ }
+
+ setCurrentPhase(null);
+ }
+
+ if (current$$1 !== null && !didReceiveUpdate) {
+ bailoutHooks(current$$1, workInProgress, renderExpirationTime);
+ return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ }
+
+ workInProgress.effectTag |= PerformedWork;
+ reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
+ return workInProgress.child;
+ }
+
+ function updateMemoComponent(current$$1, workInProgress, Component, nextProps, updateExpirationTime, renderExpirationTime) {
+ if (current$$1 === null) {
+ var type = Component.type;
+
+ if (isSimpleFunctionComponent(type) && Component.compare === null && Component.defaultProps === undefined) {
+ workInProgress.tag = SimpleMemoComponent;
+ workInProgress.type = type;
+ {
+ validateFunctionComponentInDev(workInProgress, type);
+ }
+ return updateSimpleMemoComponent(current$$1, workInProgress, type, nextProps, updateExpirationTime, renderExpirationTime);
+ }
+
+ {
+ var innerPropTypes = type.propTypes;
+
+ if (innerPropTypes) {
+ checkPropTypes(innerPropTypes, nextProps, "prop", getComponentName(type), getCurrentFiberStackInDev);
+ }
+ }
+ var child = createFiberFromTypeAndProps(Component.type, null, nextProps, null, workInProgress.mode, renderExpirationTime);
+ child.ref = workInProgress.ref;
+ child.return = workInProgress;
+ workInProgress.child = child;
+ return child;
+ }
+
+ {
+ var _type = Component.type;
+ var _innerPropTypes = _type.propTypes;
+
+ if (_innerPropTypes) {
+ checkPropTypes(_innerPropTypes, nextProps, "prop", getComponentName(_type), getCurrentFiberStackInDev);
+ }
+ }
+ var currentChild = current$$1.child;
+
+ if (updateExpirationTime < renderExpirationTime) {
+ var prevProps = currentChild.memoizedProps;
+ var compare = Component.compare;
+ compare = compare !== null ? compare : shallowEqual;
+
+ if (compare(prevProps, nextProps) && current$$1.ref === workInProgress.ref) {
+ return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ }
+ }
+
+ workInProgress.effectTag |= PerformedWork;
+ var newChild = createWorkInProgress(currentChild, nextProps, renderExpirationTime);
+ newChild.ref = workInProgress.ref;
+ newChild.return = workInProgress;
+ workInProgress.child = newChild;
+ return newChild;
+ }
+
+ function updateSimpleMemoComponent(current$$1, workInProgress, Component, nextProps, updateExpirationTime, renderExpirationTime) {
+ {
+ if (workInProgress.type !== workInProgress.elementType) {
+ var outerMemoType = workInProgress.elementType;
+
+ if (outerMemoType.$$typeof === REACT_LAZY_TYPE) {
+ outerMemoType = refineResolvedLazyComponent(outerMemoType);
+ }
+
+ var outerPropTypes = outerMemoType && outerMemoType.propTypes;
+
+ if (outerPropTypes) {
+ checkPropTypes(outerPropTypes, nextProps, "prop", getComponentName(outerMemoType), getCurrentFiberStackInDev);
+ }
+ }
+ }
+
+ if (current$$1 !== null) {
+ var prevProps = current$$1.memoizedProps;
+
+ if (shallowEqual(prevProps, nextProps) && current$$1.ref === workInProgress.ref) {
+ didReceiveUpdate = false;
+
+ if (updateExpirationTime < renderExpirationTime) {
+ return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ }
+ }
+ }
+
+ return updateFunctionComponent(current$$1, workInProgress, Component, nextProps, renderExpirationTime);
+ }
+
+ function updateFragment(current$$1, workInProgress, renderExpirationTime) {
+ var nextChildren = workInProgress.pendingProps;
+ reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
+ return workInProgress.child;
+ }
+
+ function updateMode(current$$1, workInProgress, renderExpirationTime) {
+ var nextChildren = workInProgress.pendingProps.children;
+ reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
+ return workInProgress.child;
+ }
+
+ function updateProfiler(current$$1, workInProgress, renderExpirationTime) {
+ if (enableProfilerTimer) {
+ workInProgress.effectTag |= Update;
+ }
+
+ var nextProps = workInProgress.pendingProps;
+ var nextChildren = nextProps.children;
+ reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
+ return workInProgress.child;
+ }
+
+ function markRef(current$$1, workInProgress) {
+ var ref = workInProgress.ref;
+
+ if (current$$1 === null && ref !== null || current$$1 !== null && current$$1.ref !== ref) {
+ workInProgress.effectTag |= Ref;
+ }
+ }
+
+ function updateFunctionComponent(current$$1, workInProgress, Component, nextProps, renderExpirationTime) {
+ {
+ if (workInProgress.type !== workInProgress.elementType) {
+ var innerPropTypes = Component.propTypes;
+
+ if (innerPropTypes) {
+ checkPropTypes(innerPropTypes, nextProps, "prop", getComponentName(Component), getCurrentFiberStackInDev);
+ }
+ }
+ }
+ var unmaskedContext = getUnmaskedContext(workInProgress, Component, true);
+ var context = getMaskedContext(workInProgress, unmaskedContext);
+ var nextChildren = void 0;
+ prepareToReadContext(workInProgress, renderExpirationTime);
+ {
+ ReactCurrentOwner$3.current = workInProgress;
+ setCurrentPhase("render");
+ nextChildren = renderWithHooks(current$$1, workInProgress, Component, nextProps, context, renderExpirationTime);
+
+ if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
+ if (workInProgress.memoizedState !== null) {
+ nextChildren = renderWithHooks(current$$1, workInProgress, Component, nextProps, context, renderExpirationTime);
+ }
+ }
+
+ setCurrentPhase(null);
+ }
+
+ if (current$$1 !== null && !didReceiveUpdate) {
+ bailoutHooks(current$$1, workInProgress, renderExpirationTime);
+ return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ }
+
+ workInProgress.effectTag |= PerformedWork;
+ reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
+ return workInProgress.child;
+ }
+
+ function updateClassComponent(current$$1, workInProgress, Component, nextProps, renderExpirationTime) {
+ {
+ if (workInProgress.type !== workInProgress.elementType) {
+ var innerPropTypes = Component.propTypes;
+
+ if (innerPropTypes) {
+ checkPropTypes(innerPropTypes, nextProps, "prop", getComponentName(Component), getCurrentFiberStackInDev);
+ }
+ }
+ }
+ var hasContext = void 0;
+
+ if (isContextProvider(Component)) {
+ hasContext = true;
+ pushContextProvider(workInProgress);
+ } else {
+ hasContext = false;
+ }
+
+ prepareToReadContext(workInProgress, renderExpirationTime);
+ var instance = workInProgress.stateNode;
+ var shouldUpdate = void 0;
+
+ if (instance === null) {
+ if (current$$1 !== null) {
+ current$$1.alternate = null;
+ workInProgress.alternate = null;
+ workInProgress.effectTag |= Placement;
+ }
+
+ constructClassInstance(workInProgress, Component, nextProps, renderExpirationTime);
+ mountClassInstance(workInProgress, Component, nextProps, renderExpirationTime);
+ shouldUpdate = true;
+ } else if (current$$1 === null) {
+ shouldUpdate = resumeMountClassInstance(workInProgress, Component, nextProps, renderExpirationTime);
+ } else {
+ shouldUpdate = updateClassInstance(current$$1, workInProgress, Component, nextProps, renderExpirationTime);
+ }
+
+ var nextUnitOfWork = finishClassComponent(current$$1, workInProgress, Component, shouldUpdate, hasContext, renderExpirationTime);
+ {
+ var inst = workInProgress.stateNode;
+
+ if (inst.props !== nextProps) {
+ !didWarnAboutReassigningProps ? warning$1(false, "It looks like %s is reassigning its own `this.props` while rendering. " + "This is not supported and can lead to confusing bugs.", getComponentName(workInProgress.type) || "a component") : void 0;
+ didWarnAboutReassigningProps = true;
+ }
+ }
+ return nextUnitOfWork;
+ }
+
+ function finishClassComponent(current$$1, workInProgress, Component, shouldUpdate, hasContext, renderExpirationTime) {
+ markRef(current$$1, workInProgress);
+ var didCaptureError = (workInProgress.effectTag & DidCapture) !== NoEffect;
+
+ if (!shouldUpdate && !didCaptureError) {
+ if (hasContext) {
+ invalidateContextProvider(workInProgress, Component, false);
+ }
+
+ return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ }
+
+ var instance = workInProgress.stateNode;
+ ReactCurrentOwner$3.current = workInProgress;
+ var nextChildren = void 0;
+
+ if (didCaptureError && typeof Component.getDerivedStateFromError !== "function") {
+ nextChildren = null;
+
+ if (enableProfilerTimer) {
+ stopProfilerTimerIfRunning(workInProgress);
+ }
+ } else {
+ {
+ setCurrentPhase("render");
+ nextChildren = instance.render();
+
+ if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
+ instance.render();
+ }
+
+ setCurrentPhase(null);
+ }
+ }
+
+ workInProgress.effectTag |= PerformedWork;
+
+ if (current$$1 !== null && didCaptureError) {
+ forceUnmountCurrentAndReconcile(current$$1, workInProgress, nextChildren, renderExpirationTime);
+ } else {
+ reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
+ }
+
+ workInProgress.memoizedState = instance.state;
+
+ if (hasContext) {
+ invalidateContextProvider(workInProgress, Component, true);
+ }
+
+ return workInProgress.child;
+ }
+
+ function pushHostRootContext(workInProgress) {
+ var root = workInProgress.stateNode;
+
+ if (root.pendingContext) {
+ pushTopLevelContextObject(workInProgress, root.pendingContext, root.pendingContext !== root.context);
+ } else if (root.context) {
+ pushTopLevelContextObject(workInProgress, root.context, false);
+ }
+
+ pushHostContainer(workInProgress, root.containerInfo);
+ }
+
+ function updateHostRoot(current$$1, workInProgress, renderExpirationTime) {
+ pushHostRootContext(workInProgress);
+ var updateQueue = workInProgress.updateQueue;
+ invariant(updateQueue !== null, "If the root does not have an updateQueue, we should have already " + "bailed out. This error is likely caused by a bug in React. Please " + "file an issue.");
+ var nextProps = workInProgress.pendingProps;
+ var prevState = workInProgress.memoizedState;
+ var prevChildren = prevState !== null ? prevState.element : null;
+ processUpdateQueue(workInProgress, updateQueue, nextProps, null, renderExpirationTime);
+ var nextState = workInProgress.memoizedState;
+ var nextChildren = nextState.element;
+
+ if (nextChildren === prevChildren) {
+ resetHydrationState();
+ return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ }
+
+ var root = workInProgress.stateNode;
+
+ if ((current$$1 === null || current$$1.child === null) && root.hydrate && enterHydrationState(workInProgress)) {
+ workInProgress.effectTag |= Placement;
+ workInProgress.child = mountChildFibers(workInProgress, null, nextChildren, renderExpirationTime);
+ } else {
+ reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
+ resetHydrationState();
+ }
+
+ return workInProgress.child;
+ }
+
+ function updateHostComponent(current$$1, workInProgress, renderExpirationTime) {
+ pushHostContext(workInProgress);
+
+ if (current$$1 === null) {
+ tryToClaimNextHydratableInstance(workInProgress);
+ }
+
+ var type = workInProgress.type;
+ var nextProps = workInProgress.pendingProps;
+ var prevProps = current$$1 !== null ? current$$1.memoizedProps : null;
+ var nextChildren = nextProps.children;
+ var isDirectTextChild = shouldSetTextContent(type, nextProps);
+
+ if (isDirectTextChild) {
+ nextChildren = null;
+ } else if (prevProps !== null && shouldSetTextContent(type, prevProps)) {
+ workInProgress.effectTag |= ContentReset;
+ }
+
+ markRef(current$$1, workInProgress);
+
+ if (renderExpirationTime !== Never && workInProgress.mode & ConcurrentMode && shouldDeprioritizeSubtree(type, nextProps)) {
+ workInProgress.expirationTime = workInProgress.childExpirationTime = Never;
+ return null;
+ }
+
+ reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
+ return workInProgress.child;
+ }
+
+ function updateHostText(current$$1, workInProgress) {
+ if (current$$1 === null) {
+ tryToClaimNextHydratableInstance(workInProgress);
+ }
+
+ return null;
+ }
+
+ function mountLazyComponent(_current, workInProgress, elementType, updateExpirationTime, renderExpirationTime) {
+ if (_current !== null) {
+ _current.alternate = null;
+ workInProgress.alternate = null;
+ workInProgress.effectTag |= Placement;
+ }
+
+ var props = workInProgress.pendingProps;
+ cancelWorkTimer(workInProgress);
+ var Component = readLazyComponentType(elementType);
+ workInProgress.type = Component;
+ var resolvedTag = workInProgress.tag = resolveLazyComponentTag(Component);
+ startWorkTimer(workInProgress);
+ var resolvedProps = resolveDefaultProps(Component, props);
+ var child = void 0;
+
+ switch (resolvedTag) {
+ case FunctionComponent:
+ {
+ {
+ validateFunctionComponentInDev(workInProgress, Component);
+ }
+ child = updateFunctionComponent(null, workInProgress, Component, resolvedProps, renderExpirationTime);
+ break;
+ }
+
+ case ClassComponent:
+ {
+ child = updateClassComponent(null, workInProgress, Component, resolvedProps, renderExpirationTime);
+ break;
+ }
+
+ case ForwardRef:
+ {
+ child = updateForwardRef(null, workInProgress, Component, resolvedProps, renderExpirationTime);
+ break;
+ }
+
+ case MemoComponent:
+ {
+ {
+ if (workInProgress.type !== workInProgress.elementType) {
+ var outerPropTypes = Component.propTypes;
+
+ if (outerPropTypes) {
+ checkPropTypes(outerPropTypes, resolvedProps, "prop", getComponentName(Component), getCurrentFiberStackInDev);
+ }
+ }
+ }
+ child = updateMemoComponent(null, workInProgress, Component, resolveDefaultProps(Component.type, resolvedProps), updateExpirationTime, renderExpirationTime);
+ break;
+ }
+
+ default:
+ {
+ var hint = "";
+ {
+ if (Component !== null && typeof Component === "object" && Component.$$typeof === REACT_LAZY_TYPE) {
+ hint = " Did you wrap a component in React.lazy() more than once?";
+ }
+ }
+ invariant(false, "Element type is invalid. Received a promise that resolves to: %s. " + "Lazy element type must resolve to a class or function.%s", Component, hint);
+ }
+ }
+
+ return child;
+ }
+
+ function mountIncompleteClassComponent(_current, workInProgress, Component, nextProps, renderExpirationTime) {
+ if (_current !== null) {
+ _current.alternate = null;
+ workInProgress.alternate = null;
+ workInProgress.effectTag |= Placement;
+ }
+
+ workInProgress.tag = ClassComponent;
+ var hasContext = void 0;
+
+ if (isContextProvider(Component)) {
+ hasContext = true;
+ pushContextProvider(workInProgress);
+ } else {
+ hasContext = false;
+ }
+
+ prepareToReadContext(workInProgress, renderExpirationTime);
+ constructClassInstance(workInProgress, Component, nextProps, renderExpirationTime);
+ mountClassInstance(workInProgress, Component, nextProps, renderExpirationTime);
+ return finishClassComponent(null, workInProgress, Component, true, hasContext, renderExpirationTime);
+ }
+
+ function mountIndeterminateComponent(_current, workInProgress, Component, renderExpirationTime) {
+ if (_current !== null) {
+ _current.alternate = null;
+ workInProgress.alternate = null;
+ workInProgress.effectTag |= Placement;
+ }
+
+ var props = workInProgress.pendingProps;
+ var unmaskedContext = getUnmaskedContext(workInProgress, Component, false);
+ var context = getMaskedContext(workInProgress, unmaskedContext);
+ prepareToReadContext(workInProgress, renderExpirationTime);
+ var value = void 0;
+ {
+ if (Component.prototype && typeof Component.prototype.render === "function") {
+ var componentName = getComponentName(Component) || "Unknown";
+
+ if (!didWarnAboutBadClass[componentName]) {
+ warningWithoutStack$1(false, "The <%s /> component appears to have a render method, but doesn't extend React.Component. " + "This is likely to cause errors. Change %s to extend React.Component instead.", componentName, componentName);
+ didWarnAboutBadClass[componentName] = true;
+ }
+ }
+
+ if (workInProgress.mode & StrictMode) {
+ ReactStrictModeWarnings.recordLegacyContextWarning(workInProgress, null);
+ }
+
+ ReactCurrentOwner$3.current = workInProgress;
+ value = renderWithHooks(null, workInProgress, Component, props, context, renderExpirationTime);
+ }
+ workInProgress.effectTag |= PerformedWork;
+
+ if (typeof value === "object" && value !== null && typeof value.render === "function" && value.$$typeof === undefined) {
+ workInProgress.tag = ClassComponent;
+ resetHooks();
+ var hasContext = false;
+
+ if (isContextProvider(Component)) {
+ hasContext = true;
+ pushContextProvider(workInProgress);
+ } else {
+ hasContext = false;
+ }
+
+ workInProgress.memoizedState = value.state !== null && value.state !== undefined ? value.state : null;
+ var getDerivedStateFromProps = Component.getDerivedStateFromProps;
+
+ if (typeof getDerivedStateFromProps === "function") {
+ applyDerivedStateFromProps(workInProgress, Component, getDerivedStateFromProps, props);
+ }
+
+ adoptClassInstance(workInProgress, value);
+ mountClassInstance(workInProgress, Component, props, renderExpirationTime);
+ return finishClassComponent(null, workInProgress, Component, true, hasContext, renderExpirationTime);
+ } else {
+ workInProgress.tag = FunctionComponent;
+ {
+ if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
+ if (workInProgress.memoizedState !== null) {
+ value = renderWithHooks(null, workInProgress, Component, props, context, renderExpirationTime);
+ }
+ }
+ }
+ reconcileChildren(null, workInProgress, value, renderExpirationTime);
+ {
+ validateFunctionComponentInDev(workInProgress, Component);
+ }
+ return workInProgress.child;
+ }
+ }
+
+ function validateFunctionComponentInDev(workInProgress, Component) {
+ if (Component) {
+ !!Component.childContextTypes ? warningWithoutStack$1(false, "%s(...): childContextTypes cannot be defined on a function component.", Component.displayName || Component.name || "Component") : void 0;
+ }
+
+ if (workInProgress.ref !== null) {
+ var info = "";
+ var ownerName = getCurrentFiberOwnerNameInDevOrNull();
+
+ if (ownerName) {
+ info += "\n\nCheck the render method of `" + ownerName + "`.";
+ }
+
+ var warningKey = ownerName || workInProgress._debugID || "";
+ var debugSource = workInProgress._debugSource;
+
+ if (debugSource) {
+ warningKey = debugSource.fileName + ":" + debugSource.lineNumber;
+ }
+
+ if (!didWarnAboutFunctionRefs[warningKey]) {
+ didWarnAboutFunctionRefs[warningKey] = true;
+ warning$1(false, "Function components cannot be given refs. " + "Attempts to access this ref will fail. " + "Did you mean to use React.forwardRef()?%s", info);
+ }
+ }
+
+ if (typeof Component.getDerivedStateFromProps === "function") {
+ var componentName = getComponentName(Component) || "Unknown";
+
+ if (!didWarnAboutGetDerivedStateOnFunctionComponent[componentName]) {
+ warningWithoutStack$1(false, "%s: Function components do not support getDerivedStateFromProps.", componentName);
+ didWarnAboutGetDerivedStateOnFunctionComponent[componentName] = true;
+ }
+ }
+
+ if (typeof Component.contextType === "object" && Component.contextType !== null) {
+ var _componentName = getComponentName(Component) || "Unknown";
+
+ if (!didWarnAboutContextTypeOnFunctionComponent[_componentName]) {
+ warningWithoutStack$1(false, "%s: Function components do not support contextType.", _componentName);
+ didWarnAboutContextTypeOnFunctionComponent[_componentName] = true;
+ }
+ }
+ }
+
+ function updateSuspenseComponent(current$$1, workInProgress, renderExpirationTime) {
+ var mode = workInProgress.mode;
+ var nextProps = workInProgress.pendingProps;
+ var nextState = workInProgress.memoizedState;
+ var nextDidTimeout = void 0;
+
+ if ((workInProgress.effectTag & DidCapture) === NoEffect) {
+ nextState = null;
+ nextDidTimeout = false;
+ } else {
+ nextState = {
+ timedOutAt: nextState !== null ? nextState.timedOutAt : NoWork
+ };
+ nextDidTimeout = true;
+ workInProgress.effectTag &= ~DidCapture;
+ }
+
+ var child = void 0;
+ var next = void 0;
+
+ if (current$$1 === null) {
+ if (enableSuspenseServerRenderer) {
+ if (nextProps.fallback !== undefined) {
+ tryToClaimNextHydratableInstance(workInProgress);
+
+ if (workInProgress.tag === DehydratedSuspenseComponent) {
+ return updateDehydratedSuspenseComponent(null, workInProgress, renderExpirationTime);
+ }
+ }
+ }
+
+ if (nextDidTimeout) {
+ var nextFallbackChildren = nextProps.fallback;
+ var primaryChildFragment = createFiberFromFragment(null, mode, NoWork, null);
+
+ if ((workInProgress.mode & ConcurrentMode) === NoContext) {
+ var progressedState = workInProgress.memoizedState;
+ var progressedPrimaryChild = progressedState !== null ? workInProgress.child.child : workInProgress.child;
+ primaryChildFragment.child = progressedPrimaryChild;
+ }
+
+ var fallbackChildFragment = createFiberFromFragment(nextFallbackChildren, mode, renderExpirationTime, null);
+ primaryChildFragment.sibling = fallbackChildFragment;
+ child = primaryChildFragment;
+ next = fallbackChildFragment;
+ child.return = next.return = workInProgress;
+ } else {
+ var nextPrimaryChildren = nextProps.children;
+ child = next = mountChildFibers(workInProgress, null, nextPrimaryChildren, renderExpirationTime);
+ }
+ } else {
+ var prevState = current$$1.memoizedState;
+ var prevDidTimeout = prevState !== null;
+
+ if (prevDidTimeout) {
+ var currentPrimaryChildFragment = current$$1.child;
+ var currentFallbackChildFragment = currentPrimaryChildFragment.sibling;
+
+ if (nextDidTimeout) {
+ var _nextFallbackChildren = nextProps.fallback;
+
+ var _primaryChildFragment = createWorkInProgress(currentPrimaryChildFragment, currentPrimaryChildFragment.pendingProps, NoWork);
+
+ if ((workInProgress.mode & ConcurrentMode) === NoContext) {
+ var _progressedState = workInProgress.memoizedState;
+
+ var _progressedPrimaryChild = _progressedState !== null ? workInProgress.child.child : workInProgress.child;
+
+ if (_progressedPrimaryChild !== currentPrimaryChildFragment.child) {
+ _primaryChildFragment.child = _progressedPrimaryChild;
+ }
+ }
+
+ if (enableProfilerTimer && workInProgress.mode & ProfileMode) {
+ var treeBaseDuration = 0;
+ var hiddenChild = _primaryChildFragment.child;
+
+ while (hiddenChild !== null) {
+ treeBaseDuration += hiddenChild.treeBaseDuration;
+ hiddenChild = hiddenChild.sibling;
+ }
+
+ _primaryChildFragment.treeBaseDuration = treeBaseDuration;
+ }
+
+ var _fallbackChildFragment = _primaryChildFragment.sibling = createWorkInProgress(currentFallbackChildFragment, _nextFallbackChildren, currentFallbackChildFragment.expirationTime);
+
+ child = _primaryChildFragment;
+ _primaryChildFragment.childExpirationTime = NoWork;
+ next = _fallbackChildFragment;
+ child.return = next.return = workInProgress;
+ } else {
+ var _nextPrimaryChildren = nextProps.children;
+ var currentPrimaryChild = currentPrimaryChildFragment.child;
+ var primaryChild = reconcileChildFibers(workInProgress, currentPrimaryChild, _nextPrimaryChildren, renderExpirationTime);
+ child = next = primaryChild;
+ }
+ } else {
+ var _currentPrimaryChild = current$$1.child;
+
+ if (nextDidTimeout) {
+ var _nextFallbackChildren2 = nextProps.fallback;
+
+ var _primaryChildFragment2 = createFiberFromFragment(null, mode, NoWork, null);
+
+ _primaryChildFragment2.child = _currentPrimaryChild;
+
+ if ((workInProgress.mode & ConcurrentMode) === NoContext) {
+ var _progressedState2 = workInProgress.memoizedState;
+
+ var _progressedPrimaryChild2 = _progressedState2 !== null ? workInProgress.child.child : workInProgress.child;
+
+ _primaryChildFragment2.child = _progressedPrimaryChild2;
+ }
+
+ if (enableProfilerTimer && workInProgress.mode & ProfileMode) {
+ var _treeBaseDuration = 0;
+ var _hiddenChild = _primaryChildFragment2.child;
+
+ while (_hiddenChild !== null) {
+ _treeBaseDuration += _hiddenChild.treeBaseDuration;
+ _hiddenChild = _hiddenChild.sibling;
+ }
+
+ _primaryChildFragment2.treeBaseDuration = _treeBaseDuration;
+ }
+
+ var _fallbackChildFragment2 = _primaryChildFragment2.sibling = createFiberFromFragment(_nextFallbackChildren2, mode, renderExpirationTime, null);
+
+ _fallbackChildFragment2.effectTag |= Placement;
+ child = _primaryChildFragment2;
+ _primaryChildFragment2.childExpirationTime = NoWork;
+ next = _fallbackChildFragment2;
+ child.return = next.return = workInProgress;
+ } else {
+ var _nextPrimaryChildren2 = nextProps.children;
+ next = child = reconcileChildFibers(workInProgress, _currentPrimaryChild, _nextPrimaryChildren2, renderExpirationTime);
+ }
+ }
+
+ workInProgress.stateNode = current$$1.stateNode;
+ }
+
+ workInProgress.memoizedState = nextState;
+ workInProgress.child = child;
+ return next;
+ }
+
+ function updateDehydratedSuspenseComponent(current$$1, workInProgress, renderExpirationTime) {
+ if (current$$1 === null) {
+ workInProgress.expirationTime = Never;
+ return null;
+ }
+
+ if ((workInProgress.effectTag & DidCapture) !== NoEffect) {
+ workInProgress.child = null;
+ return null;
+ }
+
+ var hasContextChanged$$1 = current$$1.childExpirationTime >= renderExpirationTime;
+ var suspenseInstance = current$$1.stateNode;
+
+ if (didReceiveUpdate || hasContextChanged$$1 || isSuspenseInstanceFallback(suspenseInstance)) {
+ current$$1.alternate = null;
+ workInProgress.alternate = null;
+ var returnFiber = workInProgress.return;
+ invariant(returnFiber !== null, "Suspense boundaries are never on the root. " + "This is probably a bug in React.");
+ var last = returnFiber.lastEffect;
+
+ if (last !== null) {
+ last.nextEffect = current$$1;
+ returnFiber.lastEffect = current$$1;
+ } else {
+ returnFiber.firstEffect = returnFiber.lastEffect = current$$1;
+ }
+
+ current$$1.nextEffect = null;
+ current$$1.effectTag = Deletion;
+ workInProgress.tag = SuspenseComponent;
+ workInProgress.stateNode = null;
+ workInProgress.memoizedState = null;
+ workInProgress.effectTag |= Placement;
+ return updateSuspenseComponent(null, workInProgress, renderExpirationTime);
+ } else if (isSuspenseInstancePending(suspenseInstance)) {
+ workInProgress.effectTag |= DidCapture;
+ workInProgress.child = null;
+ registerSuspenseInstanceRetry(suspenseInstance, retryTimedOutBoundary.bind(null, current$$1));
+ return null;
+ } else {
+ reenterHydrationStateFromDehydratedSuspenseInstance(workInProgress);
+ var nextProps = workInProgress.pendingProps;
+ var nextChildren = nextProps.children;
+ workInProgress.child = mountChildFibers(workInProgress, null, nextChildren, renderExpirationTime);
+ return workInProgress.child;
+ }
+ }
+
+ function updatePortalComponent(current$$1, workInProgress, renderExpirationTime) {
+ pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+ var nextChildren = workInProgress.pendingProps;
+
+ if (current$$1 === null) {
+ workInProgress.child = reconcileChildFibers(workInProgress, null, nextChildren, renderExpirationTime);
+ } else {
+ reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
+ }
+
+ return workInProgress.child;
+ }
+
+ function updateContextProvider(current$$1, workInProgress, renderExpirationTime) {
+ var providerType = workInProgress.type;
+ var context = providerType._context;
+ var newProps = workInProgress.pendingProps;
+ var oldProps = workInProgress.memoizedProps;
+ var newValue = newProps.value;
+ {
+ var providerPropTypes = workInProgress.type.propTypes;
+
+ if (providerPropTypes) {
+ checkPropTypes(providerPropTypes, newProps, "prop", "Context.Provider", getCurrentFiberStackInDev);
+ }
+ }
+ pushProvider(workInProgress, newValue);
+
+ if (oldProps !== null) {
+ var oldValue = oldProps.value;
+ var changedBits = calculateChangedBits(context, newValue, oldValue);
+
+ if (changedBits === 0) {
+ if (oldProps.children === newProps.children && !hasContextChanged()) {
+ return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ }
+ } else {
+ propagateContextChange(workInProgress, context, changedBits, renderExpirationTime);
+ }
+ }
+
+ var newChildren = newProps.children;
+ reconcileChildren(current$$1, workInProgress, newChildren, renderExpirationTime);
+ return workInProgress.child;
+ }
+
+ var hasWarnedAboutUsingContextAsConsumer = false;
+
+ function updateContextConsumer(current$$1, workInProgress, renderExpirationTime) {
+ var context = workInProgress.type;
+ {
+ if (context._context === undefined) {
+ if (context !== context.Consumer) {
+ if (!hasWarnedAboutUsingContextAsConsumer) {
+ hasWarnedAboutUsingContextAsConsumer = true;
+ warning$1(false, "Rendering directly is not supported and will be removed in " + "a future major release. Did you mean to render instead?");
+ }
+ }
+ } else {
+ context = context._context;
+ }
+ }
+ var newProps = workInProgress.pendingProps;
+ var render = newProps.children;
+ {
+ !(typeof render === "function") ? warningWithoutStack$1(false, "A context consumer was rendered with multiple children, or a child " + "that isn't a function. A context consumer expects a single child " + "that is a function. If you did pass a function, make sure there " + "is no trailing or leading whitespace around it.") : void 0;
+ }
+ prepareToReadContext(workInProgress, renderExpirationTime);
+
+ var newValue = _readContext(context, newProps.unstable_observedBits);
+
+ var newChildren = void 0;
+ {
+ ReactCurrentOwner$3.current = workInProgress;
+ setCurrentPhase("render");
+ newChildren = render(newValue);
+ setCurrentPhase(null);
+ }
+ workInProgress.effectTag |= PerformedWork;
+ reconcileChildren(current$$1, workInProgress, newChildren, renderExpirationTime);
+ return workInProgress.child;
+ }
+
+ function markWorkInProgressReceivedUpdate() {
+ didReceiveUpdate = true;
+ }
+
+ function bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime) {
+ cancelWorkTimer(workInProgress);
+
+ if (current$$1 !== null) {
+ workInProgress.contextDependencies = current$$1.contextDependencies;
+ }
+
+ if (enableProfilerTimer) {
+ stopProfilerTimerIfRunning(workInProgress);
+ }
+
+ var childExpirationTime = workInProgress.childExpirationTime;
+
+ if (childExpirationTime < renderExpirationTime) {
+ return null;
+ } else {
+ cloneChildFibers(current$$1, workInProgress);
+ return workInProgress.child;
+ }
+ }
+
+ function beginWork(current$$1, workInProgress, renderExpirationTime) {
+ var updateExpirationTime = workInProgress.expirationTime;
+
+ if (current$$1 !== null) {
+ var oldProps = current$$1.memoizedProps;
+ var newProps = workInProgress.pendingProps;
+
+ if (oldProps !== newProps || hasContextChanged()) {
+ didReceiveUpdate = true;
+ } else if (updateExpirationTime < renderExpirationTime) {
+ didReceiveUpdate = false;
+
+ switch (workInProgress.tag) {
+ case HostRoot:
+ pushHostRootContext(workInProgress);
+ resetHydrationState();
+ break;
+
+ case HostComponent:
+ pushHostContext(workInProgress);
+ break;
+
+ case ClassComponent:
+ {
+ var Component = workInProgress.type;
+
+ if (isContextProvider(Component)) {
+ pushContextProvider(workInProgress);
+ }
+
+ break;
+ }
+
+ case HostPortal:
+ pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+ break;
+
+ case ContextProvider:
+ {
+ var newValue = workInProgress.memoizedProps.value;
+ pushProvider(workInProgress, newValue);
+ break;
+ }
+
+ case Profiler:
+ if (enableProfilerTimer) {
+ workInProgress.effectTag |= Update;
+ }
+
+ break;
+
+ case SuspenseComponent:
+ {
+ var state = workInProgress.memoizedState;
+ var didTimeout = state !== null;
+
+ if (didTimeout) {
+ var primaryChildFragment = workInProgress.child;
+ var primaryChildExpirationTime = primaryChildFragment.childExpirationTime;
+
+ if (primaryChildExpirationTime !== NoWork && primaryChildExpirationTime >= renderExpirationTime) {
+ return updateSuspenseComponent(current$$1, workInProgress, renderExpirationTime);
+ } else {
+ var child = bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+
+ if (child !== null) {
+ return child.sibling;
+ } else {
+ return null;
+ }
+ }
+ }
+
+ break;
+ }
+
+ case DehydratedSuspenseComponent:
+ {
+ if (enableSuspenseServerRenderer) {
+ workInProgress.effectTag |= DidCapture;
+ break;
+ }
+ }
+ }
+
+ return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ }
+ } else {
+ didReceiveUpdate = false;
+ }
+
+ workInProgress.expirationTime = NoWork;
+
+ switch (workInProgress.tag) {
+ case IndeterminateComponent:
+ {
+ var elementType = workInProgress.elementType;
+ return mountIndeterminateComponent(current$$1, workInProgress, elementType, renderExpirationTime);
+ }
+
+ case LazyComponent:
+ {
+ var _elementType = workInProgress.elementType;
+ return mountLazyComponent(current$$1, workInProgress, _elementType, updateExpirationTime, renderExpirationTime);
+ }
+
+ case FunctionComponent:
+ {
+ var _Component = workInProgress.type;
+ var unresolvedProps = workInProgress.pendingProps;
+ var resolvedProps = workInProgress.elementType === _Component ? unresolvedProps : resolveDefaultProps(_Component, unresolvedProps);
+ return updateFunctionComponent(current$$1, workInProgress, _Component, resolvedProps, renderExpirationTime);
+ }
+
+ case ClassComponent:
+ {
+ var _Component2 = workInProgress.type;
+ var _unresolvedProps = workInProgress.pendingProps;
+
+ var _resolvedProps = workInProgress.elementType === _Component2 ? _unresolvedProps : resolveDefaultProps(_Component2, _unresolvedProps);
+
+ return updateClassComponent(current$$1, workInProgress, _Component2, _resolvedProps, renderExpirationTime);
+ }
+
+ case HostRoot:
+ return updateHostRoot(current$$1, workInProgress, renderExpirationTime);
+
+ case HostComponent:
+ return updateHostComponent(current$$1, workInProgress, renderExpirationTime);
+
+ case HostText:
+ return updateHostText(current$$1, workInProgress);
+
+ case SuspenseComponent:
+ return updateSuspenseComponent(current$$1, workInProgress, renderExpirationTime);
+
+ case HostPortal:
+ return updatePortalComponent(current$$1, workInProgress, renderExpirationTime);
+
+ case ForwardRef:
+ {
+ var type = workInProgress.type;
+ var _unresolvedProps2 = workInProgress.pendingProps;
+
+ var _resolvedProps2 = workInProgress.elementType === type ? _unresolvedProps2 : resolveDefaultProps(type, _unresolvedProps2);
+
+ return updateForwardRef(current$$1, workInProgress, type, _resolvedProps2, renderExpirationTime);
+ }
+
+ case Fragment:
+ return updateFragment(current$$1, workInProgress, renderExpirationTime);
+
+ case Mode:
+ return updateMode(current$$1, workInProgress, renderExpirationTime);
+
+ case Profiler:
+ return updateProfiler(current$$1, workInProgress, renderExpirationTime);
+
+ case ContextProvider:
+ return updateContextProvider(current$$1, workInProgress, renderExpirationTime);
+
+ case ContextConsumer:
+ return updateContextConsumer(current$$1, workInProgress, renderExpirationTime);
+
+ case MemoComponent:
+ {
+ var _type2 = workInProgress.type;
+ var _unresolvedProps3 = workInProgress.pendingProps;
+
+ var _resolvedProps3 = resolveDefaultProps(_type2, _unresolvedProps3);
+
+ {
+ if (workInProgress.type !== workInProgress.elementType) {
+ var outerPropTypes = _type2.propTypes;
+
+ if (outerPropTypes) {
+ checkPropTypes(outerPropTypes, _resolvedProps3, "prop", getComponentName(_type2), getCurrentFiberStackInDev);
+ }
+ }
+ }
+ _resolvedProps3 = resolveDefaultProps(_type2.type, _resolvedProps3);
+ return updateMemoComponent(current$$1, workInProgress, _type2, _resolvedProps3, updateExpirationTime, renderExpirationTime);
+ }
+
+ case SimpleMemoComponent:
+ {
+ return updateSimpleMemoComponent(current$$1, workInProgress, workInProgress.type, workInProgress.pendingProps, updateExpirationTime, renderExpirationTime);
+ }
+
+ case IncompleteClassComponent:
+ {
+ var _Component3 = workInProgress.type;
+ var _unresolvedProps4 = workInProgress.pendingProps;
+
+ var _resolvedProps4 = workInProgress.elementType === _Component3 ? _unresolvedProps4 : resolveDefaultProps(_Component3, _unresolvedProps4);
+
+ return mountIncompleteClassComponent(current$$1, workInProgress, _Component3, _resolvedProps4, renderExpirationTime);
+ }
+
+ case DehydratedSuspenseComponent:
+ {
+ if (enableSuspenseServerRenderer) {
+ return updateDehydratedSuspenseComponent(current$$1, workInProgress, renderExpirationTime);
+ }
+
+ break;
+ }
+ }
+
+ invariant(false, "Unknown unit of work tag. This error is likely caused by a bug in " + "React. Please file an issue.");
+ }
+
+ var valueCursor = createCursor(null);
+ var rendererSigil = void 0;
+ {
+ rendererSigil = {};
+ }
+ var currentlyRenderingFiber = null;
+ var lastContextDependency = null;
+ var lastContextWithAllBitsObserved = null;
+ var isDisallowedContextReadInDEV = false;
+
+ function resetContextDependences() {
+ currentlyRenderingFiber = null;
+ lastContextDependency = null;
+ lastContextWithAllBitsObserved = null;
+ {
+ isDisallowedContextReadInDEV = false;
+ }
+ }
+
+ function enterDisallowedContextReadInDEV() {
+ {
+ isDisallowedContextReadInDEV = true;
+ }
+ }
+
+ function exitDisallowedContextReadInDEV() {
+ {
+ isDisallowedContextReadInDEV = false;
+ }
+ }
+
+ function pushProvider(providerFiber, nextValue) {
+ var context = providerFiber.type._context;
+
+ if (isPrimaryRenderer) {
+ push(valueCursor, context._currentValue, providerFiber);
+ context._currentValue = nextValue;
+ {
+ !(context._currentRenderer === undefined || context._currentRenderer === null || context._currentRenderer === rendererSigil) ? warningWithoutStack$1(false, "Detected multiple renderers concurrently rendering the " + "same context provider. This is currently unsupported.") : void 0;
+ context._currentRenderer = rendererSigil;
+ }
+ } else {
+ push(valueCursor, context._currentValue2, providerFiber);
+ context._currentValue2 = nextValue;
+ {
+ !(context._currentRenderer2 === undefined || context._currentRenderer2 === null || context._currentRenderer2 === rendererSigil) ? warningWithoutStack$1(false, "Detected multiple renderers concurrently rendering the " + "same context provider. This is currently unsupported.") : void 0;
+ context._currentRenderer2 = rendererSigil;
+ }
+ }
+ }
+
+ function popProvider(providerFiber) {
+ var currentValue = valueCursor.current;
+ pop(valueCursor, providerFiber);
+ var context = providerFiber.type._context;
+
+ if (isPrimaryRenderer) {
+ context._currentValue = currentValue;
+ } else {
+ context._currentValue2 = currentValue;
+ }
+ }
+
+ function calculateChangedBits(context, newValue, oldValue) {
+ if (is(oldValue, newValue)) {
+ return 0;
+ } else {
+ var changedBits = typeof context._calculateChangedBits === "function" ? context._calculateChangedBits(oldValue, newValue) : maxSigned31BitInt;
+ {
+ !((changedBits & maxSigned31BitInt) === changedBits) ? warning$1(false, "calculateChangedBits: Expected the return value to be a " + "31-bit integer. Instead received: %s", changedBits) : void 0;
+ }
+ return changedBits | 0;
+ }
+ }
+
+ function scheduleWorkOnParentPath(parent, renderExpirationTime) {
+ var node = parent;
+
+ while (node !== null) {
+ var alternate = node.alternate;
+
+ if (node.childExpirationTime < renderExpirationTime) {
+ node.childExpirationTime = renderExpirationTime;
+
+ if (alternate !== null && alternate.childExpirationTime < renderExpirationTime) {
+ alternate.childExpirationTime = renderExpirationTime;
+ }
+ } else if (alternate !== null && alternate.childExpirationTime < renderExpirationTime) {
+ alternate.childExpirationTime = renderExpirationTime;
+ } else {
+ break;
+ }
+
+ node = node.return;
+ }
+ }
+
+ function propagateContextChange(workInProgress, context, changedBits, renderExpirationTime) {
+ var fiber = workInProgress.child;
+
+ if (fiber !== null) {
+ fiber.return = workInProgress;
+ }
+
+ while (fiber !== null) {
+ var nextFiber = void 0;
+ var list = fiber.contextDependencies;
+
+ if (list !== null) {
+ nextFiber = fiber.child;
+ var dependency = list.first;
+
+ while (dependency !== null) {
+ if (dependency.context === context && (dependency.observedBits & changedBits) !== 0) {
+ if (fiber.tag === ClassComponent) {
+ var update = createUpdate(renderExpirationTime);
+ update.tag = ForceUpdate;
+ enqueueUpdate(fiber, update);
+ }
+
+ if (fiber.expirationTime < renderExpirationTime) {
+ fiber.expirationTime = renderExpirationTime;
+ }
+
+ var alternate = fiber.alternate;
+
+ if (alternate !== null && alternate.expirationTime < renderExpirationTime) {
+ alternate.expirationTime = renderExpirationTime;
+ }
+
+ scheduleWorkOnParentPath(fiber.return, renderExpirationTime);
+
+ if (list.expirationTime < renderExpirationTime) {
+ list.expirationTime = renderExpirationTime;
+ }
+
+ break;
+ }
+
+ dependency = dependency.next;
+ }
+ } else if (fiber.tag === ContextProvider) {
+ nextFiber = fiber.type === workInProgress.type ? null : fiber.child;
+ } else if (enableSuspenseServerRenderer && fiber.tag === DehydratedSuspenseComponent) {
+ if (fiber.expirationTime < renderExpirationTime) {
+ fiber.expirationTime = renderExpirationTime;
+ }
+
+ var _alternate = fiber.alternate;
+
+ if (_alternate !== null && _alternate.expirationTime < renderExpirationTime) {
+ _alternate.expirationTime = renderExpirationTime;
+ }
+
+ scheduleWorkOnParentPath(fiber, renderExpirationTime);
+ nextFiber = fiber.sibling;
+ } else {
+ nextFiber = fiber.child;
+ }
+
+ if (nextFiber !== null) {
+ nextFiber.return = fiber;
+ } else {
+ nextFiber = fiber;
+
+ while (nextFiber !== null) {
+ if (nextFiber === workInProgress) {
+ nextFiber = null;
+ break;
+ }
+
+ var sibling = nextFiber.sibling;
+
+ if (sibling !== null) {
+ sibling.return = nextFiber.return;
+ nextFiber = sibling;
+ break;
+ }
+
+ nextFiber = nextFiber.return;
+ }
+ }
+
+ fiber = nextFiber;
+ }
+ }
+
+ function prepareToReadContext(workInProgress, renderExpirationTime) {
+ currentlyRenderingFiber = workInProgress;
+ lastContextDependency = null;
+ lastContextWithAllBitsObserved = null;
+ var currentDependencies = workInProgress.contextDependencies;
+
+ if (currentDependencies !== null && currentDependencies.expirationTime >= renderExpirationTime) {
+ markWorkInProgressReceivedUpdate();
+ }
+
+ workInProgress.contextDependencies = null;
+ }
+
+ function _readContext(context, observedBits) {
+ {
+ !!isDisallowedContextReadInDEV ? warning$1(false, "Context can only be read while React is rendering. " + "In classes, you can read it in the render method or getDerivedStateFromProps. " + "In function components, you can read it directly in the function body, but not " + "inside Hooks like useReducer() or useMemo().") : void 0;
+ }
+
+ if (lastContextWithAllBitsObserved === context) {} else if (observedBits === false || observedBits === 0) {} else {
+ var resolvedObservedBits = void 0;
+
+ if (typeof observedBits !== "number" || observedBits === maxSigned31BitInt) {
+ lastContextWithAllBitsObserved = context;
+ resolvedObservedBits = maxSigned31BitInt;
+ } else {
+ resolvedObservedBits = observedBits;
+ }
+
+ var contextItem = {
+ context: context,
+ observedBits: resolvedObservedBits,
+ next: null
+ };
+
+ if (lastContextDependency === null) {
+ invariant(currentlyRenderingFiber !== null, "Context can only be read while React is rendering. " + "In classes, you can read it in the render method or getDerivedStateFromProps. " + "In function components, you can read it directly in the function body, but not " + "inside Hooks like useReducer() or useMemo().");
+ lastContextDependency = contextItem;
+ currentlyRenderingFiber.contextDependencies = {
+ first: contextItem,
+ expirationTime: NoWork
+ };
+ } else {
+ lastContextDependency = lastContextDependency.next = contextItem;
+ }
+ }
+
+ return isPrimaryRenderer ? context._currentValue : context._currentValue2;
+ }
+
+ var UpdateState = 0;
+ var ReplaceState = 1;
+ var ForceUpdate = 2;
+ var CaptureUpdate = 3;
+ var hasForceUpdate = false;
+ var didWarnUpdateInsideUpdate = void 0;
+ var currentlyProcessingQueue = void 0;
+ var resetCurrentlyProcessingQueue = void 0;
+ {
+ didWarnUpdateInsideUpdate = false;
+ currentlyProcessingQueue = null;
+
+ resetCurrentlyProcessingQueue = function resetCurrentlyProcessingQueue() {
+ currentlyProcessingQueue = null;
+ };
+ }
+
+ function createUpdateQueue(baseState) {
+ var queue = {
+ baseState: baseState,
+ firstUpdate: null,
+ lastUpdate: null,
+ firstCapturedUpdate: null,
+ lastCapturedUpdate: null,
+ firstEffect: null,
+ lastEffect: null,
+ firstCapturedEffect: null,
+ lastCapturedEffect: null
+ };
+ return queue;
+ }
+
+ function cloneUpdateQueue(currentQueue) {
+ var queue = {
+ baseState: currentQueue.baseState,
+ firstUpdate: currentQueue.firstUpdate,
+ lastUpdate: currentQueue.lastUpdate,
+ firstCapturedUpdate: null,
+ lastCapturedUpdate: null,
+ firstEffect: null,
+ lastEffect: null,
+ firstCapturedEffect: null,
+ lastCapturedEffect: null
+ };
+ return queue;
+ }
+
+ function createUpdate(expirationTime) {
+ return {
+ expirationTime: expirationTime,
+ tag: UpdateState,
+ payload: null,
+ callback: null,
+ next: null,
+ nextEffect: null
+ };
+ }
+
+ function appendUpdateToQueue(queue, update) {
+ if (queue.lastUpdate === null) {
+ queue.firstUpdate = queue.lastUpdate = update;
+ } else {
+ queue.lastUpdate.next = update;
+ queue.lastUpdate = update;
+ }
+ }
+
+ function enqueueUpdate(fiber, update) {
+ var alternate = fiber.alternate;
+ var queue1 = void 0;
+ var queue2 = void 0;
+
+ if (alternate === null) {
+ queue1 = fiber.updateQueue;
+ queue2 = null;
+
+ if (queue1 === null) {
+ queue1 = fiber.updateQueue = createUpdateQueue(fiber.memoizedState);
+ }
+ } else {
+ queue1 = fiber.updateQueue;
+ queue2 = alternate.updateQueue;
+
+ if (queue1 === null) {
+ if (queue2 === null) {
+ queue1 = fiber.updateQueue = createUpdateQueue(fiber.memoizedState);
+ queue2 = alternate.updateQueue = createUpdateQueue(alternate.memoizedState);
+ } else {
+ queue1 = fiber.updateQueue = cloneUpdateQueue(queue2);
+ }
+ } else {
+ if (queue2 === null) {
+ queue2 = alternate.updateQueue = cloneUpdateQueue(queue1);
+ } else {}
+ }
+ }
+
+ if (queue2 === null || queue1 === queue2) {
+ appendUpdateToQueue(queue1, update);
+ } else {
+ if (queue1.lastUpdate === null || queue2.lastUpdate === null) {
+ appendUpdateToQueue(queue1, update);
+ appendUpdateToQueue(queue2, update);
+ } else {
+ appendUpdateToQueue(queue1, update);
+ queue2.lastUpdate = update;
+ }
+ }
+
+ {
+ if (fiber.tag === ClassComponent && (currentlyProcessingQueue === queue1 || queue2 !== null && currentlyProcessingQueue === queue2) && !didWarnUpdateInsideUpdate) {
+ warningWithoutStack$1(false, "An update (setState, replaceState, or forceUpdate) was scheduled " + "from inside an update function. Update functions should be pure, " + "with zero side-effects. Consider using componentDidUpdate or a " + "callback.");
+ didWarnUpdateInsideUpdate = true;
+ }
+ }
+ }
+
+ function enqueueCapturedUpdate(workInProgress, update) {
+ var workInProgressQueue = workInProgress.updateQueue;
+
+ if (workInProgressQueue === null) {
+ workInProgressQueue = workInProgress.updateQueue = createUpdateQueue(workInProgress.memoizedState);
+ } else {
+ workInProgressQueue = ensureWorkInProgressQueueIsAClone(workInProgress, workInProgressQueue);
+ }
+
+ if (workInProgressQueue.lastCapturedUpdate === null) {
+ workInProgressQueue.firstCapturedUpdate = workInProgressQueue.lastCapturedUpdate = update;
+ } else {
+ workInProgressQueue.lastCapturedUpdate.next = update;
+ workInProgressQueue.lastCapturedUpdate = update;
+ }
+ }
+
+ function ensureWorkInProgressQueueIsAClone(workInProgress, queue) {
+ var current = workInProgress.alternate;
+
+ if (current !== null) {
+ if (queue === current.updateQueue) {
+ queue = workInProgress.updateQueue = cloneUpdateQueue(queue);
+ }
+ }
+
+ return queue;
+ }
+
+ function getStateFromUpdate(workInProgress, queue, update, prevState, nextProps, instance) {
+ switch (update.tag) {
+ case ReplaceState:
+ {
+ var _payload = update.payload;
+
+ if (typeof _payload === "function") {
+ {
+ enterDisallowedContextReadInDEV();
+
+ if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
+ _payload.call(instance, prevState, nextProps);
+ }
+ }
+
+ var nextState = _payload.call(instance, prevState, nextProps);
+
+ {
+ exitDisallowedContextReadInDEV();
+ }
+ return nextState;
+ }
+
+ return _payload;
+ }
+
+ case CaptureUpdate:
+ {
+ workInProgress.effectTag = workInProgress.effectTag & ~ShouldCapture | DidCapture;
+ }
+
+ case UpdateState:
+ {
+ var _payload2 = update.payload;
+ var partialState = void 0;
+
+ if (typeof _payload2 === "function") {
+ {
+ enterDisallowedContextReadInDEV();
+
+ if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
+ _payload2.call(instance, prevState, nextProps);
+ }
+ }
+ partialState = _payload2.call(instance, prevState, nextProps);
+ {
+ exitDisallowedContextReadInDEV();
+ }
+ } else {
+ partialState = _payload2;
+ }
+
+ if (partialState === null || partialState === undefined) {
+ return prevState;
+ }
+
+ return _extends({}, prevState, partialState);
+ }
+
+ case ForceUpdate:
+ {
+ hasForceUpdate = true;
+ return prevState;
+ }
+ }
+
+ return prevState;
+ }
+
+ function processUpdateQueue(workInProgress, queue, props, instance, renderExpirationTime) {
+ hasForceUpdate = false;
+ queue = ensureWorkInProgressQueueIsAClone(workInProgress, queue);
+ {
+ currentlyProcessingQueue = queue;
+ }
+ var newBaseState = queue.baseState;
+ var newFirstUpdate = null;
+ var newExpirationTime = NoWork;
+ var update = queue.firstUpdate;
+ var resultState = newBaseState;
+
+ while (update !== null) {
+ var updateExpirationTime = update.expirationTime;
+
+ if (updateExpirationTime < renderExpirationTime) {
+ if (newFirstUpdate === null) {
+ newFirstUpdate = update;
+ newBaseState = resultState;
+ }
+
+ if (newExpirationTime < updateExpirationTime) {
+ newExpirationTime = updateExpirationTime;
+ }
+ } else {
+ resultState = getStateFromUpdate(workInProgress, queue, update, resultState, props, instance);
+ var _callback = update.callback;
+
+ if (_callback !== null) {
+ workInProgress.effectTag |= Callback;
+ update.nextEffect = null;
+
+ if (queue.lastEffect === null) {
+ queue.firstEffect = queue.lastEffect = update;
+ } else {
+ queue.lastEffect.nextEffect = update;
+ queue.lastEffect = update;
+ }
+ }
+ }
+
+ update = update.next;
+ }
+
+ var newFirstCapturedUpdate = null;
+ update = queue.firstCapturedUpdate;
+
+ while (update !== null) {
+ var _updateExpirationTime = update.expirationTime;
+
+ if (_updateExpirationTime < renderExpirationTime) {
+ if (newFirstCapturedUpdate === null) {
+ newFirstCapturedUpdate = update;
+
+ if (newFirstUpdate === null) {
+ newBaseState = resultState;
+ }
+ }
+
+ if (newExpirationTime < _updateExpirationTime) {
+ newExpirationTime = _updateExpirationTime;
+ }
+ } else {
+ resultState = getStateFromUpdate(workInProgress, queue, update, resultState, props, instance);
+ var _callback2 = update.callback;
+
+ if (_callback2 !== null) {
+ workInProgress.effectTag |= Callback;
+ update.nextEffect = null;
+
+ if (queue.lastCapturedEffect === null) {
+ queue.firstCapturedEffect = queue.lastCapturedEffect = update;
+ } else {
+ queue.lastCapturedEffect.nextEffect = update;
+ queue.lastCapturedEffect = update;
+ }
+ }
+ }
+
+ update = update.next;
+ }
+
+ if (newFirstUpdate === null) {
+ queue.lastUpdate = null;
+ }
+
+ if (newFirstCapturedUpdate === null) {
+ queue.lastCapturedUpdate = null;
+ } else {
+ workInProgress.effectTag |= Callback;
+ }
+
+ if (newFirstUpdate === null && newFirstCapturedUpdate === null) {
+ newBaseState = resultState;
+ }
+
+ queue.baseState = newBaseState;
+ queue.firstUpdate = newFirstUpdate;
+ queue.firstCapturedUpdate = newFirstCapturedUpdate;
+ workInProgress.expirationTime = newExpirationTime;
+ workInProgress.memoizedState = resultState;
+ {
+ currentlyProcessingQueue = null;
+ }
+ }
+
+ function callCallback(callback, context) {
+ 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;
+ }
+
+ commitUpdateEffects(finishedQueue.firstEffect, instance);
+ finishedQueue.firstEffect = finishedQueue.lastEffect = null;
+ commitUpdateEffects(finishedQueue.firstCapturedEffect, instance);
+ finishedQueue.firstCapturedEffect = finishedQueue.lastCapturedEffect = null;
+ }
+
+ function commitUpdateEffects(effect, instance) {
+ while (effect !== null) {
+ var _callback3 = effect.callback;
+
+ if (_callback3 !== null) {
+ effect.callback = null;
+ callCallback(_callback3, instance);
+ }
+
+ effect = effect.nextEffect;
+ }
+ }
+
+ function createCapturedValue(value, source) {
+ return {
+ value: value,
+ source: source,
+ stack: getStackByFiberInDevAndProd(source)
+ };
+ }
+
+ function markUpdate(workInProgress) {
+ workInProgress.effectTag |= Update;
+ }
+
+ function markRef$1(workInProgress) {
+ workInProgress.effectTag |= Ref;
+ }
+
+ var _appendAllChildren = void 0;
+
+ var updateHostContainer = void 0;
+ var updateHostComponent$1 = void 0;
+ var updateHostText$1 = void 0;
+
+ if (supportsMutation) {
+ _appendAllChildren = function appendAllChildren(parent, workInProgress, needsVisibilityToggle, isHidden) {
+ var node = workInProgress.child;
+
+ while (node !== null) {
+ if (node.tag === HostComponent || node.tag === HostText) {
+ appendInitialChild(parent, node.stateNode);
+ } else if (node.tag === HostPortal) {} else if (node.child !== null) {
+ node.child.return = node;
+ node = node.child;
+ continue;
+ }
+
+ if (node === workInProgress) {
+ return;
+ }
+
+ while (node.sibling === null) {
+ if (node.return === null || node.return === workInProgress) {
+ return;
+ }
+
+ node = node.return;
+ }
+
+ node.sibling.return = node.return;
+ node = node.sibling;
+ }
+ };
+
+ updateHostContainer = function updateHostContainer(workInProgress) {};
+
+ updateHostComponent$1 = function updateHostComponent$1(current, workInProgress, type, newProps, rootContainerInstance) {
+ var oldProps = current.memoizedProps;
+
+ if (oldProps === newProps) {
+ return;
+ }
+
+ var instance = workInProgress.stateNode;
+ var currentHostContext = getHostContext();
+ var updatePayload = prepareUpdate(instance, type, oldProps, newProps, rootContainerInstance, currentHostContext);
+ workInProgress.updateQueue = updatePayload;
+
+ if (updatePayload) {
+ markUpdate(workInProgress);
+ }
+ };
+
+ updateHostText$1 = function updateHostText$1(current, workInProgress, oldText, newText) {
+ if (oldText !== newText) {
+ markUpdate(workInProgress);
+ }
+ };
+ } else if (supportsPersistence) {
+ _appendAllChildren = function appendAllChildren(parent, workInProgress, needsVisibilityToggle, isHidden) {
+ var node = workInProgress.child;
+
+ while (node !== null) {
+ branches: if (node.tag === HostComponent) {
+ var instance = node.stateNode;
+
+ if (needsVisibilityToggle) {
+ var props = node.memoizedProps;
+ var type = node.type;
+
+ if (isHidden) {
+ instance = cloneHiddenInstance(instance, type, props, node);
+ } else {
+ instance = cloneUnhiddenInstance(instance, type, props, node);
+ }
+
+ node.stateNode = instance;
+ }
+
+ appendInitialChild(parent, instance);
+ } else if (node.tag === HostText) {
+ var _instance = node.stateNode;
+
+ if (needsVisibilityToggle) {
+ var text = node.memoizedProps;
+ var rootContainerInstance = getRootHostContainer();
+ var currentHostContext = getHostContext();
+
+ if (isHidden) {
+ _instance = createHiddenTextInstance(text, rootContainerInstance, currentHostContext, workInProgress);
+ } else {
+ _instance = createTextInstance(text, rootContainerInstance, currentHostContext, workInProgress);
+ }
+
+ node.stateNode = _instance;
+ }
+
+ appendInitialChild(parent, _instance);
+ } else if (node.tag === HostPortal) {} else if (node.tag === SuspenseComponent) {
+ var current = node.alternate;
+
+ if (current !== null) {
+ var oldState = current.memoizedState;
+ var newState = node.memoizedState;
+ var oldIsHidden = oldState !== null;
+ var newIsHidden = newState !== null;
+
+ if (oldIsHidden !== newIsHidden) {
+ var primaryChildParent = newIsHidden ? node.child : node;
+
+ if (primaryChildParent !== null) {
+ _appendAllChildren(parent, primaryChildParent, true, newIsHidden);
+ }
+
+ break branches;
+ }
+ }
+
+ if (node.child !== null) {
+ node.child.return = node;
+ node = node.child;
+ continue;
+ }
+ } else if (node.child !== null) {
+ node.child.return = node;
+ node = node.child;
+ continue;
+ }
+
+ node = node;
+
+ if (node === workInProgress) {
+ return;
+ }
+
+ while (node.sibling === null) {
+ if (node.return === null || node.return === workInProgress) {
+ return;
+ }
+
+ node = node.return;
+ }
+
+ node.sibling.return = node.return;
+ node = node.sibling;
+ }
+ };
+
+ var appendAllChildrenToContainer = function appendAllChildrenToContainer(containerChildSet, workInProgress, needsVisibilityToggle, isHidden) {
+ var node = workInProgress.child;
+
+ while (node !== null) {
+ branches: if (node.tag === HostComponent) {
+ var instance = node.stateNode;
+
+ if (needsVisibilityToggle) {
+ var props = node.memoizedProps;
+ var type = node.type;
+
+ if (isHidden) {
+ instance = cloneHiddenInstance(instance, type, props, node);
+ } else {
+ instance = cloneUnhiddenInstance(instance, type, props, node);
+ }
+
+ node.stateNode = instance;
+ }
+
+ appendChildToContainerChildSet(containerChildSet, instance);
+ } else if (node.tag === HostText) {
+ var _instance2 = node.stateNode;
+
+ if (needsVisibilityToggle) {
+ var text = node.memoizedProps;
+ var rootContainerInstance = getRootHostContainer();
+ var currentHostContext = getHostContext();
+
+ if (isHidden) {
+ _instance2 = createHiddenTextInstance(text, rootContainerInstance, currentHostContext, workInProgress);
+ } else {
+ _instance2 = createTextInstance(text, rootContainerInstance, currentHostContext, workInProgress);
+ }
+
+ node.stateNode = _instance2;
+ }
+
+ appendChildToContainerChildSet(containerChildSet, _instance2);
+ } else if (node.tag === HostPortal) {} else if (node.tag === SuspenseComponent) {
+ var current = node.alternate;
+
+ if (current !== null) {
+ var oldState = current.memoizedState;
+ var newState = node.memoizedState;
+ var oldIsHidden = oldState !== null;
+ var newIsHidden = newState !== null;
+
+ if (oldIsHidden !== newIsHidden) {
+ var primaryChildParent = newIsHidden ? node.child : node;
+
+ if (primaryChildParent !== null) {
+ appendAllChildrenToContainer(containerChildSet, primaryChildParent, true, newIsHidden);
+ }
+
+ break branches;
+ }
+ }
+
+ if (node.child !== null) {
+ node.child.return = node;
+ node = node.child;
+ continue;
+ }
+ } else if (node.child !== null) {
+ node.child.return = node;
+ node = node.child;
+ continue;
+ }
+
+ node = node;
+
+ if (node === workInProgress) {
+ return;
+ }
+
+ while (node.sibling === null) {
+ if (node.return === null || node.return === workInProgress) {
+ return;
+ }
+
+ node = node.return;
+ }
+
+ node.sibling.return = node.return;
+ node = node.sibling;
+ }
+ };
+
+ updateHostContainer = function updateHostContainer(workInProgress) {
+ var portalOrRoot = workInProgress.stateNode;
+ var childrenUnchanged = workInProgress.firstEffect === null;
+
+ if (childrenUnchanged) {} else {
+ var container = portalOrRoot.containerInfo;
+ var newChildSet = createContainerChildSet(container);
+ appendAllChildrenToContainer(newChildSet, workInProgress, false, false);
+ portalOrRoot.pendingChildren = newChildSet;
+ markUpdate(workInProgress);
+ finalizeContainerChildren(container, newChildSet);
+ }
+ };
+
+ updateHostComponent$1 = function updateHostComponent$1(current, workInProgress, type, newProps, rootContainerInstance) {
+ var currentInstance = current.stateNode;
+ var oldProps = current.memoizedProps;
+ var childrenUnchanged = workInProgress.firstEffect === null;
+
+ if (childrenUnchanged && oldProps === newProps) {
+ workInProgress.stateNode = currentInstance;
+ return;
+ }
+
+ var recyclableInstance = workInProgress.stateNode;
+ var currentHostContext = getHostContext();
+ var updatePayload = null;
+
+ if (oldProps !== newProps) {
+ updatePayload = prepareUpdate(recyclableInstance, type, oldProps, newProps, rootContainerInstance, currentHostContext);
+ }
+
+ if (childrenUnchanged && updatePayload === null) {
+ workInProgress.stateNode = currentInstance;
+ return;
+ }
+
+ var newInstance = cloneInstance(currentInstance, updatePayload, type, oldProps, newProps, workInProgress, childrenUnchanged, recyclableInstance);
+
+ if (finalizeInitialChildren(newInstance, type, newProps, rootContainerInstance, currentHostContext)) {
+ markUpdate(workInProgress);
+ }
+
+ workInProgress.stateNode = newInstance;
+
+ if (childrenUnchanged) {
+ markUpdate(workInProgress);
+ } else {
+ _appendAllChildren(newInstance, workInProgress, false, false);
+ }
+ };
+
+ updateHostText$1 = function updateHostText$1(current, workInProgress, oldText, newText) {
+ if (oldText !== newText) {
+ var rootContainerInstance = getRootHostContainer();
+ var currentHostContext = getHostContext();
+ workInProgress.stateNode = createTextInstance(newText, rootContainerInstance, currentHostContext, workInProgress);
+ markUpdate(workInProgress);
+ }
+ };
+ } else {
+ updateHostContainer = function updateHostContainer(workInProgress) {};
+
+ updateHostComponent$1 = function updateHostComponent$1(current, workInProgress, type, newProps, rootContainerInstance) {};
+
+ updateHostText$1 = function updateHostText$1(current, workInProgress, oldText, newText) {};
+ }
+
+ function completeWork(current, workInProgress, renderExpirationTime) {
+ var newProps = workInProgress.pendingProps;
+
+ switch (workInProgress.tag) {
+ case IndeterminateComponent:
+ break;
+
+ case LazyComponent:
+ break;
+
+ case SimpleMemoComponent:
+ case FunctionComponent:
+ break;
+
+ case ClassComponent:
+ {
+ var Component = workInProgress.type;
+
+ if (isContextProvider(Component)) {
+ popContext(workInProgress);
+ }
+
+ break;
+ }
+
+ case HostRoot:
+ {
+ popHostContainer(workInProgress);
+ popTopLevelContextObject(workInProgress);
+ var fiberRoot = workInProgress.stateNode;
+
+ if (fiberRoot.pendingContext) {
+ fiberRoot.context = fiberRoot.pendingContext;
+ fiberRoot.pendingContext = null;
+ }
+
+ if (current === null || current.child === null) {
+ popHydrationState(workInProgress);
+ workInProgress.effectTag &= ~Placement;
+ }
+
+ updateHostContainer(workInProgress);
+ break;
+ }
+
+ case HostComponent:
+ {
+ popHostContext(workInProgress);
+ var rootContainerInstance = getRootHostContainer();
+ var type = workInProgress.type;
+
+ if (current !== null && workInProgress.stateNode != null) {
+ updateHostComponent$1(current, workInProgress, type, newProps, rootContainerInstance);
+
+ if (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.");
+ break;
+ }
+
+ 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, false, false);
+
+ if (finalizeInitialChildren(instance, type, newProps, rootContainerInstance, currentHostContext)) {
+ markUpdate(workInProgress);
+ }
+
+ workInProgress.stateNode = instance;
+ }
+
+ if (workInProgress.ref !== null) {
+ markRef$1(workInProgress);
+ }
+ }
+
+ break;
+ }
+
+ case HostText:
+ {
+ var newText = newProps;
+
+ if (current && workInProgress.stateNode != null) {
+ var oldText = current.memoizedProps;
+ updateHostText$1(current, workInProgress, oldText, newText);
+ } else {
+ if (typeof newText !== "string") {
+ 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.");
+ }
+
+ var _rootContainerInstance = getRootHostContainer();
+
+ var _currentHostContext = getHostContext();
+
+ var _wasHydrated = popHydrationState(workInProgress);
+
+ if (_wasHydrated) {
+ if (prepareToHydrateHostTextInstance(workInProgress)) {
+ markUpdate(workInProgress);
+ }
+ } else {
+ workInProgress.stateNode = createTextInstance(newText, _rootContainerInstance, _currentHostContext, workInProgress);
+ }
+ }
+
+ break;
+ }
+
+ case ForwardRef:
+ break;
+
+ case SuspenseComponent:
+ {
+ var nextState = workInProgress.memoizedState;
+
+ if ((workInProgress.effectTag & DidCapture) !== NoEffect) {
+ workInProgress.expirationTime = renderExpirationTime;
+ return workInProgress;
+ }
+
+ var nextDidTimeout = nextState !== null;
+ var prevDidTimeout = current !== null && current.memoizedState !== null;
+
+ if (current === null) {
+ popHydrationState(workInProgress);
+ } else if (!nextDidTimeout && prevDidTimeout) {
+ var currentFallbackChild = current.child.sibling;
+
+ if (currentFallbackChild !== null) {
+ var first = workInProgress.firstEffect;
+
+ if (first !== null) {
+ workInProgress.firstEffect = currentFallbackChild;
+ currentFallbackChild.nextEffect = first;
+ } else {
+ workInProgress.firstEffect = workInProgress.lastEffect = currentFallbackChild;
+ currentFallbackChild.nextEffect = null;
+ }
+
+ currentFallbackChild.effectTag = Deletion;
+ }
+ }
+
+ if (nextDidTimeout || prevDidTimeout) {
+ workInProgress.effectTag |= Update;
+ }
+
+ break;
+ }
+
+ case Fragment:
+ break;
+
+ case Mode:
+ break;
+
+ case Profiler:
+ break;
+
+ case HostPortal:
+ popHostContainer(workInProgress);
+ updateHostContainer(workInProgress);
+ break;
+
+ case ContextProvider:
+ popProvider(workInProgress);
+ break;
+
+ case ContextConsumer:
+ break;
+
+ case MemoComponent:
+ break;
+
+ case IncompleteClassComponent:
+ {
+ var _Component = workInProgress.type;
+
+ if (isContextProvider(_Component)) {
+ popContext(workInProgress);
+ }
+
+ break;
+ }
+
+ case DehydratedSuspenseComponent:
+ {
+ if (enableSuspenseServerRenderer) {
+ if (current === null) {
+ var _wasHydrated2 = popHydrationState(workInProgress);
+
+ invariant(_wasHydrated2, "A dehydrated suspense component was completed without a hydrated node. " + "This is probably a bug in React.");
+ skipPastDehydratedSuspenseInstance(workInProgress);
+ } else if ((workInProgress.effectTag & DidCapture) === NoEffect) {
+ current.alternate = null;
+ workInProgress.alternate = null;
+ workInProgress.tag = SuspenseComponent;
+ workInProgress.memoizedState = null;
+ workInProgress.stateNode = null;
+ }
+ }
+
+ break;
+ }
+
+ default:
+ invariant(false, "Unknown unit of work tag. This error is likely caused by a bug in " + "React. Please file an issue.");
+ }
+
+ return null;
+ }
+
+ function shouldCaptureSuspense(workInProgress) {
+ if (workInProgress.memoizedProps.fallback === undefined) {
+ return false;
+ }
+
+ var nextState = workInProgress.memoizedState;
+ return nextState === null;
+ }
+
+ 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 componentName = capturedError.componentName,
+ componentStack = capturedError.componentStack,
+ errorBoundaryName = capturedError.errorBoundaryName,
+ errorBoundaryFound = capturedError.errorBoundaryFound,
+ willRetry = capturedError.willRetry;
+
+ if (error != null && error._suppressLogging) {
+ if (errorBoundaryFound && willRetry) {
+ return;
+ }
+
+ console.error(error);
+ }
+
+ var componentNameMessage = componentName ? "The above error occurred in the <" + componentName + "> component:" : "The above error occurred in one of your React components:";
+ var errorBoundaryMessage = void 0;
+
+ if (errorBoundaryFound && errorBoundaryName) {
+ if (willRetry) {
+ errorBoundaryMessage = "React will try to recreate this component tree from scratch " + ("using the error boundary you provided, " + errorBoundaryName + ".");
+ } else {
+ errorBoundaryMessage = "This error was initially handled by the error boundary " + errorBoundaryName + ".\n" + "Recreating the tree from scratch failed so React will unmount the tree.";
+ }
+ } else {
+ errorBoundaryMessage = "Consider adding an error boundary to your tree to customize error handling behavior.\n" + "Visit https://fb.me/react-error-boundaries to learn more about error boundaries.";
+ }
+
+ var combinedMessage = "" + componentNameMessage + componentStack + "\n\n" + ("" + errorBoundaryMessage);
+ console.error(combinedMessage);
+ }
+ }
+
+ var didWarnAboutUndefinedSnapshotBeforeUpdate = null;
+ {
+ didWarnAboutUndefinedSnapshotBeforeUpdate = new Set();
+ }
+ var PossiblyWeakSet$1 = typeof WeakSet === "function" ? WeakSet : Set;
+
+ function logError(boundary, errorInfo) {
+ var source = errorInfo.source;
+ var stack = errorInfo.stack;
+
+ if (stack === null && source !== null) {
+ stack = getStackByFiberInDevAndProd(source);
+ }
+
+ var capturedError = {
+ componentName: source !== null ? getComponentName(source.type) : null,
+ componentStack: stack !== null ? stack : "",
+ error: errorInfo.value,
+ errorBoundary: null,
+ errorBoundaryName: null,
+ errorBoundaryFound: false,
+ willRetry: false
+ };
+
+ if (boundary !== null && boundary.tag === ClassComponent) {
+ capturedError.errorBoundary = boundary.stateNode;
+ capturedError.errorBoundaryName = getComponentName(boundary.type);
+ capturedError.errorBoundaryFound = true;
+ capturedError.willRetry = true;
+ }
+
+ try {
+ logCapturedError(capturedError);
+ } catch (e) {
+ setTimeout(function () {
+ throw e;
+ });
+ }
+ }
+
+ var callComponentWillUnmountWithTimer = function callComponentWillUnmountWithTimer(current$$1, instance) {
+ startPhaseTimer(current$$1, "componentWillUnmount");
+ instance.props = current$$1.memoizedProps;
+ instance.state = current$$1.memoizedState;
+ instance.componentWillUnmount();
+ stopPhaseTimer();
+ };
+
+ function safelyCallComponentWillUnmount(current$$1, instance) {
+ {
+ invokeGuardedCallback(null, callComponentWillUnmountWithTimer, null, current$$1, instance);
+
+ if (hasCaughtError()) {
+ var unmountError = clearCaughtError();
+ captureCommitPhaseError(current$$1, unmountError);
+ }
+ }
+ }
+
+ function safelyDetachRef(current$$1) {
+ var ref = current$$1.ref;
+
+ if (ref !== null) {
+ if (typeof ref === "function") {
+ {
+ invokeGuardedCallback(null, ref, null, null);
+
+ if (hasCaughtError()) {
+ var refError = clearCaughtError();
+ captureCommitPhaseError(current$$1, refError);
+ }
+ }
+ } else {
+ ref.current = null;
+ }
+ }
+ }
+
+ function safelyCallDestroy(current$$1, destroy) {
+ {
+ invokeGuardedCallback(null, destroy, null);
+
+ if (hasCaughtError()) {
+ var error = clearCaughtError();
+ captureCommitPhaseError(current$$1, error);
+ }
+ }
+ }
+
+ function commitBeforeMutationLifeCycles(current$$1, finishedWork) {
+ switch (finishedWork.tag) {
+ case FunctionComponent:
+ case ForwardRef:
+ case SimpleMemoComponent:
+ {
+ commitHookEffectList(UnmountSnapshot, NoEffect$1, finishedWork);
+ return;
+ }
+
+ case ClassComponent:
+ {
+ if (finishedWork.effectTag & Snapshot) {
+ if (current$$1 !== null) {
+ var prevProps = current$$1.memoizedProps;
+ var prevState = current$$1.memoizedState;
+ startPhaseTimer(finishedWork, "getSnapshotBeforeUpdate");
+ var instance = finishedWork.stateNode;
+ {
+ if (finishedWork.type === finishedWork.elementType && !didWarnAboutReassigningProps) {
+ !(instance.props === finishedWork.memoizedProps) ? warning$1(false, "Expected %s props to match memoized props before " + "getSnapshotBeforeUpdate. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
+ !(instance.state === finishedWork.memoizedState) ? warning$1(false, "Expected %s state to match memoized state before " + "getSnapshotBeforeUpdate. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
+ }
+ }
+ var snapshot = instance.getSnapshotBeforeUpdate(finishedWork.elementType === finishedWork.type ? prevProps : resolveDefaultProps(finishedWork.type, prevProps), prevState);
+ {
+ var didWarnSet = didWarnAboutUndefinedSnapshotBeforeUpdate;
+
+ if (snapshot === undefined && !didWarnSet.has(finishedWork.type)) {
+ didWarnSet.add(finishedWork.type);
+ warningWithoutStack$1(false, "%s.getSnapshotBeforeUpdate(): A snapshot value (or null) " + "must be returned. You have returned undefined.", getComponentName(finishedWork.type));
+ }
+ }
+ instance.__reactInternalSnapshotBeforeUpdate = snapshot;
+ stopPhaseTimer();
+ }
+ }
+
+ return;
+ }
+
+ case HostRoot:
+ case HostComponent:
+ case HostText:
+ case HostPortal:
+ case IncompleteClassComponent:
+ return;
+
+ default:
+ {
+ 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 commitHookEffectList(unmountTag, mountTag, finishedWork) {
+ var updateQueue = finishedWork.updateQueue;
+ var lastEffect = updateQueue !== null ? updateQueue.lastEffect : null;
+
+ if (lastEffect !== null) {
+ var firstEffect = lastEffect.next;
+ var effect = firstEffect;
+
+ do {
+ if ((effect.tag & unmountTag) !== NoEffect$1) {
+ var destroy = effect.destroy;
+ effect.destroy = undefined;
+
+ if (destroy !== undefined) {
+ destroy();
+ }
+ }
+
+ if ((effect.tag & mountTag) !== NoEffect$1) {
+ var create = effect.create;
+ effect.destroy = create();
+ {
+ var _destroy = effect.destroy;
+
+ if (_destroy !== undefined && typeof _destroy !== "function") {
+ var addendum = void 0;
+
+ if (_destroy === null) {
+ addendum = " You returned null. If your effect does not require clean " + "up, return undefined (or nothing).";
+ } else if (typeof _destroy.then === "function") {
+ addendum = "\n\nIt looks like you wrote useEffect(async () => ...) or returned a Promise. " + "Instead, you may write an async function separately " + "and then call it from inside the effect:\n\n" + "async function fetchComment(commentId) {\n" + " // You can await here\n" + "}\n\n" + "useEffect(() => {\n" + " fetchComment(commentId);\n" + "}, [commentId]);\n\n" + "In the future, React will provide a more idiomatic solution for data fetching " + "that doesn't involve writing effects manually.";
+ } else {
+ addendum = " You returned: " + _destroy;
+ }
+
+ warningWithoutStack$1(false, "An Effect function must not return anything besides a function, " + "which is used for clean-up.%s%s", addendum, getStackByFiberInDevAndProd(finishedWork));
+ }
+ }
+ }
+
+ effect = effect.next;
+ } while (effect !== firstEffect);
+ }
+ }
+
+ function commitPassiveHookEffects(finishedWork) {
+ commitHookEffectList(UnmountPassive, NoEffect$1, finishedWork);
+ commitHookEffectList(NoEffect$1, MountPassive, finishedWork);
+ }
+
+ function commitLifeCycles(finishedRoot, current$$1, finishedWork, committedExpirationTime) {
+ switch (finishedWork.tag) {
+ case FunctionComponent:
+ case ForwardRef:
+ case SimpleMemoComponent:
+ {
+ commitHookEffectList(UnmountLayout, MountLayout, finishedWork);
+ break;
+ }
+
+ case ClassComponent:
+ {
+ var instance = finishedWork.stateNode;
+
+ if (finishedWork.effectTag & Update) {
+ if (current$$1 === null) {
+ startPhaseTimer(finishedWork, "componentDidMount");
+ {
+ if (finishedWork.type === finishedWork.elementType && !didWarnAboutReassigningProps) {
+ !(instance.props === finishedWork.memoizedProps) ? warning$1(false, "Expected %s props to match memoized props before " + "componentDidMount. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
+ !(instance.state === finishedWork.memoizedState) ? warning$1(false, "Expected %s state to match memoized state before " + "componentDidMount. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
+ }
+ }
+ instance.componentDidMount();
+ stopPhaseTimer();
+ } else {
+ var prevProps = finishedWork.elementType === finishedWork.type ? current$$1.memoizedProps : resolveDefaultProps(finishedWork.type, current$$1.memoizedProps);
+ var prevState = current$$1.memoizedState;
+ startPhaseTimer(finishedWork, "componentDidUpdate");
+ {
+ if (finishedWork.type === finishedWork.elementType && !didWarnAboutReassigningProps) {
+ !(instance.props === finishedWork.memoizedProps) ? warning$1(false, "Expected %s props to match memoized props before " + "componentDidUpdate. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
+ !(instance.state === finishedWork.memoizedState) ? warning$1(false, "Expected %s state to match memoized state before " + "componentDidUpdate. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
+ }
+ }
+ instance.componentDidUpdate(prevProps, prevState, instance.__reactInternalSnapshotBeforeUpdate);
+ stopPhaseTimer();
+ }
+ }
+
+ var updateQueue = finishedWork.updateQueue;
+
+ if (updateQueue !== null) {
+ {
+ if (finishedWork.type === finishedWork.elementType && !didWarnAboutReassigningProps) {
+ !(instance.props === finishedWork.memoizedProps) ? warning$1(false, "Expected %s props to match memoized props before " + "processing the update queue. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
+ !(instance.state === finishedWork.memoizedState) ? warning$1(false, "Expected %s state to match memoized state before " + "processing the update queue. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
+ }
+ }
+ commitUpdateQueue(finishedWork, updateQueue, instance, committedExpirationTime);
+ }
+
+ return;
+ }
+
+ case HostRoot:
+ {
+ var _updateQueue = finishedWork.updateQueue;
+
+ if (_updateQueue !== null) {
+ var _instance = null;
+
+ if (finishedWork.child !== null) {
+ switch (finishedWork.child.tag) {
+ case HostComponent:
+ _instance = getPublicInstance(finishedWork.child.stateNode);
+ break;
+
+ case ClassComponent:
+ _instance = finishedWork.child.stateNode;
+ break;
+ }
+ }
+
+ commitUpdateQueue(finishedWork, _updateQueue, _instance, committedExpirationTime);
+ }
+
+ return;
+ }
+
+ case HostComponent:
+ {
+ var _instance2 = finishedWork.stateNode;
+
+ if (current$$1 === null && finishedWork.effectTag & Update) {
+ var type = finishedWork.type;
+ var props = finishedWork.memoizedProps;
+ }
+
+ return;
+ }
+
+ case HostText:
+ {
+ return;
+ }
+
+ case HostPortal:
+ {
+ return;
+ }
+
+ case Profiler:
+ {
+ if (enableProfilerTimer) {
+ var onRender = finishedWork.memoizedProps.onRender;
+
+ if (enableSchedulerTracing) {
+ onRender(finishedWork.memoizedProps.id, current$$1 === null ? "mount" : "update", finishedWork.actualDuration, finishedWork.treeBaseDuration, finishedWork.actualStartTime, getCommitTime(), finishedRoot.memoizedInteractions);
+ } else {
+ onRender(finishedWork.memoizedProps.id, current$$1 === null ? "mount" : "update", finishedWork.actualDuration, finishedWork.treeBaseDuration, finishedWork.actualStartTime, getCommitTime());
+ }
+ }
+
+ return;
+ }
+
+ case SuspenseComponent:
+ break;
+
+ case IncompleteClassComponent:
+ break;
+
+ 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 hideOrUnhideAllChildren(finishedWork, isHidden) {
+ if (supportsMutation) {
+ var node = finishedWork;
+
+ while (true) {
+ if (node.tag === HostComponent) {
+ var instance = node.stateNode;
+
+ if (isHidden) {
+ hideInstance(instance);
+ } else {
+ unhideInstance(node.stateNode, node.memoizedProps);
+ }
+ } else if (node.tag === HostText) {
+ var _instance3 = node.stateNode;
+
+ if (isHidden) {
+ hideTextInstance(_instance3);
+ } else {
+ unhideTextInstance(_instance3, node.memoizedProps);
+ }
+ } else if (node.tag === SuspenseComponent && node.memoizedState !== null) {
+ var fallbackChildFragment = node.child.sibling;
+ fallbackChildFragment.return = node;
+ node = fallbackChildFragment;
+ continue;
+ } else if (node.child !== null) {
+ node.child.return = node;
+ node = node.child;
+ continue;
+ }
+
+ if (node === finishedWork) {
+ return;
+ }
+
+ while (node.sibling === null) {
+ if (node.return === null || node.return === finishedWork) {
+ return;
+ }
+
+ node = node.return;
+ }
+
+ node.sibling.return = node.return;
+ node = node.sibling;
+ }
+ }
+ }
+
+ function commitAttachRef(finishedWork) {
+ var ref = finishedWork.ref;
+
+ if (ref !== null) {
+ var instance = finishedWork.stateNode;
+ var instanceToUse = void 0;
+
+ switch (finishedWork.tag) {
+ case HostComponent:
+ instanceToUse = getPublicInstance(instance);
+ break;
+
+ default:
+ instanceToUse = instance;
+ }
+
+ if (typeof ref === "function") {
+ ref(instanceToUse);
+ } else {
+ {
+ if (!ref.hasOwnProperty("current")) {
+ warningWithoutStack$1(false, "Unexpected ref object provided for %s. " + "Use either a ref-setter function or React.createRef().%s", getComponentName(finishedWork.type), getStackByFiberInDevAndProd(finishedWork));
+ }
+ }
+ ref.current = instanceToUse;
+ }
+ }
+ }
+
+ function commitDetachRef(current$$1) {
+ var currentRef = current$$1.ref;
+
+ if (currentRef !== null) {
+ if (typeof currentRef === "function") {
+ currentRef(null);
+ } else {
+ currentRef.current = null;
+ }
+ }
+ }
+
+ function commitUnmount(current$$1) {
+ onCommitUnmount(current$$1);
+
+ switch (current$$1.tag) {
+ case FunctionComponent:
+ case ForwardRef:
+ case MemoComponent:
+ case SimpleMemoComponent:
+ {
+ var updateQueue = current$$1.updateQueue;
+
+ if (updateQueue !== null) {
+ var lastEffect = updateQueue.lastEffect;
+
+ if (lastEffect !== null) {
+ var firstEffect = lastEffect.next;
+ var effect = firstEffect;
+
+ do {
+ var destroy = effect.destroy;
+
+ if (destroy !== undefined) {
+ safelyCallDestroy(current$$1, destroy);
+ }
+
+ effect = effect.next;
+ } while (effect !== firstEffect);
+ }
+ }
+
+ break;
+ }
+
+ case ClassComponent:
+ {
+ safelyDetachRef(current$$1);
+ var instance = current$$1.stateNode;
+
+ if (typeof instance.componentWillUnmount === "function") {
+ safelyCallComponentWillUnmount(current$$1, instance);
+ }
+
+ return;
+ }
+
+ case HostComponent:
+ {
+ safelyDetachRef(current$$1);
+ return;
+ }
+
+ case HostPortal:
+ {
+ if (supportsMutation) {
+ unmountHostComponents(current$$1);
+ } else if (supportsPersistence) {
+ emptyPortalContainer(current$$1);
+ }
+
+ 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$$1) {
+ current$$1.return = null;
+ current$$1.child = null;
+ current$$1.memoizedState = null;
+ current$$1.updateQueue = null;
+ var alternate = current$$1.alternate;
+
+ if (alternate !== null) {
+ alternate.return = null;
+ alternate.child = null;
+ alternate.memoizedState = null;
+ alternate.updateQueue = null;
+ }
+ }
+
+ function emptyPortalContainer(current$$1) {
+ if (!supportsPersistence) {
+ return;
+ }
+
+ var portal = current$$1.stateNode;
+ var containerInfo = portal.containerInfo;
+ var emptyChildSet = createContainerChildSet(containerInfo);
+ replaceContainerChildren(containerInfo, emptyChildSet);
+ }
+
+ function commitContainer(finishedWork) {
+ if (!supportsPersistence) {
+ return;
+ }
+
+ switch (finishedWork.tag) {
+ case ClassComponent:
+ {
+ 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 && node.tag !== DehydratedSuspenseComponent) {
+ if (node.effectTag & Placement) {
+ continue siblings;
+ }
+
+ if (node.child === null || node.tag === HostPortal) {
+ continue siblings;
+ } else {
+ node.child.return = node;
+ node = node.child;
+ }
+ }
+
+ if (!(node.effectTag & Placement)) {
+ return node.stateNode;
+ }
+ }
+ }
+
+ function commitPlacement(finishedWork) {
+ if (!supportsMutation) {
+ return;
+ }
+
+ var parentFiber = getHostParentFiber(finishedWork);
+ var parent = void 0;
+ var isContainer = void 0;
+
+ 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$$1) {
+ var node = current$$1;
+ var currentParentIsValid = false;
+ var currentParent = void 0;
+ var currentParentIsContainer = void 0;
+
+ while (true) {
+ if (!currentParentIsValid) {
+ var parent = node.return;
+
+ findParent: while (true) {
+ 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 (enableSuspenseServerRenderer && node.tag === DehydratedSuspenseComponent) {
+ if (currentParentIsContainer) {
+ clearSuspenseBoundaryFromContainer(currentParent, node.stateNode);
+ } else {
+ clearSuspenseBoundary(currentParent, node.stateNode);
+ }
+ } else if (node.tag === HostPortal) {
+ if (node.child !== null) {
+ currentParent = node.stateNode.containerInfo;
+ currentParentIsContainer = true;
+ node.child.return = node;
+ node = node.child;
+ continue;
+ }
+ } else {
+ commitUnmount(node);
+
+ if (node.child !== null) {
+ node.child.return = node;
+ node = node.child;
+ continue;
+ }
+ }
+
+ if (node === current$$1) {
+ return;
+ }
+
+ while (node.sibling === null) {
+ if (node.return === null || node.return === current$$1) {
+ return;
+ }
+
+ node = node.return;
+
+ if (node.tag === HostPortal) {
+ currentParentIsValid = false;
+ }
+ }
+
+ node.sibling.return = node.return;
+ node = node.sibling;
+ }
+ }
+
+ function commitDeletion(current$$1) {
+ if (supportsMutation) {
+ unmountHostComponents(current$$1);
+ } else {
+ commitNestedUnmounts(current$$1);
+ }
+
+ detachFiber(current$$1);
+ }
+
+ function commitWork(current$$1, finishedWork) {
+ if (!supportsMutation) {
+ switch (finishedWork.tag) {
+ case FunctionComponent:
+ case ForwardRef:
+ case MemoComponent:
+ case SimpleMemoComponent:
+ {
+ commitHookEffectList(UnmountMutation, MountMutation, finishedWork);
+ return;
+ }
+ }
+
+ commitContainer(finishedWork);
+ return;
+ }
+
+ switch (finishedWork.tag) {
+ case FunctionComponent:
+ case ForwardRef:
+ case MemoComponent:
+ case SimpleMemoComponent:
+ {
+ commitHookEffectList(UnmountMutation, MountMutation, finishedWork);
+ return;
+ }
+
+ case ClassComponent:
+ {
+ return;
+ }
+
+ case HostComponent:
+ {
+ var instance = finishedWork.stateNode;
+
+ if (instance != null) {
+ var newProps = finishedWork.memoizedProps;
+ var oldProps = current$$1 !== null ? current$$1.memoizedProps : newProps;
+ var type = finishedWork.type;
+ var updatePayload = finishedWork.updateQueue;
+ finishedWork.updateQueue = null;
+
+ if (updatePayload !== null) {
+ commitUpdate(instance, updatePayload, type, oldProps, newProps, finishedWork);
+ }
+ }
+
+ return;
+ }
+
+ case HostText:
+ {
+ 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$$1 !== null ? current$$1.memoizedProps : newText;
+ commitTextUpdate(textInstance, oldText, newText);
+ return;
+ }
+
+ case HostRoot:
+ {
+ return;
+ }
+
+ case Profiler:
+ {
+ return;
+ }
+
+ case SuspenseComponent:
+ {
+ var newState = finishedWork.memoizedState;
+ var newDidTimeout = void 0;
+ var primaryChildParent = finishedWork;
+
+ if (newState === null) {
+ newDidTimeout = false;
+ } else {
+ newDidTimeout = true;
+ primaryChildParent = finishedWork.child;
+
+ if (newState.timedOutAt === NoWork) {
+ newState.timedOutAt = requestCurrentTime();
+ }
+ }
+
+ if (primaryChildParent !== null) {
+ hideOrUnhideAllChildren(primaryChildParent, newDidTimeout);
+ }
+
+ var thenables = finishedWork.updateQueue;
+
+ if (thenables !== null) {
+ finishedWork.updateQueue = null;
+ var retryCache = finishedWork.stateNode;
+
+ if (retryCache === null) {
+ retryCache = finishedWork.stateNode = new PossiblyWeakSet$1();
+ }
+
+ thenables.forEach(function (thenable) {
+ var retry = resolveRetryThenable.bind(null, finishedWork, thenable);
+
+ if (enableSchedulerTracing) {
+ retry = tracing.unstable_wrap(retry);
+ }
+
+ if (!retryCache.has(thenable)) {
+ retryCache.add(thenable);
+ thenable.then(retry, retry);
+ }
+ });
+ }
+
+ return;
+ }
+
+ case IncompleteClassComponent:
+ {
+ 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$$1) {
+ if (!supportsMutation) {
+ return;
+ }
+
+ resetTextContent(current$$1.stateNode);
+ }
+
+ var PossiblyWeakSet = typeof WeakSet === "function" ? WeakSet : Set;
+ var PossiblyWeakMap = typeof WeakMap === "function" ? WeakMap : Map;
+
+ function createRootErrorUpdate(fiber, errorInfo, expirationTime) {
+ var update = createUpdate(expirationTime);
+ 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 getDerivedStateFromError = fiber.type.getDerivedStateFromError;
+
+ if (typeof getDerivedStateFromError === "function") {
+ var error = errorInfo.value;
+
+ update.payload = function () {
+ return getDerivedStateFromError(error);
+ };
+ }
+
+ var inst = fiber.stateNode;
+
+ if (inst !== null && typeof inst.componentDidCatch === "function") {
+ update.callback = function callback() {
+ if (typeof getDerivedStateFromError !== "function") {
+ markLegacyErrorBoundaryAsFailed(this);
+ }
+
+ var error = errorInfo.value;
+ var stack = errorInfo.stack;
+ logError(fiber, errorInfo);
+ this.componentDidCatch(error, {
+ componentStack: stack !== null ? stack : ""
+ });
+ {
+ if (typeof getDerivedStateFromError !== "function") {
+ !(fiber.expirationTime === Sync) ? warningWithoutStack$1(false, "%s: Error boundaries should implement getDerivedStateFromError(). " + "In that method, return a state update to display an error message or fallback UI.", getComponentName(fiber.type) || "Unknown") : void 0;
+ }
+ }
+ };
+ }
+
+ return update;
+ }
+
+ function attachPingListener(root, renderExpirationTime, thenable) {
+ var pingCache = root.pingCache;
+ var threadIDs = void 0;
+
+ if (pingCache === null) {
+ pingCache = root.pingCache = new PossiblyWeakMap();
+ threadIDs = new Set();
+ pingCache.set(thenable, threadIDs);
+ } else {
+ threadIDs = pingCache.get(thenable);
+
+ if (threadIDs === undefined) {
+ threadIDs = new Set();
+ pingCache.set(thenable, threadIDs);
+ }
+ }
+
+ if (!threadIDs.has(renderExpirationTime)) {
+ threadIDs.add(renderExpirationTime);
+ var ping = pingSuspendedRoot.bind(null, root, thenable, renderExpirationTime);
+
+ if (enableSchedulerTracing) {
+ ping = tracing.unstable_wrap(ping);
+ }
+
+ thenable.then(ping, ping);
+ }
+ }
+
+ function throwException(root, returnFiber, sourceFiber, value, renderExpirationTime) {
+ sourceFiber.effectTag |= Incomplete;
+ sourceFiber.firstEffect = sourceFiber.lastEffect = null;
+
+ if (value !== null && typeof value === "object" && typeof value.then === "function") {
+ var thenable = value;
+ var _workInProgress = returnFiber;
+ var earliestTimeoutMs = -1;
+ var startTimeMs = -1;
+
+ do {
+ if (_workInProgress.tag === SuspenseComponent) {
+ var current$$1 = _workInProgress.alternate;
+
+ if (current$$1 !== null) {
+ var currentState = current$$1.memoizedState;
+
+ if (currentState !== null) {
+ var timedOutAt = currentState.timedOutAt;
+ startTimeMs = expirationTimeToMs(timedOutAt);
+ break;
+ }
+ }
+
+ var timeoutPropMs = _workInProgress.pendingProps.maxDuration;
+
+ if (typeof timeoutPropMs === "number") {
+ if (timeoutPropMs <= 0) {
+ earliestTimeoutMs = 0;
+ } else if (earliestTimeoutMs === -1 || timeoutPropMs < earliestTimeoutMs) {
+ earliestTimeoutMs = timeoutPropMs;
+ }
+ }
+ }
+
+ _workInProgress = _workInProgress.return;
+ } while (_workInProgress !== null);
+
+ _workInProgress = returnFiber;
+
+ do {
+ if (_workInProgress.tag === SuspenseComponent && shouldCaptureSuspense(_workInProgress)) {
+ var thenables = _workInProgress.updateQueue;
+
+ if (thenables === null) {
+ var updateQueue = new Set();
+ updateQueue.add(thenable);
+ _workInProgress.updateQueue = updateQueue;
+ } else {
+ thenables.add(thenable);
+ }
+
+ if ((_workInProgress.mode & ConcurrentMode) === NoEffect) {
+ _workInProgress.effectTag |= DidCapture;
+ sourceFiber.effectTag &= ~(LifecycleEffectMask | Incomplete);
+
+ if (sourceFiber.tag === ClassComponent) {
+ var currentSourceFiber = sourceFiber.alternate;
+
+ if (currentSourceFiber === null) {
+ sourceFiber.tag = IncompleteClassComponent;
+ } else {
+ var update = createUpdate(Sync);
+ update.tag = ForceUpdate;
+ enqueueUpdate(sourceFiber, update);
+ }
+ }
+
+ sourceFiber.expirationTime = Sync;
+ return;
+ }
+
+ attachPingListener(root, renderExpirationTime, thenable);
+ var absoluteTimeoutMs = void 0;
+
+ if (earliestTimeoutMs === -1) {
+ absoluteTimeoutMs = maxSigned31BitInt;
+ } else {
+ if (startTimeMs === -1) {
+ var earliestExpirationTime = findEarliestOutstandingPriorityLevel(root, renderExpirationTime);
+ var earliestExpirationTimeMs = expirationTimeToMs(earliestExpirationTime);
+ startTimeMs = earliestExpirationTimeMs - LOW_PRIORITY_EXPIRATION;
+ }
+
+ absoluteTimeoutMs = startTimeMs + earliestTimeoutMs;
+ }
+
+ renderDidSuspend(root, absoluteTimeoutMs, renderExpirationTime);
+ _workInProgress.effectTag |= ShouldCapture;
+ _workInProgress.expirationTime = renderExpirationTime;
+ return;
+ } else if (enableSuspenseServerRenderer && _workInProgress.tag === DehydratedSuspenseComponent) {
+ attachPingListener(root, renderExpirationTime, thenable);
+ var retryCache = _workInProgress.memoizedState;
+
+ if (retryCache === null) {
+ retryCache = _workInProgress.memoizedState = new PossiblyWeakSet();
+ var _current = _workInProgress.alternate;
+ invariant(_current, "A dehydrated suspense boundary must commit before trying to render. " + "This is probably a bug in React.");
+ _current.memoizedState = retryCache;
+ }
+
+ if (!retryCache.has(thenable)) {
+ retryCache.add(thenable);
+ var retry = resolveRetryThenable.bind(null, _workInProgress, thenable);
+
+ if (enableSchedulerTracing) {
+ retry = tracing.unstable_wrap(retry);
+ }
+
+ thenable.then(retry, retry);
+ }
+
+ _workInProgress.effectTag |= ShouldCapture;
+ _workInProgress.expirationTime = renderExpirationTime;
+ return;
+ }
+
+ _workInProgress = _workInProgress.return;
+ } while (_workInProgress !== null);
+
+ value = new Error((getComponentName(sourceFiber.type) || "A React component") + " suspended while rendering, but no fallback UI was specified.\n" + "\n" + "Add a component higher in the tree to " + "provide a loading indicator or placeholder to display." + getStackByFiberInDevAndProd(sourceFiber));
+ }
+
+ renderDidError();
+ value = createCapturedValue(value, sourceFiber);
+ var workInProgress = returnFiber;
+
+ do {
+ switch (workInProgress.tag) {
+ case HostRoot:
+ {
+ var _errorInfo = value;
+ workInProgress.effectTag |= ShouldCapture;
+ workInProgress.expirationTime = renderExpirationTime;
+
+ var _update = createRootErrorUpdate(workInProgress, _errorInfo, renderExpirationTime);
+
+ enqueueCapturedUpdate(workInProgress, _update);
+ return;
+ }
+
+ case ClassComponent:
+ var errorInfo = value;
+ var ctor = workInProgress.type;
+ var instance = workInProgress.stateNode;
+
+ if ((workInProgress.effectTag & DidCapture) === NoEffect && (typeof ctor.getDerivedStateFromError === "function" || instance !== null && typeof instance.componentDidCatch === "function" && !isAlreadyFailedLegacyErrorBoundary(instance))) {
+ workInProgress.effectTag |= ShouldCapture;
+ workInProgress.expirationTime = renderExpirationTime;
+
+ var _update2 = createClassErrorUpdate(workInProgress, errorInfo, renderExpirationTime);
+
+ enqueueCapturedUpdate(workInProgress, _update2);
+ return;
+ }
+
+ break;
+
+ default:
+ break;
+ }
+
+ workInProgress = workInProgress.return;
+ } while (workInProgress !== null);
+ }
+
+ function unwindWork(workInProgress, renderExpirationTime) {
+ switch (workInProgress.tag) {
+ case ClassComponent:
+ {
+ var Component = workInProgress.type;
+
+ if (isContextProvider(Component)) {
+ popContext(workInProgress);
+ }
+
+ var effectTag = workInProgress.effectTag;
+
+ if (effectTag & ShouldCapture) {
+ workInProgress.effectTag = effectTag & ~ShouldCapture | DidCapture;
+ return workInProgress;
+ }
+
+ return null;
+ }
+
+ case HostRoot:
+ {
+ popHostContainer(workInProgress);
+ popTopLevelContextObject(workInProgress);
+ var _effectTag = workInProgress.effectTag;
+ invariant((_effectTag & DidCapture) === NoEffect, "The root failed to unmount after an error. This is likely a bug in " + "React. Please file an issue.");
+ workInProgress.effectTag = _effectTag & ~ShouldCapture | DidCapture;
+ return workInProgress;
+ }
+
+ case HostComponent:
+ {
+ popHostContext(workInProgress);
+ return null;
+ }
+
+ case SuspenseComponent:
+ {
+ var _effectTag2 = workInProgress.effectTag;
+
+ if (_effectTag2 & ShouldCapture) {
+ workInProgress.effectTag = _effectTag2 & ~ShouldCapture | DidCapture;
+ return workInProgress;
+ }
+
+ return null;
+ }
+
+ case DehydratedSuspenseComponent:
+ {
+ if (enableSuspenseServerRenderer) {
+ var _effectTag3 = workInProgress.effectTag;
+
+ if (_effectTag3 & ShouldCapture) {
+ workInProgress.effectTag = _effectTag3 & ~ShouldCapture | DidCapture;
+ return workInProgress;
+ }
+ }
+
+ return null;
+ }
+
+ case HostPortal:
+ popHostContainer(workInProgress);
+ return null;
+
+ case ContextProvider:
+ popProvider(workInProgress);
+ return null;
+
+ default:
+ return null;
+ }
+ }
+
+ function unwindInterruptedWork(interruptedWork) {
+ switch (interruptedWork.tag) {
+ case ClassComponent:
+ {
+ var childContextTypes = interruptedWork.type.childContextTypes;
+
+ if (childContextTypes !== null && childContextTypes !== undefined) {
+ popContext(interruptedWork);
+ }
+
+ break;
+ }
+
+ case HostRoot:
+ {
+ popHostContainer(interruptedWork);
+ popTopLevelContextObject(interruptedWork);
+ break;
+ }
+
+ case HostComponent:
+ {
+ popHostContext(interruptedWork);
+ break;
+ }
+
+ case HostPortal:
+ popHostContainer(interruptedWork);
+ break;
+
+ case ContextProvider:
+ popProvider(interruptedWork);
+ break;
+
+ default:
+ break;
+ }
+ }
+
+ var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+ var ReactCurrentOwner$2 = ReactSharedInternals.ReactCurrentOwner;
+ var didWarnAboutStateTransition = void 0;
+ var didWarnSetStateChildContext = void 0;
+ var warnAboutUpdateOnUnmounted = void 0;
+ var warnAboutInvalidUpdates = void 0;
+
+ if (enableSchedulerTracing) {
+ invariant(tracing.__interactionsRef != null && tracing.__interactionsRef.current != null, "It is not supported to run the profiling version of a renderer (for example, `react-dom/profiling`) " + "without also replacing the `scheduler/tracing` module with `scheduler/tracing-profiling`. " + "Your bundler might have a setting for aliasing both modules. " + "Learn more at http://fb.me/react-profiling");
+ }
+
+ {
+ didWarnAboutStateTransition = false;
+ didWarnSetStateChildContext = false;
+ var didWarnStateUpdateForUnmountedComponent = {};
+
+ warnAboutUpdateOnUnmounted = function warnAboutUpdateOnUnmounted(fiber, isClass) {
+ var componentName = getComponentName(fiber.type) || "ReactComponent";
+
+ if (didWarnStateUpdateForUnmountedComponent[componentName]) {
+ return;
+ }
+
+ warningWithoutStack$1(false, "Can't perform a React state update on an unmounted component. This " + "is a no-op, but it indicates a memory leak in your application. To " + "fix, cancel all subscriptions and asynchronous tasks in %s.%s", isClass ? "the componentWillUnmount method" : "a useEffect cleanup function", getStackByFiberInDevAndProd(fiber));
+ didWarnStateUpdateForUnmountedComponent[componentName] = true;
+ };
+
+ warnAboutInvalidUpdates = function warnAboutInvalidUpdates(instance) {
+ switch (phase) {
+ case "getChildContext":
+ if (didWarnSetStateChildContext) {
+ return;
+ }
+
+ warningWithoutStack$1(false, "setState(...): Cannot call setState() inside getChildContext()");
+ didWarnSetStateChildContext = true;
+ break;
+
+ case "render":
+ if (didWarnAboutStateTransition) {
+ return;
+ }
+
+ warningWithoutStack$1(false, "Cannot update during an existing state transition (such as within " + "`render`). Render methods should be a pure function of props and state.");
+ didWarnAboutStateTransition = true;
+ break;
+ }
+ };
+ }
+ var isWorking = false;
+ var nextUnitOfWork = null;
+ var nextRoot = null;
+ var nextRenderExpirationTime = NoWork;
+ var nextLatestAbsoluteTimeoutMs = -1;
+ var nextRenderDidError = false;
+ var nextEffect = null;
+ var isCommitting$1 = false;
+ var rootWithPendingPassiveEffects = null;
+ var passiveEffectCallbackHandle = null;
+ var passiveEffectCallback = null;
+ var legacyErrorBoundariesThatAlreadyFailed = null;
+ var interruptedBy = null;
+ var stashedWorkInProgressProperties = void 0;
+ var replayUnitOfWork = void 0;
+ var mayReplayFailedUnitOfWork = void 0;
+ var isReplayingFailedUnitOfWork = void 0;
+ var originalReplayError = void 0;
+ var rethrowOriginalError = void 0;
+
+ if (true && replayFailedUnitOfWorkWithInvokeGuardedCallback) {
+ stashedWorkInProgressProperties = null;
+ mayReplayFailedUnitOfWork = true;
+ isReplayingFailedUnitOfWork = false;
+ originalReplayError = null;
+
+ replayUnitOfWork = function replayUnitOfWork(failedUnitOfWork, thrownValue, isYieldy) {
+ if (thrownValue !== null && typeof thrownValue === "object" && typeof thrownValue.then === "function") {
+ return;
+ }
+
+ if (stashedWorkInProgressProperties === null) {
+ warningWithoutStack$1(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:
+ {
+ var Component = failedUnitOfWork.type;
+
+ if (isContextProvider(Component)) {
+ popContext(failedUnitOfWork);
+ }
+
+ break;
+ }
+
+ case HostPortal:
+ popHostContainer(failedUnitOfWork);
+ break;
+
+ case ContextProvider:
+ popProvider(failedUnitOfWork);
+ break;
+ }
+
+ isReplayingFailedUnitOfWork = true;
+ originalReplayError = thrownValue;
+ invokeGuardedCallback(null, workLoop, null, isYieldy);
+ isReplayingFailedUnitOfWork = false;
+ originalReplayError = null;
+
+ if (hasCaughtError()) {
+ var replayError = clearCaughtError();
+
+ if (replayError != null && thrownValue != null) {
+ try {
+ if (replayError._suppressLogging) {
+ thrownValue._suppressLogging = true;
+ }
+ } catch (inner) {}
+ }
+ } 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;
+ nextLatestAbsoluteTimeoutMs = -1;
+ nextRenderDidError = false;
+ nextUnitOfWork = null;
+ }
+
+ function commitAllHostEffects() {
+ while (nextEffect !== null) {
+ {
+ setCurrentFiber(nextEffect);
+ }
+ recordEffect();
+ var effectTag = nextEffect.effectTag;
+
+ if (effectTag & ContentReset) {
+ commitResetTextContent(nextEffect);
+ }
+
+ if (effectTag & Ref) {
+ var current$$1 = nextEffect.alternate;
+
+ if (current$$1 !== null) {
+ commitDetachRef(current$$1);
+ }
+ }
+
+ var primaryEffectTag = effectTag & (Placement | Update | Deletion);
+
+ switch (primaryEffectTag) {
+ case Placement:
+ {
+ commitPlacement(nextEffect);
+ nextEffect.effectTag &= ~Placement;
+ break;
+ }
+
+ case PlacementAndUpdate:
+ {
+ commitPlacement(nextEffect);
+ nextEffect.effectTag &= ~Placement;
+ var _current = nextEffect.alternate;
+ commitWork(_current, nextEffect);
+ break;
+ }
+
+ case Update:
+ {
+ var _current2 = nextEffect.alternate;
+ commitWork(_current2, nextEffect);
+ break;
+ }
+
+ case Deletion:
+ {
+ commitDeletion(nextEffect);
+ break;
+ }
+ }
+
+ nextEffect = nextEffect.nextEffect;
+ }
+
+ {
+ resetCurrentFiber();
+ }
+ }
+
+ function commitBeforeMutationLifecycles() {
+ while (nextEffect !== null) {
+ {
+ setCurrentFiber(nextEffect);
+ }
+ var effectTag = nextEffect.effectTag;
+
+ if (effectTag & Snapshot) {
+ recordEffect();
+ var current$$1 = nextEffect.alternate;
+ commitBeforeMutationLifeCycles(current$$1, nextEffect);
+ }
+
+ nextEffect = nextEffect.nextEffect;
+ }
+
+ {
+ resetCurrentFiber();
+ }
+ }
+
+ function commitAllLifeCycles(finishedRoot, committedExpirationTime) {
+ {
+ ReactStrictModeWarnings.flushPendingUnsafeLifecycleWarnings();
+ ReactStrictModeWarnings.flushLegacyContextWarning();
+
+ if (warnAboutDeprecatedLifecycles) {
+ ReactStrictModeWarnings.flushPendingDeprecationWarnings();
+ }
+ }
+
+ while (nextEffect !== null) {
+ {
+ setCurrentFiber(nextEffect);
+ }
+ var effectTag = nextEffect.effectTag;
+
+ if (effectTag & (Update | Callback)) {
+ recordEffect();
+ var current$$1 = nextEffect.alternate;
+ commitLifeCycles(finishedRoot, current$$1, nextEffect, committedExpirationTime);
+ }
+
+ if (effectTag & Ref) {
+ recordEffect();
+ commitAttachRef(nextEffect);
+ }
+
+ if (effectTag & Passive) {
+ rootWithPendingPassiveEffects = finishedRoot;
+ }
+
+ nextEffect = nextEffect.nextEffect;
+ }
+
+ {
+ resetCurrentFiber();
+ }
+ }
+
+ function commitPassiveEffects(root, firstEffect) {
+ rootWithPendingPassiveEffects = null;
+ passiveEffectCallbackHandle = null;
+ passiveEffectCallback = null;
+ var previousIsRendering = isRendering;
+ isRendering = true;
+ var effect = firstEffect;
+
+ do {
+ {
+ setCurrentFiber(effect);
+ }
+
+ if (effect.effectTag & Passive) {
+ var didError = false;
+ var error = void 0;
+ {
+ invokeGuardedCallback(null, commitPassiveHookEffects, null, effect);
+
+ if (hasCaughtError()) {
+ didError = true;
+ error = clearCaughtError();
+ }
+ }
+
+ if (didError) {
+ captureCommitPhaseError(effect, error);
+ }
+ }
+
+ effect = effect.nextEffect;
+ } while (effect !== null);
+
+ {
+ resetCurrentFiber();
+ }
+ isRendering = previousIsRendering;
+ var rootExpirationTime = root.expirationTime;
+
+ if (rootExpirationTime !== NoWork) {
+ requestWork(root, rootExpirationTime);
+ }
+
+ if (!isBatchingUpdates && !isRendering) {
+ performSyncWork();
+ }
+ }
+
+ function isAlreadyFailedLegacyErrorBoundary(instance) {
+ return legacyErrorBoundariesThatAlreadyFailed !== null && legacyErrorBoundariesThatAlreadyFailed.has(instance);
+ }
+
+ function markLegacyErrorBoundaryAsFailed(instance) {
+ if (legacyErrorBoundariesThatAlreadyFailed === null) {
+ legacyErrorBoundariesThatAlreadyFailed = new Set([instance]);
+ } else {
+ legacyErrorBoundariesThatAlreadyFailed.add(instance);
+ }
+ }
+
+ function flushPassiveEffects() {
+ if (passiveEffectCallbackHandle !== null) {
+ cancelPassiveEffects(passiveEffectCallbackHandle);
+ }
+
+ if (passiveEffectCallback !== null) {
+ passiveEffectCallback();
+ }
+ }
+
+ 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 updateExpirationTimeBeforeCommit = finishedWork.expirationTime;
+ var childExpirationTimeBeforeCommit = finishedWork.childExpirationTime;
+ var earliestRemainingTimeBeforeCommit = childExpirationTimeBeforeCommit > updateExpirationTimeBeforeCommit ? childExpirationTimeBeforeCommit : updateExpirationTimeBeforeCommit;
+ markCommittedPriorityLevels(root, earliestRemainingTimeBeforeCommit);
+ var prevInteractions = null;
+
+ if (enableSchedulerTracing) {
+ prevInteractions = tracing.__interactionsRef.current;
+ tracing.__interactionsRef.current = root.memoizedInteractions;
+ }
+
+ ReactCurrentOwner$2.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(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(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(null, commitAllLifeCycles, null, root, 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 (firstEffect !== null && rootWithPendingPassiveEffects !== null) {
+ var callback = commitPassiveEffects.bind(null, root, firstEffect);
+
+ if (enableSchedulerTracing) {
+ callback = tracing.unstable_wrap(callback);
+ }
+
+ passiveEffectCallbackHandle = scheduler.unstable_runWithPriority(scheduler.unstable_NormalPriority, function () {
+ return schedulePassiveEffects(callback);
+ });
+ passiveEffectCallback = callback;
+ }
+
+ isCommitting$1 = false;
+ isWorking = false;
+ stopCommitLifeCyclesTimer();
+ stopCommitTimer();
+ onCommitRoot(finishedWork.stateNode);
+
+ if (true && ReactFiberInstrumentation_1.debugTool) {
+ ReactFiberInstrumentation_1.debugTool.onCommitWork(finishedWork);
+ }
+
+ var updateExpirationTimeAfterCommit = finishedWork.expirationTime;
+ var childExpirationTimeAfterCommit = finishedWork.childExpirationTime;
+ var earliestRemainingTimeAfterCommit = childExpirationTimeAfterCommit > updateExpirationTimeAfterCommit ? childExpirationTimeAfterCommit : updateExpirationTimeAfterCommit;
+
+ if (earliestRemainingTimeAfterCommit === NoWork) {
+ legacyErrorBoundariesThatAlreadyFailed = null;
+ }
+
+ onCommit(root, earliestRemainingTimeAfterCommit);
+
+ if (enableSchedulerTracing) {
+ tracing.__interactionsRef.current = prevInteractions;
+ var subscriber = void 0;
+
+ try {
+ subscriber = tracing.__subscriberRef.current;
+
+ if (subscriber !== null && root.memoizedInteractions.size > 0) {
+ var threadID = computeThreadID(committedExpirationTime, root.interactionThreadID);
+ subscriber.onWorkStopped(root.memoizedInteractions, threadID);
+ }
+ } catch (error) {
+ if (!hasUnhandledError) {
+ hasUnhandledError = true;
+ unhandledError = error;
+ }
+ } finally {
+ var pendingInteractionMap = root.pendingInteractionMap;
+ pendingInteractionMap.forEach(function (scheduledInteractions, scheduledExpirationTime) {
+ if (scheduledExpirationTime > earliestRemainingTimeAfterCommit) {
+ pendingInteractionMap.delete(scheduledExpirationTime);
+ scheduledInteractions.forEach(function (interaction) {
+ interaction.__count--;
+
+ if (subscriber !== null && interaction.__count === 0) {
+ try {
+ subscriber.onInteractionScheduledWorkCompleted(interaction);
+ } catch (error) {
+ if (!hasUnhandledError) {
+ hasUnhandledError = true;
+ unhandledError = error;
+ }
+ }
+ }
+ });
+ }
+ });
+ }
+ }
+ }
+
+ function resetChildExpirationTime(workInProgress, renderTime) {
+ if (renderTime !== Never && workInProgress.childExpirationTime === Never) {
+ return;
+ }
+
+ var newChildExpirationTime = NoWork;
+
+ if (enableProfilerTimer && workInProgress.mode & ProfileMode) {
+ var actualDuration = workInProgress.actualDuration;
+ var treeBaseDuration = workInProgress.selfBaseDuration;
+ var shouldBubbleActualDurations = workInProgress.alternate === null || workInProgress.child !== workInProgress.alternate.child;
+ var child = workInProgress.child;
+
+ while (child !== null) {
+ var childUpdateExpirationTime = child.expirationTime;
+ var childChildExpirationTime = child.childExpirationTime;
+
+ if (childUpdateExpirationTime > newChildExpirationTime) {
+ newChildExpirationTime = childUpdateExpirationTime;
+ }
+
+ if (childChildExpirationTime > newChildExpirationTime) {
+ newChildExpirationTime = childChildExpirationTime;
+ }
+
+ if (shouldBubbleActualDurations) {
+ actualDuration += child.actualDuration;
+ }
+
+ treeBaseDuration += child.treeBaseDuration;
+ child = child.sibling;
+ }
+
+ workInProgress.actualDuration = actualDuration;
+ workInProgress.treeBaseDuration = treeBaseDuration;
+ } else {
+ var _child = workInProgress.child;
+
+ while (_child !== null) {
+ var _childUpdateExpirationTime = _child.expirationTime;
+ var _childChildExpirationTime = _child.childExpirationTime;
+
+ if (_childUpdateExpirationTime > newChildExpirationTime) {
+ newChildExpirationTime = _childUpdateExpirationTime;
+ }
+
+ if (_childChildExpirationTime > newChildExpirationTime) {
+ newChildExpirationTime = _childChildExpirationTime;
+ }
+
+ _child = _child.sibling;
+ }
+ }
+
+ workInProgress.childExpirationTime = newChildExpirationTime;
+ }
+
+ function completeUnitOfWork(workInProgress) {
+ while (true) {
+ var current$$1 = workInProgress.alternate;
+ {
+ setCurrentFiber(workInProgress);
+ }
+ var returnFiber = workInProgress.return;
+ var siblingFiber = workInProgress.sibling;
+
+ if ((workInProgress.effectTag & Incomplete) === NoEffect) {
+ if (true && replayFailedUnitOfWorkWithInvokeGuardedCallback) {
+ mayReplayFailedUnitOfWork = false;
+ }
+
+ nextUnitOfWork = workInProgress;
+
+ if (enableProfilerTimer) {
+ if (workInProgress.mode & ProfileMode) {
+ startProfilerTimer(workInProgress);
+ }
+
+ nextUnitOfWork = completeWork(current$$1, workInProgress, nextRenderExpirationTime);
+
+ if (workInProgress.mode & ProfileMode) {
+ stopProfilerTimerIfRunningAndRecordDelta(workInProgress, false);
+ }
+ } else {
+ nextUnitOfWork = completeWork(current$$1, workInProgress, nextRenderExpirationTime);
+ }
+
+ if (true && replayFailedUnitOfWorkWithInvokeGuardedCallback) {
+ mayReplayFailedUnitOfWork = true;
+ }
+
+ stopWorkTimer(workInProgress);
+ resetChildExpirationTime(workInProgress, nextRenderExpirationTime);
+ {
+ resetCurrentFiber();
+ }
+
+ if (nextUnitOfWork !== null) {
+ return nextUnitOfWork;
+ }
+
+ 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 {
+ if (enableProfilerTimer && workInProgress.mode & ProfileMode) {
+ stopProfilerTimerIfRunningAndRecordDelta(workInProgress, false);
+ var actualDuration = workInProgress.actualDuration;
+ var child = workInProgress.child;
+
+ while (child !== null) {
+ actualDuration += child.actualDuration;
+ child = child.sibling;
+ }
+
+ workInProgress.actualDuration = actualDuration;
+ }
+
+ var next = unwindWork(workInProgress, nextRenderExpirationTime);
+
+ if (workInProgress.effectTag & DidCapture) {
+ stopFailedWorkTimer(workInProgress);
+ } else {
+ stopWorkTimer(workInProgress);
+ }
+
+ {
+ 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$$1 = workInProgress.alternate;
+ startWorkTimer(workInProgress);
+ {
+ setCurrentFiber(workInProgress);
+ }
+
+ if (true && replayFailedUnitOfWorkWithInvokeGuardedCallback) {
+ stashedWorkInProgressProperties = assignFiberPropertiesInDEV(stashedWorkInProgressProperties, workInProgress);
+ }
+
+ var next = void 0;
+
+ if (enableProfilerTimer) {
+ if (workInProgress.mode & ProfileMode) {
+ startProfilerTimer(workInProgress);
+ }
+
+ next = beginWork(current$$1, workInProgress, nextRenderExpirationTime);
+ workInProgress.memoizedProps = workInProgress.pendingProps;
+
+ if (workInProgress.mode & ProfileMode) {
+ stopProfilerTimerIfRunningAndRecordDelta(workInProgress, true);
+ }
+ } else {
+ next = beginWork(current$$1, workInProgress, nextRenderExpirationTime);
+ workInProgress.memoizedProps = workInProgress.pendingProps;
+ }
+
+ {
+ resetCurrentFiber();
+
+ if (isReplayingFailedUnitOfWork) {
+ rethrowOriginalError();
+ }
+ }
+
+ if (true && ReactFiberInstrumentation_1.debugTool) {
+ ReactFiberInstrumentation_1.debugTool.onBeginWork(workInProgress);
+ }
+
+ if (next === null) {
+ next = completeUnitOfWork(workInProgress);
+ }
+
+ ReactCurrentOwner$2.current = null;
+ return next;
+ }
+
+ function workLoop(isYieldy) {
+ if (!isYieldy) {
+ while (nextUnitOfWork !== null) {
+ nextUnitOfWork = performUnitOfWork(nextUnitOfWork);
+ }
+ } else {
+ while (nextUnitOfWork !== null && !shouldYield$$1()) {
+ nextUnitOfWork = performUnitOfWork(nextUnitOfWork);
+ }
+ }
+ }
+
+ function renderRoot(root, isYieldy) {
+ invariant(!isWorking, "renderRoot was called recursively. This error is likely caused " + "by a bug in React. Please file an issue.");
+ flushPassiveEffects();
+ isWorking = true;
+ var previousDispatcher = ReactCurrentDispatcher.current;
+ ReactCurrentDispatcher.current = ContextOnlyDispatcher;
+ var expirationTime = root.nextExpirationTimeToWorkOn;
+
+ if (expirationTime !== nextRenderExpirationTime || root !== nextRoot || nextUnitOfWork === null) {
+ resetStack();
+ nextRoot = root;
+ nextRenderExpirationTime = expirationTime;
+ nextUnitOfWork = createWorkInProgress(nextRoot.current, null, nextRenderExpirationTime);
+ root.pendingCommitExpirationTime = NoWork;
+
+ if (enableSchedulerTracing) {
+ var interactions = new Set();
+ root.pendingInteractionMap.forEach(function (scheduledInteractions, scheduledExpirationTime) {
+ if (scheduledExpirationTime >= expirationTime) {
+ scheduledInteractions.forEach(function (interaction) {
+ return interactions.add(interaction);
+ });
+ }
+ });
+ root.memoizedInteractions = interactions;
+
+ if (interactions.size > 0) {
+ var subscriber = tracing.__subscriberRef.current;
+
+ if (subscriber !== null) {
+ var threadID = computeThreadID(expirationTime, root.interactionThreadID);
+
+ try {
+ subscriber.onWorkStarted(interactions, threadID);
+ } catch (error) {
+ if (!hasUnhandledError) {
+ hasUnhandledError = true;
+ unhandledError = error;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ var prevInteractions = null;
+
+ if (enableSchedulerTracing) {
+ prevInteractions = tracing.__interactionsRef.current;
+ tracing.__interactionsRef.current = root.memoizedInteractions;
+ }
+
+ var didFatal = false;
+ startWorkLoopTimer(nextUnitOfWork);
+
+ do {
+ try {
+ workLoop(isYieldy);
+ } catch (thrownValue) {
+ resetContextDependences();
+ resetHooks();
+ var mayReplay = void 0;
+
+ if (true && replayFailedUnitOfWorkWithInvokeGuardedCallback) {
+ mayReplay = mayReplayFailedUnitOfWork;
+ mayReplayFailedUnitOfWork = true;
+ }
+
+ if (nextUnitOfWork === null) {
+ didFatal = true;
+ onUncaughtError(thrownValue);
+ } else {
+ if (enableProfilerTimer && nextUnitOfWork.mode & ProfileMode) {
+ stopProfilerTimerIfRunningAndRecordDelta(nextUnitOfWork, true);
+ }
+
+ {
+ resetCurrentlyProcessingQueue();
+ }
+
+ if (true && replayFailedUnitOfWorkWithInvokeGuardedCallback) {
+ if (mayReplay) {
+ var failedUnitOfWork = nextUnitOfWork;
+ 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);
+ } else {
+ throwException(root, returnFiber, sourceFiber, thrownValue, nextRenderExpirationTime);
+ nextUnitOfWork = completeUnitOfWork(sourceFiber);
+ continue;
+ }
+ }
+ }
+
+ break;
+ } while (true);
+
+ if (enableSchedulerTracing) {
+ tracing.__interactionsRef.current = prevInteractions;
+ }
+
+ isWorking = false;
+ ReactCurrentDispatcher.current = previousDispatcher;
+ resetContextDependences();
+ resetHooks();
+
+ if (didFatal) {
+ var _didCompleteRoot = false;
+ stopWorkLoopTimer(interruptedBy, _didCompleteRoot);
+ interruptedBy = null;
+ {
+ resetStackAfterFatalErrorInDev();
+ }
+ nextRoot = null;
+ onFatal(root);
+ return;
+ }
+
+ if (nextUnitOfWork !== null) {
+ var _didCompleteRoot2 = false;
+ stopWorkLoopTimer(interruptedBy, _didCompleteRoot2);
+ interruptedBy = null;
+ onYield(root);
+ return;
+ }
+
+ var didCompleteRoot = true;
+ stopWorkLoopTimer(interruptedBy, didCompleteRoot);
+ 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.");
+ nextRoot = null;
+ interruptedBy = null;
+
+ if (nextRenderDidError) {
+ if (hasLowerPriorityWork(root, expirationTime)) {
+ markSuspendedPriorityLevel(root, expirationTime);
+ var suspendedExpirationTime = expirationTime;
+ var rootExpirationTime = root.expirationTime;
+ onSuspend(root, rootWorkInProgress, suspendedExpirationTime, rootExpirationTime, -1);
+ return;
+ } else if (!root.didError && isYieldy) {
+ root.didError = true;
+
+ var _suspendedExpirationTime = root.nextExpirationTimeToWorkOn = expirationTime;
+
+ var _rootExpirationTime = root.expirationTime = Sync;
+
+ onSuspend(root, rootWorkInProgress, _suspendedExpirationTime, _rootExpirationTime, -1);
+ return;
+ }
+ }
+
+ if (isYieldy && nextLatestAbsoluteTimeoutMs !== -1) {
+ var _suspendedExpirationTime2 = expirationTime;
+ markSuspendedPriorityLevel(root, _suspendedExpirationTime2);
+ var earliestExpirationTime = findEarliestOutstandingPriorityLevel(root, expirationTime);
+ var earliestExpirationTimeMs = expirationTimeToMs(earliestExpirationTime);
+
+ if (earliestExpirationTimeMs < nextLatestAbsoluteTimeoutMs) {
+ nextLatestAbsoluteTimeoutMs = earliestExpirationTimeMs;
+ }
+
+ var currentTimeMs = expirationTimeToMs(requestCurrentTime());
+ var msUntilTimeout = nextLatestAbsoluteTimeoutMs - currentTimeMs;
+ msUntilTimeout = msUntilTimeout < 0 ? 0 : msUntilTimeout;
+ var _rootExpirationTime2 = root.expirationTime;
+ onSuspend(root, rootWorkInProgress, _suspendedExpirationTime2, _rootExpirationTime2, msUntilTimeout);
+ return;
+ }
+
+ onComplete(root, rootWorkInProgress, expirationTime);
+ }
+
+ function captureCommitPhaseError(sourceFiber, value) {
+ var expirationTime = Sync;
+ var fiber = sourceFiber.return;
+
+ while (fiber !== null) {
+ switch (fiber.tag) {
+ case ClassComponent:
+ var ctor = fiber.type;
+ var instance = fiber.stateNode;
+
+ if (typeof ctor.getDerivedStateFromError === "function" || typeof instance.componentDidCatch === "function" && !isAlreadyFailedLegacyErrorBoundary(instance)) {
+ var errorInfo = createCapturedValue(value, sourceFiber);
+ var update = createClassErrorUpdate(fiber, errorInfo, expirationTime);
+ enqueueUpdate(fiber, update);
+ scheduleWork(fiber, expirationTime);
+ return;
+ }
+
+ break;
+
+ case HostRoot:
+ {
+ var _errorInfo = createCapturedValue(value, sourceFiber);
+
+ var _update = createRootErrorUpdate(fiber, _errorInfo, expirationTime);
+
+ enqueueUpdate(fiber, _update);
+ 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);
+ scheduleWork(rootFiber, expirationTime);
+ }
+ }
+
+ function computeThreadID(expirationTime, interactionThreadID) {
+ return expirationTime * 1000 + interactionThreadID;
+ }
+
+ function computeExpirationForFiber(currentTime, fiber) {
+ var priorityLevel = scheduler.unstable_getCurrentPriorityLevel();
+ var expirationTime = void 0;
+
+ if ((fiber.mode & ConcurrentMode) === NoContext) {
+ expirationTime = Sync;
+ } else if (isWorking && !isCommitting$1) {
+ expirationTime = nextRenderExpirationTime;
+ } else {
+ switch (priorityLevel) {
+ case scheduler.unstable_ImmediatePriority:
+ expirationTime = Sync;
+ break;
+
+ case scheduler.unstable_UserBlockingPriority:
+ expirationTime = computeInteractiveExpiration(currentTime);
+ break;
+
+ case scheduler.unstable_NormalPriority:
+ expirationTime = computeAsyncExpiration(currentTime);
+ break;
+
+ case scheduler.unstable_LowPriority:
+ case scheduler.unstable_IdlePriority:
+ expirationTime = Never;
+ break;
+
+ default:
+ invariant(false, "Unknown priority level. This error is likely caused by a bug in " + "React. Please file an issue.");
+ }
+
+ if (nextRoot !== null && expirationTime === nextRenderExpirationTime) {
+ expirationTime -= 1;
+ }
+ }
+
+ if (priorityLevel === scheduler.unstable_UserBlockingPriority && (lowestPriorityPendingInteractiveExpirationTime === NoWork || expirationTime < lowestPriorityPendingInteractiveExpirationTime)) {
+ lowestPriorityPendingInteractiveExpirationTime = expirationTime;
+ }
+
+ return expirationTime;
+ }
+
+ function renderDidSuspend(root, absoluteTimeoutMs, suspendedTime) {
+ if (absoluteTimeoutMs >= 0 && nextLatestAbsoluteTimeoutMs < absoluteTimeoutMs) {
+ nextLatestAbsoluteTimeoutMs = absoluteTimeoutMs;
+ }
+ }
+
+ function renderDidError() {
+ nextRenderDidError = true;
+ }
+
+ function pingSuspendedRoot(root, thenable, pingTime) {
+ var pingCache = root.pingCache;
+
+ if (pingCache !== null) {
+ pingCache.delete(thenable);
+ }
+
+ if (nextRoot !== null && nextRenderExpirationTime === pingTime) {
+ nextRoot = null;
+ } else {
+ if (isPriorityLevelSuspended(root, pingTime)) {
+ markPingedPriorityLevel(root, pingTime);
+ var rootExpirationTime = root.expirationTime;
+
+ if (rootExpirationTime !== NoWork) {
+ requestWork(root, rootExpirationTime);
+ }
+ }
+ }
+ }
+
+ function retryTimedOutBoundary(boundaryFiber) {
+ var currentTime = requestCurrentTime();
+ var retryTime = computeExpirationForFiber(currentTime, boundaryFiber);
+ var root = scheduleWorkToRoot(boundaryFiber, retryTime);
+
+ if (root !== null) {
+ markPendingPriorityLevel(root, retryTime);
+ var rootExpirationTime = root.expirationTime;
+
+ if (rootExpirationTime !== NoWork) {
+ requestWork(root, rootExpirationTime);
+ }
+ }
+ }
+
+ function resolveRetryThenable(boundaryFiber, thenable) {
+ var retryCache = void 0;
+
+ if (enableSuspenseServerRenderer) {
+ switch (boundaryFiber.tag) {
+ case SuspenseComponent:
+ retryCache = boundaryFiber.stateNode;
+ break;
+
+ case DehydratedSuspenseComponent:
+ retryCache = boundaryFiber.memoizedState;
+ break;
+
+ default:
+ invariant(false, "Pinged unknown suspense boundary type. " + "This is probably a bug in React.");
+ }
+ } else {
+ retryCache = boundaryFiber.stateNode;
+ }
+
+ if (retryCache !== null) {
+ retryCache.delete(thenable);
+ }
+
+ retryTimedOutBoundary(boundaryFiber);
+ }
+
+ function scheduleWorkToRoot(fiber, expirationTime) {
+ recordScheduleUpdate();
+ {
+ if (fiber.tag === ClassComponent) {
+ var instance = fiber.stateNode;
+ warnAboutInvalidUpdates(instance);
+ }
+ }
+
+ if (fiber.expirationTime < expirationTime) {
+ fiber.expirationTime = expirationTime;
+ }
+
+ var alternate = fiber.alternate;
+
+ if (alternate !== null && alternate.expirationTime < expirationTime) {
+ alternate.expirationTime = expirationTime;
+ }
+
+ var node = fiber.return;
+ var root = null;
+
+ if (node === null && fiber.tag === HostRoot) {
+ root = fiber.stateNode;
+ } else {
+ while (node !== null) {
+ alternate = node.alternate;
+
+ if (node.childExpirationTime < expirationTime) {
+ node.childExpirationTime = expirationTime;
+
+ if (alternate !== null && alternate.childExpirationTime < expirationTime) {
+ alternate.childExpirationTime = expirationTime;
+ }
+ } else if (alternate !== null && alternate.childExpirationTime < expirationTime) {
+ alternate.childExpirationTime = expirationTime;
+ }
+
+ if (node.return === null && node.tag === HostRoot) {
+ root = node.stateNode;
+ break;
+ }
+
+ node = node.return;
+ }
+ }
+
+ if (enableSchedulerTracing) {
+ if (root !== null) {
+ var interactions = tracing.__interactionsRef.current;
+
+ if (interactions.size > 0) {
+ var pendingInteractionMap = root.pendingInteractionMap;
+ var pendingInteractions = pendingInteractionMap.get(expirationTime);
+
+ if (pendingInteractions != null) {
+ interactions.forEach(function (interaction) {
+ if (!pendingInteractions.has(interaction)) {
+ interaction.__count++;
+ }
+
+ pendingInteractions.add(interaction);
+ });
+ } else {
+ pendingInteractionMap.set(expirationTime, new Set(interactions));
+ interactions.forEach(function (interaction) {
+ interaction.__count++;
+ });
+ }
+
+ var subscriber = tracing.__subscriberRef.current;
+
+ if (subscriber !== null) {
+ var threadID = computeThreadID(expirationTime, root.interactionThreadID);
+ subscriber.onWorkScheduled(interactions, threadID);
+ }
+ }
+ }
+ }
+
+ return root;
+ }
+
+ function warnIfNotCurrentlyBatchingInDev(fiber) {
+ {
+ if (isRendering === false && isBatchingUpdates === false) {
+ warningWithoutStack$1(false, "An update to %s inside a test was not wrapped in act(...).\n\n" + "When testing, code that causes React state updates should be wrapped into act(...):\n\n" + "act(() => {\n" + " /* fire events that update state */\n" + "});\n" + "/* assert on the output */\n\n" + "This ensures that you're testing the behavior the user would see in the browser." + " Learn more at https://fb.me/react-wrap-tests-with-act" + "%s", getComponentName(fiber.type), getStackByFiberInDevAndProd(fiber));
+ }
+ }
+ }
+
+ function scheduleWork(fiber, expirationTime) {
+ var root = scheduleWorkToRoot(fiber, expirationTime);
+
+ if (root === null) {
+ {
+ switch (fiber.tag) {
+ case ClassComponent:
+ warnAboutUpdateOnUnmounted(fiber, true);
+ break;
+
+ case FunctionComponent:
+ case ForwardRef:
+ case MemoComponent:
+ case SimpleMemoComponent:
+ warnAboutUpdateOnUnmounted(fiber, false);
+ break;
+ }
+ }
+ return;
+ }
+
+ 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) {
+ nestedUpdateCount = 0;
+ 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.");
+ }
+ }
+
+ var firstScheduledRoot = null;
+ var lastScheduledRoot = null;
+ var callbackExpirationTime = NoWork;
+ var callbackID = void 0;
+ var isRendering = false;
+ var nextFlushedRoot = null;
+ var nextFlushedExpirationTime = NoWork;
+ var lowestPriorityPendingInteractiveExpirationTime = NoWork;
+ var hasUnhandledError = false;
+ var unhandledError = null;
+ var isBatchingUpdates = false;
+ var isUnbatchingUpdates = false;
+ var completedBatches = null;
+ var originalStartTimeMs = now$$1();
+ var currentRendererTime = msToExpirationTime(originalStartTimeMs);
+ var currentSchedulerTime = currentRendererTime;
+ var NESTED_UPDATE_LIMIT = 50;
+ var nestedUpdateCount = 0;
+ var lastCommittedRootDuringThisBatch = null;
+
+ function recomputeCurrentRendererTime() {
+ var currentTimeMs = now$$1() - originalStartTimeMs;
+ currentRendererTime = msToExpirationTime(currentTimeMs);
+ }
+
+ function scheduleCallbackWithExpirationTime(root, expirationTime) {
+ if (callbackExpirationTime !== NoWork) {
+ if (expirationTime < callbackExpirationTime) {
+ return;
+ } else {
+ if (callbackID !== null) {
+ cancelDeferredCallback$$1(callbackID);
+ }
+ }
+ } else {
+ startRequestCallbackTimer();
+ }
+
+ callbackExpirationTime = expirationTime;
+ var currentMs = now$$1() - originalStartTimeMs;
+ var expirationTimeMs = expirationTimeToMs(expirationTime);
+ var timeout = expirationTimeMs - currentMs;
+ callbackID = scheduleDeferredCallback$$1(performAsyncWork, {
+ timeout: timeout
+ });
+ }
+
+ function onFatal(root) {
+ root.finishedWork = null;
+ }
+
+ function onComplete(root, finishedWork, expirationTime) {
+ root.pendingCommitExpirationTime = expirationTime;
+ root.finishedWork = finishedWork;
+ }
+
+ function onSuspend(root, finishedWork, suspendedExpirationTime, rootExpirationTime, msUntilTimeout) {
+ root.expirationTime = rootExpirationTime;
+
+ if (msUntilTimeout === 0 && !shouldYield$$1()) {
+ root.pendingCommitExpirationTime = suspendedExpirationTime;
+ root.finishedWork = finishedWork;
+ } else if (msUntilTimeout > 0) {
+ root.timeoutHandle = scheduleTimeout(onTimeout.bind(null, root, finishedWork, suspendedExpirationTime), msUntilTimeout);
+ }
+ }
+
+ function onYield(root) {
+ root.finishedWork = null;
+ }
+
+ function onTimeout(root, finishedWork, suspendedExpirationTime) {
+ root.pendingCommitExpirationTime = suspendedExpirationTime;
+ root.finishedWork = finishedWork;
+ recomputeCurrentRendererTime();
+ currentSchedulerTime = currentRendererTime;
+ flushRoot(root, suspendedExpirationTime);
+ }
+
+ function onCommit(root, expirationTime) {
+ root.expirationTime = expirationTime;
+ root.finishedWork = null;
+ }
+
+ function requestCurrentTime() {
+ if (isRendering) {
+ return currentSchedulerTime;
+ }
+
+ findHighestPriorityRoot();
+
+ if (nextFlushedExpirationTime === NoWork || nextFlushedExpirationTime === Never) {
+ recomputeCurrentRendererTime();
+ currentSchedulerTime = currentRendererTime;
+ return currentSchedulerTime;
+ }
+
+ return currentSchedulerTime;
+ }
+
+ 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(root, 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 (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 (remainingExpirationTime > highestPriorityWork) {
+ highestPriorityWork = remainingExpirationTime;
+ highestPriorityRoot = root;
+ }
+
+ if (root === lastScheduledRoot) {
+ break;
+ }
+
+ if (highestPriorityWork === Sync) {
+ break;
+ }
+
+ previousScheduledRoot = root;
+ root = root.nextScheduledRoot;
+ }
+ }
+ }
+
+ nextFlushedRoot = highestPriorityRoot;
+ nextFlushedExpirationTime = highestPriorityWork;
+ }
+
+ function performAsyncWork(didTimeout) {
+ if (didTimeout) {
+ if (firstScheduledRoot !== null) {
+ recomputeCurrentRendererTime();
+ var root = firstScheduledRoot;
+
+ do {
+ didExpireAtExpirationTime(root, currentRendererTime);
+ root = root.nextScheduledRoot;
+ } while (root !== firstScheduledRoot);
+ }
+ }
+
+ performWork(NoWork, true);
+ }
+
+ function performSyncWork() {
+ performWork(Sync, false);
+ }
+
+ function performWork(minExpirationTime, isYieldy) {
+ findHighestPriorityRoot();
+
+ if (isYieldy) {
+ recomputeCurrentRendererTime();
+ currentSchedulerTime = currentRendererTime;
+
+ if (enableUserTimingAPI) {
+ var didExpire = nextFlushedExpirationTime > currentRendererTime;
+ var timeout = expirationTimeToMs(nextFlushedExpirationTime);
+ stopRequestCallbackTimer(didExpire, timeout);
+ }
+
+ while (nextFlushedRoot !== null && nextFlushedExpirationTime !== NoWork && minExpirationTime <= nextFlushedExpirationTime && !(shouldYield$$1() && currentRendererTime > nextFlushedExpirationTime)) {
+ performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, currentRendererTime > nextFlushedExpirationTime);
+ findHighestPriorityRoot();
+ recomputeCurrentRendererTime();
+ currentSchedulerTime = currentRendererTime;
+ }
+ } else {
+ while (nextFlushedRoot !== null && nextFlushedExpirationTime !== NoWork && minExpirationTime <= nextFlushedExpirationTime) {
+ performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, false);
+ findHighestPriorityRoot();
+ }
+ }
+
+ if (isYieldy) {
+ callbackExpirationTime = NoWork;
+ callbackID = null;
+ }
+
+ if (nextFlushedExpirationTime !== NoWork) {
+ scheduleCallbackWithExpirationTime(nextFlushedRoot, nextFlushedExpirationTime);
+ }
+
+ 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();
+ }
+
+ function finishRendering() {
+ nestedUpdateCount = 0;
+ lastCommittedRootDuringThisBatch = null;
+
+ 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;
+ var timeoutHandle = root.timeoutHandle;
+
+ if (timeoutHandle !== noTimeout) {
+ root.timeoutHandle = noTimeout;
+ cancelTimeout(timeoutHandle);
+ }
+
+ renderRoot(root, isYieldy);
+ 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;
+ var _timeoutHandle = root.timeoutHandle;
+
+ if (_timeoutHandle !== noTimeout) {
+ root.timeoutHandle = noTimeout;
+ cancelTimeout(_timeoutHandle);
+ }
+
+ renderRoot(root, isYieldy);
+ _finishedWork = root.finishedWork;
+
+ if (_finishedWork !== null) {
+ if (!shouldYield$$1()) {
+ completeRoot(root, _finishedWork, expirationTime);
+ } else {
+ root.finishedWork = _finishedWork;
+ }
+ }
+ }
+ }
+
+ 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;
+
+ if (root === lastCommittedRootDuringThisBatch) {
+ nestedUpdateCount++;
+ } else {
+ lastCommittedRootDuringThisBatch = root;
+ nestedUpdateCount = 0;
+ }
+
+ scheduler.unstable_runWithPriority(scheduler.unstable_ImmediatePriority, function () {
+ commitRoot(root, finishedWork);
+ });
+ }
+
+ 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 interactiveUpdates$1(fn, a, b) {
+ if (!isBatchingUpdates && !isRendering && lowestPriorityPendingInteractiveExpirationTime !== NoWork) {
+ performWork(lowestPriorityPendingInteractiveExpirationTime, false);
+ lowestPriorityPendingInteractiveExpirationTime = NoWork;
+ }
+
+ var previousIsBatchingUpdates = isBatchingUpdates;
+ isBatchingUpdates = true;
+
+ try {
+ return scheduler.unstable_runWithPriority(scheduler.unstable_UserBlockingPriority, function () {
+ return fn(a, b);
+ });
+ } finally {
+ isBatchingUpdates = previousIsBatchingUpdates;
+
+ if (!isBatchingUpdates && !isRendering) {
+ performSyncWork();
+ }
+ }
+ }
+
+ function flushInteractiveUpdates$1() {
+ if (!isRendering && lowestPriorityPendingInteractiveExpirationTime !== NoWork) {
+ performWork(lowestPriorityPendingInteractiveExpirationTime, false);
+ lowestPriorityPendingInteractiveExpirationTime = NoWork;
+ }
+ }
+
+ var didWarnAboutNestedUpdates = void 0;
+ var didWarnAboutFindNodeInStrictMode = void 0;
+ {
+ didWarnAboutNestedUpdates = false;
+ didWarnAboutFindNodeInStrictMode = {};
+ }
+
+ function getContextForSubtree(parentComponent) {
+ if (!parentComponent) {
+ return emptyContextObject;
+ }
+
+ var fiber = get$1(parentComponent);
+ var parentContext = findCurrentUnmaskedContext(fiber);
+
+ if (fiber.tag === ClassComponent) {
+ var Component = fiber.type;
+
+ if (isContextProvider(Component)) {
+ return processChildContext(fiber, Component, parentContext);
+ }
+ }
+
+ return parentContext;
+ }
+
+ function scheduleRootUpdate(current$$1, element, expirationTime, callback) {
+ {
+ if (phase === "render" && current !== null && !didWarnAboutNestedUpdates) {
+ didWarnAboutNestedUpdates = true;
+ warningWithoutStack$1(false, "Render methods should be a pure function of props and state; " + "triggering nested component updates from render is not allowed. " + "If necessary, trigger nested updates in componentDidUpdate.\n\n" + "Check the render method of %s.", getComponentName(current.type) || "Unknown");
+ }
+ }
+ var update = createUpdate(expirationTime);
+ update.payload = {
+ element: element
+ };
+ callback = callback === undefined ? null : callback;
+
+ if (callback !== null) {
+ !(typeof callback === "function") ? warningWithoutStack$1(false, "render(...): Expected the last optional `callback` argument to be a " + "function. Instead received: %s.", callback) : void 0;
+ update.callback = callback;
+ }
+
+ flushPassiveEffects();
+ enqueueUpdate(current$$1, update);
+ scheduleWork(current$$1, expirationTime);
+ return expirationTime;
+ }
+
+ function updateContainerAtExpirationTime(element, container, parentComponent, expirationTime, callback) {
+ var current$$1 = container.current;
+ {
+ if (ReactFiberInstrumentation_1.debugTool) {
+ if (current$$1.alternate === null) {
+ ReactFiberInstrumentation_1.debugTool.onMountContainer(container);
+ } else if (element === null) {
+ ReactFiberInstrumentation_1.debugTool.onUnmountContainer(container);
+ } else {
+ ReactFiberInstrumentation_1.debugTool.onUpdateContainer(container);
+ }
+ }
+ }
+ var context = getContextForSubtree(parentComponent);
+
+ if (container.context === null) {
+ container.context = context;
+ } else {
+ container.pendingContext = context;
+ }
+
+ return scheduleRootUpdate(current$$1, element, expirationTime, callback);
+ }
+
+ function findHostInstance(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 findHostInstanceWithWarning(component, methodName) {
+ {
+ 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;
+ }
+
+ if (hostFiber.mode & StrictMode) {
+ var componentName = getComponentName(fiber.type) || "Component";
+
+ if (!didWarnAboutFindNodeInStrictMode[componentName]) {
+ didWarnAboutFindNodeInStrictMode[componentName] = true;
+
+ if (fiber.mode & StrictMode) {
+ warningWithoutStack$1(false, "%s is deprecated in StrictMode. " + "%s was passed an instance of %s which is inside StrictMode. " + "Instead, add a ref directly to the element you want to reference." + "\n%s" + "\n\nLearn more about using refs safely here:" + "\nhttps://fb.me/react-strict-mode-find-node", methodName, methodName, componentName, getStackByFiberInDevAndProd(hostFiber));
+ } else {
+ warningWithoutStack$1(false, "%s is deprecated in StrictMode. " + "%s was passed an instance of %s which renders StrictMode children. " + "Instead, add a ref directly to the element you want to reference." + "\n%s" + "\n\nLearn more about using refs safely here:" + "\nhttps://fb.me/react-strict-mode-find-node", methodName, methodName, componentName, getStackByFiberInDevAndProd(hostFiber));
+ }
+ }
+ }
+
+ return hostFiber.stateNode;
+ }
+ return findHostInstance(component);
+ }
+
+ function createContainer(containerInfo, isConcurrent, hydrate) {
+ return createFiberRoot(containerInfo, isConcurrent, hydrate);
+ }
+
+ function updateContainer(element, container, parentComponent, callback) {
+ var current$$1 = container.current;
+ var currentTime = requestCurrentTime();
+ var expirationTime = computeExpirationForFiber(currentTime, current$$1);
+ 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;
+ }
+ }
+
+ var overrideProps = null;
+ {
+ var copyWithSetImpl = function copyWithSetImpl(obj, path, idx, value) {
+ if (idx >= path.length) {
+ return value;
+ }
+
+ var key = path[idx];
+ var updated = Array.isArray(obj) ? obj.slice() : _extends({}, obj);
+ updated[key] = copyWithSetImpl(obj[key], path, idx + 1, value);
+ return updated;
+ };
+
+ var copyWithSet = function copyWithSet(obj, path, value) {
+ return copyWithSetImpl(obj, path, 0, value);
+ };
+
+ overrideProps = function overrideProps(fiber, path, value) {
+ flushPassiveEffects();
+ fiber.pendingProps = copyWithSet(fiber.memoizedProps, path, value);
+
+ if (fiber.alternate) {
+ fiber.alternate.pendingProps = fiber.pendingProps;
+ }
+
+ scheduleWork(fiber, Sync);
+ };
+ }
+
+ function injectIntoDevTools(devToolsConfig) {
+ var _findFiberByHostInstance = devToolsConfig.findFiberByHostInstance;
+ var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+ return injectInternals(_extends({}, devToolsConfig, {
+ overrideProps: overrideProps,
+ currentDispatcherRef: ReactCurrentDispatcher,
+ findHostInstanceByFiber: function findHostInstanceByFiber(fiber) {
+ var hostFiber = findCurrentHostFiber(fiber);
+
+ if (hostFiber === null) {
+ return null;
+ }
+
+ return hostFiber.stateNode;
+ },
+ findFiberByHostInstance: function findFiberByHostInstance(instance) {
+ if (!_findFiberByHostInstance) {
+ return null;
+ }
+
+ return _findFiberByHostInstance(instance);
+ }
+ }));
+ }
+
+ function _createPortal(children, containerInfo, implementation) {
+ var key = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
+ return {
+ $$typeof: REACT_PORTAL_TYPE,
+ key: key == null ? null : "" + key,
+ children: children,
+ containerInfo: containerInfo,
+ implementation: implementation
+ };
+ }
+
+ var ReactVersion = "16.8.3";
+
+ var NativeMethodsMixin = function NativeMethodsMixin(findNodeHandle, findHostInstance) {
+ var NativeMethodsMixin = {
+ measure: function measure(callback) {
+ UIManager.measure(findNodeHandle(this), mountSafeCallback_NOT_REALLY_SAFE(this, callback));
+ },
+ measureInWindow: function measureInWindow(callback) {
+ UIManager.measureInWindow(findNodeHandle(this), mountSafeCallback_NOT_REALLY_SAFE(this, callback));
+ },
+ measureLayout: function measureLayout(relativeToNativeNode, onSuccess, onFail) {
+ UIManager.measureLayout(findNodeHandle(this), relativeToNativeNode, mountSafeCallback_NOT_REALLY_SAFE(this, onFail), mountSafeCallback_NOT_REALLY_SAFE(this, onSuccess));
+ },
+ setNativeProps: function setNativeProps(nativeProps) {
+ {
+ if (warnAboutDeprecatedSetNativeProps) {
+ warningWithoutStack$1(false, "Warning: Calling ref.setNativeProps(nativeProps) " + "is deprecated and will be removed in a future release. " + "Use the setNativeProps export from the react-native package instead." + "\n\timport {setNativeProps} from 'react-native';\n\tsetNativeProps(ref, nativeProps);\n");
+ }
+ }
+ var maybeInstance = void 0;
+
+ try {
+ maybeInstance = findHostInstance(this);
+ } catch (error) {}
+
+ if (maybeInstance == null) {
+ return;
+ }
+
+ var nativeTag = maybeInstance._nativeTag || maybeInstance.canonical._nativeTag;
+ var viewConfig = maybeInstance.viewConfig || maybeInstance.canonical.viewConfig;
+ {
+ warnForStyleProps(nativeProps, viewConfig.validAttributes);
+ }
+ var updatePayload = create(nativeProps, viewConfig.validAttributes);
+
+ if (updatePayload != null) {
+ UIManager.updateView(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_NOT_REALLY_SAFE(this, callback));
+ };
+
+ ReactNativeComponent.prototype.measureInWindow = function measureInWindow(callback) {
+ UIManager.measureInWindow(findNodeHandle(this), mountSafeCallback_NOT_REALLY_SAFE(this, callback));
+ };
+
+ ReactNativeComponent.prototype.measureLayout = function measureLayout(relativeToNativeNode, onSuccess, onFail) {
+ UIManager.measureLayout(findNodeHandle(this), relativeToNativeNode, mountSafeCallback_NOT_REALLY_SAFE(this, onFail), mountSafeCallback_NOT_REALLY_SAFE(this, onSuccess));
+ };
+
+ ReactNativeComponent.prototype.setNativeProps = function setNativeProps(nativeProps) {
+ {
+ if (warnAboutDeprecatedSetNativeProps) {
+ warningWithoutStack$1(false, "Warning: Calling ref.setNativeProps(nativeProps) " + "is deprecated and will be removed in a future release. " + "Use the setNativeProps export from the react-native package instead." + "\n\timport {setNativeProps} from 'react-native';\n\tsetNativeProps(ref, nativeProps);\n");
+ }
+ }
+ var maybeInstance = void 0;
+
+ try {
+ maybeInstance = findHostInstance(this);
+ } catch (error) {}
+
+ if (maybeInstance == null) {
+ return;
+ }
+
+ var nativeTag = maybeInstance._nativeTag || maybeInstance.canonical._nativeTag;
+ var viewConfig = maybeInstance.viewConfig || maybeInstance.canonical.viewConfig;
+ var updatePayload = create(nativeProps, viewConfig.validAttributes);
+
+ if (updatePayload != null) {
+ UIManager.updateView(nativeTag, viewConfig.uiViewClassName, updatePayload);
+ }
+ };
+
+ return ReactNativeComponent;
+ }(React.Component);
+
+ return ReactNativeComponent;
+ };
+
+ var emptyObject$1 = {};
+ {
+ Object.freeze(emptyObject$1);
+ }
+ 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$1;
+ }
+
+ return emptyObject$1;
+ };
+
+ var getHostNode = function getHostNode(fiber, findNodeHandle) {
+ var hostNode = void 0;
+
+ while (fiber) {
+ if (fiber.stateNode !== null && fiber.tag === HostComponent) {
+ hostNode = findNodeHandle(fiber.stateNode);
+ }
+
+ if (hostNode) {
+ return hostNode;
+ }
+
+ fiber = fiber.child;
+ }
+
+ return null;
+ };
+
+ var createHierarchy = function createHierarchy(fiberHierarchy) {
+ return fiberHierarchy.map(function (fiber) {
+ return {
+ name: getComponentName(fiber.type),
+ getInspectorData: function getInspectorData(findNodeHandle) {
+ return {
+ measure: function measure(callback) {
+ return 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$1,
+ selection: null,
+ source: null
+ };
+ }
+
+ var fiber = findCurrentFiberUsingSlowPath(closestInstance);
+ var fiberHierarchy = getOwnerHierarchy(fiber);
+ var instance = lastNonHostInstance(fiberHierarchy);
+ var hierarchy = createHierarchy(fiberHierarchy);
+ var props = getHostProps(instance);
+ var source = instance._debugSource;
+ var selection = fiberHierarchy.indexOf(instance);
+ return {
+ hierarchy: hierarchy,
+ props: props,
+ selection: selection,
+ source: source
+ };
+ };
+ }
+
+ function setNativeProps(handle, nativeProps) {
+ if (handle._nativeTag == null) {
+ !(handle._nativeTag != null) ? warningWithoutStack$1(false, "setNativeProps was called with a ref that isn't a " + "native component. Use React.forwardRef to get access to the underlying native component") : void 0;
+ return;
+ }
+
+ {
+ warnForStyleProps(nativeProps, handle.viewConfig.validAttributes);
+ }
+ var updatePayload = create(nativeProps, handle.viewConfig.validAttributes);
+
+ if (updatePayload != null) {
+ UIManager.updateView(handle._nativeTag, handle.viewConfig.uiViewClassName, updatePayload);
+ }
+ }
+
+ var ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner;
+
+ function findNodeHandle(componentOrHandle) {
+ {
+ var owner = ReactCurrentOwner.current;
+
+ if (owner !== null && owner.stateNode !== null) {
+ !owner.stateNode._warnedAboutRefsInRender ? warningWithoutStack$1(false, "%s is accessing findNodeHandle inside its render(). " + "render() should be a pure function of props and state. It should " + "never access something that requires stale data from the previous " + "render, such as refs. Move this logic to componentDidMount and " + "componentDidUpdate instead.", getComponentName(owner.type) || "A component") : void 0;
+ owner.stateNode._warnedAboutRefsInRender = true;
+ }
+ }
+
+ if (componentOrHandle == null) {
+ return null;
+ }
+
+ if (typeof componentOrHandle === "number") {
+ return componentOrHandle;
+ }
+
+ if (componentOrHandle._nativeTag) {
+ return componentOrHandle._nativeTag;
+ }
+
+ if (componentOrHandle.canonical && componentOrHandle.canonical._nativeTag) {
+ return componentOrHandle.canonical._nativeTag;
+ }
+
+ var hostInstance = void 0;
+ {
+ hostInstance = findHostInstanceWithWarning(componentOrHandle, "findNodeHandle");
+ }
+
+ if (hostInstance == null) {
+ return hostInstance;
+ }
+
+ if (hostInstance.canonical) {
+ return hostInstance.canonical._nativeTag;
+ }
+
+ return hostInstance._nativeTag;
+ }
+
+ setBatchingImplementation(batchedUpdates$1, interactiveUpdates$1, flushInteractiveUpdates$1);
+
+ function computeComponentStackForErrorReporting(reactTag) {
+ var fiber = getInstanceFromTag(reactTag);
+
+ if (!fiber) {
+ return "";
+ }
+
+ return getStackByFiberInDevAndProd(fiber);
+ }
+
+ var roots = new Map();
+ var ReactNativeRenderer = {
+ NativeComponent: ReactNativeComponent(findNodeHandle, findHostInstance),
+ findNodeHandle: findNodeHandle,
+ setNativeProps: setNativeProps,
+ 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;
+ module.exports = reactNativeRenderer;
+ })();
+ }
+},85,[14,86,173,71,174,11,49,175,80,176,16,177,180,98],"node_modules\\react-native\\Libraries\\Renderer\\oss\\ReactNativeRenderer-dev.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var start = Date.now();
+
+ _$$_REQUIRE(_dependencyMap[0], "setUpGlobals");
+
+ _$$_REQUIRE(_dependencyMap[1], "polyfillES6Collections");
+
+ _$$_REQUIRE(_dependencyMap[2], "setUpSystrace");
+
+ _$$_REQUIRE(_dependencyMap[3], "setUpErrorHandling");
+
+ _$$_REQUIRE(_dependencyMap[4], "checkNativeVersion");
+
+ _$$_REQUIRE(_dependencyMap[5], "polyfillPromise");
+
+ _$$_REQUIRE(_dependencyMap[6], "setUpRegeneratorRuntime");
+
+ _$$_REQUIRE(_dependencyMap[7], "setUpTimers");
+
+ _$$_REQUIRE(_dependencyMap[8], "setUpXHR");
+
+ _$$_REQUIRE(_dependencyMap[9], "setUpAlert");
+
+ _$$_REQUIRE(_dependencyMap[10], "setUpGeolocation");
+
+ _$$_REQUIRE(_dependencyMap[11], "setUpBatchedBridge");
+
+ _$$_REQUIRE(_dependencyMap[12], "setUpSegmentFetcher");
+
+ if (__DEV__) {
+ _$$_REQUIRE(_dependencyMap[13], "setUpDeveloperTools");
+ }
+
+ var PerformanceLogger = _$$_REQUIRE(_dependencyMap[14], "PerformanceLogger");
+
+ PerformanceLogger.markPoint('initializeCore_start', PerformanceLogger.currentTimestamp() - (Date.now() - start));
+ PerformanceLogger.markPoint('initializeCore_end');
+},86,[87,88,96,97,107,110,117,118,123,144,147,151,165,166,156],"node_modules\\react-native\\Libraries\\Core\\InitializeCore.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ if (global.GLOBAL === undefined) {
+ global.GLOBAL = global;
+ }
+
+ if (global.window === undefined) {
+ global.window = global;
+ }
+
+ if (global.self === undefined) {
+ global.self = global;
+ }
+
+ global.process = global.process || {};
+ global.process.env = global.process.env || {};
+
+ if (!global.process.env.NODE_ENV) {
+ global.process.env.NODE_ENV = __DEV__ ? 'development' : 'production';
+ }
+},87,[],"node_modules\\react-native\\Libraries\\Core\\setUpGlobals.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _require = _$$_REQUIRE(_dependencyMap[0], "PolyfillFunctions"),
+ polyfillGlobal = _require.polyfillGlobal;
+
+ var _shouldPolyfillCollection = _$$_REQUIRE(_dependencyMap[1], "_shouldPolyfillES6Collection");
+
+ if (_shouldPolyfillCollection('Map')) {
+ _$$_REQUIRE(_dependencyMap[2], "_wrapObjectFreezeAndFriends");
+
+ polyfillGlobal('Map', function () {
+ return _$$_REQUIRE(_dependencyMap[3], "Map");
+ });
+ }
+
+ if (_shouldPolyfillCollection('Set')) {
+ _$$_REQUIRE(_dependencyMap[2], "_wrapObjectFreezeAndFriends");
+
+ polyfillGlobal('Set', function () {
+ return _$$_REQUIRE(_dependencyMap[4], "Set");
+ });
+ }
+},88,[89,90,91,92,95],"node_modules\\react-native\\Libraries\\Core\\polyfillES6Collections.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var defineLazyObjectProperty = _$$_REQUIRE(_dependencyMap[0], "defineLazyObjectProperty");
+
+ function polyfillObjectProperty(object, name, getValue) {
+ var descriptor = Object.getOwnPropertyDescriptor(object, name);
+
+ if (__DEV__ && descriptor) {
+ var backupName = "original" + name[0].toUpperCase() + name.substr(1);
+ Object.defineProperty(object, backupName, descriptor);
+ }
+
+ var _ref = descriptor || {},
+ enumerable = _ref.enumerable,
+ writable = _ref.writable,
+ configurable = _ref.configurable;
+
+ if (descriptor && !configurable) {
+ console.error('Failed to set polyfill. ' + name + ' is not configurable.');
+ return;
+ }
+
+ defineLazyObjectProperty(object, name, {
+ get: getValue,
+ enumerable: enumerable !== false,
+ writable: writable !== false
+ });
+ }
+
+ function polyfillGlobal(name, getValue) {
+ polyfillObjectProperty(global, name, getValue);
+ }
+
+ module.exports = {
+ polyfillObjectProperty: polyfillObjectProperty,
+ polyfillGlobal: polyfillGlobal
+ };
+},89,[51],"node_modules\\react-native\\Libraries\\Utilities\\PolyfillFunctions.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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;
+},90,[],"node_modules\\react-native\\Libraries\\vendor\\core\\_shouldPolyfillES6Collection.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var testMap;
+
+ function getTestMap() {
+ return testMap || (testMap = new (_$$_REQUIRE(_dependencyMap[0], "./Map"))());
+ }
+
+ ['freeze', 'seal', 'preventExtensions'].forEach(function (name) {
+ var method = Object[name];
+
+ if (typeof method === 'function') {
+ Object[name] = function (obj) {
+ try {
+ getTestMap().set(obj, obj).delete(obj);
+ } finally {
+ return method.call(Object, obj);
+ }
+ };
+ }
+ });
+},91,[92],"node_modules\\react-native\\Libraries\\vendor\\core\\_wrapObjectFreezeAndFriends.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _shouldPolyfillES6Collection = _$$_REQUIRE(_dependencyMap[2], "_shouldPolyfillES6Collection");
+
+ var guid = _$$_REQUIRE(_dependencyMap[3], "guid");
+
+ var toIterator = _$$_REQUIRE(_dependencyMap[4], "toIterator");
+
+ module.exports = function (global, undefined) {
+ if (!_shouldPolyfillES6Collection('Map')) {
+ return global.Map;
+ }
+
+ _$$_REQUIRE(_dependencyMap[5], "./_wrapObjectFreezeAndFriends");
+
+ var hasOwn = Object.prototype.hasOwnProperty;
+ 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 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 (hasOwn.call(map, 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);
+ }
+ }
+
+ var getHash = function () {
+ var propIsEnumerable = Object.prototype.propertyIsEnumerable;
+ var hashProperty = '__MAP_POLYFILL_INTERNAL_HASH__';
+ var hashCounter = 0;
+ var nonExtensibleObjects = [];
+ var nonExtensibleHashes = [];
+ return function getHash(o) {
+ if (hasOwn.call(o, hashProperty)) {
+ return o[hashProperty];
+ }
+
+ if (!isES5) {
+ if (hasOwn.call(o, 'propertyIsEnumerable') && hasOwn.call(o.propertyIsEnumerable, hashProperty)) {
+ return o.propertyIsEnumerable[hashProperty];
+ }
+ }
+
+ if (isExtensible(o)) {
+ if (isES5) {
+ Object.defineProperty(o, hashProperty, {
+ enumerable: false,
+ writable: false,
+ configurable: false,
+ value: ++hashCounter
+ });
+ return hashCounter;
+ }
+
+ if (o.propertyIsEnumerable) {
+ o.propertyIsEnumerable = function () {
+ return propIsEnumerable.apply(this, arguments);
+ };
+
+ return o.propertyIsEnumerable[hashProperty] = ++hashCounter;
+ }
+ }
+
+ var index = nonExtensibleObjects.indexOf(o);
+
+ if (index < 0) {
+ index = nonExtensibleObjects.length;
+ nonExtensibleObjects[index] = o;
+ nonExtensibleHashes[index] = ++hashCounter;
+ }
+
+ return nonExtensibleHashes[index];
+ };
+ }();
+
+ return Map;
+ }(Function('return this')());
+},92,[3,4,90,93,94,91],"node_modules\\react-native\\Libraries\\vendor\\core\\Map.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ function guid() {
+ return 'f' + (Math.random() * (1 << 30)).toString(16).replace('.', '');
+ }
+
+ module.exports = guid;
+},93,[],"node_modules\\react-native\\Libraries\\vendor\\core\\guid.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ var 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;
+},94,[14,3,4],"node_modules\\react-native\\Libraries\\vendor\\core\\toIterator.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var Map = _$$_REQUIRE(_dependencyMap[2], "Map");
+
+ var _shouldPolyfillES6Collection = _$$_REQUIRE(_dependencyMap[3], "_shouldPolyfillES6Collection");
+
+ var toIterator = _$$_REQUIRE(_dependencyMap[4], "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')());
+},95,[3,4,92,90,94],"node_modules\\react-native\\Libraries\\vendor\\core\\Set.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ if (global.__RCTProfileIsProfiling) {
+ var Systrace = _$$_REQUIRE(_dependencyMap[0], "Systrace");
+
+ Systrace.installReactHook();
+ Systrace.setEnabled(true);
+ }
+},96,[48],"node_modules\\react-native\\Libraries\\Core\\setUpSystrace.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var ExceptionsManager = _$$_REQUIRE(_dependencyMap[0], "ExceptionsManager");
+
+ ExceptionsManager.installConsoleErrorReporter();
+
+ if (!global.__fbDisableExceptionsManager) {
+ var handleError = function handleError(e, isFatal) {
+ try {
+ ExceptionsManager.handleException(e, isFatal);
+ } catch (ee) {
+ console.log('Failed to print error: ', ee.message);
+ throw e;
+ }
+ };
+
+ var ErrorUtils = _$$_REQUIRE(_dependencyMap[1], "ErrorUtils");
+
+ ErrorUtils.setGlobalHandler(handleError);
+ }
+},97,[98,47],"node_modules\\react-native\\Libraries\\Core\\setUpErrorHandling.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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;
+ var message = e.jsEngine == null ? e.message : e.message + ", js engine: " + e.jsEngine;
+
+ if (isFatal) {
+ ExceptionsManager.reportFatalException(message, stack, currentExceptionID);
+ } else {
+ ExceptionsManager.reportSoftException(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
+ };
+},98,[36,99,101,50],"node_modules\\react-native\\Libraries\\Core\\ExceptionsManager.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ function parseErrorStack(e) {
+ if (!e || !e.stack) {
+ return [];
+ }
+
+ var stacktraceParser = _$$_REQUIRE(_dependencyMap[0], "stacktrace-parser");
+
+ var stack = Array.isArray(e.stack) ? e.stack : stacktraceParser.parse(e.stack);
+ var framesToPop = typeof e.framesToPop === 'number' ? e.framesToPop : 0;
+
+ while (framesToPop--) {
+ stack.shift();
+ }
+
+ return stack;
+ }
+
+ module.exports = parseErrorStack;
+},99,[100],"node_modules\\react-native\\Libraries\\Core\\Devtools\\parseErrorStack.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ (function (global, factory) {
+ typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : typeof define === 'function' && define.amd ? define(['exports'], factory) : (global = global || self, factory(global.stackTraceParser = {}));
+ })(this, function (exports) {
+ 'use strict';
+
+ var UNKNOWN_FUNCTION = '';
+
+ function parse(stackString) {
+ var lines = stackString.split('\n');
+ return lines.reduce(function (stack, line) {
+ var parseResult = parseChrome(line) || parseWinjs(line) || parseGecko(line) || parseJSC(line) || parseNode(line);
+
+ if (parseResult) {
+ stack.push(parseResult);
+ }
+
+ return stack;
+ }, []);
+ }
+
+ var chromeRe = /^\s*at (.*?) ?\(((?:file|https?|blob|chrome-extension|native|eval|webpack||\/).*?)(?::(\d+))?(?::(\d+))?\)?\s*$/i;
+ var chromeEvalRe = /\((\S*)(?::(\d+))(?::(\d+))\)/;
+
+ function parseChrome(line) {
+ var parts = chromeRe.exec(line);
+
+ if (!parts) {
+ return null;
+ }
+
+ var isNative = parts[2] && parts[2].indexOf('native') === 0;
+ var isEval = parts[2] && parts[2].indexOf('eval') === 0;
+ var submatch = chromeEvalRe.exec(parts[2]);
+
+ if (isEval && submatch != null) {
+ parts[2] = submatch[1];
+ parts[3] = submatch[2];
+ parts[4] = submatch[3];
+ }
+
+ return {
+ file: !isNative ? parts[2] : null,
+ methodName: parts[1] || UNKNOWN_FUNCTION,
+ arguments: isNative ? [parts[2]] : [],
+ lineNumber: parts[3] ? +parts[3] : null,
+ column: parts[4] ? +parts[4] : null
+ };
+ }
+
+ var winjsRe = /^\s*at (?:((?:\[object object\])?.+) )?\(?((?:file|ms-appx|https?|webpack|blob):.*?):(\d+)(?::(\d+))?\)?\s*$/i;
+
+ function parseWinjs(line) {
+ var parts = winjsRe.exec(line);
+
+ if (!parts) {
+ return null;
+ }
+
+ return {
+ file: parts[2],
+ methodName: parts[1] || UNKNOWN_FUNCTION,
+ arguments: [],
+ lineNumber: +parts[3],
+ column: parts[4] ? +parts[4] : null
+ };
+ }
+
+ var geckoRe = /^\s*(.*?)(?:\((.*?)\))?(?:^|@)((?:file|https?|blob|chrome|webpack|resource|\[native).*?|[^@]*bundle)(?::(\d+))?(?::(\d+))?\s*$/i;
+ var geckoEvalRe = /(\S+) line (\d+)(?: > eval line \d+)* > eval/i;
+
+ function parseGecko(line) {
+ var parts = geckoRe.exec(line);
+
+ if (!parts) {
+ return null;
+ }
+
+ var isEval = parts[3] && parts[3].indexOf(' > eval') > -1;
+ var submatch = geckoEvalRe.exec(parts[3]);
+
+ if (isEval && submatch != null) {
+ parts[3] = submatch[1];
+ parts[4] = submatch[2];
+ parts[5] = null;
+ }
+
+ return {
+ file: parts[3],
+ methodName: parts[1] || UNKNOWN_FUNCTION,
+ arguments: parts[2] ? parts[2].split(',') : [],
+ lineNumber: parts[4] ? +parts[4] : null,
+ column: parts[5] ? +parts[5] : null
+ };
+ }
+
+ var javaScriptCoreRe = /^(?:\s*([^@]*)(?:\((.*?)\))?@)?(\S.*?):(\d+)(?::(\d+))?\s*$/i;
+
+ function parseJSC(line) {
+ var parts = javaScriptCoreRe.exec(line);
+
+ if (!parts) {
+ return null;
+ }
+
+ return {
+ file: parts[3],
+ methodName: parts[1] || UNKNOWN_FUNCTION,
+ arguments: [],
+ lineNumber: +parts[4],
+ column: parts[5] ? +parts[5] : null
+ };
+ }
+
+ var nodeRe = /^\s*at (?:((?:\[object object\])?\S+(?: \[as \S+\])?) )?\(?(.*?):(\d+)(?::(\d+))?\)?\s*$/i;
+
+ function parseNode(line) {
+ var parts = nodeRe.exec(line);
+
+ if (!parts) {
+ return null;
+ }
+
+ return {
+ file: parts[2],
+ methodName: parts[1] || UNKNOWN_FUNCTION,
+ arguments: [],
+ lineNumber: +parts[3],
+ column: parts[4] ? +parts[4] : null
+ };
+ }
+
+ exports.parse = parse;
+ Object.defineProperty(exports, '__esModule', {
+ value: true
+ });
+ });
+},100,[],"node_modules\\stacktrace-parser\\dist\\stack-trace-parser.umd.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _regeneratorRuntime = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/regenerator");
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/defineProperty");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var getDevServer = _$$_REQUIRE(_dependencyMap[2], "getDevServer");
+
+ var _require = _$$_REQUIRE(_dependencyMap[3], "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[4], "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();
+ }
+ }
+ });
+ }
+
+ module.exports = symbolicateStackTrace;
+},101,[102,32,104,36,105],"node_modules\\react-native\\Libraries\\Core\\Devtools\\symbolicateStackTrace.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "regenerator-runtime");
+},102,[103],"node_modules\\@babel\\runtime\\regenerator\\index.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var runtime = function (exports) {
+ "use strict";
+
+ var Op = Object.prototype;
+ var hasOwn = Op.hasOwnProperty;
+ var undefined;
+ var $Symbol = typeof Symbol === "function" ? Symbol : {};
+ var iteratorSymbol = $Symbol.iterator || "@@iterator";
+ var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";
+ var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
+
+ function wrap(innerFn, outerFn, self, tryLocsList) {
+ var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
+ var generator = Object.create(protoGenerator.prototype);
+ var context = new Context(tryLocsList || []);
+ generator._invoke = makeInvokeMethod(innerFn, self, context);
+ return generator;
+ }
+
+ exports.wrap = wrap;
+
+ function tryCatch(fn, obj, arg) {
+ try {
+ return {
+ type: "normal",
+ arg: fn.call(obj, arg)
+ };
+ } catch (err) {
+ return {
+ type: "throw",
+ arg: err
+ };
+ }
+ }
+
+ var GenStateSuspendedStart = "suspendedStart";
+ var GenStateSuspendedYield = "suspendedYield";
+ var GenStateExecuting = "executing";
+ var GenStateCompleted = "completed";
+ var ContinueSentinel = {};
+
+ function Generator() {}
+
+ function GeneratorFunction() {}
+
+ function GeneratorFunctionPrototype() {}
+
+ var IteratorPrototype = {};
+
+ IteratorPrototype[iteratorSymbol] = function () {
+ return this;
+ };
+
+ var getProto = Object.getPrototypeOf;
+ var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
+
+ if (NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
+ IteratorPrototype = NativeIteratorPrototype;
+ }
+
+ var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
+ GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;
+ GeneratorFunctionPrototype.constructor = GeneratorFunction;
+ GeneratorFunctionPrototype[toStringTagSymbol] = GeneratorFunction.displayName = "GeneratorFunction";
+
+ function defineIteratorMethods(prototype) {
+ ["next", "throw", "return"].forEach(function (method) {
+ prototype[method] = function (arg) {
+ return this._invoke(method, arg);
+ };
+ });
+ }
+
+ exports.isGeneratorFunction = function (genFun) {
+ var ctor = typeof genFun === "function" && genFun.constructor;
+ return ctor ? ctor === GeneratorFunction || (ctor.displayName || ctor.name) === "GeneratorFunction" : false;
+ };
+
+ exports.mark = function (genFun) {
+ if (Object.setPrototypeOf) {
+ Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
+ } else {
+ genFun.__proto__ = GeneratorFunctionPrototype;
+
+ if (!(toStringTagSymbol in genFun)) {
+ genFun[toStringTagSymbol] = "GeneratorFunction";
+ }
+ }
+
+ genFun.prototype = Object.create(Gp);
+ return genFun;
+ };
+
+ exports.awrap = function (arg) {
+ return {
+ __await: arg
+ };
+ };
+
+ function AsyncIterator(generator) {
+ function invoke(method, arg, resolve, reject) {
+ var record = tryCatch(generator[method], generator, arg);
+
+ if (record.type === "throw") {
+ reject(record.arg);
+ } else {
+ var result = record.arg;
+ var value = result.value;
+
+ if (value && typeof value === "object" && hasOwn.call(value, "__await")) {
+ return Promise.resolve(value.__await).then(function (value) {
+ invoke("next", value, resolve, reject);
+ }, function (err) {
+ invoke("throw", err, resolve, reject);
+ });
+ }
+
+ return Promise.resolve(value).then(function (unwrapped) {
+ result.value = unwrapped;
+ resolve(result);
+ }, function (error) {
+ return invoke("throw", error, resolve, reject);
+ });
+ }
+ }
+
+ var previousPromise;
+
+ function enqueue(method, arg) {
+ function callInvokeWithMethodAndArg() {
+ return new Promise(function (resolve, reject) {
+ invoke(method, arg, resolve, reject);
+ });
+ }
+
+ return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
+ }
+
+ this._invoke = enqueue;
+ }
+
+ defineIteratorMethods(AsyncIterator.prototype);
+
+ AsyncIterator.prototype[asyncIteratorSymbol] = function () {
+ return this;
+ };
+
+ exports.AsyncIterator = AsyncIterator;
+
+ exports.async = function (innerFn, outerFn, self, tryLocsList) {
+ var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList));
+ return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {
+ return result.done ? result.value : iter.next();
+ });
+ };
+
+ function makeInvokeMethod(innerFn, self, context) {
+ var state = GenStateSuspendedStart;
+ return function invoke(method, arg) {
+ if (state === GenStateExecuting) {
+ throw new Error("Generator is already running");
+ }
+
+ if (state === GenStateCompleted) {
+ if (method === "throw") {
+ throw arg;
+ }
+
+ return doneResult();
+ }
+
+ context.method = method;
+ context.arg = arg;
+
+ while (true) {
+ var delegate = context.delegate;
+
+ if (delegate) {
+ var delegateResult = maybeInvokeDelegate(delegate, context);
+
+ if (delegateResult) {
+ if (delegateResult === ContinueSentinel) continue;
+ return delegateResult;
+ }
+ }
+
+ if (context.method === "next") {
+ context.sent = context._sent = context.arg;
+ } else if (context.method === "throw") {
+ if (state === GenStateSuspendedStart) {
+ state = GenStateCompleted;
+ throw context.arg;
+ }
+
+ context.dispatchException(context.arg);
+ } else if (context.method === "return") {
+ context.abrupt("return", context.arg);
+ }
+
+ state = GenStateExecuting;
+ var record = tryCatch(innerFn, self, context);
+
+ if (record.type === "normal") {
+ state = context.done ? GenStateCompleted : GenStateSuspendedYield;
+
+ if (record.arg === ContinueSentinel) {
+ continue;
+ }
+
+ return {
+ value: record.arg,
+ done: context.done
+ };
+ } else if (record.type === "throw") {
+ state = GenStateCompleted;
+ context.method = "throw";
+ context.arg = record.arg;
+ }
+ }
+ };
+ }
+
+ function maybeInvokeDelegate(delegate, context) {
+ var method = delegate.iterator[context.method];
+
+ if (method === undefined) {
+ context.delegate = null;
+
+ if (context.method === "throw") {
+ if (delegate.iterator["return"]) {
+ context.method = "return";
+ context.arg = undefined;
+ maybeInvokeDelegate(delegate, context);
+
+ if (context.method === "throw") {
+ return ContinueSentinel;
+ }
+ }
+
+ context.method = "throw";
+ context.arg = new TypeError("The iterator does not provide a 'throw' method");
+ }
+
+ return ContinueSentinel;
+ }
+
+ var record = tryCatch(method, delegate.iterator, context.arg);
+
+ if (record.type === "throw") {
+ context.method = "throw";
+ context.arg = record.arg;
+ context.delegate = null;
+ return ContinueSentinel;
+ }
+
+ var info = record.arg;
+
+ if (!info) {
+ context.method = "throw";
+ context.arg = new TypeError("iterator result is not an object");
+ context.delegate = null;
+ return ContinueSentinel;
+ }
+
+ if (info.done) {
+ context[delegate.resultName] = info.value;
+ context.next = delegate.nextLoc;
+
+ if (context.method !== "return") {
+ context.method = "next";
+ context.arg = undefined;
+ }
+ } else {
+ return info;
+ }
+
+ context.delegate = null;
+ return ContinueSentinel;
+ }
+
+ defineIteratorMethods(Gp);
+ Gp[toStringTagSymbol] = "Generator";
+
+ Gp[iteratorSymbol] = function () {
+ return this;
+ };
+
+ Gp.toString = function () {
+ return "[object Generator]";
+ };
+
+ function pushTryEntry(locs) {
+ var entry = {
+ tryLoc: locs[0]
+ };
+
+ if (1 in locs) {
+ entry.catchLoc = locs[1];
+ }
+
+ if (2 in locs) {
+ entry.finallyLoc = locs[2];
+ entry.afterLoc = locs[3];
+ }
+
+ this.tryEntries.push(entry);
+ }
+
+ function resetTryEntry(entry) {
+ var record = entry.completion || {};
+ record.type = "normal";
+ delete record.arg;
+ entry.completion = record;
+ }
+
+ function Context(tryLocsList) {
+ this.tryEntries = [{
+ tryLoc: "root"
+ }];
+ tryLocsList.forEach(pushTryEntry, this);
+ this.reset(true);
+ }
+
+ exports.keys = function (object) {
+ var keys = [];
+
+ for (var key in object) {
+ keys.push(key);
+ }
+
+ keys.reverse();
+ return function next() {
+ while (keys.length) {
+ var key = keys.pop();
+
+ if (key in object) {
+ next.value = key;
+ next.done = false;
+ return next;
+ }
+ }
+
+ next.done = true;
+ return next;
+ };
+ };
+
+ function values(iterable) {
+ if (iterable) {
+ var iteratorMethod = iterable[iteratorSymbol];
+
+ if (iteratorMethod) {
+ return iteratorMethod.call(iterable);
+ }
+
+ if (typeof iterable.next === "function") {
+ return iterable;
+ }
+
+ if (!isNaN(iterable.length)) {
+ var i = -1,
+ next = function next() {
+ while (++i < iterable.length) {
+ if (hasOwn.call(iterable, i)) {
+ next.value = iterable[i];
+ next.done = false;
+ return next;
+ }
+ }
+
+ next.value = undefined;
+ next.done = true;
+ return next;
+ };
+
+ return next.next = next;
+ }
+ }
+
+ return {
+ next: doneResult
+ };
+ }
+
+ exports.values = values;
+
+ function doneResult() {
+ return {
+ value: undefined,
+ done: true
+ };
+ }
+
+ Context.prototype = {
+ constructor: Context,
+ reset: function reset(skipTempReset) {
+ this.prev = 0;
+ this.next = 0;
+ this.sent = this._sent = undefined;
+ this.done = false;
+ this.delegate = null;
+ this.method = "next";
+ this.arg = undefined;
+ this.tryEntries.forEach(resetTryEntry);
+
+ if (!skipTempReset) {
+ for (var name in this) {
+ if (name.charAt(0) === "t" && hasOwn.call(this, name) && !isNaN(+name.slice(1))) {
+ this[name] = undefined;
+ }
+ }
+ }
+ },
+ stop: function stop() {
+ this.done = true;
+ var rootEntry = this.tryEntries[0];
+ var rootRecord = rootEntry.completion;
+
+ if (rootRecord.type === "throw") {
+ throw rootRecord.arg;
+ }
+
+ return this.rval;
+ },
+ dispatchException: function dispatchException(exception) {
+ if (this.done) {
+ throw exception;
+ }
+
+ var context = this;
+
+ function handle(loc, caught) {
+ record.type = "throw";
+ record.arg = exception;
+ context.next = loc;
+
+ if (caught) {
+ context.method = "next";
+ context.arg = undefined;
+ }
+
+ return !!caught;
+ }
+
+ for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+ var entry = this.tryEntries[i];
+ var record = entry.completion;
+
+ if (entry.tryLoc === "root") {
+ return handle("end");
+ }
+
+ if (entry.tryLoc <= this.prev) {
+ var hasCatch = hasOwn.call(entry, "catchLoc");
+ var hasFinally = hasOwn.call(entry, "finallyLoc");
+
+ if (hasCatch && hasFinally) {
+ if (this.prev < entry.catchLoc) {
+ return handle(entry.catchLoc, true);
+ } else if (this.prev < entry.finallyLoc) {
+ return handle(entry.finallyLoc);
+ }
+ } else if (hasCatch) {
+ if (this.prev < entry.catchLoc) {
+ return handle(entry.catchLoc, true);
+ }
+ } else if (hasFinally) {
+ if (this.prev < entry.finallyLoc) {
+ return handle(entry.finallyLoc);
+ }
+ } else {
+ throw new Error("try statement without catch or finally");
+ }
+ }
+ }
+ },
+ abrupt: function abrupt(type, arg) {
+ for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+ var entry = this.tryEntries[i];
+
+ if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
+ var finallyEntry = entry;
+ break;
+ }
+ }
+
+ if (finallyEntry && (type === "break" || type === "continue") && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc) {
+ finallyEntry = null;
+ }
+
+ var record = finallyEntry ? finallyEntry.completion : {};
+ record.type = type;
+ record.arg = arg;
+
+ if (finallyEntry) {
+ this.method = "next";
+ this.next = finallyEntry.finallyLoc;
+ return ContinueSentinel;
+ }
+
+ return this.complete(record);
+ },
+ complete: function complete(record, afterLoc) {
+ if (record.type === "throw") {
+ throw record.arg;
+ }
+
+ if (record.type === "break" || record.type === "continue") {
+ this.next = record.arg;
+ } else if (record.type === "return") {
+ this.rval = this.arg = record.arg;
+ this.method = "return";
+ this.next = "end";
+ } else if (record.type === "normal" && afterLoc) {
+ this.next = afterLoc;
+ }
+
+ return ContinueSentinel;
+ },
+ finish: function finish(finallyLoc) {
+ for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+ var entry = this.tryEntries[i];
+
+ if (entry.finallyLoc === finallyLoc) {
+ this.complete(entry.completion, entry.afterLoc);
+ resetTryEntry(entry);
+ return ContinueSentinel;
+ }
+ }
+ },
+ "catch": function _catch(tryLoc) {
+ for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+ var entry = this.tryEntries[i];
+
+ if (entry.tryLoc === tryLoc) {
+ var record = entry.completion;
+
+ if (record.type === "throw") {
+ var thrown = record.arg;
+ resetTryEntry(entry);
+ }
+
+ return thrown;
+ }
+ }
+
+ throw new Error("illegal catch attempt");
+ },
+ delegateYield: function delegateYield(iterable, resultName, nextLoc) {
+ this.delegate = {
+ iterator: values(iterable),
+ resultName: resultName,
+ nextLoc: nextLoc
+ };
+
+ if (this.method === "next") {
+ this.arg = undefined;
+ }
+
+ return ContinueSentinel;
+ }
+ };
+ return exports;
+ }(typeof module === "object" ? module.exports : {});
+
+ try {
+ regeneratorRuntime = runtime;
+ } catch (accidentalStrictMode) {
+ Function("r", "regeneratorRuntime = r")(runtime);
+ }
+},103,[],"node_modules\\regenerator-runtime\\runtime.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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;
+},104,[36],"node_modules\\react-native\\Libraries\\Core\\Devtools\\getDevServer.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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
+ };
+ }
+},105,[106],"node_modules\\react-native\\Libraries\\Network\\fetch.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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;
+ }
+
+ if ('responseType' in xhr && support.blob) {
+ xhr.responseType = 'blob';
+ }
+
+ 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);
+},106,[],"node_modules\\react-native\\Libraries\\vendor\\core\\whatwg-fetch.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var ReactNativeVersionCheck = _$$_REQUIRE(_dependencyMap[0], "ReactNativeVersionCheck");
+
+ ReactNativeVersionCheck.checkVersions();
+},107,[108],"node_modules\\react-native\\Libraries\\Core\\checkNativeVersion.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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 : '');
+ }
+},108,[36,109],"node_modules\\react-native\\Libraries\\Core\\ReactNativeVersionCheck.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ exports.version = {
+ major: 0,
+ minor: 59,
+ patch: 0,
+ prerelease: null
+ };
+},109,[],"node_modules\\react-native\\Libraries\\Core\\ReactNativeVersion.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _require = _$$_REQUIRE(_dependencyMap[0], "PolyfillFunctions"),
+ polyfillGlobal = _require.polyfillGlobal;
+
+ polyfillGlobal('Promise', function () {
+ return _$$_REQUIRE(_dependencyMap[1], "Promise");
+ });
+},110,[89,111],"node_modules\\react-native\\Libraries\\Core\\polyfillPromise.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var Promise = _$$_REQUIRE(_dependencyMap[0], "promise/setimmediate/es6-extensions");
+
+ _$$_REQUIRE(_dependencyMap[1], "promise/setimmediate/done");
+
+ Promise.prototype.finally = function (onSettled) {
+ return this.then(onSettled, onSettled);
+ };
+
+ if (__DEV__) {
+ _$$_REQUIRE(_dependencyMap[2], "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[3], "pretty-format")(error);
+ }
+
+ var warning = "Possible Unhandled Promise Rejection (id: " + id + "):\n" + (message + "\n") + (stack == null ? '' : stack);
+ console.warn(warning);
+ },
+ onHandled: function onHandled(id) {
+ var warning = "Promise Rejection Handled (id: " + id + ")\n" + 'This means you can ignore any previous messages of the form ' + ("\"Possible Unhandled Promise Rejection (id: " + id + "):\"");
+ console.warn(warning);
+ }
+ });
+ }
+
+ module.exports = Promise;
+},111,[112,114,115,116],"node_modules\\react-native\\Libraries\\Promise.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var Promise = _$$_REQUIRE(_dependencyMap[0], "./core.js");
+
+ module.exports = Promise;
+ var TRUE = valuePromise(true);
+ var FALSE = valuePromise(false);
+ var NULL = valuePromise(null);
+ var UNDEFINED = valuePromise(undefined);
+ var ZERO = valuePromise(0);
+ var EMPTYSTRING = valuePromise('');
+
+ function valuePromise(value) {
+ var p = new Promise(Promise._61);
+ p._65 = 1;
+ p._55 = value;
+ return p;
+ }
+
+ Promise.resolve = function (value) {
+ if (value instanceof Promise) return value;
+ if (value === null) return NULL;
+ if (value === undefined) return UNDEFINED;
+ if (value === true) return TRUE;
+ if (value === false) return FALSE;
+ if (value === 0) return ZERO;
+ if (value === '') return EMPTYSTRING;
+
+ if (typeof value === 'object' || typeof value === 'function') {
+ try {
+ var then = value.then;
+
+ if (typeof then === 'function') {
+ return new Promise(then.bind(value));
+ }
+ } catch (ex) {
+ return new Promise(function (resolve, reject) {
+ reject(ex);
+ });
+ }
+ }
+
+ return valuePromise(value);
+ };
+
+ Promise.all = function (arr) {
+ var args = Array.prototype.slice.call(arr);
+ return new Promise(function (resolve, reject) {
+ if (args.length === 0) return resolve([]);
+ var remaining = args.length;
+
+ function res(i, val) {
+ if (val && (typeof val === 'object' || typeof val === 'function')) {
+ if (val instanceof Promise && val.then === Promise.prototype.then) {
+ while (val._65 === 3) {
+ val = val._55;
+ }
+
+ if (val._65 === 1) return res(i, val._55);
+ if (val._65 === 2) reject(val._55);
+ val.then(function (val) {
+ res(i, val);
+ }, reject);
+ return;
+ } else {
+ var then = val.then;
+
+ if (typeof then === 'function') {
+ var p = new Promise(then.bind(val));
+ p.then(function (val) {
+ res(i, val);
+ }, reject);
+ return;
+ }
+ }
+ }
+
+ args[i] = val;
+
+ if (--remaining === 0) {
+ resolve(args);
+ }
+ }
+
+ for (var i = 0; i < args.length; i++) {
+ res(i, args[i]);
+ }
+ });
+ };
+
+ Promise.reject = function (value) {
+ return new Promise(function (resolve, reject) {
+ reject(value);
+ });
+ };
+
+ Promise.race = function (values) {
+ return new Promise(function (resolve, reject) {
+ values.forEach(function (value) {
+ Promise.resolve(value).then(resolve, reject);
+ });
+ });
+ };
+
+ Promise.prototype['catch'] = function (onRejected) {
+ return this.then(null, onRejected);
+ };
+},112,[113],"node_modules\\promise\\setimmediate\\es6-extensions.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ function noop() {}
+
+ var LAST_ERROR = null;
+ var IS_ERROR = {};
+
+ function getThen(obj) {
+ try {
+ return obj.then;
+ } catch (ex) {
+ LAST_ERROR = ex;
+ return IS_ERROR;
+ }
+ }
+
+ function tryCallOne(fn, a) {
+ try {
+ return fn(a);
+ } catch (ex) {
+ LAST_ERROR = ex;
+ return IS_ERROR;
+ }
+ }
+
+ function tryCallTwo(fn, a, b) {
+ try {
+ fn(a, b);
+ } catch (ex) {
+ LAST_ERROR = ex;
+ return IS_ERROR;
+ }
+ }
+
+ module.exports = Promise;
+
+ function Promise(fn) {
+ if (typeof this !== 'object') {
+ throw new TypeError('Promises must be constructed via new');
+ }
+
+ if (typeof fn !== 'function') {
+ throw new TypeError('Promise constructor\'s argument is not a function');
+ }
+
+ this._40 = 0;
+ this._65 = 0;
+ this._55 = null;
+ this._72 = null;
+ if (fn === noop) return;
+ doResolve(fn, this);
+ }
+
+ Promise._37 = null;
+ Promise._87 = null;
+ Promise._61 = noop;
+
+ Promise.prototype.then = function (onFulfilled, onRejected) {
+ if (this.constructor !== Promise) {
+ return safeThen(this, onFulfilled, onRejected);
+ }
+
+ var res = new Promise(noop);
+ handle(this, new Handler(onFulfilled, onRejected, res));
+ return res;
+ };
+
+ function safeThen(self, onFulfilled, onRejected) {
+ return new self.constructor(function (resolve, reject) {
+ var res = new Promise(noop);
+ res.then(resolve, reject);
+ handle(self, new Handler(onFulfilled, onRejected, res));
+ });
+ }
+
+ function handle(self, deferred) {
+ while (self._65 === 3) {
+ self = self._55;
+ }
+
+ if (Promise._37) {
+ Promise._37(self);
+ }
+
+ if (self._65 === 0) {
+ if (self._40 === 0) {
+ self._40 = 1;
+ self._72 = deferred;
+ return;
+ }
+
+ if (self._40 === 1) {
+ self._40 = 2;
+ self._72 = [self._72, deferred];
+ return;
+ }
+
+ self._72.push(deferred);
+
+ return;
+ }
+
+ handleResolved(self, deferred);
+ }
+
+ function handleResolved(self, deferred) {
+ setImmediate(function () {
+ var cb = self._65 === 1 ? deferred.onFulfilled : deferred.onRejected;
+
+ if (cb === null) {
+ if (self._65 === 1) {
+ resolve(deferred.promise, self._55);
+ } else {
+ reject(deferred.promise, self._55);
+ }
+
+ return;
+ }
+
+ var ret = tryCallOne(cb, self._55);
+
+ if (ret === IS_ERROR) {
+ reject(deferred.promise, LAST_ERROR);
+ } else {
+ resolve(deferred.promise, ret);
+ }
+ });
+ }
+
+ function resolve(self, newValue) {
+ if (newValue === self) {
+ return reject(self, new TypeError('A promise cannot be resolved with itself.'));
+ }
+
+ if (newValue && (typeof newValue === 'object' || typeof newValue === 'function')) {
+ var then = getThen(newValue);
+
+ if (then === IS_ERROR) {
+ return reject(self, LAST_ERROR);
+ }
+
+ if (then === self.then && newValue instanceof Promise) {
+ self._65 = 3;
+ self._55 = newValue;
+ finale(self);
+ return;
+ } else if (typeof then === 'function') {
+ doResolve(then.bind(newValue), self);
+ return;
+ }
+ }
+
+ self._65 = 1;
+ self._55 = newValue;
+ finale(self);
+ }
+
+ function reject(self, newValue) {
+ self._65 = 2;
+ self._55 = newValue;
+
+ if (Promise._87) {
+ Promise._87(self, newValue);
+ }
+
+ finale(self);
+ }
+
+ function finale(self) {
+ if (self._40 === 1) {
+ handle(self, self._72);
+ self._72 = null;
+ }
+
+ if (self._40 === 2) {
+ for (var i = 0; i < self._72.length; i++) {
+ handle(self, self._72[i]);
+ }
+
+ self._72 = null;
+ }
+ }
+
+ function Handler(onFulfilled, onRejected, promise) {
+ this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null;
+ this.onRejected = typeof onRejected === 'function' ? onRejected : null;
+ this.promise = promise;
+ }
+
+ function doResolve(fn, promise) {
+ var done = false;
+ var res = tryCallTwo(fn, function (value) {
+ if (done) return;
+ done = true;
+ resolve(promise, value);
+ }, function (reason) {
+ if (done) return;
+ done = true;
+ reject(promise, reason);
+ });
+
+ if (!done && res === IS_ERROR) {
+ done = true;
+ reject(promise, LAST_ERROR);
+ }
+ }
+},113,[],"node_modules\\promise\\setimmediate\\core.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var Promise = _$$_REQUIRE(_dependencyMap[0], "./core.js");
+
+ module.exports = Promise;
+
+ Promise.prototype.done = function (onFulfilled, onRejected) {
+ var self = arguments.length ? this.then.apply(this, arguments) : this;
+ self.then(null, function (err) {
+ setTimeout(function () {
+ throw err;
+ }, 0);
+ });
+ };
+},114,[113],"node_modules\\promise\\setimmediate\\done.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var Promise = _$$_REQUIRE(_dependencyMap[0], "./core");
+
+ 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;
+ });
+ }
+},115,[113],"node_modules\\promise\\setimmediate\\rejection-tracking.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ (function (global, factory) {
+ typeof exports === 'object' && typeof module !== 'undefined' ? factory() : typeof define === 'function' && define.amd ? define(factory) : factory();
+ })(this, function () {
+ 'use strict';
+
+ function createCommonjsModule(fn, module) {
+ return module = {
+ exports: {}
+ }, fn(module, module.exports), module.exports;
+ }
+
+ var colorName = {
+ "aliceblue": [240, 248, 255],
+ "antiquewhite": [250, 235, 215],
+ "aqua": [0, 255, 255],
+ "aquamarine": [127, 255, 212],
+ "azure": [240, 255, 255],
+ "beige": [245, 245, 220],
+ "bisque": [255, 228, 196],
+ "black": [0, 0, 0],
+ "blanchedalmond": [255, 235, 205],
+ "blue": [0, 0, 255],
+ "blueviolet": [138, 43, 226],
+ "brown": [165, 42, 42],
+ "burlywood": [222, 184, 135],
+ "cadetblue": [95, 158, 160],
+ "chartreuse": [127, 255, 0],
+ "chocolate": [210, 105, 30],
+ "coral": [255, 127, 80],
+ "cornflowerblue": [100, 149, 237],
+ "cornsilk": [255, 248, 220],
+ "crimson": [220, 20, 60],
+ "cyan": [0, 255, 255],
+ "darkblue": [0, 0, 139],
+ "darkcyan": [0, 139, 139],
+ "darkgoldenrod": [184, 134, 11],
+ "darkgray": [169, 169, 169],
+ "darkgreen": [0, 100, 0],
+ "darkgrey": [169, 169, 169],
+ "darkkhaki": [189, 183, 107],
+ "darkmagenta": [139, 0, 139],
+ "darkolivegreen": [85, 107, 47],
+ "darkorange": [255, 140, 0],
+ "darkorchid": [153, 50, 204],
+ "darkred": [139, 0, 0],
+ "darksalmon": [233, 150, 122],
+ "darkseagreen": [143, 188, 143],
+ "darkslateblue": [72, 61, 139],
+ "darkslategray": [47, 79, 79],
+ "darkslategrey": [47, 79, 79],
+ "darkturquoise": [0, 206, 209],
+ "darkviolet": [148, 0, 211],
+ "deeppink": [255, 20, 147],
+ "deepskyblue": [0, 191, 255],
+ "dimgray": [105, 105, 105],
+ "dimgrey": [105, 105, 105],
+ "dodgerblue": [30, 144, 255],
+ "firebrick": [178, 34, 34],
+ "floralwhite": [255, 250, 240],
+ "forestgreen": [34, 139, 34],
+ "fuchsia": [255, 0, 255],
+ "gainsboro": [220, 220, 220],
+ "ghostwhite": [248, 248, 255],
+ "gold": [255, 215, 0],
+ "goldenrod": [218, 165, 32],
+ "gray": [128, 128, 128],
+ "green": [0, 128, 0],
+ "greenyellow": [173, 255, 47],
+ "grey": [128, 128, 128],
+ "honeydew": [240, 255, 240],
+ "hotpink": [255, 105, 180],
+ "indianred": [205, 92, 92],
+ "indigo": [75, 0, 130],
+ "ivory": [255, 255, 240],
+ "khaki": [240, 230, 140],
+ "lavender": [230, 230, 250],
+ "lavenderblush": [255, 240, 245],
+ "lawngreen": [124, 252, 0],
+ "lemonchiffon": [255, 250, 205],
+ "lightblue": [173, 216, 230],
+ "lightcoral": [240, 128, 128],
+ "lightcyan": [224, 255, 255],
+ "lightgoldenrodyellow": [250, 250, 210],
+ "lightgray": [211, 211, 211],
+ "lightgreen": [144, 238, 144],
+ "lightgrey": [211, 211, 211],
+ "lightpink": [255, 182, 193],
+ "lightsalmon": [255, 160, 122],
+ "lightseagreen": [32, 178, 170],
+ "lightskyblue": [135, 206, 250],
+ "lightslategray": [119, 136, 153],
+ "lightslategrey": [119, 136, 153],
+ "lightsteelblue": [176, 196, 222],
+ "lightyellow": [255, 255, 224],
+ "lime": [0, 255, 0],
+ "limegreen": [50, 205, 50],
+ "linen": [250, 240, 230],
+ "magenta": [255, 0, 255],
+ "maroon": [128, 0, 0],
+ "mediumaquamarine": [102, 205, 170],
+ "mediumblue": [0, 0, 205],
+ "mediumorchid": [186, 85, 211],
+ "mediumpurple": [147, 112, 219],
+ "mediumseagreen": [60, 179, 113],
+ "mediumslateblue": [123, 104, 238],
+ "mediumspringgreen": [0, 250, 154],
+ "mediumturquoise": [72, 209, 204],
+ "mediumvioletred": [199, 21, 133],
+ "midnightblue": [25, 25, 112],
+ "mintcream": [245, 255, 250],
+ "mistyrose": [255, 228, 225],
+ "moccasin": [255, 228, 181],
+ "navajowhite": [255, 222, 173],
+ "navy": [0, 0, 128],
+ "oldlace": [253, 245, 230],
+ "olive": [128, 128, 0],
+ "olivedrab": [107, 142, 35],
+ "orange": [255, 165, 0],
+ "orangered": [255, 69, 0],
+ "orchid": [218, 112, 214],
+ "palegoldenrod": [238, 232, 170],
+ "palegreen": [152, 251, 152],
+ "paleturquoise": [175, 238, 238],
+ "palevioletred": [219, 112, 147],
+ "papayawhip": [255, 239, 213],
+ "peachpuff": [255, 218, 185],
+ "peru": [205, 133, 63],
+ "pink": [255, 192, 203],
+ "plum": [221, 160, 221],
+ "powderblue": [176, 224, 230],
+ "purple": [128, 0, 128],
+ "rebeccapurple": [102, 51, 153],
+ "red": [255, 0, 0],
+ "rosybrown": [188, 143, 143],
+ "royalblue": [65, 105, 225],
+ "saddlebrown": [139, 69, 19],
+ "salmon": [250, 128, 114],
+ "sandybrown": [244, 164, 96],
+ "seagreen": [46, 139, 87],
+ "seashell": [255, 245, 238],
+ "sienna": [160, 82, 45],
+ "silver": [192, 192, 192],
+ "skyblue": [135, 206, 235],
+ "slateblue": [106, 90, 205],
+ "slategray": [112, 128, 144],
+ "slategrey": [112, 128, 144],
+ "snow": [255, 250, 250],
+ "springgreen": [0, 255, 127],
+ "steelblue": [70, 130, 180],
+ "tan": [210, 180, 140],
+ "teal": [0, 128, 128],
+ "thistle": [216, 191, 216],
+ "tomato": [255, 99, 71],
+ "turquoise": [64, 224, 208],
+ "violet": [238, 130, 238],
+ "wheat": [245, 222, 179],
+ "white": [255, 255, 255],
+ "whitesmoke": [245, 245, 245],
+ "yellow": [255, 255, 0],
+ "yellowgreen": [154, 205, 50]
+ };
+ var conversions = createCommonjsModule(function (module) {
+ var reverseKeywords = {};
+
+ for (var key in colorName) {
+ if (colorName.hasOwnProperty(key)) {
+ reverseKeywords[colorName[key]] = key;
+ }
+ }
+
+ var convert = module.exports = {
+ rgb: {
+ channels: 3,
+ labels: 'rgb'
+ },
+ hsl: {
+ channels: 3,
+ labels: 'hsl'
+ },
+ hsv: {
+ channels: 3,
+ labels: 'hsv'
+ },
+ hwb: {
+ channels: 3,
+ labels: 'hwb'
+ },
+ cmyk: {
+ channels: 4,
+ labels: 'cmyk'
+ },
+ xyz: {
+ channels: 3,
+ labels: 'xyz'
+ },
+ lab: {
+ channels: 3,
+ labels: 'lab'
+ },
+ lch: {
+ channels: 3,
+ labels: 'lch'
+ },
+ hex: {
+ channels: 1,
+ labels: ['hex']
+ },
+ keyword: {
+ channels: 1,
+ labels: ['keyword']
+ },
+ ansi16: {
+ channels: 1,
+ labels: ['ansi16']
+ },
+ ansi256: {
+ channels: 1,
+ labels: ['ansi256']
+ },
+ hcg: {
+ channels: 3,
+ labels: ['h', 'c', 'g']
+ },
+ apple: {
+ channels: 3,
+ labels: ['r16', 'g16', 'b16']
+ },
+ gray: {
+ channels: 1,
+ labels: ['gray']
+ }
+ };
+
+ for (var model in convert) {
+ if (convert.hasOwnProperty(model)) {
+ if (!('channels' in convert[model])) {
+ throw new Error('missing channels property: ' + model);
+ }
+
+ if (!('labels' in convert[model])) {
+ throw new Error('missing channel labels property: ' + model);
+ }
+
+ if (convert[model].labels.length !== convert[model].channels) {
+ throw new Error('channel and label counts mismatch: ' + model);
+ }
+
+ var channels = convert[model].channels;
+ var labels = convert[model].labels;
+ delete convert[model].channels;
+ delete convert[model].labels;
+ Object.defineProperty(convert[model], 'channels', {
+ value: channels
+ });
+ Object.defineProperty(convert[model], 'labels', {
+ value: labels
+ });
+ }
+ }
+
+ convert.rgb.hsl = function (rgb) {
+ var r = rgb[0] / 255;
+ var g = rgb[1] / 255;
+ var b = rgb[2] / 255;
+ var min = Math.min(r, g, b);
+ var max = Math.max(r, g, b);
+ var delta = max - min;
+ var h;
+ var s;
+ var l;
+
+ if (max === min) {
+ h = 0;
+ } else if (r === max) {
+ h = (g - b) / delta;
+ } else if (g === max) {
+ h = 2 + (b - r) / delta;
+ } else if (b === max) {
+ h = 4 + (r - g) / delta;
+ }
+
+ h = Math.min(h * 60, 360);
+
+ if (h < 0) {
+ h += 360;
+ }
+
+ l = (min + max) / 2;
+
+ if (max === min) {
+ s = 0;
+ } else if (l <= 0.5) {
+ s = delta / (max + min);
+ } else {
+ s = delta / (2 - max - min);
+ }
+
+ return [h, s * 100, l * 100];
+ };
+
+ convert.rgb.hsv = function (rgb) {
+ var rdif;
+ var gdif;
+ var bdif;
+ var h;
+ var s;
+ var r = rgb[0] / 255;
+ var g = rgb[1] / 255;
+ var b = rgb[2] / 255;
+ var v = Math.max(r, g, b);
+ var diff = v - Math.min(r, g, b);
+
+ var diffc = function diffc(c) {
+ return (v - c) / 6 / diff + 1 / 2;
+ };
+
+ if (diff === 0) {
+ h = s = 0;
+ } else {
+ s = diff / v;
+ rdif = diffc(r);
+ gdif = diffc(g);
+ bdif = diffc(b);
+
+ if (r === v) {
+ h = bdif - gdif;
+ } else if (g === v) {
+ h = 1 / 3 + rdif - bdif;
+ } else if (b === v) {
+ h = 2 / 3 + gdif - rdif;
+ }
+
+ if (h < 0) {
+ h += 1;
+ } else if (h > 1) {
+ h -= 1;
+ }
+ }
+
+ return [h * 360, s * 100, v * 100];
+ };
+
+ convert.rgb.hwb = function (rgb) {
+ var r = rgb[0];
+ var g = rgb[1];
+ var b = rgb[2];
+ var h = convert.rgb.hsl(rgb)[0];
+ var w = 1 / 255 * Math.min(r, Math.min(g, b));
+ b = 1 - 1 / 255 * Math.max(r, Math.max(g, b));
+ return [h, w * 100, b * 100];
+ };
+
+ convert.rgb.cmyk = function (rgb) {
+ var r = rgb[0] / 255;
+ var g = rgb[1] / 255;
+ var b = rgb[2] / 255;
+ var c;
+ var m;
+ var y;
+ var k;
+ k = Math.min(1 - r, 1 - g, 1 - b);
+ c = (1 - r - k) / (1 - k) || 0;
+ m = (1 - g - k) / (1 - k) || 0;
+ y = (1 - b - k) / (1 - k) || 0;
+ return [c * 100, m * 100, y * 100, k * 100];
+ };
+
+ function comparativeDistance(x, y) {
+ return Math.pow(x[0] - y[0], 2) + Math.pow(x[1] - y[1], 2) + Math.pow(x[2] - y[2], 2);
+ }
+
+ convert.rgb.keyword = function (rgb) {
+ var reversed = reverseKeywords[rgb];
+
+ if (reversed) {
+ return reversed;
+ }
+
+ var currentClosestDistance = Infinity;
+ var currentClosestKeyword;
+
+ for (var keyword in colorName) {
+ if (colorName.hasOwnProperty(keyword)) {
+ var value = colorName[keyword];
+ var distance = comparativeDistance(rgb, value);
+
+ if (distance < currentClosestDistance) {
+ currentClosestDistance = distance;
+ currentClosestKeyword = keyword;
+ }
+ }
+ }
+
+ return currentClosestKeyword;
+ };
+
+ convert.keyword.rgb = function (keyword) {
+ return colorName[keyword];
+ };
+
+ convert.rgb.xyz = function (rgb) {
+ var r = rgb[0] / 255;
+ var g = rgb[1] / 255;
+ var b = rgb[2] / 255;
+ r = r > 0.04045 ? Math.pow((r + 0.055) / 1.055, 2.4) : r / 12.92;
+ g = g > 0.04045 ? Math.pow((g + 0.055) / 1.055, 2.4) : g / 12.92;
+ b = b > 0.04045 ? Math.pow((b + 0.055) / 1.055, 2.4) : b / 12.92;
+ var x = r * 0.4124 + g * 0.3576 + b * 0.1805;
+ var y = r * 0.2126 + g * 0.7152 + b * 0.0722;
+ var z = r * 0.0193 + g * 0.1192 + b * 0.9505;
+ return [x * 100, y * 100, z * 100];
+ };
+
+ convert.rgb.lab = function (rgb) {
+ var xyz = convert.rgb.xyz(rgb);
+ var x = xyz[0];
+ var y = xyz[1];
+ var z = xyz[2];
+ var l;
+ var a;
+ var b;
+ x /= 95.047;
+ y /= 100;
+ z /= 108.883;
+ x = x > 0.008856 ? Math.pow(x, 1 / 3) : 7.787 * x + 16 / 116;
+ y = y > 0.008856 ? Math.pow(y, 1 / 3) : 7.787 * y + 16 / 116;
+ z = z > 0.008856 ? Math.pow(z, 1 / 3) : 7.787 * z + 16 / 116;
+ l = 116 * y - 16;
+ a = 500 * (x - y);
+ b = 200 * (y - z);
+ return [l, a, b];
+ };
+
+ convert.hsl.rgb = function (hsl) {
+ var h = hsl[0] / 360;
+ var s = hsl[1] / 100;
+ var l = hsl[2] / 100;
+ var t1;
+ var t2;
+ var t3;
+ var rgb;
+ var val;
+
+ if (s === 0) {
+ val = l * 255;
+ return [val, val, val];
+ }
+
+ if (l < 0.5) {
+ t2 = l * (1 + s);
+ } else {
+ t2 = l + s - l * s;
+ }
+
+ t1 = 2 * l - t2;
+ rgb = [0, 0, 0];
+
+ for (var i = 0; i < 3; i++) {
+ t3 = h + 1 / 3 * -(i - 1);
+
+ if (t3 < 0) {
+ t3++;
+ }
+
+ if (t3 > 1) {
+ t3--;
+ }
+
+ if (6 * t3 < 1) {
+ val = t1 + (t2 - t1) * 6 * t3;
+ } else if (2 * t3 < 1) {
+ val = t2;
+ } else if (3 * t3 < 2) {
+ val = t1 + (t2 - t1) * (2 / 3 - t3) * 6;
+ } else {
+ val = t1;
+ }
+
+ rgb[i] = val * 255;
+ }
+
+ return rgb;
+ };
+
+ convert.hsl.hsv = function (hsl) {
+ var h = hsl[0];
+ var s = hsl[1] / 100;
+ var l = hsl[2] / 100;
+ var smin = s;
+ var lmin = Math.max(l, 0.01);
+ var sv;
+ var v;
+ l *= 2;
+ s *= l <= 1 ? l : 2 - l;
+ smin *= lmin <= 1 ? lmin : 2 - lmin;
+ v = (l + s) / 2;
+ sv = l === 0 ? 2 * smin / (lmin + smin) : 2 * s / (l + s);
+ return [h, sv * 100, v * 100];
+ };
+
+ convert.hsv.rgb = function (hsv) {
+ var h = hsv[0] / 60;
+ var s = hsv[1] / 100;
+ var v = hsv[2] / 100;
+ var hi = Math.floor(h) % 6;
+ var f = h - Math.floor(h);
+ var p = 255 * v * (1 - s);
+ var q = 255 * v * (1 - s * f);
+ var t = 255 * v * (1 - s * (1 - f));
+ v *= 255;
+
+ switch (hi) {
+ case 0:
+ return [v, t, p];
+
+ case 1:
+ return [q, v, p];
+
+ case 2:
+ return [p, v, t];
+
+ case 3:
+ return [p, q, v];
+
+ case 4:
+ return [t, p, v];
+
+ case 5:
+ return [v, p, q];
+ }
+ };
+
+ convert.hsv.hsl = function (hsv) {
+ var h = hsv[0];
+ var s = hsv[1] / 100;
+ var v = hsv[2] / 100;
+ var vmin = Math.max(v, 0.01);
+ var lmin;
+ var sl;
+ var l;
+ l = (2 - s) * v;
+ lmin = (2 - s) * vmin;
+ sl = s * vmin;
+ sl /= lmin <= 1 ? lmin : 2 - lmin;
+ sl = sl || 0;
+ l /= 2;
+ return [h, sl * 100, l * 100];
+ };
+
+ convert.hwb.rgb = function (hwb) {
+ var h = hwb[0] / 360;
+ var wh = hwb[1] / 100;
+ var bl = hwb[2] / 100;
+ var ratio = wh + bl;
+ var i;
+ var v;
+ var f;
+ var n;
+
+ if (ratio > 1) {
+ wh /= ratio;
+ bl /= ratio;
+ }
+
+ i = Math.floor(6 * h);
+ v = 1 - bl;
+ f = 6 * h - i;
+
+ if ((i & 0x01) !== 0) {
+ f = 1 - f;
+ }
+
+ n = wh + f * (v - wh);
+ var r;
+ var g;
+ var b;
+
+ switch (i) {
+ default:
+ case 6:
+ case 0:
+ r = v;
+ g = n;
+ b = wh;
+ break;
+
+ case 1:
+ r = n;
+ g = v;
+ b = wh;
+ break;
+
+ case 2:
+ r = wh;
+ g = v;
+ b = n;
+ break;
+
+ case 3:
+ r = wh;
+ g = n;
+ b = v;
+ break;
+
+ case 4:
+ r = n;
+ g = wh;
+ b = v;
+ break;
+
+ case 5:
+ r = v;
+ g = wh;
+ b = n;
+ break;
+ }
+
+ return [r * 255, g * 255, b * 255];
+ };
+
+ convert.cmyk.rgb = function (cmyk) {
+ var c = cmyk[0] / 100;
+ var m = cmyk[1] / 100;
+ var y = cmyk[2] / 100;
+ var k = cmyk[3] / 100;
+ var r;
+ var g;
+ var b;
+ r = 1 - Math.min(1, c * (1 - k) + k);
+ g = 1 - Math.min(1, m * (1 - k) + k);
+ b = 1 - Math.min(1, y * (1 - k) + k);
+ return [r * 255, g * 255, b * 255];
+ };
+
+ convert.xyz.rgb = function (xyz) {
+ var x = xyz[0] / 100;
+ var y = xyz[1] / 100;
+ var z = xyz[2] / 100;
+ var r;
+ var g;
+ var b;
+ r = x * 3.2406 + y * -1.5372 + z * -0.4986;
+ g = x * -0.9689 + y * 1.8758 + z * 0.0415;
+ b = x * 0.0557 + y * -0.2040 + z * 1.0570;
+ r = r > 0.0031308 ? 1.055 * Math.pow(r, 1.0 / 2.4) - 0.055 : r * 12.92;
+ g = g > 0.0031308 ? 1.055 * Math.pow(g, 1.0 / 2.4) - 0.055 : g * 12.92;
+ b = b > 0.0031308 ? 1.055 * Math.pow(b, 1.0 / 2.4) - 0.055 : b * 12.92;
+ r = Math.min(Math.max(0, r), 1);
+ g = Math.min(Math.max(0, g), 1);
+ b = Math.min(Math.max(0, b), 1);
+ return [r * 255, g * 255, b * 255];
+ };
+
+ convert.xyz.lab = function (xyz) {
+ var x = xyz[0];
+ var y = xyz[1];
+ var z = xyz[2];
+ var l;
+ var a;
+ var b;
+ x /= 95.047;
+ y /= 100;
+ z /= 108.883;
+ x = x > 0.008856 ? Math.pow(x, 1 / 3) : 7.787 * x + 16 / 116;
+ y = y > 0.008856 ? Math.pow(y, 1 / 3) : 7.787 * y + 16 / 116;
+ z = z > 0.008856 ? Math.pow(z, 1 / 3) : 7.787 * z + 16 / 116;
+ l = 116 * y - 16;
+ a = 500 * (x - y);
+ b = 200 * (y - z);
+ return [l, a, b];
+ };
+
+ convert.lab.xyz = function (lab) {
+ var l = lab[0];
+ var a = lab[1];
+ var b = lab[2];
+ var x;
+ var y;
+ var z;
+ y = (l + 16) / 116;
+ x = a / 500 + y;
+ z = y - b / 200;
+ var y2 = Math.pow(y, 3);
+ var x2 = Math.pow(x, 3);
+ var z2 = Math.pow(z, 3);
+ y = y2 > 0.008856 ? y2 : (y - 16 / 116) / 7.787;
+ x = x2 > 0.008856 ? x2 : (x - 16 / 116) / 7.787;
+ z = z2 > 0.008856 ? z2 : (z - 16 / 116) / 7.787;
+ x *= 95.047;
+ y *= 100;
+ z *= 108.883;
+ return [x, y, z];
+ };
+
+ convert.lab.lch = function (lab) {
+ var l = lab[0];
+ var a = lab[1];
+ var b = lab[2];
+ var hr;
+ var h;
+ var c;
+ hr = Math.atan2(b, a);
+ h = hr * 360 / 2 / Math.PI;
+
+ if (h < 0) {
+ h += 360;
+ }
+
+ c = Math.sqrt(a * a + b * b);
+ return [l, c, h];
+ };
+
+ convert.lch.lab = function (lch) {
+ var l = lch[0];
+ var c = lch[1];
+ var h = lch[2];
+ var a;
+ var b;
+ var hr;
+ hr = h / 360 * 2 * Math.PI;
+ a = c * Math.cos(hr);
+ b = c * Math.sin(hr);
+ return [l, a, b];
+ };
+
+ convert.rgb.ansi16 = function (args) {
+ var r = args[0];
+ var g = args[1];
+ var b = args[2];
+ var value = 1 in arguments ? arguments[1] : convert.rgb.hsv(args)[2];
+ value = Math.round(value / 50);
+
+ if (value === 0) {
+ return 30;
+ }
+
+ var ansi = 30 + (Math.round(b / 255) << 2 | Math.round(g / 255) << 1 | Math.round(r / 255));
+
+ if (value === 2) {
+ ansi += 60;
+ }
+
+ return ansi;
+ };
+
+ convert.hsv.ansi16 = function (args) {
+ return convert.rgb.ansi16(convert.hsv.rgb(args), args[2]);
+ };
+
+ convert.rgb.ansi256 = function (args) {
+ var r = args[0];
+ var g = args[1];
+ var b = args[2];
+
+ if (r === g && g === b) {
+ if (r < 8) {
+ return 16;
+ }
+
+ if (r > 248) {
+ return 231;
+ }
+
+ return Math.round((r - 8) / 247 * 24) + 232;
+ }
+
+ var ansi = 16 + 36 * Math.round(r / 255 * 5) + 6 * Math.round(g / 255 * 5) + Math.round(b / 255 * 5);
+ return ansi;
+ };
+
+ convert.ansi16.rgb = function (args) {
+ var color = args % 10;
+
+ if (color === 0 || color === 7) {
+ if (args > 50) {
+ color += 3.5;
+ }
+
+ color = color / 10.5 * 255;
+ return [color, color, color];
+ }
+
+ var mult = (~~(args > 50) + 1) * 0.5;
+ var r = (color & 1) * mult * 255;
+ var g = (color >> 1 & 1) * mult * 255;
+ var b = (color >> 2 & 1) * mult * 255;
+ return [r, g, b];
+ };
+
+ convert.ansi256.rgb = function (args) {
+ if (args >= 232) {
+ var c = (args - 232) * 10 + 8;
+ return [c, c, c];
+ }
+
+ args -= 16;
+ var rem;
+ var r = Math.floor(args / 36) / 5 * 255;
+ var g = Math.floor((rem = args % 36) / 6) / 5 * 255;
+ var b = rem % 6 / 5 * 255;
+ return [r, g, b];
+ };
+
+ convert.rgb.hex = function (args) {
+ var integer = ((Math.round(args[0]) & 0xFF) << 16) + ((Math.round(args[1]) & 0xFF) << 8) + (Math.round(args[2]) & 0xFF);
+ var string = integer.toString(16).toUpperCase();
+ return '000000'.substring(string.length) + string;
+ };
+
+ convert.hex.rgb = function (args) {
+ var match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
+
+ if (!match) {
+ return [0, 0, 0];
+ }
+
+ var colorString = match[0];
+
+ if (match[0].length === 3) {
+ colorString = colorString.split('').map(function (char) {
+ return char + char;
+ }).join('');
+ }
+
+ var integer = parseInt(colorString, 16);
+ var r = integer >> 16 & 0xFF;
+ var g = integer >> 8 & 0xFF;
+ var b = integer & 0xFF;
+ return [r, g, b];
+ };
+
+ convert.rgb.hcg = function (rgb) {
+ var r = rgb[0] / 255;
+ var g = rgb[1] / 255;
+ var b = rgb[2] / 255;
+ var max = Math.max(Math.max(r, g), b);
+ var min = Math.min(Math.min(r, g), b);
+ var chroma = max - min;
+ var grayscale;
+ var hue;
+
+ if (chroma < 1) {
+ grayscale = min / (1 - chroma);
+ } else {
+ grayscale = 0;
+ }
+
+ if (chroma <= 0) {
+ hue = 0;
+ } else if (max === r) {
+ hue = (g - b) / chroma % 6;
+ } else if (max === g) {
+ hue = 2 + (b - r) / chroma;
+ } else {
+ hue = 4 + (r - g) / chroma + 4;
+ }
+
+ hue /= 6;
+ hue %= 1;
+ return [hue * 360, chroma * 100, grayscale * 100];
+ };
+
+ convert.hsl.hcg = function (hsl) {
+ var s = hsl[1] / 100;
+ var l = hsl[2] / 100;
+ var c = 1;
+ var f = 0;
+
+ if (l < 0.5) {
+ c = 2.0 * s * l;
+ } else {
+ c = 2.0 * s * (1.0 - l);
+ }
+
+ if (c < 1.0) {
+ f = (l - 0.5 * c) / (1.0 - c);
+ }
+
+ return [hsl[0], c * 100, f * 100];
+ };
+
+ convert.hsv.hcg = function (hsv) {
+ var s = hsv[1] / 100;
+ var v = hsv[2] / 100;
+ var c = s * v;
+ var f = 0;
+
+ if (c < 1.0) {
+ f = (v - c) / (1 - c);
+ }
+
+ return [hsv[0], c * 100, f * 100];
+ };
+
+ convert.hcg.rgb = function (hcg) {
+ var h = hcg[0] / 360;
+ var c = hcg[1] / 100;
+ var g = hcg[2] / 100;
+
+ if (c === 0.0) {
+ return [g * 255, g * 255, g * 255];
+ }
+
+ var pure = [0, 0, 0];
+ var hi = h % 1 * 6;
+ var v = hi % 1;
+ var w = 1 - v;
+ var mg = 0;
+
+ switch (Math.floor(hi)) {
+ case 0:
+ pure[0] = 1;
+ pure[1] = v;
+ pure[2] = 0;
+ break;
+
+ case 1:
+ pure[0] = w;
+ pure[1] = 1;
+ pure[2] = 0;
+ break;
+
+ case 2:
+ pure[0] = 0;
+ pure[1] = 1;
+ pure[2] = v;
+ break;
+
+ case 3:
+ pure[0] = 0;
+ pure[1] = w;
+ pure[2] = 1;
+ break;
+
+ case 4:
+ pure[0] = v;
+ pure[1] = 0;
+ pure[2] = 1;
+ break;
+
+ default:
+ pure[0] = 1;
+ pure[1] = 0;
+ pure[2] = w;
+ }
+
+ mg = (1.0 - c) * g;
+ return [(c * pure[0] + mg) * 255, (c * pure[1] + mg) * 255, (c * pure[2] + mg) * 255];
+ };
+
+ convert.hcg.hsv = function (hcg) {
+ var c = hcg[1] / 100;
+ var g = hcg[2] / 100;
+ var v = c + g * (1.0 - c);
+ var f = 0;
+
+ if (v > 0.0) {
+ f = c / v;
+ }
+
+ return [hcg[0], f * 100, v * 100];
+ };
+
+ convert.hcg.hsl = function (hcg) {
+ var c = hcg[1] / 100;
+ var g = hcg[2] / 100;
+ var l = g * (1.0 - c) + 0.5 * c;
+ var s = 0;
+
+ if (l > 0.0 && l < 0.5) {
+ s = c / (2 * l);
+ } else if (l >= 0.5 && l < 1.0) {
+ s = c / (2 * (1 - l));
+ }
+
+ return [hcg[0], s * 100, l * 100];
+ };
+
+ convert.hcg.hwb = function (hcg) {
+ var c = hcg[1] / 100;
+ var g = hcg[2] / 100;
+ var v = c + g * (1.0 - c);
+ return [hcg[0], (v - c) * 100, (1 - v) * 100];
+ };
+
+ convert.hwb.hcg = function (hwb) {
+ var w = hwb[1] / 100;
+ var b = hwb[2] / 100;
+ var v = 1 - b;
+ var c = v - w;
+ var g = 0;
+
+ if (c < 1) {
+ g = (v - c) / (1 - c);
+ }
+
+ return [hwb[0], c * 100, g * 100];
+ };
+
+ convert.apple.rgb = function (apple) {
+ return [apple[0] / 65535 * 255, apple[1] / 65535 * 255, apple[2] / 65535 * 255];
+ };
+
+ convert.rgb.apple = function (rgb) {
+ return [rgb[0] / 255 * 65535, rgb[1] / 255 * 65535, rgb[2] / 255 * 65535];
+ };
+
+ convert.gray.rgb = function (args) {
+ return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255];
+ };
+
+ convert.gray.hsl = convert.gray.hsv = function (args) {
+ return [0, 0, args[0]];
+ };
+
+ convert.gray.hwb = function (gray) {
+ return [0, 100, gray[0]];
+ };
+
+ convert.gray.cmyk = function (gray) {
+ return [0, 0, 0, gray[0]];
+ };
+
+ convert.gray.lab = function (gray) {
+ return [gray[0], 0, 0];
+ };
+
+ convert.gray.hex = function (gray) {
+ var val = Math.round(gray[0] / 100 * 255) & 0xFF;
+ var integer = (val << 16) + (val << 8) + val;
+ var string = integer.toString(16).toUpperCase();
+ return '000000'.substring(string.length) + string;
+ };
+
+ convert.rgb.gray = function (rgb) {
+ var val = (rgb[0] + rgb[1] + rgb[2]) / 3;
+ return [val / 255 * 100];
+ };
+ });
+ var conversions_1 = conversions.rgb;
+ var conversions_2 = conversions.hsl;
+ var conversions_3 = conversions.hsv;
+ var conversions_4 = conversions.hwb;
+ var conversions_5 = conversions.cmyk;
+ var conversions_6 = conversions.xyz;
+ var conversions_7 = conversions.lab;
+ var conversions_8 = conversions.lch;
+ var conversions_9 = conversions.hex;
+ var conversions_10 = conversions.keyword;
+ var conversions_11 = conversions.ansi16;
+ var conversions_12 = conversions.ansi256;
+ var conversions_13 = conversions.hcg;
+ var conversions_14 = conversions.apple;
+ var conversions_15 = conversions.gray;
+
+ function buildGraph() {
+ var graph = {};
+ var models = Object.keys(conversions);
+
+ for (var len = models.length, i = 0; i < len; i++) {
+ graph[models[i]] = {
+ distance: -1,
+ parent: null
+ };
+ }
+
+ return graph;
+ }
+
+ function deriveBFS(fromModel) {
+ var graph = buildGraph();
+ var queue = [fromModel];
+ graph[fromModel].distance = 0;
+
+ while (queue.length) {
+ var current = queue.pop();
+ var adjacents = Object.keys(conversions[current]);
+
+ for (var len = adjacents.length, i = 0; i < len; i++) {
+ var adjacent = adjacents[i];
+ var node = graph[adjacent];
+
+ if (node.distance === -1) {
+ node.distance = graph[current].distance + 1;
+ node.parent = current;
+ queue.unshift(adjacent);
+ }
+ }
+ }
+
+ return graph;
+ }
+
+ function link(from, to) {
+ return function (args) {
+ return to(from(args));
+ };
+ }
+
+ function wrapConversion(toModel, graph) {
+ var path = [graph[toModel].parent, toModel];
+ var fn = conversions[graph[toModel].parent][toModel];
+ var cur = graph[toModel].parent;
+
+ while (graph[cur].parent) {
+ path.unshift(graph[cur].parent);
+ fn = link(conversions[graph[cur].parent][cur], fn);
+ cur = graph[cur].parent;
+ }
+
+ fn.conversion = path;
+ return fn;
+ }
+
+ var route = function route(fromModel) {
+ var graph = deriveBFS(fromModel);
+ var conversion = {};
+ var models = Object.keys(graph);
+
+ for (var len = models.length, i = 0; i < len; i++) {
+ var toModel = models[i];
+ var node = graph[toModel];
+
+ if (node.parent === null) {
+ continue;
+ }
+
+ conversion[toModel] = wrapConversion(toModel, graph);
+ }
+
+ return conversion;
+ };
+
+ var _typeof = typeof Symbol === "function" && typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") === "symbol" ? function (obj) {
+ return typeof obj;
+ } : function (obj) {
+ return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof obj;
+ };
+
+ var classCallCheck = function classCallCheck(instance, Constructor) {
+ if (!(instance instanceof Constructor)) {
+ throw new TypeError("Cannot call a class as a function");
+ }
+ };
+
+ var inherits = 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 possibleConstructorReturn = 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;
+ };
+
+ var convert = {};
+ var models = Object.keys(conversions);
+
+ function wrapRaw(fn) {
+ var wrappedFn = function wrappedFn(args) {
+ if (args === undefined || args === null) {
+ return args;
+ }
+
+ if (arguments.length > 1) {
+ args = Array.prototype.slice.call(arguments);
+ }
+
+ return fn(args);
+ };
+
+ if ('conversion' in fn) {
+ wrappedFn.conversion = fn.conversion;
+ }
+
+ return wrappedFn;
+ }
+
+ function wrapRounded(fn) {
+ var wrappedFn = function wrappedFn(args) {
+ if (args === undefined || args === null) {
+ return args;
+ }
+
+ if (arguments.length > 1) {
+ args = Array.prototype.slice.call(arguments);
+ }
+
+ var result = fn(args);
+
+ if ((typeof result === 'undefined' ? 'undefined' : _typeof(result)) === 'object') {
+ for (var len = result.length, i = 0; i < len; i++) {
+ result[i] = Math.round(result[i]);
+ }
+ }
+
+ return result;
+ };
+
+ if ('conversion' in fn) {
+ wrappedFn.conversion = fn.conversion;
+ }
+
+ return wrappedFn;
+ }
+
+ models.forEach(function (fromModel) {
+ convert[fromModel] = {};
+ Object.defineProperty(convert[fromModel], 'channels', {
+ value: conversions[fromModel].channels
+ });
+ Object.defineProperty(convert[fromModel], 'labels', {
+ value: conversions[fromModel].labels
+ });
+ var routes = route(fromModel);
+ var routeModels = Object.keys(routes);
+ routeModels.forEach(function (toModel) {
+ var fn = routes[toModel];
+ convert[fromModel][toModel] = wrapRounded(fn);
+ convert[fromModel][toModel].raw = wrapRaw(fn);
+ });
+ });
+ var colorConvert = convert;
+ var ansiStyles = createCommonjsModule(function (module) {
+ var wrapAnsi16 = function wrapAnsi16(fn, offset) {
+ return function () {
+ var code = fn.apply(colorConvert, arguments);
+ return '\x1B[' + (code + offset) + 'm';
+ };
+ };
+
+ var wrapAnsi256 = function wrapAnsi256(fn, offset) {
+ return function () {
+ var code = fn.apply(colorConvert, arguments);
+ return '\x1B[' + (38 + offset) + ';5;' + code + 'm';
+ };
+ };
+
+ var wrapAnsi16m = function wrapAnsi16m(fn, offset) {
+ return function () {
+ var rgb = fn.apply(colorConvert, arguments);
+ return '\x1B[' + (38 + offset) + ';2;' + rgb[0] + ';' + rgb[1] + ';' + rgb[2] + 'm';
+ };
+ };
+
+ function assembleStyles() {
+ var codes = new Map();
+ var styles = {
+ modifier: {
+ reset: [0, 0],
+ bold: [1, 22],
+ dim: [2, 22],
+ italic: [3, 23],
+ underline: [4, 24],
+ inverse: [7, 27],
+ hidden: [8, 28],
+ strikethrough: [9, 29]
+ },
+ color: {
+ black: [30, 39],
+ red: [31, 39],
+ green: [32, 39],
+ yellow: [33, 39],
+ blue: [34, 39],
+ magenta: [35, 39],
+ cyan: [36, 39],
+ white: [37, 39],
+ gray: [90, 39],
+ redBright: [91, 39],
+ greenBright: [92, 39],
+ yellowBright: [93, 39],
+ blueBright: [94, 39],
+ magentaBright: [95, 39],
+ cyanBright: [96, 39],
+ whiteBright: [97, 39]
+ },
+ bgColor: {
+ bgBlack: [40, 49],
+ bgRed: [41, 49],
+ bgGreen: [42, 49],
+ bgYellow: [43, 49],
+ bgBlue: [44, 49],
+ bgMagenta: [45, 49],
+ bgCyan: [46, 49],
+ bgWhite: [47, 49],
+ bgBlackBright: [100, 49],
+ bgRedBright: [101, 49],
+ bgGreenBright: [102, 49],
+ bgYellowBright: [103, 49],
+ bgBlueBright: [104, 49],
+ bgMagentaBright: [105, 49],
+ bgCyanBright: [106, 49],
+ bgWhiteBright: [107, 49]
+ }
+ };
+ styles.color.grey = styles.color.gray;
+ var _iteratorNormalCompletion = true;
+ var _didIteratorError = false;
+ var _iteratorError = undefined;
+
+ try {
+ for (var _iterator = Object.keys(styles)[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+ var groupName = _step.value;
+ var group = styles[groupName];
+ var _iteratorNormalCompletion3 = true;
+ var _didIteratorError3 = false;
+ var _iteratorError3 = undefined;
+
+ try {
+ for (var _iterator3 = Object.keys(group)[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+ var styleName = _step3.value;
+ var style = group[styleName];
+ styles[styleName] = {
+ open: '\x1B[' + style[0] + 'm',
+ close: '\x1B[' + style[1] + 'm'
+ };
+ group[styleName] = styles[styleName];
+ codes.set(style[0], style[1]);
+ }
+ } catch (err) {
+ _didIteratorError3 = true;
+ _iteratorError3 = err;
+ } finally {
+ try {
+ if (!_iteratorNormalCompletion3 && _iterator3.return) {
+ _iterator3.return();
+ }
+ } finally {
+ if (_didIteratorError3) {
+ throw _iteratorError3;
+ }
+ }
+ }
+
+ Object.defineProperty(styles, groupName, {
+ value: group,
+ enumerable: false
+ });
+ Object.defineProperty(styles, 'codes', {
+ value: codes,
+ enumerable: false
+ });
+ }
+ } catch (err) {
+ _didIteratorError = true;
+ _iteratorError = err;
+ } finally {
+ try {
+ if (!_iteratorNormalCompletion && _iterator.return) {
+ _iterator.return();
+ }
+ } finally {
+ if (_didIteratorError) {
+ throw _iteratorError;
+ }
+ }
+ }
+
+ var ansi2ansi = function ansi2ansi(n) {
+ return n;
+ };
+
+ var rgb2rgb = function rgb2rgb(r, g, b) {
+ return [r, g, b];
+ };
+
+ styles.color.close = '\x1B[39m';
+ styles.bgColor.close = '\x1B[49m';
+ styles.color.ansi = {
+ ansi: wrapAnsi16(ansi2ansi, 0)
+ };
+ styles.color.ansi256 = {
+ ansi256: wrapAnsi256(ansi2ansi, 0)
+ };
+ styles.color.ansi16m = {
+ rgb: wrapAnsi16m(rgb2rgb, 0)
+ };
+ styles.bgColor.ansi = {
+ ansi: wrapAnsi16(ansi2ansi, 10)
+ };
+ styles.bgColor.ansi256 = {
+ ansi256: wrapAnsi256(ansi2ansi, 10)
+ };
+ styles.bgColor.ansi16m = {
+ rgb: wrapAnsi16m(rgb2rgb, 10)
+ };
+ var _iteratorNormalCompletion2 = true;
+ var _didIteratorError2 = false;
+ var _iteratorError2 = undefined;
+
+ try {
+ for (var _iterator2 = Object.keys(colorConvert)[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+ var key = _step2.value;
+
+ if (_typeof(colorConvert[key]) !== 'object') {
+ continue;
+ }
+
+ var suite = colorConvert[key];
+
+ if (key === 'ansi16') {
+ key = 'ansi';
+ }
+
+ if ('ansi16' in suite) {
+ styles.color.ansi[key] = wrapAnsi16(suite.ansi16, 0);
+ styles.bgColor.ansi[key] = wrapAnsi16(suite.ansi16, 10);
+ }
+
+ if ('ansi256' in suite) {
+ styles.color.ansi256[key] = wrapAnsi256(suite.ansi256, 0);
+ styles.bgColor.ansi256[key] = wrapAnsi256(suite.ansi256, 10);
+ }
+
+ if ('rgb' in suite) {
+ styles.color.ansi16m[key] = wrapAnsi16m(suite.rgb, 0);
+ styles.bgColor.ansi16m[key] = wrapAnsi16m(suite.rgb, 10);
+ }
+ }
+ } catch (err) {
+ _didIteratorError2 = true;
+ _iteratorError2 = err;
+ } finally {
+ try {
+ if (!_iteratorNormalCompletion2 && _iterator2.return) {
+ _iterator2.return();
+ }
+ } finally {
+ if (_didIteratorError2) {
+ throw _iteratorError2;
+ }
+ }
+ }
+
+ return styles;
+ }
+
+ Object.defineProperty(module, 'exports', {
+ enumerable: true,
+ get: assembleStyles
+ });
+ });
+
+ var getSymbols = Object.getOwnPropertySymbols || function (obj) {
+ return [];
+ };
+
+ var isSymbol = function isSymbol(key) {
+ return (typeof key === 'undefined' ? 'undefined' : _typeof(key)) === 'symbol' || toString.call(key) === '[object Symbol]';
+ };
+
+ function printIteratorEntries(iterator, config, indentation, depth, refs, printer) {
+ var separator = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : ': ';
+ var result = '';
+ var current = iterator.next();
+
+ if (!current.done) {
+ result += config.spacingOuter;
+ var indentationNext = indentation + config.indent;
+
+ while (!current.done) {
+ var name = printer(current.value[0], config, indentationNext, depth, refs);
+ var value = printer(current.value[1], config, indentationNext, depth, refs);
+ result += indentationNext + name + separator + value;
+ current = iterator.next();
+
+ if (!current.done) {
+ result += ',' + config.spacingInner;
+ } else if (!config.min) {
+ result += ',';
+ }
+ }
+
+ result += config.spacingOuter + indentation;
+ }
+
+ return result;
+ }
+
+ function printIteratorValues(iterator, config, indentation, depth, refs, printer) {
+ var result = '';
+ var current = iterator.next();
+
+ if (!current.done) {
+ result += config.spacingOuter;
+ var indentationNext = indentation + config.indent;
+
+ while (!current.done) {
+ result += indentationNext + printer(current.value, config, indentationNext, depth, refs);
+ current = iterator.next();
+
+ if (!current.done) {
+ result += ',' + config.spacingInner;
+ } else if (!config.min) {
+ result += ',';
+ }
+ }
+
+ result += config.spacingOuter + indentation;
+ }
+
+ return result;
+ }
+
+ function printListItems(list, config, indentation, depth, refs, printer) {
+ var result = '';
+
+ if (list.length) {
+ result += config.spacingOuter;
+ var indentationNext = indentation + config.indent;
+
+ for (var i = 0; i < list.length; i++) {
+ result += indentationNext + printer(list[i], config, indentationNext, depth, refs);
+
+ if (i < list.length - 1) {
+ result += ',' + config.spacingInner;
+ } else if (!config.min) {
+ result += ',';
+ }
+ }
+
+ result += config.spacingOuter + indentation;
+ }
+
+ return result;
+ }
+
+ function printObjectProperties(val, config, indentation, depth, refs, printer) {
+ var result = '';
+ var keys = Object.keys(val).sort();
+ var symbols = getSymbols(val);
+
+ if (symbols.length) {
+ keys = keys.filter(function (key) {
+ return !isSymbol(key);
+ }).concat(symbols);
+ }
+
+ if (keys.length) {
+ result += config.spacingOuter;
+ var indentationNext = indentation + config.indent;
+
+ for (var i = 0; i < keys.length; i++) {
+ var key = keys[i];
+ var name = printer(key, config, indentationNext, depth, refs);
+ var value = printer(val[key], config, indentationNext, depth, refs);
+ result += indentationNext + name + ': ' + value;
+
+ if (i < keys.length - 1) {
+ result += ',' + config.spacingInner;
+ } else if (!config.min) {
+ result += ',';
+ }
+ }
+
+ result += config.spacingOuter + indentation;
+ }
+
+ return result;
+ }
+
+ var asymmetricMatcher = (typeof Symbol === "function" ? Symbol.for : "@@for")('jest.asymmetricMatcher');
+ var SPACE = ' ';
+
+ var serialize = function serialize(val, config, indentation, depth, refs, printer) {
+ var stringedValue = val.toString();
+
+ if (stringedValue === 'ArrayContaining' || stringedValue === 'ArrayNotContaining') {
+ if (++depth > config.maxDepth) {
+ return '[' + stringedValue + ']';
+ }
+
+ return stringedValue + SPACE + '[' + printListItems(val.sample, config, indentation, depth, refs, printer) + ']';
+ }
+
+ if (stringedValue === 'ObjectContaining' || stringedValue === 'ObjectNotContaining') {
+ if (++depth > config.maxDepth) {
+ return '[' + stringedValue + ']';
+ }
+
+ return stringedValue + SPACE + '{' + printObjectProperties(val.sample, config, indentation, depth, refs, printer) + '}';
+ }
+
+ if (stringedValue === 'StringMatching' || stringedValue === 'StringNotMatching') {
+ return stringedValue + SPACE + printer(val.sample, config, indentation, depth, refs);
+ }
+
+ if (stringedValue === 'StringContaining' || stringedValue === 'StringNotContaining') {
+ return stringedValue + SPACE + printer(val.sample, config, indentation, depth, refs);
+ }
+
+ return val.toAsymmetricMatcher();
+ };
+
+ var test = function test(val) {
+ return val && val.$$typeof === asymmetricMatcher;
+ };
+
+ var AsymmetricMatcher = {
+ serialize: serialize,
+ test: test
+ };
+
+ var ansiRegex = function ansiRegex(options) {
+ options = _extends({
+ onlyFirst: false
+ }, options);
+ var pattern = ["[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[a-zA-Z\\d]*)*)?\\u0007)", '(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))'].join('|');
+ return new RegExp(pattern, options.onlyFirst ? undefined : 'g');
+ };
+
+ var toHumanReadableAnsi = function toHumanReadableAnsi(text) {
+ return text.replace(ansiRegex(), function (match, offset, string) {
+ switch (match) {
+ case ansiStyles.red.close:
+ case ansiStyles.green.close:
+ case ansiStyles.cyan.close:
+ case ansiStyles.gray.close:
+ case ansiStyles.white.close:
+ case ansiStyles.yellow.close:
+ case ansiStyles.bgRed.close:
+ case ansiStyles.bgGreen.close:
+ case ansiStyles.bgYellow.close:
+ case ansiStyles.inverse.close:
+ case ansiStyles.dim.close:
+ case ansiStyles.bold.close:
+ case ansiStyles.reset.open:
+ case ansiStyles.reset.close:
+ return '';
+
+ case ansiStyles.red.open:
+ return '';
+
+ case ansiStyles.green.open:
+ return '';
+
+ case ansiStyles.cyan.open:
+ return '';
+
+ case ansiStyles.gray.open:
+ return '';
+
+ case ansiStyles.white.open:
+ return '';
+
+ case ansiStyles.yellow.open:
+ return '';
+
+ case ansiStyles.bgRed.open:
+ return '';
+
+ case ansiStyles.bgGreen.open:
+ return '';
+
+ case ansiStyles.bgYellow.open:
+ return '';
+
+ case ansiStyles.inverse.open:
+ return '';
+
+ case ansiStyles.dim.open:
+ return '';
+
+ case ansiStyles.bold.open:
+ return '';
+
+ default:
+ return '';
+ }
+ });
+ };
+
+ var test$1 = function test(val) {
+ return typeof val === 'string' && val.match(ansiRegex());
+ };
+
+ var serialize$1 = function serialize(val, config, indentation, depth, refs, printer) {
+ return printer(toHumanReadableAnsi(val), config, indentation, depth, refs);
+ };
+
+ var ConvertAnsi = {
+ serialize: serialize$1,
+ test: test$1
+ };
+ var SPACE$1 = ' ';
+ var OBJECT_NAMES = ['DOMStringMap', 'NamedNodeMap'];
+ var ARRAY_REGEXP = /^(HTML\w*Collection|NodeList)$/;
+
+ var testName = function testName(name) {
+ return OBJECT_NAMES.indexOf(name) !== -1 || ARRAY_REGEXP.test(name);
+ };
+
+ var test$2 = function test(val) {
+ return val && val.constructor && val.constructor.name && testName(val.constructor.name);
+ };
+
+ var propsReducer = function propsReducer(props, attribute) {
+ props[attribute.name] = attribute.value;
+ return props;
+ };
+
+ var serialize$2 = function serialize(collection, config, indentation, depth, refs, printer) {
+ var name = collection.constructor.name;
+
+ if (++depth > config.maxDepth) {
+ return '[' + name + ']';
+ }
+
+ return (config.min ? '' : name + SPACE$1) + (OBJECT_NAMES.indexOf(name) !== -1 ? '{' + printObjectProperties(name === 'NamedNodeMap' ? Array.prototype.reduce.call(collection, propsReducer, {}) : _extends({}, collection), config, indentation, depth, refs, printer) + '}' : '[' + printListItems(Array.from(collection), config, indentation, depth, refs, printer) + ']');
+ };
+
+ var DOMCollection = {
+ serialize: serialize$2,
+ test: test$2
+ };
+
+ function escapeHTML(str) {
+ return str.replace(//g, '>');
+ }
+
+ var printProps = function printProps(keys, props, config, indentation, depth, refs, printer) {
+ var indentationNext = indentation + config.indent;
+ var colors = config.colors;
+ return keys.map(function (key) {
+ var value = props[key];
+ var printed = printer(value, config, indentationNext, depth, refs);
+
+ if (typeof value !== 'string') {
+ if (printed.indexOf('\n') !== -1) {
+ printed = config.spacingOuter + indentationNext + printed + config.spacingOuter + indentation;
+ }
+
+ printed = '{' + printed + '}';
+ }
+
+ return config.spacingInner + indentation + colors.prop.open + key + colors.prop.close + '=' + colors.value.open + printed + colors.value.close;
+ }).join('');
+ };
+
+ var printChildren = function printChildren(children, config, indentation, depth, refs, printer) {
+ return children.map(function (child) {
+ return config.spacingOuter + indentation + (typeof child === 'string' ? printText(child, config) : printer(child, config, indentation, depth, refs));
+ }).join('');
+ };
+
+ var printText = function printText(text, config) {
+ var contentColor = config.colors.content;
+ return contentColor.open + escapeHTML(text) + contentColor.close;
+ };
+
+ var printComment = function printComment(comment, config) {
+ var commentColor = config.colors.comment;
+ return commentColor.open + '' + commentColor.close;
+ };
+
+ var printElement = function printElement(type, printedProps, printedChildren, config, indentation) {
+ var tagColor = config.colors.tag;
+ return tagColor.open + '<' + type + (printedProps && tagColor.close + printedProps + config.spacingOuter + indentation + tagColor.open) + (printedChildren ? '>' + tagColor.close + printedChildren + config.spacingOuter + indentation + tagColor.open + '' + tagColor.close;
+ };
+
+ var printElementAsLeaf = function printElementAsLeaf(type, config) {
+ var tagColor = config.colors.tag;
+ return tagColor.open + '<' + type + tagColor.close + ' …' + tagColor.open + ' />' + tagColor.close;
+ };
+
+ var ELEMENT_NODE = 1;
+ var TEXT_NODE = 3;
+ var COMMENT_NODE = 8;
+ var FRAGMENT_NODE = 11;
+ var ELEMENT_REGEXP = /^((HTML|SVG)\w*)?Element$/;
+
+ var testNode = function testNode(nodeType, name) {
+ return nodeType === ELEMENT_NODE && ELEMENT_REGEXP.test(name) || nodeType === TEXT_NODE && name === 'Text' || nodeType === COMMENT_NODE && name === 'Comment' || nodeType === FRAGMENT_NODE && name === 'DocumentFragment';
+ };
+
+ var test$3 = function test(val) {
+ return val && val.constructor && val.constructor.name && testNode(val.nodeType, val.constructor.name);
+ };
+
+ var keysMapper = function keysMapper(attribute) {
+ return attribute.name;
+ };
+
+ var propsReducer$1 = function propsReducer(props, attribute) {
+ props[attribute.name] = attribute.value;
+ return props;
+ };
+
+ var serialize$3 = function serialize(node, config, indentation, depth, refs, printer) {
+ if (node.nodeType === TEXT_NODE) {
+ return printText(node.data, config);
+ }
+
+ if (node.nodeType === COMMENT_NODE) {
+ return printComment(node.data, config);
+ }
+
+ var type = node.nodeType === FRAGMENT_NODE ? 'DocumentFragment' : node.tagName.toLowerCase();
+
+ if (++depth > config.maxDepth) {
+ return printElementAsLeaf(type, config);
+ }
+
+ return printElement(type, printProps(Array.prototype.map.call(node.attributes || [], keysMapper).sort(), Array.prototype.reduce.call(node.attributes || [], propsReducer$1, {}), config, indentation + config.indent, depth, refs, printer), printChildren(Array.prototype.slice.call(node.childNodes || node.children), config, indentation + config.indent, depth, refs, printer), config, indentation);
+ };
+
+ var DOMElement = {
+ serialize: serialize$3,
+ test: test$3
+ };
+ var IS_ITERABLE_SENTINEL = '@@__IMMUTABLE_ITERABLE__@@';
+ var IS_LIST_SENTINEL = '@@__IMMUTABLE_LIST__@@';
+ var IS_KEYED_SENTINEL = '@@__IMMUTABLE_KEYED__@@';
+ var IS_MAP_SENTINEL = '@@__IMMUTABLE_MAP__@@';
+ var IS_ORDERED_SENTINEL = '@@__IMMUTABLE_ORDERED__@@';
+ var IS_RECORD_SENTINEL = '@@__IMMUTABLE_RECORD__@@';
+ var IS_SEQ_SENTINEL = '@@__IMMUTABLE_SEQ__@@';
+ var IS_SET_SENTINEL = '@@__IMMUTABLE_SET__@@';
+ var IS_STACK_SENTINEL = '@@__IMMUTABLE_STACK__@@';
+
+ var getImmutableName = function getImmutableName(name) {
+ return 'Immutable.' + name;
+ };
+
+ var printAsLeaf = function printAsLeaf(name) {
+ return '[' + name + ']';
+ };
+
+ var SPACE$2 = ' ';
+ var LAZY = '…';
+
+ var printImmutableEntries = function printImmutableEntries(val, config, indentation, depth, refs, printer, type) {
+ return ++depth > config.maxDepth ? printAsLeaf(getImmutableName(type)) : getImmutableName(type) + SPACE$2 + '{' + printIteratorEntries(val.entries(), config, indentation, depth, refs, printer) + '}';
+ };
+
+ var getRecordEntries = function getRecordEntries(val) {
+ var i = 0;
+ return {
+ next: function next() {
+ if (i < val._keys.length) {
+ var key = val._keys[i++];
+ return {
+ done: false,
+ value: [key, val.get(key)]
+ };
+ }
+
+ return {
+ done: true
+ };
+ }
+ };
+ };
+
+ var printImmutableRecord = function printImmutableRecord(val, config, indentation, depth, refs, printer) {
+ var name = getImmutableName(val._name || 'Record');
+ return ++depth > config.maxDepth ? printAsLeaf(name) : name + SPACE$2 + '{' + printIteratorEntries(getRecordEntries(val), config, indentation, depth, refs, printer) + '}';
+ };
+
+ var printImmutableSeq = function printImmutableSeq(val, config, indentation, depth, refs, printer) {
+ var name = getImmutableName('Seq');
+
+ if (++depth > config.maxDepth) {
+ return printAsLeaf(name);
+ }
+
+ if (val[IS_KEYED_SENTINEL]) {
+ return name + SPACE$2 + '{' + (val._iter || val._object ? printIteratorEntries(val.entries(), config, indentation, depth, refs, printer) : LAZY) + '}';
+ }
+
+ return name + SPACE$2 + '[' + (val._iter || val._array || val._collection || val._iterable ? printIteratorValues(val.values(), config, indentation, depth, refs, printer) : LAZY) + ']';
+ };
+
+ var printImmutableValues = function printImmutableValues(val, config, indentation, depth, refs, printer, type) {
+ return ++depth > config.maxDepth ? printAsLeaf(getImmutableName(type)) : getImmutableName(type) + SPACE$2 + '[' + printIteratorValues(val.values(), config, indentation, depth, refs, printer) + ']';
+ };
+
+ var serialize$4 = function serialize(val, config, indentation, depth, refs, printer) {
+ if (val[IS_MAP_SENTINEL]) {
+ return printImmutableEntries(val, config, indentation, depth, refs, printer, val[IS_ORDERED_SENTINEL] ? 'OrderedMap' : 'Map');
+ }
+
+ if (val[IS_LIST_SENTINEL]) {
+ return printImmutableValues(val, config, indentation, depth, refs, printer, 'List');
+ }
+
+ if (val[IS_SET_SENTINEL]) {
+ return printImmutableValues(val, config, indentation, depth, refs, printer, val[IS_ORDERED_SENTINEL] ? 'OrderedSet' : 'Set');
+ }
+
+ if (val[IS_STACK_SENTINEL]) {
+ return printImmutableValues(val, config, indentation, depth, refs, printer, 'Stack');
+ }
+
+ if (val[IS_SEQ_SENTINEL]) {
+ return printImmutableSeq(val, config, indentation, depth, refs, printer);
+ }
+
+ return printImmutableRecord(val, config, indentation, depth, refs, printer);
+ };
+
+ var test$4 = function test(val) {
+ return val && (val[IS_ITERABLE_SENTINEL] === true || val[IS_RECORD_SENTINEL] === true);
+ };
+
+ var Immutable = {
+ serialize: serialize$4,
+ test: test$4
+ };
+ var elementSymbol = (typeof Symbol === "function" ? Symbol.for : "@@for")('react.element');
+ var fragmentSymbol = (typeof Symbol === "function" ? Symbol.for : "@@for")('react.fragment');
+ var forwardRefSymbol = (typeof Symbol === "function" ? Symbol.for : "@@for")('react.forward_ref');
+ var providerSymbol = (typeof Symbol === "function" ? Symbol.for : "@@for")('react.provider');
+ var contextSymbol = (typeof Symbol === "function" ? Symbol.for : "@@for")('react.context');
+
+ var getChildren = function getChildren(arg) {
+ var children = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+
+ if (Array.isArray(arg)) {
+ arg.forEach(function (item) {
+ getChildren(item, children);
+ });
+ } else if (arg != null && arg !== false) {
+ children.push(arg);
+ }
+
+ return children;
+ };
+
+ var getType = function getType(element) {
+ var type = element.type;
+
+ if (typeof type === 'string') {
+ return type;
+ }
+
+ if (typeof type === 'function') {
+ return type.displayName || type.name || 'Unknown';
+ }
+
+ if (type === fragmentSymbol) {
+ return 'React.Fragment';
+ }
+
+ if ((typeof type === 'undefined' ? 'undefined' : _typeof(type)) === 'object' && type !== null) {
+ if (type.$$typeof === providerSymbol) {
+ return 'Context.Provider';
+ }
+
+ if (type.$$typeof === contextSymbol) {
+ return 'Context.Consumer';
+ }
+
+ if (type.$$typeof === forwardRefSymbol) {
+ var functionName = type.render.displayName || type.render.name || '';
+ return functionName !== '' ? 'ForwardRef(' + functionName + ')' : 'ForwardRef';
+ }
+ }
+
+ return 'UNDEFINED';
+ };
+
+ var getPropKeys = function getPropKeys(element) {
+ var props = element.props;
+ return Object.keys(props).filter(function (key) {
+ return key !== 'children' && props[key] !== undefined;
+ }).sort();
+ };
+
+ var serialize$5 = function serialize(element, config, indentation, depth, refs, printer) {
+ return ++depth > config.maxDepth ? printElementAsLeaf(getType(element), config) : printElement(getType(element), printProps(getPropKeys(element), element.props, config, indentation + config.indent, depth, refs, printer), printChildren(getChildren(element.props.children), config, indentation + config.indent, depth, refs, printer), config, indentation);
+ };
+
+ var test$5 = function test(val) {
+ return val && val.$$typeof === elementSymbol;
+ };
+
+ var ReactElement = {
+ serialize: serialize$5,
+ test: test$5
+ };
+ var testSymbol = (typeof Symbol === "function" ? Symbol.for : "@@for")('react.test.json');
+
+ var getPropKeys$1 = function getPropKeys(object) {
+ var props = object.props;
+ return props ? Object.keys(props).filter(function (key) {
+ return props[key] !== undefined;
+ }).sort() : [];
+ };
+
+ var serialize$6 = function serialize(object, config, indentation, depth, refs, printer) {
+ return ++depth > config.maxDepth ? printElementAsLeaf(object.type, config) : printElement(object.type, object.props ? printProps(getPropKeys$1(object), object.props, config, indentation + config.indent, depth, refs, printer) : '', object.children ? printChildren(object.children, config, indentation + config.indent, depth, refs, printer) : '', config, indentation);
+ };
+
+ var test$6 = function test(val) {
+ return val && val.$$typeof === testSymbol;
+ };
+
+ var ReactTestComponent = {
+ serialize: serialize$6,
+ test: test$6
+ };
+ var toString$1 = Object.prototype.toString;
+ var toISOString = Date.prototype.toISOString;
+ var errorToString = Error.prototype.toString;
+ var regExpToString = RegExp.prototype.toString;
+ var symbolToString = (typeof Symbol === "function" ? Symbol.prototype : "@@prototype").toString;
+
+ var getConstructorName = function getConstructorName(val) {
+ return typeof val.constructor === 'function' && val.constructor.name || 'Object';
+ };
+
+ var isWindow = function isWindow(val) {
+ return typeof window !== 'undefined' && val === window;
+ };
+
+ var SYMBOL_REGEXP = /^Symbol\((.*)\)(.*)$/;
+ var NEWLINE_REGEXP = /\n/gi;
+
+ var PrettyFormatPluginError = function (_Error) {
+ inherits(PrettyFormatPluginError, _Error);
+
+ function PrettyFormatPluginError(message, stack) {
+ classCallCheck(this, PrettyFormatPluginError);
+
+ var _this = possibleConstructorReturn(this, (PrettyFormatPluginError.__proto__ || Object.getPrototypeOf(PrettyFormatPluginError)).call(this, message));
+
+ _this.stack = stack;
+ _this.name = _this.constructor.name;
+ return _this;
+ }
+
+ return PrettyFormatPluginError;
+ }(Error);
+
+ function isToStringedArrayType(toStringed) {
+ return toStringed === '[object Array]' || toStringed === '[object ArrayBuffer]' || toStringed === '[object DataView]' || toStringed === '[object Float32Array]' || toStringed === '[object Float64Array]' || toStringed === '[object Int8Array]' || toStringed === '[object Int16Array]' || toStringed === '[object Int32Array]' || toStringed === '[object Uint8Array]' || toStringed === '[object Uint8ClampedArray]' || toStringed === '[object Uint16Array]' || toStringed === '[object Uint32Array]';
+ }
+
+ function printNumber(val) {
+ return Object.is(val, -0) ? '-0' : String(val);
+ }
+
+ function printFunction(val, printFunctionName) {
+ if (!printFunctionName) {
+ return '[Function]';
+ }
+
+ return '[Function ' + (val.name || 'anonymous') + ']';
+ }
+
+ function printSymbol(val) {
+ return symbolToString.call(val).replace(SYMBOL_REGEXP, 'Symbol($1)');
+ }
+
+ function printError(val) {
+ return '[' + errorToString.call(val) + ']';
+ }
+
+ function printBasicValue(val, printFunctionName, escapeRegex, escapeString) {
+ if (val === true || val === false) {
+ return '' + val;
+ }
+
+ if (val === undefined) {
+ return 'undefined';
+ }
+
+ if (val === null) {
+ return 'null';
+ }
+
+ var typeOf = typeof val === 'undefined' ? 'undefined' : _typeof(val);
+
+ if (typeOf === 'number') {
+ return printNumber(val);
+ }
+
+ if (typeOf === 'string') {
+ if (escapeString) {
+ return '"' + val.replace(/"|\\/g, '\\$&') + '"';
+ }
+
+ return '"' + val + '"';
+ }
+
+ if (typeOf === 'function') {
+ return printFunction(val, printFunctionName);
+ }
+
+ if (typeOf === 'symbol') {
+ return printSymbol(val);
+ }
+
+ var toStringed = toString$1.call(val);
+
+ if (toStringed === '[object WeakMap]') {
+ return 'WeakMap {}';
+ }
+
+ if (toStringed === '[object WeakSet]') {
+ return 'WeakSet {}';
+ }
+
+ if (toStringed === '[object Function]' || toStringed === '[object GeneratorFunction]') {
+ return printFunction(val, printFunctionName);
+ }
+
+ if (toStringed === '[object Symbol]') {
+ return printSymbol(val);
+ }
+
+ if (toStringed === '[object Date]') {
+ return isNaN(+val) ? 'Date { NaN }' : toISOString.call(val);
+ }
+
+ if (toStringed === '[object Error]') {
+ return printError(val);
+ }
+
+ if (toStringed === '[object RegExp]') {
+ if (escapeRegex) {
+ return regExpToString.call(val).replace(/[\\^$*+?.()|[\]{}]/g, '\\$&');
+ }
+
+ return regExpToString.call(val);
+ }
+
+ if (val instanceof Error) {
+ return printError(val);
+ }
+
+ return null;
+ }
+
+ function printComplexValue(val, config, indentation, depth, refs, hasCalledToJSON) {
+ if (refs.indexOf(val) !== -1) {
+ return '[Circular]';
+ }
+
+ refs = refs.slice();
+ refs.push(val);
+ var hitMaxDepth = ++depth > config.maxDepth;
+ var min = config.min;
+
+ if (config.callToJSON && !hitMaxDepth && val.toJSON && typeof val.toJSON === 'function' && !hasCalledToJSON) {
+ return printer(val.toJSON(), config, indentation, depth, refs, true);
+ }
+
+ var toStringed = toString$1.call(val);
+
+ if (toStringed === '[object Arguments]') {
+ return hitMaxDepth ? '[Arguments]' : (min ? '' : 'Arguments ') + '[' + printListItems(val, config, indentation, depth, refs, printer) + ']';
+ }
+
+ if (isToStringedArrayType(toStringed)) {
+ return hitMaxDepth ? '[' + val.constructor.name + ']' : (min ? '' : val.constructor.name + ' ') + '[' + printListItems(val, config, indentation, depth, refs, printer) + ']';
+ }
+
+ if (toStringed === '[object Map]') {
+ return hitMaxDepth ? '[Map]' : 'Map {' + printIteratorEntries(val.entries(), config, indentation, depth, refs, printer, ' => ') + '}';
+ }
+
+ if (toStringed === '[object Set]') {
+ return hitMaxDepth ? '[Set]' : 'Set {' + printIteratorValues(val.values(), config, indentation, depth, refs, printer) + '}';
+ }
+
+ return hitMaxDepth || isWindow(val) ? '[' + getConstructorName(val) + ']' : (min ? '' : getConstructorName(val) + ' ') + '{' + printObjectProperties(val, config, indentation, depth, refs, printer) + '}';
+ }
+
+ function printPlugin(plugin, val, config, indentation, depth, refs) {
+ var printed = void 0;
+
+ try {
+ printed = plugin.serialize ? plugin.serialize(val, config, indentation, depth, refs, printer) : plugin.print(val, function (valChild) {
+ return printer(valChild, config, indentation, depth, refs);
+ }, function (str) {
+ var indentationNext = indentation + config.indent;
+ return indentationNext + str.replace(NEWLINE_REGEXP, '\n' + indentationNext);
+ }, {
+ edgeSpacing: config.spacingOuter,
+ min: config.min,
+ spacing: config.spacingInner
+ }, config.colors);
+ } catch (error) {
+ throw new PrettyFormatPluginError(error.message, error.stack);
+ }
+
+ if (typeof printed !== 'string') {
+ throw new Error('pretty-format: Plugin must return type "string" but instead returned "' + (typeof printed === 'undefined' ? 'undefined' : _typeof(printed)) + '".');
+ }
+
+ return printed;
+ }
+
+ function findPlugin(plugins, val) {
+ for (var p = 0; p < plugins.length; p++) {
+ try {
+ if (plugins[p].test(val)) {
+ return plugins[p];
+ }
+ } catch (error) {
+ throw new PrettyFormatPluginError(error.message, error.stack);
+ }
+ }
+
+ return null;
+ }
+
+ function printer(val, config, indentation, depth, refs, hasCalledToJSON) {
+ var plugin = findPlugin(config.plugins, val);
+
+ if (plugin !== null) {
+ return printPlugin(plugin, val, config, indentation, depth, refs);
+ }
+
+ var basicResult = printBasicValue(val, config.printFunctionName, config.escapeRegex, config.escapeString);
+
+ if (basicResult !== null) {
+ return basicResult;
+ }
+
+ return printComplexValue(val, config, indentation, depth, refs, hasCalledToJSON);
+ }
+
+ var DEFAULT_THEME = {
+ comment: 'gray',
+ content: 'reset',
+ prop: 'yellow',
+ tag: 'cyan',
+ value: 'green'
+ };
+ var DEFAULT_THEME_KEYS = Object.keys(DEFAULT_THEME);
+ var DEFAULT_OPTIONS = {
+ callToJSON: true,
+ escapeRegex: false,
+ escapeString: true,
+ highlight: false,
+ indent: 2,
+ maxDepth: Infinity,
+ min: false,
+ plugins: [],
+ printFunctionName: true,
+ theme: DEFAULT_THEME
+ };
+
+ function validateOptions(options) {
+ Object.keys(options).forEach(function (key) {
+ if (!DEFAULT_OPTIONS.hasOwnProperty(key)) {
+ throw new Error('pretty-format: Unknown option "' + key + '".');
+ }
+ });
+
+ if (options.min && options.indent !== undefined && options.indent !== 0) {
+ throw new Error('pretty-format: Options "min" and "indent" cannot be used together.');
+ }
+
+ if (options.theme !== undefined) {
+ if (options.theme === null) {
+ throw new Error('pretty-format: Option "theme" must not be null.');
+ }
+
+ if (_typeof(options.theme) !== 'object') {
+ throw new Error('pretty-format: Option "theme" must be of type "object" but instead received "' + _typeof(options.theme) + '".');
+ }
+ }
+ }
+
+ var getColorsHighlight = function getColorsHighlight(options) {
+ return DEFAULT_THEME_KEYS.reduce(function (colors, key) {
+ var value = options.theme && options.theme[key] !== undefined ? options.theme[key] : DEFAULT_THEME[key];
+ var color = ansiStyles[value];
+
+ if (color && typeof color.close === 'string' && typeof color.open === 'string') {
+ colors[key] = color;
+ } else {
+ throw new Error('pretty-format: Option "theme" has a key "' + key + '" whose value "' + value + '" is undefined in ansi-styles.');
+ }
+
+ return colors;
+ }, Object.create(null));
+ };
+
+ var getColorsEmpty = function getColorsEmpty() {
+ return DEFAULT_THEME_KEYS.reduce(function (colors, key) {
+ colors[key] = {
+ close: '',
+ open: ''
+ };
+ return colors;
+ }, Object.create(null));
+ };
+
+ var getPrintFunctionName = function getPrintFunctionName(options) {
+ return options && options.printFunctionName !== undefined ? options.printFunctionName : DEFAULT_OPTIONS.printFunctionName;
+ };
+
+ var getEscapeRegex = function getEscapeRegex(options) {
+ return options && options.escapeRegex !== undefined ? options.escapeRegex : DEFAULT_OPTIONS.escapeRegex;
+ };
+
+ var getEscapeString = function getEscapeString(options) {
+ return options && options.escapeString !== undefined ? options.escapeString : DEFAULT_OPTIONS.escapeString;
+ };
+
+ var getConfig = function getConfig(options) {
+ return {
+ callToJSON: options && options.callToJSON !== undefined ? options.callToJSON : DEFAULT_OPTIONS.callToJSON,
+ colors: options && options.highlight ? getColorsHighlight(options) : getColorsEmpty(),
+ escapeRegex: getEscapeRegex(options),
+ escapeString: getEscapeString(options),
+ indent: options && options.min ? '' : createIndent(options && options.indent !== undefined ? options.indent : DEFAULT_OPTIONS.indent),
+ maxDepth: options && options.maxDepth !== undefined ? options.maxDepth : DEFAULT_OPTIONS.maxDepth,
+ min: options && options.min !== undefined ? options.min : DEFAULT_OPTIONS.min,
+ plugins: options && options.plugins !== undefined ? options.plugins : DEFAULT_OPTIONS.plugins,
+ printFunctionName: getPrintFunctionName(options),
+ spacingInner: options && options.min ? ' ' : '\n',
+ spacingOuter: options && options.min ? '' : '\n'
+ };
+ };
+
+ function createIndent(indent) {
+ return new Array(indent + 1).join(' ');
+ }
+
+ function prettyFormat(val, options) {
+ if (options) {
+ validateOptions(options);
+
+ if (options.plugins) {
+ var plugin = findPlugin(options.plugins, val);
+
+ if (plugin !== null) {
+ return printPlugin(plugin, val, getConfig(options), '', 0, []);
+ }
+ }
+ }
+
+ var basicResult = printBasicValue(val, getPrintFunctionName(options), getEscapeRegex(options), getEscapeString(options));
+
+ if (basicResult !== null) {
+ return basicResult;
+ }
+
+ return printComplexValue(val, getConfig(options), '', 0, []);
+ }
+
+ prettyFormat.plugins = {
+ AsymmetricMatcher: AsymmetricMatcher,
+ ConvertAnsi: ConvertAnsi,
+ DOMCollection: DOMCollection,
+ DOMElement: DOMElement,
+ Immutable: Immutable,
+ ReactElement: ReactElement,
+ ReactTestComponent: ReactTestComponent
+ };
+ module.exports = prettyFormat;
+ });
+},116,[14],"node_modules\\pretty-format\\build-es5\\index.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _require = _$$_REQUIRE(_dependencyMap[0], "PolyfillFunctions"),
+ polyfillGlobal = _require.polyfillGlobal;
+
+ polyfillGlobal('regeneratorRuntime', function () {
+ delete global.regeneratorRuntime;
+ return _$$_REQUIRE(_dependencyMap[1], "regenerator-runtime/runtime");
+ });
+},117,[89,103],"node_modules\\react-native\\Libraries\\Core\\setUpRegeneratorRuntime.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _require = _$$_REQUIRE(_dependencyMap[0], "PolyfillFunctions"),
+ polyfillGlobal = _require.polyfillGlobal;
+
+ var defineLazyTimer = function defineLazyTimer(name) {
+ polyfillGlobal(name, function () {
+ return _$$_REQUIRE(_dependencyMap[1], "JSTimers")[name];
+ });
+ };
+
+ defineLazyTimer('setTimeout');
+ defineLazyTimer('setInterval');
+ defineLazyTimer('setImmediate');
+ defineLazyTimer('clearTimeout');
+ defineLazyTimer('clearInterval');
+ defineLazyTimer('clearImmediate');
+ defineLazyTimer('requestAnimationFrame');
+ defineLazyTimer('cancelAnimationFrame');
+ defineLazyTimer('requestIdleCallback');
+ defineLazyTimer('cancelIdleCallback');
+},118,[89,119],"node_modules\\react-native\\Libraries\\Core\\setUpTimers.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var Platform = _$$_REQUIRE(_dependencyMap[0], "Platform");
+
+ var Systrace = _$$_REQUIRE(_dependencyMap[1], "Systrace");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[2], "invariant");
+
+ var _require = _$$_REQUIRE(_dependencyMap[3], "NativeModules"),
+ Timing = _require.Timing;
+
+ var BatchedBridge = _$$_REQUIRE(_dependencyMap[4], "BatchedBridge");
+
+ var _performanceNow = null;
+
+ function performanceNow() {
+ if (!_performanceNow) {
+ _performanceNow = _$$_REQUIRE(_dependencyMap[5], "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[6], "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[7], "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;
+ }
+
+ BatchedBridge.setImmediatesCallback(ExportedJSTimers.callImmediates.bind(ExportedJSTimers));
+ module.exports = ExportedJSTimers;
+},119,[35,48,19,36,41,120,99,21],"node_modules\\react-native\\Libraries\\Core\\Timers\\JSTimers.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ "use strict";
+
+ var performance = _$$_REQUIRE(_dependencyMap[0], "./performance");
+
+ var performanceNow;
+
+ if (performance.now) {
+ performanceNow = function performanceNow() {
+ return performance.now();
+ };
+ } else {
+ performanceNow = function performanceNow() {
+ return Date.now();
+ };
+ }
+
+ module.exports = performanceNow;
+},120,[121],"node_modules\\fbjs\\lib\\performanceNow.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var ExecutionEnvironment = _$$_REQUIRE(_dependencyMap[0], "./ExecutionEnvironment");
+
+ var performance;
+
+ if (ExecutionEnvironment.canUseDOM) {
+ performance = window.performance || window.msPerformance || window.webkitPerformance;
+ }
+
+ module.exports = performance || {};
+},121,[122],"node_modules\\fbjs\\lib\\performance.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var canUseDOM = !!(typeof window !== 'undefined' && window.document && window.document.createElement);
+ var ExecutionEnvironment = {
+ canUseDOM: canUseDOM,
+ canUseWorkers: typeof Worker !== 'undefined',
+ canUseEventListeners: canUseDOM && !!(window.addEventListener || window.attachEvent),
+ canUseViewport: canUseDOM && !!window.screen,
+ isInWorker: !canUseDOM
+ };
+ module.exports = ExecutionEnvironment;
+},122,[],"node_modules\\fbjs\\lib\\ExecutionEnvironment.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _require = _$$_REQUIRE(_dependencyMap[0], "PolyfillFunctions"),
+ polyfillGlobal = _require.polyfillGlobal;
+
+ polyfillGlobal('XMLHttpRequest', function () {
+ return _$$_REQUIRE(_dependencyMap[1], "XMLHttpRequest");
+ });
+ polyfillGlobal('FormData', function () {
+ return _$$_REQUIRE(_dependencyMap[2], "FormData");
+ });
+ polyfillGlobal('fetch', function () {
+ return _$$_REQUIRE(_dependencyMap[3], "fetch").fetch;
+ });
+ polyfillGlobal('Headers', function () {
+ return _$$_REQUIRE(_dependencyMap[3], "fetch").Headers;
+ });
+ polyfillGlobal('Request', function () {
+ return _$$_REQUIRE(_dependencyMap[3], "fetch").Request;
+ });
+ polyfillGlobal('Response', function () {
+ return _$$_REQUIRE(_dependencyMap[3], "fetch").Response;
+ });
+ polyfillGlobal('WebSocket', function () {
+ return _$$_REQUIRE(_dependencyMap[4], "WebSocket");
+ });
+ polyfillGlobal('Blob', function () {
+ return _$$_REQUIRE(_dependencyMap[5], "Blob");
+ });
+ polyfillGlobal('File', function () {
+ return _$$_REQUIRE(_dependencyMap[6], "File");
+ });
+ polyfillGlobal('FileReader', function () {
+ return _$$_REQUIRE(_dependencyMap[7], "FileReader");
+ });
+ polyfillGlobal('URL', function () {
+ return _$$_REQUIRE(_dependencyMap[8], "URL").URL;
+ });
+ polyfillGlobal('URLSearchParams', function () {
+ return _$$_REQUIRE(_dependencyMap[8], "URL").URLSearchParams;
+ });
+},123,[89,124,138,105,139,135,141,142,143],"node_modules\\react-native\\Libraries\\Core\\setUpXHR.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _toConsumableArray = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/toConsumableArray");
+
+ var _get = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/get");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/classCallCheck");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits");
+
+ var EventTarget = _$$_REQUIRE(_dependencyMap[7], "event-target-shim");
+
+ var RCTNetworking = _$$_REQUIRE(_dependencyMap[8], "RCTNetworking");
+
+ var base64 = _$$_REQUIRE(_dependencyMap[9], "base64-js");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[10], "invariant");
+
+ var warning = _$$_REQUIRE(_dependencyMap[11], "fbjs/lib/warning");
+
+ var BlobManager = _$$_REQUIRE(_dependencyMap[12], "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) {
+ _inherits(XMLHttpRequestEventTarget, _EventTarget);
+
+ function XMLHttpRequestEventTarget() {
+ _classCallCheck(this, XMLHttpRequestEventTarget);
+
+ return _possibleConstructorReturn(this, _getPrototypeOf(XMLHttpRequestEventTarget).apply(this, arguments));
+ }
+
+ return XMLHttpRequestEventTarget;
+ }(EventTarget.apply(void 0, REQUEST_EVENTS));
+
+ var XMLHttpRequest = function (_EventTarget2) {
+ _inherits(XMLHttpRequest, _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 if (this._response === '') {
+ this._cachedResponse = null;
+ } else {
+ throw new Error("Invalid response for blob: " + this._response);
+ }
+
+ break;
+
+ case 'json':
+ try {
+ this._cachedResponse = JSON.parse(this._response);
+ } catch (_) {
+ this._cachedResponse = null;
+ }
+
+ break;
+
+ default:
+ this._cachedResponse = null;
+ }
+
+ return this._cachedResponse;
+ }
+ }]);
+
+ return XMLHttpRequest;
+ }(EventTarget.apply(void 0, _toConsumableArray(XHR_EVENTS)));
+
+ XMLHttpRequest.UNSENT = UNSENT;
+ XMLHttpRequest.OPENED = OPENED;
+ XMLHttpRequest.HEADERS_RECEIVED = HEADERS_RECEIVED;
+ XMLHttpRequest.LOADING = LOADING;
+ XMLHttpRequest.DONE = DONE;
+ XMLHttpRequest._interceptor = null;
+ module.exports = XMLHttpRequest;
+},124,[43,25,4,3,5,8,9,125,129,134,19,21,136],"node_modules\\react-native\\Libraries\\Network\\XMLHttpRequest.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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
+ }
+ });
+},125,[126,127,128],"node_modules\\event-target-shim\\lib\\event-target.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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
+ };
+ };
+},126,[],"node_modules\\event-target-shim\\lib\\commons.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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;
+ };
+},127,[126],"node_modules\\event-target-shim\\lib\\custom-event-target.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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);
+ };
+},128,[126],"node_modules\\event-target-shim\\lib\\event-wrapper.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var MissingNativeEventEmitterShim = _$$_REQUIRE(_dependencyMap[6], "MissingNativeEventEmitterShim");
+
+ var NativeEventEmitter = _$$_REQUIRE(_dependencyMap[7], "NativeEventEmitter");
+
+ var RCTNetworkingNative = _$$_REQUIRE(_dependencyMap[8], "NativeModules").Networking;
+
+ var convertRequestBody = _$$_REQUIRE(_dependencyMap[9], "convertRequestBody");
+
+ var RCTNetworking = function (_NativeEventEmitter) {
+ _inherits(RCTNetworking, _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);
+ }
+ }]);
+
+ return RCTNetworking;
+ }(NativeEventEmitter);
+
+ if (__DEV__ && !RCTNetworkingNative) {
+ var MissingNativeRCTNetworkingShim = function (_MissingNativeEventEm) {
+ _inherits(MissingNativeRCTNetworkingShim, _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();
+ }
+ }]);
+
+ return MissingNativeRCTNetworkingShim;
+ }(MissingNativeEventEmitterShim);
+
+ RCTNetworking = new MissingNativeRCTNetworkingShim();
+ } else {
+ RCTNetworking = new RCTNetworking();
+ }
+
+ module.exports = RCTNetworking;
+},129,[32,3,4,5,8,9,130,131,36,132],"Libraries\\Networking\\RCTNetworking.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var EmitterSubscription = _$$_REQUIRE(_dependencyMap[5], "EmitterSubscription");
+
+ var EventEmitter = _$$_REQUIRE(_dependencyMap[6], "EventEmitter");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[7], "invariant");
+
+ var MissingNativeEventEmitterShim = function (_EventEmitter) {
+ _inherits(MissingNativeEventEmitterShim, _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();
+ }
+ }]);
+
+ return MissingNativeEventEmitterShim;
+ }(EventEmitter);
+
+ module.exports = MissingNativeEventEmitterShim;
+},130,[3,4,5,8,9,28,27,19],"node_modules\\react-native\\Libraries\\EventEmitter\\MissingNativeEventEmitterShim.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _get = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/get");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var EventEmitter = _$$_REQUIRE(_dependencyMap[6], "EventEmitter");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[7], "Platform");
+
+ var RCTDeviceEventEmitter = _$$_REQUIRE(_dependencyMap[8], "RCTDeviceEventEmitter");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[9], "invariant");
+
+ var NativeEventEmitter = function (_EventEmitter) {
+ _inherits(NativeEventEmitter, _EventEmitter);
+
+ function NativeEventEmitter(nativeModule) {
+ var _this;
+
+ _classCallCheck(this, NativeEventEmitter);
+
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(NativeEventEmitter).call(this, RCTDeviceEventEmitter.sharedSubscriber));
+
+ if (Platform.OS === 'ios' || Platform.OS === 'macos') {
+ invariant(nativeModule, 'Native module cannot be null.');
+ _this._nativeModule = nativeModule;
+ }
+
+ return _this;
+ }
+
+ _createClass(NativeEventEmitter, [{
+ key: "addListener",
+ value: function addListener(eventType, listener, context) {
+ if (this._nativeModule != null) {
+ this._nativeModule.addListener(eventType);
+ }
+
+ return _get(_getPrototypeOf(NativeEventEmitter.prototype), "addListener", this).call(this, eventType, listener, context);
+ }
+ }, {
+ key: "removeAllListeners",
+ value: function removeAllListeners(eventType) {
+ invariant(eventType, 'eventType argument is required.');
+ var count = this.listeners(eventType).length;
+
+ if (this._nativeModule != null) {
+ this._nativeModule.removeListeners(count);
+ }
+
+ _get(_getPrototypeOf(NativeEventEmitter.prototype), "removeAllListeners", this).call(this, eventType);
+ }
+ }, {
+ key: "removeSubscription",
+ value: function removeSubscription(subscription) {
+ if (this._nativeModule != null) {
+ this._nativeModule.removeListeners(1);
+ }
+
+ _get(_getPrototypeOf(NativeEventEmitter.prototype), "removeSubscription", this).call(this, subscription);
+ }
+ }]);
+
+ return NativeEventEmitter;
+ }(EventEmitter);
+
+ module.exports = NativeEventEmitter;
+},131,[3,4,5,8,25,9,27,35,24,19],"node_modules\\react-native\\Libraries\\EventEmitter\\NativeEventEmitter.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var binaryToBase64 = _$$_REQUIRE(_dependencyMap[0], "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;
+},132,[133,135,138],"node_modules\\react-native\\Libraries\\Network\\convertRequestBody.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var base64 = _$$_REQUIRE(_dependencyMap[0], "base64-js");
+
+ function binaryToBase64(data) {
+ if (data instanceof ArrayBuffer) {
+ data = new Uint8Array(data);
+ }
+
+ if (data instanceof Uint8Array) {
+ return base64.fromByteArray(data);
+ }
+
+ if (!ArrayBuffer.isView(data)) {
+ throw new Error('data must be ArrayBuffer or typed array');
+ }
+
+ var _data = data,
+ buffer = _data.buffer,
+ byteOffset = _data.byteOffset,
+ byteLength = _data.byteLength;
+ return base64.fromByteArray(new Uint8Array(buffer, byteOffset, byteLength));
+ }
+
+ module.exports = binaryToBase64;
+},133,[134],"node_modules\\react-native\\Libraries\\Utilities\\binaryToBase64.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ exports.byteLength = byteLength;
+ exports.toByteArray = toByteArray;
+ exports.fromByteArray = fromByteArray;
+ var lookup = [];
+ var revLookup = [];
+ var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array;
+ var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+
+ for (var i = 0, len = code.length; i < len; ++i) {
+ lookup[i] = code[i];
+ revLookup[code.charCodeAt(i)] = i;
+ }
+
+ revLookup['-'.charCodeAt(0)] = 62;
+ revLookup['_'.charCodeAt(0)] = 63;
+
+ function getLens(b64) {
+ var len = b64.length;
+
+ if (len % 4 > 0) {
+ throw new Error('Invalid string. Length must be a multiple of 4');
+ }
+
+ var validLen = b64.indexOf('=');
+ if (validLen === -1) validLen = len;
+ var placeHoldersLen = validLen === len ? 0 : 4 - validLen % 4;
+ return [validLen, placeHoldersLen];
+ }
+
+ function byteLength(b64) {
+ var lens = getLens(b64);
+ var validLen = lens[0];
+ var placeHoldersLen = lens[1];
+ return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+ }
+
+ function _byteLength(b64, validLen, placeHoldersLen) {
+ return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+ }
+
+ function toByteArray(b64) {
+ var tmp;
+ var lens = getLens(b64);
+ var validLen = lens[0];
+ var placeHoldersLen = lens[1];
+ var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));
+ var curByte = 0;
+ var len = placeHoldersLen > 0 ? validLen - 4 : validLen;
+
+ 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('');
+ }
+},134,[],"node_modules\\base64-js\\index.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var Blob = function () {
+ function Blob() {
+ var parts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+ var options = arguments.length > 1 ? arguments[1] : undefined;
+
+ _classCallCheck(this, Blob);
+
+ var BlobManager = _$$_REQUIRE(_dependencyMap[2], "BlobManager");
+
+ this.data = BlobManager.createFromParts(parts, options).data;
+ }
+
+ _createClass(Blob, [{
+ key: "slice",
+ value: function slice(start, end) {
+ var BlobManager = _$$_REQUIRE(_dependencyMap[2], "BlobManager");
+
+ var _this$data = this.data,
+ offset = _this$data.offset,
+ size = _this$data.size;
+
+ if (typeof start === 'number') {
+ if (start > size) {
+ start = size;
+ }
+
+ offset += start;
+ size -= start;
+
+ if (typeof end === 'number') {
+ if (end < 0) {
+ end = this.size + end;
+ }
+
+ size = end - start;
+ }
+ }
+
+ return BlobManager.createFromOptions({
+ blobId: this.data.blobId,
+ offset: offset,
+ size: size
+ });
+ }
+ }, {
+ key: "close",
+ value: function close() {
+ var BlobManager = _$$_REQUIRE(_dependencyMap[2], "BlobManager");
+
+ BlobManager.release(this.data.blobId);
+ this.data = null;
+ }
+ }, {
+ key: "data",
+ set: function set(data) {
+ this._data = data;
+ },
+ get: function get() {
+ if (!this._data) {
+ throw new Error('Blob has been closed and is no longer available');
+ }
+
+ return this._data;
+ }
+ }, {
+ key: "size",
+ get: function get() {
+ return this.data.size;
+ }
+ }, {
+ key: "type",
+ get: function get() {
+ return this.data.type || '';
+ }
+ }]);
+
+ return Blob;
+ }();
+
+ module.exports = Blob;
+},135,[3,4,136],"node_modules\\react-native\\Libraries\\Blob\\Blob.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ var Blob = _$$_REQUIRE(_dependencyMap[3], "Blob");
+
+ var BlobRegistry = _$$_REQUIRE(_dependencyMap[4], "BlobRegistry");
+
+ var _require = _$$_REQUIRE(_dependencyMap[5], "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;
+},136,[14,3,4,135,137,36],"node_modules\\react-native\\Libraries\\Blob\\BlobManager.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var registry = {};
+
+ var register = function register(id) {
+ if (registry[id]) {
+ registry[id]++;
+ } else {
+ registry[id] = 1;
+ }
+ };
+
+ var unregister = function unregister(id) {
+ if (registry[id]) {
+ registry[id]--;
+
+ if (registry[id] <= 0) {
+ delete registry[id];
+ }
+ }
+ };
+
+ var has = function has(id) {
+ return registry[id] && registry[id] > 0;
+ };
+
+ module.exports = {
+ register: register,
+ unregister: unregister,
+ has: has
+ };
+},137,[],"node_modules\\react-native\\Libraries\\Blob\\BlobRegistry.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ var _slicedToArray = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var FormData = function () {
+ function FormData() {
+ _classCallCheck(this, FormData);
+
+ this._parts = [];
+ }
+
+ _createClass(FormData, [{
+ key: "append",
+ value: function append(key, value) {
+ this._parts.push([key, value]);
+ }
+ }, {
+ key: "getParts",
+ value: function getParts() {
+ return this._parts.map(function (_ref) {
+ var _ref2 = _slicedToArray(_ref, 2),
+ name = _ref2[0],
+ value = _ref2[1];
+
+ var contentDisposition = 'form-data; name="' + name + '"';
+ var headers = {
+ 'content-disposition': contentDisposition
+ };
+
+ if (typeof value === 'object' && value) {
+ if (typeof value.name === 'string') {
+ headers['content-disposition'] += '; filename="' + value.name + '"';
+ }
+
+ if (typeof value.type === 'string') {
+ headers['content-type'] = value.type;
+ }
+
+ return _objectSpread({}, value, {
+ headers: headers,
+ fieldName: name
+ });
+ }
+
+ return {
+ string: String(value),
+ headers: headers,
+ fieldName: name
+ };
+ });
+ }
+ }]);
+
+ return FormData;
+ }();
+
+ module.exports = FormData;
+},138,[32,37,3,4],"node_modules\\react-native\\Libraries\\Network\\FormData.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _objectWithoutProperties = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/objectWithoutProperties");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var Blob = _$$_REQUIRE(_dependencyMap[6], "Blob");
+
+ var EventTarget = _$$_REQUIRE(_dependencyMap[7], "event-target-shim");
+
+ var NativeEventEmitter = _$$_REQUIRE(_dependencyMap[8], "NativeEventEmitter");
+
+ var BlobManager = _$$_REQUIRE(_dependencyMap[9], "BlobManager");
+
+ var NativeModules = _$$_REQUIRE(_dependencyMap[10], "NativeModules");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[11], "Platform");
+
+ var WebSocketEvent = _$$_REQUIRE(_dependencyMap[12], "WebSocketEvent");
+
+ var base64 = _$$_REQUIRE(_dependencyMap[13], "base64-js");
+
+ var binaryToBase64 = _$$_REQUIRE(_dependencyMap[14], "binaryToBase64");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[15], "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) {
+ _inherits(WebSocket, _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' || Platform.OS === 'win32' || Platform.OS === 'windesktop') {
+ 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;
+ }
+ }]);
+
+ 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;
+},139,[33,3,4,5,8,9,135,125,131,136,36,35,140,134,133,19],"node_modules\\react-native\\Libraries\\WebSocket\\WebSocket.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var WebSocketEvent = function WebSocketEvent(type, eventInitDict) {
+ _classCallCheck(this, WebSocketEvent);
+
+ this.type = type.toString();
+
+ _extends(this, eventInitDict);
+ };
+
+ module.exports = WebSocketEvent;
+},140,[14,3],"node_modules\\react-native\\Libraries\\WebSocket\\WebSocketEvent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var Blob = _$$_REQUIRE(_dependencyMap[5], "Blob");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[6], "invariant");
+
+ var File = function (_Blob) {
+ _inherits(File, _Blob);
+
+ function File(parts, name, options) {
+ var _this;
+
+ _classCallCheck(this, File);
+
+ invariant(parts != null && name != null, 'Failed to construct `File`: Must pass both `parts` and `name` arguments.');
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(File).call(this, parts, options));
+ _this.data.name = name;
+ return _this;
+ }
+
+ _createClass(File, [{
+ key: "name",
+ get: function get() {
+ invariant(this.data.name != null, 'Files must have a name set.');
+ return this.data.name;
+ }
+ }, {
+ key: "lastModified",
+ get: function get() {
+ return this.data.lastModified || 0;
+ }
+ }]);
+
+ return File;
+ }(Blob);
+
+ module.exports = File;
+},141,[3,4,5,8,9,135,19],"node_modules\\react-native\\Libraries\\Blob\\File.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var EventTarget = _$$_REQUIRE(_dependencyMap[5], "event-target-shim");
+
+ var Blob = _$$_REQUIRE(_dependencyMap[6], "Blob");
+
+ var _require = _$$_REQUIRE(_dependencyMap[7], "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) {
+ _inherits(FileReader, _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;
+ }
+ }]);
+
+ return FileReader;
+ }(EventTarget.apply(void 0, READER_EVENTS));
+
+ FileReader.EMPTY = EMPTY;
+ FileReader.LOADING = LOADING;
+ FileReader.DONE = DONE;
+ module.exports = FileReader;
+},142,[3,4,5,8,9,125,135,36],"node_modules\\react-native\\Libraries\\Blob\\FileReader.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+
+ Object.defineProperty(exports, "__esModule", {
+ value: true
+ });
+ exports.URL = exports.URLSearchParams = void 0;
+
+ var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+
+ var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+
+ var _Symbol$iterator;
+
+ var Blob = _$$_REQUIRE(_dependencyMap[3], "Blob");
+
+ var _require = _$$_REQUIRE(_dependencyMap[4], "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 + "/";
+ }
+ }
+
+ _Symbol$iterator = Symbol.iterator;
+
+ var URLSearchParams = function () {
+ function URLSearchParams(params) {
+ var _this = this;
+
+ (0, _classCallCheck2.default)(this, URLSearchParams);
+ this._searchParams = [];
+
+ if (typeof params === 'object') {
+ Object.keys(params).forEach(function (key) {
+ return _this.append(key, params[key]);
+ });
+ }
+ }
+
+ (0, _createClass2.default)(URLSearchParams, [{
+ key: "append",
+ value: function append(key, value) {
+ this._searchParams.push([key, value]);
+ }
+ }, {
+ key: "delete",
+ value: function _delete(name) {
+ throw new Error('not implemented');
+ }
+ }, {
+ key: "get",
+ value: function get(name) {
+ throw new Error('not implemented');
+ }
+ }, {
+ key: "getAll",
+ value: function getAll(name) {
+ throw new Error('not implemented');
+ }
+ }, {
+ key: "has",
+ value: function has(name) {
+ throw new Error('not implemented');
+ }
+ }, {
+ key: "set",
+ value: function set(name, value) {
+ throw new Error('not implemented');
+ }
+ }, {
+ key: "sort",
+ value: function sort() {
+ throw new Error('not implemented');
+ }
+ }, {
+ key: _Symbol$iterator,
+ value: function value() {
+ return this._searchParams[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();
+ }
+ }, {
+ key: "toString",
+ value: function toString() {
+ if (this._searchParams.length === 0) {
+ return '';
+ }
+
+ var last = this._searchParams.length - 1;
+ return this._searchParams.reduce(function (acc, curr, index) {
+ return acc + curr.join('=') + (index === last ? '' : '&');
+ }, '');
+ }
+ }]);
+ return URLSearchParams;
+ }();
+
+ exports.URLSearchParams = URLSearchParams;
+
+ function validateBaseUrl(url) {
+ return /^(?:(?:(?:https?|ftp):)?\/\/)(?:(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z\u00a1-\uffff0-9]-*)*[a-z\u00a1-\uffff0-9]+)(?:\.(?:[a-z\u00a1-\uffff0-9]-*)*[a-z\u00a1-\uffff0-9]+)*(?:\.(?:[a-z\u00a1-\uffff]{2,})))(?::\d{2,5})?(?:[/?#]\S*)?$/i.test(url);
+ }
+
+ var URL = function () {
+ (0, _createClass2.default)(URL, null, [{
+ key: "createObjectURL",
+ value: function createObjectURL(blob) {
+ if (BLOB_URL_PREFIX === null) {
+ throw new Error('Cannot create URL for blob!');
+ }
+
+ return "" + BLOB_URL_PREFIX + blob.data.blobId + "?offset=" + blob.data.offset + "&size=" + blob.size;
+ }
+ }, {
+ key: "revokeObjectURL",
+ value: function revokeObjectURL(url) {}
+ }]);
+
+ function URL(url, base) {
+ (0, _classCallCheck2.default)(this, URL);
+ this._searchParamsInstance = null;
+ var baseUrl = null;
+
+ if (base) {
+ if (typeof base === 'string') {
+ baseUrl = base;
+
+ if (!validateBaseUrl(baseUrl)) {
+ throw new TypeError("Invalid base URL: " + baseUrl);
+ }
+ } else if (typeof base === 'object') {
+ baseUrl = base.toString();
+ }
+
+ if (baseUrl.endsWith('/') && url.startsWith('/')) {
+ baseUrl = baseUrl.slice(0, baseUrl.length - 1);
+ }
+
+ if (baseUrl.endsWith(url)) {
+ url = '';
+ }
+
+ this._url = "" + baseUrl + url;
+ } else {
+ this._url = url;
+
+ if (!this._url.endsWith('/')) {
+ this._url += '/';
+ }
+ }
+ }
+
+ (0, _createClass2.default)(URL, [{
+ key: "toJSON",
+ value: function toJSON() {
+ return this.toString();
+ }
+ }, {
+ key: "toString",
+ value: function toString() {
+ if (this._searchParamsInstance === null) {
+ return this._url;
+ }
+
+ var separator = this._url.indexOf('?') > -1 ? '&' : '?';
+ return this._url + separator + this._searchParamsInstance.toString();
+ }
+ }, {
+ key: "hash",
+ get: function get() {
+ throw new Error('not implemented');
+ }
+ }, {
+ key: "host",
+ get: function get() {
+ throw new Error('not implemented');
+ }
+ }, {
+ key: "hostname",
+ get: function get() {
+ throw new Error('not implemented');
+ }
+ }, {
+ key: "href",
+ get: function get() {
+ return this.toString();
+ }
+ }, {
+ key: "origin",
+ get: function get() {
+ throw new Error('not implemented');
+ }
+ }, {
+ key: "password",
+ get: function get() {
+ throw new Error('not implemented');
+ }
+ }, {
+ key: "pathname",
+ get: function get() {
+ throw new Error('not implemented');
+ }
+ }, {
+ key: "port",
+ get: function get() {
+ throw new Error('not implemented');
+ }
+ }, {
+ key: "protocol",
+ get: function get() {
+ throw new Error('not implemented');
+ }
+ }, {
+ key: "search",
+ get: function get() {
+ throw new Error('not implemented');
+ }
+ }, {
+ key: "searchParams",
+ get: function get() {
+ if (this._searchParamsInstance == null) {
+ this._searchParamsInstance = new URLSearchParams();
+ }
+
+ return this._searchParamsInstance;
+ }
+ }, {
+ key: "username",
+ get: function get() {
+ throw new Error('not implemented');
+ }
+ }]);
+ return URL;
+ }();
+
+ exports.URL = URL;
+},143,[1,3,4,135,36],"node_modules\\react-native\\Libraries\\Blob\\URL.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ if (!global.alert) {
+ global.alert = function (text) {
+ _$$_REQUIRE(_dependencyMap[0], "Alert").alert('Alert', '' + text);
+ };
+ }
+},144,[145],"node_modules\\react-native\\Libraries\\Core\\setUpAlert.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var AlertMacOS = _$$_REQUIRE(_dependencyMap[3], "AlertMacOS");
+
+ var NativeModules = _$$_REQUIRE(_dependencyMap[4], "NativeModules");
+
+ var RCTAlertManager = NativeModules.AlertManager;
+
+ var Platform = _$$_REQUIRE(_dependencyMap[5], "Platform");
+
+ var Alert = function () {
+ function Alert() {
+ _classCallCheck(this, Alert);
+ }
+
+ _createClass(Alert, null, [{
+ key: "alert",
+ value: function alert(title, message, buttons, options) {
+ if (Platform.OS === 'ios') {
+ AlertIOS.alert(title, message, buttons);
+ } else if (Platform.OS === 'macos') {
+ AlertMacOS.alert(title, message, buttons);
+ } else if (Platform.OS === 'android') {
+ AlertAndroid.alert(title, message, buttons, options);
+ }
+ }
+ }, {
+ key: "prompt",
+ value: function prompt(title, message, callbackOrButtons) {
+ var type = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'plain-text';
+ var defaultValue = arguments.length > 4 ? arguments[4] : undefined;
+ var keyboardType = arguments.length > 5 ? arguments[5] : undefined;
+
+ if (Platform.OS === 'ios') {
+ AlertIOS.prompt(title, message, callbackOrButtons, type, defaultValue, keyboardType);
+ }
+ }
+ }]);
+
+ return Alert;
+ }();
+
+ var AlertIOS = function () {
+ function AlertIOS() {
+ _classCallCheck(this, AlertIOS);
+ }
+
+ _createClass(AlertIOS, null, [{
+ key: "alert",
+ value: function alert(title, message, callbackOrButtons) {
+ 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 Alert.prompt(). React Native is ' + 'assuming you want to use the deprecated Alert.prompt(title, defaultValue, buttons, callback) ' + 'signature. The current signature is Alert.prompt(title, message, callbackOrButtons, type, defaultValue, ' + 'keyboardType) and the old syntax will be removed in a future version.');
+ var callback = type;
+ RCTAlertManager.alertWithArgs({
+ title: title || '',
+ type: 'plain-text',
+ defaultValue: message
+ }, function (id, value) {
+ callback(value);
+ });
+ return;
+ }
+
+ var callbacks = [];
+ var buttons = [];
+ var cancelButtonKey;
+ var destructiveButtonKey;
+
+ if (typeof callbackOrButtons === 'function') {
+ callbacks = [callbackOrButtons];
+ } else if (Array.isArray(callbackOrButtons)) {
+ callbackOrButtons.forEach(function (btn, index) {
+ callbacks[index] = btn.onPress;
+
+ if (btn.style === 'cancel') {
+ cancelButtonKey = String(index);
+ } else if (btn.style === 'destructive') {
+ destructiveButtonKey = String(index);
+ }
+
+ if (btn.text || index < (callbackOrButtons || []).length - 1) {
+ var btnDef = {};
+ btnDef[index] = btn.text || '';
+ buttons.push(btnDef);
+ }
+ });
+ }
+
+ RCTAlertManager.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;
+ }();
+
+ 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;
+},145,[32,3,4,146,36,35],"node_modules\\react-native\\Libraries\\Alert\\Alert.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var RCTAlertManager = _$$_REQUIRE(_dependencyMap[2], "NativeModules").AlertManager;
+
+ var AlertMacOS = function () {
+ function AlertMacOS() {
+ _classCallCheck(this, AlertMacOS);
+ }
+
+ _createClass(AlertMacOS, null, [{
+ key: "alert",
+ value: function alert(title, message, callbackOrButtons) {
+ 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 defaultInputs = arguments.length > 4 ? arguments[4] : undefined;
+ var modal = arguments.length > 5 ? arguments[5] : undefined;
+ var critical = arguments.length > 6 ? arguments[6] : undefined;
+ var callbacks = [];
+ var buttons = [];
+
+ if (typeof callbackOrButtons === 'function') {
+ callbacks = [callbackOrButtons];
+ } else if (callbackOrButtons instanceof Array) {
+ callbackOrButtons.forEach(function (btn, index) {
+ callbacks[index] = btn.onPress;
+
+ if (btn.text || index < (callbackOrButtons || []).length - 1) {
+ var btnDef = {};
+ btnDef[index] = btn.text || '';
+ buttons.push(btnDef);
+ }
+ });
+ }
+
+ RCTAlertManager.alertWithArgs({
+ title: title || undefined,
+ message: message || undefined,
+ buttons: buttons,
+ type: type || undefined,
+ defaultInputs: defaultInputs,
+ modal: modal || undefined,
+ critical: critical || undefined
+ }, function (id, value) {
+ var cb = callbacks[id];
+ cb && cb(value);
+ });
+ }
+ }]);
+
+ return AlertMacOS;
+ }();
+
+ module.exports = AlertMacOS;
+},146,[3,4,36],"node_modules\\react-native\\Libraries\\Alert\\AlertMacOS.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _require = _$$_REQUIRE(_dependencyMap[0], "PolyfillFunctions"),
+ polyfillObjectProperty = _require.polyfillObjectProperty;
+
+ var navigator = global.navigator;
+
+ if (navigator === undefined) {
+ global.navigator = navigator = {};
+ }
+
+ polyfillObjectProperty(navigator, 'product', function () {
+ return 'ReactNative';
+ });
+ polyfillObjectProperty(navigator, 'geolocation', function () {
+ return _$$_REQUIRE(_dependencyMap[1], "Geolocation");
+ });
+},147,[89,148],"node_modules\\react-native\\Libraries\\Core\\setUpGeolocation.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _regeneratorRuntime = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/regenerator");
+
+ var NativeEventEmitter = _$$_REQUIRE(_dependencyMap[1], "NativeEventEmitter");
+
+ var RCTLocationObserver = _$$_REQUIRE(_dependencyMap[2], "NativeModules").LocationObserver;
+
+ var invariant = _$$_REQUIRE(_dependencyMap[3], "invariant");
+
+ var logError = _$$_REQUIRE(_dependencyMap[4], "logError");
+
+ var warning = _$$_REQUIRE(_dependencyMap[5], "fbjs/lib/warning");
+
+ var LocationEventEmitter = new NativeEventEmitter(RCTLocationObserver);
+
+ var Platform = _$$_REQUIRE(_dependencyMap[6], "Platform");
+
+ var PermissionsAndroid = _$$_REQUIRE(_dependencyMap[7], "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();
+ }
+ }
+ });
+ },
+ 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;
+},148,[102,131,36,19,149,21,35,150],"node_modules\\react-native\\Libraries\\Geolocation\\Geolocation.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var logError = function logError() {
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ if (args.length === 1 && args[0] instanceof Error) {
+ var err = args[0];
+ console.error('Error: "' + err.message + '". Stack:\n' + err.stack);
+ } else {
+ console.error.apply(console, args);
+ }
+ };
+
+ module.exports = logError;
+},149,[],"node_modules\\react-native\\Libraries\\Utilities\\logError.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _regeneratorRuntime = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/regenerator");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ var NativeModules = _$$_REQUIRE(_dependencyMap[3], "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();
+ }
+ }
+ });
+ }
+ }, {
+ key: "requestMultiple",
+ value: function requestMultiple(permissions) {
+ return NativeModules.PermissionsAndroid.requestMultiplePermissions(permissions);
+ }
+ }]);
+
+ return PermissionsAndroid;
+ }();
+
+ PermissionsAndroid = new PermissionsAndroid();
+ module.exports = PermissionsAndroid;
+},150,[102,3,4,36],"node_modules\\react-native\\Libraries\\PermissionsAndroid\\PermissionsAndroid.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var BatchedBridge = _$$_REQUIRE(_dependencyMap[0], "BatchedBridge");
+
+ BatchedBridge.registerLazyCallableModule('Systrace', function () {
+ return _$$_REQUIRE(_dependencyMap[1], "Systrace");
+ });
+ BatchedBridge.registerLazyCallableModule('JSTimers', function () {
+ return _$$_REQUIRE(_dependencyMap[2], "JSTimers");
+ });
+ BatchedBridge.registerLazyCallableModule('HeapCapture', function () {
+ return _$$_REQUIRE(_dependencyMap[3], "HeapCapture");
+ });
+ BatchedBridge.registerLazyCallableModule('SamplingProfiler', function () {
+ return _$$_REQUIRE(_dependencyMap[4], "SamplingProfiler");
+ });
+ BatchedBridge.registerLazyCallableModule('RCTLog', function () {
+ return _$$_REQUIRE(_dependencyMap[5], "RCTLog");
+ });
+ BatchedBridge.registerLazyCallableModule('RCTDeviceEventEmitter', function () {
+ return _$$_REQUIRE(_dependencyMap[6], "RCTDeviceEventEmitter");
+ });
+ BatchedBridge.registerLazyCallableModule('RCTNativeAppEventEmitter', function () {
+ return _$$_REQUIRE(_dependencyMap[7], "RCTNativeAppEventEmitter");
+ });
+ BatchedBridge.registerLazyCallableModule('PerformanceLogger', function () {
+ return _$$_REQUIRE(_dependencyMap[8], "PerformanceLogger");
+ });
+ BatchedBridge.registerLazyCallableModule('JSDevSupportModule', function () {
+ return _$$_REQUIRE(_dependencyMap[9], "JSDevSupportModule");
+ });
+
+ if (__DEV__ && !global.__RCTProfileIsProfiling) {
+ BatchedBridge.registerCallableModule('HMRClient', _$$_REQUIRE(_dependencyMap[10], "HMRClient"));
+ }
+},151,[41,48,119,152,153,154,24,155,156,158,159],"node_modules\\react-native\\Libraries\\Core\\setUpBatchedBridge.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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;
+},152,[36],"node_modules\\react-native\\Libraries\\Utilities\\HeapCapture.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var SamplingProfiler = {
+ poke: function poke(token) {
+ var error = null;
+ var result = null;
+
+ try {
+ result = global.pokeSamplingProfiler();
+
+ if (result === null) {
+ console.log('The JSC Sampling Profiler has started');
+ } else {
+ console.log('The JSC Sampling Profiler has stopped');
+ }
+ } catch (e) {
+ console.log('Error occurred when restarting Sampling Profiler: ' + e.toString());
+ error = e.toString();
+ }
+
+ var _require = _$$_REQUIRE(_dependencyMap[0], "NativeModules"),
+ JSCSamplingProfiler = _require.JSCSamplingProfiler;
+
+ JSCSamplingProfiler.operationComplete(token, result, error);
+ }
+ };
+ module.exports = SamplingProfiler;
+},153,[36],"node_modules\\react-native\\Libraries\\Performance\\SamplingProfiler.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var invariant = _$$_REQUIRE(_dependencyMap[0], "invariant");
+
+ var levelsMap = {
+ log: 'log',
+ info: 'info',
+ warn: 'warn',
+ error: 'error',
+ fatal: 'error'
+ };
+ var warningHandler = null;
+ var RCTLog = {
+ logIfNoNativeHook: function logIfNoNativeHook(level) {
+ for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+ args[_key - 1] = arguments[_key];
+ }
+
+ if (typeof global.nativeLoggingHook === 'undefined') {
+ RCTLog.logToConsole.apply(RCTLog, [level].concat(args));
+ } else {
+ if (warningHandler && level === 'warn') {
+ warningHandler.apply(void 0, args);
+ }
+ }
+ },
+ logToConsole: function logToConsole(level) {
+ var _console;
+
+ var logFn = levelsMap[level];
+ invariant(logFn, 'Level "' + level + '" not one of ' + Object.keys(levelsMap).toString());
+
+ for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+ args[_key2 - 1] = arguments[_key2];
+ }
+
+ (_console = console)[logFn].apply(_console, args);
+ },
+ setWarningHandler: function setWarningHandler(handler) {
+ warningHandler = handler;
+ }
+ };
+ module.exports = RCTLog;
+},154,[19],"node_modules\\react-native\\Libraries\\Utilities\\RCTLog.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var RCTDeviceEventEmitter = _$$_REQUIRE(_dependencyMap[0], "RCTDeviceEventEmitter");
+
+ var RCTNativeAppEventEmitter = RCTDeviceEventEmitter;
+ module.exports = RCTNativeAppEventEmitter;
+},155,[24],"node_modules\\react-native\\Libraries\\EventEmitter\\RCTNativeAppEventEmitter.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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 points = {};
+ 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 = {};
+ points = {};
+
+ if (PRINT_TO_CONSOLE) {
+ infoLog('PerformanceLogger.js', 'clear');
+ }
+ },
+ clearCompleted: function clearCompleted() {
+ for (var _key in timespans) {
+ if (timespans[_key].totalTime) {
+ delete timespans[_key];
+ }
+ }
+
+ extras = {};
+ points = {};
+
+ 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 = {};
+ points = {};
+
+ 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);
+ },
+ markPoint: function markPoint(key, timestamp) {
+ var _timestamp;
+
+ if (points[key]) {
+ if (__DEV__) {
+ infoLog('PerformanceLogger: Attempting to mark a point that has been already logged ', key);
+ }
+
+ return;
+ }
+
+ points[key] = (_timestamp = timestamp) != null ? _timestamp : performanceNow();
+ },
+ getPoints: function getPoints() {
+ return points;
+ },
+ logPoints: function logPoints() {
+ for (var _key3 in points) {
+ infoLog(_key3 + ': ' + points[_key3] + 'ms');
+ }
+ }
+ };
+ module.exports = PerformanceLogger;
+},156,[48,157,120],"node_modules\\react-native\\Libraries\\Utilities\\PerformanceLogger.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ function infoLog() {
+ var _console;
+
+ return (_console = console).log.apply(_console, arguments);
+ }
+
+ module.exports = infoLog;
+},157,[],"node_modules\\react-native\\Libraries\\Utilities\\infoLog.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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;
+},158,[36,84],"node_modules\\react-native\\Libraries\\Utilities\\JSDevSupportModule.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var Platform = _$$_REQUIRE(_dependencyMap[0], "Platform");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[1], "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' || Platform.OS === 'macos') {
+ 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();
+
+ if (data.type === 'GraphNotFoundError') {
+ hmrClient.disable();
+ throw new Error('The packager server has restarted since the last Hot update. Hot Reloading will be disabled until you reload the application.');
+ } else if (data.type === 'RevisionNotFoundError') {
+ hmrClient.disable();
+ throw new Error('The packager server and the client are out of sync. Hot Reloading will be disabled until you reload the application.');
+ } else {
+ throw new Error(data.type + " " + data.message);
+ }
+ });
+ hmrClient.on('close', function (data) {
+ HMRLoadingView.hide();
+ throw new Error('Disconnected from the packager server. Hot Reloading will be disabled until you reload the application.');
+ });
+ hmrClient.enable();
+ }
+ };
+ module.exports = HMRClient;
+},159,[35,19,160,164,36],"node_modules\\react-native\\Libraries\\Utilities\\HMRClient.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ "use strict";
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/inherits");
+
+ var WebSocketHMRClient = _$$_REQUIRE(_dependencyMap[4], "./WebSocketHMRClient");
+
+ var injectUpdate = _$$_REQUIRE(_dependencyMap[5], "./injectUpdate");
+
+ var HMRClient = function (_WebSocketHMRClient) {
+ _inherits(HMRClient, _WebSocketHMRClient);
+
+ function HMRClient(url) {
+ var _this;
+
+ _classCallCheck(this, HMRClient);
+
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(HMRClient).call(this, url));
+
+ _this.on("update", function (update) {
+ injectUpdate(update);
+ });
+
+ return _this;
+ }
+
+ return HMRClient;
+ }(WebSocketHMRClient);
+
+ module.exports = HMRClient;
+},160,[3,5,8,9,161,163],"node_modules\\react-native\\node_modules\\metro\\src\\lib\\bundle-modules\\HMRClient.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ "use strict";
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var EventEmitter = _$$_REQUIRE(_dependencyMap[5], "eventemitter3");
+
+ var WebSocketHMRClient = function (_EventEmitter) {
+ _inherits(WebSocketHMRClient, _EventEmitter);
+
+ function WebSocketHMRClient(url) {
+ var _this;
+
+ _classCallCheck(this, WebSocketHMRClient);
+
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(WebSocketHMRClient).call(this));
+ _this._url = url;
+ return _this;
+ }
+
+ _createClass(WebSocketHMRClient, [{
+ key: "enable",
+ value: function enable() {
+ var _this2 = this;
+
+ if (this._ws) {
+ this.disable();
+ }
+
+ this._ws = new global.WebSocket(this._url);
+
+ this._ws.onopen = function () {
+ _this2.emit("open");
+ };
+
+ 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":
+ _this2.emit("update", data.body);
+
+ 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;
+ }
+ }
+ }]);
+
+ return WebSocketHMRClient;
+ }(EventEmitter);
+
+ module.exports = WebSocketHMRClient;
+},161,[3,4,5,8,9,162],"node_modules\\react-native\\node_modules\\metro\\src\\lib\\bundle-modules\\WebSocketHMRClient.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var has = Object.prototype.hasOwnProperty,
+ prefix = '~';
+
+ function Events() {}
+
+ if (Object.create) {
+ Events.prototype = Object.create(null);
+ if (!new Events().__proto__) prefix = false;
+ }
+
+ function EE(fn, context, once) {
+ this.fn = fn;
+ this.context = context;
+ this.once = once || false;
+ }
+
+ function addListener(emitter, event, fn, context, once) {
+ if (typeof fn !== 'function') {
+ throw new TypeError('The listener must be a function');
+ }
+
+ var listener = new EE(fn, context || emitter, once),
+ evt = prefix ? prefix + event : event;
+ if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);else emitter._events[evt] = [emitter._events[evt], listener];
+ return emitter;
+ }
+
+ function clearEvent(emitter, evt) {
+ if (--emitter._eventsCount === 0) emitter._events = new Events();else delete emitter._events[evt];
+ }
+
+ function EventEmitter() {
+ this._events = new Events();
+ this._eventsCount = 0;
+ }
+
+ EventEmitter.prototype.eventNames = function eventNames() {
+ var names = [],
+ events,
+ name;
+ if (this._eventsCount === 0) return names;
+
+ for (name in events = this._events) {
+ if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
+ }
+
+ if (Object.getOwnPropertySymbols) {
+ return names.concat(Object.getOwnPropertySymbols(events));
+ }
+
+ return names;
+ };
+
+ EventEmitter.prototype.listeners = function listeners(event) {
+ var evt = prefix ? prefix + event : event,
+ handlers = this._events[evt];
+ if (!handlers) return [];
+ if (handlers.fn) return [handlers.fn];
+
+ for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
+ ee[i] = handlers[i].fn;
+ }
+
+ return ee;
+ };
+
+ EventEmitter.prototype.listenerCount = function listenerCount(event) {
+ var evt = prefix ? prefix + event : event,
+ listeners = this._events[evt];
+ if (!listeners) return 0;
+ if (listeners.fn) return 1;
+ return listeners.length;
+ };
+
+ EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+ var evt = prefix ? prefix + event : event;
+ if (!this._events[evt]) return false;
+ var listeners = this._events[evt],
+ len = arguments.length,
+ args,
+ i;
+
+ if (listeners.fn) {
+ if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);
+
+ switch (len) {
+ case 1:
+ return listeners.fn.call(listeners.context), true;
+
+ case 2:
+ return listeners.fn.call(listeners.context, a1), true;
+
+ case 3:
+ return listeners.fn.call(listeners.context, a1, a2), true;
+
+ case 4:
+ return listeners.fn.call(listeners.context, a1, a2, a3), true;
+
+ case 5:
+ return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+
+ case 6:
+ return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+ }
+
+ for (i = 1, args = new Array(len - 1); i < len; i++) {
+ args[i - 1] = arguments[i];
+ }
+
+ listeners.fn.apply(listeners.context, args);
+ } else {
+ var length = listeners.length,
+ j;
+
+ for (i = 0; i < length; i++) {
+ if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);
+
+ switch (len) {
+ case 1:
+ listeners[i].fn.call(listeners[i].context);
+ break;
+
+ case 2:
+ listeners[i].fn.call(listeners[i].context, a1);
+ break;
+
+ case 3:
+ listeners[i].fn.call(listeners[i].context, a1, a2);
+ break;
+
+ case 4:
+ listeners[i].fn.call(listeners[i].context, a1, a2, a3);
+ break;
+
+ default:
+ if (!args) for (j = 1, args = new Array(len - 1); j < len; j++) {
+ args[j - 1] = arguments[j];
+ }
+ listeners[i].fn.apply(listeners[i].context, args);
+ }
+ }
+ }
+
+ return true;
+ };
+
+ EventEmitter.prototype.on = function on(event, fn, context) {
+ return addListener(this, event, fn, context, false);
+ };
+
+ EventEmitter.prototype.once = function once(event, fn, context) {
+ return addListener(this, event, fn, context, true);
+ };
+
+ EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
+ var evt = prefix ? prefix + event : event;
+ if (!this._events[evt]) return this;
+
+ if (!fn) {
+ clearEvent(this, evt);
+ return this;
+ }
+
+ var listeners = this._events[evt];
+
+ if (listeners.fn) {
+ if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
+ clearEvent(this, evt);
+ }
+ } else {
+ for (var i = 0, events = [], length = listeners.length; i < length; i++) {
+ if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) {
+ events.push(listeners[i]);
+ }
+ }
+
+ if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;else clearEvent(this, evt);
+ }
+
+ return this;
+ };
+
+ EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
+ var evt;
+
+ if (event) {
+ evt = prefix ? prefix + event : event;
+ if (this._events[evt]) clearEvent(this, evt);
+ } else {
+ this._events = new Events();
+ this._eventsCount = 0;
+ }
+
+ return this;
+ };
+
+ EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+ EventEmitter.prototype.addListener = EventEmitter.prototype.on;
+ EventEmitter.prefixed = prefix;
+ EventEmitter.EventEmitter = EventEmitter;
+
+ if ('undefined' !== typeof module) {
+ module.exports = EventEmitter;
+ }
+},162,[],"node_modules\\eventemitter3\\index.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ "use strict";
+
+ function _slicedToArray(arr, i) {
+ return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest();
+ }
+
+ function _nonIterableRest() {
+ throw new TypeError("Invalid attempt to destructure non-iterable instance");
+ }
+
+ function _iterableToArrayLimit(arr, i) {
+ var _arr = [];
+ var _n = true;
+ var _d = false;
+ var _e = undefined;
+
+ try {
+ for (var _i = arr[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"](), _s; !(_n = (_s = _i.next()).done); _n = true) {
+ _arr.push(_s.value);
+
+ if (i && _arr.length === i) break;
+ }
+ } catch (err) {
+ _d = true;
+ _e = err;
+ } finally {
+ try {
+ if (!_n && _i["return"] != null) _i["return"]();
+ } finally {
+ if (_d) throw _e;
+ }
+ }
+
+ return _arr;
+ }
+
+ function _arrayWithHoles(arr) {
+ if (Array.isArray(arr)) return arr;
+ }
+
+ function injectModules(modules, sourceMappingURLs, sourceURLs) {
+ modules.forEach(function (_ref, i) {
+ var _ref2 = _slicedToArray(_ref, 2),
+ id = _ref2[0],
+ code = _ref2[1];
+
+ var injectFunction = typeof global.nativeInjectHMRUpdate === "function" ? global.nativeInjectHMRUpdate : eval;
+ var pragma = "sourceMappingURL";
+ injectFunction(code + ("\n//# " + pragma + "=" + sourceMappingURLs[i]), sourceURLs[i]);
+ });
+ }
+
+ function injectUpdate(update) {
+ injectModules(update.added, update.addedSourceMappingURLs, update.addedSourceURLs);
+ injectModules(update.modified, update.modifiedSourceMappingURLs, update.modifiedSourceURLs);
+ }
+
+ module.exports = injectUpdate;
+},163,[],"node_modules\\react-native\\node_modules\\metro\\src\\lib\\bundle-modules\\injectUpdate.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var HMRLoadingView = function () {
+ function HMRLoadingView() {
+ _classCallCheck(this, HMRLoadingView);
+ }
+
+ _createClass(HMRLoadingView, null, [{
+ key: "showMessage",
+ value: function showMessage(message) {}
+ }, {
+ key: "hide",
+ value: function hide() {}
+ }]);
+
+ return HMRLoadingView;
+ }();
+
+ module.exports = HMRLoadingView;
+},164,[3,4],"Libraries\\Utilities\\HMRLoadingView.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ global.__fetchSegment = function (segmentId, options, callback) {
+ var _require = _$$_REQUIRE(_dependencyMap[0], "NativeModules"),
+ SegmentFetcher = _require.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);
+ });
+ };
+},165,[36],"node_modules\\react-native\\Libraries\\Core\\setUpSegmentFetcher.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ if (__DEV__) {
+ if (!global.__RCTProfileIsProfiling) {
+ if (!window.document) {
+ _$$_REQUIRE(_dependencyMap[0], "setupDevtools");
+ }
+
+ var JSInspector = _$$_REQUIRE(_dependencyMap[1], "JSInspector");
+
+ JSInspector.registerAgent(_$$_REQUIRE(_dependencyMap[2], "NetworkAgent"));
+ }
+ }
+},166,[167,170,171],"node_modules\\react-native\\Libraries\\Core\\setUpDeveloperTools.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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.isAvailable || 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
+ };
+},167,[168,139,169,104,80],"node_modules\\react-native\\Libraries\\Core\\Devtools\\setupDevtools.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var MissingNativeEventEmitterShim = _$$_REQUIRE(_dependencyMap[5], "MissingNativeEventEmitterShim");
+
+ var NativeEventEmitter = _$$_REQUIRE(_dependencyMap[6], "NativeEventEmitter");
+
+ var NativeModules = _$$_REQUIRE(_dependencyMap[7], "NativeModules");
+
+ var RCTAppState = NativeModules.AppState;
+
+ var logError = _$$_REQUIRE(_dependencyMap[8], "logError");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[9], "invariant");
+
+ var AppState = function (_NativeEventEmitter) {
+ _inherits(AppState, _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);
+ }
+ }]);
+
+ return AppState;
+ }(NativeEventEmitter);
+
+ if (__DEV__ && !RCTAppState) {
+ var MissingNativeAppStateShim = function (_MissingNativeEventEm) {
+ _inherits(MissingNativeAppStateShim, _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();
+ }
+ }]);
+
+ return MissingNativeAppStateShim;
+ }(MissingNativeEventEmitterShim);
+
+ AppState = new MissingNativeAppStateShim();
+ } else {
+ AppState = new AppState();
+ }
+
+ module.exports = AppState;
+},168,[3,4,5,8,9,130,131,36,149,19],"node_modules\\react-native\\Libraries\\AppState\\AppState.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ !function (e, t) {
+ "object" == typeof exports && "object" == typeof module ? module.exports = t() : "function" == typeof define && define.amd ? define([], t) : "object" == typeof exports ? exports.ReactDevToolsBackend = t() : e.ReactDevToolsBackend = t();
+ }(window, function () {
+ return function (e) {
+ var t = {};
+
+ function n(r) {
+ if (t[r]) return t[r].exports;
+ var o = t[r] = {
+ i: r,
+ l: !1,
+ exports: {}
+ };
+ return e[r].call(o.exports, o, o.exports, n), o.l = !0, o.exports;
+ }
+
+ return n.m = e, n.c = t, n.d = function (e, t, r) {
+ n.o(e, t) || Object.defineProperty(e, t, {
+ enumerable: !0,
+ get: r
+ });
+ }, n.r = function (e) {
+ "undefined" != typeof Symbol && (typeof Symbol === "function" ? Symbol.toStringTag : "@@toStringTag") && Object.defineProperty(e, typeof Symbol === "function" ? Symbol.toStringTag : "@@toStringTag", {
+ value: "Module"
+ }), Object.defineProperty(e, "__esModule", {
+ value: !0
+ });
+ }, n.t = function (e, t) {
+ if (1 & t && (e = n(e)), 8 & t) return e;
+ if (4 & t && "object" == typeof e && e && e.__esModule) return e;
+ var r = Object.create(null);
+ if (n.r(r), Object.defineProperty(r, "default", {
+ enumerable: !0,
+ value: e
+ }), 2 & t && "string" != typeof e) for (var o in e) {
+ n.d(r, o, function (t) {
+ return e[t];
+ }.bind(null, o));
+ }
+ return r;
+ }, n.n = function (e) {
+ var t = e && e.__esModule ? function () {
+ return e.default;
+ } : function () {
+ return e;
+ };
+ return n.d(t, "a", t), t;
+ }, n.o = function (e, t) {
+ return Object.prototype.hasOwnProperty.call(e, t);
+ }, n.p = "", n(n.s = 8);
+ }([function (e, t, n) {
+ var r, o, i;
+ !function (a, s) {
+ "use strict";
+
+ o = [n(54)], void 0 === (i = "function" == typeof (r = function r(e) {
+ var t = /(^|@)\S+\:\d+/,
+ n = /^\s*at .*(\S+\:\d+|\(native\))/m,
+ r = /^(eval@)?(\[native code\])?$/;
+ return {
+ parse: function parse(e) {
+ if (void 0 !== e.stacktrace || void 0 !== e["opera#sourceloc"]) return this.parseOpera(e);
+ if (e.stack && e.stack.match(n)) return this.parseV8OrIE(e);
+ if (e.stack) return this.parseFFOrSafari(e);
+ throw new Error("Cannot parse given Error object");
+ },
+ extractLocation: function extractLocation(e) {
+ if (-1 === e.indexOf(":")) return [e];
+ var t = /(.+?)(?:\:(\d+))?(?:\:(\d+))?$/.exec(e.replace(/[\(\)]/g, ""));
+ return [t[1], t[2] || void 0, t[3] || void 0];
+ },
+ parseV8OrIE: function parseV8OrIE(t) {
+ var r = t.stack.split("\n").filter(function (e) {
+ return !!e.match(n);
+ }, this);
+ return r.map(function (t) {
+ t.indexOf("(eval ") > -1 && (t = t.replace(/eval code/g, "eval").replace(/(\(eval at [^\()]*)|(\)\,.*$)/g, ""));
+ var n = t.replace(/^\s+/, "").replace(/\(eval code/g, "(").split(/\s+/).slice(1),
+ r = this.extractLocation(n.pop()),
+ o = n.join(" ") || void 0,
+ i = ["eval", ""].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(//, "$2").replace(/\([^\)]*\)/g, "") || void 0;
+ i.match(/\(([^\)]*)\)/) && (n = i.replace(/^[^\(]+\(([^\)]*)\)$/, "$1"));
+ var s = void 0 === n || "[arguments not available]" === n ? void 0 : n.split(",");
+ return new e({
+ functionName: a,
+ args: s,
+ fileName: o[0],
+ lineNumber: o[1],
+ columnNumber: o[2],
+ source: t
+ });
+ }, this);
+ }
+ };
+ }) ? r.apply(t, o) : r) || (e.exports = i);
+ }();
+ }, function (e, t, n) {
+ "use strict";
+
+ var r = Object.prototype.hasOwnProperty,
+ o = Object.prototype.propertyIsEnumerable;
+
+ e.exports = Object.assign || function (e, t) {
+ for (var n, i, a = function (e) {
+ if (null == e) throw new TypeError("Object.assign cannot be called with null or undefined");
+ return Object(e);
+ }(e), s = 1; s < arguments.length; s++) {
+ for (var u in n = Object(arguments[s])) {
+ r.call(n, u) && (a[u] = n[u]);
+ }
+
+ if (Object.getOwnPropertySymbols) {
+ i = Object.getOwnPropertySymbols(n);
+
+ for (var c = 0; c < i.length; c++) {
+ o.call(n, i[c]) && (a[i[c]] = n[i[c]]);
+ }
+ }
+ }
+
+ return a;
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ function r(e, t, n) {
+ return t in e ? Object.defineProperty(e, t, {
+ value: n,
+ enumerable: !0,
+ configurable: !0,
+ writable: !0
+ }) : e[t] = n, e;
+ }
+
+ function o(e, t, n, i) {
+ if (n >= t.length) return i;
+ var a = t[n],
+ s = Array.isArray(e) ? e.slice() : function (e) {
+ for (var t = 1; t < arguments.length; t++) {
+ var n = null != arguments[t] ? arguments[t] : {},
+ o = Object.keys(n);
+ "function" == typeof Object.getOwnPropertySymbols && (o = o.concat(Object.getOwnPropertySymbols(n).filter(function (e) {
+ return Object.getOwnPropertyDescriptor(n, e).enumerable;
+ }))), o.forEach(function (t) {
+ r(e, t, n[t]);
+ });
+ }
+
+ return e;
+ }({}, e);
+ return s[a] = o(e[a], t, n + 1, i), s;
+ }
+
+ e.exports = function (e, t, n) {
+ return o(e, t, 0, n);
+ };
+ }, function (e, t) {
+ function n(e) {
+ return function (e) {
+ if (Array.isArray(e)) {
+ for (var t = 0, n = new Array(e.length); t < e.length; t++) {
+ n[t] = e[t];
+ }
+
+ return n;
+ }
+ }(e) || function (e) {
+ if ((typeof Symbol === "function" ? Symbol.iterator : "@@iterator") in Object(e) || "[object Arguments]" === Object.prototype.toString.call(e)) return Array.from(e);
+ }(e) || function () {
+ throw new TypeError("Invalid attempt to spread non-iterable instance");
+ }();
+ }
+
+ var r = Object.prototype.hasOwnProperty;
+
+ e.exports = function (e, t) {
+ return t.reduce(function (e, t) {
+ if (e) {
+ if (r.call(e, t)) return e[t];
+ if ("function" == typeof e[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]) return n(e)[t];
+ }
+
+ return null;
+ }, e);
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ var r = n(14);
+ e.exports = {
+ name: r("name"),
+ type: r("type"),
+ inspected: r("inspected"),
+ meta: r("meta"),
+ proto: r("proto")
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ var r = /^(.*) \[from (.*)\]$/,
+ o = new WeakMap();
+
+ e.exports = function (e) {
+ var t,
+ n = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : "Unknown",
+ i = o.get(e);
+ if (null != i) return i;
+ "string" == typeof e.displayName && (t = e.displayName), t || (t = e.name || n);
+ var a = t.match(r);
+
+ if (a) {
+ var s = a[1],
+ u = a[2];
+ s && u && (u === s || u.startsWith(s + ".")) && (t = s);
+ }
+
+ return o.set(e, t), t;
+ };
+ }, function (e, t) {
+ var n,
+ r,
+ o = e.exports = {};
+
+ function i() {
+ throw new Error("setTimeout has not been defined");
+ }
+
+ function a() {
+ throw new Error("clearTimeout has not been defined");
+ }
+
+ function s(e) {
+ if (n === setTimeout) return setTimeout(e, 0);
+ if ((n === i || !n) && setTimeout) return n = setTimeout, setTimeout(e, 0);
+
+ try {
+ return n(e, 0);
+ } catch (t) {
+ try {
+ return n.call(null, e, 0);
+ } catch (t) {
+ return n.call(this, e, 0);
+ }
+ }
+ }
+
+ !function () {
+ try {
+ n = "function" == typeof setTimeout ? setTimeout : i;
+ } catch (e) {
+ n = i;
+ }
+
+ try {
+ r = "function" == typeof clearTimeout ? clearTimeout : a;
+ } catch (e) {
+ r = a;
+ }
+ }();
+ var u,
+ c = [],
+ l = !1,
+ f = -1;
+
+ function p() {
+ l && u && (l = !1, u.length ? c = u.concat(c) : f = -1, c.length && d());
+ }
+
+ function d() {
+ if (!l) {
+ var e = s(p);
+ l = !0;
+
+ for (var t = c.length; t;) {
+ for (u = c, c = []; ++f < t;) {
+ u && u[f].run();
+ }
+
+ f = -1, t = c.length;
+ }
+
+ u = null, l = !1, function (e) {
+ if (r === clearTimeout) return clearTimeout(e);
+ if ((r === a || !r) && clearTimeout) return r = clearTimeout, clearTimeout(e);
+
+ try {
+ r(e);
+ } catch (t) {
+ try {
+ return r.call(null, e);
+ } catch (t) {
+ return r.call(this, e);
+ }
+ }
+ }(e);
+ }
+ }
+
+ function h(e, t) {
+ this.fun = e, this.array = t;
+ }
+
+ function m() {}
+
+ o.nextTick = function (e) {
+ var t = new Array(arguments.length - 1);
+ if (arguments.length > 1) for (var n = 1; n < arguments.length; n++) {
+ t[n - 1] = arguments[n];
+ }
+ c.push(new h(e, t)), 1 !== c.length || l || s(d);
+ }, h.prototype.run = function () {
+ this.fun.apply(null, this.array);
+ }, o.title = "browser", o.browser = !0, o.env = {}, o.argv = [], o.version = "", o.versions = {}, o.on = m, o.addListener = m, o.once = m, o.off = m, o.removeListener = m, o.removeAllListeners = m, o.emit = m, o.prependListener = m, o.prependOnceListener = m, o.listeners = function (e) {
+ return [];
+ }, o.binding = function (e) {
+ throw new Error("process.binding is not supported");
+ }, o.cwd = function () {
+ return "/";
+ }, o.chdir = function (e) {
+ throw new Error("process.chdir is not supported");
+ }, o.umask = function () {
+ return 0;
+ };
+ }, function (e, t) {
+ function n(e) {
+ return (n = "function" == typeof Symbol && "symbol" == typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") ? function (e) {
+ return typeof e;
+ } : function (e) {
+ return e && "function" == typeof Symbol && e.constructor === Symbol && e !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof e;
+ })(e);
+ }
+
+ var r;
+
+ r = function () {
+ return this;
+ }();
+
+ try {
+ r = r || Function("return this")() || (0, eval)("this");
+ } catch (e) {
+ "object" === ("undefined" == typeof window ? "undefined" : n(window)) && (r = window);
+ }
+
+ e.exports = r;
+ }, function (e, t, n) {
+ "use strict";
+
+ var r = n(9),
+ o = n(13),
+ i = n(37),
+ a = n(38),
+ s = n(39),
+ u = n(48),
+ c = n(52),
+ l = n(61).default,
+ f = n(55);
+ a(window), window.document && window.__REACT_DEVTOOLS_GLOBAL_HOOK__.on("react-devtools", function (e) {
+ n(56)(e);
+ }), e.exports = {
+ connectToDevTools: function e(t) {
+ var n = t || {},
+ a = n.host,
+ p = void 0 === a ? "localhost" : a,
+ d = n.port,
+ h = void 0 === d ? 8097 : d,
+ m = n.websocket,
+ y = n.resolveRNStyle,
+ v = void 0 === y ? null : y,
+ g = n.isAppActive;
+
+ function b() {
+ setTimeout(function () {
+ return e(t);
+ }, 2e3);
+ }
+
+ if ((void 0 === g ? function () {
+ return !0;
+ } : g)()) {
+ var _ = [],
+ w = [],
+ S = "ws://" + p + ":" + h,
+ E = m || new window.WebSocket(S);
+ E.onclose = function () {
+ O || (O = !0, b(), w.forEach(function (e) {
+ return e();
+ }));
+ }, E.onerror = function () {
+ O || (O = !0, w.forEach(function (e) {
+ return e();
+ }));
+ }, E.onmessage = function (e) {
+ var t;
+
+ try {
+ u("string" == typeof e.data), t = JSON.parse(e.data);
+ } catch (t) {
+ return void console.error("failed to parse json: " + String(e.data));
+ }
+
+ _.forEach(function (e) {
+ try {
+ e(t);
+ } catch (e) {
+ throw console.log(t), e;
+ }
+ });
+ }, E.onopen = function () {
+ !function (e, t) {
+ e.onClose(function () {
+ a && a.emit("shutdown"), window.__REACT_DEVTOOLS_GLOBAL_HOOK__.emit("shutdown"), n = null, a = null, console.log("closing devtools");
+ });
+ var n = new o(e),
+ a = new r(window, {
+ rnStyle: !!t,
+ rnStyleMeasure: !!t
+ });
+ a.addBridge(n), t && c(n, a, t), f(n, a, window.__REACT_DEVTOOLS_GLOBAL_HOOK__), l(n, a);
+ var u = setTimeout(function () {
+ console.warn("react-devtools agent got no connection");
+ }, 2e4);
+ a.once("connected", function () {
+ a && (s(window.__REACT_DEVTOOLS_GLOBAL_HOOK__, a), clearTimeout(u));
+ }), i.init(a);
+ }({
+ listen: function listen(e) {
+ _.push(e);
+ },
+ onClose: function onClose(e) {
+ w.push(e);
+ },
+ send: function send(e) {
+ E.send(JSON.stringify(e));
+ }
+ }, v);
+ };
+ var O = !1;
+ } else b();
+ }
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ function r(e) {
+ return (r = "function" == typeof Symbol && "symbol" == typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") ? function (e) {
+ return typeof e;
+ } : function (e) {
+ return e && "function" == typeof Symbol && e.constructor === Symbol && e !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof e;
+ })(e);
+ }
+
+ function o(e, t) {
+ for (var n = 0; n < t.length; n++) {
+ var r = t[n];
+ r.enumerable = r.enumerable || !1, r.configurable = !0, "value" in r && (r.writable = !0), Object.defineProperty(e, r.key, r);
+ }
+ }
+
+ function i(e) {
+ return (i = Object.setPrototypeOf ? Object.getPrototypeOf : function (e) {
+ return e.__proto__ || Object.getPrototypeOf(e);
+ })(e);
+ }
+
+ function a(e, t) {
+ return (a = Object.setPrototypeOf || function (e, t) {
+ return e.__proto__ = t, e;
+ })(e, t);
+ }
+
+ function s(e) {
+ if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+ return e;
+ }
+
+ var u = n(10).EventEmitter,
+ c = n(1),
+ l = n(11).default,
+ f = n(12),
+ p = n(3),
+ d = function (e) {
+ function t(e, n) {
+ var o, a, u, l;
+ !function (e, t) {
+ if (!(e instanceof t)) throw new TypeError("Cannot call a class as a function");
+ }(this, t), a = this, u = i(t).call(this), (o = !u || "object" !== r(u) && "function" != typeof u ? s(a) : u).global = e, o.internalInstancesById = new Map(), o.idsByInternalInstances = new WeakMap(), o.renderers = new Map(), o.elementData = new Map(), o.roots = new Set(), o.reactInternals = {}, o.on("selected", function (e) {
+ var t = o.elementData.get(e);
+ t && t.publicInstance && o.global.$r === l && (o.global.$r = t.publicInstance, l = t.publicInstance);
+ }), o._prevSelected = null, o._scrollUpdate = !1;
+ var f = window.document && "function" == typeof window.document.createElement;
+ return o.capabilities = c({
+ scroll: f && "function" == typeof window.document.body.scrollIntoView,
+ dom: f,
+ editTextContent: !1
+ }, n), f && (o._updateScroll = o._updateScroll.bind(s(s(o))), window.addEventListener("scroll", o._onScroll.bind(s(s(o))), !0), window.addEventListener("click", o._onClick.bind(s(s(o))), !0), window.addEventListener("mouseover", o._onMouseOver.bind(s(s(o))), !0), window.addEventListener("resize", o._onResize.bind(s(s(o))), !0)), o;
+ }
+
+ var n, d, h;
+ return function (e, t) {
+ if ("function" != typeof t && null !== t) throw new TypeError("Super expression must either be null or a function");
+ e.prototype = Object.create(t && t.prototype, {
+ constructor: {
+ value: e,
+ writable: !0,
+ configurable: !0
+ }
+ }), t && a(e, t);
+ }(t, u), n = t, (d = [{
+ key: "sub",
+ value: function value(e, t) {
+ var n = this;
+ return this.on(e, t), function () {
+ n.removeListener(e, t);
+ };
+ }
+ }, {
+ key: "setReactInternals",
+ value: function value(e, t) {
+ this.reactInternals[e] = t;
+ }
+ }, {
+ key: "addBridge",
+ value: function value(e) {
+ var t = this;
+ e.on("requestCapabilities", function () {
+ e.send("capabilities", t.capabilities), t.emit("connected");
+ }), e.on("setState", this._setState.bind(this)), e.on("setProps", this._setProps.bind(this)), e.on("setContext", this._setContext.bind(this)), e.on("makeGlobal", this._makeGlobal.bind(this)), e.on("highlight", function (e) {
+ return t.highlight(e);
+ }), e.on("highlightMany", function (e) {
+ return t.highlightMany(e);
+ }), e.on("hideHighlight", function () {
+ return t.emit("hideHighlight");
+ }), e.on("startInspecting", function () {
+ return t.emit("startInspecting");
+ }), e.on("stopInspecting", function () {
+ return t.emit("stopInspecting");
+ }), e.on("selected", function (e) {
+ return t.emit("selected", e);
+ }), e.on("isRecording", function (e) {
+ return t.emit("isRecording", e);
+ }), e.on("setInspectEnabled", function (e) {
+ t._inspectEnabled = e, t.emit("stopInspecting");
+ }), e.on("shutdown", function () {
+ return t.emit("shutdown");
+ }), e.on("changeTextContent", function (e) {
+ var n = e.id,
+ r = e.text,
+ o = t.getNodeForID(n);
+ o && (o.textContent = r);
+ }), e.on("putSelectedNode", function (e) {
+ window.__REACT_DEVTOOLS_GLOBAL_HOOK__.$node = t.getNodeForID(e);
+ }), e.on("putSelectedInstance", function (e) {
+ var n = t.elementData.get(e);
+ window.__REACT_DEVTOOLS_GLOBAL_HOOK__.$type = n ? n.type : null, n && n.publicInstance ? window.__REACT_DEVTOOLS_GLOBAL_HOOK__.$inst = n.publicInstance : window.__REACT_DEVTOOLS_GLOBAL_HOOK__.$inst = null;
+ }), e.on("checkSelection", function () {
+ var e = window.__REACT_DEVTOOLS_GLOBAL_HOOK__.$0;
+ e !== t._prevSelected && (t._prevSelected = e, e !== window.__REACT_DEVTOOLS_GLOBAL_HOOK__.$node && t.selectFromDOMNode(e, !0));
+ }), e.on("scrollToNode", function (e) {
+ return t.scrollToNode(e);
+ }), e.on("traceupdatesstatechange", function (e) {
+ return t.emit("traceupdatesstatechange", e);
+ }), e.on("colorizerchange", function (e) {
+ return t.emit("colorizerchange", e);
+ }), this.on("root", function (t) {
+ return e.send("root", t);
+ }), this.on("mount", function (t) {
+ return e.send("mount", t);
+ }), this.on("update", function (t) {
+ return e.send("update", t);
+ }), this.on("updateProfileTimes", function (t) {
+ return e.send("updateProfileTimes", t);
+ }), this.on("unmount", function (t) {
+ e.send("unmount", t), e.forget(t);
+ }), this.on("setSelection", function (t) {
+ return e.send("select", t);
+ }), this.on("setInspectEnabled", function (t) {
+ return e.send("setInspectEnabled", t);
+ }), this.on("isRecording", function (t) {
+ return e.send("isRecording", t);
+ }), this.on("storeSnapshot", function (t) {
+ return e.send("storeSnapshot", t);
+ }), this.on("clearSnapshots", function () {
+ return e.send("clearSnapshots");
+ });
+ }
+ }, {
+ key: "scrollToNode",
+ value: function value(e) {
+ var t = this.getNodeForID(e);
+
+ if (t) {
+ var n = t.nodeType === Node.ELEMENT_NODE ? t : t.parentElement;
+ n ? ("function" == typeof n.scrollIntoViewIfNeeded ? n.scrollIntoViewIfNeeded() : "function" == typeof n.scrollIntoView && n.scrollIntoView(), this.highlight(e)) : console.warn("unable to get the domElement for scrolling");
+ } else console.warn("unable to get the node for scrolling");
+ }
+ }, {
+ key: "highlight",
+ value: function value(e) {
+ var t = this.elementData.get(e),
+ n = this.getNodeForID(e);
+ t && n && this.emit("highlight", {
+ node: n,
+ name: t.name,
+ props: t.props
+ });
+ }
+ }, {
+ key: "highlightMany",
+ value: function value(e) {
+ var t = this,
+ n = [];
+ e.forEach(function (e) {
+ var r = t.getNodeForID(e);
+ r && n.push(r);
+ }), n.length && this.emit("highlightMany", n);
+ }
+ }, {
+ key: "getNodeForID",
+ value: function value(e) {
+ var t = this.internalInstancesById.get(e);
+ if (!t) return null;
+ var n = this.renderers.get(e);
+ return n && this.reactInternals[n].getNativeFromReactElement ? this.reactInternals[n].getNativeFromReactElement(t) : null;
+ }
+ }, {
+ key: "selectFromDOMNode",
+ value: function value(e, t) {
+ var n = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : 0,
+ r = this.getIDForNode(e);
+ r && this.emit("setSelection", {
+ id: r,
+ quiet: t,
+ offsetFromLeaf: n
+ });
+ }
+ }, {
+ key: "selectFromReactInstance",
+ value: function value(e, t) {
+ var n = this.getId(e);
+ n ? this.emit("setSelection", {
+ id: n,
+ quiet: t
+ }) : console.log("no instance id", e);
+ }
+ }, {
+ key: "getIDForNode",
+ value: function value(e) {
+ if (!this.reactInternals) return null;
+ var t;
+
+ for (var n in this.reactInternals) {
+ try {
+ t = this.reactInternals[n].getReactElementFromNative(e);
+ } catch (e) {}
+
+ if (t) return this.getId(t);
+ }
+
+ return null;
+ }
+ }, {
+ key: "_setProps",
+ value: function value(e) {
+ var t = e.id,
+ n = e.path,
+ r = e.value,
+ o = this.elementData.get(t);
+ o && o.updater && "function" == typeof o.updater.setInProps ? o.updater.setInProps(n, r) : console.warn("trying to set props on a component that doesn't support it");
+ }
+ }, {
+ key: "_setState",
+ value: function value(e) {
+ var t = e.id,
+ n = e.path,
+ r = e.value,
+ o = this.elementData.get(t);
+ o && o.updater && "function" == typeof o.updater.setInState ? o.updater.setInState(n, r) : console.warn("trying to set state on a component that doesn't support it");
+ }
+ }, {
+ key: "_setContext",
+ value: function value(e) {
+ var t = e.id,
+ n = e.path,
+ r = e.value,
+ o = this.elementData.get(t);
+ o && o.updater && "function" == typeof o.updater.setInContext ? o.updater.setInContext(n, r) : console.warn("trying to set context on a component that doesn't support it");
+ }
+ }, {
+ key: "_makeGlobal",
+ value: function value(e) {
+ var t,
+ n = e.id,
+ r = e.path,
+ o = this.elementData.get(n);
+ o && (t = "instance" === r ? o.publicInstance : p(o, r), this.global.$tmp = t, console.log("$tmp =", t));
+ }
+ }, {
+ key: "getId",
+ value: function value(e) {
+ return "object" === r(e) && e ? (this.idsByInternalInstances.has(e) || (this.idsByInternalInstances.set(e, f()), this.internalInstancesById.set(l(this.idsByInternalInstances.get(e)), e)), l(this.idsByInternalInstances.get(e))) : e;
+ }
+ }, {
+ key: "addRoot",
+ value: function value(e, t) {
+ var n = this.getId(t);
+ this.roots.add(n), this.emit("root", n);
+ }
+ }, {
+ key: "rootCommitted",
+ value: function value(e, t, n) {
+ var r = this.getId(t);
+ this.emit("rootCommitted", r, t, n);
+ }
+ }, {
+ key: "onMounted",
+ value: function value(e, t, n) {
+ var r = this,
+ o = this.getId(t);
+ this.renderers.set(o, e), this.elementData.set(o, n);
+ var i = c({}, n);
+ i.children && i.children.map && (i.children = i.children.map(function (e) {
+ return r.getId(e);
+ })), i.id = o, i.canUpdate = i.updater && i.updater.canUpdate, delete i.type, delete i.updater, this.emit("mount", i);
+ }
+ }, {
+ key: "onUpdated",
+ value: function value(e, t) {
+ var n = this,
+ r = this.getId(e);
+ this.elementData.set(r, t);
+ var o = c({}, t);
+ o.children && o.children.map && (o.children = o.children.map(function (e) {
+ return n.getId(e);
+ })), o.id = r, o.canUpdate = o.updater && o.updater.canUpdate, delete o.type, delete o.updater, this.emit("update", o);
+ }
+ }, {
+ key: "onUpdatedProfileTimes",
+ value: function value(e, t) {
+ var n = this,
+ r = this.getId(e);
+ this.elementData.set(r, t);
+ var o = c({}, t);
+ o.children && o.children.map && (o.children = o.children.map(function (e) {
+ return n.getId(e);
+ })), o.id = r, o.canUpdate = o.updater && o.updater.canUpdate, delete o.type, delete o.updater, this.emit("updateProfileTimes", o);
+ }
+ }, {
+ key: "onUnmounted",
+ value: function value(e) {
+ var t = this.getId(e);
+ this.elementData.delete(t), this.roots.has(t) && (this.roots.delete(t), this.emit("rootUnmounted", t)), this.renderers.delete(t), this.emit("unmount", t), this.idsByInternalInstances.delete(e);
+ }
+ }, {
+ key: "_onScroll",
+ value: function value() {
+ this._scrollUpdate || (this._scrollUpdate = !0, window.requestAnimationFrame(this._updateScroll));
+ }
+ }, {
+ key: "_updateScroll",
+ value: function value() {
+ this.emit("refreshMultiOverlay"), this.emit("stopInspecting"), this._scrollUpdate = !1;
+ }
+ }, {
+ key: "_onClick",
+ value: function value(e) {
+ if (this._inspectEnabled) {
+ var t = this.getIDForNode(e.target);
+ t && (e.stopPropagation(), e.preventDefault(), this.emit("setSelection", {
+ id: t
+ }), this.emit("setInspectEnabled", !1));
+ }
+ }
+ }, {
+ key: "_onMouseOver",
+ value: function value(e) {
+ if (this._inspectEnabled) {
+ var t = this.getIDForNode(e.target);
+ if (!t) return;
+ this.highlight(t);
+ }
+ }
+ }, {
+ key: "_onResize",
+ value: function value(e) {
+ this.emit("stopInspecting");
+ }
+ }]) && o(n.prototype, d), h && o(n, h), t;
+ }();
+
+ e.exports = d;
+ }, function (e, t) {
+ function n(e) {
+ return (n = "function" == typeof Symbol && "symbol" == typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") ? function (e) {
+ return typeof e;
+ } : function (e) {
+ return e && "function" == typeof Symbol && e.constructor === Symbol && e !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof e;
+ })(e);
+ }
+
+ function r() {
+ this._events = this._events || {}, this._maxListeners = this._maxListeners || void 0;
+ }
+
+ function o(e) {
+ return "function" == typeof e;
+ }
+
+ function i(e) {
+ return "object" === n(e) && null !== e;
+ }
+
+ function a(e) {
+ return void 0 === e;
+ }
+
+ e.exports = r, r.EventEmitter = r, r.prototype._events = void 0, r.prototype._maxListeners = void 0, r.defaultMaxListeners = 10, r.prototype.setMaxListeners = function (e) {
+ if ("number" != typeof e || e < 0 || isNaN(e)) throw TypeError("n must be a positive number");
+ return this._maxListeners = e, this;
+ }, r.prototype.emit = function (e) {
+ var t, n, r, s, u, c;
+
+ if (this._events || (this._events = {}), "error" === e && (!this._events.error || i(this._events.error) && !this._events.error.length)) {
+ if ((t = arguments[1]) instanceof Error) throw t;
+ var l = new Error('Uncaught, unspecified "error" event. (' + t + ")");
+ throw l.context = t, l;
+ }
+
+ if (a(n = this._events[e])) return !1;
+ if (o(n)) switch (arguments.length) {
+ case 1:
+ n.call(this);
+ break;
+
+ case 2:
+ n.call(this, arguments[1]);
+ break;
+
+ case 3:
+ n.call(this, arguments[1], arguments[2]);
+ break;
+
+ default:
+ s = Array.prototype.slice.call(arguments, 1), n.apply(this, s);
+ } else if (i(n)) for (s = Array.prototype.slice.call(arguments, 1), r = (c = n.slice()).length, u = 0; u < r; u++) {
+ c[u].apply(this, s);
+ }
+ return !0;
+ }, r.prototype.addListener = function (e, t) {
+ var n;
+ if (!o(t)) throw TypeError("listener must be a function");
+ return this._events || (this._events = {}), this._events.newListener && this.emit("newListener", e, o(t.listener) ? t.listener : t), this._events[e] ? i(this._events[e]) ? this._events[e].push(t) : this._events[e] = [this._events[e], t] : this._events[e] = t, i(this._events[e]) && !this._events[e].warned && (n = a(this._maxListeners) ? r.defaultMaxListeners : this._maxListeners) && n > 0 && this._events[e].length > n && (this._events[e].warned = !0, console.error("(node) warning: possible EventEmitter memory leak detected. %d listeners added. Use emitter.setMaxListeners() to increase limit.", this._events[e].length), "function" == typeof console.trace && console.trace()), this;
+ }, r.prototype.on = r.prototype.addListener, r.prototype.once = function (e, t) {
+ if (!o(t)) throw TypeError("listener must be a function");
+ var n = !1;
+
+ function r() {
+ this.removeListener(e, r), n || (n = !0, t.apply(this, arguments));
+ }
+
+ return r.listener = t, this.on(e, r), this;
+ }, r.prototype.removeListener = function (e, t) {
+ var n, r, a, s;
+ if (!o(t)) throw TypeError("listener must be a function");
+ if (!this._events || !this._events[e]) return this;
+ if (a = (n = this._events[e]).length, r = -1, n === t || o(n.listener) && n.listener === t) delete this._events[e], this._events.removeListener && this.emit("removeListener", e, t);else if (i(n)) {
+ for (s = a; s-- > 0;) {
+ if (n[s] === t || n[s].listener && n[s].listener === t) {
+ r = s;
+ break;
+ }
+ }
+
+ if (r < 0) return this;
+ 1 === n.length ? (n.length = 0, delete this._events[e]) : n.splice(r, 1), this._events.removeListener && this.emit("removeListener", e, t);
+ }
+ return this;
+ }, r.prototype.removeAllListeners = function (e) {
+ var t, n;
+ if (!this._events) return this;
+ if (!this._events.removeListener) return 0 === arguments.length ? this._events = {} : this._events[e] && delete this._events[e], this;
+
+ if (0 === arguments.length) {
+ for (t in this._events) {
+ "removeListener" !== t && this.removeAllListeners(t);
+ }
+
+ return this.removeAllListeners("removeListener"), this._events = {}, this;
+ }
+
+ if (o(n = this._events[e])) this.removeListener(e, n);else if (n) for (; n.length;) {
+ this.removeListener(e, n[n.length - 1]);
+ }
+ return delete this._events[e], this;
+ }, r.prototype.listeners = function (e) {
+ return this._events && this._events[e] ? o(this._events[e]) ? [this._events[e]] : this._events[e].slice() : [];
+ }, r.prototype.listenerCount = function (e) {
+ if (this._events) {
+ var t = this._events[e];
+ if (o(t)) return 1;
+ if (t) return t.length;
+ }
+
+ return 0;
+ }, r.listenerCount = function (e, t) {
+ return e.listenerCount(t);
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ Object.defineProperty(t, "__esModule", {
+ value: !0
+ }), t.default = function (e) {
+ if (null != e) return e;
+ throw new Error("Got unexpected null or undefined");
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ e.exports = function () {
+ return "g" + Math.random().toString(16).substr(2);
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ function r(e) {
+ return function (e) {
+ if (Array.isArray(e)) {
+ for (var t = 0, n = new Array(e.length); t < e.length; t++) {
+ n[t] = e[t];
+ }
+
+ return n;
+ }
+ }(e) || function (e) {
+ if ((typeof Symbol === "function" ? Symbol.iterator : "@@iterator") in Object(e) || "[object Arguments]" === Object.prototype.toString.call(e)) return Array.from(e);
+ }(e) || function () {
+ throw new TypeError("Invalid attempt to spread non-iterable instance");
+ }();
+ }
+
+ function o(e, t, n) {
+ return t in e ? Object.defineProperty(e, t, {
+ value: n,
+ enumerable: !0,
+ configurable: !0,
+ writable: !0
+ }) : e[t] = n, e;
+ }
+
+ function i(e, t) {
+ for (var n = 0; n < t.length; n++) {
+ var r = t[n];
+ r.enumerable = r.enumerable || !1, r.configurable = !0, "value" in r && (r.writable = !0), Object.defineProperty(e, r.key, r);
+ }
+ }
+
+ var a = n(4),
+ s = n(32),
+ u = n(33),
+ c = n(3),
+ l = n(34);
+
+ function f(e, t) {
+ return -1 === String(window[e]).indexOf("[native code]") ? t : window[e];
+ }
+
+ var p = 5,
+ d = f("cancelIdleCallback", clearTimeout),
+ h = f("requestIdleCallback", function (e, t) {
+ var n = 3e3 * p;
+ return n > 500 && (n = 500), setTimeout(function () {
+ var t = l();
+ e({
+ didTimeout: !1,
+ timeRemaining: function timeRemaining() {
+ return 1 / 0;
+ }
+ });
+ var n = l();
+ p = (n - t) / 1e3;
+ }, n);
+ }),
+ m = function () {
+ function e(t) {
+ !function (e, t) {
+ if (!(e instanceof t)) throw new TypeError("Cannot call a class as a function");
+ }(this, e), this._cbs = new Map(), this._inspectables = new Map(), this._cid = 0, this._listeners = {}, this._buffer = [], this._flushHandle = null, this._callers = {}, this._paused = !1, this._wall = t, t.listen(this._handleMessage.bind(this));
+ }
+
+ var t, n, l;
+ return t = e, (n = [{
+ key: "inspect",
+ value: function value(e, t, n) {
+ var r = this._cid++;
+ this._cbs.set(r, function (e, t, r, o) {
+ t.length && s(e, t), r && o.length && s(r, o), r && (e[a.proto] = r), n(e);
+ }), this._wall.send({
+ type: "inspect",
+ callback: r,
+ path: t,
+ id: e
+ });
+ }
+ }, {
+ key: "call",
+ value: function value(e, t, n) {
+ var r = this._cid++;
+ this._cbs.set(r, n), this._wall.send({
+ type: "call",
+ callback: r,
+ args: t,
+ name: e
+ });
+ }
+ }, {
+ key: "onCall",
+ value: function value(e, t) {
+ if (this._callers[e]) throw new Error("only one call handler per call name allowed");
+ this._callers[e] = t;
+ }
+ }, {
+ key: "pause",
+ value: function value() {
+ this._wall.send({
+ type: "pause"
+ });
+ }
+ }, {
+ key: "resume",
+ value: function value() {
+ this._wall.send({
+ type: "resume"
+ });
+ }
+ }, {
+ key: "setInspectable",
+ value: function value(e, t) {
+ var n = this._inspectables.get(e);
+
+ n ? this._inspectables.set(e, function (e) {
+ for (var t = 1; t < arguments.length; t++) {
+ var n = null != arguments[t] ? arguments[t] : {},
+ r = Object.keys(n);
+ "function" == typeof Object.getOwnPropertySymbols && (r = r.concat(Object.getOwnPropertySymbols(n).filter(function (e) {
+ return Object.getOwnPropertyDescriptor(n, e).enumerable;
+ }))), r.forEach(function (t) {
+ o(e, t, n[t]);
+ });
+ }
+
+ return e;
+ }({}, n, t)) : this._inspectables.set(e, t);
+ }
+ }, {
+ key: "send",
+ value: function value(e, t) {
+ this._buffer.push({
+ evt: e,
+ data: t
+ }), this.scheduleFlush();
+ }
+ }, {
+ key: "scheduleFlush",
+ value: function value() {
+ if (!this._flushHandle && this._buffer.length) {
+ var e = this._paused ? 5e3 : 500;
+ this._flushHandle = h(this.flushBufferWhileIdle.bind(this), {
+ timeout: e
+ });
+ }
+ }
+ }, {
+ key: "cancelFlush",
+ value: function value() {
+ this._flushHandle && (d(this._flushHandle), this._flushHandle = null);
+ }
+ }, {
+ key: "flushBufferWhileIdle",
+ value: function value(e) {
+ this._flushHandle = null;
+
+ for (var t = this._paused ? 20 : 10, n = Math.round(this._buffer.length / t), r = this._paused ? 50 : 100; this._buffer.length && (e.timeRemaining() > 0 || e.didTimeout);) {
+ var o = Math.min(this._buffer.length, Math.max(r, n)),
+ i = this._buffer.splice(0, o);
+
+ this.flushBufferSlice(i);
+ }
+
+ this._buffer.length && this.scheduleFlush();
+ }
+ }, {
+ key: "flushBufferSlice",
+ value: function value(e) {
+ var t = this,
+ n = e.map(function (e) {
+ var n = e.evt,
+ r = e.data,
+ o = [],
+ i = u(r, o);
+ return o.length && t.setInspectable(r.id, r), {
+ type: "event",
+ evt: n,
+ data: i,
+ cleaned: o
+ };
+ });
+
+ this._wall.send({
+ type: "many-events",
+ events: n
+ });
+ }
+ }, {
+ key: "forget",
+ value: function value(e) {
+ this._inspectables.delete(e);
+ }
+ }, {
+ key: "on",
+ value: function value(e, t) {
+ this._listeners[e] ? this._listeners[e].push(t) : this._listeners[e] = [t];
+ }
+ }, {
+ key: "off",
+ value: function value(e, t) {
+ if (this._listeners[e]) {
+ var n = this._listeners[e].indexOf(t);
+
+ -1 !== n && this._listeners[e].splice(n, 1);
+ }
+ }
+ }, {
+ key: "once",
+ value: function value(e, t) {
+ var n = this;
+ this.on(e, function r() {
+ t.apply(this, arguments), n.off(e, r);
+ });
+ }
+ }, {
+ key: "_handleMessage",
+ value: function value(e) {
+ var t = this;
+ if ("resume" === e.type) return this._paused = !1, void this.scheduleFlush();
+ if ("pause" === e.type) return this._paused = !0, void this.cancelFlush();
+ if ("callback" !== e.type) {
+ if ("call" !== e.type) {
+ if ("inspect" !== e.type) {
+ if ("event" === e.type) {
+ e.cleaned && s(e.data, e.cleaned);
+ var n = this._listeners[e.evt],
+ o = e.data;
+ n && n.forEach(function (e) {
+ return e(o);
+ });
+ }
+
+ "many-events" === e.type && e.events.forEach(function (e) {
+ e.cleaned && s(e.data, e.cleaned);
+ var n = t._listeners[e.evt];
+ n && n.forEach(function (t) {
+ return t(e.data);
+ });
+ });
+ } else this._inspectResponse(e.id, e.path, e.callback);
+ } else this._handleCall(e.name, e.args, e.callback);
+ } else {
+ var i = this._cbs.get(e.id);
+
+ i && (i.apply(void 0, r(e.args)), this._cbs.delete(e.id));
+ }
+ }
+ }, {
+ key: "_handleCall",
+ value: function value(e, t, n) {
+ if (this._callers[e]) {
+ var r;
+ t = Array.isArray(t) ? t : [t];
+
+ try {
+ r = this._callers[e].apply(null, t);
+ } catch (e) {
+ return void console.error("Failed to call", e);
+ }
+
+ this._wall.send({
+ type: "callback",
+ id: n,
+ args: [r]
+ });
+ } else console.warn('unknown call: "' + e + '"');
+ }
+ }, {
+ key: "_inspectResponse",
+ value: function value(e, t, n) {
+ var r = this._inspectables.get(e),
+ o = {},
+ i = [],
+ a = null,
+ s = [];
+
+ if (r) {
+ var l = c(r, t),
+ f = !1,
+ p = "function" == typeof l;
+
+ if (l && "function" == typeof l[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]) {
+ var d = Object.create({}),
+ h = 0,
+ m = !0,
+ y = !1,
+ v = void 0;
+
+ try {
+ for (var g, b = l[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"](); !(m = (g = b.next()).done); m = !0) {
+ var _ = g.value;
+ if (h > 100) break;
+ d[h] = _, h++;
+ }
+ } catch (e) {
+ y = !0, v = e;
+ } finally {
+ try {
+ m || null == b.return || b.return();
+ } finally {
+ if (y) throw v;
+ }
+ }
+
+ l = d;
+ }
+
+ if (Object.getOwnPropertyNames(l).forEach(function (e) {
+ "__proto__" === e && (f = !0), (!p || "arguments" !== e && "callee" !== e && "caller" !== e) && (o[e] = u(l[e], i, [e]));
+ }), !f && l.__proto__ && "Object" !== l.constructor.name) {
+ var w = {},
+ S = "function" == typeof l.__proto__;
+ Object.getOwnPropertyNames(l.__proto__).forEach(function (e) {
+ (!S || "arguments" !== e && "callee" !== e && "caller" !== e) && (w[e] = u(l.__proto__[e], s, [e]));
+ }), a = w;
+ }
+ }
+
+ this._wall.send({
+ type: "callback",
+ id: n,
+ args: [o, i, a, s]
+ });
+ }
+ }]) && i(t.prototype, n), l && i(t, l), e;
+ }();
+
+ e.exports = m;
+ }, function (e, t, n) {
+ "use strict";
+
+ e.exports = n(15)() ? Symbol : n(16);
+ }, function (e, t, n) {
+ "use strict";
+
+ function r(e) {
+ return (r = "function" == typeof Symbol && "symbol" == typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") ? function (e) {
+ return typeof e;
+ } : function (e) {
+ return e && "function" == typeof Symbol && e.constructor === Symbol && e !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof e;
+ })(e);
+ }
+
+ e.exports = function () {
+ var e;
+ if ("function" != typeof Symbol) return !1;
+ e = Symbol("test symbol");
+
+ try {
+ String(e);
+ } catch (e) {
+ return !1;
+ }
+
+ return "symbol" === r(typeof Symbol === "function" ? Symbol.iterator : "@@iterator") || "object" === r(typeof Symbol === "function" ? Symbol.isConcatSpreadable : "@@isConcatSpreadable") && "object" === r(typeof Symbol === "function" ? Symbol.iterator : "@@iterator") && "object" === r(typeof Symbol === "function" ? Symbol.toPrimitive : "@@toPrimitive") && "object" === r(typeof Symbol === "function" ? Symbol.toStringTag : "@@toStringTag") && "object" === r(typeof Symbol === "function" ? Symbol.unscopables : "@@unscopables");
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ var r,
+ o,
+ _i,
+ a = n(17),
+ s = n(30),
+ u = Object.create,
+ c = Object.defineProperties,
+ l = Object.defineProperty,
+ f = Object.prototype,
+ p = u(null);
+
+ "function" == typeof Symbol && (r = Symbol);
+ var d,
+ h = (d = u(null), function (e) {
+ for (var t, n, r = 0; d[e + (r || "")];) {
+ ++r;
+ }
+
+ return d[e += r || ""] = !0, l(f, t = "@@" + e, a.gs(null, function (e) {
+ n || (n = !0, l(this, t, a(e)), n = !1);
+ })), t;
+ });
+ _i = function i(e) {
+ if (this instanceof _i) throw new TypeError("TypeError: Symbol is not a constructor");
+ return o(e);
+ }, e.exports = o = function e(t) {
+ var n;
+ if (this instanceof e) throw new TypeError("TypeError: Symbol is not a constructor");
+ return n = u(_i.prototype), t = void 0 === t ? "" : String(t), c(n, {
+ __description__: a("", t),
+ __name__: a("", h(t))
+ });
+ }, c(o, {
+ for: a(function (e) {
+ return p[e] ? p[e] : p[e] = o(String(e));
+ }),
+ keyFor: a(function (e) {
+ var t;
+
+ for (t in s(e), p) {
+ if (p[t] === e) return t;
+ }
+ }),
+ hasInstance: a("", r && r.hasInstance || o("hasInstance")),
+ isConcatSpreadable: a("", r && r.isConcatSpreadable || o("isConcatSpreadable")),
+ iterator: a("", r && r.iterator || o("iterator")),
+ match: a("", r && r.match || o("match")),
+ replace: a("", r && r.replace || o("replace")),
+ search: a("", r && r.search || o("search")),
+ species: a("", r && r.species || o("species")),
+ split: a("", r && r.split || o("split")),
+ toPrimitive: a("", r && r.toPrimitive || o("toPrimitive")),
+ toStringTag: a("", r && r.toStringTag || o("toStringTag")),
+ unscopables: a("", r && r.unscopables || o("unscopables"))
+ }), c(_i.prototype, {
+ constructor: a(o),
+ toString: a("", function () {
+ return this.__name__;
+ })
+ }), c(o.prototype, {
+ toString: a(function () {
+ return "Symbol (" + s(this).__description__ + ")";
+ }),
+ valueOf: a(function () {
+ return s(this);
+ })
+ }), l(o.prototype, o.toPrimitive, a("", function () {
+ return s(this);
+ })), l(o.prototype, o.toStringTag, a("c", "Symbol")), l(_i.prototype, o.toStringTag, a("c", o.prototype[o.toStringTag])), l(_i.prototype, o.toPrimitive, a("c", o.prototype[o.toPrimitive]));
+ }, function (e, t, n) {
+ "use strict";
+
+ var r = n(18),
+ o = n(25),
+ i = n(26),
+ a = n(27);
+
+ (e.exports = function (e, t) {
+ var n, i, s, u, c;
+ return arguments.length < 2 || "string" != typeof e ? (u = t, t = e, e = null) : u = arguments[2], null == e ? (n = s = !0, i = !1) : (n = a.call(e, "c"), i = a.call(e, "e"), s = a.call(e, "w")), c = {
+ value: t,
+ configurable: n,
+ enumerable: i,
+ writable: s
+ }, u ? r(o(u), c) : c;
+ }).gs = function (e, t, n) {
+ var s, u, c, l;
+ return "string" != typeof e ? (c = n, n = t, t = e, e = null) : c = arguments[3], null == t ? t = void 0 : i(t) ? null == n ? n = void 0 : i(n) || (c = n, n = void 0) : (c = t, t = n = void 0), null == e ? (s = !0, u = !1) : (s = a.call(e, "c"), u = a.call(e, "e")), l = {
+ get: t,
+ set: n,
+ configurable: s,
+ enumerable: u
+ }, c ? r(o(c), l) : l;
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ e.exports = n(19)() ? Object.assign : n(20);
+ }, function (e, t, n) {
+ "use strict";
+
+ e.exports = function () {
+ var e,
+ t = Object.assign;
+ return "function" == typeof t && (t(e = {
+ foo: "raz"
+ }, {
+ bar: "dwa"
+ }, {
+ trzy: "trzy"
+ }), e.foo + e.bar + e.trzy === "razdwatrzy");
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ var r = n(21),
+ o = n(24),
+ i = Math.max;
+
+ e.exports = function (e, t) {
+ var n,
+ a,
+ s,
+ u = i(arguments.length, 2);
+
+ for (e = Object(o(e)), s = function s(r) {
+ try {
+ e[r] = t[r];
+ } catch (e) {
+ n || (n = e);
+ }
+ }, a = 1; a < u; ++a) {
+ t = arguments[a], r(t).forEach(s);
+ }
+
+ if (void 0 !== n) throw n;
+ return e;
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ e.exports = n(22)() ? Object.keys : n(23);
+ }, function (e, t, n) {
+ "use strict";
+
+ e.exports = function () {
+ try {
+ return Object.keys("primitive"), !0;
+ } catch (e) {
+ return !1;
+ }
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ var r = Object.keys;
+
+ e.exports = function (e) {
+ return r(null == e ? e : Object(e));
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ e.exports = function (e) {
+ if (null == e) throw new TypeError("Cannot use null or undefined");
+ return e;
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ var r = Array.prototype.forEach,
+ o = Object.create;
+
+ e.exports = function (e) {
+ var t = o(null);
+ return r.call(arguments, function (e) {
+ null != e && function (e, t) {
+ var n;
+
+ for (n in e) {
+ t[n] = e[n];
+ }
+ }(Object(e), t);
+ }), t;
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ e.exports = function (e) {
+ return "function" == typeof e;
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ e.exports = n(28)() ? String.prototype.contains : n(29);
+ }, function (e, t, n) {
+ "use strict";
+
+ var r = "razdwatrzy";
+
+ e.exports = function () {
+ return "function" == typeof r.contains && !0 === r.contains("dwa") && !1 === r.contains("foo");
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ var r = String.prototype.indexOf;
+
+ e.exports = function (e) {
+ return r.call(this, e, arguments[1]) > -1;
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ var r = n(31);
+
+ e.exports = function (e) {
+ if (!r(e)) throw new TypeError(e + " is not a symbol");
+ return e;
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ function r(e) {
+ return (r = "function" == typeof Symbol && "symbol" == typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") ? function (e) {
+ return typeof e;
+ } : function (e) {
+ return e && "function" == typeof Symbol && e.constructor === Symbol && e !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof e;
+ })(e);
+ }
+
+ e.exports = function (e) {
+ return e && ("symbol" === r(e) || "Symbol" === e["@@toStringTag"]) || !1;
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ var r = n(4);
+
+ e.exports = function (e, t) {
+ t.forEach(function (t) {
+ var n = t.pop(),
+ o = t.reduce(function (e, t) {
+ return e ? e[t] : null;
+ }, e);
+
+ if (o && o[n]) {
+ var i = {};
+ i[r.name] = o[n].name, i[r.type] = o[n].type, i[r.meta] = o[n].meta, i[r.inspected] = !1, o[n] = i;
+ }
+ });
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ function r(e) {
+ return (r = "function" == typeof Symbol && "symbol" == typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") ? function (e) {
+ return typeof e;
+ } : function (e) {
+ return e && "function" == typeof Symbol && e.constructor === Symbol && e !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof e;
+ })(e);
+ }
+
+ var o = 2;
+
+ function i(e, t, n, r) {
+ var o = {};
+ return "array" !== e && "typed_array" !== e || (o.length = t.length), "iterator" !== e && "typed_array" !== e || (o.readOnly = !0), n.push(r), {
+ type: e,
+ meta: o,
+ name: t.constructor && "Object" !== t.constructor.name ? t.constructor.name : ""
+ };
+ }
+
+ e.exports = function e(t, n) {
+ var a = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : [],
+ s = arguments.length > 3 && void 0 !== arguments[3] ? arguments[3] : 0,
+ u = function (e) {
+ if (!e) return null;
+ var t = r(e);
+
+ if ("object" === t) {
+ if (e._reactFragment) return "react_fragment";
+ if (Array.isArray(e)) return "array";
+ if (ArrayBuffer.isView(e)) return e instanceof DataView ? "data_view" : "typed_array";
+ if (e instanceof ArrayBuffer) return "array_buffer";
+ if ("function" == typeof e[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]) return "iterator";
+ if ("[object Date]" === Object.prototype.toString.call(e)) return "date";
+ }
+
+ return t;
+ }(t);
+
+ switch (u) {
+ case "function":
+ return n.push(a), {
+ name: t.name,
+ type: "function"
+ };
+
+ case "string":
+ return t.length <= 500 ? t : t.slice(0, 500) + "...";
+
+ case "symbol":
+ return n.push(a), {
+ type: "symbol",
+ name: t.toString()
+ };
+
+ case "react_fragment":
+ return "A React Fragment";
+
+ case "array_buffer":
+ case "data_view":
+ return n.push(a), {
+ type: u,
+ name: "data_view" === u ? "DataView" : "ArrayBuffer",
+ meta: {
+ length: t.byteLength,
+ uninspectable: !0
+ }
+ };
+
+ case "array":
+ return s > o ? i(u, t, n, a) : t.map(function (t, r) {
+ return e(t, n, a.concat([r]), s + 1);
+ });
+
+ case "typed_array":
+ case "iterator":
+ return i(u, t, n, a);
+
+ case "date":
+ return n.push(a), {
+ name: t.toString(),
+ type: "date",
+ meta: {
+ uninspectable: !0
+ }
+ };
+
+ case "object":
+ if (s > o || t.constructor && "function" == typeof t.constructor && "Object" !== t.constructor.name) return i(u, t, n, a);
+ var c = {};
+
+ for (var l in t) {
+ c[l] = e(t[l], n, a.concat([l]), s + 1);
+ }
+
+ return c;
+
+ default:
+ return t;
+ }
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ var r,
+ o = n(35);
+ r = o.now ? function () {
+ return o.now();
+ } : function () {
+ return Date.now();
+ }, e.exports = r;
+ }, function (e, t, n) {
+ "use strict";
+
+ var r;
+ n(36).canUseDOM && (r = window.performance || window.msPerformance || window.webkitPerformance), e.exports = r || {};
+ }, function (e, t, n) {
+ "use strict";
+
+ var r = !("undefined" == typeof window || !window.document || !window.document.createElement),
+ o = {
+ canUseDOM: r,
+ canUseWorkers: "undefined" != typeof Worker,
+ canUseEventListeners: r && !(!window.addEventListener && !window.attachEvent),
+ canUseViewport: r && !!window.screen,
+ isInWorker: !r
+ };
+ e.exports = o;
+ }, function (e, t, n) {
+ "use strict";
+
+ function r(e, t) {
+ for (var n = 0; n < t.length; n++) {
+ var r = t[n];
+ r.enumerable = r.enumerable || !1, r.configurable = !0, "value" in r && (r.writable = !0), Object.defineProperty(e, r.key, r);
+ }
+ }
+
+ function o(e, t, n) {
+ return t in e ? Object.defineProperty(e, t, {
+ value: n,
+ enumerable: !0,
+ configurable: !0,
+ writable: !0
+ }) : e[t] = n, e;
+ }
+
+ function i(e) {
+ return (i = "function" == typeof Symbol && "symbol" == typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") ? function (e) {
+ return typeof e;
+ } : function (e) {
+ return e && "function" == typeof Symbol && e.constructor === Symbol && e !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof e;
+ })(e);
+ }
+
+ var a = "object" === ("undefined" == typeof performance ? "undefined" : i(performance)) && "function" == typeof performance.now ? function () {
+ return performance.now();
+ } : function () {
+ return Date.now();
+ },
+ s = function () {
+ function e(t) {
+ var n = this;
+ !function (e, t) {
+ if (!(e instanceof t)) throw new TypeError("Cannot call a class as a function");
+ }(this, e), o(this, "_committedNodes", new Set()), o(this, "_isRecording", !1), o(this, "_maxActualDuration", 0), o(this, "_recordingStartTime", 0), o(this, "_onIsRecording", function (e) {
+ n._committedNodes = new Set(), n._isRecording = e, n._recordingStartTime = e ? a() : 0, e && n._agent.emit("clearSnapshots");
+ }), o(this, "_onMountOrUpdate", function (e) {
+ n._isRecording && void 0 !== e.actualDuration && (n._committedNodes.add(e.id), n._maxActualDuration = Math.max(n._maxActualDuration, e.actualDuration));
+ }), o(this, "_onRootCommitted", function (e, t, r) {
+ n._isRecording && (n._takeCommitSnapshotForRoot(e, r), n._committedNodes = new Set(), n._maxActualDuration = 0);
+ }), o(this, "_onUnmount", function (e) {
+ n._committedNodes.delete(e);
+ }), this._agent = t, t.on("isRecording", this._onIsRecording), t.on("mount", this._onMountOrUpdate), t.on("rootCommitted", this._onRootCommitted), t.on("unmount", this._onUnmount), t.on("update", this._onMountOrUpdate);
+ }
+
+ var t, n, i;
+ return t = e, (n = [{
+ key: "_takeCommitSnapshotForRoot",
+ value: function value(e, t) {
+ var n = this,
+ r = {
+ memoizedInteractions: (null != t.memoizedInteractions ? Array.from(t.memoizedInteractions) : []).map(function (e) {
+ return {
+ name: e.name,
+ timestamp: e.timestamp - n._recordingStartTime
+ };
+ }),
+ committedNodes: Array.from(this._committedNodes),
+ commitTime: a() - this._recordingStartTime,
+ duration: this._maxActualDuration,
+ root: e
+ };
+
+ this._agent.emit("storeSnapshot", r);
+ }
+ }]) && r(t.prototype, n), i && r(t, i), e;
+ }();
+
+ e.exports = {
+ init: function init(e) {
+ return new s(e);
+ }
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ e.exports = function (e) {
+ if (!e.__REACT_DEVTOOLS_GLOBAL_HOOK__) {
+ var t = !1,
+ n = {
+ _renderers: {},
+ helpers: {},
+ checkDCE: function checkDCE(e) {
+ try {
+ Function.prototype.toString.call(e).indexOf("^_^") > -1 && (t = !0, setTimeout(function () {
+ throw new Error("React is running in production mode, but dead code elimination has not been applied. Read how to correctly configure React for production: https://fb.me/react-perf-use-the-production-build");
+ }));
+ } catch (e) {}
+ },
+ inject: function inject(e) {
+ var r = Math.random().toString(16).slice(2);
+ n._renderers[r] = e;
+ var o = t ? "deadcode" : function (e) {
+ try {
+ if ("string" == typeof e.version) return e.bundleType > 0 ? "development" : "production";
+ var t = Function.prototype.toString;
+
+ if (e.Mount && e.Mount._renderNewRootComponent) {
+ var n = t.call(e.Mount._renderNewRootComponent);
+ return 0 !== n.indexOf("function") ? "production" : -1 !== n.indexOf("storedMeasure") ? "development" : -1 !== n.indexOf("should be a pure function") ? -1 !== n.indexOf("NODE_ENV") ? "development" : -1 !== n.indexOf("development") ? "development" : -1 !== n.indexOf("true") ? "development" : -1 !== n.indexOf("nextElement") || -1 !== n.indexOf("nextComponent") ? "unminified" : "development" : -1 !== n.indexOf("nextElement") || -1 !== n.indexOf("nextComponent") ? "unminified" : "outdated";
+ }
+ } catch (e) {}
+
+ return "production";
+ }(e);
+ return n.emit("renderer", {
+ id: r,
+ renderer: e,
+ reactBuildType: o
+ }), r;
+ },
+ _listeners: {},
+ sub: function sub(e, t) {
+ return n.on(e, t), function () {
+ return n.off(e, t);
+ };
+ },
+ on: function on(e, t) {
+ n._listeners[e] || (n._listeners[e] = []), n._listeners[e].push(t);
+ },
+ off: function off(e, t) {
+ if (n._listeners[e]) {
+ var r = n._listeners[e].indexOf(t);
+
+ -1 !== r && n._listeners[e].splice(r, 1), n._listeners[e].length || (n._listeners[e] = null);
+ }
+ },
+ emit: function emit(e, t) {
+ n._listeners[e] && n._listeners[e].map(function (e) {
+ return e(t);
+ });
+ },
+ supportsFiber: !0,
+ _fiberRoots: {},
+ getFiberRoots: function getFiberRoots(e) {
+ var t = n._fiberRoots;
+ return t[e] || (t[e] = new Set()), t[e];
+ },
+ onCommitFiberUnmount: function onCommitFiberUnmount(e, t) {
+ n.helpers[e] && n.helpers[e].handleCommitFiberUnmount(t);
+ },
+ onCommitFiberRoot: function onCommitFiberRoot(e, t) {
+ var r = n.getFiberRoots(e),
+ o = t.current,
+ i = r.has(t),
+ a = null == o.memoizedState || null == o.memoizedState.element;
+ i || a ? i && a && r.delete(t) : r.add(t), n.helpers[e] && n.helpers[e].handleCommitFiberRoot(t);
+ }
+ };
+ Object.defineProperty(e, "__REACT_DEVTOOLS_GLOBAL_HOOK__", {
+ value: n
+ });
+ }
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ var r = n(40);
+
+ e.exports = function (e, t) {
+ var n = [e.sub("renderer-attached", function (e) {
+ var n = e.id,
+ r = (e.renderer, e.helpers);
+ t.setReactInternals(n, r), r.walkTree(t.onMounted.bind(t, n), t.addRoot.bind(t, n));
+ }), e.sub("mount", function (e) {
+ var n = e.renderer,
+ r = e.internalInstance,
+ o = e.data;
+ return t.onMounted(n, r, o);
+ }), e.sub("unmount", function (e) {
+ e.renderer;
+ var n = e.internalInstance;
+ return t.onUnmounted(n);
+ }), e.sub("update", function (e) {
+ e.renderer;
+ var n = e.internalInstance,
+ r = e.data;
+ return t.onUpdated(n, r);
+ }), e.sub("root", function (e) {
+ var n = e.renderer,
+ r = e.internalInstance;
+ return t.addRoot(n, r);
+ }), e.sub("rootCommitted", function (e) {
+ var n = e.renderer,
+ r = e.internalInstance,
+ o = e.data;
+ return t.rootCommitted(n, r, o);
+ }), e.sub("updateProfileTimes", function (e) {
+ e.renderer;
+ var n = e.internalInstance,
+ r = e.data;
+ return t.onUpdatedProfileTimes(n, r);
+ })];
+ r(e) && (e.emit("react-devtools", t), e.reactDevtoolsAgent = t, t.on("shutdown", function () {
+ n.forEach(function (e) {
+ return e();
+ }), e.reactDevtoolsAgent = null;
+ }));
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ var r = n(41);
+
+ e.exports = function (e) {
+ var t = window.React && window.React.__internals;
+
+ for (var n in t && 0 === Object.keys(e._renderers).length && e.inject(t), e._renderers) {
+ e.helpers[n] = r(e, n, e._renderers[n]), e.emit("renderer-attached", {
+ id: n,
+ renderer: e._renderers[n],
+ helpers: e.helpers[n]
+ });
+ }
+
+ e.on("renderer", function (t) {
+ var n = t.id,
+ o = t.renderer;
+ e.helpers[n] = r(e, n, o), e.emit("renderer-attached", {
+ id: n,
+ renderer: o,
+ helpers: e.helpers[n]
+ });
+ });
+ return e.on("shutdown", function t() {
+ for (var n in e.helpers) {
+ e.helpers[n].cleanup();
+ }
+
+ e.off("shutdown", t);
+ }), !0;
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ var r = n(42),
+ o = n(45),
+ i = n(46);
+
+ function a(e, t, n) {
+ var i = n ? o(e) : r(e);
+ i.children && Array.isArray(i.children) && i.children.forEach(function (e) {
+ return a(e, t, n);
+ }), t(e, i);
+ }
+
+ function s(e, t, n) {
+ var r = e[t];
+ return e[t] = function (e) {
+ var t = r.apply(this, arguments);
+ return n(t), t;
+ }, r;
+ }
+
+ function u(e, t, n) {
+ var r = e[t];
+ return e[t] = function (e) {
+ var t = r.apply(this, arguments);
+ return n.apply(this, arguments), t;
+ }, r;
+ }
+
+ function c(e, t) {
+ var n = {};
+
+ for (var r in t) {
+ n[r] = u(e, r, t[r]);
+ }
+
+ return n;
+ }
+
+ function l(e, t) {
+ for (var n in t) {
+ e[n] = t[n];
+ }
+ }
+
+ e.exports = function (e, t, n) {
+ var u,
+ f,
+ p,
+ d = new Map(),
+ h = {},
+ m = !n.Reconciler;
+ return "function" == typeof n.findFiberByHostInstance ? i(e, t, n) : (n.Mount.findNodeHandle && n.Mount.nativeTagToRootNodeID ? (h.getNativeFromReactElement = function (e) {
+ return n.Mount.findNodeHandle(e);
+ }, h.getReactElementFromNative = function (e) {
+ var t = n.Mount.nativeTagToRootNodeID(e);
+ return d.get(t);
+ }) : n.ComponentTree ? (h.getNativeFromReactElement = function (e) {
+ return n.ComponentTree.getNodeFromInstance(e);
+ }, h.getReactElementFromNative = function (e) {
+ return n.ComponentTree.getClosestInstanceFromNode(e);
+ }) : n.Mount.getID && n.Mount.getNode ? (h.getNativeFromReactElement = function (e) {
+ try {
+ return n.Mount.getNode(e._rootNodeID);
+ } catch (e) {
+ return;
+ }
+ }, h.getReactElementFromNative = function (e) {
+ for (var t = n.Mount.getID(e); e && e.parentNode && !t;) {
+ e = e.parentNode, t = n.Mount.getID(e);
+ }
+
+ return d.get(t);
+ }) : console.warn("Unknown react version (does not have getID), probably an unshimmed React Native"), n.Mount._renderNewRootComponent ? p = s(n.Mount, "_renderNewRootComponent", function (n) {
+ e.emit("root", {
+ renderer: t,
+ internalInstance: n
+ });
+ }) : n.Mount.renderComponent && (f = s(n.Mount, "renderComponent", function (n) {
+ e.emit("root", {
+ renderer: t,
+ internalInstance: n._reactInternalInstance
+ });
+ })), n.Component ? (console.error("You are using a version of React with limited support in this version of the devtools.\nPlease upgrade to use at least 0.13, or you can downgrade to use the old version of the devtools:\ninstructions here https://github.com/facebook/react-devtools/tree/devtools-next#how-do-i-use-this-for-react--013"), u = c(n.Component.Mixin, {
+ mountComponent: function mountComponent() {
+ var n = this;
+ d.set(this._rootNodeID, this), setTimeout(function () {
+ e.emit("mount", {
+ internalInstance: n,
+ data: o(n),
+ renderer: t
+ });
+ }, 0);
+ },
+ updateComponent: function updateComponent() {
+ var n = this;
+ setTimeout(function () {
+ e.emit("update", {
+ internalInstance: n,
+ data: o(n),
+ renderer: t
+ });
+ }, 0);
+ },
+ unmountComponent: function unmountComponent() {
+ e.emit("unmount", {
+ internalInstance: this,
+ renderer: t
+ }), d.delete(this._rootNodeID);
+ }
+ })) : n.Reconciler && (u = c(n.Reconciler, {
+ mountComponent: function mountComponent(n, o, i, a) {
+ var s = r(n);
+ d.set(n._rootNodeID, n), e.emit("mount", {
+ internalInstance: n,
+ data: s,
+ renderer: t
+ });
+ },
+ performUpdateIfNecessary: function performUpdateIfNecessary(n, o, i, a) {
+ e.emit("update", {
+ internalInstance: n,
+ data: r(n),
+ renderer: t
+ });
+ },
+ receiveComponent: function receiveComponent(n, o, i, a) {
+ e.emit("update", {
+ internalInstance: n,
+ data: r(n),
+ renderer: t
+ });
+ },
+ unmountComponent: function unmountComponent(n) {
+ e.emit("unmount", {
+ internalInstance: n,
+ renderer: t
+ }), d.delete(n._rootNodeID);
+ }
+ })), h.walkTree = function (e, t) {
+ !function (e, t, n, r) {
+ for (var o in e) {
+ a(e[o], t, r), n(e[o]);
+ }
+ }(n.Mount._instancesByReactRootID || n.Mount._instancesByContainerID, function (t, n) {
+ d.set(t._rootNodeID, t), e(t, n);
+ }, t, m);
+ }, h.cleanup = function () {
+ u && (n.Component ? l(n.Component.Mixin, u) : l(n.Reconciler, u)), p && (n.Mount._renderNewRootComponent = p), f && (n.Mount.renderComponent = f), u = null, p = null, f = null;
+ }, h.renderer = null, h);
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ function r(e, t, n) {
+ return t in e ? Object.defineProperty(e, t, {
+ value: n,
+ enumerable: !0,
+ configurable: !0,
+ writable: !0
+ }) : e[t] = n, e;
+ }
+
+ function o(e) {
+ return (o = "function" == typeof Symbol && "symbol" == typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") ? function (e) {
+ return typeof e;
+ } : function (e) {
+ return e && "function" == typeof Symbol && e.constructor === Symbol && e !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof e;
+ })(e);
+ }
+
+ var i = n(2),
+ a = n(5),
+ s = n(43);
+
+ function u(e, t, n) {
+ var r = t.pop(),
+ o = t.reduce(function (e, t) {
+ return e ? e[t] : null;
+ }, e);
+ o && (o[r] = n);
+ }
+
+ function c(e) {
+ var t = [];
+
+ for (var n in e) {
+ t.push(e[n]);
+ }
+
+ return t;
+ }
+
+ e.exports = function (e) {
+ var t = null,
+ n = null,
+ l = null,
+ f = null,
+ p = null,
+ d = null,
+ h = null,
+ m = null,
+ y = null,
+ v = null,
+ g = null,
+ b = null,
+ _ = "Native";
+ if ("object" !== o(e)) _ = "Text", g = e + "";else if (null === e._currentElement || !1 === e._currentElement) _ = "Empty";else if (e._renderedComponent) _ = "NativeWrapper", t = [e._renderedComponent], n = e._instance.props, l = e._instance.state, (f = e._instance.context) && 0 === Object.keys(f).length && (f = null);else if (e._renderedChildren) t = c(e._renderedChildren);else if (e._currentElement && e._currentElement.props) {
+ var w = e._currentElement.props.children,
+ S = [];
+ s(w, "", function (e, t) {
+ var n = o(t);
+ "string" !== n && "number" !== n || S.push(t);
+ }), t = S.length <= 1 ? S.length ? String(S[0]) : void 0 : S;
+ }
+
+ if (!n && e._currentElement && e._currentElement.props && (n = e._currentElement.props), null != e._currentElement && (h = e._currentElement.type, e._currentElement.key && (m = String(e._currentElement.key)), v = e._currentElement._source, y = e._currentElement.ref, "string" == typeof h ? (d = h, null != e._nativeNode && (b = e._nativeNode), null != e._hostNode && (b = e._hostNode)) : "function" == typeof h ? (_ = "Composite", d = a(h), e._renderedComponent && (e._currentElement.props === e._renderedComponent._currentElement || e._currentElement.type.isReactTopLevelWrapper) && (_ = "Wrapper"), null === d && (d = "No display name")) : "string" == typeof e._stringText ? (_ = "Text", g = e._stringText) : d = a(h)), e._instance) {
+ var E = e._instance,
+ O = E.forceUpdate || E.updater && E.updater.enqueueForceUpdate && function (e) {
+ E.updater.enqueueForceUpdate(this, e, "forceUpdate");
+ };
+
+ p = {
+ canUpdate: !0,
+ setState: E.setState && E.setState.bind(E),
+ setInProps: O && function (e, t, n, o) {
+ var a = e._currentElement;
+ e._currentElement = function (e) {
+ for (var t = 1; t < arguments.length; t++) {
+ var n = null != arguments[t] ? arguments[t] : {},
+ o = Object.keys(n);
+ "function" == typeof Object.getOwnPropertySymbols && (o = o.concat(Object.getOwnPropertySymbols(n).filter(function (e) {
+ return Object.getOwnPropertyDescriptor(n, e).enumerable;
+ }))), o.forEach(function (t) {
+ r(e, t, n[t]);
+ });
+ }
+
+ return e;
+ }({}, a, {
+ props: i(a.props, n, o)
+ }), t.call(e._instance);
+ }.bind(null, e, O),
+ setInState: E.forceUpdate && function (e, t, n) {
+ u(e.state, t, n), e.forceUpdate();
+ }.bind(null, E),
+ setInContext: O && function (e, t, n, r) {
+ u(e.context, n, r), t.call(e);
+ }.bind(null, E, O)
+ }, "function" == typeof h && (b = E), E._renderedChildren && (t = c(E._renderedChildren));
+ }
+
+ return "function" == typeof e.setNativeProps && (p = {
+ setNativeProps: function setNativeProps(t) {
+ e.setNativeProps(t);
+ }
+ }), {
+ nodeType: _,
+ type: h,
+ key: m,
+ ref: y,
+ source: v,
+ name: d,
+ props: n,
+ state: l,
+ context: f,
+ children: t,
+ text: g,
+ updater: p,
+ publicInstance: b
+ };
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ function r(e) {
+ return (r = "function" == typeof Symbol && "symbol" == typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") ? function (e) {
+ return typeof e;
+ } : function (e) {
+ return e && "function" == typeof Symbol && e.constructor === Symbol && e !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof e;
+ })(e);
+ }
+
+ var o = n(44),
+ i = ".",
+ a = ":",
+ s = "@@iterator",
+ u = "function" == typeof Symbol && (typeof Symbol === "function" ? Symbol.iterator : "@@iterator"),
+ c = "function" == typeof Symbol && (typeof Symbol === "function" ? Symbol.for : "@@for") && (typeof Symbol === "function" ? Symbol.for : "@@for")("react.element") || 60103;
+
+ function l(e, t) {
+ return "object" === r(e) && null !== e && null != e.key ? (n = e.key, o = {
+ "=": "=0",
+ ":": "=2"
+ }, "$" + ("" + n).replace(/[=:]/g, function (e) {
+ return o[e];
+ })) : t.toString(36);
+ var n, o;
+ }
+
+ e.exports = function e(t, n, f, p) {
+ var d,
+ h = r(t);
+ if ("undefined" !== h && "boolean" !== h || (t = null), null === t || "string" === h || "number" === h || "object" === h && t.$$typeof === c) return f(p, t, "" === n ? i + l(t, 0) : n), 1;
+ var m = 0,
+ y = "" === n ? i : n + a;
+ if (Array.isArray(t)) for (var v = 0; v < t.length; v++) {
+ m += e(d = t[v], y + l(d, v), f, p);
+ } else {
+ var g = u && t[u] || t[s];
+ if ("function" == typeof g) for (var b, _ = g.call(t), w = 0; !(b = _.next()).done;) {
+ m += e(d = b.value, y + l(d, w++), f, p);
+ } else if ("object" === h) {
+ var S = "" + t;
+ o(!1, "The React Devtools cannot render an object as a child. (found: %s).%s", "[object Object]" === S ? "object with keys {" + Object.keys(t).join(", ") + "}" : S, " If you meant to render a collection of children, use an array instead.");
+ }
+ }
+ return m;
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ e.exports = function (e, t, n, r, o, i, a, s) {
+ if (!e) {
+ var u;
+ if (void 0 === t) u = new Error("Minified exception occurred; use the non-minified dev environment for the full error message and additional helpful warnings.");else {
+ var c = [n, r, o, i, a, s],
+ l = 0;
+ (u = new Error(t.replace(/%s/g, function () {
+ return c[l++];
+ }))).name = "Invariant Violation";
+ }
+ throw u.framesToPop = 1, u;
+ }
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ var r = n(2);
+
+ function o(e, t, n) {
+ var r = t.pop(),
+ o = t.reduce(function (e, t) {
+ return e ? e[t] : null;
+ }, e);
+ o && (o[r] = n);
+ }
+
+ e.exports = function (e) {
+ var t = null,
+ n = e.props,
+ i = e.state,
+ a = e.context,
+ s = null,
+ u = null,
+ c = null,
+ l = null,
+ f = null,
+ p = null,
+ d = null,
+ h = "Native";
+ return e._renderedComponent ? (h = "Wrapper", t = [e._renderedComponent], a && 0 === Object.keys(a).length && (a = null)) : e._renderedChildren ? (u = e.constructor.displayName, t = function (e) {
+ var t = [];
+
+ for (var n in e) {
+ t.push(e[n]);
+ }
+
+ return t;
+ }(e._renderedChildren)) : "string" == typeof n.children && (u = e.constructor.displayName, t = n.children, h = "Native"), !n && e._currentElement && e._currentElement.props && (n = e._currentElement.props), e._currentElement && (c = e._currentElement.type, e._currentElement.key && (l = String(e._currentElement.key)), f = e._currentElement.ref, "string" == typeof c ? u = c : (h = "Composite", (u = c.displayName) || (u = "No display name"))), u || (u = e.constructor.displayName || "No display name", h = "Composite"), "string" == typeof n && (h = "Text", p = n, n = null, u = null), e.forceUpdate && (s = {
+ canUpdate: !0,
+ setState: e.setState.bind(e),
+ setInProps: e.forceUpdate && function (e, t, n) {
+ e.props = r(e.props, t, n), e.forceUpdate();
+ }.bind(null, e),
+ setInState: e.forceUpdate && function (e, t, n) {
+ o(e.state, t, n), e.forceUpdate();
+ }.bind(null, e),
+ setInContext: e.forceUpdate && function (e, t, n) {
+ o(e.context, t, n), e.forceUpdate();
+ }.bind(null, e)
+ }, d = e), {
+ nodeType: h,
+ type: c,
+ key: l,
+ ref: f,
+ source: null,
+ name: u,
+ props: n,
+ state: i,
+ context: a,
+ children: t,
+ text: p,
+ updater: s,
+ publicInstance: d
+ };
+ };
+ }, function (e, t, n) {
+ "use strict";
+
+ function r(e) {
+ return (r = "function" == typeof Symbol && "symbol" == typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") ? function (e) {
+ return typeof e;
+ } : function (e) {
+ return e && "function" == typeof Symbol && e.constructor === Symbol && e !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof e;
+ })(e);
+ }
+
+ var o = n(47),
+ i = n(2),
+ a = n(5);
+
+ e.exports = function (e, t, n) {
+ var s,
+ u = n.overrideProps,
+ c = (s = n.version, {
+ ReactTypeOfWork: o.gte(s, "16.6.0-beta.0") ? {
+ ClassComponent: 1,
+ ContextConsumer: 9,
+ ContextProvider: 10,
+ CoroutineComponent: -1,
+ CoroutineHandlerPhase: -1,
+ ForwardRef: 11,
+ Fragment: 7,
+ FunctionComponent: 0,
+ HostComponent: 5,
+ HostPortal: 4,
+ HostRoot: 3,
+ HostText: 6,
+ IncompleteClassComponent: 17,
+ IndeterminateComponent: 2,
+ LazyComponent: 16,
+ MemoComponent: 14,
+ Mode: 8,
+ Profiler: 12,
+ SimpleMemoComponent: 15,
+ SuspenseComponent: 13,
+ YieldComponent: -1
+ } : o.gte(s, "16.4.3-alpha") ? {
+ ClassComponent: 2,
+ ContextConsumer: 11,
+ ContextProvider: 12,
+ CoroutineComponent: -1,
+ CoroutineHandlerPhase: -1,
+ ForwardRef: 13,
+ Fragment: 9,
+ FunctionComponent: 0,
+ HostComponent: 7,
+ HostPortal: 6,
+ HostRoot: 5,
+ HostText: 8,
+ IncompleteClassComponent: -1,
+ IndeterminateComponent: 4,
+ LazyComponent: -1,
+ MemoComponent: -1,
+ Mode: 10,
+ Profiler: 15,
+ SimpleMemoComponent: -1,
+ SuspenseComponent: 16,
+ YieldComponent: -1
+ } : {
+ ClassComponent: 2,
+ ContextConsumer: 12,
+ ContextProvider: 13,
+ CoroutineComponent: 7,
+ CoroutineHandlerPhase: 8,
+ ForwardRef: 14,
+ Fragment: 10,
+ FunctionComponent: 1,
+ HostComponent: 5,
+ HostPortal: 4,
+ HostRoot: 3,
+ HostText: 6,
+ IncompleteClassComponent: -1,
+ IndeterminateComponent: 0,
+ LazyComponent: -1,
+ MemoComponent: -1,
+ Mode: 11,
+ Profiler: 15,
+ SimpleMemoComponent: -1,
+ SuspenseComponent: 16,
+ YieldComponent: 9
+ },
+ ReactSymbols: {
+ CONCURRENT_MODE_NUMBER: 60111,
+ CONCURRENT_MODE_SYMBOL_STRING: "Symbol(react.concurrent_mode)",
+ DEPRECATED_ASYNC_MODE_SYMBOL_STRING: "Symbol(react.async_mode)",
+ CONTEXT_CONSUMER_NUMBER: 60110,
+ CONTEXT_CONSUMER_SYMBOL_STRING: "Symbol(react.context)",
+ CONTEXT_PROVIDER_NUMBER: 60109,
+ CONTEXT_PROVIDER_SYMBOL_STRING: "Symbol(react.provider)",
+ FORWARD_REF_NUMBER: 60112,
+ FORWARD_REF_SYMBOL_STRING: "Symbol(react.forward_ref)",
+ MEMO_NUMBER: 60115,
+ MEMO_SYMBOL_STRING: "Symbol(react.memo)",
+ PROFILER_NUMBER: 60114,
+ PROFILER_SYMBOL_STRING: "Symbol(react.profiler)",
+ STRICT_MODE_NUMBER: 60108,
+ STRICT_MODE_SYMBOL_STRING: "Symbol(react.strict_mode)",
+ SUSPENSE_NUMBER: 60113,
+ SUSPENSE_SYMBOL_STRING: "Symbol(react.suspense)",
+ DEPRECATED_PLACEHOLDER_SYMBOL_STRING: "Symbol(react.placeholder)"
+ },
+ ReactTypeOfSideEffect: {
+ PerformedWork: 1
+ }
+ }),
+ l = c.ReactTypeOfWork,
+ f = c.ReactSymbols,
+ p = c.ReactTypeOfSideEffect.PerformedWork,
+ d = l.FunctionComponent,
+ h = l.ClassComponent,
+ m = l.ContextConsumer,
+ y = l.Fragment,
+ v = l.ForwardRef,
+ g = l.HostRoot,
+ b = l.HostPortal,
+ _ = l.HostComponent,
+ w = l.HostText,
+ S = l.IncompleteClassComponent,
+ E = l.IndeterminateComponent,
+ O = l.MemoComponent,
+ x = l.SimpleMemoComponent,
+ C = f.CONCURRENT_MODE_NUMBER,
+ I = f.CONCURRENT_MODE_SYMBOL_STRING,
+ N = f.DEPRECATED_ASYNC_MODE_SYMBOL_STRING,
+ T = f.CONTEXT_CONSUMER_NUMBER,
+ k = f.CONTEXT_CONSUMER_SYMBOL_STRING,
+ R = f.CONTEXT_PROVIDER_NUMBER,
+ j = f.CONTEXT_PROVIDER_SYMBOL_STRING,
+ M = f.PROFILER_NUMBER,
+ D = f.PROFILER_SYMBOL_STRING,
+ P = f.STRICT_MODE_NUMBER,
+ L = f.STRICT_MODE_SYMBOL_STRING,
+ A = f.SUSPENSE_NUMBER,
+ B = f.SUSPENSE_SYMBOL_STRING,
+ F = f.DEPRECATED_PLACEHOLDER_SYMBOL_STRING;
+
+ function U(e) {
+ var t = e.elementType,
+ n = e.type,
+ o = e.key,
+ s = e.ref,
+ c = e.tag,
+ l = e._debugSource,
+ f = null,
+ p = null,
+ m = null,
+ U = null,
+ H = null,
+ $ = null,
+ G = null,
+ W = null,
+ q = null,
+ Y = null,
+ K = null,
+ X = null,
+ J = null,
+ Z = null,
+ Q = !1,
+ ee = (c === d || c === x || c === v) && !!e.memoizedState,
+ te = n;
+
+ switch ("object" === r(n) && null !== n && "function" == typeof n.then && (te = n._reactResult), "function" == typeof u && ($ = {
+ canUpdate: !0,
+ setState: null,
+ setInProps: u.bind(null, e),
+ setInState: null,
+ setInContext: null
+ }), c) {
+ case h:
+ case d:
+ case S:
+ case E:
+ G = "Composite", W = a(te), f = e.stateNode, p = e.memoizedProps, m = e.memoizedState, null != f && (H = f.context) && 0 === Object.keys(H).length && (H = null);
+ var ne = f;
+ ne && ($ = {
+ canUpdate: !0,
+ setState: ne.setState && ne.setState.bind(ne),
+ setInProps: ne.forceUpdate && function (e, t, n) {
+ var r = e.stateNode;
+ e.pendingProps = i(r.props, t, n), e.alternate && (e.alternate.pendingProps = e.pendingProps), e.stateNode.forceUpdate();
+ }.bind(null, e),
+ setInState: ne.forceUpdate && function (e, t, n) {
+ z(e.state, t, n), e.forceUpdate();
+ }.bind(null, ne),
+ setInContext: ne.forceUpdate && function (e, t, n) {
+ z(e.context, t, n), e.forceUpdate();
+ }.bind(null, ne)
+ }), U = [];
+ break;
+
+ case v:
+ var re = a(te.render, "");
+ G = "Special", W = te.displayName || ("" !== re ? "ForwardRef(".concat(re, ")") : "ForwardRef"), p = e.memoizedProps, m = e.memoizedState, U = [];
+ break;
+
+ case g:
+ G = "Wrapper", U = [], K = e.stateNode.memoizedInteractions;
+ break;
+
+ case b:
+ G = "Portal", W = "ReactPortal", p = {
+ target: e.stateNode.containerInfo
+ }, U = [];
+ break;
+
+ case _:
+ G = "Native", W = (W = e.type).replace("topsecret-", ""), f = e.stateNode, U = "string" == typeof (p = e.memoizedProps).children || "number" == typeof p.children ? p.children.toString() : [], "function" == typeof e.stateNode.setNativeProps && ($ = {
+ setNativeProps: function setNativeProps(t) {
+ e.stateNode.setNativeProps(t);
+ }
+ });
+ break;
+
+ case w:
+ G = "Text", f = e.stateNode, q = e.memoizedProps;
+ break;
+
+ case y:
+ G = "Wrapper", U = [];
+ break;
+
+ case O:
+ case x:
+ if (G = "Composite", t.displayName) W = t.displayName;else {
+ var oe = n.displayName || n.name;
+ W = oe ? "Memo(".concat(oe, ")") : "Memo";
+ }
+ p = e.memoizedProps, m = e.memoizedState, U = [];
+ break;
+
+ default:
+ var ie = "object" === r(n) && null !== n ? n.$$typeof : n;
+
+ switch ("symbol" === r(ie) ? ie.toString() : ie) {
+ case C:
+ case I:
+ case N:
+ G = "Special", W = "ConcurrentMode", U = [];
+ break;
+
+ case R:
+ case j:
+ G = "Special", p = e.memoizedProps, Y = e.type._context || e.type.context, W = "".concat(Y.displayName || "Context", ".Provider"), U = [];
+ break;
+
+ case T:
+ case k:
+ G = "Special", p = e.memoizedProps, Y = e.type._context || e.type, W = "".concat(Y.displayName || "Context", ".Consumer"), U = [];
+ break;
+
+ case P:
+ case L:
+ G = "Special", W = "StrictMode", U = [];
+ break;
+
+ case A:
+ case B:
+ case F:
+ G = "Special", W = "Suspense", p = e.memoizedProps, U = [], Q = null !== e.memoizedState;
+ break;
+
+ case M:
+ case D:
+ G = "Special", p = e.memoizedProps, W = "Profiler(".concat(e.memoizedProps.id, ")"), U = [];
+ break;
+
+ default:
+ G = "Native", p = e.memoizedProps, W = "TODO_NOT_IMPLEMENTED_YET", U = [];
+ }
+
+ }
+
+ if (null !== p && void 0 !== r(e.elementType) && e.type !== e.elementType && (p = function (e, t) {
+ if (e && e.defaultProps) {
+ var n = _extends({}, t),
+ r = e.defaultProps;
+
+ for (var o in r) {
+ void 0 === n[o] && (n[o] = r[o]);
+ }
+
+ return n;
+ }
+
+ return t;
+ }(e.type, p)), Array.isArray(U)) if (Q) {
+ var ae = e.child,
+ se = ae.child,
+ ue = ae.sibling.child;
+ U.push(se), U.push(ue);
+ } else for (var ce = e.child; ce;) {
+ U.push(V(ce)), ce = ce.sibling;
+ }
+ return void 0 !== e.actualDuration && (X = e.actualDuration, J = e.actualStartTime, Z = e.treeBaseDuration), null === f && (f = {
+ props: p,
+ state: m,
+ type: n
+ }), {
+ nodeType: G,
+ type: n,
+ key: o,
+ ref: s,
+ source: l,
+ name: W,
+ props: p,
+ state: m,
+ context: H,
+ children: U,
+ text: q,
+ updater: $,
+ publicInstance: f,
+ memoizedInteractions: K,
+ actualDuration: X,
+ actualStartTime: J,
+ treeBaseDuration: Z,
+ containsHooks: ee
+ };
+ }
+
+ function z(e, t, n) {
+ var r = t.pop(),
+ o = t.reduce(function (e, t) {
+ return e ? e[t] : null;
+ }, e);
+ o && (o[r] = n);
+ }
+
+ var H = new Set();
+
+ function V(e) {
+ if (H.has(e)) return e;
+ var t = e.alternate;
+ return null != t && H.has(t) ? t : (H.add(e), e);
+ }
+
+ var $ = [];
+
+ function G() {
+ var t = $;
+ $ = [];
+
+ for (var n = 0; n < t.length; n++) {
+ var r = t[n];
+ e.emit(r.type, r);
+ }
+ }
+
+ function W(e) {
+ $.push({
+ internalInstance: V(e),
+ data: U(e),
+ renderer: t,
+ type: "mount"
+ }), e.tag === g && $.push({
+ internalInstance: V(e),
+ renderer: t,
+ type: "root"
+ });
+ }
+
+ function q(e, n) {
+ var r,
+ o,
+ i = U(e);
+ if (!n && !function (e, t) {
+ switch (t.tag) {
+ case h:
+ case d:
+ case m:
+ case O:
+ case x:
+ return (t.effectTag & p) === p;
+
+ default:
+ return e.memoizedProps !== t.memoizedProps || e.memoizedState !== t.memoizedState || e.ref !== t.ref;
+ }
+ }(e.alternate, e)) return r = e.alternate, o = e, void (void 0 === r.actualDuration || r.actualDuration === o.actualDuration && r.actualStartTime === o.actualStartTime && r.treeBaseDuration === o.treeBaseDuration || $.push({
+ internalInstance: V(e),
+ data: i,
+ renderer: t,
+ type: "updateProfileTimes"
+ }));
+ $.push({
+ internalInstance: V(e),
+ data: i,
+ renderer: t,
+ type: "update"
+ });
+ }
+
+ function Y(e) {
+ var n = e.tag === g,
+ r = V(e),
+ o = {
+ internalInstance: r,
+ renderer: t,
+ type: "unmount"
+ };
+ n ? $.push(o) : $.unshift(o), H.delete(r);
+ }
+
+ function K(e) {
+ $.push({
+ internalInstance: V(e),
+ data: U(e),
+ renderer: t,
+ type: "rootCommitted"
+ });
+ }
+
+ function X(e) {
+ var t = e;
+
+ e: for (;;) {
+ if (t.child) t.child.return = t, t = t.child;else {
+ if (W(t), t == e) return;
+
+ if (!t.sibling) {
+ for (; t.return;) {
+ if (W(t = t.return), t == e) return;
+
+ if (t.sibling) {
+ t.sibling.return = t.return, t = t.sibling;
+ continue e;
+ }
+ }
+
+ return;
+ }
+
+ t.sibling.return = t.return, t = t.sibling;
+ }
+ }
+ }
+
+ return {
+ getNativeFromReactElement: function getNativeFromReactElement(e) {
+ try {
+ var t = e;
+ return n.findHostInstanceByFiber(t);
+ } catch (e) {
+ return null;
+ }
+ },
+ getReactElementFromNative: function getReactElementFromNative(e) {
+ var t = n.findFiberByHostInstance(e);
+ return null != t ? V(t) : null;
+ },
+ handleCommitFiberRoot: function handleCommitFiberRoot(e) {
+ var t = e.current,
+ n = t.alternate;
+
+ if (n) {
+ var r = null != n.memoizedState && null != n.memoizedState.element,
+ o = null != t.memoizedState && null != t.memoizedState.element;
+ !r && o ? X(t) : r && o ? function e(t, n) {
+ if (t.tag === l.SuspenseComponent && null !== t.memoizedState) {
+ var r = t.child.sibling.child;
+ r.alternate ? e(r, r.alternate) : X(r), q(t, !1);
+ } else {
+ var o = !1;
+
+ if (t.child !== n.child) {
+ for (var i = t.child, a = n.child; i;) {
+ if (i.alternate) {
+ var s = i.alternate;
+ e(i, s), o || s === a || (o = !0);
+ } else X(i), o || (o = !0);
+
+ i = i.sibling, o || null == a || (a = a.sibling);
+ }
+
+ o || null == a || (o = !0);
+ }
+
+ q(t, o);
+ }
+ }(t, n) : r && !o && Y(t);
+ } else X(t);
+
+ K(t), G();
+ },
+ handleCommitFiberUnmount: function handleCommitFiberUnmount(e) {
+ Y(e);
+ },
+ cleanup: function cleanup() {},
+ walkTree: function walkTree() {
+ e.getFiberRoots(t).forEach(function (e) {
+ X(e.current), K(e.current);
+ }), G();
+ },
+ renderer: n
+ };
+ };
+ }, function (e, t, n) {
+ (function (n) {
+ function r(e) {
+ return (r = "function" == typeof Symbol && "symbol" == typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") ? function (e) {
+ return typeof e;
+ } : function (e) {
+ return e && "function" == typeof Symbol && e.constructor === Symbol && e !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof e;
+ })(e);
+ }
+
+ var o;
+ t = e.exports = K, o = "object" === (void 0 === n ? "undefined" : r(n)) && n.env && n.env.NODE_DEBUG && /\bsemver\b/i.test(n.env.NODE_DEBUG) ? function () {
+ var e = Array.prototype.slice.call(arguments, 0);
+ e.unshift("SEMVER"), console.log.apply(console, e);
+ } : function () {}, t.SEMVER_SPEC_VERSION = "2.0.0";
+ var i = 256,
+ a = Number.MAX_SAFE_INTEGER || 9007199254740991,
+ s = t.re = [],
+ u = t.src = [],
+ c = 0,
+ l = c++;
+ u[l] = "0|[1-9]\\d*";
+ var f = c++;
+ u[f] = "[0-9]+";
+ var p = c++;
+ u[p] = "\\d*[a-zA-Z-][a-zA-Z0-9-]*";
+ var d = c++;
+ u[d] = "(" + u[l] + ")\\.(" + u[l] + ")\\.(" + u[l] + ")";
+ var h = c++;
+ u[h] = "(" + u[f] + ")\\.(" + u[f] + ")\\.(" + u[f] + ")";
+ var m = c++;
+ u[m] = "(?:" + u[l] + "|" + u[p] + ")";
+ var y = c++;
+ u[y] = "(?:" + u[f] + "|" + u[p] + ")";
+ var v = c++;
+ u[v] = "(?:-(" + u[m] + "(?:\\." + u[m] + ")*))";
+ var g = c++;
+ u[g] = "(?:-?(" + u[y] + "(?:\\." + u[y] + ")*))";
+ var b = c++;
+ u[b] = "[0-9A-Za-z-]+";
+
+ var _ = c++;
+
+ u[_] = "(?:\\+(" + u[b] + "(?:\\." + u[b] + ")*))";
+ var w = c++,
+ S = "v?" + u[d] + u[v] + "?" + u[_] + "?";
+ u[w] = "^" + S + "$";
+ var E = "[v=\\s]*" + u[h] + u[g] + "?" + u[_] + "?",
+ O = c++;
+ u[O] = "^" + E + "$";
+ var x = c++;
+ u[x] = "((?:<|>)?=?)";
+ var C = c++;
+ u[C] = u[f] + "|x|X|\\*";
+ var I = c++;
+ u[I] = u[l] + "|x|X|\\*";
+ var N = c++;
+ u[N] = "[v=\\s]*(" + u[I] + ")(?:\\.(" + u[I] + ")(?:\\.(" + u[I] + ")(?:" + u[v] + ")?" + u[_] + "?)?)?";
+ var T = c++;
+ u[T] = "[v=\\s]*(" + u[C] + ")(?:\\.(" + u[C] + ")(?:\\.(" + u[C] + ")(?:" + u[g] + ")?" + u[_] + "?)?)?";
+ var k = c++;
+ u[k] = "^" + u[x] + "\\s*" + u[N] + "$";
+ var R = c++;
+ u[R] = "^" + u[x] + "\\s*" + u[T] + "$";
+ var j = c++;
+ u[j] = "(?:^|[^\\d])(\\d{1,16})(?:\\.(\\d{1,16}))?(?:\\.(\\d{1,16}))?(?:$|[^\\d])";
+ var M = c++;
+ u[M] = "(?:~>?)";
+ var D = c++;
+ u[D] = "(\\s*)" + u[M] + "\\s+", s[D] = new RegExp(u[D], "g");
+ var P = c++;
+ u[P] = "^" + u[M] + u[N] + "$";
+ var L = c++;
+ u[L] = "^" + u[M] + u[T] + "$";
+ var A = c++;
+ u[A] = "(?:\\^)";
+ var B = c++;
+ u[B] = "(\\s*)" + u[A] + "\\s+", s[B] = new RegExp(u[B], "g");
+ var F = c++;
+ u[F] = "^" + u[A] + u[N] + "$";
+ var U = c++;
+ u[U] = "^" + u[A] + u[T] + "$";
+ var z = c++;
+ u[z] = "^" + u[x] + "\\s*(" + E + ")$|^$";
+ var H = c++;
+ u[H] = "^" + u[x] + "\\s*(" + S + ")$|^$";
+ var V = c++;
+ u[V] = "(\\s*)" + u[x] + "\\s*(" + E + "|" + u[N] + ")", s[V] = new RegExp(u[V], "g");
+ var $ = c++;
+ u[$] = "^\\s*(" + u[N] + ")\\s+-\\s+(" + u[N] + ")\\s*$";
+ var G = c++;
+ u[G] = "^\\s*(" + u[T] + ")\\s+-\\s+(" + u[T] + ")\\s*$";
+ var W = c++;
+ u[W] = "(<|>)?=?\\s*\\*";
+
+ for (var q = 0; q < 35; q++) {
+ o(q, u[q]), s[q] || (s[q] = new RegExp(u[q]));
+ }
+
+ function Y(e, t) {
+ if (e instanceof K) return e;
+ if ("string" != typeof e) return null;
+ if (e.length > i) return null;
+ if (!(t ? s[O] : s[w]).test(e)) return null;
+
+ try {
+ return new K(e, t);
+ } catch (e) {
+ return null;
+ }
+ }
+
+ function K(e, t) {
+ if (e instanceof K) {
+ if (e.loose === t) return e;
+ e = e.version;
+ } else if ("string" != typeof e) throw new TypeError("Invalid Version: " + e);
+
+ if (e.length > i) throw new TypeError("version is longer than " + i + " characters");
+ if (!(this instanceof K)) return new K(e, t);
+ o("SemVer", e, t), this.loose = t;
+ var n = e.trim().match(t ? s[O] : s[w]);
+ if (!n) throw new TypeError("Invalid Version: " + e);
+ if (this.raw = e, this.major = +n[1], this.minor = +n[2], this.patch = +n[3], this.major > a || this.major < 0) throw new TypeError("Invalid major version");
+ if (this.minor > a || this.minor < 0) throw new TypeError("Invalid minor version");
+ if (this.patch > a || this.patch < 0) throw new TypeError("Invalid patch version");
+ n[4] ? this.prerelease = n[4].split(".").map(function (e) {
+ if (/^[0-9]+$/.test(e)) {
+ var t = +e;
+ if (t >= 0 && t < a) return t;
+ }
+
+ return e;
+ }) : this.prerelease = [], this.build = n[5] ? n[5].split(".") : [], this.format();
+ }
+
+ t.parse = Y, t.valid = function (e, t) {
+ var n = Y(e, t);
+ return n ? n.version : null;
+ }, t.clean = function (e, t) {
+ var n = Y(e.trim().replace(/^[=v]+/, ""), t);
+ return n ? n.version : null;
+ }, t.SemVer = K, K.prototype.format = function () {
+ return this.version = this.major + "." + this.minor + "." + this.patch, this.prerelease.length && (this.version += "-" + this.prerelease.join(".")), this.version;
+ }, K.prototype.toString = function () {
+ return this.version;
+ }, K.prototype.compare = function (e) {
+ return o("SemVer.compare", this.version, this.loose, e), e instanceof K || (e = new K(e, this.loose)), this.compareMain(e) || this.comparePre(e);
+ }, K.prototype.compareMain = function (e) {
+ return e instanceof K || (e = new K(e, this.loose)), J(this.major, e.major) || J(this.minor, e.minor) || J(this.patch, e.patch);
+ }, K.prototype.comparePre = function (e) {
+ if (e instanceof K || (e = new K(e, this.loose)), this.prerelease.length && !e.prerelease.length) return -1;
+ if (!this.prerelease.length && e.prerelease.length) return 1;
+ if (!this.prerelease.length && !e.prerelease.length) return 0;
+ var t = 0;
+
+ do {
+ var n = this.prerelease[t],
+ r = e.prerelease[t];
+ if (o("prerelease compare", t, n, r), void 0 === n && void 0 === r) return 0;
+ if (void 0 === r) return 1;
+ if (void 0 === n) return -1;
+ if (n !== r) return J(n, r);
+ } while (++t);
+ }, K.prototype.inc = function (e, t) {
+ switch (e) {
+ case "premajor":
+ this.prerelease.length = 0, this.patch = 0, this.minor = 0, this.major++, this.inc("pre", t);
+ break;
+
+ case "preminor":
+ this.prerelease.length = 0, this.patch = 0, this.minor++, this.inc("pre", t);
+ break;
+
+ case "prepatch":
+ this.prerelease.length = 0, this.inc("patch", t), this.inc("pre", t);
+ break;
+
+ case "prerelease":
+ 0 === this.prerelease.length && this.inc("patch", t), this.inc("pre", t);
+ break;
+
+ case "major":
+ 0 === this.minor && 0 === this.patch && 0 !== this.prerelease.length || this.major++, this.minor = 0, this.patch = 0, this.prerelease = [];
+ break;
+
+ case "minor":
+ 0 === this.patch && 0 !== this.prerelease.length || this.minor++, this.patch = 0, this.prerelease = [];
+ break;
+
+ case "patch":
+ 0 === this.prerelease.length && this.patch++, this.prerelease = [];
+ break;
+
+ case "pre":
+ if (0 === this.prerelease.length) this.prerelease = [0];else {
+ for (var n = this.prerelease.length; --n >= 0;) {
+ "number" == typeof this.prerelease[n] && (this.prerelease[n]++, n = -2);
+ }
+
+ -1 === n && this.prerelease.push(0);
+ }
+ t && (this.prerelease[0] === t ? isNaN(this.prerelease[1]) && (this.prerelease = [t, 0]) : this.prerelease = [t, 0]);
+ break;
+
+ default:
+ throw new Error("invalid increment argument: " + e);
+ }
+
+ return this.format(), this.raw = this.version, this;
+ }, t.inc = function (e, t, n, r) {
+ "string" == typeof n && (r = n, n = void 0);
+
+ try {
+ return new K(e, n).inc(t, r).version;
+ } catch (e) {
+ return null;
+ }
+ }, t.diff = function (e, t) {
+ if (te(e, t)) return null;
+ var n = Y(e),
+ r = Y(t);
+
+ if (n.prerelease.length || r.prerelease.length) {
+ for (var o in n) {
+ if (("major" === o || "minor" === o || "patch" === o) && n[o] !== r[o]) return "pre" + o;
+ }
+
+ return "prerelease";
+ }
+
+ for (var o in n) {
+ if (("major" === o || "minor" === o || "patch" === o) && n[o] !== r[o]) return o;
+ }
+ }, t.compareIdentifiers = J;
+ var X = /^[0-9]+$/;
+
+ function J(e, t) {
+ var n = X.test(e),
+ r = X.test(t);
+ return n && r && (e = +e, t = +t), n && !r ? -1 : r && !n ? 1 : e < t ? -1 : e > t ? 1 : 0;
+ }
+
+ function Z(e, t, n) {
+ return new K(e, n).compare(new K(t, n));
+ }
+
+ function Q(e, t, n) {
+ return Z(e, t, n) > 0;
+ }
+
+ function ee(e, t, n) {
+ return Z(e, t, n) < 0;
+ }
+
+ function te(e, t, n) {
+ return 0 === Z(e, t, n);
+ }
+
+ function ne(e, t, n) {
+ return 0 !== Z(e, t, n);
+ }
+
+ function re(e, t, n) {
+ return Z(e, t, n) >= 0;
+ }
+
+ function oe(e, t, n) {
+ return Z(e, t, n) <= 0;
+ }
+
+ function ie(e, t, n, o) {
+ var i;
+
+ switch (t) {
+ case "===":
+ "object" === r(e) && (e = e.version), "object" === r(n) && (n = n.version), i = e === n;
+ break;
+
+ case "!==":
+ "object" === r(e) && (e = e.version), "object" === r(n) && (n = n.version), i = e !== n;
+ break;
+
+ case "":
+ case "=":
+ case "==":
+ i = te(e, n, o);
+ break;
+
+ case "!=":
+ i = ne(e, n, o);
+ break;
+
+ case ">":
+ i = Q(e, n, o);
+ break;
+
+ case ">=":
+ i = re(e, n, o);
+ break;
+
+ case "<":
+ i = ee(e, n, o);
+ break;
+
+ case "<=":
+ i = oe(e, n, o);
+ break;
+
+ default:
+ throw new TypeError("Invalid operator: " + t);
+ }
+
+ return i;
+ }
+
+ function ae(e, t) {
+ if (e instanceof ae) {
+ if (e.loose === t) return e;
+ e = e.value;
+ }
+
+ if (!(this instanceof ae)) return new ae(e, t);
+ o("comparator", e, t), this.loose = t, this.parse(e), this.semver === se ? this.value = "" : this.value = this.operator + this.semver.version, o("comp", this);
+ }
+
+ t.rcompareIdentifiers = function (e, t) {
+ return J(t, e);
+ }, t.major = function (e, t) {
+ return new K(e, t).major;
+ }, t.minor = function (e, t) {
+ return new K(e, t).minor;
+ }, t.patch = function (e, t) {
+ return new K(e, t).patch;
+ }, t.compare = Z, t.compareLoose = function (e, t) {
+ return Z(e, t, !0);
+ }, t.rcompare = function (e, t, n) {
+ return Z(t, e, n);
+ }, t.sort = function (e, n) {
+ return e.sort(function (e, r) {
+ return t.compare(e, r, n);
+ });
+ }, t.rsort = function (e, n) {
+ return e.sort(function (e, r) {
+ return t.rcompare(e, r, n);
+ });
+ }, t.gt = Q, t.lt = ee, t.eq = te, t.neq = ne, t.gte = re, t.lte = oe, t.cmp = ie, t.Comparator = ae;
+ var se = {};
+
+ function ue(e, t) {
+ if (e instanceof ue) return e.loose === t ? e : new ue(e.raw, t);
+ if (e instanceof ae) return new ue(e.value, t);
+ if (!(this instanceof ue)) return new ue(e, t);
+ if (this.loose = t, this.raw = e, this.set = e.split(/\s*\|\|\s*/).map(function (e) {
+ return this.parseRange(e.trim());
+ }, this).filter(function (e) {
+ return e.length;
+ }), !this.set.length) throw new TypeError("Invalid SemVer Range: " + e);
+ this.format();
+ }
+
+ function ce(e) {
+ return !e || "x" === e.toLowerCase() || "*" === e;
+ }
+
+ function le(e, t, n, r, o, i, a, s, u, c, l, f, p) {
+ return ((t = ce(n) ? "" : ce(r) ? ">=" + n + ".0.0" : ce(o) ? ">=" + n + "." + r + ".0" : ">=" + t) + " " + (s = ce(u) ? "" : ce(c) ? "<" + (+u + 1) + ".0.0" : ce(l) ? "<" + u + "." + (+c + 1) + ".0" : f ? "<=" + u + "." + c + "." + l + "-" + f : "<=" + s)).trim();
+ }
+
+ function fe(e, t) {
+ for (var n = 0; n < e.length; n++) {
+ if (!e[n].test(t)) return !1;
+ }
+
+ if (t.prerelease.length) {
+ for (n = 0; n < e.length; n++) {
+ if (o(e[n].semver), e[n].semver !== se && e[n].semver.prerelease.length > 0) {
+ var r = e[n].semver;
+ if (r.major === t.major && r.minor === t.minor && r.patch === t.patch) return !0;
+ }
+ }
+
+ return !1;
+ }
+
+ return !0;
+ }
+
+ function pe(e, t, n) {
+ try {
+ t = new ue(t, n);
+ } catch (e) {
+ return !1;
+ }
+
+ return t.test(e);
+ }
+
+ function de(e, t, n, r) {
+ var o, i, a, s, u;
+
+ switch (e = new K(e, r), t = new ue(t, r), n) {
+ case ">":
+ o = Q, i = oe, a = ee, s = ">", u = ">=";
+ break;
+
+ case "<":
+ o = ee, i = re, a = Q, s = "<", u = "<=";
+ break;
+
+ default:
+ throw new TypeError('Must provide a hilo val of "<" or ">"');
+ }
+
+ if (pe(e, t, r)) return !1;
+
+ for (var c = 0; c < t.set.length; ++c) {
+ var l = t.set[c],
+ f = null,
+ p = null;
+ if (l.forEach(function (e) {
+ e.semver === se && (e = new ae(">=0.0.0")), f = f || e, p = p || e, o(e.semver, f.semver, r) ? f = e : a(e.semver, p.semver, r) && (p = e);
+ }), f.operator === s || f.operator === u) return !1;
+ if ((!p.operator || p.operator === s) && i(e, p.semver)) return !1;
+ if (p.operator === u && a(e, p.semver)) return !1;
+ }
+
+ return !0;
+ }
+
+ ae.prototype.parse = function (e) {
+ var t = this.loose ? s[z] : s[H],
+ n = e.match(t);
+ if (!n) throw new TypeError("Invalid comparator: " + e);
+ this.operator = n[1], "=" === this.operator && (this.operator = ""), n[2] ? this.semver = new K(n[2], this.loose) : this.semver = se;
+ }, ae.prototype.toString = function () {
+ return this.value;
+ }, ae.prototype.test = function (e) {
+ return o("Comparator.test", e, this.loose), this.semver === se || ("string" == typeof e && (e = new K(e, this.loose)), ie(e, this.operator, this.semver, this.loose));
+ }, ae.prototype.intersects = function (e, t) {
+ if (!(e instanceof ae)) throw new TypeError("a Comparator is required");
+ var n;
+ if ("" === this.operator) return n = new ue(e.value, t), pe(this.value, n, t);
+ if ("" === e.operator) return n = new ue(this.value, t), pe(e.semver, n, t);
+ var r = !(">=" !== this.operator && ">" !== this.operator || ">=" !== e.operator && ">" !== e.operator),
+ o = !("<=" !== this.operator && "<" !== this.operator || "<=" !== e.operator && "<" !== e.operator),
+ i = this.semver.version === e.semver.version,
+ a = !(">=" !== this.operator && "<=" !== this.operator || ">=" !== e.operator && "<=" !== e.operator),
+ s = ie(this.semver, "<", e.semver, t) && (">=" === this.operator || ">" === this.operator) && ("<=" === e.operator || "<" === e.operator),
+ u = ie(this.semver, ">", e.semver, t) && ("<=" === this.operator || "<" === this.operator) && (">=" === e.operator || ">" === e.operator);
+ return r || o || i && a || s || u;
+ }, t.Range = ue, ue.prototype.format = function () {
+ return this.range = this.set.map(function (e) {
+ return e.join(" ").trim();
+ }).join("||").trim(), this.range;
+ }, ue.prototype.toString = function () {
+ return this.range;
+ }, ue.prototype.parseRange = function (e) {
+ var t = this.loose;
+ e = e.trim(), o("range", e, t);
+ var n = t ? s[G] : s[$];
+ e = e.replace(n, le), o("hyphen replace", e), e = e.replace(s[V], "$1$2$3"), o("comparator trim", e, s[V]), e = (e = (e = e.replace(s[D], "$1~")).replace(s[B], "$1^")).split(/\s+/).join(" ");
+ var r = t ? s[z] : s[H],
+ i = e.split(" ").map(function (e) {
+ return function (e, t) {
+ return o("comp", e), e = function (e, t) {
+ return e.trim().split(/\s+/).map(function (e) {
+ return function (e, t) {
+ o("caret", e, t);
+ var n = t ? s[U] : s[F];
+ return e.replace(n, function (t, n, r, i, a) {
+ var s;
+ return o("caret", e, t, n, r, i, a), ce(n) ? s = "" : ce(r) ? s = ">=" + n + ".0.0 <" + (+n + 1) + ".0.0" : ce(i) ? s = "0" === n ? ">=" + n + "." + r + ".0 <" + n + "." + (+r + 1) + ".0" : ">=" + n + "." + r + ".0 <" + (+n + 1) + ".0.0" : a ? (o("replaceCaret pr", a), "-" !== a.charAt(0) && (a = "-" + a), s = "0" === n ? "0" === r ? ">=" + n + "." + r + "." + i + a + " <" + n + "." + r + "." + (+i + 1) : ">=" + n + "." + r + "." + i + a + " <" + n + "." + (+r + 1) + ".0" : ">=" + n + "." + r + "." + i + a + " <" + (+n + 1) + ".0.0") : (o("no pr"), s = "0" === n ? "0" === r ? ">=" + n + "." + r + "." + i + " <" + n + "." + r + "." + (+i + 1) : ">=" + n + "." + r + "." + i + " <" + n + "." + (+r + 1) + ".0" : ">=" + n + "." + r + "." + i + " <" + (+n + 1) + ".0.0"), o("caret return", s), s;
+ });
+ }(e, t);
+ }).join(" ");
+ }(e, t), o("caret", e), e = function (e, t) {
+ return e.trim().split(/\s+/).map(function (e) {
+ return function (e, t) {
+ var n = t ? s[L] : s[P];
+ return e.replace(n, function (t, n, r, i, a) {
+ var s;
+ return o("tilde", e, t, n, r, i, a), ce(n) ? s = "" : ce(r) ? s = ">=" + n + ".0.0 <" + (+n + 1) + ".0.0" : ce(i) ? s = ">=" + n + "." + r + ".0 <" + n + "." + (+r + 1) + ".0" : a ? (o("replaceTilde pr", a), "-" !== a.charAt(0) && (a = "-" + a), s = ">=" + n + "." + r + "." + i + a + " <" + n + "." + (+r + 1) + ".0") : s = ">=" + n + "." + r + "." + i + " <" + n + "." + (+r + 1) + ".0", o("tilde return", s), s;
+ });
+ }(e, t);
+ }).join(" ");
+ }(e, t), o("tildes", e), e = function (e, t) {
+ return o("replaceXRanges", e, t), e.split(/\s+/).map(function (e) {
+ return function (e, t) {
+ e = e.trim();
+ var n = t ? s[R] : s[k];
+ return e.replace(n, function (t, n, r, i, a, s) {
+ o("xRange", e, t, n, r, i, a, s);
+ var u = ce(r),
+ c = u || ce(i),
+ l = c || ce(a),
+ f = l;
+ return "=" === n && f && (n = ""), u ? t = ">" === n || "<" === n ? "<0.0.0" : "*" : n && f ? (c && (i = 0), l && (a = 0), ">" === n ? (n = ">=", c ? (r = +r + 1, i = 0, a = 0) : l && (i = +i + 1, a = 0)) : "<=" === n && (n = "<", c ? r = +r + 1 : i = +i + 1), t = n + r + "." + i + "." + a) : c ? t = ">=" + r + ".0.0 <" + (+r + 1) + ".0.0" : l && (t = ">=" + r + "." + i + ".0 <" + r + "." + (+i + 1) + ".0"), o("xRange return", t), t;
+ });
+ }(e, t);
+ }).join(" ");
+ }(e, t), o("xrange", e), e = function (e, t) {
+ return o("replaceStars", e, t), e.trim().replace(s[W], "");
+ }(e, t), o("stars", e), e;
+ }(e, t);
+ }).join(" ").split(/\s+/);
+ return this.loose && (i = i.filter(function (e) {
+ return !!e.match(r);
+ })), i = i.map(function (e) {
+ return new ae(e, t);
+ });
+ }, ue.prototype.intersects = function (e, t) {
+ if (!(e instanceof ue)) throw new TypeError("a Range is required");
+ return this.set.some(function (n) {
+ return n.every(function (n) {
+ return e.set.some(function (e) {
+ return e.every(function (e) {
+ return n.intersects(e, t);
+ });
+ });
+ });
+ });
+ }, t.toComparators = function (e, t) {
+ return new ue(e, t).set.map(function (e) {
+ return e.map(function (e) {
+ return e.value;
+ }).join(" ").trim().split(" ");
+ });
+ }, ue.prototype.test = function (e) {
+ if (!e) return !1;
+ "string" == typeof e && (e = new K(e, this.loose));
+
+ for (var t = 0; t < this.set.length; t++) {
+ if (fe(this.set[t], e)) return !0;
+ }
+
+ return !1;
+ }, t.satisfies = pe, t.maxSatisfying = function (e, t, n) {
+ var r = null,
+ o = null;
+
+ try {
+ var i = new ue(t, n);
+ } catch (e) {
+ return null;
+ }
+
+ return e.forEach(function (e) {
+ i.test(e) && (r && -1 !== o.compare(e) || (o = new K(r = e, n)));
+ }), r;
+ }, t.minSatisfying = function (e, t, n) {
+ var r = null,
+ o = null;
+
+ try {
+ var i = new ue(t, n);
+ } catch (e) {
+ return null;
+ }
+
+ return e.forEach(function (e) {
+ i.test(e) && (r && 1 !== o.compare(e) || (o = new K(r = e, n)));
+ }), r;
+ }, t.validRange = function (e, t) {
+ try {
+ return new ue(e, t).range || "*";
+ } catch (e) {
+ return null;
+ }
+ }, t.ltr = function (e, t, n) {
+ return de(e, t, "<", n);
+ }, t.gtr = function (e, t, n) {
+ return de(e, t, ">", n);
+ }, t.outside = de, t.prerelease = function (e, t) {
+ var n = Y(e, t);
+ return n && n.prerelease.length ? n.prerelease : null;
+ }, t.intersects = function (e, t, n) {
+ return e = new ue(e, n), t = new ue(t, n), e.intersects(t);
+ }, t.coerce = function (e) {
+ if (e instanceof K) return e;
+ if ("string" != typeof e) return null;
+ var t = e.match(s[j]);
+ return null == t ? null : Y((t[1] || "0") + "." + (t[2] || "0") + "." + (t[3] || "0"));
+ };
+ }).call(this, n(6));
+ }, function (e, t, n) {
+ "use strict";
+
+ (function (t) {
+ /*!
+ * The buffer module from node.js, for the browser.
+ *
+ * @author Feross Aboukhadijeh
+ * @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 = "🔍", 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;
+ });
+ }]);
+ });
+},169,[14],"node_modules\\react-devtools-core\\build\\backend.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var JSInspector = {
+ registerAgent: function registerAgent(type) {
+ if (global.__registerInspectorAgent) {
+ global.__registerInspectorAgent(type);
+ }
+ },
+ getTimestamp: function getTimestamp() {
+ return global.__inspectorTimestamp();
+ }
+ };
+ module.exports = JSInspector;
+},170,[],"node_modules\\react-native\\Libraries\\JSInspector\\JSInspector.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/inherits");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/createClass");
+
+ var InspectorAgent = _$$_REQUIRE(_dependencyMap[5], "InspectorAgent");
+
+ var JSInspector = _$$_REQUIRE(_dependencyMap[6], "JSInspector");
+
+ var XMLHttpRequest = _$$_REQUIRE(_dependencyMap[7], "XMLHttpRequest");
+
+ var Interceptor = function () {
+ function Interceptor(agent) {
+ _classCallCheck(this, Interceptor);
+
+ this._agent = agent;
+ this._requests = new Map();
+ }
+
+ _createClass(Interceptor, [{
+ key: "getData",
+ value: function getData(requestId) {
+ return this._requests.get(requestId);
+ }
+ }, {
+ key: "requestSent",
+ value: function requestSent(id, url, method, headers) {
+ var requestId = String(id);
+
+ this._requests.set(requestId, '');
+
+ var request = {
+ url: url,
+ method: method,
+ headers: headers,
+ initialPriority: 'Medium'
+ };
+ var event = {
+ requestId: requestId,
+ documentURL: '',
+ frameId: '1',
+ loaderId: '1',
+ request: request,
+ timestamp: JSInspector.getTimestamp(),
+ initiator: {
+ type: 'other'
+ },
+ type: 'Other'
+ };
+
+ this._agent.sendEvent('requestWillBeSent', event);
+ }
+ }, {
+ key: "responseReceived",
+ value: function responseReceived(id, url, status, headers) {
+ var requestId = String(id);
+ var response = {
+ url: url,
+ status: status,
+ statusText: String(status),
+ headers: headers,
+ requestHeaders: {},
+ mimeType: this._getMimeType(headers),
+ connectionReused: false,
+ connectionId: -1,
+ encodedDataLength: 0,
+ securityState: 'unknown'
+ };
+ var event = {
+ requestId: requestId,
+ frameId: '1',
+ loaderId: '1',
+ timestamp: JSInspector.getTimestamp(),
+ type: 'Other',
+ response: response
+ };
+
+ this._agent.sendEvent('responseReceived', event);
+ }
+ }, {
+ key: "dataReceived",
+ value: function dataReceived(id, data) {
+ var requestId = String(id);
+ var existingData = this._requests.get(requestId) || '';
+
+ this._requests.set(requestId, existingData.concat(data));
+
+ var event = {
+ requestId: requestId,
+ timestamp: JSInspector.getTimestamp(),
+ dataLength: data.length,
+ encodedDataLength: data.length
+ };
+
+ this._agent.sendEvent('dataReceived', event);
+ }
+ }, {
+ key: "loadingFinished",
+ value: function loadingFinished(id, encodedDataLength) {
+ var event = {
+ requestId: String(id),
+ timestamp: JSInspector.getTimestamp(),
+ encodedDataLength: encodedDataLength
+ };
+
+ this._agent.sendEvent('loadingFinished', event);
+ }
+ }, {
+ key: "loadingFailed",
+ value: function loadingFailed(id, error) {
+ var event = {
+ requestId: String(id),
+ timestamp: JSInspector.getTimestamp(),
+ type: 'Other',
+ errorText: error
+ };
+
+ this._agent.sendEvent('loadingFailed', event);
+ }
+ }, {
+ key: "_getMimeType",
+ value: function _getMimeType(headers) {
+ var contentType = headers['Content-Type'] || '';
+ return contentType.split(';')[0];
+ }
+ }]);
+
+ return Interceptor;
+ }();
+
+ var NetworkAgent = function (_InspectorAgent) {
+ _inherits(NetworkAgent, _InspectorAgent);
+
+ function NetworkAgent() {
+ _classCallCheck(this, NetworkAgent);
+
+ return _possibleConstructorReturn(this, _getPrototypeOf(NetworkAgent).apply(this, arguments));
+ }
+
+ _createClass(NetworkAgent, [{
+ key: "enable",
+ value: function enable(_ref) {
+ var maxResourceBufferSize = _ref.maxResourceBufferSize,
+ maxTotalBufferSize = _ref.maxTotalBufferSize;
+ this._interceptor = new Interceptor(this);
+ XMLHttpRequest.setInterceptor(this._interceptor);
+ }
+ }, {
+ key: "disable",
+ value: function disable() {
+ XMLHttpRequest.setInterceptor(null);
+ this._interceptor = null;
+ }
+ }, {
+ key: "getResponseBody",
+ value: function getResponseBody(_ref2) {
+ var requestId = _ref2.requestId;
+ return {
+ body: this.interceptor().getData(requestId),
+ base64Encoded: false
+ };
+ }
+ }, {
+ key: "interceptor",
+ value: function interceptor() {
+ if (this._interceptor) {
+ return this._interceptor;
+ } else {
+ throw Error('_interceptor can not be null');
+ }
+ }
+ }]);
+
+ return NetworkAgent;
+ }(InspectorAgent);
+
+ NetworkAgent.DOMAIN = 'Network';
+ module.exports = NetworkAgent;
+},171,[5,8,9,3,4,172,170,124],"node_modules\\react-native\\Libraries\\JSInspector\\NetworkAgent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var InspectorAgent = function () {
+ function InspectorAgent(eventSender) {
+ _classCallCheck(this, InspectorAgent);
+
+ this._eventSender = eventSender;
+ }
+
+ _createClass(InspectorAgent, [{
+ key: "sendEvent",
+ value: function sendEvent(name, params) {
+ this._eventSender(name, params);
+ }
+ }]);
+
+ return InspectorAgent;
+ }();
+
+ module.exports = InspectorAgent;
+},172,[3,4],"node_modules\\react-native\\Libraries\\JSInspector\\InspectorAgent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var invariant = _$$_REQUIRE(_dependencyMap[0], "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);
+
+ if (typeof callback !== 'function') {
+ invariant(false, 'View config not found for name %s.%s', name, typeof name[0] === 'string' && /[a-z]/.test(name[0]) ? ' Make sure to start component names with a capital letter.' : '');
+ }
+
+ viewConfigCallbacks.set(name, null);
+ viewConfig = callback();
+ processEventTypes(viewConfig);
+ viewConfigs.set(name, viewConfig);
+ } else {
+ viewConfig = viewConfigs.get(name);
+ }
+
+ invariant(viewConfig, 'View config not found for name %s', name);
+ return viewConfig;
+ };
+},173,[19],"node_modules\\react-native\\Libraries\\Renderer\\shims\\ReactNativeViewConfigRegistry.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var BatchedBridge = _$$_REQUIRE(_dependencyMap[0], "BatchedBridge");
+
+ var RCTEventEmitter = {
+ register: function register(eventEmitter) {
+ BatchedBridge.registerCallableModule('RCTEventEmitter', eventEmitter);
+ }
+ };
+ module.exports = RCTEventEmitter;
+},174,[41],"node_modules\\react-native\\Libraries\\EventEmitter\\RCTEventEmitter.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var deepDiffer = function deepDiffer(one, two) {
+ var maxDepth = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1;
+
+ if (maxDepth === 0) {
+ return true;
+ }
+
+ if (one === two) {
+ return false;
+ }
+
+ if (typeof one === 'function' && typeof two === 'function') {
+ return false;
+ }
+
+ if (typeof one !== 'object' || one === null) {
+ return one !== two;
+ }
+
+ if (typeof two !== 'object' || two === null) {
+ return true;
+ }
+
+ if (one.constructor !== two.constructor) {
+ return true;
+ }
+
+ if (Array.isArray(one)) {
+ var len = one.length;
+
+ if (two.length !== len) {
+ return true;
+ }
+
+ for (var ii = 0; ii < len; ii++) {
+ if (deepDiffer(one[ii], two[ii], maxDepth - 1)) {
+ return true;
+ }
+ }
+ } else {
+ for (var key in one) {
+ if (deepDiffer(one[key], two[key], maxDepth - 1)) {
+ return true;
+ }
+ }
+
+ for (var twoKey in two) {
+ if (one[twoKey] === undefined && two[twoKey] !== undefined) {
+ return true;
+ }
+ }
+ }
+
+ return false;
+ };
+
+ module.exports = deepDiffer;
+},175,[],"node_modules\\react-native\\Libraries\\Utilities\\differ\\deepDiffer.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var UIManager = _$$_REQUIRE(_dependencyMap[0], "UIManager");
+
+ var currentlyFocusedID = null;
+ var inputs = new Set();
+
+ function currentlyFocusedField() {
+ return currentlyFocusedID;
+ }
+
+ function focusTextInput(textFieldID) {
+ if (currentlyFocusedID !== textFieldID && textFieldID !== null) {
+ UIManager.focus(textFieldID);
+ }
+ }
+
+ function blurTextInput(textFieldID) {
+ if (currentlyFocusedID === textFieldID && textFieldID !== null) {
+ currentlyFocusedID = null;
+ UIManager.blur(textFieldID);
+ }
+ }
+
+ function setFocusedTextInput(textFieldID) {
+ if (currentlyFocusedID !== textFieldID && textFieldID !== null) {
+ currentlyFocusedID = textFieldID;
+ }
+ }
+
+ function clearFocusedTextInput(textFieldID) {
+ if (currentlyFocusedID === textFieldID && textFieldID !== null) {
+ currentlyFocusedID = null;
+ }
+ }
+
+ function registerInput(textFieldID) {
+ inputs.add(textFieldID);
+ }
+
+ function unregisterInput(textFieldID) {
+ inputs.delete(textFieldID);
+ }
+
+ function isTextInput(textFieldID) {
+ return inputs.has(textFieldID);
+ }
+
+ module.exports = {
+ currentlyFocusedField: currentlyFocusedField,
+ setFocusedTextInput: setFocusedTextInput,
+ clearFocusedTextInput: clearFocusedTextInput,
+ focusTextInput: focusTextInput,
+ blurTextInput: blurTextInput,
+ registerInput: registerInput,
+ unregisterInput: unregisterInput,
+ isTextInput: isTextInput
+ };
+},176,[71],"Libraries\\Components\\TextInput\\TextInputState.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ if (process.env.NODE_ENV === 'production') {
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "./cjs/scheduler-tracing.production.min.js");
+ } else {
+ module.exports = _$$_REQUIRE(_dependencyMap[1], "./cjs/scheduler-tracing.development.js");
+ }
+},177,[178,179],"node_modules\\react-native\\node_modules\\scheduler\\tracing.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ /** @license React v0.11.3
+ * scheduler-tracing.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+ 'use strict';
+
+ Object.defineProperty(exports, "__esModule", {
+ value: !0
+ });
+ var b = 0;
+ exports.__interactionsRef = null;
+ exports.__subscriberRef = null;
+
+ exports.unstable_clear = function (a) {
+ return a();
+ };
+
+ exports.unstable_getCurrent = function () {
+ return null;
+ };
+
+ exports.unstable_getThreadID = function () {
+ return ++b;
+ };
+
+ exports.unstable_trace = function (a, d, c) {
+ return c();
+ };
+
+ exports.unstable_wrap = function (a) {
+ return a;
+ };
+
+ exports.unstable_subscribe = function () {};
+
+ exports.unstable_unsubscribe = function () {};
+},178,[],"node_modules\\react-native\\node_modules\\scheduler\\cjs\\scheduler-tracing.production.min.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ /** @license React v0.11.3
+ * scheduler-tracing.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+ 'use strict';
+
+ if (process.env.NODE_ENV !== "production") {
+ (function () {
+ 'use strict';
+
+ Object.defineProperty(exports, '__esModule', {
+ value: true
+ });
+ var enableSchedulerTracing = true;
+ var DEFAULT_THREAD_ID = 0;
+ var interactionIDCounter = 0;
+ var threadIDCounter = 0;
+ exports.__interactionsRef = null;
+ exports.__subscriberRef = null;
+
+ if (enableSchedulerTracing) {
+ exports.__interactionsRef = {
+ current: new Set()
+ };
+ exports.__subscriberRef = {
+ current: null
+ };
+ }
+
+ function unstable_clear(callback) {
+ if (!enableSchedulerTracing) {
+ return callback();
+ }
+
+ var prevInteractions = exports.__interactionsRef.current;
+ exports.__interactionsRef.current = new Set();
+
+ try {
+ return callback();
+ } finally {
+ exports.__interactionsRef.current = prevInteractions;
+ }
+ }
+
+ function unstable_getCurrent() {
+ if (!enableSchedulerTracing) {
+ return null;
+ } else {
+ return exports.__interactionsRef.current;
+ }
+ }
+
+ function unstable_getThreadID() {
+ return ++threadIDCounter;
+ }
+
+ function unstable_trace(name, timestamp, callback) {
+ var threadID = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : DEFAULT_THREAD_ID;
+
+ if (!enableSchedulerTracing) {
+ return callback();
+ }
+
+ var interaction = {
+ __count: 1,
+ id: interactionIDCounter++,
+ name: name,
+ timestamp: timestamp
+ };
+ var prevInteractions = exports.__interactionsRef.current;
+ var interactions = new Set(prevInteractions);
+ interactions.add(interaction);
+ exports.__interactionsRef.current = interactions;
+ var subscriber = exports.__subscriberRef.current;
+ var returnValue = void 0;
+
+ try {
+ if (subscriber !== null) {
+ subscriber.onInteractionTraced(interaction);
+ }
+ } finally {
+ try {
+ if (subscriber !== null) {
+ subscriber.onWorkStarted(interactions, threadID);
+ }
+ } finally {
+ try {
+ returnValue = callback();
+ } finally {
+ exports.__interactionsRef.current = prevInteractions;
+
+ try {
+ if (subscriber !== null) {
+ subscriber.onWorkStopped(interactions, threadID);
+ }
+ } finally {
+ interaction.__count--;
+
+ if (subscriber !== null && interaction.__count === 0) {
+ subscriber.onInteractionScheduledWorkCompleted(interaction);
+ }
+ }
+ }
+ }
+ }
+
+ return returnValue;
+ }
+
+ function unstable_wrap(callback) {
+ var threadID = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : DEFAULT_THREAD_ID;
+
+ if (!enableSchedulerTracing) {
+ return callback;
+ }
+
+ var wrappedInteractions = exports.__interactionsRef.current;
+ var subscriber = exports.__subscriberRef.current;
+
+ if (subscriber !== null) {
+ subscriber.onWorkScheduled(wrappedInteractions, threadID);
+ }
+
+ wrappedInteractions.forEach(function (interaction) {
+ interaction.__count++;
+ });
+ var hasRun = false;
+
+ function wrapped() {
+ var prevInteractions = exports.__interactionsRef.current;
+ exports.__interactionsRef.current = wrappedInteractions;
+ subscriber = exports.__subscriberRef.current;
+
+ try {
+ var returnValue = void 0;
+
+ try {
+ if (subscriber !== null) {
+ subscriber.onWorkStarted(wrappedInteractions, threadID);
+ }
+ } finally {
+ try {
+ returnValue = callback.apply(undefined, arguments);
+ } finally {
+ exports.__interactionsRef.current = prevInteractions;
+
+ if (subscriber !== null) {
+ subscriber.onWorkStopped(wrappedInteractions, threadID);
+ }
+ }
+ }
+
+ return returnValue;
+ } finally {
+ if (!hasRun) {
+ hasRun = true;
+ wrappedInteractions.forEach(function (interaction) {
+ interaction.__count--;
+
+ if (subscriber !== null && interaction.__count === 0) {
+ subscriber.onInteractionScheduledWorkCompleted(interaction);
+ }
+ });
+ }
+ }
+ }
+
+ wrapped.cancel = function cancel() {
+ subscriber = exports.__subscriberRef.current;
+
+ try {
+ if (subscriber !== null) {
+ subscriber.onWorkCanceled(wrappedInteractions, threadID);
+ }
+ } finally {
+ wrappedInteractions.forEach(function (interaction) {
+ interaction.__count--;
+
+ if (subscriber && interaction.__count === 0) {
+ subscriber.onInteractionScheduledWorkCompleted(interaction);
+ }
+ });
+ }
+ };
+
+ return wrapped;
+ }
+
+ var subscribers = null;
+
+ if (enableSchedulerTracing) {
+ subscribers = new Set();
+ }
+
+ function unstable_subscribe(subscriber) {
+ if (enableSchedulerTracing) {
+ subscribers.add(subscriber);
+
+ if (subscribers.size === 1) {
+ exports.__subscriberRef.current = {
+ onInteractionScheduledWorkCompleted: onInteractionScheduledWorkCompleted,
+ onInteractionTraced: onInteractionTraced,
+ onWorkCanceled: onWorkCanceled,
+ onWorkScheduled: onWorkScheduled,
+ onWorkStarted: onWorkStarted,
+ onWorkStopped: onWorkStopped
+ };
+ }
+ }
+ }
+
+ function unstable_unsubscribe(subscriber) {
+ if (enableSchedulerTracing) {
+ subscribers.delete(subscriber);
+
+ if (subscribers.size === 0) {
+ exports.__subscriberRef.current = null;
+ }
+ }
+ }
+
+ function onInteractionTraced(interaction) {
+ var didCatchError = false;
+ var caughtError = null;
+ subscribers.forEach(function (subscriber) {
+ try {
+ subscriber.onInteractionTraced(interaction);
+ } catch (error) {
+ if (!didCatchError) {
+ didCatchError = true;
+ caughtError = error;
+ }
+ }
+ });
+
+ if (didCatchError) {
+ throw caughtError;
+ }
+ }
+
+ function onInteractionScheduledWorkCompleted(interaction) {
+ var didCatchError = false;
+ var caughtError = null;
+ subscribers.forEach(function (subscriber) {
+ try {
+ subscriber.onInteractionScheduledWorkCompleted(interaction);
+ } catch (error) {
+ if (!didCatchError) {
+ didCatchError = true;
+ caughtError = error;
+ }
+ }
+ });
+
+ if (didCatchError) {
+ throw caughtError;
+ }
+ }
+
+ function onWorkScheduled(interactions, threadID) {
+ var didCatchError = false;
+ var caughtError = null;
+ subscribers.forEach(function (subscriber) {
+ try {
+ subscriber.onWorkScheduled(interactions, threadID);
+ } catch (error) {
+ if (!didCatchError) {
+ didCatchError = true;
+ caughtError = error;
+ }
+ }
+ });
+
+ if (didCatchError) {
+ throw caughtError;
+ }
+ }
+
+ function onWorkStarted(interactions, threadID) {
+ var didCatchError = false;
+ var caughtError = null;
+ subscribers.forEach(function (subscriber) {
+ try {
+ subscriber.onWorkStarted(interactions, threadID);
+ } catch (error) {
+ if (!didCatchError) {
+ didCatchError = true;
+ caughtError = error;
+ }
+ }
+ });
+
+ if (didCatchError) {
+ throw caughtError;
+ }
+ }
+
+ function onWorkStopped(interactions, threadID) {
+ var didCatchError = false;
+ var caughtError = null;
+ subscribers.forEach(function (subscriber) {
+ try {
+ subscriber.onWorkStopped(interactions, threadID);
+ } catch (error) {
+ if (!didCatchError) {
+ didCatchError = true;
+ caughtError = error;
+ }
+ }
+ });
+
+ if (didCatchError) {
+ throw caughtError;
+ }
+ }
+
+ function onWorkCanceled(interactions, threadID) {
+ var didCatchError = false;
+ var caughtError = null;
+ subscribers.forEach(function (subscriber) {
+ try {
+ subscriber.onWorkCanceled(interactions, threadID);
+ } catch (error) {
+ if (!didCatchError) {
+ didCatchError = true;
+ caughtError = error;
+ }
+ }
+ });
+
+ if (didCatchError) {
+ throw caughtError;
+ }
+ }
+
+ exports.unstable_clear = unstable_clear;
+ exports.unstable_getCurrent = unstable_getCurrent;
+ exports.unstable_getThreadID = unstable_getThreadID;
+ exports.unstable_trace = unstable_trace;
+ exports.unstable_wrap = unstable_wrap;
+ exports.unstable_subscribe = unstable_subscribe;
+ exports.unstable_unsubscribe = unstable_unsubscribe;
+ })();
+ }
+},179,[],"node_modules\\react-native\\node_modules\\scheduler\\cjs\\scheduler-tracing.development.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ if (process.env.NODE_ENV === 'production') {
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "./cjs/scheduler.production.min.js");
+ } else {
+ module.exports = _$$_REQUIRE(_dependencyMap[1], "./cjs/scheduler.development.js");
+ }
+},180,[181,182],"node_modules\\react-native\\node_modules\\scheduler\\index.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ /** @license React v0.11.3
+ * scheduler.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+ 'use strict';
+
+ Object.defineProperty(exports, "__esModule", {
+ value: !0
+ });
+ var d = null,
+ f = !1,
+ h = 3,
+ k = -1,
+ l = -1,
+ m = !1,
+ n = !1;
+
+ function p() {
+ if (!m) {
+ var a = d.expirationTime;
+ n ? q() : n = !0;
+
+ _r(t, a);
+ }
+ }
+
+ function u() {
+ var a = d,
+ b = d.next;
+ if (d === b) d = null;else {
+ var c = d.previous;
+ d = c.next = b;
+ b.previous = c;
+ }
+ a.next = a.previous = null;
+ c = a.callback;
+ b = a.expirationTime;
+ a = a.priorityLevel;
+ var e = h,
+ Q = l;
+ h = a;
+ l = b;
+
+ try {
+ var g = c();
+ } finally {
+ h = e, l = Q;
+ }
+
+ if ("function" === typeof g) if (g = {
+ callback: g,
+ priorityLevel: a,
+ expirationTime: b,
+ next: null,
+ previous: null
+ }, null === d) d = g.next = g.previous = g;else {
+ c = null;
+ a = d;
+
+ do {
+ if (a.expirationTime >= b) {
+ c = a;
+ break;
+ }
+
+ a = a.next;
+ } while (a !== d);
+
+ null === c ? c = d : c === d && (d = g, p());
+ b = c.previous;
+ b.next = c.previous = g;
+ g.next = c;
+ g.previous = b;
+ }
+ }
+
+ function v() {
+ if (-1 === k && null !== d && 1 === d.priorityLevel) {
+ m = !0;
+
+ try {
+ do {
+ u();
+ } while (null !== d && 1 === d.priorityLevel);
+ } finally {
+ m = !1, null !== d ? p() : n = !1;
+ }
+ }
+ }
+
+ function t(a) {
+ m = !0;
+ var b = f;
+ f = a;
+
+ try {
+ if (a) for (; null !== d;) {
+ var c = exports.unstable_now();
+
+ if (d.expirationTime <= c) {
+ do {
+ u();
+ } while (null !== d && d.expirationTime <= c);
+ } else break;
+ } else if (null !== d) {
+ do {
+ u();
+ } while (null !== d && !w());
+ }
+ } finally {
+ m = !1, f = b, null !== d ? p() : n = !1, v();
+ }
+ }
+
+ var x = Date,
+ y = "function" === typeof setTimeout ? setTimeout : void 0,
+ z = "function" === typeof clearTimeout ? clearTimeout : void 0,
+ A = "function" === typeof requestAnimationFrame ? requestAnimationFrame : void 0,
+ B = "function" === typeof cancelAnimationFrame ? cancelAnimationFrame : void 0,
+ C,
+ D;
+
+ function E(a) {
+ C = A(function (b) {
+ z(D);
+ a(b);
+ });
+ D = y(function () {
+ B(C);
+ a(exports.unstable_now());
+ }, 100);
+ }
+
+ if ("object" === typeof performance && "function" === typeof performance.now) {
+ var F = performance;
+
+ exports.unstable_now = function () {
+ return F.now();
+ };
+ } else exports.unstable_now = function () {
+ return x.now();
+ };
+
+ var _r,
+ q,
+ w,
+ G = null;
+
+ "undefined" !== typeof window ? G = window : "undefined" !== typeof global && (G = global);
+
+ if (G && G._schedMock) {
+ var H = G._schedMock;
+ _r = H[0];
+ q = H[1];
+ w = H[2];
+ exports.unstable_now = H[3];
+ } else if ("undefined" === typeof window || "function" !== typeof MessageChannel) {
+ var I = null,
+ J = function J(a) {
+ if (null !== I) try {
+ I(a);
+ } finally {
+ I = null;
+ }
+ };
+
+ _r = function r(a) {
+ null !== I ? setTimeout(_r, 0, a) : (I = a, setTimeout(J, 0, !1));
+ };
+
+ q = function q() {
+ I = null;
+ };
+
+ w = function w() {
+ return !1;
+ };
+ } else {
+ "undefined" !== typeof console && ("function" !== typeof A && console.error("This browser doesn't support requestAnimationFrame. Make sure that you load a polyfill in older browsers. https://fb.me/react-polyfills"), "function" !== typeof B && console.error("This browser doesn't support cancelAnimationFrame. Make sure that you load a polyfill in older browsers. https://fb.me/react-polyfills"));
+ var K = null,
+ L = !1,
+ M = -1,
+ N = !1,
+ O = !1,
+ P = 0,
+ R = 33,
+ S = 33;
+
+ w = function w() {
+ return P <= exports.unstable_now();
+ };
+
+ var T = new MessageChannel(),
+ U = T.port2;
+
+ T.port1.onmessage = function () {
+ L = !1;
+ var a = K,
+ b = M;
+ K = null;
+ M = -1;
+ var c = exports.unstable_now(),
+ e = !1;
+ if (0 >= P - c) if (-1 !== b && b <= c) e = !0;else {
+ N || (N = !0, E(V));
+ K = a;
+ M = b;
+ return;
+ }
+
+ if (null !== a) {
+ O = !0;
+
+ try {
+ a(e);
+ } finally {
+ O = !1;
+ }
+ }
+ };
+
+ var V = function V(a) {
+ if (null !== K) {
+ E(V);
+ var b = a - P + S;
+ b < S && R < S ? (8 > b && (b = 8), S = b < R ? R : b) : R = b;
+ P = a + S;
+ L || (L = !0, U.postMessage(void 0));
+ } else N = !1;
+ };
+
+ _r = function _r(a, b) {
+ K = a;
+ M = b;
+ O || 0 > b ? U.postMessage(void 0) : N || (N = !0, E(V));
+ };
+
+ q = function q() {
+ K = null;
+ L = !1;
+ M = -1;
+ };
+ }
+
+ exports.unstable_ImmediatePriority = 1;
+ exports.unstable_UserBlockingPriority = 2;
+ exports.unstable_NormalPriority = 3;
+ exports.unstable_IdlePriority = 5;
+ exports.unstable_LowPriority = 4;
+
+ exports.unstable_runWithPriority = function (a, b) {
+ switch (a) {
+ case 1:
+ case 2:
+ case 3:
+ case 4:
+ case 5:
+ break;
+
+ default:
+ a = 3;
+ }
+
+ var c = h,
+ e = k;
+ h = a;
+ k = exports.unstable_now();
+
+ try {
+ return b();
+ } finally {
+ h = c, k = e, v();
+ }
+ };
+
+ exports.unstable_scheduleCallback = function (a, b) {
+ var c = -1 !== k ? k : exports.unstable_now();
+ if ("object" === typeof b && null !== b && "number" === typeof b.timeout) b = c + b.timeout;else switch (h) {
+ case 1:
+ b = c + -1;
+ break;
+
+ case 2:
+ b = c + 250;
+ break;
+
+ case 5:
+ b = c + 1073741823;
+ break;
+
+ case 4:
+ b = c + 1E4;
+ break;
+
+ default:
+ b = c + 5E3;
+ }
+ a = {
+ callback: a,
+ priorityLevel: h,
+ expirationTime: b,
+ next: null,
+ previous: null
+ };
+ if (null === d) d = a.next = a.previous = a, p();else {
+ c = null;
+ var e = d;
+
+ do {
+ if (e.expirationTime > b) {
+ c = e;
+ break;
+ }
+
+ e = e.next;
+ } while (e !== d);
+
+ null === c ? c = d : c === d && (d = a, p());
+ b = c.previous;
+ b.next = c.previous = a;
+ a.next = c;
+ a.previous = b;
+ }
+ return a;
+ };
+
+ exports.unstable_cancelCallback = function (a) {
+ var b = a.next;
+
+ if (null !== b) {
+ if (b === a) d = null;else {
+ a === d && (d = b);
+ var c = a.previous;
+ c.next = b;
+ b.previous = c;
+ }
+ a.next = a.previous = null;
+ }
+ };
+
+ exports.unstable_wrapCallback = function (a) {
+ var b = h;
+ return function () {
+ var c = h,
+ e = k;
+ h = b;
+ k = exports.unstable_now();
+
+ try {
+ return a.apply(this, arguments);
+ } finally {
+ h = c, k = e, v();
+ }
+ };
+ };
+
+ exports.unstable_getCurrentPriorityLevel = function () {
+ return h;
+ };
+
+ exports.unstable_shouldYield = function () {
+ return !f && (null !== d && d.expirationTime < l || w());
+ };
+},181,[],"node_modules\\react-native\\node_modules\\scheduler\\cjs\\scheduler.production.min.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ /** @license React v0.11.3
+ * scheduler.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+ 'use strict';
+
+ if (process.env.NODE_ENV !== "production") {
+ (function () {
+ 'use strict';
+
+ Object.defineProperty(exports, '__esModule', {
+ value: true
+ });
+ var ImmediatePriority = 1;
+ var UserBlockingPriority = 2;
+ var NormalPriority = 3;
+ var LowPriority = 4;
+ var IdlePriority = 5;
+ var maxSigned31BitInt = 1073741823;
+ var IMMEDIATE_PRIORITY_TIMEOUT = -1;
+ var USER_BLOCKING_PRIORITY = 250;
+ var NORMAL_PRIORITY_TIMEOUT = 5000;
+ var LOW_PRIORITY_TIMEOUT = 10000;
+ var IDLE_PRIORITY = maxSigned31BitInt;
+ var firstCallbackNode = null;
+ var currentDidTimeout = false;
+ var currentPriorityLevel = NormalPriority;
+ var currentEventStartTime = -1;
+ var currentExpirationTime = -1;
+ var isExecutingCallback = false;
+ var isHostCallbackScheduled = false;
+ var hasNativePerformanceNow = typeof performance === 'object' && typeof performance.now === 'function';
+
+ function ensureHostCallbackIsScheduled() {
+ if (isExecutingCallback) {
+ return;
+ }
+
+ var expirationTime = firstCallbackNode.expirationTime;
+
+ if (!isHostCallbackScheduled) {
+ isHostCallbackScheduled = true;
+ } else {
+ cancelHostCallback();
+ }
+
+ _requestHostCallback(flushWork, expirationTime);
+ }
+
+ function flushFirstCallback() {
+ var flushedNode = firstCallbackNode;
+ var next = firstCallbackNode.next;
+
+ if (firstCallbackNode === next) {
+ firstCallbackNode = null;
+ next = null;
+ } else {
+ var lastCallbackNode = firstCallbackNode.previous;
+ firstCallbackNode = lastCallbackNode.next = next;
+ next.previous = lastCallbackNode;
+ }
+
+ flushedNode.next = flushedNode.previous = null;
+ var callback = flushedNode.callback;
+ var expirationTime = flushedNode.expirationTime;
+ var priorityLevel = flushedNode.priorityLevel;
+ var previousPriorityLevel = currentPriorityLevel;
+ var previousExpirationTime = currentExpirationTime;
+ currentPriorityLevel = priorityLevel;
+ currentExpirationTime = expirationTime;
+ var continuationCallback;
+
+ try {
+ continuationCallback = callback();
+ } finally {
+ currentPriorityLevel = previousPriorityLevel;
+ currentExpirationTime = previousExpirationTime;
+ }
+
+ if (typeof continuationCallback === 'function') {
+ var continuationNode = {
+ callback: continuationCallback,
+ priorityLevel: priorityLevel,
+ expirationTime: expirationTime,
+ next: null,
+ previous: null
+ };
+
+ if (firstCallbackNode === null) {
+ firstCallbackNode = continuationNode.next = continuationNode.previous = continuationNode;
+ } else {
+ var nextAfterContinuation = null;
+ var node = firstCallbackNode;
+
+ do {
+ if (node.expirationTime >= expirationTime) {
+ nextAfterContinuation = node;
+ break;
+ }
+
+ node = node.next;
+ } while (node !== firstCallbackNode);
+
+ if (nextAfterContinuation === null) {
+ nextAfterContinuation = firstCallbackNode;
+ } else if (nextAfterContinuation === firstCallbackNode) {
+ firstCallbackNode = continuationNode;
+ ensureHostCallbackIsScheduled();
+ }
+
+ var previous = nextAfterContinuation.previous;
+ previous.next = nextAfterContinuation.previous = continuationNode;
+ continuationNode.next = nextAfterContinuation;
+ continuationNode.previous = previous;
+ }
+ }
+ }
+
+ function flushImmediateWork() {
+ if (currentEventStartTime === -1 && firstCallbackNode !== null && firstCallbackNode.priorityLevel === ImmediatePriority) {
+ isExecutingCallback = true;
+
+ try {
+ do {
+ flushFirstCallback();
+ } while (firstCallbackNode !== null && firstCallbackNode.priorityLevel === ImmediatePriority);
+ } finally {
+ isExecutingCallback = false;
+
+ if (firstCallbackNode !== null) {
+ ensureHostCallbackIsScheduled();
+ } else {
+ isHostCallbackScheduled = false;
+ }
+ }
+ }
+ }
+
+ function flushWork(didTimeout) {
+ isExecutingCallback = true;
+ var previousDidTimeout = currentDidTimeout;
+ currentDidTimeout = didTimeout;
+
+ try {
+ if (didTimeout) {
+ while (firstCallbackNode !== null) {
+ var currentTime = exports.unstable_now();
+
+ if (firstCallbackNode.expirationTime <= currentTime) {
+ do {
+ flushFirstCallback();
+ } while (firstCallbackNode !== null && firstCallbackNode.expirationTime <= currentTime);
+
+ continue;
+ }
+
+ break;
+ }
+ } else {
+ if (firstCallbackNode !== null) {
+ do {
+ flushFirstCallback();
+ } while (firstCallbackNode !== null && !shouldYieldToHost());
+ }
+ }
+ } finally {
+ isExecutingCallback = false;
+ currentDidTimeout = previousDidTimeout;
+
+ if (firstCallbackNode !== null) {
+ ensureHostCallbackIsScheduled();
+ } else {
+ isHostCallbackScheduled = false;
+ }
+
+ flushImmediateWork();
+ }
+ }
+
+ function unstable_runWithPriority(priorityLevel, eventHandler) {
+ switch (priorityLevel) {
+ case ImmediatePriority:
+ case UserBlockingPriority:
+ case NormalPriority:
+ case LowPriority:
+ case IdlePriority:
+ break;
+
+ default:
+ priorityLevel = NormalPriority;
+ }
+
+ var previousPriorityLevel = currentPriorityLevel;
+ var previousEventStartTime = currentEventStartTime;
+ currentPriorityLevel = priorityLevel;
+ currentEventStartTime = exports.unstable_now();
+
+ try {
+ return eventHandler();
+ } finally {
+ currentPriorityLevel = previousPriorityLevel;
+ currentEventStartTime = previousEventStartTime;
+ flushImmediateWork();
+ }
+ }
+
+ function unstable_wrapCallback(callback) {
+ var parentPriorityLevel = currentPriorityLevel;
+ return function () {
+ var previousPriorityLevel = currentPriorityLevel;
+ var previousEventStartTime = currentEventStartTime;
+ currentPriorityLevel = parentPriorityLevel;
+ currentEventStartTime = exports.unstable_now();
+
+ try {
+ return callback.apply(this, arguments);
+ } finally {
+ currentPriorityLevel = previousPriorityLevel;
+ currentEventStartTime = previousEventStartTime;
+ flushImmediateWork();
+ }
+ };
+ }
+
+ function unstable_scheduleCallback(callback, deprecated_options) {
+ var startTime = currentEventStartTime !== -1 ? currentEventStartTime : exports.unstable_now();
+ var expirationTime;
+
+ if (typeof deprecated_options === 'object' && deprecated_options !== null && typeof deprecated_options.timeout === 'number') {
+ expirationTime = startTime + deprecated_options.timeout;
+ } else {
+ switch (currentPriorityLevel) {
+ case ImmediatePriority:
+ expirationTime = startTime + IMMEDIATE_PRIORITY_TIMEOUT;
+ break;
+
+ case UserBlockingPriority:
+ expirationTime = startTime + USER_BLOCKING_PRIORITY;
+ break;
+
+ case IdlePriority:
+ expirationTime = startTime + IDLE_PRIORITY;
+ break;
+
+ case LowPriority:
+ expirationTime = startTime + LOW_PRIORITY_TIMEOUT;
+ break;
+
+ case NormalPriority:
+ default:
+ expirationTime = startTime + NORMAL_PRIORITY_TIMEOUT;
+ }
+ }
+
+ var newNode = {
+ callback: callback,
+ priorityLevel: currentPriorityLevel,
+ expirationTime: expirationTime,
+ next: null,
+ previous: null
+ };
+
+ if (firstCallbackNode === null) {
+ firstCallbackNode = newNode.next = newNode.previous = newNode;
+ ensureHostCallbackIsScheduled();
+ } else {
+ var next = null;
+ var node = firstCallbackNode;
+
+ do {
+ if (node.expirationTime > expirationTime) {
+ next = node;
+ break;
+ }
+
+ node = node.next;
+ } while (node !== firstCallbackNode);
+
+ if (next === null) {
+ next = firstCallbackNode;
+ } else if (next === firstCallbackNode) {
+ firstCallbackNode = newNode;
+ ensureHostCallbackIsScheduled();
+ }
+
+ var previous = next.previous;
+ previous.next = next.previous = newNode;
+ newNode.next = next;
+ newNode.previous = previous;
+ }
+
+ return newNode;
+ }
+
+ function unstable_cancelCallback(callbackNode) {
+ var next = callbackNode.next;
+
+ if (next === null) {
+ return;
+ }
+
+ if (next === callbackNode) {
+ firstCallbackNode = null;
+ } else {
+ if (callbackNode === firstCallbackNode) {
+ firstCallbackNode = next;
+ }
+
+ var previous = callbackNode.previous;
+ previous.next = next;
+ next.previous = previous;
+ }
+
+ callbackNode.next = callbackNode.previous = null;
+ }
+
+ function unstable_getCurrentPriorityLevel() {
+ return currentPriorityLevel;
+ }
+
+ function unstable_shouldYield() {
+ return !currentDidTimeout && (firstCallbackNode !== null && firstCallbackNode.expirationTime < currentExpirationTime || shouldYieldToHost());
+ }
+
+ var localDate = Date;
+ var localSetTimeout = typeof setTimeout === 'function' ? setTimeout : undefined;
+ var localClearTimeout = typeof clearTimeout === 'function' ? clearTimeout : undefined;
+ var localRequestAnimationFrame = typeof requestAnimationFrame === 'function' ? requestAnimationFrame : undefined;
+ var localCancelAnimationFrame = typeof cancelAnimationFrame === 'function' ? cancelAnimationFrame : undefined;
+ var ANIMATION_FRAME_TIMEOUT = 100;
+ var rAFID;
+ var rAFTimeoutID;
+
+ var requestAnimationFrameWithTimeout = function requestAnimationFrameWithTimeout(callback) {
+ rAFID = localRequestAnimationFrame(function (timestamp) {
+ localClearTimeout(rAFTimeoutID);
+ callback(timestamp);
+ });
+ rAFTimeoutID = localSetTimeout(function () {
+ localCancelAnimationFrame(rAFID);
+ callback(exports.unstable_now());
+ }, ANIMATION_FRAME_TIMEOUT);
+ };
+
+ if (hasNativePerformanceNow) {
+ var Performance = performance;
+
+ exports.unstable_now = function () {
+ return Performance.now();
+ };
+ } else {
+ exports.unstable_now = function () {
+ return localDate.now();
+ };
+ }
+
+ var _requestHostCallback;
+
+ var cancelHostCallback;
+ var shouldYieldToHost;
+ var globalValue = null;
+
+ if (typeof window !== 'undefined') {
+ globalValue = window;
+ } else if (typeof global !== 'undefined') {
+ globalValue = global;
+ }
+
+ if (globalValue && globalValue._schedMock) {
+ var globalImpl = globalValue._schedMock;
+ _requestHostCallback = globalImpl[0];
+ cancelHostCallback = globalImpl[1];
+ shouldYieldToHost = globalImpl[2];
+ exports.unstable_now = globalImpl[3];
+ } else if (typeof window === 'undefined' || typeof MessageChannel !== 'function') {
+ var _callback = null;
+
+ var _flushCallback = function _flushCallback(didTimeout) {
+ if (_callback !== null) {
+ try {
+ _callback(didTimeout);
+ } finally {
+ _callback = null;
+ }
+ }
+ };
+
+ _requestHostCallback = function requestHostCallback(cb, ms) {
+ if (_callback !== null) {
+ setTimeout(_requestHostCallback, 0, cb);
+ } else {
+ _callback = cb;
+ setTimeout(_flushCallback, 0, false);
+ }
+ };
+
+ cancelHostCallback = function cancelHostCallback() {
+ _callback = null;
+ };
+
+ shouldYieldToHost = function shouldYieldToHost() {
+ return false;
+ };
+ } else {
+ if (typeof console !== 'undefined') {
+ if (typeof localRequestAnimationFrame !== 'function') {
+ console.error("This browser doesn't support requestAnimationFrame. " + 'Make sure that you load a ' + 'polyfill in older browsers. https://fb.me/react-polyfills');
+ }
+
+ if (typeof localCancelAnimationFrame !== 'function') {
+ console.error("This browser doesn't support cancelAnimationFrame. " + 'Make sure that you load a ' + 'polyfill in older browsers. https://fb.me/react-polyfills');
+ }
+ }
+
+ var scheduledHostCallback = null;
+ var isMessageEventScheduled = false;
+ var timeoutTime = -1;
+ var isAnimationFrameScheduled = false;
+ var isFlushingHostCallback = false;
+ var frameDeadline = 0;
+ var previousFrameTime = 33;
+ var activeFrameTime = 33;
+
+ shouldYieldToHost = function shouldYieldToHost() {
+ return frameDeadline <= exports.unstable_now();
+ };
+
+ var channel = new MessageChannel();
+ var port = channel.port2;
+
+ channel.port1.onmessage = function (event) {
+ isMessageEventScheduled = false;
+ var prevScheduledCallback = scheduledHostCallback;
+ var prevTimeoutTime = timeoutTime;
+ scheduledHostCallback = null;
+ timeoutTime = -1;
+ var currentTime = exports.unstable_now();
+ var didTimeout = false;
+
+ if (frameDeadline - currentTime <= 0) {
+ if (prevTimeoutTime !== -1 && prevTimeoutTime <= currentTime) {
+ didTimeout = true;
+ } else {
+ if (!isAnimationFrameScheduled) {
+ isAnimationFrameScheduled = true;
+ requestAnimationFrameWithTimeout(animationTick);
+ }
+
+ scheduledHostCallback = prevScheduledCallback;
+ timeoutTime = prevTimeoutTime;
+ return;
+ }
+ }
+
+ if (prevScheduledCallback !== null) {
+ isFlushingHostCallback = true;
+
+ try {
+ prevScheduledCallback(didTimeout);
+ } finally {
+ isFlushingHostCallback = false;
+ }
+ }
+ };
+
+ var animationTick = function animationTick(rafTime) {
+ if (scheduledHostCallback !== null) {
+ requestAnimationFrameWithTimeout(animationTick);
+ } else {
+ isAnimationFrameScheduled = false;
+ return;
+ }
+
+ var nextFrameTime = rafTime - frameDeadline + activeFrameTime;
+
+ if (nextFrameTime < activeFrameTime && previousFrameTime < activeFrameTime) {
+ if (nextFrameTime < 8) {
+ nextFrameTime = 8;
+ }
+
+ activeFrameTime = nextFrameTime < previousFrameTime ? previousFrameTime : nextFrameTime;
+ } else {
+ previousFrameTime = nextFrameTime;
+ }
+
+ frameDeadline = rafTime + activeFrameTime;
+
+ if (!isMessageEventScheduled) {
+ isMessageEventScheduled = true;
+ port.postMessage(undefined);
+ }
+ };
+
+ _requestHostCallback = function _requestHostCallback(callback, absoluteTimeout) {
+ scheduledHostCallback = callback;
+ timeoutTime = absoluteTimeout;
+
+ if (isFlushingHostCallback || absoluteTimeout < 0) {
+ port.postMessage(undefined);
+ } else if (!isAnimationFrameScheduled) {
+ isAnimationFrameScheduled = true;
+ requestAnimationFrameWithTimeout(animationTick);
+ }
+ };
+
+ cancelHostCallback = function cancelHostCallback() {
+ scheduledHostCallback = null;
+ isMessageEventScheduled = false;
+ timeoutTime = -1;
+ };
+ }
+
+ exports.unstable_ImmediatePriority = ImmediatePriority;
+ exports.unstable_UserBlockingPriority = UserBlockingPriority;
+ exports.unstable_NormalPriority = NormalPriority;
+ exports.unstable_IdlePriority = IdlePriority;
+ exports.unstable_LowPriority = LowPriority;
+ exports.unstable_runWithPriority = unstable_runWithPriority;
+ exports.unstable_scheduleCallback = unstable_scheduleCallback;
+ exports.unstable_cancelCallback = unstable_cancelCallback;
+ exports.unstable_wrapCallback = unstable_wrapCallback;
+ exports.unstable_getCurrentPriorityLevel = unstable_getCurrentPriorityLevel;
+ exports.unstable_shouldYield = unstable_shouldYield;
+ })();
+ }
+},182,[],"node_modules\\react-native\\node_modules\\scheduler\\cjs\\scheduler.development.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ "use strict";
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ _$$_REQUIRE(_dependencyMap[1], "InitializeCore");
+
+ var ReactNativeViewConfigRegistry = _$$_REQUIRE(_dependencyMap[2], "ReactNativeViewConfigRegistry"),
+ UIManager = _$$_REQUIRE(_dependencyMap[3], "UIManager"),
+ RCTEventEmitter = _$$_REQUIRE(_dependencyMap[4], "RCTEventEmitter"),
+ React = _$$_REQUIRE(_dependencyMap[5], "react"),
+ deepDiffer = _$$_REQUIRE(_dependencyMap[6], "deepDiffer"),
+ flattenStyle = _$$_REQUIRE(_dependencyMap[7], "flattenStyle"),
+ TextInputState = _$$_REQUIRE(_dependencyMap[8], "TextInputState");
+
+ var scheduler = _$$_REQUIRE(_dependencyMap[9], "scheduler"),
+ ExceptionsManager = _$$_REQUIRE(_dependencyMap[10], "ExceptionsManager");
+
+ function invariant(condition, format, a, b, c, d, e, f) {
+ if (!condition) {
+ condition = void 0;
+ if (void 0 === format) condition = 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],
+ argIndex = 0;
+ condition = Error(format.replace(/%s/g, function () {
+ return args[argIndex++];
+ }));
+ condition.name = "Invariant Violation";
+ }
+ condition.framesToPop = 1;
+ throw condition;
+ }
+ }
+
+ function invokeGuardedCallbackImpl(name, func, context, a, b, c, d, e, f) {
+ var funcArgs = Array.prototype.slice.call(arguments, 3);
+
+ try {
+ func.apply(context, funcArgs);
+ } catch (error) {
+ this.onError(error);
+ }
+ }
+
+ var hasError = !1,
+ caughtError = null,
+ hasRethrowError = !1,
+ rethrowError = null,
+ reporter = {
+ onError: function onError(error) {
+ hasError = !0;
+ caughtError = error;
+ }
+ };
+
+ function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
+ hasError = !1;
+ caughtError = null;
+ invokeGuardedCallbackImpl.apply(reporter, arguments);
+ }
+
+ function invokeGuardedCallbackAndCatchFirstError(name, func, context, a, b, c, d, e, f) {
+ invokeGuardedCallback.apply(this, arguments);
+
+ if (hasError) {
+ if (hasError) {
+ var error = caughtError;
+ hasError = !1;
+ caughtError = null;
+ } else invariant(!1, "clearCaughtError was called but no error was captured. This error is likely caused by a bug in React. Please file an issue."), error = void 0;
+
+ hasRethrowError || (hasRethrowError = !0, rethrowError = 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, listener, inst) {
+ var type = event.type || "unknown-event";
+ event.currentTarget = getNodeFromInstance(inst);
+ invokeGuardedCallbackAndCatchFirstError(type, listener, void 0, event);
+ event.currentTarget = null;
+ }
+
+ function executeDirectDispatch(event) {
+ var dispatchListener = event._dispatchListeners,
+ dispatchInstance = event._dispatchInstances;
+ 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, dispatchListeners[i], dispatchInstances[i]);
+ } else dispatchListeners && executeDispatch(e, dispatchListeners, dispatchInstances);
+ e._dispatchListeners = null;
+ e._dispatchInstances = null;
+ e.isPersistent() || e.constructor.release(e);
+ }
+ }
+
+ var injection = {
+ injectEventPluginOrder: function injectEventPluginOrder(injectedEventPluginOrder) {
+ 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));
+ }
+ }
+ }
+
+ function functionThatReturnsTrue() {
+ return !0;
+ }
+
+ function functionThatReturnsFalse() {
+ return !1;
+ }
+
+ function SyntheticEvent(dispatchConfig, targetInst, nativeEvent, nativeEventTarget) {
+ this.dispatchConfig = dispatchConfig;
+ this._targetInst = targetInst;
+ this.nativeEvent = nativeEvent;
+ dispatchConfig = this.constructor.Interface;
+
+ for (var propName in dispatchConfig) {
+ dispatchConfig.hasOwnProperty(propName) && ((targetInst = dispatchConfig[propName]) ? this[propName] = targetInst(nativeEvent) : "target" === propName ? this.target = nativeEventTarget : this[propName] = nativeEvent[propName]);
+ }
+
+ this.isDefaultPrevented = (null != nativeEvent.defaultPrevented ? nativeEvent.defaultPrevented : !1 === nativeEvent.returnValue) ? functionThatReturnsTrue : functionThatReturnsFalse;
+ this.isPropagationStopped = functionThatReturnsFalse;
+ return this;
+ }
+
+ _extends(SyntheticEvent.prototype, {
+ preventDefault: function preventDefault() {
+ this.defaultPrevented = !0;
+ var event = this.nativeEvent;
+ event && (event.preventDefault ? event.preventDefault() : "unknown" !== typeof event.returnValue && (event.returnValue = !1), this.isDefaultPrevented = functionThatReturnsTrue);
+ },
+ stopPropagation: function stopPropagation() {
+ var event = this.nativeEvent;
+ event && (event.stopPropagation ? event.stopPropagation() : "unknown" !== typeof event.cancelBubble && (event.cancelBubble = !0), this.isPropagationStopped = functionThatReturnsTrue);
+ },
+ persist: function persist() {
+ this.isPersistent = functionThatReturnsTrue;
+ },
+ isPersistent: functionThatReturnsFalse,
+ destructor: function destructor() {
+ var Interface = this.constructor.Interface,
+ propName;
+
+ for (propName in Interface) {
+ this[propName] = null;
+ }
+
+ this.nativeEvent = this._targetInst = this.dispatchConfig = null;
+ this.isPropagationStopped = this.isDefaultPrevented = functionThatReturnsFalse;
+ this._dispatchInstances = this._dispatchListeners = null;
+ }
+ });
+
+ SyntheticEvent.Interface = {
+ type: null,
+ target: null,
+ currentTarget: function currentTarget() {
+ return null;
+ },
+ eventPhase: null,
+ bubbles: null,
+ cancelable: null,
+ timeStamp: function timeStamp(event) {
+ return event.timeStamp || Date.now();
+ },
+ defaultPrevented: null,
+ isTrusted: null
+ };
+
+ SyntheticEvent.extend = function (Interface) {
+ function E() {}
+
+ function Class() {
+ return Super.apply(this, arguments);
+ }
+
+ var Super = this;
+ E.prototype = Super.prototype;
+ var prototype = new E();
+
+ _extends(prototype, Class.prototype);
+
+ Class.prototype = prototype;
+ Class.prototype.constructor = Class;
+ Class.Interface = _extends({}, Super.Interface, Interface);
+ Class.extend = Super.extend;
+ addEventPoolingTo(Class);
+ return Class;
+ };
+
+ addEventPoolingTo(SyntheticEvent);
+
+ function getPooledEvent(dispatchConfig, targetInst, nativeEvent, nativeInst) {
+ if (this.eventPool.length) {
+ var instance = this.eventPool.pop();
+ this.call(instance, dispatchConfig, targetInst, nativeEvent, nativeInst);
+ return instance;
+ }
+
+ return new this(dispatchConfig, targetInst, nativeEvent, nativeInst);
+ }
+
+ function releasePooledEvent(event) {
+ 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;
+ }
+ }
+ },
+ ReactNativeBridgeEventPlugin = {
+ eventTypes: ReactNativeViewConfigRegistry.eventTypes,
+ extractEvents: function extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+ if (null == targetInst) return null;
+ var bubbleDispatchConfig = ReactNativeViewConfigRegistry.customBubblingEventTypes[topLevelType],
+ directDispatchConfig = ReactNativeViewConfigRegistry.customDirectEventTypes[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 getInstanceFromTag(tag) {
+ return instanceCache[tag] || null;
+ }
+
+ var restoreTarget = null,
+ restoreQueue = null;
+
+ function restoreStateOfTarget(target) {
+ if (target = getInstanceFromNode(target)) {
+ invariant(!1, "setRestoreImplementation() needs to be called to handle a target for controlled events. This error is likely caused by a bug in React. Please file an issue.");
+ var props = getFiberCurrentPropsFromNode(target.stateNode);
+ null(target.stateNode, target.type, props);
+ }
+ }
+
+ function _batchedUpdatesImpl(fn, bookkeeping) {
+ return fn(bookkeeping);
+ }
+
+ function _flushInteractiveUpdatesImpl() {}
+
+ var isBatching = !1;
+
+ function batchedUpdates(fn, bookkeeping) {
+ if (isBatching) return fn(bookkeeping);
+ isBatching = !0;
+
+ try {
+ return _batchedUpdatesImpl(fn, bookkeeping);
+ } finally {
+ if (isBatching = !1, null !== restoreTarget || null !== restoreQueue) if (_flushInteractiveUpdatesImpl(), restoreTarget && (bookkeeping = restoreTarget, fn = restoreQueue, restoreQueue = restoreTarget = null, restoreStateOfTarget(bookkeeping), fn)) for (bookkeeping = 0; bookkeeping < fn.length; bookkeeping++) {
+ restoreStateOfTarget(fn[bookkeeping]);
+ }
+ }
+ }
+
+ var EMPTY_NATIVE_EVENT = {};
+
+ function _receiveRootNodeIDEvent(rootNodeID, topLevelType, nativeEventParam) {
+ var nativeEvent = nativeEventParam || EMPTY_NATIVE_EVENT,
+ inst = getInstanceFromTag(rootNodeID);
+ batchedUpdates(function () {
+ var events = nativeEvent.target;
+
+ for (var events$jscomp$0 = null, i = 0; i < plugins.length; i++) {
+ var possiblePlugin = plugins[i];
+ possiblePlugin && (possiblePlugin = possiblePlugin.extractEvents(topLevelType, inst, nativeEvent, events)) && (events$jscomp$0 = accumulateInto(events$jscomp$0, possiblePlugin));
+ }
+
+ events = events$jscomp$0;
+ null !== events && (eventQueue = accumulateInto(eventQueue, events));
+ events = eventQueue;
+ eventQueue = null;
+ if (events && (forEachAccumulated(events, executeDispatchesAndReleaseTopLevel), invariant(!eventQueue, "processEventQueue(): Additional events were enqueued while processing an event queue. Support for this has not yet been implemented."), hasRethrowError)) throw events = rethrowError, hasRethrowError = !1, rethrowError = null, events;
+ });
+ }
+
+ RCTEventEmitter.register({
+ receiveEvent: function receiveEvent(rootNodeID, topLevelType, nativeEventParam) {
+ _receiveRootNodeIDEvent(rootNodeID, topLevelType, nativeEventParam);
+ },
+ receiveTouches: function receiveTouches(eventTopLevelType, touches, changedIndices) {
+ if ("topTouchEnd" === eventTopLevelType || "topTouchCancel" === eventTopLevelType) {
+ var JSCompiler_temp = [];
+
+ for (var i = 0; i < changedIndices.length; i++) {
+ var index = changedIndices[i];
+ JSCompiler_temp.push(touches[index]);
+ touches[index] = null;
+ }
+
+ for (i = changedIndices = 0; i < touches.length; i++) {
+ index = touches[i], null !== index && (touches[changedIndices++] = index);
+ }
+
+ touches.length = changedIndices;
+ } else for (JSCompiler_temp = [], i = 0; i < changedIndices.length; i++) {
+ JSCompiler_temp.push(touches[changedIndices[i]]);
+ }
+
+ for (changedIndices = 0; changedIndices < JSCompiler_temp.length; changedIndices++) {
+ i = JSCompiler_temp[changedIndices];
+ i.changedTouches = JSCompiler_temp;
+ i.touches = touches;
+ index = null;
+ var target = i.target;
+ null === target || void 0 === target || 1 > target || (index = target);
+
+ _receiveRootNodeIDEvent(index, eventTopLevelType, i);
+ }
+ }
+ });
+
+ getFiberCurrentPropsFromNode = function getFiberCurrentPropsFromNode(stateNode) {
+ return instanceProps[stateNode._nativeTag] || null;
+ };
+
+ 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;
+ };
+
+ ResponderEventPlugin.injection.injectGlobalResponderHandler({
+ onChange: function onChange(from, to, blockNativeResponder) {
+ null !== to ? UIManager.setJSResponder(to.stateNode._nativeTag, blockNativeResponder) : UIManager.clearJSResponder();
+ }
+ });
+ var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+ ReactSharedInternals.hasOwnProperty("ReactCurrentDispatcher") || (ReactSharedInternals.ReactCurrentDispatcher = {
+ current: null
+ });
+ var hasSymbol = "function" === typeof Symbol && (typeof Symbol === "function" ? Symbol.for : "@@for"),
+ REACT_ELEMENT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.element") : 60103,
+ REACT_PORTAL_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.portal") : 60106,
+ REACT_FRAGMENT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.fragment") : 60107,
+ REACT_STRICT_MODE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.strict_mode") : 60108,
+ REACT_PROFILER_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.profiler") : 60114,
+ REACT_PROVIDER_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.provider") : 60109,
+ REACT_CONTEXT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.context") : 60110,
+ REACT_CONCURRENT_MODE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.concurrent_mode") : 60111,
+ REACT_FORWARD_REF_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.forward_ref") : 60112,
+ REACT_SUSPENSE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.suspense") : 60113,
+ REACT_MEMO_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.memo") : 60115,
+ REACT_LAZY_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.lazy") : 60116,
+ MAYBE_ITERATOR_SYMBOL = "function" === typeof Symbol && (typeof Symbol === "function" ? Symbol.iterator : "@@iterator");
+
+ function getIteratorFn(maybeIterable) {
+ if (null === maybeIterable || "object" !== typeof maybeIterable) return null;
+ maybeIterable = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable["@@iterator"];
+ return "function" === typeof maybeIterable ? maybeIterable : null;
+ }
+
+ function getComponentName(type) {
+ if (null == type) return null;
+ if ("function" === typeof type) return type.displayName || type.name || null;
+ if ("string" === typeof type) return type;
+
+ switch (type) {
+ case REACT_CONCURRENT_MODE_TYPE:
+ return "ConcurrentMode";
+
+ case REACT_FRAGMENT_TYPE:
+ return "Fragment";
+
+ case REACT_PORTAL_TYPE:
+ return "Portal";
+
+ case REACT_PROFILER_TYPE:
+ return "Profiler";
+
+ case REACT_STRICT_MODE_TYPE:
+ return "StrictMode";
+
+ case REACT_SUSPENSE_TYPE:
+ return "Suspense";
+ }
+
+ if ("object" === typeof type) switch (type.$$typeof) {
+ case REACT_CONTEXT_TYPE:
+ return "Context.Consumer";
+
+ case REACT_PROVIDER_TYPE:
+ return "Context.Provider";
+
+ case REACT_FORWARD_REF_TYPE:
+ var innerType = type.render;
+ innerType = innerType.displayName || innerType.name || "";
+ return type.displayName || ("" !== innerType ? "ForwardRef(" + innerType + ")" : "ForwardRef");
+
+ case REACT_MEMO_TYPE:
+ return getComponentName(type.type);
+
+ case REACT_LAZY_TYPE:
+ if (type = 1 === type._status ? type._result : null) return getComponentName(type);
+ }
+ return null;
+ }
+
+ function isFiberMountedImpl(fiber) {
+ var node = fiber;
+ if (fiber.alternate) for (; node.return;) {
+ node = node.return;
+ } else {
+ if (0 !== (node.effectTag & 2)) return 1;
+
+ for (; node.return;) {
+ if (node = node.return, 0 !== (node.effectTag & 2)) return 1;
+ }
+ }
+ return 3 === node.tag ? 2 : 3;
+ }
+
+ function assertIsMounted(fiber) {
+ 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;
+ }
+
+ var emptyObject = {},
+ removedKeys = null,
+ removedKeyCount = 0;
+
+ function restoreDeletedValuesInNestedArray(updatePayload, node, validAttributes) {
+ if (Array.isArray(node)) for (var i = node.length; i-- && 0 < removedKeyCount;) {
+ restoreDeletedValuesInNestedArray(updatePayload, node[i], validAttributes);
+ } else if (node && 0 < removedKeyCount) for (i in removedKeys) {
+ if (removedKeys[i]) {
+ var nextProp = node[i];
+
+ if (void 0 !== nextProp) {
+ var attributeConfig = validAttributes[i];
+
+ if (attributeConfig) {
+ "function" === typeof nextProp && (nextProp = !0);
+ "undefined" === typeof nextProp && (nextProp = null);
+ if ("object" !== typeof attributeConfig) updatePayload[i] = nextProp;else if ("function" === typeof attributeConfig.diff || "function" === typeof attributeConfig.process) nextProp = "function" === typeof attributeConfig.process ? attributeConfig.process(nextProp) : nextProp, updatePayload[i] = nextProp;
+ removedKeys[i] = !1;
+ removedKeyCount--;
+ }
+ }
+ }
+ }
+ }
+
+ function diffNestedProperty(updatePayload, prevProp, nextProp, validAttributes) {
+ if (!updatePayload && prevProp === nextProp) return updatePayload;
+ if (!prevProp || !nextProp) return nextProp ? addNestedProperty(updatePayload, nextProp, validAttributes) : prevProp ? clearNestedProperty(updatePayload, prevProp, validAttributes) : updatePayload;
+ if (!Array.isArray(prevProp) && !Array.isArray(nextProp)) return diffProperties(updatePayload, prevProp, nextProp, validAttributes);
+
+ if (Array.isArray(prevProp) && Array.isArray(nextProp)) {
+ var minLength = prevProp.length < nextProp.length ? prevProp.length : nextProp.length,
+ i;
+
+ for (i = 0; i < minLength; i++) {
+ updatePayload = diffNestedProperty(updatePayload, prevProp[i], nextProp[i], validAttributes);
+ }
+
+ for (; i < prevProp.length; i++) {
+ updatePayload = clearNestedProperty(updatePayload, prevProp[i], validAttributes);
+ }
+
+ for (; i < nextProp.length; i++) {
+ updatePayload = addNestedProperty(updatePayload, nextProp[i], validAttributes);
+ }
+
+ return updatePayload;
+ }
+
+ return Array.isArray(prevProp) ? diffProperties(updatePayload, 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, nextProp, validAttributes);
+
+ for (var i = 0; i < nextProp.length; i++) {
+ updatePayload = addNestedProperty(updatePayload, nextProp[i], validAttributes);
+ }
+
+ return updatePayload;
+ }
+
+ function clearNestedProperty(updatePayload, prevProp, validAttributes) {
+ if (!prevProp) return updatePayload;
+ if (!Array.isArray(prevProp)) return diffProperties(updatePayload, prevProp, emptyObject, validAttributes);
+
+ for (var i = 0; i < prevProp.length; i++) {
+ updatePayload = clearNestedProperty(updatePayload, prevProp[i], validAttributes);
+ }
+
+ return updatePayload;
+ }
+
+ function diffProperties(updatePayload, prevProps, nextProps, validAttributes) {
+ var attributeConfig, propKey;
+
+ for (propKey in nextProps) {
+ if (attributeConfig = validAttributes[propKey]) {
+ var prevProp = prevProps[propKey];
+ var nextProp = nextProps[propKey];
+ "function" === typeof nextProp && (nextProp = !0, "function" === typeof prevProp && (prevProp = !0));
+ "undefined" === typeof nextProp && (nextProp = null, "undefined" === typeof prevProp && (prevProp = null));
+ removedKeys && (removedKeys[propKey] = !1);
+ if (updatePayload && void 0 !== updatePayload[propKey]) {
+ if ("object" !== typeof attributeConfig) updatePayload[propKey] = nextProp;else {
+ if ("function" === typeof attributeConfig.diff || "function" === typeof attributeConfig.process) attributeConfig = "function" === typeof attributeConfig.process ? attributeConfig.process(nextProp) : nextProp, updatePayload[propKey] = attributeConfig;
+ }
+ } else if (prevProp !== nextProp) if ("object" !== typeof attributeConfig) ("object" !== typeof nextProp || null === nextProp || 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_NOT_REALLY_SAFE(context, callback) {
+ return function () {
+ if (callback && ("boolean" !== typeof context.__isMounted || context.__isMounted)) return callback.apply(context, arguments);
+ };
+ }
+
+ var ReactNativeFiberHostComponent = function () {
+ function ReactNativeFiberHostComponent(tag, viewConfig) {
+ if (!(this instanceof ReactNativeFiberHostComponent)) throw new TypeError("Cannot call a class as a function");
+ this._nativeTag = tag;
+ this._children = [];
+ this.viewConfig = viewConfig;
+ }
+
+ ReactNativeFiberHostComponent.prototype.blur = function () {
+ TextInputState.blurTextInput(this._nativeTag);
+ };
+
+ ReactNativeFiberHostComponent.prototype.focus = function () {
+ TextInputState.focusTextInput(this._nativeTag);
+ };
+
+ ReactNativeFiberHostComponent.prototype.measure = function (callback) {
+ UIManager.measure(this._nativeTag, mountSafeCallback_NOT_REALLY_SAFE(this, callback));
+ };
+
+ ReactNativeFiberHostComponent.prototype.measureInWindow = function (callback) {
+ UIManager.measureInWindow(this._nativeTag, mountSafeCallback_NOT_REALLY_SAFE(this, callback));
+ };
+
+ ReactNativeFiberHostComponent.prototype.measureLayout = function (relativeToNativeNode, onSuccess, onFail) {
+ UIManager.measureLayout(this._nativeTag, relativeToNativeNode, mountSafeCallback_NOT_REALLY_SAFE(this, onFail), mountSafeCallback_NOT_REALLY_SAFE(this, onSuccess));
+ };
+
+ ReactNativeFiberHostComponent.prototype.setNativeProps = function (nativeProps) {
+ nativeProps = diffProperties(null, emptyObject, nativeProps, this.viewConfig.validAttributes);
+ null != nativeProps && 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;
+
+ function setTimeoutCallback() {
+ frameDeadline = now$1() + 5;
+ var callback = scheduledCallback;
+ scheduledCallback = null;
+ null !== callback && callback();
+ }
+
+ function scheduleDeferredCallback$1(callback) {
+ scheduledCallback = callback;
+ return setTimeout(setTimeoutCallback, 1);
+ }
+
+ function shim$1() {
+ invariant(!1, "The current renderer does not support hydration. This error is likely caused by a bug in React. Please file an issue.");
+ }
+
+ var UPDATE_SIGNAL = {},
+ nextReactTag = 3;
+
+ function allocateTag() {
+ var tag = nextReactTag;
+ 1 === tag % 10 && (tag += 2);
+ nextReactTag = tag + 2;
+ return tag;
+ }
+
+ function recursivelyUncacheFiberNode(node) {
+ if ("number" === typeof node) delete instanceCache[node], delete instanceProps[node];else {
+ var tag = node._nativeTag;
+ delete instanceCache[tag];
+ delete instanceProps[tag];
+
+ node._children.forEach(recursivelyUncacheFiberNode);
+ }
+ }
+
+ function finalizeInitialChildren(parentInstance) {
+ if (0 === parentInstance._children.length) return !1;
+
+ var nativeTags = parentInstance._children.map(function (child) {
+ return "number" === typeof child ? child : child._nativeTag;
+ });
+
+ UIManager.setChildren(parentInstance._nativeTag, nativeTags);
+ return !1;
+ }
+
+ var scheduleTimeout = setTimeout,
+ cancelTimeout = clearTimeout;
+
+ function commitUpdate(instance, updatePayloadTODO, type, oldProps, newProps) {
+ updatePayloadTODO = instance.viewConfig;
+ instanceProps[instance._nativeTag] = newProps;
+ oldProps = diffProperties(null, oldProps, newProps, updatePayloadTODO.validAttributes);
+ null != oldProps && UIManager.updateView(instance._nativeTag, updatePayloadTODO.uiViewClassName, oldProps);
+ }
+
+ var BEFORE_SLASH_RE = /^(.*)[\\\/]/;
+
+ function getStackByFiberInDevAndProd(workInProgress) {
+ var info = "";
+
+ do {
+ a: switch (workInProgress.tag) {
+ case 3:
+ case 4:
+ case 6:
+ case 7:
+ case 10:
+ case 9:
+ var JSCompiler_inline_result = "";
+ break a;
+
+ default:
+ var owner = workInProgress._debugOwner,
+ source = workInProgress._debugSource,
+ name = getComponentName(workInProgress.type);
+ JSCompiler_inline_result = null;
+ owner && (JSCompiler_inline_result = getComponentName(owner.type));
+ owner = name;
+ name = "";
+ source ? name = " (at " + source.fileName.replace(BEFORE_SLASH_RE, "") + ":" + source.lineNumber + ")" : JSCompiler_inline_result && (name = " (created by " + JSCompiler_inline_result + ")");
+ JSCompiler_inline_result = "\n in " + (owner || "Unknown") + name;
+ }
+
+ info += JSCompiler_inline_result;
+ workInProgress = workInProgress.return;
+ } while (workInProgress);
+
+ return info;
+ }
+
+ new Set();
+ var valueStack = [],
+ index = -1;
+
+ function pop(cursor) {
+ 0 > index || (cursor.current = valueStack[index], valueStack[index] = null, index--);
+ }
+
+ function push(cursor, value) {
+ index++;
+ valueStack[index] = cursor.current;
+ cursor.current = value;
+ }
+
+ var emptyContextObject = {},
+ contextStackCursor = {
+ current: emptyContextObject
+ },
+ didPerformWorkStackCursor = {
+ current: !1
+ },
+ previousContext = emptyContextObject;
+
+ function getMaskedContext(workInProgress, unmaskedContext) {
+ var contextTypes = workInProgress.type.contextTypes;
+ if (!contextTypes) return emptyContextObject;
+ var instance = workInProgress.stateNode;
+ if (instance && instance.__reactInternalMemoizedUnmaskedChildContext === unmaskedContext) return instance.__reactInternalMemoizedMaskedChildContext;
+ var context = {},
+ key;
+
+ for (key in contextTypes) {
+ context[key] = unmaskedContext[key];
+ }
+
+ instance && (workInProgress = workInProgress.stateNode, workInProgress.__reactInternalMemoizedUnmaskedChildContext = unmaskedContext, workInProgress.__reactInternalMemoizedMaskedChildContext = context);
+ return context;
+ }
+
+ function isContextProvider(type) {
+ type = type.childContextTypes;
+ return null !== type && void 0 !== type;
+ }
+
+ function popContext(fiber) {
+ pop(didPerformWorkStackCursor, fiber);
+ pop(contextStackCursor, fiber);
+ }
+
+ function popTopLevelContextObject(fiber) {
+ pop(didPerformWorkStackCursor, fiber);
+ pop(contextStackCursor, fiber);
+ }
+
+ function pushTopLevelContextObject(fiber, context, didChange) {
+ invariant(contextStackCursor.current === emptyContextObject, "Unexpected context found on stack. This error is likely caused by a bug in React. Please file an issue.");
+ push(contextStackCursor, context, fiber);
+ push(didPerformWorkStackCursor, didChange, fiber);
+ }
+
+ function processChildContext(fiber, type, parentContext) {
+ var instance = fiber.stateNode;
+ fiber = type.childContextTypes;
+ if ("function" !== typeof instance.getChildContext) return parentContext;
+ instance = instance.getChildContext();
+
+ for (var contextKey in instance) {
+ invariant(contextKey in fiber, '%s.getChildContext(): key "%s" is not defined in childContextTypes.', getComponentName(type) || "Unknown", contextKey);
+ }
+
+ return _extends({}, parentContext, instance);
+ }
+
+ function pushContextProvider(workInProgress) {
+ var instance = workInProgress.stateNode;
+ instance = instance && instance.__reactInternalMemoizedMergedChildContext || emptyContextObject;
+ previousContext = contextStackCursor.current;
+ push(contextStackCursor, instance, workInProgress);
+ push(didPerformWorkStackCursor, didPerformWorkStackCursor.current, workInProgress);
+ return !0;
+ }
+
+ function invalidateContextProvider(workInProgress, type, didChange) {
+ var instance = workInProgress.stateNode;
+ invariant(instance, "Expected to have an instance by this point. This error is likely caused by a bug in React. Please file an issue.");
+ didChange ? (type = processChildContext(workInProgress, type, previousContext), instance.__reactInternalMemoizedMergedChildContext = type, pop(didPerformWorkStackCursor, workInProgress), pop(contextStackCursor, workInProgress), push(contextStackCursor, type, workInProgress)) : pop(didPerformWorkStackCursor, workInProgress);
+ push(didPerformWorkStackCursor, didChange, workInProgress);
+ }
+
+ var 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 FiberNode(tag, pendingProps, key, mode) {
+ this.tag = tag;
+ this.key = key;
+ this.sibling = this.child = this.return = this.stateNode = this.type = this.elementType = null;
+ this.index = 0;
+ this.ref = null;
+ this.pendingProps = pendingProps;
+ this.contextDependencies = this.memoizedState = this.updateQueue = this.memoizedProps = null;
+ this.mode = mode;
+ this.effectTag = 0;
+ this.lastEffect = this.firstEffect = this.nextEffect = null;
+ this.childExpirationTime = this.expirationTime = 0;
+ this.alternate = null;
+ }
+
+ function createFiber(tag, pendingProps, key, mode) {
+ return new FiberNode(tag, pendingProps, key, mode);
+ }
+
+ function shouldConstruct(Component) {
+ Component = Component.prototype;
+ return !(!Component || !Component.isReactComponent);
+ }
+
+ function resolveLazyComponentTag(Component) {
+ if ("function" === typeof Component) return shouldConstruct(Component) ? 1 : 0;
+
+ if (void 0 !== Component && null !== Component) {
+ Component = Component.$$typeof;
+ if (Component === REACT_FORWARD_REF_TYPE) return 11;
+ if (Component === REACT_MEMO_TYPE) return 14;
+ }
+
+ return 2;
+ }
+
+ function createWorkInProgress(current, pendingProps) {
+ var workInProgress = current.alternate;
+ null === workInProgress ? (workInProgress = createFiber(current.tag, pendingProps, current.key, current.mode), workInProgress.elementType = current.elementType, workInProgress.type = current.type, workInProgress.stateNode = current.stateNode, workInProgress.alternate = current, current.alternate = workInProgress) : (workInProgress.pendingProps = pendingProps, workInProgress.effectTag = 0, workInProgress.nextEffect = null, workInProgress.firstEffect = null, workInProgress.lastEffect = null);
+ workInProgress.childExpirationTime = current.childExpirationTime;
+ workInProgress.expirationTime = current.expirationTime;
+ workInProgress.child = current.child;
+ workInProgress.memoizedProps = current.memoizedProps;
+ workInProgress.memoizedState = current.memoizedState;
+ workInProgress.updateQueue = current.updateQueue;
+ workInProgress.contextDependencies = current.contextDependencies;
+ workInProgress.sibling = current.sibling;
+ workInProgress.index = current.index;
+ workInProgress.ref = current.ref;
+ return workInProgress;
+ }
+
+ function createFiberFromTypeAndProps(type, key, pendingProps, owner, mode, expirationTime) {
+ var fiberTag = 2;
+ owner = type;
+ if ("function" === typeof type) shouldConstruct(type) && (fiberTag = 1);else if ("string" === typeof type) fiberTag = 5;else a: switch (type) {
+ case REACT_FRAGMENT_TYPE:
+ return createFiberFromFragment(pendingProps.children, mode, expirationTime, key);
+
+ case REACT_CONCURRENT_MODE_TYPE:
+ return createFiberFromMode(pendingProps, mode | 3, expirationTime, key);
+
+ case REACT_STRICT_MODE_TYPE:
+ return createFiberFromMode(pendingProps, mode | 2, expirationTime, key);
+
+ case REACT_PROFILER_TYPE:
+ return type = createFiber(12, pendingProps, key, mode | 4), type.elementType = REACT_PROFILER_TYPE, type.type = REACT_PROFILER_TYPE, type.expirationTime = expirationTime, type;
+
+ case REACT_SUSPENSE_TYPE:
+ return type = createFiber(13, pendingProps, key, mode), type.elementType = REACT_SUSPENSE_TYPE, type.type = REACT_SUSPENSE_TYPE, type.expirationTime = expirationTime, type;
+
+ default:
+ if ("object" === typeof type && null !== type) switch (type.$$typeof) {
+ case REACT_PROVIDER_TYPE:
+ fiberTag = 10;
+ break a;
+
+ case REACT_CONTEXT_TYPE:
+ fiberTag = 9;
+ break a;
+
+ case REACT_FORWARD_REF_TYPE:
+ fiberTag = 11;
+ break a;
+
+ case REACT_MEMO_TYPE:
+ fiberTag = 14;
+ break a;
+
+ case REACT_LAZY_TYPE:
+ fiberTag = 16;
+ owner = null;
+ break a;
+ }
+ 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, "");
+ }
+ key = createFiber(fiberTag, pendingProps, key, mode);
+ key.elementType = type;
+ key.type = owner;
+ key.expirationTime = expirationTime;
+ return key;
+ }
+
+ function createFiberFromFragment(elements, mode, expirationTime, key) {
+ elements = createFiber(7, elements, key, mode);
+ elements.expirationTime = expirationTime;
+ return elements;
+ }
+
+ function createFiberFromMode(pendingProps, mode, expirationTime, key) {
+ pendingProps = createFiber(8, pendingProps, key, mode);
+ mode = 0 === (mode & 1) ? REACT_STRICT_MODE_TYPE : REACT_CONCURRENT_MODE_TYPE;
+ pendingProps.elementType = mode;
+ pendingProps.type = mode;
+ pendingProps.expirationTime = expirationTime;
+ return pendingProps;
+ }
+
+ function createFiberFromText(content, mode, expirationTime) {
+ content = createFiber(6, content, null, mode);
+ content.expirationTime = expirationTime;
+ return content;
+ }
+
+ function createFiberFromPortal(portal, mode, expirationTime) {
+ mode = createFiber(4, null !== portal.children ? portal.children : [], portal.key, mode);
+ mode.expirationTime = expirationTime;
+ mode.stateNode = {
+ containerInfo: portal.containerInfo,
+ pendingChildren: null,
+ implementation: portal.implementation
+ };
+ return mode;
+ }
+
+ function 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);
+ findNextExpirationTimeToWorkOn(expirationTime, root);
+ }
+
+ function markCommittedPriorityLevels(root, earliestRemainingTime) {
+ root.didError = !1;
+ if (0 === earliestRemainingTime) root.earliestPendingTime = 0, root.latestPendingTime = 0, root.earliestSuspendedTime = 0, root.latestSuspendedTime = 0, root.latestPingedTime = 0;else {
+ earliestRemainingTime < root.latestPingedTime && (root.latestPingedTime = 0);
+ var latestPendingTime = root.latestPendingTime;
+ 0 !== latestPendingTime && (latestPendingTime > earliestRemainingTime ? root.earliestPendingTime = root.latestPendingTime = 0 : root.earliestPendingTime > earliestRemainingTime && (root.earliestPendingTime = root.latestPendingTime));
+ latestPendingTime = root.earliestSuspendedTime;
+ 0 === latestPendingTime ? markPendingPriorityLevel(root, earliestRemainingTime) : earliestRemainingTime < root.latestSuspendedTime ? (root.earliestSuspendedTime = 0, root.latestSuspendedTime = 0, root.latestPingedTime = 0, markPendingPriorityLevel(root, earliestRemainingTime)) : earliestRemainingTime > latestPendingTime && markPendingPriorityLevel(root, earliestRemainingTime);
+ }
+ findNextExpirationTimeToWorkOn(0, root);
+ }
+
+ function markSuspendedPriorityLevel(root, suspendedTime) {
+ root.didError = !1;
+ root.latestPingedTime >= suspendedTime && (root.latestPingedTime = 0);
+ var earliestPendingTime = root.earliestPendingTime,
+ latestPendingTime = root.latestPendingTime;
+ earliestPendingTime === suspendedTime ? root.earliestPendingTime = latestPendingTime === suspendedTime ? root.latestPendingTime = 0 : latestPendingTime : latestPendingTime === suspendedTime && (root.latestPendingTime = earliestPendingTime);
+ earliestPendingTime = root.earliestSuspendedTime;
+ latestPendingTime = root.latestSuspendedTime;
+ 0 === earliestPendingTime ? root.earliestSuspendedTime = root.latestSuspendedTime = suspendedTime : earliestPendingTime < suspendedTime ? root.earliestSuspendedTime = suspendedTime : latestPendingTime > suspendedTime && (root.latestSuspendedTime = suspendedTime);
+ findNextExpirationTimeToWorkOn(suspendedTime, root);
+ }
+
+ function findEarliestOutstandingPriorityLevel(root, renderExpirationTime) {
+ var earliestPendingTime = root.earliestPendingTime;
+ root = root.earliestSuspendedTime;
+ earliestPendingTime > renderExpirationTime && (renderExpirationTime = earliestPendingTime);
+ root > renderExpirationTime && (renderExpirationTime = root);
+ return renderExpirationTime;
+ }
+
+ function findNextExpirationTimeToWorkOn(completedExpirationTime, root) {
+ var earliestSuspendedTime = root.earliestSuspendedTime,
+ latestSuspendedTime = root.latestSuspendedTime,
+ earliestPendingTime = root.earliestPendingTime,
+ latestPingedTime = root.latestPingedTime;
+ earliestPendingTime = 0 !== earliestPendingTime ? earliestPendingTime : latestPingedTime;
+ 0 === earliestPendingTime && (0 === completedExpirationTime || latestSuspendedTime < completedExpirationTime) && (earliestPendingTime = latestSuspendedTime);
+ completedExpirationTime = earliestPendingTime;
+ 0 !== completedExpirationTime && earliestSuspendedTime > completedExpirationTime && (completedExpirationTime = earliestSuspendedTime);
+ root.nextExpirationTimeToWorkOn = earliestPendingTime;
+ root.expirationTime = completedExpirationTime;
+ }
+
+ function is(x, y) {
+ return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
+ }
+
+ var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+ function shallowEqual(objA, objB) {
+ if (is(objA, objB)) return !0;
+ if ("object" !== typeof objA || null === objA || "object" !== typeof objB || null === objB) return !1;
+ var keysA = Object.keys(objA),
+ keysB = Object.keys(objB);
+ if (keysA.length !== keysB.length) return !1;
+
+ for (keysB = 0; keysB < keysA.length; keysB++) {
+ if (!hasOwnProperty.call(objB, keysA[keysB]) || !is(objA[keysA[keysB]], objB[keysA[keysB]])) return !1;
+ }
+
+ return !0;
+ }
+
+ function resolveDefaultProps(Component, baseProps) {
+ if (Component && Component.defaultProps) {
+ baseProps = _extends({}, baseProps);
+ Component = Component.defaultProps;
+
+ for (var propName in Component) {
+ void 0 === baseProps[propName] && (baseProps[propName] = Component[propName]);
+ }
+ }
+
+ return baseProps;
+ }
+
+ function readLazyComponentType(lazyComponent) {
+ var result = lazyComponent._result;
+
+ switch (lazyComponent._status) {
+ case 1:
+ return result;
+
+ case 2:
+ throw result;
+
+ case 0:
+ throw result;
+
+ default:
+ lazyComponent._status = 0;
+ result = lazyComponent._ctor;
+ result = result();
+ result.then(function (moduleObject) {
+ 0 === lazyComponent._status && (moduleObject = moduleObject.default, lazyComponent._status = 1, lazyComponent._result = moduleObject);
+ }, function (error) {
+ 0 === lazyComponent._status && (lazyComponent._status = 2, lazyComponent._result = error);
+ });
+
+ switch (lazyComponent._status) {
+ case 1:
+ return lazyComponent._result;
+
+ case 2:
+ throw lazyComponent._result;
+ }
+
+ lazyComponent._result = result;
+ throw result;
+ }
+ }
+
+ var emptyRefsObject = new React.Component().refs;
+
+ function applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, nextProps) {
+ ctor = workInProgress.memoizedState;
+ getDerivedStateFromProps = getDerivedStateFromProps(nextProps, ctor);
+ getDerivedStateFromProps = null === getDerivedStateFromProps || void 0 === getDerivedStateFromProps ? ctor : _extends({}, ctor, getDerivedStateFromProps);
+ workInProgress.memoizedState = getDerivedStateFromProps;
+ nextProps = workInProgress.updateQueue;
+ null !== nextProps && 0 === workInProgress.expirationTime && (nextProps.baseState = getDerivedStateFromProps);
+ }
+
+ var classComponentUpdater = {
+ isMounted: function isMounted(component) {
+ return (component = component._reactInternalFiber) ? 2 === isFiberMountedImpl(component) : !1;
+ },
+ enqueueSetState: function enqueueSetState(inst, payload, callback) {
+ inst = inst._reactInternalFiber;
+ var currentTime = requestCurrentTime();
+ currentTime = computeExpirationForFiber(currentTime, inst);
+ var update = createUpdate(currentTime);
+ update.payload = payload;
+ void 0 !== callback && null !== callback && (update.callback = callback);
+ flushPassiveEffects();
+ enqueueUpdate(inst, update);
+ scheduleWork(inst, currentTime);
+ },
+ enqueueReplaceState: function enqueueReplaceState(inst, payload, callback) {
+ inst = inst._reactInternalFiber;
+ var currentTime = requestCurrentTime();
+ currentTime = computeExpirationForFiber(currentTime, inst);
+ var update = createUpdate(currentTime);
+ update.tag = ReplaceState;
+ update.payload = payload;
+ void 0 !== callback && null !== callback && (update.callback = callback);
+ flushPassiveEffects();
+ enqueueUpdate(inst, update);
+ scheduleWork(inst, currentTime);
+ },
+ enqueueForceUpdate: function enqueueForceUpdate(inst, callback) {
+ inst = inst._reactInternalFiber;
+ var currentTime = requestCurrentTime();
+ currentTime = computeExpirationForFiber(currentTime, inst);
+ var update = createUpdate(currentTime);
+ update.tag = ForceUpdate;
+ void 0 !== callback && null !== callback && (update.callback = callback);
+ flushPassiveEffects();
+ enqueueUpdate(inst, update);
+ scheduleWork(inst, currentTime);
+ }
+ };
+
+ function checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext) {
+ workInProgress = workInProgress.stateNode;
+ return "function" === typeof workInProgress.shouldComponentUpdate ? workInProgress.shouldComponentUpdate(newProps, newState, nextContext) : ctor.prototype && ctor.prototype.isPureReactComponent ? !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState) : !0;
+ }
+
+ function constructClassInstance(workInProgress, ctor, props) {
+ var isLegacyContextConsumer = !1,
+ unmaskedContext = emptyContextObject;
+ var context = ctor.contextType;
+ "object" === typeof context && null !== context ? context = readContext(context) : (unmaskedContext = isContextProvider(ctor) ? previousContext : contextStackCursor.current, isLegacyContextConsumer = ctor.contextTypes, context = (isLegacyContextConsumer = null !== isLegacyContextConsumer && void 0 !== isLegacyContextConsumer) ? getMaskedContext(workInProgress, unmaskedContext) : emptyContextObject);
+ ctor = new ctor(props, context);
+ workInProgress.memoizedState = null !== ctor.state && void 0 !== ctor.state ? ctor.state : null;
+ ctor.updater = classComponentUpdater;
+ workInProgress.stateNode = ctor;
+ ctor._reactInternalFiber = workInProgress;
+ isLegacyContextConsumer && (workInProgress = workInProgress.stateNode, workInProgress.__reactInternalMemoizedUnmaskedChildContext = unmaskedContext, workInProgress.__reactInternalMemoizedMaskedChildContext = context);
+ return ctor;
+ }
+
+ function callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext) {
+ workInProgress = instance.state;
+ "function" === typeof instance.componentWillReceiveProps && instance.componentWillReceiveProps(newProps, nextContext);
+ "function" === typeof instance.UNSAFE_componentWillReceiveProps && instance.UNSAFE_componentWillReceiveProps(newProps, nextContext);
+ instance.state !== workInProgress && classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
+ }
+
+ function mountClassInstance(workInProgress, ctor, newProps, renderExpirationTime) {
+ var instance = workInProgress.stateNode;
+ instance.props = newProps;
+ instance.state = workInProgress.memoizedState;
+ instance.refs = emptyRefsObject;
+ var contextType = ctor.contextType;
+ "object" === typeof contextType && null !== contextType ? instance.context = readContext(contextType) : (contextType = isContextProvider(ctor) ? previousContext : contextStackCursor.current, instance.context = getMaskedContext(workInProgress, contextType));
+ contextType = workInProgress.updateQueue;
+ null !== contextType && (processUpdateQueue(workInProgress, contextType, newProps, instance, renderExpirationTime), instance.state = workInProgress.memoizedState);
+ contextType = ctor.getDerivedStateFromProps;
+ "function" === typeof contextType && (applyDerivedStateFromProps(workInProgress, ctor, contextType, newProps), instance.state = workInProgress.memoizedState);
+ "function" === typeof ctor.getDerivedStateFromProps || "function" === typeof instance.getSnapshotBeforeUpdate || "function" !== typeof instance.UNSAFE_componentWillMount && "function" !== typeof instance.componentWillMount || (ctor = instance.state, "function" === typeof instance.componentWillMount && instance.componentWillMount(), "function" === typeof instance.UNSAFE_componentWillMount && instance.UNSAFE_componentWillMount(), ctor !== instance.state && classComponentUpdater.enqueueReplaceState(instance, instance.state, null), contextType = workInProgress.updateQueue, null !== contextType && (processUpdateQueue(workInProgress, contextType, newProps, instance, renderExpirationTime), instance.state = workInProgress.memoizedState));
+ "function" === typeof instance.componentDidMount && (workInProgress.effectTag |= 4);
+ }
+
+ var isArray = Array.isArray;
+
+ function coerceRef(returnFiber, current$$1, element) {
+ returnFiber = element.ref;
+
+ if (null !== returnFiber && "function" !== typeof returnFiber && "object" !== typeof returnFiber) {
+ if (element._owner) {
+ element = element._owner;
+ var inst = void 0;
+ element && (invariant(1 === element.tag, "Function components cannot have refs. Did you mean to use React.forwardRef()?"), 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$$1 && null !== current$$1.ref && "function" === typeof current$$1.ref && current$$1.ref._stringRef === stringRef) return current$$1.ref;
+
+ current$$1 = function current$$1(value) {
+ var refs = inst.refs;
+ refs === emptyRefsObject && (refs = inst.refs = {});
+ null === value ? delete refs[stringRef] : refs[stringRef] = value;
+ };
+
+ current$$1._stringRef = stringRef;
+ return current$$1;
+ }
+
+ invariant("string" === typeof returnFiber, "Expected ref to be a function, a string, an object returned by React.createRef(), or null.");
+ 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 function component\n2. You may be adding a ref to a component that was not created inside a component's render method\n3. You have multiple copies of React loaded\nSee https://fb.me/react-refs-must-have-owner for more information.", 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$$1, textContent, expirationTime) {
+ if (null === current$$1 || 6 !== current$$1.tag) return current$$1 = createFiberFromText(textContent, returnFiber.mode, expirationTime), current$$1.return = returnFiber, current$$1;
+ current$$1 = useFiber(current$$1, textContent, expirationTime);
+ current$$1.return = returnFiber;
+ return current$$1;
+ }
+
+ function updateElement(returnFiber, current$$1, element, expirationTime) {
+ if (null !== current$$1 && current$$1.elementType === element.type) return expirationTime = useFiber(current$$1, element.props, expirationTime), expirationTime.ref = coerceRef(returnFiber, current$$1, element), expirationTime.return = returnFiber, expirationTime;
+ expirationTime = createFiberFromTypeAndProps(element.type, element.key, element.props, null, returnFiber.mode, expirationTime);
+ expirationTime.ref = coerceRef(returnFiber, current$$1, element);
+ expirationTime.return = returnFiber;
+ return expirationTime;
+ }
+
+ function updatePortal(returnFiber, current$$1, portal, expirationTime) {
+ if (null === current$$1 || 4 !== current$$1.tag || current$$1.stateNode.containerInfo !== portal.containerInfo || current$$1.stateNode.implementation !== portal.implementation) return current$$1 = createFiberFromPortal(portal, returnFiber.mode, expirationTime), current$$1.return = returnFiber, current$$1;
+ current$$1 = useFiber(current$$1, portal.children || [], expirationTime);
+ current$$1.return = returnFiber;
+ return current$$1;
+ }
+
+ function updateFragment(returnFiber, current$$1, fragment, expirationTime, key) {
+ if (null === current$$1 || 7 !== current$$1.tag) return current$$1 = createFiberFromFragment(fragment, returnFiber.mode, expirationTime, key), current$$1.return = returnFiber, current$$1;
+ current$$1 = useFiber(current$$1, fragment, expirationTime);
+ current$$1.return = returnFiber;
+ return current$$1;
+ }
+
+ function createChild(returnFiber, newChild, expirationTime) {
+ if ("string" === typeof newChild || "number" === typeof newChild) return newChild = createFiberFromText("" + newChild, returnFiber.mode, expirationTime), newChild.return = returnFiber, newChild;
+
+ if ("object" === typeof newChild && null !== newChild) {
+ switch (newChild.$$typeof) {
+ case REACT_ELEMENT_TYPE:
+ return expirationTime = createFiberFromTypeAndProps(newChild.type, newChild.key, newChild.props, null, returnFiber.mode, expirationTime), expirationTime.ref = coerceRef(returnFiber, null, newChild), expirationTime.return = returnFiber, expirationTime;
+
+ case REACT_PORTAL_TYPE:
+ return newChild = createFiberFromPortal(newChild, returnFiber.mode, expirationTime), newChild.return = returnFiber, newChild;
+ }
+
+ if (isArray(newChild) || getIteratorFn(newChild)) return newChild = createFiberFromFragment(newChild, returnFiber.mode, expirationTime, null), newChild.return = returnFiber, newChild;
+ throwOnInvalidObjectType(returnFiber, newChild);
+ }
+
+ return null;
+ }
+
+ function updateSlot(returnFiber, oldFiber, newChild, expirationTime) {
+ var key = null !== oldFiber ? oldFiber.key : null;
+ if ("string" === typeof newChild || "number" === typeof newChild) return null !== key ? null : updateTextNode(returnFiber, oldFiber, "" + newChild, expirationTime);
+
+ if ("object" === typeof newChild && null !== newChild) {
+ switch (newChild.$$typeof) {
+ case REACT_ELEMENT_TYPE:
+ return newChild.key === key ? newChild.type === REACT_FRAGMENT_TYPE ? updateFragment(returnFiber, oldFiber, newChild.props.children, expirationTime, key) : updateElement(returnFiber, oldFiber, newChild, expirationTime) : null;
+
+ case REACT_PORTAL_TYPE:
+ return newChild.key === key ? updatePortal(returnFiber, oldFiber, newChild, expirationTime) : null;
+ }
+
+ if (isArray(newChild) || getIteratorFn(newChild)) return null !== key ? null : updateFragment(returnFiber, oldFiber, newChild, expirationTime, null);
+ throwOnInvalidObjectType(returnFiber, newChild);
+ }
+
+ return null;
+ }
+
+ function updateFromMap(existingChildren, returnFiber, newIdx, newChild, expirationTime) {
+ if ("string" === typeof newChild || "number" === typeof newChild) return existingChildren = existingChildren.get(newIdx) || null, updateTextNode(returnFiber, existingChildren, "" + newChild, expirationTime);
+
+ if ("object" === typeof newChild && null !== newChild) {
+ switch (newChild.$$typeof) {
+ case REACT_ELEMENT_TYPE:
+ return existingChildren = existingChildren.get(null === newChild.key ? newIdx : newChild.key) || null, newChild.type === REACT_FRAGMENT_TYPE ? updateFragment(returnFiber, existingChildren, newChild.props.children, expirationTime, newChild.key) : updateElement(returnFiber, existingChildren, newChild, expirationTime);
+
+ case REACT_PORTAL_TYPE:
+ return existingChildren = existingChildren.get(null === newChild.key ? newIdx : newChild.key) || null, updatePortal(returnFiber, existingChildren, newChild, expirationTime);
+ }
+
+ if (isArray(newChild) || getIteratorFn(newChild)) return existingChildren = existingChildren.get(newIdx) || null, updateFragment(returnFiber, existingChildren, newChild, expirationTime, null);
+ throwOnInvalidObjectType(returnFiber, newChild);
+ }
+
+ return null;
+ }
+
+ function reconcileChildrenArray(returnFiber, currentFirstChild, newChildren, expirationTime) {
+ for (var resultingFirstChild = null, previousNewFiber = null, oldFiber = currentFirstChild, newIdx = currentFirstChild = 0, nextOldFiber = null; null !== oldFiber && newIdx < newChildren.length; newIdx++) {
+ oldFiber.index > newIdx ? (nextOldFiber = oldFiber, oldFiber = null) : nextOldFiber = oldFiber.sibling;
+ var newFiber = updateSlot(returnFiber, oldFiber, newChildren[newIdx], expirationTime);
+
+ if (null === newFiber) {
+ null === oldFiber && (oldFiber = nextOldFiber);
+ break;
+ }
+
+ shouldTrackSideEffects && oldFiber && null === newFiber.alternate && deleteChild(returnFiber, oldFiber);
+ currentFirstChild = placeChild(newFiber, currentFirstChild, newIdx);
+ null === previousNewFiber ? resultingFirstChild = newFiber : previousNewFiber.sibling = newFiber;
+ previousNewFiber = newFiber;
+ oldFiber = nextOldFiber;
+ }
+
+ if (newIdx === newChildren.length) return deleteRemainingChildren(returnFiber, oldFiber), resultingFirstChild;
+
+ if (null === oldFiber) {
+ for (; newIdx < newChildren.length; newIdx++) {
+ 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 (7 === isUnkeyedTopLevelFragment.tag ? newChild.type === REACT_FRAGMENT_TYPE : isUnkeyedTopLevelFragment.elementType === newChild.type) {
+ deleteRemainingChildren(returnFiber, isUnkeyedTopLevelFragment.sibling);
+ currentFirstChild = useFiber(isUnkeyedTopLevelFragment, newChild.type === REACT_FRAGMENT_TYPE ? newChild.props.children : newChild.props, expirationTime);
+ currentFirstChild.ref = coerceRef(returnFiber, isUnkeyedTopLevelFragment, newChild);
+ currentFirstChild.return = returnFiber;
+ returnFiber = currentFirstChild;
+ break a;
+ } 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 = createFiberFromTypeAndProps(newChild.type, newChild.key, newChild.props, null, returnFiber.mode, expirationTime), expirationTime.ref = coerceRef(returnFiber, currentFirstChild, newChild), expirationTime.return = returnFiber, returnFiber = expirationTime);
+ }
+
+ return placeSingleChild(returnFiber);
+
+ case REACT_PORTAL_TYPE:
+ a: {
+ for (isUnkeyedTopLevelFragment = newChild.key; null !== currentFirstChild;) {
+ if (currentFirstChild.key === isUnkeyedTopLevelFragment) {
+ if (4 === currentFirstChild.tag && currentFirstChild.stateNode.containerInfo === newChild.containerInfo && currentFirstChild.stateNode.implementation === newChild.implementation) {
+ deleteRemainingChildren(returnFiber, currentFirstChild.sibling);
+ currentFirstChild = useFiber(currentFirstChild, newChild.children || [], expirationTime);
+ currentFirstChild.return = returnFiber;
+ returnFiber = currentFirstChild;
+ break a;
+ } 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(newChild)) return reconcileChildrenArray(returnFiber, currentFirstChild, newChild, expirationTime);
+ if (getIteratorFn(newChild)) return reconcileChildrenIterator(returnFiber, currentFirstChild, newChild, expirationTime);
+ isObject && throwOnInvalidObjectType(returnFiber, newChild);
+ if ("undefined" === typeof newChild && !isUnkeyedTopLevelFragment) switch (returnFiber.tag) {
+ case 1:
+ case 0:
+ 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),
+ NO_CONTEXT = {},
+ contextStackCursor$1 = {
+ current: NO_CONTEXT
+ },
+ contextFiberStackCursor = {
+ current: NO_CONTEXT
+ },
+ rootInstanceStackCursor = {
+ current: 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 pushHostContext(fiber) {
+ requiredContext(rootInstanceStackCursor.current);
+ var context = requiredContext(contextStackCursor$1.current);
+ var nextContext = fiber.type;
+ nextContext = "AndroidTextInput" === nextContext || "RCTMultilineTextInputView" === nextContext || "RCTSinglelineTextInputView" === nextContext || "RCTText" === nextContext || "RCTVirtualText" === nextContext;
+ nextContext = context.isInAParentText !== nextContext ? {
+ isInAParentText: nextContext
+ } : context;
+ context !== nextContext && (push(contextFiberStackCursor, fiber, fiber), push(contextStackCursor$1, nextContext, fiber));
+ }
+
+ function popHostContext(fiber) {
+ contextFiberStackCursor.current === fiber && (pop(contextStackCursor$1, fiber), pop(contextFiberStackCursor, fiber));
+ }
+
+ var NoEffect$1 = 0,
+ UnmountSnapshot = 2,
+ UnmountMutation = 4,
+ MountMutation = 8,
+ UnmountLayout = 16,
+ MountLayout = 32,
+ MountPassive = 64,
+ UnmountPassive = 128,
+ ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher,
+ renderExpirationTime = 0,
+ currentlyRenderingFiber$1 = null,
+ currentHook = null,
+ nextCurrentHook = null,
+ firstWorkInProgressHook = null,
+ workInProgressHook = null,
+ nextWorkInProgressHook = null,
+ remainingExpirationTime = 0,
+ componentUpdateQueue = null,
+ sideEffectTag = 0,
+ didScheduleRenderPhaseUpdate = !1,
+ renderPhaseUpdates = null,
+ numberOfReRenders = 0;
+
+ function throwInvalidHookError() {
+ invariant(!1, "Hooks can only be called inside the body of a function component. (https://fb.me/react-invalid-hook-call)");
+ }
+
+ function areHookInputsEqual(nextDeps, prevDeps) {
+ if (null === prevDeps) return !1;
+
+ for (var i = 0; i < prevDeps.length && i < nextDeps.length; i++) {
+ if (!is(nextDeps[i], prevDeps[i])) return !1;
+ }
+
+ return !0;
+ }
+
+ function renderWithHooks(current, workInProgress, Component, props, refOrContext, nextRenderExpirationTime) {
+ renderExpirationTime = nextRenderExpirationTime;
+ currentlyRenderingFiber$1 = workInProgress;
+ nextCurrentHook = null !== current ? current.memoizedState : null;
+ ReactCurrentDispatcher$1.current = null === nextCurrentHook ? HooksDispatcherOnMount : HooksDispatcherOnUpdate;
+ workInProgress = Component(props, refOrContext);
+
+ if (didScheduleRenderPhaseUpdate) {
+ do {
+ didScheduleRenderPhaseUpdate = !1, numberOfReRenders += 1, nextCurrentHook = null !== current ? current.memoizedState : null, nextWorkInProgressHook = firstWorkInProgressHook, componentUpdateQueue = workInProgressHook = currentHook = null, ReactCurrentDispatcher$1.current = HooksDispatcherOnUpdate, workInProgress = Component(props, refOrContext);
+ } while (didScheduleRenderPhaseUpdate);
+
+ renderPhaseUpdates = null;
+ numberOfReRenders = 0;
+ }
+
+ ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
+ current = currentlyRenderingFiber$1;
+ current.memoizedState = firstWorkInProgressHook;
+ current.expirationTime = remainingExpirationTime;
+ current.updateQueue = componentUpdateQueue;
+ current.effectTag |= sideEffectTag;
+ current = null !== currentHook && null !== currentHook.next;
+ renderExpirationTime = 0;
+ nextWorkInProgressHook = workInProgressHook = firstWorkInProgressHook = nextCurrentHook = currentHook = currentlyRenderingFiber$1 = null;
+ remainingExpirationTime = 0;
+ componentUpdateQueue = null;
+ sideEffectTag = 0;
+ invariant(!current, "Rendered fewer hooks than expected. This may be caused by an accidental early return statement.");
+ return workInProgress;
+ }
+
+ function resetHooks() {
+ ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
+ renderExpirationTime = 0;
+ nextWorkInProgressHook = workInProgressHook = firstWorkInProgressHook = nextCurrentHook = currentHook = currentlyRenderingFiber$1 = null;
+ remainingExpirationTime = 0;
+ componentUpdateQueue = null;
+ sideEffectTag = 0;
+ didScheduleRenderPhaseUpdate = !1;
+ renderPhaseUpdates = null;
+ numberOfReRenders = 0;
+ }
+
+ function mountWorkInProgressHook() {
+ var hook = {
+ memoizedState: null,
+ baseState: null,
+ queue: null,
+ baseUpdate: null,
+ next: null
+ };
+ null === workInProgressHook ? firstWorkInProgressHook = workInProgressHook = hook : workInProgressHook = workInProgressHook.next = hook;
+ return workInProgressHook;
+ }
+
+ function updateWorkInProgressHook() {
+ if (null !== nextWorkInProgressHook) workInProgressHook = nextWorkInProgressHook, nextWorkInProgressHook = workInProgressHook.next, currentHook = nextCurrentHook, nextCurrentHook = null !== currentHook ? currentHook.next : null;else {
+ invariant(null !== nextCurrentHook, "Rendered more hooks than during the previous render.");
+ currentHook = nextCurrentHook;
+ var newHook = {
+ memoizedState: currentHook.memoizedState,
+ baseState: currentHook.baseState,
+ queue: currentHook.queue,
+ baseUpdate: currentHook.baseUpdate,
+ next: null
+ };
+ workInProgressHook = null === workInProgressHook ? firstWorkInProgressHook = newHook : workInProgressHook.next = newHook;
+ nextCurrentHook = currentHook.next;
+ }
+ return workInProgressHook;
+ }
+
+ function basicStateReducer(state, action) {
+ return "function" === typeof action ? action(state) : action;
+ }
+
+ function updateReducer(reducer) {
+ var hook = updateWorkInProgressHook(),
+ queue = hook.queue;
+ invariant(null !== queue, "Should have a queue. This is likely a bug in React. Please file an issue.");
+
+ if (0 < numberOfReRenders) {
+ var _dispatch = queue.dispatch;
+
+ if (null !== renderPhaseUpdates) {
+ var firstRenderPhaseUpdate = renderPhaseUpdates.get(queue);
+
+ if (void 0 !== firstRenderPhaseUpdate) {
+ renderPhaseUpdates.delete(queue);
+ var newState = hook.memoizedState;
+
+ do {
+ newState = reducer(newState, firstRenderPhaseUpdate.action), firstRenderPhaseUpdate = firstRenderPhaseUpdate.next;
+ } while (null !== firstRenderPhaseUpdate);
+
+ is(newState, hook.memoizedState) || (didReceiveUpdate = !0);
+ hook.memoizedState = newState;
+ hook.baseUpdate === queue.last && (hook.baseState = newState);
+ queue.eagerReducer = reducer;
+ queue.eagerState = newState;
+ return [newState, _dispatch];
+ }
+ }
+
+ return [hook.memoizedState, _dispatch];
+ }
+
+ _dispatch = queue.last;
+ var baseUpdate = hook.baseUpdate;
+ newState = hook.baseState;
+ null !== baseUpdate ? (null !== _dispatch && (_dispatch.next = null), _dispatch = baseUpdate.next) : _dispatch = null !== _dispatch ? _dispatch.next : null;
+
+ if (null !== _dispatch) {
+ var newBaseUpdate = firstRenderPhaseUpdate = null,
+ _update = _dispatch,
+ didSkip = !1;
+
+ do {
+ var updateExpirationTime = _update.expirationTime;
+ updateExpirationTime < renderExpirationTime ? (didSkip || (didSkip = !0, newBaseUpdate = baseUpdate, firstRenderPhaseUpdate = newState), updateExpirationTime > remainingExpirationTime && (remainingExpirationTime = updateExpirationTime)) : newState = _update.eagerReducer === reducer ? _update.eagerState : reducer(newState, _update.action);
+ baseUpdate = _update;
+ _update = _update.next;
+ } while (null !== _update && _update !== _dispatch);
+
+ didSkip || (newBaseUpdate = baseUpdate, firstRenderPhaseUpdate = newState);
+ is(newState, hook.memoizedState) || (didReceiveUpdate = !0);
+ hook.memoizedState = newState;
+ hook.baseUpdate = newBaseUpdate;
+ hook.baseState = firstRenderPhaseUpdate;
+ queue.eagerReducer = reducer;
+ queue.eagerState = newState;
+ }
+
+ return [hook.memoizedState, queue.dispatch];
+ }
+
+ function pushEffect(tag, create, destroy, deps) {
+ tag = {
+ tag: tag,
+ create: create,
+ destroy: destroy,
+ deps: deps,
+ next: null
+ };
+ null === componentUpdateQueue ? (componentUpdateQueue = {
+ lastEffect: null
+ }, componentUpdateQueue.lastEffect = tag.next = tag) : (create = componentUpdateQueue.lastEffect, null === create ? componentUpdateQueue.lastEffect = tag.next = tag : (destroy = create.next, create.next = tag, tag.next = destroy, componentUpdateQueue.lastEffect = tag));
+ return tag;
+ }
+
+ function mountEffectImpl(fiberEffectTag, hookEffectTag, create, deps) {
+ var hook = mountWorkInProgressHook();
+ sideEffectTag |= fiberEffectTag;
+ hook.memoizedState = pushEffect(hookEffectTag, create, void 0, void 0 === deps ? null : deps);
+ }
+
+ function updateEffectImpl(fiberEffectTag, hookEffectTag, create, deps) {
+ var hook = updateWorkInProgressHook();
+ deps = void 0 === deps ? null : deps;
+ var destroy = void 0;
+
+ if (null !== currentHook) {
+ var prevEffect = currentHook.memoizedState;
+ destroy = prevEffect.destroy;
+
+ if (null !== deps && areHookInputsEqual(deps, prevEffect.deps)) {
+ pushEffect(NoEffect$1, create, destroy, deps);
+ return;
+ }
+ }
+
+ sideEffectTag |= fiberEffectTag;
+ hook.memoizedState = pushEffect(hookEffectTag, create, destroy, deps);
+ }
+
+ function imperativeHandleEffect(create, ref) {
+ if ("function" === typeof ref) return create = create(), ref(create), function () {
+ ref(null);
+ };
+ if (null !== ref && void 0 !== ref) return create = create(), ref.current = create, function () {
+ ref.current = null;
+ };
+ }
+
+ function mountDebugValue() {}
+
+ function dispatchAction(fiber, queue, action) {
+ invariant(25 > numberOfReRenders, "Too many re-renders. React limits the number of renders to prevent an infinite loop.");
+ var alternate = fiber.alternate;
+ if (fiber === currentlyRenderingFiber$1 || null !== alternate && alternate === currentlyRenderingFiber$1) {
+ if (didScheduleRenderPhaseUpdate = !0, fiber = {
+ expirationTime: renderExpirationTime,
+ action: action,
+ eagerReducer: null,
+ eagerState: null,
+ next: null
+ }, null === renderPhaseUpdates && (renderPhaseUpdates = new Map()), action = renderPhaseUpdates.get(queue), void 0 === action) renderPhaseUpdates.set(queue, fiber);else {
+ for (queue = action; null !== queue.next;) {
+ queue = queue.next;
+ }
+
+ queue.next = fiber;
+ }
+ } else {
+ flushPassiveEffects();
+ var currentTime = requestCurrentTime();
+ currentTime = computeExpirationForFiber(currentTime, fiber);
+ var _update2 = {
+ expirationTime: currentTime,
+ action: action,
+ eagerReducer: null,
+ eagerState: null,
+ next: null
+ },
+ _last = queue.last;
+ if (null === _last) _update2.next = _update2;else {
+ var first = _last.next;
+ null !== first && (_update2.next = first);
+ _last.next = _update2;
+ }
+ queue.last = _update2;
+ if (0 === fiber.expirationTime && (null === alternate || 0 === alternate.expirationTime) && (alternate = queue.eagerReducer, null !== alternate)) try {
+ var currentState = queue.eagerState,
+ _eagerState = alternate(currentState, action);
+
+ _update2.eagerReducer = alternate;
+ _update2.eagerState = _eagerState;
+ if (is(_eagerState, currentState)) return;
+ } catch (error) {} finally {}
+ scheduleWork(fiber, currentTime);
+ }
+ }
+
+ var ContextOnlyDispatcher = {
+ readContext: readContext,
+ useCallback: throwInvalidHookError,
+ useContext: throwInvalidHookError,
+ useEffect: throwInvalidHookError,
+ useImperativeHandle: throwInvalidHookError,
+ useLayoutEffect: throwInvalidHookError,
+ useMemo: throwInvalidHookError,
+ useReducer: throwInvalidHookError,
+ useRef: throwInvalidHookError,
+ useState: throwInvalidHookError,
+ useDebugValue: throwInvalidHookError
+ },
+ HooksDispatcherOnMount = {
+ readContext: readContext,
+ useCallback: function useCallback(callback, deps) {
+ mountWorkInProgressHook().memoizedState = [callback, void 0 === deps ? null : deps];
+ return callback;
+ },
+ useContext: readContext,
+ useEffect: function useEffect(create, deps) {
+ return mountEffectImpl(516, UnmountPassive | MountPassive, create, deps);
+ },
+ useImperativeHandle: function useImperativeHandle(ref, create, deps) {
+ deps = null !== deps && void 0 !== deps ? deps.concat([ref]) : null;
+ return mountEffectImpl(4, UnmountMutation | MountLayout, imperativeHandleEffect.bind(null, create, ref), deps);
+ },
+ useLayoutEffect: function useLayoutEffect(create, deps) {
+ return mountEffectImpl(4, UnmountMutation | MountLayout, create, deps);
+ },
+ useMemo: function useMemo(nextCreate, deps) {
+ var hook = mountWorkInProgressHook();
+ deps = void 0 === deps ? null : deps;
+ nextCreate = nextCreate();
+ hook.memoizedState = [nextCreate, deps];
+ return nextCreate;
+ },
+ useReducer: function useReducer(reducer, initialArg, init) {
+ var hook = mountWorkInProgressHook();
+ initialArg = void 0 !== init ? init(initialArg) : initialArg;
+ hook.memoizedState = hook.baseState = initialArg;
+ reducer = hook.queue = {
+ last: null,
+ dispatch: null,
+ eagerReducer: reducer,
+ eagerState: initialArg
+ };
+ reducer = reducer.dispatch = dispatchAction.bind(null, currentlyRenderingFiber$1, reducer);
+ return [hook.memoizedState, reducer];
+ },
+ useRef: function useRef(initialValue) {
+ var hook = mountWorkInProgressHook();
+ initialValue = {
+ current: initialValue
+ };
+ return hook.memoizedState = initialValue;
+ },
+ useState: function useState(initialState) {
+ var hook = mountWorkInProgressHook();
+ "function" === typeof initialState && (initialState = initialState());
+ hook.memoizedState = hook.baseState = initialState;
+ initialState = hook.queue = {
+ last: null,
+ dispatch: null,
+ eagerReducer: basicStateReducer,
+ eagerState: initialState
+ };
+ initialState = initialState.dispatch = dispatchAction.bind(null, currentlyRenderingFiber$1, initialState);
+ return [hook.memoizedState, initialState];
+ },
+ useDebugValue: mountDebugValue
+ },
+ HooksDispatcherOnUpdate = {
+ readContext: readContext,
+ useCallback: function useCallback(callback, deps) {
+ var hook = updateWorkInProgressHook();
+ deps = void 0 === deps ? null : deps;
+ var prevState = hook.memoizedState;
+ if (null !== prevState && null !== deps && areHookInputsEqual(deps, prevState[1])) return prevState[0];
+ hook.memoizedState = [callback, deps];
+ return callback;
+ },
+ useContext: readContext,
+ useEffect: function useEffect(create, deps) {
+ return updateEffectImpl(516, UnmountPassive | MountPassive, create, deps);
+ },
+ useImperativeHandle: function useImperativeHandle(ref, create, deps) {
+ deps = null !== deps && void 0 !== deps ? deps.concat([ref]) : null;
+ return updateEffectImpl(4, UnmountMutation | MountLayout, imperativeHandleEffect.bind(null, create, ref), deps);
+ },
+ useLayoutEffect: function useLayoutEffect(create, deps) {
+ return updateEffectImpl(4, UnmountMutation | MountLayout, create, deps);
+ },
+ useMemo: function useMemo(nextCreate, deps) {
+ var hook = updateWorkInProgressHook();
+ deps = void 0 === deps ? null : deps;
+ var prevState = hook.memoizedState;
+ if (null !== prevState && null !== deps && areHookInputsEqual(deps, prevState[1])) return prevState[0];
+ nextCreate = nextCreate();
+ hook.memoizedState = [nextCreate, deps];
+ return nextCreate;
+ },
+ useReducer: updateReducer,
+ useRef: function useRef() {
+ return updateWorkInProgressHook().memoizedState;
+ },
+ useState: function useState(initialState) {
+ return updateReducer(basicStateReducer, initialState);
+ },
+ useDebugValue: mountDebugValue
+ },
+ hydrationParentFiber = null,
+ nextHydratableInstance = null,
+ isHydrating = !1;
+
+ function tryHydrate(fiber, nextInstance) {
+ switch (fiber.tag) {
+ case 5:
+ return nextInstance = shim$1(nextInstance, fiber.type, fiber.pendingProps), null !== nextInstance ? (fiber.stateNode = nextInstance, !0) : !1;
+
+ case 6:
+ return nextInstance = shim$1(nextInstance, fiber.pendingProps), null !== nextInstance ? (fiber.stateNode = nextInstance, !0) : !1;
+
+ case 13:
+ return !1;
+
+ default:
+ return !1;
+ }
+ }
+
+ function tryToClaimNextHydratableInstance(fiber$jscomp$0) {
+ if (isHydrating) {
+ var nextInstance = nextHydratableInstance;
+
+ if (nextInstance) {
+ var firstAttemptedInstance = nextInstance;
+
+ if (!tryHydrate(fiber$jscomp$0, nextInstance)) {
+ nextInstance = shim$1(firstAttemptedInstance);
+
+ if (!nextInstance || !tryHydrate(fiber$jscomp$0, nextInstance)) {
+ fiber$jscomp$0.effectTag |= 2;
+ isHydrating = !1;
+ hydrationParentFiber = fiber$jscomp$0;
+ return;
+ }
+
+ var returnFiber = hydrationParentFiber,
+ fiber = createFiber(5, null, null, 0);
+ fiber.elementType = "DELETED";
+ fiber.type = "DELETED";
+ fiber.stateNode = firstAttemptedInstance;
+ fiber.return = returnFiber;
+ fiber.effectTag = 8;
+ null !== returnFiber.lastEffect ? (returnFiber.lastEffect.nextEffect = fiber, returnFiber.lastEffect = fiber) : returnFiber.firstEffect = returnFiber.lastEffect = fiber;
+ }
+
+ hydrationParentFiber = fiber$jscomp$0;
+ nextHydratableInstance = shim$1(nextInstance);
+ } else fiber$jscomp$0.effectTag |= 2, isHydrating = !1, hydrationParentFiber = fiber$jscomp$0;
+ }
+ }
+
+ var ReactCurrentOwner$3 = ReactSharedInternals.ReactCurrentOwner,
+ didReceiveUpdate = !1;
+
+ function reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime) {
+ workInProgress.child = null === current$$1 ? mountChildFibers(workInProgress, null, nextChildren, renderExpirationTime) : reconcileChildFibers(workInProgress, current$$1.child, nextChildren, renderExpirationTime);
+ }
+
+ function updateForwardRef(current$$1, workInProgress, Component, nextProps, renderExpirationTime) {
+ Component = Component.render;
+ var ref = workInProgress.ref;
+ prepareToReadContext(workInProgress, renderExpirationTime);
+ nextProps = renderWithHooks(current$$1, workInProgress, Component, nextProps, ref, renderExpirationTime);
+ if (null !== current$$1 && !didReceiveUpdate) return workInProgress.updateQueue = current$$1.updateQueue, workInProgress.effectTag &= -517, current$$1.expirationTime <= renderExpirationTime && (current$$1.expirationTime = 0), bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ workInProgress.effectTag |= 1;
+ reconcileChildren(current$$1, workInProgress, nextProps, renderExpirationTime);
+ return workInProgress.child;
+ }
+
+ function updateMemoComponent(current$$1, workInProgress, Component, nextProps, updateExpirationTime, renderExpirationTime) {
+ if (null === current$$1) {
+ var type = Component.type;
+ if ("function" === typeof type && !shouldConstruct(type) && void 0 === type.defaultProps && null === Component.compare && void 0 === Component.defaultProps) return workInProgress.tag = 15, workInProgress.type = type, updateSimpleMemoComponent(current$$1, workInProgress, type, nextProps, updateExpirationTime, renderExpirationTime);
+ current$$1 = createFiberFromTypeAndProps(Component.type, null, nextProps, null, workInProgress.mode, renderExpirationTime);
+ current$$1.ref = workInProgress.ref;
+ current$$1.return = workInProgress;
+ return workInProgress.child = current$$1;
+ }
+
+ type = current$$1.child;
+ if (updateExpirationTime < renderExpirationTime && (updateExpirationTime = type.memoizedProps, Component = Component.compare, Component = null !== Component ? Component : shallowEqual, Component(updateExpirationTime, nextProps) && current$$1.ref === workInProgress.ref)) return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ workInProgress.effectTag |= 1;
+ current$$1 = createWorkInProgress(type, nextProps, renderExpirationTime);
+ current$$1.ref = workInProgress.ref;
+ current$$1.return = workInProgress;
+ return workInProgress.child = current$$1;
+ }
+
+ function updateSimpleMemoComponent(current$$1, workInProgress, Component, nextProps, updateExpirationTime, renderExpirationTime) {
+ return null !== current$$1 && shallowEqual(current$$1.memoizedProps, nextProps) && current$$1.ref === workInProgress.ref && (didReceiveUpdate = !1, updateExpirationTime < renderExpirationTime) ? bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime) : updateFunctionComponent(current$$1, workInProgress, Component, nextProps, renderExpirationTime);
+ }
+
+ function markRef(current$$1, workInProgress) {
+ var ref = workInProgress.ref;
+ if (null === current$$1 && null !== ref || null !== current$$1 && current$$1.ref !== ref) workInProgress.effectTag |= 128;
+ }
+
+ function updateFunctionComponent(current$$1, workInProgress, Component, nextProps, renderExpirationTime) {
+ var unmaskedContext = isContextProvider(Component) ? previousContext : contextStackCursor.current;
+ unmaskedContext = getMaskedContext(workInProgress, unmaskedContext);
+ prepareToReadContext(workInProgress, renderExpirationTime);
+ Component = renderWithHooks(current$$1, workInProgress, Component, nextProps, unmaskedContext, renderExpirationTime);
+ if (null !== current$$1 && !didReceiveUpdate) return workInProgress.updateQueue = current$$1.updateQueue, workInProgress.effectTag &= -517, current$$1.expirationTime <= renderExpirationTime && (current$$1.expirationTime = 0), bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ workInProgress.effectTag |= 1;
+ reconcileChildren(current$$1, workInProgress, Component, renderExpirationTime);
+ return workInProgress.child;
+ }
+
+ function updateClassComponent(current$$1, workInProgress, Component, nextProps, renderExpirationTime) {
+ if (isContextProvider(Component)) {
+ var hasContext = !0;
+ pushContextProvider(workInProgress);
+ } else hasContext = !1;
+
+ prepareToReadContext(workInProgress, renderExpirationTime);
+ if (null === workInProgress.stateNode) null !== current$$1 && (current$$1.alternate = null, workInProgress.alternate = null, workInProgress.effectTag |= 2), constructClassInstance(workInProgress, Component, nextProps, renderExpirationTime), mountClassInstance(workInProgress, Component, nextProps, renderExpirationTime), nextProps = !0;else if (null === current$$1) {
+ var instance = workInProgress.stateNode,
+ oldProps = workInProgress.memoizedProps;
+ instance.props = oldProps;
+ var oldContext = instance.context,
+ contextType = Component.contextType;
+ "object" === typeof contextType && null !== contextType ? contextType = readContext(contextType) : (contextType = isContextProvider(Component) ? previousContext : contextStackCursor.current, contextType = getMaskedContext(workInProgress, contextType));
+ var getDerivedStateFromProps = Component.getDerivedStateFromProps,
+ hasNewLifecycles = "function" === typeof getDerivedStateFromProps || "function" === typeof instance.getSnapshotBeforeUpdate;
+ hasNewLifecycles || "function" !== typeof instance.UNSAFE_componentWillReceiveProps && "function" !== typeof instance.componentWillReceiveProps || (oldProps !== nextProps || oldContext !== contextType) && callComponentWillReceiveProps(workInProgress, instance, nextProps, contextType);
+ hasForceUpdate = !1;
+ var oldState = workInProgress.memoizedState;
+ oldContext = instance.state = oldState;
+ var updateQueue = workInProgress.updateQueue;
+ null !== updateQueue && (processUpdateQueue(workInProgress, updateQueue, nextProps, instance, renderExpirationTime), oldContext = workInProgress.memoizedState);
+ oldProps !== nextProps || oldState !== oldContext || didPerformWorkStackCursor.current || hasForceUpdate ? ("function" === typeof getDerivedStateFromProps && (applyDerivedStateFromProps(workInProgress, Component, getDerivedStateFromProps, nextProps), oldContext = workInProgress.memoizedState), (oldProps = hasForceUpdate || checkShouldComponentUpdate(workInProgress, Component, oldProps, nextProps, oldState, oldContext, contextType)) ? (hasNewLifecycles || "function" !== typeof instance.UNSAFE_componentWillMount && "function" !== typeof instance.componentWillMount || ("function" === typeof instance.componentWillMount && instance.componentWillMount(), "function" === typeof instance.UNSAFE_componentWillMount && instance.UNSAFE_componentWillMount()), "function" === typeof instance.componentDidMount && (workInProgress.effectTag |= 4)) : ("function" === typeof instance.componentDidMount && (workInProgress.effectTag |= 4), workInProgress.memoizedProps = nextProps, workInProgress.memoizedState = oldContext), instance.props = nextProps, instance.state = oldContext, instance.context = contextType, nextProps = oldProps) : ("function" === typeof instance.componentDidMount && (workInProgress.effectTag |= 4), nextProps = !1);
+ } else instance = workInProgress.stateNode, oldProps = workInProgress.memoizedProps, instance.props = workInProgress.type === workInProgress.elementType ? oldProps : resolveDefaultProps(workInProgress.type, oldProps), oldContext = instance.context, contextType = Component.contextType, "object" === typeof contextType && null !== contextType ? contextType = readContext(contextType) : (contextType = isContextProvider(Component) ? previousContext : contextStackCursor.current, contextType = getMaskedContext(workInProgress, contextType)), getDerivedStateFromProps = Component.getDerivedStateFromProps, (hasNewLifecycles = "function" === typeof getDerivedStateFromProps || "function" === typeof instance.getSnapshotBeforeUpdate) || "function" !== typeof instance.UNSAFE_componentWillReceiveProps && "function" !== typeof instance.componentWillReceiveProps || (oldProps !== nextProps || oldContext !== contextType) && callComponentWillReceiveProps(workInProgress, instance, nextProps, contextType), hasForceUpdate = !1, oldContext = workInProgress.memoizedState, oldState = instance.state = oldContext, updateQueue = workInProgress.updateQueue, null !== updateQueue && (processUpdateQueue(workInProgress, updateQueue, nextProps, instance, renderExpirationTime), oldState = workInProgress.memoizedState), oldProps !== nextProps || oldContext !== oldState || didPerformWorkStackCursor.current || hasForceUpdate ? ("function" === typeof getDerivedStateFromProps && (applyDerivedStateFromProps(workInProgress, Component, getDerivedStateFromProps, nextProps), oldState = workInProgress.memoizedState), (getDerivedStateFromProps = hasForceUpdate || checkShouldComponentUpdate(workInProgress, Component, oldProps, nextProps, oldContext, oldState, contextType)) ? (hasNewLifecycles || "function" !== typeof instance.UNSAFE_componentWillUpdate && "function" !== typeof instance.componentWillUpdate || ("function" === typeof instance.componentWillUpdate && instance.componentWillUpdate(nextProps, oldState, contextType), "function" === typeof instance.UNSAFE_componentWillUpdate && instance.UNSAFE_componentWillUpdate(nextProps, oldState, contextType)), "function" === typeof instance.componentDidUpdate && (workInProgress.effectTag |= 4), "function" === typeof instance.getSnapshotBeforeUpdate && (workInProgress.effectTag |= 256)) : ("function" !== typeof instance.componentDidUpdate || oldProps === current$$1.memoizedProps && oldContext === current$$1.memoizedState || (workInProgress.effectTag |= 4), "function" !== typeof instance.getSnapshotBeforeUpdate || oldProps === current$$1.memoizedProps && oldContext === current$$1.memoizedState || (workInProgress.effectTag |= 256), workInProgress.memoizedProps = nextProps, workInProgress.memoizedState = oldState), instance.props = nextProps, instance.state = oldState, instance.context = contextType, nextProps = getDerivedStateFromProps) : ("function" !== typeof instance.componentDidUpdate || oldProps === current$$1.memoizedProps && oldContext === current$$1.memoizedState || (workInProgress.effectTag |= 4), "function" !== typeof instance.getSnapshotBeforeUpdate || oldProps === current$$1.memoizedProps && oldContext === current$$1.memoizedState || (workInProgress.effectTag |= 256), nextProps = !1);
+ return finishClassComponent(current$$1, workInProgress, Component, nextProps, hasContext, renderExpirationTime);
+ }
+
+ function finishClassComponent(current$$1, workInProgress, Component, shouldUpdate, hasContext, renderExpirationTime) {
+ markRef(current$$1, workInProgress);
+ var didCaptureError = 0 !== (workInProgress.effectTag & 64);
+ if (!shouldUpdate && !didCaptureError) return hasContext && invalidateContextProvider(workInProgress, Component, !1), bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ shouldUpdate = workInProgress.stateNode;
+ ReactCurrentOwner$3.current = workInProgress;
+ var nextChildren = didCaptureError && "function" !== typeof Component.getDerivedStateFromError ? null : shouldUpdate.render();
+ workInProgress.effectTag |= 1;
+ null !== current$$1 && didCaptureError ? (workInProgress.child = reconcileChildFibers(workInProgress, current$$1.child, null, renderExpirationTime), workInProgress.child = reconcileChildFibers(workInProgress, null, nextChildren, renderExpirationTime)) : reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
+ workInProgress.memoizedState = shouldUpdate.state;
+ hasContext && invalidateContextProvider(workInProgress, Component, !0);
+ return workInProgress.child;
+ }
+
+ function pushHostRootContext(workInProgress) {
+ var root = workInProgress.stateNode;
+ root.pendingContext ? pushTopLevelContextObject(workInProgress, root.pendingContext, root.pendingContext !== root.context) : root.context && pushTopLevelContextObject(workInProgress, root.context, !1);
+ pushHostContainer(workInProgress, root.containerInfo);
+ }
+
+ function updateSuspenseComponent(current$$1, workInProgress, renderExpirationTime) {
+ var mode = workInProgress.mode,
+ nextProps = workInProgress.pendingProps,
+ nextState = workInProgress.memoizedState;
+
+ if (0 === (workInProgress.effectTag & 64)) {
+ nextState = null;
+ var nextDidTimeout = !1;
+ } else nextState = {
+ timedOutAt: null !== nextState ? nextState.timedOutAt : 0
+ }, nextDidTimeout = !0, workInProgress.effectTag &= -65;
+
+ if (null === current$$1) {
+ if (nextDidTimeout) {
+ var nextFallbackChildren = nextProps.fallback;
+ current$$1 = createFiberFromFragment(null, mode, 0, null);
+ 0 === (workInProgress.mode & 1) && (current$$1.child = null !== workInProgress.memoizedState ? workInProgress.child.child : workInProgress.child);
+ mode = createFiberFromFragment(nextFallbackChildren, mode, renderExpirationTime, null);
+ current$$1.sibling = mode;
+ renderExpirationTime = current$$1;
+ renderExpirationTime.return = mode.return = workInProgress;
+ } else renderExpirationTime = mode = mountChildFibers(workInProgress, null, nextProps.children, renderExpirationTime);
+ } else null !== current$$1.memoizedState ? (mode = current$$1.child, nextFallbackChildren = mode.sibling, nextDidTimeout ? (renderExpirationTime = nextProps.fallback, nextProps = createWorkInProgress(mode, mode.pendingProps, 0), 0 === (workInProgress.mode & 1) && (nextDidTimeout = null !== workInProgress.memoizedState ? workInProgress.child.child : workInProgress.child, nextDidTimeout !== mode.child && (nextProps.child = nextDidTimeout)), mode = nextProps.sibling = createWorkInProgress(nextFallbackChildren, renderExpirationTime, nextFallbackChildren.expirationTime), renderExpirationTime = nextProps, nextProps.childExpirationTime = 0, renderExpirationTime.return = mode.return = workInProgress) : renderExpirationTime = mode = reconcileChildFibers(workInProgress, mode.child, nextProps.children, renderExpirationTime)) : (nextFallbackChildren = current$$1.child, nextDidTimeout ? (nextDidTimeout = nextProps.fallback, nextProps = createFiberFromFragment(null, mode, 0, null), nextProps.child = nextFallbackChildren, 0 === (workInProgress.mode & 1) && (nextProps.child = null !== workInProgress.memoizedState ? workInProgress.child.child : workInProgress.child), mode = nextProps.sibling = createFiberFromFragment(nextDidTimeout, mode, renderExpirationTime, null), mode.effectTag |= 2, renderExpirationTime = nextProps, nextProps.childExpirationTime = 0, renderExpirationTime.return = mode.return = workInProgress) : mode = renderExpirationTime = reconcileChildFibers(workInProgress, nextFallbackChildren, nextProps.children, renderExpirationTime)), workInProgress.stateNode = current$$1.stateNode;
+ workInProgress.memoizedState = nextState;
+ workInProgress.child = renderExpirationTime;
+ return mode;
+ }
+
+ function bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime) {
+ null !== current$$1 && (workInProgress.contextDependencies = current$$1.contextDependencies);
+ if (workInProgress.childExpirationTime < renderExpirationTime) return null;
+ invariant(null === current$$1 || workInProgress.child === current$$1.child, "Resuming work not yet implemented.");
+
+ if (null !== workInProgress.child) {
+ current$$1 = workInProgress.child;
+ renderExpirationTime = createWorkInProgress(current$$1, current$$1.pendingProps, current$$1.expirationTime);
+ workInProgress.child = renderExpirationTime;
+
+ for (renderExpirationTime.return = workInProgress; null !== current$$1.sibling;) {
+ current$$1 = current$$1.sibling, renderExpirationTime = renderExpirationTime.sibling = createWorkInProgress(current$$1, current$$1.pendingProps, current$$1.expirationTime), renderExpirationTime.return = workInProgress;
+ }
+
+ renderExpirationTime.sibling = null;
+ }
+
+ return workInProgress.child;
+ }
+
+ function beginWork(current$$1, workInProgress, renderExpirationTime) {
+ var updateExpirationTime = workInProgress.expirationTime;
+ if (null !== current$$1) {
+ if (current$$1.memoizedProps !== workInProgress.pendingProps || didPerformWorkStackCursor.current) didReceiveUpdate = !0;else {
+ if (updateExpirationTime < renderExpirationTime) {
+ didReceiveUpdate = !1;
+
+ switch (workInProgress.tag) {
+ case 3:
+ pushHostRootContext(workInProgress);
+ break;
+
+ case 5:
+ pushHostContext(workInProgress);
+ break;
+
+ case 1:
+ isContextProvider(workInProgress.type) && pushContextProvider(workInProgress);
+ break;
+
+ case 4:
+ pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+ break;
+
+ case 10:
+ pushProvider(workInProgress, workInProgress.memoizedProps.value);
+ break;
+
+ case 13:
+ if (null !== workInProgress.memoizedState) {
+ updateExpirationTime = workInProgress.child.childExpirationTime;
+ if (0 !== updateExpirationTime && updateExpirationTime >= renderExpirationTime) return updateSuspenseComponent(current$$1, workInProgress, renderExpirationTime);
+ workInProgress = bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ return null !== workInProgress ? workInProgress.sibling : null;
+ }
+
+ }
+
+ return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ }
+ }
+ } else didReceiveUpdate = !1;
+ workInProgress.expirationTime = 0;
+
+ switch (workInProgress.tag) {
+ case 2:
+ updateExpirationTime = workInProgress.elementType;
+ null !== current$$1 && (current$$1.alternate = null, workInProgress.alternate = null, workInProgress.effectTag |= 2);
+ current$$1 = workInProgress.pendingProps;
+ var context = getMaskedContext(workInProgress, contextStackCursor.current);
+ prepareToReadContext(workInProgress, renderExpirationTime);
+ context = renderWithHooks(null, workInProgress, updateExpirationTime, current$$1, context, renderExpirationTime);
+ workInProgress.effectTag |= 1;
+
+ if ("object" === typeof context && null !== context && "function" === typeof context.render && void 0 === context.$$typeof) {
+ workInProgress.tag = 1;
+ resetHooks();
+
+ if (isContextProvider(updateExpirationTime)) {
+ var hasContext = !0;
+ pushContextProvider(workInProgress);
+ } else hasContext = !1;
+
+ workInProgress.memoizedState = null !== context.state && void 0 !== context.state ? context.state : null;
+ var getDerivedStateFromProps = updateExpirationTime.getDerivedStateFromProps;
+ "function" === typeof getDerivedStateFromProps && applyDerivedStateFromProps(workInProgress, updateExpirationTime, getDerivedStateFromProps, current$$1);
+ context.updater = classComponentUpdater;
+ workInProgress.stateNode = context;
+ context._reactInternalFiber = workInProgress;
+ mountClassInstance(workInProgress, updateExpirationTime, current$$1, renderExpirationTime);
+ workInProgress = finishClassComponent(null, workInProgress, updateExpirationTime, !0, hasContext, renderExpirationTime);
+ } else workInProgress.tag = 0, reconcileChildren(null, workInProgress, context, renderExpirationTime), workInProgress = workInProgress.child;
+
+ return workInProgress;
+
+ case 16:
+ context = workInProgress.elementType;
+ null !== current$$1 && (current$$1.alternate = null, workInProgress.alternate = null, workInProgress.effectTag |= 2);
+ hasContext = workInProgress.pendingProps;
+ current$$1 = readLazyComponentType(context);
+ workInProgress.type = current$$1;
+ context = workInProgress.tag = resolveLazyComponentTag(current$$1);
+ hasContext = resolveDefaultProps(current$$1, hasContext);
+ getDerivedStateFromProps = void 0;
+
+ switch (context) {
+ case 0:
+ getDerivedStateFromProps = updateFunctionComponent(null, workInProgress, current$$1, hasContext, renderExpirationTime);
+ break;
+
+ case 1:
+ getDerivedStateFromProps = updateClassComponent(null, workInProgress, current$$1, hasContext, renderExpirationTime);
+ break;
+
+ case 11:
+ getDerivedStateFromProps = updateForwardRef(null, workInProgress, current$$1, hasContext, renderExpirationTime);
+ break;
+
+ case 14:
+ getDerivedStateFromProps = updateMemoComponent(null, workInProgress, current$$1, resolveDefaultProps(current$$1.type, hasContext), updateExpirationTime, renderExpirationTime);
+ break;
+
+ default:
+ invariant(!1, "Element type is invalid. Received a promise that resolves to: %s. Lazy element type must resolve to a class or function.%s", current$$1, "");
+ }
+
+ return getDerivedStateFromProps;
+
+ case 0:
+ return updateExpirationTime = workInProgress.type, context = workInProgress.pendingProps, context = workInProgress.elementType === updateExpirationTime ? context : resolveDefaultProps(updateExpirationTime, context), updateFunctionComponent(current$$1, workInProgress, updateExpirationTime, context, renderExpirationTime);
+
+ case 1:
+ return updateExpirationTime = workInProgress.type, context = workInProgress.pendingProps, context = workInProgress.elementType === updateExpirationTime ? context : resolveDefaultProps(updateExpirationTime, context), updateClassComponent(current$$1, workInProgress, updateExpirationTime, context, renderExpirationTime);
+
+ case 3:
+ return pushHostRootContext(workInProgress), updateExpirationTime = workInProgress.updateQueue, invariant(null !== updateExpirationTime, "If the root does not have an updateQueue, we should have already bailed out. This error is likely caused by a bug in React. Please file an issue."), context = workInProgress.memoizedState, context = null !== context ? context.element : null, processUpdateQueue(workInProgress, updateExpirationTime, workInProgress.pendingProps, null, renderExpirationTime), updateExpirationTime = workInProgress.memoizedState.element, updateExpirationTime === context ? workInProgress = bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime) : (reconcileChildren(current$$1, workInProgress, updateExpirationTime, renderExpirationTime), workInProgress = workInProgress.child), workInProgress;
+
+ case 5:
+ return pushHostContext(workInProgress), null === current$$1 && tryToClaimNextHydratableInstance(workInProgress), updateExpirationTime = workInProgress.pendingProps.children, markRef(current$$1, workInProgress), reconcileChildren(current$$1, workInProgress, updateExpirationTime, renderExpirationTime), workInProgress = workInProgress.child, workInProgress;
+
+ case 6:
+ return null === current$$1 && tryToClaimNextHydratableInstance(workInProgress), null;
+
+ case 13:
+ return updateSuspenseComponent(current$$1, workInProgress, renderExpirationTime);
+
+ case 4:
+ return pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo), updateExpirationTime = workInProgress.pendingProps, null === current$$1 ? workInProgress.child = reconcileChildFibers(workInProgress, null, updateExpirationTime, renderExpirationTime) : reconcileChildren(current$$1, workInProgress, updateExpirationTime, renderExpirationTime), workInProgress.child;
+
+ case 11:
+ return updateExpirationTime = workInProgress.type, context = workInProgress.pendingProps, context = workInProgress.elementType === updateExpirationTime ? context : resolveDefaultProps(updateExpirationTime, context), updateForwardRef(current$$1, workInProgress, updateExpirationTime, context, renderExpirationTime);
+
+ case 7:
+ return reconcileChildren(current$$1, workInProgress, workInProgress.pendingProps, renderExpirationTime), workInProgress.child;
+
+ case 8:
+ return reconcileChildren(current$$1, workInProgress, workInProgress.pendingProps.children, renderExpirationTime), workInProgress.child;
+
+ case 12:
+ return reconcileChildren(current$$1, workInProgress, workInProgress.pendingProps.children, renderExpirationTime), workInProgress.child;
+
+ case 10:
+ a: {
+ updateExpirationTime = workInProgress.type._context;
+ context = workInProgress.pendingProps;
+ getDerivedStateFromProps = workInProgress.memoizedProps;
+ hasContext = context.value;
+ pushProvider(workInProgress, hasContext);
+
+ if (null !== getDerivedStateFromProps) {
+ var oldValue = getDerivedStateFromProps.value;
+ hasContext = is(oldValue, hasContext) ? 0 : ("function" === typeof updateExpirationTime._calculateChangedBits ? updateExpirationTime._calculateChangedBits(oldValue, hasContext) : 1073741823) | 0;
+
+ if (0 === hasContext) {
+ if (getDerivedStateFromProps.children === context.children && !didPerformWorkStackCursor.current) {
+ workInProgress = bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ break a;
+ }
+ } else for (oldValue = workInProgress.child, null !== oldValue && (oldValue.return = workInProgress); null !== oldValue;) {
+ var list = oldValue.contextDependencies;
+
+ if (null !== list) {
+ getDerivedStateFromProps = oldValue.child;
+
+ for (var dependency = list.first; null !== dependency;) {
+ if (dependency.context === updateExpirationTime && 0 !== (dependency.observedBits & hasContext)) {
+ 1 === oldValue.tag && (dependency = createUpdate(renderExpirationTime), dependency.tag = ForceUpdate, enqueueUpdate(oldValue, dependency));
+ oldValue.expirationTime < renderExpirationTime && (oldValue.expirationTime = renderExpirationTime);
+ dependency = oldValue.alternate;
+ null !== dependency && dependency.expirationTime < renderExpirationTime && (dependency.expirationTime = renderExpirationTime);
+ dependency = renderExpirationTime;
+
+ for (var node = oldValue.return; null !== node;) {
+ var alternate = node.alternate;
+ if (node.childExpirationTime < dependency) node.childExpirationTime = dependency, null !== alternate && alternate.childExpirationTime < dependency && (alternate.childExpirationTime = dependency);else if (null !== alternate && alternate.childExpirationTime < dependency) alternate.childExpirationTime = dependency;else break;
+ node = node.return;
+ }
+
+ list.expirationTime < renderExpirationTime && (list.expirationTime = renderExpirationTime);
+ break;
+ }
+
+ dependency = dependency.next;
+ }
+ } else getDerivedStateFromProps = 10 === oldValue.tag ? oldValue.type === workInProgress.type ? null : oldValue.child : oldValue.child;
+
+ if (null !== getDerivedStateFromProps) getDerivedStateFromProps.return = oldValue;else for (getDerivedStateFromProps = oldValue; null !== getDerivedStateFromProps;) {
+ if (getDerivedStateFromProps === workInProgress) {
+ getDerivedStateFromProps = null;
+ break;
+ }
+
+ oldValue = getDerivedStateFromProps.sibling;
+
+ if (null !== oldValue) {
+ oldValue.return = getDerivedStateFromProps.return;
+ getDerivedStateFromProps = oldValue;
+ break;
+ }
+
+ getDerivedStateFromProps = getDerivedStateFromProps.return;
+ }
+ oldValue = getDerivedStateFromProps;
+ }
+ }
+
+ reconcileChildren(current$$1, workInProgress, context.children, renderExpirationTime);
+ workInProgress = workInProgress.child;
+ }
+
+ return workInProgress;
+
+ case 9:
+ return context = workInProgress.type, hasContext = workInProgress.pendingProps, updateExpirationTime = hasContext.children, prepareToReadContext(workInProgress, renderExpirationTime), context = readContext(context, hasContext.unstable_observedBits), updateExpirationTime = updateExpirationTime(context), workInProgress.effectTag |= 1, reconcileChildren(current$$1, workInProgress, updateExpirationTime, renderExpirationTime), workInProgress.child;
+
+ case 14:
+ return context = workInProgress.type, hasContext = resolveDefaultProps(context, workInProgress.pendingProps), hasContext = resolveDefaultProps(context.type, hasContext), updateMemoComponent(current$$1, workInProgress, context, hasContext, updateExpirationTime, renderExpirationTime);
+
+ case 15:
+ return updateSimpleMemoComponent(current$$1, workInProgress, workInProgress.type, workInProgress.pendingProps, updateExpirationTime, renderExpirationTime);
+
+ case 17:
+ return updateExpirationTime = workInProgress.type, context = workInProgress.pendingProps, context = workInProgress.elementType === updateExpirationTime ? context : resolveDefaultProps(updateExpirationTime, context), null !== current$$1 && (current$$1.alternate = null, workInProgress.alternate = null, workInProgress.effectTag |= 2), workInProgress.tag = 1, isContextProvider(updateExpirationTime) ? (current$$1 = !0, pushContextProvider(workInProgress)) : current$$1 = !1, prepareToReadContext(workInProgress, renderExpirationTime), constructClassInstance(workInProgress, updateExpirationTime, context, renderExpirationTime), mountClassInstance(workInProgress, updateExpirationTime, context, renderExpirationTime), finishClassComponent(null, workInProgress, updateExpirationTime, !0, current$$1, renderExpirationTime);
+ }
+
+ invariant(!1, "Unknown unit of work tag. This error is likely caused by a bug in React. Please file an issue.");
+ }
+
+ var valueCursor = {
+ current: null
+ },
+ currentlyRenderingFiber = null,
+ lastContextDependency = null,
+ lastContextWithAllBitsObserved = null;
+
+ function pushProvider(providerFiber, nextValue) {
+ var context = providerFiber.type._context;
+ push(valueCursor, context._currentValue, providerFiber);
+ context._currentValue = nextValue;
+ }
+
+ function popProvider(providerFiber) {
+ var currentValue = valueCursor.current;
+ pop(valueCursor, providerFiber);
+ providerFiber.type._context._currentValue = currentValue;
+ }
+
+ function prepareToReadContext(workInProgress, renderExpirationTime) {
+ currentlyRenderingFiber = workInProgress;
+ lastContextWithAllBitsObserved = lastContextDependency = null;
+ var currentDependencies = workInProgress.contextDependencies;
+ null !== currentDependencies && currentDependencies.expirationTime >= renderExpirationTime && (didReceiveUpdate = !0);
+ workInProgress.contextDependencies = null;
+ }
+
+ function readContext(context, observedBits) {
+ if (lastContextWithAllBitsObserved !== context && !1 !== observedBits && 0 !== observedBits) {
+ if ("number" !== typeof observedBits || 1073741823 === observedBits) lastContextWithAllBitsObserved = context, observedBits = 1073741823;
+ observedBits = {
+ context: context,
+ observedBits: observedBits,
+ next: null
+ };
+ null === lastContextDependency ? (invariant(null !== currentlyRenderingFiber, "Context can only be read while React is rendering. In classes, you can read it in the render method or getDerivedStateFromProps. In function components, you can read it directly in the function body, but not inside Hooks like useReducer() or useMemo()."), lastContextDependency = observedBits, currentlyRenderingFiber.contextDependencies = {
+ first: observedBits,
+ expirationTime: 0
+ }) : lastContextDependency = lastContextDependency.next = observedBits;
+ }
+
+ return context._currentValue;
+ }
+
+ var UpdateState = 0,
+ ReplaceState = 1,
+ ForceUpdate = 2,
+ CaptureUpdate = 3,
+ hasForceUpdate = !1;
+
+ function createUpdateQueue(baseState) {
+ return {
+ baseState: baseState,
+ firstUpdate: null,
+ lastUpdate: null,
+ firstCapturedUpdate: null,
+ lastCapturedUpdate: null,
+ firstEffect: null,
+ lastEffect: null,
+ firstCapturedEffect: null,
+ lastCapturedEffect: null
+ };
+ }
+
+ function cloneUpdateQueue(currentQueue) {
+ return {
+ baseState: currentQueue.baseState,
+ firstUpdate: currentQueue.firstUpdate,
+ lastUpdate: currentQueue.lastUpdate,
+ firstCapturedUpdate: null,
+ lastCapturedUpdate: null,
+ firstEffect: null,
+ lastEffect: null,
+ firstCapturedEffect: null,
+ lastCapturedEffect: null
+ };
+ }
+
+ function createUpdate(expirationTime) {
+ return {
+ expirationTime: expirationTime,
+ tag: UpdateState,
+ payload: null,
+ callback: null,
+ next: null,
+ nextEffect: null
+ };
+ }
+
+ function appendUpdateToQueue(queue, update) {
+ null === queue.lastUpdate ? queue.firstUpdate = queue.lastUpdate = update : (queue.lastUpdate.next = update, queue.lastUpdate = update);
+ }
+
+ function enqueueUpdate(fiber, update) {
+ var alternate = fiber.alternate;
+
+ if (null === alternate) {
+ var queue1 = fiber.updateQueue;
+ var queue2 = null;
+ null === queue1 && (queue1 = fiber.updateQueue = createUpdateQueue(fiber.memoizedState));
+ } else queue1 = fiber.updateQueue, queue2 = alternate.updateQueue, null === queue1 ? null === queue2 ? (queue1 = fiber.updateQueue = createUpdateQueue(fiber.memoizedState), queue2 = alternate.updateQueue = createUpdateQueue(alternate.memoizedState)) : queue1 = fiber.updateQueue = cloneUpdateQueue(queue2) : null === queue2 && (queue2 = alternate.updateQueue = cloneUpdateQueue(queue1));
+
+ null === queue2 || queue1 === queue2 ? appendUpdateToQueue(queue1, update) : null === queue1.lastUpdate || null === queue2.lastUpdate ? (appendUpdateToQueue(queue1, update), appendUpdateToQueue(queue2, update)) : (appendUpdateToQueue(queue1, update), queue2.lastUpdate = update);
+ }
+
+ function enqueueCapturedUpdate(workInProgress, update) {
+ var workInProgressQueue = workInProgress.updateQueue;
+ workInProgressQueue = null === workInProgressQueue ? workInProgress.updateQueue = createUpdateQueue(workInProgress.memoizedState) : ensureWorkInProgressQueueIsAClone(workInProgress, workInProgressQueue);
+ null === workInProgressQueue.lastCapturedUpdate ? workInProgressQueue.firstCapturedUpdate = workInProgressQueue.lastCapturedUpdate = update : (workInProgressQueue.lastCapturedUpdate.next = update, workInProgressQueue.lastCapturedUpdate = update);
+ }
+
+ function ensureWorkInProgressQueueIsAClone(workInProgress, queue) {
+ var current = workInProgress.alternate;
+ null !== current && queue === current.updateQueue && (queue = workInProgress.updateQueue = cloneUpdateQueue(queue));
+ return queue;
+ }
+
+ function getStateFromUpdate(workInProgress, queue, update, prevState, nextProps, instance) {
+ switch (update.tag) {
+ case ReplaceState:
+ return workInProgress = update.payload, "function" === typeof workInProgress ? workInProgress.call(instance, prevState, nextProps) : workInProgress;
+
+ case CaptureUpdate:
+ workInProgress.effectTag = workInProgress.effectTag & -2049 | 64;
+
+ case UpdateState:
+ 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 ForceUpdate:
+ hasForceUpdate = !0;
+ }
+
+ return prevState;
+ }
+
+ function processUpdateQueue(workInProgress, queue, props, instance, renderExpirationTime) {
+ hasForceUpdate = !1;
+ queue = ensureWorkInProgressQueueIsAClone(workInProgress, queue);
+
+ for (var newBaseState = queue.baseState, newFirstUpdate = null, newExpirationTime = 0, update = queue.firstUpdate, resultState = newBaseState; null !== update;) {
+ var updateExpirationTime = update.expirationTime;
+ updateExpirationTime < renderExpirationTime ? (null === newFirstUpdate && (newFirstUpdate = update, newBaseState = resultState), newExpirationTime < updateExpirationTime && (newExpirationTime = updateExpirationTime)) : (resultState = getStateFromUpdate(workInProgress, queue, update, resultState, props, instance), null !== update.callback && (workInProgress.effectTag |= 32, update.nextEffect = null, null === queue.lastEffect ? queue.firstEffect = queue.lastEffect = update : (queue.lastEffect.nextEffect = update, queue.lastEffect = update)));
+ update = update.next;
+ }
+
+ updateExpirationTime = null;
+
+ for (update = queue.firstCapturedUpdate; null !== update;) {
+ var _updateExpirationTime = update.expirationTime;
+ _updateExpirationTime < renderExpirationTime ? (null === updateExpirationTime && (updateExpirationTime = update, null === newFirstUpdate && (newBaseState = resultState)), newExpirationTime < _updateExpirationTime && (newExpirationTime = _updateExpirationTime)) : (resultState = getStateFromUpdate(workInProgress, queue, update, resultState, props, instance), null !== update.callback && (workInProgress.effectTag |= 32, update.nextEffect = null, null === queue.lastCapturedEffect ? queue.firstCapturedEffect = queue.lastCapturedEffect = update : (queue.lastCapturedEffect.nextEffect = update, queue.lastCapturedEffect = update)));
+ update = update.next;
+ }
+
+ null === newFirstUpdate && (queue.lastUpdate = null);
+ null === updateExpirationTime ? queue.lastCapturedUpdate = null : workInProgress.effectTag |= 32;
+ null === newFirstUpdate && null === updateExpirationTime && (newBaseState = resultState);
+ queue.baseState = newBaseState;
+ queue.firstUpdate = newFirstUpdate;
+ queue.firstCapturedUpdate = updateExpirationTime;
+ workInProgress.expirationTime = newExpirationTime;
+ workInProgress.memoizedState = resultState;
+ }
+
+ function commitUpdateQueue(finishedWork, finishedQueue, instance) {
+ null !== finishedQueue.firstCapturedUpdate && (null !== finishedQueue.lastUpdate && (finishedQueue.lastUpdate.next = finishedQueue.firstCapturedUpdate, finishedQueue.lastUpdate = finishedQueue.lastCapturedUpdate), finishedQueue.firstCapturedUpdate = finishedQueue.lastCapturedUpdate = null);
+ commitUpdateEffects(finishedQueue.firstEffect, instance);
+ finishedQueue.firstEffect = finishedQueue.lastEffect = null;
+ commitUpdateEffects(finishedQueue.firstCapturedEffect, instance);
+ finishedQueue.firstCapturedEffect = finishedQueue.lastCapturedEffect = null;
+ }
+
+ function commitUpdateEffects(effect, instance) {
+ for (; null !== effect;) {
+ var _callback3 = effect.callback;
+
+ if (null !== _callback3) {
+ effect.callback = null;
+ var context = instance;
+ invariant("function" === typeof _callback3, "Invalid argument passed as callback. Expected a function. Instead received: %s", _callback3);
+
+ _callback3.call(context);
+ }
+
+ effect = effect.nextEffect;
+ }
+ }
+
+ function createCapturedValue(value, source) {
+ return {
+ value: value,
+ source: source,
+ stack: getStackByFiberInDevAndProd(source)
+ };
+ }
+
+ var appendAllChildren = void 0,
+ updateHostContainer = void 0,
+ updateHostComponent$1 = void 0,
+ updateHostText$1 = void 0;
+
+ appendAllChildren = function appendAllChildren(parent, workInProgress) {
+ for (var node = workInProgress.child; null !== node;) {
+ if (5 === node.tag || 6 === node.tag) parent._children.push(node.stateNode);else if (4 !== node.tag && null !== node.child) {
+ node.child.return = node;
+ node = node.child;
+ continue;
+ }
+ if (node === workInProgress) break;
+
+ for (; null === node.sibling;) {
+ if (null === node.return || node.return === workInProgress) return;
+ node = node.return;
+ }
+
+ node.sibling.return = node.return;
+ node = node.sibling;
+ }
+ };
+
+ updateHostContainer = function updateHostContainer() {};
+
+ updateHostComponent$1 = function updateHostComponent$1(current, workInProgress, type, newProps) {
+ current.memoizedProps !== newProps && (requiredContext(contextStackCursor$1.current), workInProgress.updateQueue = UPDATE_SIGNAL) && (workInProgress.effectTag |= 4);
+ };
+
+ updateHostText$1 = function updateHostText$1(current, workInProgress, oldText, newText) {
+ oldText !== newText && (workInProgress.effectTag |= 4);
+ };
+
+ function logCapturedError(capturedError) {
+ var componentStack = capturedError.componentStack,
+ error = capturedError.error;
+
+ if (error instanceof Error) {
+ capturedError = error.message;
+ var name = error.name;
+
+ try {
+ error.message = (capturedError ? name + ": " + capturedError : name) + "\n\nThis error is located at:" + componentStack;
+ } catch (e) {}
+ } else error = "string" === typeof error ? Error(error + "\n\nThis error is located at:" + componentStack) : Error("Unspecified error at:" + componentStack);
+
+ ExceptionsManager.handleException(error, !1);
+ }
+
+ var PossiblyWeakSet$1 = "function" === typeof WeakSet ? WeakSet : Set;
+
+ function logError(boundary, errorInfo) {
+ var source = errorInfo.source,
+ stack = errorInfo.stack;
+ null === stack && null !== source && (stack = getStackByFiberInDevAndProd(source));
+ errorInfo = {
+ componentName: null !== source ? getComponentName(source.type) : null,
+ componentStack: null !== stack ? stack : "",
+ error: errorInfo.value,
+ errorBoundary: null,
+ errorBoundaryName: null,
+ errorBoundaryFound: !1,
+ willRetry: !1
+ };
+ null !== boundary && 1 === boundary.tag && (errorInfo.errorBoundary = boundary.stateNode, errorInfo.errorBoundaryName = getComponentName(boundary.type), errorInfo.errorBoundaryFound = !0, errorInfo.willRetry = !0);
+
+ try {
+ logCapturedError(errorInfo);
+ } catch (e) {
+ setTimeout(function () {
+ throw e;
+ });
+ }
+ }
+
+ function safelyDetachRef(current$$1) {
+ var ref = current$$1.ref;
+ if (null !== ref) if ("function" === typeof ref) try {
+ ref(null);
+ } catch (refError) {
+ captureCommitPhaseError(current$$1, refError);
+ } else ref.current = null;
+ }
+
+ function commitHookEffectList(unmountTag, mountTag, finishedWork) {
+ finishedWork = finishedWork.updateQueue;
+ finishedWork = null !== finishedWork ? finishedWork.lastEffect : null;
+
+ if (null !== finishedWork) {
+ var effect = finishedWork = finishedWork.next;
+
+ do {
+ if ((effect.tag & unmountTag) !== NoEffect$1) {
+ var destroy = effect.destroy;
+ effect.destroy = void 0;
+ void 0 !== destroy && destroy();
+ }
+
+ (effect.tag & mountTag) !== NoEffect$1 && (destroy = effect.create, effect.destroy = destroy());
+ effect = effect.next;
+ } while (effect !== finishedWork);
+ }
+ }
+
+ function hideOrUnhideAllChildren(finishedWork, isHidden) {
+ for (var node = finishedWork;;) {
+ if (5 === node.tag) {
+ var instance = node.stateNode;
+
+ if (isHidden) {
+ var viewConfig = instance.viewConfig;
+ var updatePayload = diffProperties(null, emptyObject, {
+ style: {
+ display: "none"
+ }
+ }, viewConfig.validAttributes);
+ UIManager.updateView(instance._nativeTag, viewConfig.uiViewClassName, updatePayload);
+ } else {
+ instance = node.stateNode;
+ updatePayload = node.memoizedProps;
+ viewConfig = instance.viewConfig;
+
+ var prevProps = _extends({}, updatePayload, {
+ style: [updatePayload.style, {
+ display: "none"
+ }]
+ });
+
+ updatePayload = diffProperties(null, prevProps, updatePayload, viewConfig.validAttributes);
+ UIManager.updateView(instance._nativeTag, viewConfig.uiViewClassName, updatePayload);
+ }
+ } else {
+ if (6 === node.tag) throw Error("Not yet implemented.");
+
+ if (13 === node.tag && null !== node.memoizedState) {
+ instance = node.child.sibling;
+ instance.return = node;
+ node = instance;
+ continue;
+ } else if (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 commitUnmount(current$$1$jscomp$0) {
+ "function" === typeof onCommitFiberUnmount && onCommitFiberUnmount(current$$1$jscomp$0);
+
+ switch (current$$1$jscomp$0.tag) {
+ case 0:
+ case 11:
+ case 14:
+ case 15:
+ var updateQueue = current$$1$jscomp$0.updateQueue;
+
+ if (null !== updateQueue && (updateQueue = updateQueue.lastEffect, null !== updateQueue)) {
+ var effect = updateQueue = updateQueue.next;
+
+ do {
+ var destroy = effect.destroy;
+
+ if (void 0 !== destroy) {
+ var current$$1 = current$$1$jscomp$0;
+
+ try {
+ destroy();
+ } catch (error) {
+ captureCommitPhaseError(current$$1, error);
+ }
+ }
+
+ effect = effect.next;
+ } while (effect !== updateQueue);
+ }
+
+ break;
+
+ case 1:
+ safelyDetachRef(current$$1$jscomp$0);
+ updateQueue = current$$1$jscomp$0.stateNode;
+ if ("function" === typeof updateQueue.componentWillUnmount) try {
+ updateQueue.props = current$$1$jscomp$0.memoizedProps, updateQueue.state = current$$1$jscomp$0.memoizedState, updateQueue.componentWillUnmount();
+ } catch (unmountError) {
+ captureCommitPhaseError(current$$1$jscomp$0, unmountError);
+ }
+ break;
+
+ case 5:
+ safelyDetachRef(current$$1$jscomp$0);
+ break;
+
+ case 4:
+ unmountHostComponents(current$$1$jscomp$0);
+ }
+ }
+
+ 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 && 18 !== parentFiber.tag;) {
+ if (parentFiber.effectTag & 2) continue b;
+ if (null === parentFiber.child || 4 === parentFiber.tag) continue b;else parentFiber.child.return = parentFiber, parentFiber = parentFiber.child;
+ }
+
+ if (!(parentFiber.effectTag & 2)) {
+ parentFiber = parentFiber.stateNode;
+ break a;
+ }
+ }
+
+ for (var node = finishedWork;;) {
+ 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$$1) {
+ for (var node = current$$1, 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) {
+ if (null !== node.child) {
+ currentParent = node.stateNode.containerInfo;
+ currentParentIsContainer = !0;
+ node.child.return = node;
+ node = node.child;
+ continue;
+ }
+ } else if (commitUnmount(node), null !== node.child) {
+ node.child.return = node;
+ node = node.child;
+ continue;
+ }
+
+ if (node === current$$1) break;
+
+ for (; null === node.sibling;) {
+ if (null === node.return || node.return === current$$1) return;
+ node = node.return;
+ 4 === node.tag && (currentParentIsValid = !1);
+ }
+
+ node.sibling.return = node.return;
+ node = node.sibling;
+ }
+ }
+
+ function commitWork(current$$1, finishedWork) {
+ switch (finishedWork.tag) {
+ case 0:
+ case 11:
+ case 14:
+ case 15:
+ commitHookEffectList(UnmountMutation, MountMutation, finishedWork);
+ break;
+
+ case 1:
+ break;
+
+ case 5:
+ var instance = finishedWork.stateNode;
+
+ if (null != instance) {
+ var newProps = finishedWork.memoizedProps;
+ current$$1 = null !== current$$1 ? current$$1.memoizedProps : newProps;
+ var type = finishedWork.type,
+ updatePayload = finishedWork.updateQueue;
+ finishedWork.updateQueue = null;
+ null !== updatePayload && commitUpdate(instance, updatePayload, type, current$$1, newProps, finishedWork);
+ }
+
+ 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 12:
+ break;
+
+ case 13:
+ instance = finishedWork.memoizedState;
+ newProps = void 0;
+ current$$1 = finishedWork;
+ null === instance ? newProps = !1 : (newProps = !0, current$$1 = finishedWork.child, 0 === instance.timedOutAt && (instance.timedOutAt = requestCurrentTime()));
+ null !== current$$1 && hideOrUnhideAllChildren(current$$1, newProps);
+ instance = finishedWork.updateQueue;
+
+ if (null !== instance) {
+ finishedWork.updateQueue = null;
+ var retryCache = finishedWork.stateNode;
+ null === retryCache && (retryCache = finishedWork.stateNode = new PossiblyWeakSet$1());
+ instance.forEach(function (thenable) {
+ var retry = resolveRetryThenable.bind(null, finishedWork, thenable);
+ retryCache.has(thenable) || (retryCache.add(thenable), thenable.then(retry, retry));
+ });
+ }
+
+ break;
+
+ case 17:
+ 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.");
+ }
+ }
+
+ var PossiblyWeakMap = "function" === typeof WeakMap ? WeakMap : Map;
+
+ function createRootErrorUpdate(fiber, errorInfo, expirationTime) {
+ expirationTime = createUpdate(expirationTime);
+ expirationTime.tag = CaptureUpdate;
+ 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 = CaptureUpdate;
+ var getDerivedStateFromError = fiber.type.getDerivedStateFromError;
+
+ if ("function" === typeof getDerivedStateFromError) {
+ var error$jscomp$0 = errorInfo.value;
+
+ expirationTime.payload = function () {
+ return getDerivedStateFromError(error$jscomp$0);
+ };
+ }
+
+ var inst = fiber.stateNode;
+ null !== inst && "function" === typeof inst.componentDidCatch && (expirationTime.callback = function () {
+ "function" !== typeof getDerivedStateFromError && (null === legacyErrorBoundariesThatAlreadyFailed ? legacyErrorBoundariesThatAlreadyFailed = new Set([this]) : legacyErrorBoundariesThatAlreadyFailed.add(this));
+ 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 1:
+ isContextProvider(workInProgress.type) && popContext(workInProgress);
+ var effectTag = workInProgress.effectTag;
+ return effectTag & 2048 ? (workInProgress.effectTag = effectTag & -2049 | 64, workInProgress) : null;
+
+ case 3:
+ return popHostContainer(workInProgress), popTopLevelContextObject(workInProgress), effectTag = workInProgress.effectTag, invariant(0 === (effectTag & 64), "The root failed to unmount after an error. This is likely a bug in React. Please file an issue."), workInProgress.effectTag = effectTag & -2049 | 64, workInProgress;
+
+ case 5:
+ return popHostContext(workInProgress), null;
+
+ case 13:
+ return effectTag = workInProgress.effectTag, effectTag & 2048 ? (workInProgress.effectTag = effectTag & -2049 | 64, workInProgress) : null;
+
+ case 18:
+ return null;
+
+ case 4:
+ return popHostContainer(workInProgress), null;
+
+ case 10:
+ return popProvider(workInProgress), null;
+
+ default:
+ return null;
+ }
+ }
+
+ var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher,
+ ReactCurrentOwner$2 = ReactSharedInternals.ReactCurrentOwner,
+ isWorking = !1,
+ nextUnitOfWork = null,
+ nextRoot = null,
+ nextRenderExpirationTime = 0,
+ nextLatestAbsoluteTimeoutMs = -1,
+ nextRenderDidError = !1,
+ nextEffect = null,
+ isCommitting$1 = !1,
+ rootWithPendingPassiveEffects = null,
+ passiveEffectCallbackHandle = null,
+ passiveEffectCallback = null,
+ 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 1:
+ var childContextTypes = interruptedWork$jscomp$0.type.childContextTypes;
+ null !== childContextTypes && void 0 !== childContextTypes && popContext(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 10:
+ popProvider(interruptedWork$jscomp$0);
+ }
+
+ interruptedWork = interruptedWork.return;
+ }
+ nextRoot = null;
+ nextRenderExpirationTime = 0;
+ nextLatestAbsoluteTimeoutMs = -1;
+ nextRenderDidError = !1;
+ nextUnitOfWork = null;
+ }
+
+ function commitAllHostEffects() {
+ for (; null !== nextEffect;) {
+ var effectTag = nextEffect.effectTag;
+
+ if (effectTag & 128) {
+ var current$$1 = nextEffect.alternate;
+ null !== current$$1 && (current$$1 = current$$1.ref, null !== current$$1 && ("function" === typeof current$$1 ? current$$1(null) : current$$1.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:
+ effectTag = nextEffect, unmountHostComponents(effectTag), effectTag.return = null, effectTag.child = null, effectTag.memoizedState = null, effectTag.updateQueue = null, effectTag = effectTag.alternate, null !== effectTag && (effectTag.return = null, effectTag.child = null, effectTag.memoizedState = null, effectTag.updateQueue = null);
+ }
+
+ nextEffect = nextEffect.nextEffect;
+ }
+ }
+
+ function commitBeforeMutationLifecycles() {
+ for (; null !== nextEffect;) {
+ if (nextEffect.effectTag & 256) a: {
+ var current$$1 = nextEffect.alternate,
+ finishedWork = nextEffect;
+
+ switch (finishedWork.tag) {
+ case 0:
+ case 11:
+ case 15:
+ commitHookEffectList(UnmountSnapshot, NoEffect$1, finishedWork);
+ break a;
+
+ case 1:
+ if (finishedWork.effectTag & 256 && null !== current$$1) {
+ var prevProps = current$$1.memoizedProps,
+ prevState = current$$1.memoizedState;
+ current$$1 = finishedWork.stateNode;
+ finishedWork = current$$1.getSnapshotBeforeUpdate(finishedWork.elementType === finishedWork.type ? prevProps : resolveDefaultProps(finishedWork.type, prevProps), prevState);
+ current$$1.__reactInternalSnapshotBeforeUpdate = finishedWork;
+ }
+
+ break a;
+
+ case 3:
+ case 5:
+ case 6:
+ case 4:
+ case 17:
+ break a;
+
+ 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;
+ }
+ }
+
+ function commitAllLifeCycles(finishedRoot, committedExpirationTime$jscomp$0) {
+ for (; null !== nextEffect;) {
+ var effectTag = nextEffect.effectTag;
+
+ if (effectTag & 36) {
+ var current$$1 = nextEffect.alternate,
+ finishedWork = nextEffect,
+ committedExpirationTime = committedExpirationTime$jscomp$0;
+
+ switch (finishedWork.tag) {
+ case 0:
+ case 11:
+ case 15:
+ commitHookEffectList(UnmountLayout, MountLayout, finishedWork);
+ break;
+
+ case 1:
+ var instance = finishedWork.stateNode;
+ if (finishedWork.effectTag & 4) if (null === current$$1) instance.componentDidMount();else {
+ var prevProps = finishedWork.elementType === finishedWork.type ? current$$1.memoizedProps : resolveDefaultProps(finishedWork.type, current$$1.memoizedProps);
+ instance.componentDidUpdate(prevProps, current$$1.memoizedState, instance.__reactInternalSnapshotBeforeUpdate);
+ }
+ current$$1 = finishedWork.updateQueue;
+ null !== current$$1 && commitUpdateQueue(finishedWork, current$$1, instance, committedExpirationTime);
+ break;
+
+ case 3:
+ instance = finishedWork.updateQueue;
+
+ if (null !== instance) {
+ current$$1 = null;
+ if (null !== finishedWork.child) switch (finishedWork.child.tag) {
+ case 5:
+ current$$1 = finishedWork.child.stateNode;
+ break;
+
+ case 1:
+ current$$1 = finishedWork.child.stateNode;
+ }
+ commitUpdateQueue(finishedWork, instance, current$$1, committedExpirationTime);
+ }
+
+ break;
+
+ case 5:
+ break;
+
+ case 6:
+ break;
+
+ case 4:
+ break;
+
+ case 12:
+ break;
+
+ case 13:
+ break;
+
+ case 17:
+ 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.");
+ }
+ }
+
+ effectTag & 128 && (finishedWork = nextEffect.ref, null !== finishedWork && (committedExpirationTime = nextEffect.stateNode, "function" === typeof finishedWork ? finishedWork(committedExpirationTime) : finishedWork.current = committedExpirationTime));
+ effectTag & 512 && (rootWithPendingPassiveEffects = finishedRoot);
+ nextEffect = nextEffect.nextEffect;
+ }
+ }
+
+ function commitPassiveEffects(root, firstEffect) {
+ passiveEffectCallback = passiveEffectCallbackHandle = rootWithPendingPassiveEffects = null;
+ var previousIsRendering = isRendering;
+ isRendering = !0;
+
+ do {
+ if (firstEffect.effectTag & 512) {
+ var didError = !1,
+ error = void 0;
+
+ try {
+ var finishedWork = firstEffect;
+ commitHookEffectList(UnmountPassive, NoEffect$1, finishedWork);
+ commitHookEffectList(NoEffect$1, MountPassive, finishedWork);
+ } catch (e) {
+ didError = !0, error = e;
+ }
+
+ didError && captureCommitPhaseError(firstEffect, error);
+ }
+
+ firstEffect = firstEffect.nextEffect;
+ } while (null !== firstEffect);
+
+ isRendering = previousIsRendering;
+ previousIsRendering = root.expirationTime;
+ 0 !== previousIsRendering && requestWork(root, previousIsRendering);
+ isBatchingUpdates || isRendering || performWork(1073741823, !1);
+ }
+
+ function flushPassiveEffects() {
+ if (null !== passiveEffectCallbackHandle) {
+ var callbackID = passiveEffectCallbackHandle;
+ scheduledCallback = null;
+ clearTimeout(callbackID);
+ }
+
+ null !== passiveEffectCallback && passiveEffectCallback();
+ }
+
+ function commitRoot(root, finishedWork) {
+ isCommitting$1 = isWorking = !0;
+ 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(0 !== committedExpirationTime, "Cannot commit an incomplete root. This error is likely caused by a bug in React. Please file an issue.");
+ root.pendingCommitExpirationTime = 0;
+ var updateExpirationTimeBeforeCommit = finishedWork.expirationTime,
+ childExpirationTimeBeforeCommit = finishedWork.childExpirationTime;
+ markCommittedPriorityLevels(root, childExpirationTimeBeforeCommit > updateExpirationTimeBeforeCommit ? childExpirationTimeBeforeCommit : updateExpirationTimeBeforeCommit);
+ ReactCurrentOwner$2.current = null;
+ updateExpirationTimeBeforeCommit = void 0;
+ 1 < finishedWork.effectTag ? null !== finishedWork.lastEffect ? (finishedWork.lastEffect.nextEffect = finishedWork, updateExpirationTimeBeforeCommit = finishedWork.firstEffect) : updateExpirationTimeBeforeCommit = finishedWork : updateExpirationTimeBeforeCommit = finishedWork.firstEffect;
+
+ for (nextEffect = updateExpirationTimeBeforeCommit; null !== nextEffect;) {
+ childExpirationTimeBeforeCommit = !1;
+ var error = void 0;
+
+ try {
+ commitBeforeMutationLifecycles();
+ } catch (e) {
+ childExpirationTimeBeforeCommit = !0, error = e;
+ }
+
+ childExpirationTimeBeforeCommit && (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 = updateExpirationTimeBeforeCommit; null !== nextEffect;) {
+ childExpirationTimeBeforeCommit = !1;
+ error = void 0;
+
+ try {
+ commitAllHostEffects();
+ } catch (e) {
+ childExpirationTimeBeforeCommit = !0, error = e;
+ }
+
+ childExpirationTimeBeforeCommit && (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));
+ }
+
+ root.current = finishedWork;
+
+ for (nextEffect = updateExpirationTimeBeforeCommit; null !== nextEffect;) {
+ childExpirationTimeBeforeCommit = !1;
+ error = void 0;
+
+ try {
+ commitAllLifeCycles(root, committedExpirationTime);
+ } catch (e) {
+ childExpirationTimeBeforeCommit = !0, error = e;
+ }
+
+ childExpirationTimeBeforeCommit && (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));
+ }
+
+ if (null !== updateExpirationTimeBeforeCommit && null !== rootWithPendingPassiveEffects) {
+ var callback = commitPassiveEffects.bind(null, root, updateExpirationTimeBeforeCommit);
+ passiveEffectCallbackHandle = scheduler.unstable_runWithPriority(scheduler.unstable_NormalPriority, function () {
+ return scheduleDeferredCallback$1(callback);
+ });
+ passiveEffectCallback = callback;
+ }
+
+ isWorking = isCommitting$1 = !1;
+ "function" === typeof onCommitFiberRoot && onCommitFiberRoot(finishedWork.stateNode);
+ committedExpirationTime = finishedWork.expirationTime;
+ finishedWork = finishedWork.childExpirationTime;
+ finishedWork = finishedWork > committedExpirationTime ? finishedWork : committedExpirationTime;
+ 0 === finishedWork && (legacyErrorBoundariesThatAlreadyFailed = null);
+ onCommit(root, finishedWork);
+ }
+
+ function completeUnitOfWork(workInProgress) {
+ for (;;) {
+ var current$$1 = workInProgress.alternate,
+ returnFiber = workInProgress.return,
+ siblingFiber = workInProgress.sibling;
+
+ if (0 === (workInProgress.effectTag & 1024)) {
+ nextUnitOfWork = workInProgress;
+
+ a: {
+ var current = current$$1;
+ current$$1 = workInProgress;
+ var renderExpirationTime = nextRenderExpirationTime,
+ newProps = current$$1.pendingProps;
+
+ switch (current$$1.tag) {
+ case 2:
+ break;
+
+ case 16:
+ break;
+
+ case 15:
+ case 0:
+ break;
+
+ case 1:
+ isContextProvider(current$$1.type) && popContext(current$$1);
+ break;
+
+ case 3:
+ popHostContainer(current$$1);
+ popTopLevelContextObject(current$$1);
+ newProps = current$$1.stateNode;
+ newProps.pendingContext && (newProps.context = newProps.pendingContext, newProps.pendingContext = null);
+ if (null === current || null === current.child) current$$1.effectTag &= -3;
+ updateHostContainer(current$$1);
+ break;
+
+ case 5:
+ popHostContext(current$$1);
+ renderExpirationTime = requiredContext(rootInstanceStackCursor.current);
+ var type = current$$1.type;
+ if (null !== current && null != current$$1.stateNode) updateHostComponent$1(current, current$$1, type, newProps, renderExpirationTime), current.ref !== current$$1.ref && (current$$1.effectTag |= 128);else if (newProps) {
+ current = requiredContext(contextStackCursor$1.current);
+ var internalInstanceHandle = current$$1,
+ tag = allocateTag(),
+ viewConfig = ReactNativeViewConfigRegistry.get(type);
+ invariant("RCTView" !== type || !current.isInAParentText, "Nesting of within is not currently supported.");
+ var updatePayload = diffProperties(null, emptyObject, newProps, viewConfig.validAttributes);
+ UIManager.createView(tag, viewConfig.uiViewClassName, renderExpirationTime, updatePayload);
+ viewConfig = new ReactNativeFiberHostComponent(tag, viewConfig);
+ instanceCache[tag] = internalInstanceHandle;
+ instanceProps[tag] = newProps;
+ appendAllChildren(viewConfig, current$$1, !1, !1);
+ finalizeInitialChildren(viewConfig, type, newProps, renderExpirationTime, current) && (current$$1.effectTag |= 4);
+ current$$1.stateNode = viewConfig;
+ null !== current$$1.ref && (current$$1.effectTag |= 128);
+ } else invariant(null !== current$$1.stateNode, "We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue.");
+ break;
+
+ case 6:
+ current && null != current$$1.stateNode ? updateHostText$1(current, current$$1, current.memoizedProps, newProps) : ("string" !== typeof newProps && invariant(null !== current$$1.stateNode, "We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue."), current = requiredContext(rootInstanceStackCursor.current), type = requiredContext(contextStackCursor$1.current), renderExpirationTime = current$$1, invariant(type.isInAParentText, "Text strings must be rendered within a component."), type = allocateTag(), UIManager.createView(type, "RCTRawText", current, {
+ text: newProps
+ }), instanceCache[type] = current$$1, renderExpirationTime.stateNode = type);
+ break;
+
+ case 11:
+ break;
+
+ case 13:
+ newProps = current$$1.memoizedState;
+
+ if (0 !== (current$$1.effectTag & 64)) {
+ current$$1.expirationTime = renderExpirationTime;
+ nextUnitOfWork = current$$1;
+ break a;
+ }
+
+ newProps = null !== newProps;
+ renderExpirationTime = null !== current && null !== current.memoizedState;
+ null !== current && !newProps && renderExpirationTime && (type = current.child.sibling, null !== type && (current = current$$1.firstEffect, null !== current ? (current$$1.firstEffect = type, type.nextEffect = current) : (current$$1.firstEffect = current$$1.lastEffect = type, type.nextEffect = null), type.effectTag = 8));
+ if (newProps || renderExpirationTime) current$$1.effectTag |= 4;
+ break;
+
+ case 7:
+ break;
+
+ case 8:
+ break;
+
+ case 12:
+ break;
+
+ case 4:
+ popHostContainer(current$$1);
+ updateHostContainer(current$$1);
+ break;
+
+ case 10:
+ popProvider(current$$1);
+ break;
+
+ case 9:
+ break;
+
+ case 14:
+ break;
+
+ case 17:
+ isContextProvider(current$$1.type) && popContext(current$$1);
+ break;
+
+ case 18:
+ break;
+
+ default:
+ invariant(!1, "Unknown unit of work tag. This error is likely caused by a bug in React. Please file an issue.");
+ }
+
+ nextUnitOfWork = null;
+ }
+
+ current$$1 = workInProgress;
+
+ if (1 === nextRenderExpirationTime || 1 !== current$$1.childExpirationTime) {
+ newProps = 0;
+
+ for (renderExpirationTime = current$$1.child; null !== renderExpirationTime;) {
+ type = renderExpirationTime.expirationTime, current = renderExpirationTime.childExpirationTime, type > newProps && (newProps = type), current > newProps && (newProps = current), renderExpirationTime = renderExpirationTime.sibling;
+ }
+
+ current$$1.childExpirationTime = newProps;
+ }
+
+ if (null !== nextUnitOfWork) return nextUnitOfWork;
+ null !== returnFiber && 0 === (returnFiber.effectTag & 1024) && (null === returnFiber.firstEffect && (returnFiber.firstEffect = workInProgress.firstEffect), null !== workInProgress.lastEffect && (null !== returnFiber.lastEffect && (returnFiber.lastEffect.nextEffect = workInProgress.firstEffect), returnFiber.lastEffect = workInProgress.lastEffect), 1 < workInProgress.effectTag && (null !== returnFiber.lastEffect ? returnFiber.lastEffect.nextEffect = workInProgress : returnFiber.firstEffect = workInProgress, returnFiber.lastEffect = workInProgress));
+ } else {
+ workInProgress = unwindWork(workInProgress, nextRenderExpirationTime);
+ if (null !== workInProgress) return workInProgress.effectTag &= 1023, workInProgress;
+ null !== returnFiber && (returnFiber.firstEffect = returnFiber.lastEffect = null, returnFiber.effectTag |= 1024);
+ }
+
+ if (null !== siblingFiber) return siblingFiber;
+ if (null !== returnFiber) workInProgress = returnFiber;else break;
+ }
+
+ return null;
+ }
+
+ function performUnitOfWork(workInProgress) {
+ var next = beginWork(workInProgress.alternate, workInProgress, nextRenderExpirationTime);
+ workInProgress.memoizedProps = workInProgress.pendingProps;
+ null === next && (next = completeUnitOfWork(workInProgress));
+ ReactCurrentOwner$2.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.");
+ flushPassiveEffects();
+ isWorking = !0;
+ var previousDispatcher = ReactCurrentDispatcher.current;
+ ReactCurrentDispatcher.current = ContextOnlyDispatcher;
+ var expirationTime = root$jscomp$0.nextExpirationTimeToWorkOn;
+ if (expirationTime !== nextRenderExpirationTime || root$jscomp$0 !== nextRoot || null === nextUnitOfWork) resetStack(), nextRoot = root$jscomp$0, nextRenderExpirationTime = expirationTime, nextUnitOfWork = createWorkInProgress(nextRoot.current, null, nextRenderExpirationTime), root$jscomp$0.pendingCommitExpirationTime = 0;
+ var didFatal = !1;
+
+ do {
+ try {
+ if (isYieldy) for (; null !== nextUnitOfWork && !(frameDeadline <= now$1());) {
+ nextUnitOfWork = performUnitOfWork(nextUnitOfWork);
+ } else for (; null !== nextUnitOfWork;) {
+ nextUnitOfWork = performUnitOfWork(nextUnitOfWork);
+ }
+ } catch (thrownValue) {
+ if (lastContextWithAllBitsObserved = lastContextDependency = currentlyRenderingFiber = null, resetHooks(), 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.");
+ var sourceFiber = nextUnitOfWork,
+ returnFiber = sourceFiber.return;
+ if (null === returnFiber) didFatal = !0, onUncaughtError(thrownValue);else {
+ a: {
+ var root = root$jscomp$0,
+ returnFiber$jscomp$0 = returnFiber,
+ sourceFiber$jscomp$0 = sourceFiber,
+ value = thrownValue;
+ returnFiber = nextRenderExpirationTime;
+ sourceFiber$jscomp$0.effectTag |= 1024;
+ sourceFiber$jscomp$0.firstEffect = sourceFiber$jscomp$0.lastEffect = null;
+
+ if (null !== value && "object" === typeof value && "function" === typeof value.then) {
+ var thenable = value;
+ value = returnFiber$jscomp$0;
+ var earliestTimeoutMs = -1,
+ startTimeMs = -1;
+
+ do {
+ if (13 === value.tag) {
+ var current$$1 = value.alternate;
+
+ if (null !== current$$1 && (current$$1 = current$$1.memoizedState, null !== current$$1)) {
+ startTimeMs = 10 * (1073741822 - current$$1.timedOutAt);
+ break;
+ }
+
+ current$$1 = value.pendingProps.maxDuration;
+ if ("number" === typeof current$$1) if (0 >= current$$1) earliestTimeoutMs = 0;else if (-1 === earliestTimeoutMs || current$$1 < earliestTimeoutMs) earliestTimeoutMs = current$$1;
+ }
+
+ value = value.return;
+ } while (null !== value);
+
+ value = returnFiber$jscomp$0;
+
+ do {
+ if (current$$1 = 13 === value.tag) current$$1 = void 0 === value.memoizedProps.fallback ? !1 : null === value.memoizedState;
+
+ if (current$$1) {
+ returnFiber$jscomp$0 = value.updateQueue;
+ null === returnFiber$jscomp$0 ? (returnFiber$jscomp$0 = new Set(), returnFiber$jscomp$0.add(thenable), value.updateQueue = returnFiber$jscomp$0) : returnFiber$jscomp$0.add(thenable);
+
+ if (0 === (value.mode & 1)) {
+ value.effectTag |= 64;
+ sourceFiber$jscomp$0.effectTag &= -1957;
+ 1 === sourceFiber$jscomp$0.tag && (null === sourceFiber$jscomp$0.alternate ? sourceFiber$jscomp$0.tag = 17 : (returnFiber = createUpdate(1073741823), returnFiber.tag = ForceUpdate, enqueueUpdate(sourceFiber$jscomp$0, returnFiber)));
+ sourceFiber$jscomp$0.expirationTime = 1073741823;
+ break a;
+ }
+
+ sourceFiber$jscomp$0 = root;
+ returnFiber$jscomp$0 = returnFiber;
+ var pingCache = sourceFiber$jscomp$0.pingCache;
+ null === pingCache ? (pingCache = sourceFiber$jscomp$0.pingCache = new PossiblyWeakMap(), current$$1 = new Set(), pingCache.set(thenable, current$$1)) : (current$$1 = pingCache.get(thenable), void 0 === current$$1 && (current$$1 = new Set(), pingCache.set(thenable, current$$1)));
+ current$$1.has(returnFiber$jscomp$0) || (current$$1.add(returnFiber$jscomp$0), sourceFiber$jscomp$0 = pingSuspendedRoot.bind(null, sourceFiber$jscomp$0, thenable, returnFiber$jscomp$0), thenable.then(sourceFiber$jscomp$0, sourceFiber$jscomp$0));
+ -1 === earliestTimeoutMs ? root = 1073741823 : (-1 === startTimeMs && (startTimeMs = 10 * (1073741822 - findEarliestOutstandingPriorityLevel(root, returnFiber)) - 5e3), root = startTimeMs + earliestTimeoutMs);
+ 0 <= root && nextLatestAbsoluteTimeoutMs < root && (nextLatestAbsoluteTimeoutMs = root);
+ value.effectTag |= 2048;
+ value.expirationTime = returnFiber;
+ break a;
+ }
+
+ value = value.return;
+ } while (null !== value);
+
+ value = Error((getComponentName(sourceFiber$jscomp$0.type) || "A React component") + " suspended while rendering, but no fallback UI was specified.\n\nAdd a component higher in the tree to provide a loading indicator or placeholder to display." + getStackByFiberInDevAndProd(sourceFiber$jscomp$0));
+ }
+
+ nextRenderDidError = !0;
+ value = createCapturedValue(value, sourceFiber$jscomp$0);
+ root = returnFiber$jscomp$0;
+
+ do {
+ switch (root.tag) {
+ case 3:
+ root.effectTag |= 2048;
+ root.expirationTime = returnFiber;
+ returnFiber = createRootErrorUpdate(root, value, returnFiber);
+ enqueueCapturedUpdate(root, returnFiber);
+ break a;
+
+ case 1:
+ if (earliestTimeoutMs = value, startTimeMs = root.type, sourceFiber$jscomp$0 = root.stateNode, 0 === (root.effectTag & 64) && ("function" === typeof startTimeMs.getDerivedStateFromError || null !== sourceFiber$jscomp$0 && "function" === typeof sourceFiber$jscomp$0.componentDidCatch && (null === legacyErrorBoundariesThatAlreadyFailed || !legacyErrorBoundariesThatAlreadyFailed.has(sourceFiber$jscomp$0)))) {
+ root.effectTag |= 2048;
+ root.expirationTime = returnFiber;
+ returnFiber = createClassErrorUpdate(root, earliestTimeoutMs, returnFiber);
+ enqueueCapturedUpdate(root, returnFiber);
+ break a;
+ }
+
+ }
+
+ root = root.return;
+ } while (null !== root);
+ }
+
+ nextUnitOfWork = completeUnitOfWork(sourceFiber);
+ continue;
+ }
+ }
+ }
+
+ break;
+ } while (1);
+
+ isWorking = !1;
+ ReactCurrentDispatcher.current = previousDispatcher;
+ lastContextWithAllBitsObserved = lastContextDependency = currentlyRenderingFiber = null;
+ resetHooks();
+ if (didFatal) nextRoot = null, root$jscomp$0.finishedWork = null;else if (null !== nextUnitOfWork) root$jscomp$0.finishedWork = null;else {
+ previousDispatcher = root$jscomp$0.current.alternate;
+ invariant(null !== previousDispatcher, "Finished root should have a work-in-progress. This error is likely caused by a bug in React. Please file an issue.");
+ nextRoot = null;
+
+ if (nextRenderDidError) {
+ didFatal = root$jscomp$0.latestPendingTime;
+ sourceFiber = root$jscomp$0.latestSuspendedTime;
+ returnFiber = root$jscomp$0.latestPingedTime;
+
+ if (0 !== didFatal && didFatal < expirationTime || 0 !== sourceFiber && sourceFiber < expirationTime || 0 !== returnFiber && returnFiber < expirationTime) {
+ markSuspendedPriorityLevel(root$jscomp$0, expirationTime);
+ onSuspend(root$jscomp$0, previousDispatcher, expirationTime, root$jscomp$0.expirationTime, -1);
+ return;
+ }
+
+ if (!root$jscomp$0.didError && isYieldy) {
+ root$jscomp$0.didError = !0;
+ expirationTime = root$jscomp$0.nextExpirationTimeToWorkOn = expirationTime;
+ isYieldy = root$jscomp$0.expirationTime = 1073741823;
+ onSuspend(root$jscomp$0, previousDispatcher, expirationTime, isYieldy, -1);
+ return;
+ }
+ }
+
+ isYieldy && -1 !== nextLatestAbsoluteTimeoutMs ? (markSuspendedPriorityLevel(root$jscomp$0, expirationTime), isYieldy = 10 * (1073741822 - findEarliestOutstandingPriorityLevel(root$jscomp$0, expirationTime)), isYieldy < nextLatestAbsoluteTimeoutMs && (nextLatestAbsoluteTimeoutMs = isYieldy), isYieldy = 10 * (1073741822 - requestCurrentTime()), isYieldy = nextLatestAbsoluteTimeoutMs - isYieldy, onSuspend(root$jscomp$0, previousDispatcher, expirationTime, root$jscomp$0.expirationTime, 0 > isYieldy ? 0 : isYieldy)) : (root$jscomp$0.pendingCommitExpirationTime = expirationTime, root$jscomp$0.finishedWork = previousDispatcher);
+ }
+ }
+
+ function captureCommitPhaseError(sourceFiber, value) {
+ for (var fiber = sourceFiber.return; null !== fiber;) {
+ switch (fiber.tag) {
+ case 1:
+ var instance = fiber.stateNode;
+
+ if ("function" === typeof fiber.type.getDerivedStateFromError || "function" === typeof instance.componentDidCatch && (null === legacyErrorBoundariesThatAlreadyFailed || !legacyErrorBoundariesThatAlreadyFailed.has(instance))) {
+ sourceFiber = createCapturedValue(value, sourceFiber);
+ sourceFiber = createClassErrorUpdate(fiber, sourceFiber, 1073741823);
+ enqueueUpdate(fiber, sourceFiber);
+ scheduleWork(fiber, 1073741823);
+ return;
+ }
+
+ break;
+
+ case 3:
+ sourceFiber = createCapturedValue(value, sourceFiber);
+ sourceFiber = createRootErrorUpdate(fiber, sourceFiber, 1073741823);
+ enqueueUpdate(fiber, sourceFiber);
+ scheduleWork(fiber, 1073741823);
+ return;
+ }
+
+ fiber = fiber.return;
+ }
+
+ 3 === sourceFiber.tag && (fiber = createCapturedValue(value, sourceFiber), fiber = createRootErrorUpdate(sourceFiber, fiber, 1073741823), enqueueUpdate(sourceFiber, fiber), scheduleWork(sourceFiber, 1073741823));
+ }
+
+ function computeExpirationForFiber(currentTime, fiber) {
+ var priorityLevel = scheduler.unstable_getCurrentPriorityLevel(),
+ expirationTime = void 0;
+ if (0 === (fiber.mode & 1)) expirationTime = 1073741823;else if (isWorking && !isCommitting$1) expirationTime = nextRenderExpirationTime;else {
+ switch (priorityLevel) {
+ case scheduler.unstable_ImmediatePriority:
+ expirationTime = 1073741823;
+ break;
+
+ case scheduler.unstable_UserBlockingPriority:
+ expirationTime = 1073741822 - 10 * (((1073741822 - currentTime + 15) / 10 | 0) + 1);
+ break;
+
+ case scheduler.unstable_NormalPriority:
+ expirationTime = 1073741822 - 25 * (((1073741822 - currentTime + 500) / 25 | 0) + 1);
+ break;
+
+ case scheduler.unstable_LowPriority:
+ case scheduler.unstable_IdlePriority:
+ expirationTime = 1;
+ break;
+
+ default:
+ invariant(!1, "Unknown priority level. This error is likely caused by a bug in React. Please file an issue.");
+ }
+
+ null !== nextRoot && expirationTime === nextRenderExpirationTime && --expirationTime;
+ }
+ priorityLevel === scheduler.unstable_UserBlockingPriority && (0 === lowestPriorityPendingInteractiveExpirationTime || expirationTime < lowestPriorityPendingInteractiveExpirationTime) && (lowestPriorityPendingInteractiveExpirationTime = expirationTime);
+ return expirationTime;
+ }
+
+ function pingSuspendedRoot(root, thenable, pingTime) {
+ var pingCache = root.pingCache;
+ null !== pingCache && pingCache.delete(thenable);
+ if (null !== nextRoot && nextRenderExpirationTime === pingTime) nextRoot = null;else if (thenable = root.earliestSuspendedTime, pingCache = root.latestSuspendedTime, 0 !== thenable && pingTime <= thenable && pingTime >= pingCache) {
+ root.didError = !1;
+ thenable = root.latestPingedTime;
+ if (0 === thenable || thenable > pingTime) root.latestPingedTime = pingTime;
+ findNextExpirationTimeToWorkOn(pingTime, root);
+ pingTime = root.expirationTime;
+ 0 !== pingTime && requestWork(root, pingTime);
+ }
+ }
+
+ function resolveRetryThenable(boundaryFiber, thenable) {
+ var retryCache = boundaryFiber.stateNode;
+ null !== retryCache && retryCache.delete(thenable);
+ thenable = requestCurrentTime();
+ thenable = computeExpirationForFiber(thenable, boundaryFiber);
+ boundaryFiber = scheduleWorkToRoot(boundaryFiber, thenable);
+ null !== boundaryFiber && (markPendingPriorityLevel(boundaryFiber, thenable), thenable = boundaryFiber.expirationTime, 0 !== thenable && requestWork(boundaryFiber, thenable));
+ }
+
+ function scheduleWorkToRoot(fiber, expirationTime) {
+ fiber.expirationTime < expirationTime && (fiber.expirationTime = expirationTime);
+ var alternate = fiber.alternate;
+ null !== alternate && alternate.expirationTime < expirationTime && (alternate.expirationTime = expirationTime);
+ var node = fiber.return,
+ root = null;
+ if (null === node && 3 === fiber.tag) root = fiber.stateNode;else for (; null !== node;) {
+ alternate = node.alternate;
+ node.childExpirationTime < expirationTime && (node.childExpirationTime = expirationTime);
+ null !== alternate && alternate.childExpirationTime < expirationTime && (alternate.childExpirationTime = expirationTime);
+
+ if (null === node.return && 3 === node.tag) {
+ root = node.stateNode;
+ break;
+ }
+
+ node = node.return;
+ }
+ return root;
+ }
+
+ function scheduleWork(fiber, expirationTime) {
+ fiber = scheduleWorkToRoot(fiber, expirationTime);
+ null !== fiber && (!isWorking && 0 !== nextRenderExpirationTime && expirationTime > nextRenderExpirationTime && resetStack(), markPendingPriorityLevel(fiber, expirationTime), isWorking && !isCommitting$1 && nextRoot === fiber || requestWork(fiber, fiber.expirationTime), nestedUpdateCount > NESTED_UPDATE_LIMIT && (nestedUpdateCount = 0, 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.")));
+ }
+
+ var firstScheduledRoot = null,
+ lastScheduledRoot = null,
+ callbackExpirationTime = 0,
+ callbackID = void 0,
+ isRendering = !1,
+ nextFlushedRoot = null,
+ nextFlushedExpirationTime = 0,
+ lowestPriorityPendingInteractiveExpirationTime = 0,
+ hasUnhandledError = !1,
+ unhandledError = null,
+ isBatchingUpdates = !1,
+ isUnbatchingUpdates = !1,
+ completedBatches = null,
+ originalStartTimeMs = now$1(),
+ currentRendererTime = 1073741822 - (originalStartTimeMs / 10 | 0),
+ currentSchedulerTime = currentRendererTime,
+ NESTED_UPDATE_LIMIT = 50,
+ nestedUpdateCount = 0,
+ lastCommittedRootDuringThisBatch = null;
+
+ function recomputeCurrentRendererTime() {
+ currentRendererTime = 1073741822 - ((now$1() - originalStartTimeMs) / 10 | 0);
+ }
+
+ function scheduleCallbackWithExpirationTime(root, expirationTime) {
+ if (0 !== callbackExpirationTime) {
+ if (expirationTime < callbackExpirationTime) return;
+ null !== callbackID && (root = callbackID, scheduledCallback = null, clearTimeout(root));
+ }
+
+ callbackExpirationTime = expirationTime;
+ root = now$1() - originalStartTimeMs;
+ callbackID = scheduleDeferredCallback$1(performAsyncWork, {
+ timeout: 10 * (1073741822 - expirationTime) - root
+ });
+ }
+
+ function onSuspend(root, finishedWork, suspendedExpirationTime, rootExpirationTime, msUntilTimeout) {
+ root.expirationTime = rootExpirationTime;
+ 0 !== msUntilTimeout || frameDeadline <= now$1() ? 0 < msUntilTimeout && (root.timeoutHandle = scheduleTimeout(onTimeout.bind(null, root, finishedWork, suspendedExpirationTime), msUntilTimeout)) : (root.pendingCommitExpirationTime = suspendedExpirationTime, root.finishedWork = finishedWork);
+ }
+
+ function onTimeout(root, finishedWork, suspendedExpirationTime) {
+ root.pendingCommitExpirationTime = suspendedExpirationTime;
+ root.finishedWork = finishedWork;
+ recomputeCurrentRendererTime();
+ currentSchedulerTime = currentRendererTime;
+ invariant(!isRendering, "work.commit(): Cannot commit while already rendering. This likely means you attempted to commit from inside a lifecycle method.");
+ nextFlushedRoot = root;
+ nextFlushedExpirationTime = suspendedExpirationTime;
+ performWorkOnRoot(root, suspendedExpirationTime, !1);
+ performWork(1073741823, !1);
+ }
+
+ function onCommit(root, expirationTime) {
+ root.expirationTime = expirationTime;
+ root.finishedWork = null;
+ }
+
+ function requestCurrentTime() {
+ if (isRendering) return currentSchedulerTime;
+ findHighestPriorityRoot();
+ if (0 === nextFlushedExpirationTime || 1 === nextFlushedExpirationTime) recomputeCurrentRendererTime(), currentSchedulerTime = currentRendererTime;
+ return currentSchedulerTime;
+ }
+
+ function requestWork(root, expirationTime) {
+ null === root.nextScheduledRoot ? (root.expirationTime = expirationTime, null === lastScheduledRoot ? (firstScheduledRoot = lastScheduledRoot = root, root.nextScheduledRoot = root) : (lastScheduledRoot = lastScheduledRoot.nextScheduledRoot = root, lastScheduledRoot.nextScheduledRoot = firstScheduledRoot)) : expirationTime > root.expirationTime && (root.expirationTime = expirationTime);
+ isRendering || (isBatchingUpdates ? isUnbatchingUpdates && (nextFlushedRoot = root, nextFlushedExpirationTime = 1073741823, performWorkOnRoot(root, 1073741823, !1)) : 1073741823 === expirationTime ? performWork(1073741823, !1) : scheduleCallbackWithExpirationTime(root, 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 {
+ remainingExpirationTime > highestPriorityWork && (highestPriorityWork = remainingExpirationTime, highestPriorityRoot = root);
+ if (root === lastScheduledRoot) break;
+ if (1073741823 === highestPriorityWork) break;
+ previousScheduledRoot = root;
+ root = root.nextScheduledRoot;
+ }
+ }
+ nextFlushedRoot = highestPriorityRoot;
+ nextFlushedExpirationTime = highestPriorityWork;
+ }
+
+ function performAsyncWork(didTimeout) {
+ if (didTimeout && null !== firstScheduledRoot) {
+ recomputeCurrentRendererTime();
+ didTimeout = firstScheduledRoot;
+
+ do {
+ var expirationTime = didTimeout.expirationTime;
+ 0 !== expirationTime && currentRendererTime <= expirationTime && (didTimeout.nextExpirationTimeToWorkOn = currentRendererTime);
+ didTimeout = didTimeout.nextScheduledRoot;
+ } while (didTimeout !== firstScheduledRoot);
+ }
+
+ performWork(0, !0);
+ }
+
+ function performWork(minExpirationTime, isYieldy) {
+ findHighestPriorityRoot();
+ if (isYieldy) for (recomputeCurrentRendererTime(), currentSchedulerTime = currentRendererTime; null !== nextFlushedRoot && 0 !== nextFlushedExpirationTime && minExpirationTime <= nextFlushedExpirationTime && !(frameDeadline <= now$1() && currentRendererTime > nextFlushedExpirationTime);) {
+ performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, currentRendererTime > nextFlushedExpirationTime), findHighestPriorityRoot(), recomputeCurrentRendererTime(), currentSchedulerTime = currentRendererTime;
+ } else for (; null !== nextFlushedRoot && 0 !== nextFlushedExpirationTime && minExpirationTime <= nextFlushedExpirationTime;) {
+ performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, !1), findHighestPriorityRoot();
+ }
+ isYieldy && (callbackExpirationTime = 0, callbackID = null);
+ 0 !== nextFlushedExpirationTime && scheduleCallbackWithExpirationTime(nextFlushedRoot, nextFlushedExpirationTime);
+ nestedUpdateCount = 0;
+ lastCommittedRootDuringThisBatch = null;
+ if (null !== completedBatches) for (minExpirationTime = completedBatches, completedBatches = null, isYieldy = 0; isYieldy < minExpirationTime.length; isYieldy++) {
+ var batch = minExpirationTime[isYieldy];
+
+ try {
+ batch._onComplete();
+ } catch (error) {
+ hasUnhandledError || (hasUnhandledError = !0, unhandledError = error);
+ }
+ }
+ if (hasUnhandledError) throw minExpirationTime = unhandledError, unhandledError = null, hasUnhandledError = !1, minExpirationTime;
+ }
+
+ 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;
+
+ if (isYieldy) {
+ var _finishedWork = root.finishedWork;
+ null !== _finishedWork ? completeRoot(root, _finishedWork, expirationTime) : (root.finishedWork = null, _finishedWork = root.timeoutHandle, -1 !== _finishedWork && (root.timeoutHandle = -1, cancelTimeout(_finishedWork)), renderRoot(root, isYieldy), _finishedWork = root.finishedWork, null !== _finishedWork && (frameDeadline <= now$1() ? root.finishedWork = _finishedWork : completeRoot(root, _finishedWork, expirationTime)));
+ } else _finishedWork = root.finishedWork, null !== _finishedWork ? completeRoot(root, _finishedWork, expirationTime) : (root.finishedWork = null, _finishedWork = root.timeoutHandle, -1 !== _finishedWork && (root.timeoutHandle = -1, cancelTimeout(_finishedWork)), renderRoot(root, isYieldy), _finishedWork = root.finishedWork, null !== _finishedWork && completeRoot(root, _finishedWork, expirationTime));
+
+ isRendering = !1;
+ }
+
+ function completeRoot(root, finishedWork, expirationTime) {
+ var firstBatch = root.firstBatch;
+
+ if (null !== firstBatch && firstBatch._expirationTime >= expirationTime && (null === completedBatches ? completedBatches = [firstBatch] : completedBatches.push(firstBatch), firstBatch._defer)) {
+ root.finishedWork = finishedWork;
+ root.expirationTime = 0;
+ return;
+ }
+
+ root.finishedWork = null;
+ root === lastCommittedRootDuringThisBatch ? nestedUpdateCount++ : (lastCommittedRootDuringThisBatch = root, nestedUpdateCount = 0);
+ scheduler.unstable_runWithPriority(scheduler.unstable_ImmediatePriority, function () {
+ commitRoot(root, finishedWork);
+ });
+ }
+
+ 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 findHostInstance(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$$1 = container.current,
+ currentTime = requestCurrentTime();
+ current$$1 = computeExpirationForFiber(currentTime, current$$1);
+ currentTime = container.current;
+
+ a: if (parentComponent) {
+ parentComponent = parentComponent._reactInternalFiber;
+
+ b: {
+ invariant(2 === isFiberMountedImpl(parentComponent) && 1 === 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.");
+ var parentContext = parentComponent;
+
+ do {
+ switch (parentContext.tag) {
+ case 3:
+ parentContext = parentContext.stateNode.context;
+ break b;
+
+ case 1:
+ if (isContextProvider(parentContext.type)) {
+ parentContext = parentContext.stateNode.__reactInternalMemoizedMergedChildContext;
+ break b;
+ }
+
+ }
+
+ parentContext = parentContext.return;
+ } while (null !== parentContext);
+
+ invariant(!1, "Found unexpected detached subtree parent. This error is likely caused by a bug in React. Please file an issue.");
+ parentContext = void 0;
+ }
+
+ if (1 === parentComponent.tag) {
+ var Component = parentComponent.type;
+
+ if (isContextProvider(Component)) {
+ parentComponent = processChildContext(parentComponent, Component, parentContext);
+ break a;
+ }
+ }
+
+ parentComponent = parentContext;
+ } else parentComponent = emptyContextObject;
+
+ null === container.context ? container.context = parentComponent : container.pendingContext = parentComponent;
+ container = callback;
+ callback = createUpdate(current$$1);
+ callback.payload = {
+ element: element
+ };
+ container = void 0 === container ? null : container;
+ null !== container && (callback.callback = container);
+ flushPassiveEffects();
+ enqueueUpdate(currentTime, callback);
+ scheduleWork(currentTime, current$$1);
+ return current$$1;
+ }
+
+ function _createPortal(children, containerInfo, implementation) {
+ var key = 3 < arguments.length && void 0 !== arguments[3] ? arguments[3] : null;
+ return {
+ $$typeof: REACT_PORTAL_TYPE,
+ key: null == key ? null : "" + key,
+ children: children,
+ containerInfo: containerInfo,
+ implementation: implementation
+ };
+ }
+
+ function _inherits(subClass, superClass) {
+ if ("function" !== typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+ subClass.prototype = Object.create(superClass && superClass.prototype, {
+ constructor: {
+ value: subClass,
+ enumerable: !1,
+ writable: !0,
+ configurable: !0
+ }
+ });
+ superClass && (Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass);
+ }
+
+ var getInspectorDataForViewTag = void 0;
+
+ getInspectorDataForViewTag = function getInspectorDataForViewTag() {
+ 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(componentOrHandle);
+ return null == componentOrHandle ? componentOrHandle : componentOrHandle.canonical ? componentOrHandle.canonical._nativeTag : componentOrHandle._nativeTag;
+ }
+
+ _batchedUpdatesImpl = function _batchedUpdatesImpl(fn, a) {
+ var previousIsBatchingUpdates = isBatchingUpdates;
+ isBatchingUpdates = !0;
+
+ try {
+ return fn(a);
+ } finally {
+ (isBatchingUpdates = previousIsBatchingUpdates) || isRendering || performWork(1073741823, !1);
+ }
+ };
+
+ _flushInteractiveUpdatesImpl = function _flushInteractiveUpdatesImpl() {
+ isRendering || 0 === lowestPriorityPendingInteractiveExpirationTime || (performWork(lowestPriorityPendingInteractiveExpirationTime, !1), lowestPriorityPendingInteractiveExpirationTime = 0);
+ };
+
+ 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_NOT_REALLY_SAFE(this, callback));
+ };
+
+ ReactNativeComponent.prototype.measureInWindow = function (callback) {
+ UIManager.measureInWindow(findNodeHandle(this), mountSafeCallback_NOT_REALLY_SAFE(this, callback));
+ };
+
+ ReactNativeComponent.prototype.measureLayout = function (relativeToNativeNode, onSuccess, onFail) {
+ UIManager.measureLayout(findNodeHandle(this), relativeToNativeNode, mountSafeCallback_NOT_REALLY_SAFE(this, onFail), mountSafeCallback_NOT_REALLY_SAFE(this, onSuccess));
+ };
+
+ ReactNativeComponent.prototype.setNativeProps = function (nativeProps) {
+ var maybeInstance = void 0;
+
+ try {
+ maybeInstance = findHostInstance(this);
+ } catch (error) {}
+
+ if (null != maybeInstance) {
+ var nativeTag = maybeInstance._nativeTag || maybeInstance.canonical._nativeTag;
+ maybeInstance = maybeInstance.viewConfig || maybeInstance.canonical.viewConfig;
+ nativeProps = diffProperties(null, emptyObject, nativeProps, maybeInstance.validAttributes);
+ null != nativeProps && UIManager.updateView(nativeTag, maybeInstance.uiViewClassName, nativeProps);
+ }
+ };
+
+ return ReactNativeComponent;
+ }(React.Component);
+ }(findNodeHandle, findHostInstance),
+ findNodeHandle: findNodeHandle,
+ setNativeProps: function setNativeProps(handle, nativeProps) {
+ null != handle._nativeTag && (nativeProps = diffProperties(null, emptyObject, nativeProps, handle.viewConfig.validAttributes), null != nativeProps && UIManager.updateView(handle._nativeTag, handle.viewConfig.uiViewClassName, nativeProps));
+ },
+ render: function render(element, containerTag, callback) {
+ var root = roots.get(containerTag);
+
+ if (!root) {
+ root = createFiber(3, null, null, 0);
+ var root$jscomp$0 = {
+ current: root,
+ containerInfo: containerTag,
+ pendingChildren: null,
+ pingCache: null,
+ earliestPendingTime: 0,
+ latestPendingTime: 0,
+ earliestSuspendedTime: 0,
+ latestSuspendedTime: 0,
+ latestPingedTime: 0,
+ didError: !1,
+ pendingCommitExpirationTime: 0,
+ finishedWork: null,
+ timeoutHandle: -1,
+ context: null,
+ pendingContext: null,
+ hydrate: !1,
+ nextExpirationTimeToWorkOn: 0,
+ expirationTime: 0,
+ firstBatch: null,
+ nextScheduledRoot: null
+ };
+ root = root.stateNode = root$jscomp$0;
+ roots.set(containerTag, root);
+ }
+
+ updateContainer(element, root, null, callback);
+
+ a: if (element = root.current, element.child) switch (element.child.tag) {
+ case 5:
+ element = element.child.stateNode;
+ break a;
+
+ default:
+ element = element.child.stateNode;
+ } else element = null;
+
+ return element;
+ },
+ unmountComponentAtNode: function unmountComponentAtNode(containerTag) {
+ var root = roots.get(containerTag);
+ root && updateContainer(null, root, null, function () {
+ roots.delete(containerTag);
+ });
+ },
+ unmountComponentAtNodeAndRemoveContainer: function unmountComponentAtNodeAndRemoveContainer(containerTag) {
+ ReactNativeRenderer.unmountComponentAtNode(containerTag);
+ 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_NOT_REALLY_SAFE(this, callback));
+ },
+ measureInWindow: function measureInWindow(callback) {
+ UIManager.measureInWindow(findNodeHandle(this), mountSafeCallback_NOT_REALLY_SAFE(this, callback));
+ },
+ measureLayout: function measureLayout(relativeToNativeNode, onSuccess, onFail) {
+ UIManager.measureLayout(findNodeHandle(this), relativeToNativeNode, mountSafeCallback_NOT_REALLY_SAFE(this, onFail), mountSafeCallback_NOT_REALLY_SAFE(this, onSuccess));
+ },
+ setNativeProps: function setNativeProps(nativeProps) {
+ var maybeInstance = void 0;
+
+ try {
+ maybeInstance = findHostInstance(this);
+ } catch (error) {}
+
+ if (null != maybeInstance) {
+ var nativeTag = maybeInstance._nativeTag || maybeInstance.canonical._nativeTag;
+ maybeInstance = maybeInstance.viewConfig || maybeInstance.canonical.viewConfig;
+ nativeProps = diffProperties(null, emptyObject, nativeProps, maybeInstance.validAttributes);
+ null != nativeProps && UIManager.updateView(nativeTag, maybeInstance.uiViewClassName, nativeProps);
+ }
+ },
+ focus: function focus() {
+ TextInputState.focusTextInput(findNodeHandle(this));
+ },
+ blur: function blur() {
+ TextInputState.blurTextInput(findNodeHandle(this));
+ }
+ };
+ }(findNodeHandle, findHostInstance),
+ computeComponentStackForErrorReporting: function computeComponentStackForErrorReporting(reactTag) {
+ return (reactTag = getInstanceFromTag(reactTag)) ? getStackByFiberInDevAndProd(reactTag) : "";
+ }
+ }
+ };
+
+ (function (devToolsConfig) {
+ var _findFiberByHostInstance = devToolsConfig.findFiberByHostInstance;
+ return injectInternals(_extends({}, devToolsConfig, {
+ overrideProps: null,
+ currentDispatcherRef: ReactSharedInternals.ReactCurrentDispatcher,
+ findHostInstanceByFiber: function findHostInstanceByFiber(fiber) {
+ fiber = findCurrentHostFiber(fiber);
+ return null === fiber ? null : fiber.stateNode;
+ },
+ findFiberByHostInstance: function findFiberByHostInstance(instance) {
+ return _findFiberByHostInstance ? _findFiberByHostInstance(instance) : null;
+ }
+ }));
+ })({
+ findFiberByHostInstance: getInstanceFromTag,
+ getInspectorDataForViewTag: getInspectorDataForViewTag,
+ bundleType: 0,
+ version: "16.8.3",
+ rendererPackageName: "react-native-renderer"
+ });
+
+ var ReactNativeRenderer$2 = {
+ default: ReactNativeRenderer
+ },
+ ReactNativeRenderer$3 = ReactNativeRenderer$2 && ReactNativeRenderer || ReactNativeRenderer$2;
+ module.exports = ReactNativeRenderer$3.default || ReactNativeRenderer$3;
+},183,[14,86,173,71,174,11,175,80,176,180,98],"node_modules\\react-native\\Libraries\\Renderer\\oss\\ReactNativeRenderer-prod.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var createReactNativeComponentClass = _$$_REQUIRE(_dependencyMap[0], "createReactNativeComponentClass");
+
+ var getNativeComponentAttributes = _$$_REQUIRE(_dependencyMap[1], "getNativeComponentAttributes");
+
+ var requireNativeComponent = function requireNativeComponent(uiViewClassName) {
+ return createReactNativeComponentClass(uiViewClassName, function () {
+ return getNativeComponentAttributes(uiViewClassName);
+ });
+ };
+
+ module.exports = requireNativeComponent;
+},184,[185,186],"node_modules\\react-native\\Libraries\\ReactNative\\requireNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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;
+},185,[173],"node_modules\\react-native\\Libraries\\Renderer\\shims\\createReactNativeComponentClass.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/defineProperty");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var ReactNativeStyleAttributes = _$$_REQUIRE(_dependencyMap[2], "ReactNativeStyleAttributes");
+
+ var UIManager = _$$_REQUIRE(_dependencyMap[3], "UIManager");
+
+ var insetsDiffer = _$$_REQUIRE(_dependencyMap[4], "insetsDiffer");
+
+ var matricesDiffer = _$$_REQUIRE(_dependencyMap[5], "matricesDiffer");
+
+ var pointsDiffer = _$$_REQUIRE(_dependencyMap[6], "pointsDiffer");
+
+ var processColor = _$$_REQUIRE(_dependencyMap[7], "processColor");
+
+ var resolveAssetSource = _$$_REQUIRE(_dependencyMap[8], "resolveAssetSource");
+
+ var sizesDiffer = _$$_REQUIRE(_dependencyMap[9], "sizesDiffer");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[10], "invariant");
+
+ var warning = _$$_REQUIRE(_dependencyMap[11], "fbjs/lib/warning");
+
+ function getNativeComponentAttributes(uiViewClassName) {
+ var viewConfig = UIManager.getViewManagerConfig(uiViewClassName);
+ invariant(viewConfig != null && viewConfig.NativeProps != null, 'requireNativeComponent: "%s" was not found in the UIManager.', uiViewClassName);
+ var baseModuleName = viewConfig.baseModuleName,
+ bubblingEventTypes = viewConfig.bubblingEventTypes,
+ directEventTypes = viewConfig.directEventTypes;
+ var nativeProps = viewConfig.NativeProps;
+
+ while (baseModuleName) {
+ var baseModule = UIManager.getViewManagerConfig(baseModuleName);
+
+ if (!baseModule) {
+ warning(false, 'Base module "%s" does not exist', baseModuleName);
+ baseModuleName = null;
+ } else {
+ bubblingEventTypes = _objectSpread({}, baseModule.bubblingEventTypes, {}, bubblingEventTypes);
+ directEventTypes = _objectSpread({}, baseModule.directEventTypes, {}, directEventTypes);
+ nativeProps = _objectSpread({}, baseModule.NativeProps, {}, nativeProps);
+ baseModuleName = baseModule.baseModuleName;
+ }
+ }
+
+ var validAttributes = {};
+
+ for (var key in nativeProps) {
+ var typeName = nativeProps[key];
+ var diff = getDifferForType(typeName);
+ var process = getProcessorForType(typeName);
+ validAttributes[key] = diff == null && process == null ? true : {
+ diff: diff,
+ process: process
+ };
+ }
+
+ validAttributes.style = ReactNativeStyleAttributes;
+
+ _extends(viewConfig, {
+ uiViewClassName: uiViewClassName,
+ validAttributes: validAttributes,
+ bubblingEventTypes: bubblingEventTypes,
+ directEventTypes: directEventTypes
+ });
+
+ if (!hasAttachedDefaultEventTypes) {
+ attachDefaultEventTypes(viewConfig);
+ hasAttachedDefaultEventTypes = true;
+ }
+
+ return viewConfig;
+ }
+
+ var hasAttachedDefaultEventTypes = false;
+
+ function attachDefaultEventTypes(viewConfig) {
+ if (UIManager.ViewManagerNames || UIManager.LazyViewManagersEnabled) {
+ 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 = getNativeComponentAttributes;
+},186,[14,32,57,71,187,188,189,75,190,78,19,21],"node_modules\\react-native\\Libraries\\ReactNative\\getNativeComponentAttributes.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var dummyInsets = {
+ top: undefined,
+ left: undefined,
+ right: undefined,
+ bottom: undefined
+ };
+
+ var insetsDiffer = function insetsDiffer(one, two) {
+ one = one || dummyInsets;
+ two = two || dummyInsets;
+ return one !== two && (one.top !== two.top || one.left !== two.left || one.right !== two.right || one.bottom !== two.bottom);
+ };
+
+ module.exports = insetsDiffer;
+},187,[],"node_modules\\react-native\\Libraries\\Utilities\\differ\\insetsDiffer.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var matricesDiffer = function matricesDiffer(one, two) {
+ if (one === two) {
+ return false;
+ }
+
+ return !one || !two || one[12] !== two[12] || one[13] !== two[13] || one[14] !== two[14] || one[5] !== two[5] || one[10] !== two[10] || one[1] !== two[1] || one[2] !== two[2] || one[3] !== two[3] || one[4] !== two[4] || one[6] !== two[6] || one[7] !== two[7] || one[8] !== two[8] || one[9] !== two[9] || one[11] !== two[11] || one[15] !== two[15];
+ };
+
+ module.exports = matricesDiffer;
+},188,[],"node_modules\\react-native\\Libraries\\Utilities\\differ\\matricesDiffer.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var dummyPoint = {
+ x: undefined,
+ y: undefined
+ };
+
+ var pointsDiffer = function pointsDiffer(one, two) {
+ one = one || dummyPoint;
+ two = two || dummyPoint;
+ return one !== two && (one.x !== two.x || one.y !== two.y);
+ };
+
+ module.exports = pointsDiffer;
+},189,[],"node_modules\\react-native\\Libraries\\Utilities\\differ\\pointsDiffer.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var AssetRegistry = _$$_REQUIRE(_dependencyMap[0], "AssetRegistry");
+
+ var AssetSourceResolver = _$$_REQUIRE(_dependencyMap[1], "AssetSourceResolver");
+
+ var _customSourceTransformer, _serverURL, _scriptURL;
+
+ var _sourceCodeScriptURL;
+
+ function getSourceCodeScriptURL() {
+ if (_sourceCodeScriptURL) {
+ return _sourceCodeScriptURL;
+ }
+
+ var sourceCode = global.nativeExtensions && global.nativeExtensions.SourceCode;
+
+ if (!sourceCode) {
+ 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;
+},190,[191,192,36],"node_modules\\react-native\\Libraries\\Image\\resolveAssetSource.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var assets = [];
+
+ function registerAsset(asset) {
+ return assets.push(asset);
+ }
+
+ function getAssetByID(assetId) {
+ return assets[assetId - 1];
+ }
+
+ module.exports = {
+ registerAsset: registerAsset,
+ getAssetByID: getAssetByID
+ };
+},191,[],"node_modules\\react-native\\Libraries\\Image\\AssetRegistry.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var PixelRatio = _$$_REQUIRE(_dependencyMap[2], "PixelRatio");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[3], "Platform");
+
+ var assetPathUtils = _$$_REQUIRE(_dependencyMap[4], "./assetPathUtils");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[5], "invariant");
+
+ function getScaledAssetPath(asset) {
+ var scale = AssetSourceResolver.pickScale(asset.scales, PixelRatio.get());
+ var scaleSuffix = scale === 1 ? '' : '@' + scale + 'x';
+ var assetDir = assetPathUtils.getBasePath(asset);
+ return assetDir + '/' + asset.name + scaleSuffix + '.' + asset.type;
+ }
+
+ function getAssetPathInDrawableFolder(asset) {
+ var scale = AssetSourceResolver.pickScale(asset.scales, PixelRatio.get());
+ var drawbleFolder = assetPathUtils.getAndroidResourceFolderName(asset, scale);
+ var fileName = assetPathUtils.getAndroidResourceIdentifier(asset);
+ return drawbleFolder + '/' + fileName + '.' + asset.type;
+ }
+
+ var AssetSourceResolver = function () {
+ function AssetSourceResolver(serverUrl, jsbundleUrl, asset) {
+ _classCallCheck(this, AssetSourceResolver);
+
+ this.serverUrl = serverUrl;
+ this.jsbundleUrl = jsbundleUrl;
+ this.asset = asset;
+ }
+
+ _createClass(AssetSourceResolver, [{
+ key: "isLoadedFromServer",
+ value: function isLoadedFromServer() {
+ return !!this.serverUrl;
+ }
+ }, {
+ key: "isLoadedFromFileSystem",
+ value: function isLoadedFromFileSystem() {
+ return !!(this.jsbundleUrl && this.jsbundleUrl.startsWith('file://'));
+ }
+ }, {
+ key: "defaultAsset",
+ value: function defaultAsset() {
+ if (this.isLoadedFromServer()) {
+ return this.assetServerURL();
+ }
+
+ if (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;
+},192,[3,4,54,35,193,19],"node_modules\\react-native\\Libraries\\Image\\AssetSourceResolver.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var androidScaleSuffix = {
+ '0.75': 'ldpi',
+ '1': 'mdpi',
+ '1.5': 'hdpi',
+ '2': 'xhdpi',
+ '3': 'xxhdpi',
+ '4': 'xxxhdpi'
+ };
+
+ function getAndroidAssetSuffix(scale) {
+ if (scale.toString() in androidScaleSuffix) {
+ return androidScaleSuffix[scale.toString()];
+ }
+
+ throw new Error('no such scale ' + scale.toString());
+ }
+
+ var drawableFileTypes = new Set(['gif', 'jpeg', 'jpg', 'png', 'svg', 'webp', 'xml']);
+
+ function getAndroidResourceFolderName(asset, scale) {
+ if (!drawableFileTypes.has(asset.type)) {
+ return 'raw';
+ }
+
+ var suffix = getAndroidAssetSuffix(scale);
+
+ if (!suffix) {
+ throw new Error("Don't know which android drawable suffix to use for scale: " + scale + '\nAsset: ' + JSON.stringify(asset, null, '\t') + '\nPossible scales are:' + JSON.stringify(androidScaleSuffix, null, '\t'));
+ }
+
+ var androidFolder = 'drawable-' + suffix;
+ return androidFolder;
+ }
+
+ function getAndroidResourceIdentifier(asset) {
+ var folderPath = getBasePath(asset);
+ return (folderPath + '/' + asset.name).toLowerCase().replace(/\//g, '_').replace(/([^a-z0-9_])/g, '').replace(/^assets_/, '');
+ }
+
+ function getBasePath(asset) {
+ var basePath = asset.httpServerLocation;
+
+ if (basePath[0] === '/') {
+ basePath = basePath.substr(1);
+ }
+
+ return basePath;
+ }
+
+ module.exports = {
+ getAndroidAssetSuffix: getAndroidAssetSuffix,
+ getAndroidResourceFolderName: getAndroidResourceFolderName,
+ getAndroidResourceIdentifier: getAndroidResourceIdentifier,
+ getBasePath: getBasePath
+ };
+},193,[],"node_modules\\react-native\\Libraries\\Image\\assetPathUtils.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var requireNativeComponent = _$$_REQUIRE(_dependencyMap[0], "requireNativeComponent");
+
+ module.exports = requireNativeComponent('RCTActivityIndicatorView');
+},194,[184],"node_modules\\react-native\\Libraries\\Components\\ActivityIndicator\\RCTActivityIndicatorViewNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "UnimplementedView");
+},195,[196],"Libraries\\Components\\ProgressBarAndroid\\ProgressBarAndroid.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Components\\UnimplementedViews\\UnimplementedView.js";
+
+ var React = _$$_REQUIRE(_dependencyMap[5], "React");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[6], "StyleSheet");
+
+ var UnimplementedView = function (_React$Component) {
+ _inherits(UnimplementedView, _React$Component);
+
+ function UnimplementedView() {
+ _classCallCheck(this, UnimplementedView);
+
+ return _possibleConstructorReturn(this, _getPrototypeOf(UnimplementedView).apply(this, arguments));
+ }
+
+ _createClass(UnimplementedView, [{
+ key: "setNativeProps",
+ value: function setNativeProps() {}
+ }, {
+ key: "render",
+ value: function render() {
+ var View = _$$_REQUIRE(_dependencyMap[7], "View");
+
+ return React.createElement(View, {
+ style: [styles.unimplementedView, this.props.style],
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 30
+ }
+ }, this.props.children);
+ }
+ }]);
+
+ return UnimplementedView;
+ }(React.Component);
+
+ var styles = StyleSheet.create({
+ unimplementedView: __DEV__ ? {
+ alignSelf: 'flex-start',
+ borderColor: 'red',
+ borderWidth: 1
+ } : {}
+ });
+ module.exports = UnimplementedView;
+},196,[3,4,5,8,9,52,53,81],"node_modules\\react-native\\Libraries\\Components\\UnimplementedViews\\UnimplementedView.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\ART\\ReactNativeART.js";
+
+ var Color = _$$_REQUIRE(_dependencyMap[5], "art/core/color");
+
+ var Path = _$$_REQUIRE(_dependencyMap[6], "ARTSerializablePath");
+
+ var Transform = _$$_REQUIRE(_dependencyMap[7], "art/core/transform");
+
+ var React = _$$_REQUIRE(_dependencyMap[8], "React");
+
+ var PropTypes = _$$_REQUIRE(_dependencyMap[9], "prop-types");
+
+ var ReactNativeViewAttributes = _$$_REQUIRE(_dependencyMap[10], "ReactNativeViewAttributes");
+
+ var createReactNativeComponentClass = _$$_REQUIRE(_dependencyMap[11], "createReactNativeComponentClass");
+
+ var merge = _$$_REQUIRE(_dependencyMap[12], "merge");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[13], "invariant");
+
+ function arrayDiffer(a, b) {
+ if (a == null || b == null) {
+ return true;
+ }
+
+ if (a.length !== b.length) {
+ return true;
+ }
+
+ for (var i = 0; i < a.length; i++) {
+ if (a[i] !== b[i]) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ function fontAndLinesDiffer(a, b) {
+ if (a === b) {
+ return false;
+ }
+
+ if (a.font !== b.font) {
+ if (a.font === null) {
+ return true;
+ }
+
+ if (b.font === null) {
+ return true;
+ }
+
+ if (a.font.fontFamily !== b.font.fontFamily || a.font.fontSize !== b.font.fontSize || a.font.fontWeight !== b.font.fontWeight || a.font.fontStyle !== b.font.fontStyle) {
+ return true;
+ }
+ }
+
+ return arrayDiffer(a.lines, b.lines);
+ }
+
+ var SurfaceViewAttributes = merge(ReactNativeViewAttributes.UIView, {});
+ var NodeAttributes = {
+ transform: {
+ diff: arrayDiffer
+ },
+ opacity: true
+ };
+ var GroupAttributes = merge(NodeAttributes, {
+ clipping: {
+ diff: arrayDiffer
+ }
+ });
+ var RenderableAttributes = merge(NodeAttributes, {
+ fill: {
+ diff: arrayDiffer
+ },
+ stroke: {
+ diff: arrayDiffer
+ },
+ strokeWidth: true,
+ strokeCap: true,
+ strokeJoin: true,
+ strokeDash: {
+ diff: arrayDiffer
+ }
+ });
+ var ShapeAttributes = merge(RenderableAttributes, {
+ d: {
+ diff: arrayDiffer
+ }
+ });
+ var TextAttributes = merge(RenderableAttributes, {
+ alignment: true,
+ frame: {
+ diff: fontAndLinesDiffer
+ },
+ path: {
+ diff: arrayDiffer
+ }
+ });
+ var NativeSurfaceView = createReactNativeComponentClass('ARTSurfaceView', function () {
+ return {
+ validAttributes: SurfaceViewAttributes,
+ uiViewClassName: 'ARTSurfaceView'
+ };
+ });
+ var NativeGroup = createReactNativeComponentClass('ARTGroup', function () {
+ return {
+ validAttributes: GroupAttributes,
+ uiViewClassName: 'ARTGroup'
+ };
+ });
+ var NativeShape = createReactNativeComponentClass('ARTShape', function () {
+ return {
+ validAttributes: ShapeAttributes,
+ uiViewClassName: 'ARTShape'
+ };
+ });
+ var NativeText = createReactNativeComponentClass('ARTText', function () {
+ return {
+ validAttributes: TextAttributes,
+ uiViewClassName: 'ARTText'
+ };
+ });
+
+ function childrenAsString(children) {
+ if (!children) {
+ return '';
+ }
+
+ if (typeof children === 'string') {
+ return children;
+ }
+
+ if (children.length) {
+ return children.join('\n');
+ }
+
+ return '';
+ }
+
+ var Surface = function (_React$Component) {
+ _inherits(Surface, _React$Component);
+
+ function Surface() {
+ _classCallCheck(this, Surface);
+
+ return _possibleConstructorReturn(this, _getPrototypeOf(Surface).apply(this, arguments));
+ }
+
+ _createClass(Surface, [{
+ key: "getChildContext",
+ value: function getChildContext() {
+ return {
+ isInSurface: true
+ };
+ }
+ }, {
+ key: "render",
+ value: function render() {
+ var height = extractNumber(this.props.height, 0);
+ var width = extractNumber(this.props.width, 0);
+ return React.createElement(NativeSurfaceView, {
+ style: [this.props.style, {
+ height: height,
+ width: width
+ }],
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 157
+ }
+ }, this.props.children);
+ }
+ }]);
+
+ return Surface;
+ }(React.Component);
+
+ Surface.childContextTypes = {
+ isInSurface: PropTypes.bool
+ };
+
+ function extractNumber(value, defaultValue) {
+ if (value == null) {
+ return defaultValue;
+ }
+
+ return +value;
+ }
+
+ var pooledTransform = new Transform();
+
+ function extractTransform(props) {
+ var scaleX = props.scaleX != null ? props.scaleX : props.scale != null ? props.scale : 1;
+ var scaleY = props.scaleY != null ? props.scaleY : props.scale != null ? props.scale : 1;
+ pooledTransform.transformTo(1, 0, 0, 1, 0, 0).move(props.x || 0, props.y || 0).rotate(props.rotation || 0, props.originX, props.originY).scale(scaleX, scaleY, props.originX, props.originY);
+
+ if (props.transform != null) {
+ pooledTransform.transform(props.transform);
+ }
+
+ return [pooledTransform.xx, pooledTransform.yx, pooledTransform.xy, pooledTransform.yy, pooledTransform.x, pooledTransform.y];
+ }
+
+ function extractOpacity(props) {
+ if (props.visible === false) {
+ return 0;
+ }
+
+ if (props.opacity == null) {
+ return 1;
+ }
+
+ return +props.opacity;
+ }
+
+ var Group = function (_React$Component2) {
+ _inherits(Group, _React$Component2);
+
+ function Group() {
+ _classCallCheck(this, Group);
+
+ return _possibleConstructorReturn(this, _getPrototypeOf(Group).apply(this, arguments));
+ }
+
+ _createClass(Group, [{
+ key: "render",
+ value: function render() {
+ var props = this.props;
+ invariant(this.context.isInSurface, 'ART: must be a child of a ');
+ return React.createElement(NativeGroup, {
+ opacity: extractOpacity(props),
+ transform: extractTransform(props),
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 232
+ }
+ }, this.props.children);
+ }
+ }]);
+
+ return Group;
+ }(React.Component);
+
+ Group.contextTypes = {
+ isInSurface: PropTypes.bool.isRequired
+ };
+
+ var ClippingRectangle = function (_React$Component3) {
+ _inherits(ClippingRectangle, _React$Component3);
+
+ function ClippingRectangle() {
+ _classCallCheck(this, ClippingRectangle);
+
+ return _possibleConstructorReturn(this, _getPrototypeOf(ClippingRectangle).apply(this, arguments));
+ }
+
+ _createClass(ClippingRectangle, [{
+ key: "render",
+ value: function render() {
+ var props = this.props;
+ var x = extractNumber(props.x, 0);
+ var y = extractNumber(props.y, 0);
+ var w = extractNumber(props.width, 0);
+ var h = extractNumber(props.height, 0);
+ var clipping = [x, y, w, h];
+ var propsExcludingXAndY = merge(props);
+ delete propsExcludingXAndY.x;
+ delete propsExcludingXAndY.y;
+ return React.createElement(NativeGroup, {
+ clipping: clipping,
+ opacity: extractOpacity(props),
+ transform: extractTransform(propsExcludingXAndY),
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 254
+ }
+ }, this.props.children);
+ }
+ }]);
+
+ return ClippingRectangle;
+ }(React.Component);
+
+ var SOLID_COLOR = 0;
+ var LINEAR_GRADIENT = 1;
+ var RADIAL_GRADIENT = 2;
+ var PATTERN = 3;
+
+ function insertColorIntoArray(color, targetArray, atIndex) {
+ var c = new Color(color);
+ targetArray[atIndex + 0] = c.red / 255;
+ targetArray[atIndex + 1] = c.green / 255;
+ targetArray[atIndex + 2] = c.blue / 255;
+ targetArray[atIndex + 3] = c.alpha;
+ }
+
+ function insertColorsIntoArray(stops, targetArray, atIndex) {
+ var i = 0;
+
+ if ('length' in stops) {
+ while (i < stops.length) {
+ insertColorIntoArray(stops[i], targetArray, atIndex + i * 4);
+ i++;
+ }
+ } else {
+ for (var offset in stops) {
+ insertColorIntoArray(stops[offset], targetArray, atIndex + i * 4);
+ i++;
+ }
+ }
+
+ return atIndex + i * 4;
+ }
+
+ function insertOffsetsIntoArray(stops, targetArray, atIndex, multi, reverse) {
+ var offsetNumber;
+ var i = 0;
+
+ if ('length' in stops) {
+ while (i < stops.length) {
+ offsetNumber = i / (stops.length - 1) * multi;
+ targetArray[atIndex + i] = reverse ? 1 - offsetNumber : offsetNumber;
+ i++;
+ }
+ } else {
+ for (var offsetString in stops) {
+ offsetNumber = +offsetString * multi;
+ targetArray[atIndex + i] = reverse ? 1 - offsetNumber : offsetNumber;
+ i++;
+ }
+ }
+
+ return atIndex + i;
+ }
+
+ function insertColorStopsIntoArray(stops, targetArray, atIndex) {
+ var lastIndex = insertColorsIntoArray(stops, targetArray, atIndex);
+ insertOffsetsIntoArray(stops, targetArray, lastIndex, 1, false);
+ }
+
+ function insertDoubleColorStopsIntoArray(stops, targetArray, atIndex) {
+ var lastIndex = insertColorsIntoArray(stops, targetArray, atIndex);
+ lastIndex = insertColorsIntoArray(stops, targetArray, lastIndex);
+ lastIndex = insertOffsetsIntoArray(stops, targetArray, lastIndex, 0.5, false);
+ insertOffsetsIntoArray(stops, targetArray, lastIndex, 0.5, true);
+ }
+
+ function applyBoundingBoxToBrushData(brushData, props) {
+ var type = brushData[0];
+ var width = +props.width;
+ var height = +props.height;
+
+ if (type === LINEAR_GRADIENT) {
+ brushData[1] *= width;
+ brushData[2] *= height;
+ brushData[3] *= width;
+ brushData[4] *= height;
+ } else if (type === RADIAL_GRADIENT) {
+ brushData[1] *= width;
+ brushData[2] *= height;
+ brushData[3] *= width;
+ brushData[4] *= height;
+ brushData[5] *= width;
+ brushData[6] *= height;
+ } else if (type === PATTERN) {}
+ }
+
+ function extractBrush(colorOrBrush, props) {
+ if (colorOrBrush == null) {
+ return null;
+ }
+
+ if (colorOrBrush._brush) {
+ if (colorOrBrush._bb) {
+ applyBoundingBoxToBrushData(colorOrBrush._brush, props);
+ colorOrBrush._bb = false;
+ }
+
+ return colorOrBrush._brush;
+ }
+
+ var c = new Color(colorOrBrush);
+ return [SOLID_COLOR, c.red / 255, c.green / 255, c.blue / 255, c.alpha];
+ }
+
+ function extractColor(color) {
+ if (color == null) {
+ return null;
+ }
+
+ var c = new Color(color);
+ return [c.red / 255, c.green / 255, c.blue / 255, c.alpha];
+ }
+
+ function extractStrokeCap(strokeCap) {
+ switch (strokeCap) {
+ case 'butt':
+ return 0;
+
+ case 'square':
+ return 2;
+
+ default:
+ return 1;
+ }
+ }
+
+ function extractStrokeJoin(strokeJoin) {
+ switch (strokeJoin) {
+ case 'miter':
+ return 0;
+
+ case 'bevel':
+ return 2;
+
+ default:
+ return 1;
+ }
+ }
+
+ var Shape = function (_React$Component4) {
+ _inherits(Shape, _React$Component4);
+
+ function Shape() {
+ _classCallCheck(this, Shape);
+
+ return _possibleConstructorReturn(this, _getPrototypeOf(Shape).apply(this, arguments));
+ }
+
+ _createClass(Shape, [{
+ key: "render",
+ value: function render() {
+ var props = this.props;
+ var path = props.d || childrenAsString(props.children);
+ var d = (path instanceof Path ? path : new Path(path)).toJSON();
+ return React.createElement(NativeShape, {
+ fill: extractBrush(props.fill, props),
+ opacity: extractOpacity(props),
+ stroke: extractColor(props.stroke),
+ strokeCap: extractStrokeCap(props.strokeCap),
+ strokeDash: props.strokeDash || null,
+ strokeJoin: extractStrokeJoin(props.strokeJoin),
+ strokeWidth: extractNumber(props.strokeWidth, 1),
+ transform: extractTransform(props),
+ d: d,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 420
+ }
+ });
+ }
+ }]);
+
+ return Shape;
+ }(React.Component);
+
+ var cachedFontObjectsFromString = {};
+ var fontFamilyPrefix = /^[\s"']*/;
+ var fontFamilySuffix = /[\s"']*$/;
+
+ function extractSingleFontFamily(fontFamilyString) {
+ return fontFamilyString.split(',')[0].replace(fontFamilyPrefix, '').replace(fontFamilySuffix, '');
+ }
+
+ function parseFontString(font) {
+ if (cachedFontObjectsFromString.hasOwnProperty(font)) {
+ return cachedFontObjectsFromString[font];
+ }
+
+ var regexp = /^\s*((?:(?:normal|bold|italic)\s+)*)(?:(\d+(?:\.\d+)?)[ptexm\%]*(?:\s*\/.*?)?\s+)?\s*\"?([^\"]*)/i;
+ var match = regexp.exec(font);
+
+ if (!match) {
+ return null;
+ }
+
+ var fontFamily = extractSingleFontFamily(match[3]);
+ var fontSize = +match[2] || 12;
+ var isBold = /bold/.exec(match[1]);
+ var isItalic = /italic/.exec(match[1]);
+ cachedFontObjectsFromString[font] = {
+ fontFamily: fontFamily,
+ fontSize: fontSize,
+ fontWeight: isBold ? 'bold' : 'normal',
+ fontStyle: isItalic ? 'italic' : 'normal'
+ };
+ return cachedFontObjectsFromString[font];
+ }
+
+ function extractFont(font) {
+ if (font == null) {
+ return null;
+ }
+
+ if (typeof font === 'string') {
+ return parseFontString(font);
+ }
+
+ var fontFamily = extractSingleFontFamily(font.fontFamily);
+ var fontSize = +font.fontSize || 12;
+ var fontWeight = font.fontWeight != null ? font.fontWeight.toString() : '400';
+ return {
+ fontFamily: fontFamily,
+ fontSize: fontSize,
+ fontWeight: fontWeight,
+ fontStyle: font.fontStyle
+ };
+ }
+
+ var newLine = /\n/g;
+
+ function extractFontAndLines(font, text) {
+ return {
+ font: extractFont(font),
+ lines: text.split(newLine)
+ };
+ }
+
+ function extractAlignment(alignment) {
+ switch (alignment) {
+ case 'right':
+ return 1;
+
+ case 'center':
+ return 2;
+
+ default:
+ return 0;
+ }
+ }
+
+ var Text = function (_React$Component5) {
+ _inherits(Text, _React$Component5);
+
+ function Text() {
+ _classCallCheck(this, Text);
+
+ return _possibleConstructorReturn(this, _getPrototypeOf(Text).apply(this, arguments));
+ }
+
+ _createClass(Text, [{
+ key: "render",
+ value: function render() {
+ var props = this.props;
+ var path = props.path;
+ var textPath = path ? (path instanceof Path ? path : new Path(path)).toJSON() : null;
+ var textFrame = extractFontAndLines(props.font, childrenAsString(props.children));
+ return React.createElement(NativeText, {
+ fill: extractBrush(props.fill, props),
+ opacity: extractOpacity(props),
+ stroke: extractColor(props.stroke),
+ strokeCap: extractStrokeCap(props.strokeCap),
+ strokeDash: props.strokeDash || null,
+ strokeJoin: extractStrokeJoin(props.strokeJoin),
+ strokeWidth: extractNumber(props.strokeWidth, 1),
+ transform: extractTransform(props),
+ alignment: extractAlignment(props.alignment),
+ frame: textFrame,
+ path: textPath,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 522
+ }
+ });
+ }
+ }]);
+
+ return Text;
+ }(React.Component);
+
+ function LinearGradient(stops, x1, y1, x2, y2) {
+ var type = LINEAR_GRADIENT;
+
+ if (arguments.length < 5) {
+ var angle = (x1 == null ? 270 : x1) * Math.PI / 180;
+ var x = Math.cos(angle);
+ var y = -Math.sin(angle);
+ var l = (Math.abs(x) + Math.abs(y)) / 2;
+ x *= l;
+ y *= l;
+ x1 = 0.5 - x;
+ x2 = 0.5 + x;
+ y1 = 0.5 - y;
+ y2 = 0.5 + y;
+ this._bb = true;
+ } else {
+ this._bb = false;
+ }
+
+ var brushData = [type, +x1, +y1, +x2, +y2];
+ insertColorStopsIntoArray(stops, brushData, 5);
+ this._brush = brushData;
+ }
+
+ function RadialGradient(stops, fx, fy, rx, ry, cx, cy) {
+ if (ry == null) {
+ ry = rx;
+ }
+
+ if (cx == null) {
+ cx = fx;
+ }
+
+ if (cy == null) {
+ cy = fy;
+ }
+
+ if (fx == null) {
+ fx = fy = rx = ry = cx = cy = 0.5;
+ this._bb = true;
+ } else {
+ this._bb = false;
+ }
+
+ var brushData = [RADIAL_GRADIENT, +fx, +fy, +rx * 2, +ry * 2, +cx, +cy];
+ insertDoubleColorStopsIntoArray(stops, brushData, 7);
+ this._brush = brushData;
+ }
+
+ function Pattern(url, width, height, left, top) {
+ this._brush = [PATTERN, url, +left || 0, +top || 0, +width, +height];
+ }
+
+ var ReactART = {
+ LinearGradient: LinearGradient,
+ RadialGradient: RadialGradient,
+ Pattern: Pattern,
+ Transform: Transform,
+ Path: Path,
+ Surface: Surface,
+ Group: Group,
+ ClippingRectangle: ClippingRectangle,
+ Shape: Shape,
+ Text: Text
+ };
+ module.exports = ReactART;
+},197,[3,4,5,8,9,198,199,202,52,62,203,185,204,19],"node_modules\\react-native\\Libraries\\ART\\ReactNativeART.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var colors = {
+ maroon: '#800000',
+ red: '#ff0000',
+ orange: '#ffA500',
+ yellow: '#ffff00',
+ olive: '#808000',
+ purple: '#800080',
+ fuchsia: "#ff00ff",
+ white: '#ffffff',
+ lime: '#00ff00',
+ green: '#008000',
+ navy: '#000080',
+ blue: '#0000ff',
+ aqua: '#00ffff',
+ teal: '#008080',
+ black: '#000000',
+ silver: '#c0c0c0',
+ gray: '#808080'
+ };
+
+ var map = function map(array, fn) {
+ var results = [];
+
+ for (var i = 0, l = array.length; i < l; i++) {
+ results[i] = fn(array[i], i);
+ }
+
+ return results;
+ };
+
+ var Color = function Color(color, type) {
+ if (color.isColor) {
+ this.red = color.red;
+ this.green = color.green;
+ this.blue = color.blue;
+ this.alpha = color.alpha;
+ } else {
+ var namedColor = colors[color];
+
+ if (namedColor) {
+ color = namedColor;
+ type = 'hex';
+ }
+
+ switch (typeof color) {
+ case 'string':
+ if (!type) type = (type = color.match(/^rgb|^hsb|^hsl/)) ? type[0] : 'hex';
+ break;
+
+ case 'object':
+ type = type || 'rgb';
+ color = color.toString();
+ break;
+
+ case 'number':
+ type = 'hex';
+ color = color.toString(16);
+ break;
+ }
+
+ color = Color['parse' + type.toUpperCase()](color);
+ this.red = color[0];
+ this.green = color[1];
+ this.blue = color[2];
+ this.alpha = color[3];
+ }
+
+ this.isColor = true;
+ };
+
+ var limit = function limit(number, min, max) {
+ return Math.min(max, Math.max(min, number));
+ };
+
+ var listMatch = /([-.\d]+\%?)\s*,\s*([-.\d]+\%?)\s*,\s*([-.\d]+\%?)\s*,?\s*([-.\d]*\%?)/;
+ var hexMatch = /^#?([a-f0-9]{1,2})([a-f0-9]{1,2})([a-f0-9]{1,2})([a-f0-9]{0,2})$/i;
+
+ Color.parseRGB = function (color) {
+ return map(color.match(listMatch).slice(1), function (bit, i) {
+ if (bit) bit = parseFloat(bit) * (bit[bit.length - 1] == '%' ? 2.55 : 1);
+ return i < 3 ? Math.round((bit %= 256) < 0 ? bit + 256 : bit) : limit(bit === '' ? 1 : Number(bit), 0, 1);
+ });
+ };
+
+ Color.parseHEX = function (color) {
+ if (color.length == 1) color = color + color + color;
+ return map(color.match(hexMatch).slice(1), function (bit, i) {
+ if (i == 3) return bit ? parseInt(bit, 16) / 255 : 1;
+ return parseInt(bit.length == 1 ? bit + bit : bit, 16);
+ });
+ };
+
+ Color.parseHSB = function (color) {
+ var hsb = map(color.match(listMatch).slice(1), function (bit, i) {
+ if (bit) bit = parseFloat(bit);
+ if (i === 0) return Math.round((bit %= 360) < 0 ? bit + 360 : bit);else if (i < 3) return limit(Math.round(bit), 0, 100);else return limit(bit === '' ? 1 : Number(bit), 0, 1);
+ });
+ var a = hsb[3];
+ var br = Math.round(hsb[2] / 100 * 255);
+ if (hsb[1] == 0) return [br, br, br, a];
+ var hue = hsb[0];
+ var f = hue % 60;
+ var p = Math.round(hsb[2] * (100 - hsb[1]) / 10000 * 255);
+ var q = Math.round(hsb[2] * (6000 - hsb[1] * f) / 600000 * 255);
+ var t = Math.round(hsb[2] * (6000 - hsb[1] * (60 - f)) / 600000 * 255);
+
+ switch (Math.floor(hue / 60)) {
+ case 0:
+ return [br, t, p, a];
+
+ case 1:
+ return [q, br, p, a];
+
+ case 2:
+ return [p, br, t, a];
+
+ case 3:
+ return [p, q, br, a];
+
+ case 4:
+ return [t, p, br, a];
+
+ default:
+ return [br, p, q, a];
+ }
+ };
+
+ Color.parseHSL = function (color) {
+ var hsb = map(color.match(listMatch).slice(1), function (bit, i) {
+ if (bit) bit = parseFloat(bit);
+ if (i === 0) return Math.round((bit %= 360) < 0 ? bit + 360 : bit);else if (i < 3) return limit(Math.round(bit), 0, 100);else return limit(bit === '' ? 1 : Number(bit), 0, 1);
+ });
+ var h = hsb[0] / 60;
+ var s = hsb[1] / 100;
+ var l = hsb[2] / 100;
+ var a = hsb[3];
+ var c = (1 - Math.abs(2 * l - 1)) * s;
+ var x = c * (1 - Math.abs(h % 2 - 1));
+ var m = l - c / 2;
+ var p = Math.round((c + m) * 255);
+ var q = Math.round((x + m) * 255);
+ var t = Math.round(m * 255);
+
+ switch (Math.floor(h)) {
+ case 0:
+ return [p, q, t, a];
+
+ case 1:
+ return [q, p, t, a];
+
+ case 2:
+ return [t, p, q, a];
+
+ case 3:
+ return [t, q, p, a];
+
+ case 4:
+ return [q, t, p, a];
+
+ default:
+ return [p, t, q, a];
+ }
+ };
+
+ var toString = function toString(type, array) {
+ if (array[3] != 1) type += 'a';else array.pop();
+ return type + '(' + array.join(', ') + ')';
+ };
+
+ Color.prototype = {
+ toHSB: function toHSB(array) {
+ var red = this.red,
+ green = this.green,
+ blue = this.blue,
+ alpha = this.alpha;
+ var max = Math.max(red, green, blue),
+ min = Math.min(red, green, blue),
+ delta = max - min;
+ var hue = 0,
+ saturation = delta != 0 ? delta / max : 0,
+ brightness = max / 255;
+
+ if (saturation) {
+ var rr = (max - red) / delta,
+ gr = (max - green) / delta,
+ br = (max - blue) / delta;
+ hue = red == max ? br - gr : green == max ? 2 + rr - br : 4 + gr - rr;
+ if ((hue /= 6) < 0) hue++;
+ }
+
+ var hsb = [Math.round(hue * 360), Math.round(saturation * 100), Math.round(brightness * 100), alpha];
+ return array ? hsb : toString('hsb', hsb);
+ },
+ toHSL: function toHSL(array) {
+ var red = this.red,
+ green = this.green,
+ blue = this.blue,
+ alpha = this.alpha;
+ var max = Math.max(red, green, blue),
+ min = Math.min(red, green, blue),
+ delta = max - min;
+ var hue = 0,
+ saturation = delta != 0 ? delta / (255 - Math.abs(max + min - 255)) : 0,
+ lightness = (max + min) / 512;
+
+ if (saturation) {
+ var rr = (max - red) / delta,
+ gr = (max - green) / delta,
+ br = (max - blue) / delta;
+ hue = red == max ? br - gr : green == max ? 2 + rr - br : 4 + gr - rr;
+ if ((hue /= 6) < 0) hue++;
+ }
+
+ var hsl = [Math.round(hue * 360), Math.round(saturation * 100), Math.round(lightness * 100), alpha];
+ return array ? hsl : toString('hsl', hsl);
+ },
+ toHEX: function toHEX(array) {
+ var a = this.alpha;
+ var alpha = (a = Math.round(a * 255).toString(16)).length == 1 ? a + a : a;
+ var hex = map([this.red, this.green, this.blue], function (bit) {
+ bit = bit.toString(16);
+ return bit.length == 1 ? '0' + bit : bit;
+ });
+ return array ? hex.concat(alpha) : '#' + hex.join('') + (alpha == 'ff' ? '' : alpha);
+ },
+ toRGB: function toRGB(array) {
+ var rgb = [this.red, this.green, this.blue, this.alpha];
+ return array ? rgb : toString('rgb', rgb);
+ }
+ };
+ Color.prototype.toString = Color.prototype.toRGB;
+
+ Color.hex = function (hex) {
+ return new Color(hex, 'hex');
+ };
+
+ if (this.hex == null) this.hex = Color.hex;
+
+ Color.hsb = function (h, s, b, a) {
+ return new Color([h || 0, s || 0, b || 0, a == null ? 1 : a], 'hsb');
+ };
+
+ if (this.hsb == null) this.hsb = Color.hsb;
+
+ Color.hsl = function (h, s, l, a) {
+ return new Color([h || 0, s || 0, l || 0, a == null ? 1 : a], 'hsl');
+ };
+
+ if (this.hsl == null) this.hsl = Color.hsl;
+
+ Color.rgb = function (r, g, b, a) {
+ return new Color([r || 0, g || 0, b || 0, a == null ? 1 : a], 'rgb');
+ };
+
+ if (this.rgb == null) this.rgb = Color.rgb;
+
+ Color.detach = function (color) {
+ color = new Color(color);
+ return [Color.rgb(color.red, color.green, color.blue).toString(), color.alpha];
+ };
+
+ module.exports = Color;
+},198,[],"node_modules\\art\\core\\color.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var Class = _$$_REQUIRE(_dependencyMap[0], "art/core/class.js");
+
+ var Path = _$$_REQUIRE(_dependencyMap[1], "art/core/path.js");
+
+ var MOVE_TO = 0;
+ var CLOSE = 1;
+ var LINE_TO = 2;
+ var CURVE_TO = 3;
+ var ARC = 4;
+ var SerializablePath = Class(Path, {
+ initialize: function initialize(path) {
+ this.reset();
+
+ if (path instanceof SerializablePath) {
+ this.path = path.path.slice(0);
+ } else if (path) {
+ if (path.applyToPath) {
+ path.applyToPath(this);
+ } else {
+ this.push(path);
+ }
+ }
+ },
+ onReset: function onReset() {
+ this.path = [];
+ },
+ onMove: function onMove(sx, sy, x, y) {
+ this.path.push(MOVE_TO, x, y);
+ },
+ onLine: function onLine(sx, sy, x, y) {
+ this.path.push(LINE_TO, x, y);
+ },
+ onBezierCurve: function onBezierCurve(sx, sy, p1x, p1y, p2x, p2y, x, y) {
+ this.path.push(CURVE_TO, p1x, p1y, p2x, p2y, x, y);
+ },
+ _arcToBezier: Path.prototype.onArc,
+ onArc: function onArc(sx, sy, ex, ey, cx, cy, rx, ry, sa, ea, ccw, rotation) {
+ if (rx !== ry || rotation) {
+ return this._arcToBezier(sx, sy, ex, ey, cx, cy, rx, ry, sa, ea, ccw, rotation);
+ }
+
+ this.path.push(ARC, cx, cy, rx, sa, ea, ccw ? 0 : 1);
+ },
+ onClose: function onClose() {
+ this.path.push(CLOSE);
+ },
+ toJSON: function toJSON() {
+ return this.path;
+ }
+ });
+ module.exports = SerializablePath;
+},199,[200,201],"node_modules\\react-native\\Libraries\\ART\\ARTSerializablePath.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ module.exports = function (mixins) {
+ var proto = {};
+
+ for (var i = 0, l = arguments.length; i < l; i++) {
+ var mixin = arguments[i];
+ if (typeof mixin == 'function') mixin = mixin.prototype;
+
+ for (var key in mixin) {
+ proto[key] = mixin[key];
+ }
+ }
+
+ if (!proto.initialize) proto.initialize = function () {};
+
+ proto.constructor = function (a, b, c, d, e, f, g, h) {
+ return new proto.initialize(a, b, c, d, e, f, g, h);
+ };
+
+ proto.constructor.prototype = proto.initialize.prototype = proto;
+ return proto.constructor;
+ };
+},200,[],"node_modules\\art\\core\\class.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var Class = _$$_REQUIRE(_dependencyMap[0], "./class");
+
+ module.exports = Class({
+ initialize: function initialize(path) {
+ this.reset().push(path);
+ },
+ push: function push() {
+ var p = Array.prototype.join.call(arguments, ' ').match(/[a-df-z]|[\-+]?(?:[\d\.]e[\-+]?|[^\s\-+,a-z])+/ig);
+ if (!p) return this;
+ var last,
+ cmd = p[0],
+ i = 1;
+
+ while (cmd) {
+ switch (cmd) {
+ case 'm':
+ this.move(p[i++], p[i++]);
+ break;
+
+ case 'l':
+ this.line(p[i++], p[i++]);
+ break;
+
+ case 'c':
+ this.curve(p[i++], p[i++], p[i++], p[i++], p[i++], p[i++]);
+ break;
+
+ case 's':
+ this.curve(p[i++], p[i++], null, null, p[i++], p[i++]);
+ break;
+
+ case 'q':
+ this.curve(p[i++], p[i++], p[i++], p[i++]);
+ break;
+
+ case 't':
+ this.curve(p[i++], p[i++]);
+ break;
+
+ case 'a':
+ this.arc(p[i + 5], p[i + 6], p[i], p[i + 1], p[i + 3], !+p[i + 4], p[i + 2]);
+ i += 7;
+ break;
+
+ case 'h':
+ this.line(p[i++], 0);
+ break;
+
+ case 'v':
+ this.line(0, p[i++]);
+ break;
+
+ case 'M':
+ this.moveTo(p[i++], p[i++]);
+ break;
+
+ case 'L':
+ this.lineTo(p[i++], p[i++]);
+ break;
+
+ case 'C':
+ this.curveTo(p[i++], p[i++], p[i++], p[i++], p[i++], p[i++]);
+ break;
+
+ case 'S':
+ this.curveTo(p[i++], p[i++], null, null, p[i++], p[i++]);
+ break;
+
+ case 'Q':
+ this.curveTo(p[i++], p[i++], p[i++], p[i++]);
+ break;
+
+ case 'T':
+ this.curveTo(p[i++], p[i++]);
+ break;
+
+ case 'A':
+ this.arcTo(p[i + 5], p[i + 6], p[i], p[i + 1], p[i + 3], !+p[i + 4], p[i + 2]);
+ i += 7;
+ break;
+
+ case 'H':
+ this.lineTo(p[i++], this.penY);
+ break;
+
+ case 'V':
+ this.lineTo(this.penX, p[i++]);
+ break;
+
+ case 'Z':
+ case 'z':
+ this.close();
+ break;
+
+ default:
+ cmd = last;
+ i--;
+ continue;
+ }
+
+ last = cmd;
+ if (last == 'm') last = 'l';else if (last == 'M') last = 'L';
+ cmd = p[i++];
+ }
+
+ return this;
+ },
+ reset: function reset() {
+ this.penX = this.penY = 0;
+ this.penDownX = this.penDownY = null;
+ this._pivotX = this._pivotY = 0;
+ this.onReset();
+ return this;
+ },
+ move: function move(x, y) {
+ this.onMove(this.penX, this.penY, this._pivotX = this.penX += +x, this._pivotY = this.penY += +y);
+ return this;
+ },
+ moveTo: function moveTo(x, y) {
+ this.onMove(this.penX, this.penY, this._pivotX = this.penX = +x, this._pivotY = this.penY = +y);
+ return this;
+ },
+ line: function line(x, y) {
+ return this.lineTo(this.penX + +x, this.penY + +y);
+ },
+ lineTo: function lineTo(x, y) {
+ if (this.penDownX == null) {
+ this.penDownX = this.penX;
+ this.penDownY = this.penY;
+ }
+
+ this.onLine(this.penX, this.penY, this._pivotX = this.penX = +x, this._pivotY = this.penY = +y);
+ return this;
+ },
+ curve: function curve(c1x, c1y, c2x, c2y, ex, ey) {
+ var x = this.penX,
+ y = this.penY;
+ return this.curveTo(x + +c1x, y + +c1y, c2x == null ? null : x + +c2x, c2y == null ? null : y + +c2y, ex == null ? null : x + +ex, ey == null ? null : y + +ey);
+ },
+ curveTo: function curveTo(c1x, c1y, c2x, c2y, ex, ey) {
+ var x = this.penX,
+ y = this.penY;
+
+ if (c2x == null) {
+ c2x = +c1x;
+ c2y = +c1y;
+ c1x = x * 2 - (this._pivotX || 0);
+ c1y = y * 2 - (this._pivotY || 0);
+ }
+
+ if (ex == null) {
+ this._pivotX = +c1x;
+ this._pivotY = +c1y;
+ ex = +c2x;
+ ey = +c2y;
+ c2x = (ex + +c1x * 2) / 3;
+ c2y = (ey + +c1y * 2) / 3;
+ c1x = (x + +c1x * 2) / 3;
+ c1y = (y + +c1y * 2) / 3;
+ } else {
+ this._pivotX = +c2x;
+ this._pivotY = +c2y;
+ }
+
+ if (this.penDownX == null) {
+ this.penDownX = x;
+ this.penDownY = y;
+ }
+
+ this.onBezierCurve(x, y, +c1x, +c1y, +c2x, +c2y, this.penX = +ex, this.penY = +ey);
+ return this;
+ },
+ arc: function arc(x, y, rx, ry, outer, counterClockwise, rotation) {
+ return this.arcTo(this.penX + +x, this.penY + +y, rx, ry, outer, counterClockwise, rotation);
+ },
+ arcTo: function arcTo(x, y, rx, ry, outer, counterClockwise, rotation) {
+ ry = Math.abs(+ry || +rx || +y - this.penY);
+ rx = Math.abs(+rx || +x - this.penX);
+ if (!rx || !ry || x == this.penX && y == this.penY) return this.lineTo(x, y);
+ var tX = this.penX,
+ tY = this.penY,
+ clockwise = !+counterClockwise,
+ large = !!+outer;
+ var rad = rotation ? rotation * Math.PI / 180 : 0,
+ cos = Math.cos(rad),
+ sin = Math.sin(rad);
+ x -= tX;
+ y -= tY;
+ var cx = cos * x / 2 + sin * y / 2,
+ cy = -sin * x / 2 + cos * y / 2,
+ rxry = rx * rx * ry * ry,
+ rycx = ry * ry * cx * cx,
+ rxcy = rx * rx * cy * cy,
+ a = rxry - rxcy - rycx;
+
+ if (a < 0) {
+ a = Math.sqrt(1 - a / rxry);
+ rx *= a;
+ ry *= a;
+ cx = x / 2;
+ cy = y / 2;
+ } else {
+ a = Math.sqrt(a / (rxcy + rycx));
+ if (large == clockwise) a = -a;
+ var cxd = -a * cy * rx / ry,
+ cyd = a * cx * ry / rx;
+ cx = cos * cxd - sin * cyd + x / 2;
+ cy = sin * cxd + cos * cyd + y / 2;
+ }
+
+ var xx = cos / rx,
+ yx = sin / rx,
+ xy = -sin / ry,
+ yy = cos / ry;
+ var sa = Math.atan2(xy * -cx + yy * -cy, xx * -cx + yx * -cy),
+ ea = Math.atan2(xy * (x - cx) + yy * (y - cy), xx * (x - cx) + yx * (y - cy));
+ cx += tX;
+ cy += tY;
+ x += tX;
+ y += tY;
+
+ if (this.penDownX == null) {
+ this.penDownX = this.penX;
+ this.penDownY = this.penY;
+ }
+
+ this.onArc(tX, tY, this._pivotX = this.penX = x, this._pivotY = this.penY = y, cx, cy, rx, ry, sa, ea, !clockwise, rotation);
+ return this;
+ },
+ counterArc: function counterArc(x, y, rx, ry, outer) {
+ return this.arc(x, y, rx, ry, outer, true);
+ },
+ counterArcTo: function counterArcTo(x, y, rx, ry, outer) {
+ return this.arcTo(x, y, rx, ry, outer, true);
+ },
+ close: function close() {
+ if (this.penDownX != null) {
+ this.onClose(this.penX, this.penY, this.penX = this.penDownX, this.penY = this.penDownY);
+ this.penDownX = null;
+ }
+
+ return this;
+ },
+ onReset: function onReset() {},
+ onMove: function onMove(sx, sy, ex, ey) {},
+ onLine: function onLine(sx, sy, ex, ey) {
+ this.onBezierCurve(sx, sy, sx, sy, ex, ey, ex, ey);
+ },
+ onBezierCurve: function onBezierCurve(sx, sy, c1x, c1y, c2x, c2y, ex, ey) {
+ var gx = ex - sx,
+ gy = ey - sy,
+ g = gx * gx + gy * gy,
+ v1,
+ v2,
+ cx,
+ cy,
+ u;
+ cx = c1x - sx;
+ cy = c1y - sy;
+ u = cx * gx + cy * gy;
+
+ if (u > g) {
+ cx -= gx;
+ cy -= gy;
+ } else if (u > 0 && g != 0) {
+ cx -= u / g * gx;
+ cy -= u / g * gy;
+ }
+
+ v1 = cx * cx + cy * cy;
+ cx = c2x - sx;
+ cy = c2y - sy;
+ u = cx * gx + cy * gy;
+
+ if (u > g) {
+ cx -= gx;
+ cy -= gy;
+ } else if (u > 0 && g != 0) {
+ cx -= u / g * gx;
+ cy -= u / g * gy;
+ }
+
+ v2 = cx * cx + cy * cy;
+
+ if (v1 < 0.01 && v2 < 0.01) {
+ this.onLine(sx, sy, ex, ey);
+ return;
+ }
+
+ if (isNaN(v1) || isNaN(v2)) {
+ throw new Error('Bad input');
+ }
+
+ var s1x = (c1x + c2x) * 0.5,
+ s1y = (c1y + c2y) * 0.5,
+ l1x = (c1x + sx) * 0.5,
+ l1y = (c1y + sy) * 0.5,
+ l2x = (l1x + s1x) * 0.5,
+ l2y = (l1y + s1y) * 0.5,
+ r2x = (ex + c2x) * 0.5,
+ r2y = (ey + c2y) * 0.5,
+ r1x = (r2x + s1x) * 0.5,
+ r1y = (r2y + s1y) * 0.5,
+ l2r1x = (l2x + r1x) * 0.5,
+ l2r1y = (l2y + r1y) * 0.5;
+ this.onBezierCurve(sx, sy, l1x, l1y, l2x, l2y, l2r1x, l2r1y);
+ this.onBezierCurve(l2r1x, l2r1y, r1x, r1y, r2x, r2y, ex, ey);
+ },
+ onArc: function onArc(sx, sy, ex, ey, cx, cy, rx, ry, sa, ea, ccw, rotation) {
+ var rad = rotation ? rotation * Math.PI / 180 : 0,
+ cos = Math.cos(rad),
+ sin = Math.sin(rad),
+ xx = cos * rx,
+ yx = -sin * ry,
+ xy = sin * rx,
+ yy = cos * ry;
+ var arc = ea - sa;
+ if (arc < 0 && !ccw) arc += Math.PI * 2;else if (arc > 0 && ccw) arc -= Math.PI * 2;
+ var n = Math.ceil(Math.abs(arc / (Math.PI / 2))),
+ step = arc / n,
+ k = 4 / 3 * Math.tan(step / 4);
+ var x = Math.cos(sa),
+ y = Math.sin(sa);
+
+ for (var i = 0; i < n; i++) {
+ var cp1x = x - k * y,
+ cp1y = y + k * x;
+ sa += step;
+ x = Math.cos(sa);
+ y = Math.sin(sa);
+ var cp2x = x + k * y,
+ cp2y = y - k * x;
+ this.onBezierCurve(sx, sy, cx + xx * cp1x + yx * cp1y, cy + xy * cp1x + yy * cp1y, cx + xx * cp2x + yx * cp2y, cy + xy * cp2x + yy * cp2y, sx = cx + xx * x + yx * y, sy = cy + xy * x + yy * y);
+ }
+ },
+ onClose: function onClose(sx, sy, ex, ey) {
+ this.onLine(sx, sy, ex, ey);
+ }
+ });
+},201,[200],"node_modules\\art\\core\\path.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var Class = _$$_REQUIRE(_dependencyMap[0], "./class");
+
+ function Transform(xx, yx, xy, yy, x, y) {
+ if (xx && typeof xx == 'object') {
+ yx = xx.yx;
+ yy = xx.yy;
+ y = xx.y;
+ xy = xx.xy;
+ x = xx.x;
+ xx = xx.xx;
+ }
+
+ this.xx = xx == null ? 1 : xx;
+ this.yx = yx || 0;
+ this.xy = xy || 0;
+ this.yy = yy == null ? 1 : yy;
+ this.x = (x == null ? this.x : x) || 0;
+ this.y = (y == null ? this.y : y) || 0;
+
+ this._transform();
+
+ return this;
+ }
+
+ ;
+ module.exports = Class({
+ initialize: Transform,
+ _transform: function _transform() {},
+ xx: 1,
+ yx: 0,
+ x: 0,
+ xy: 0,
+ yy: 1,
+ y: 0,
+ transform: function transform(xx, yx, xy, yy, x, y) {
+ var m = this;
+
+ if (xx && typeof xx == 'object') {
+ yx = xx.yx;
+ yy = xx.yy;
+ y = xx.y;
+ xy = xx.xy;
+ x = xx.x;
+ xx = xx.xx;
+ }
+
+ if (!x) x = 0;
+ if (!y) y = 0;
+ return this.transformTo(m.xx * xx + m.xy * yx, m.yx * xx + m.yy * yx, m.xx * xy + m.xy * yy, m.yx * xy + m.yy * yy, m.xx * x + m.xy * y + m.x, m.yx * x + m.yy * y + m.y);
+ },
+ transformTo: Transform,
+ translate: function translate(x, y) {
+ return this.transform(1, 0, 0, 1, x, y);
+ },
+ move: function move(x, y) {
+ this.x += x || 0;
+ this.y += y || 0;
+
+ this._transform();
+
+ return this;
+ },
+ scale: function scale(x, y) {
+ if (y == null) y = x;
+ return this.transform(x, 0, 0, y, 0, 0);
+ },
+ rotate: function rotate(deg, x, y) {
+ if (x == null || y == null) {
+ x = (this.left || 0) + (this.width || 0) / 2;
+ y = (this.top || 0) + (this.height || 0) / 2;
+ }
+
+ var rad = deg * Math.PI / 180,
+ sin = Math.sin(rad),
+ cos = Math.cos(rad);
+ this.transform(1, 0, 0, 1, x, y);
+ var m = this;
+ return this.transformTo(cos * m.xx - sin * m.yx, sin * m.xx + cos * m.yx, cos * m.xy - sin * m.yy, sin * m.xy + cos * m.yy, m.x, m.y).transform(1, 0, 0, 1, -x, -y);
+ },
+ moveTo: function moveTo(x, y) {
+ var m = this;
+ return this.transformTo(m.xx, m.yx, m.xy, m.yy, x, y);
+ },
+ rotateTo: function rotateTo(deg, x, y) {
+ var m = this;
+ var flip = m.yx / m.xx > m.yy / m.xy ? -1 : 1;
+ if (m.xx < 0 ? m.xy >= 0 : m.xy < 0) flip = -flip;
+ return this.rotate(deg - Math.atan2(flip * m.yx, flip * m.xx) * 180 / Math.PI, x, y);
+ },
+ scaleTo: function scaleTo(x, y) {
+ var m = this;
+ var h = Math.sqrt(m.xx * m.xx + m.yx * m.yx);
+ m.xx /= h;
+ m.yx /= h;
+ h = Math.sqrt(m.yy * m.yy + m.xy * m.xy);
+ m.yy /= h;
+ m.xy /= h;
+ return this.scale(x, y);
+ },
+ resizeTo: function resizeTo(width, height) {
+ var w = this.width,
+ h = this.height;
+ if (!w || !h) return this;
+ return this.scaleTo(width / w, height / h);
+ },
+ inversePoint: function inversePoint(x, y) {
+ var a = this.xx,
+ b = this.yx,
+ c = this.xy,
+ d = this.yy,
+ e = this.x,
+ f = this.y;
+ var det = b * c - a * d;
+ if (det == 0) return null;
+ return {
+ x: (d * (e - x) + c * (y - f)) / det,
+ y: (a * (f - y) + b * (x - e)) / det
+ };
+ },
+ point: function point(x, y) {
+ var m = this;
+ return {
+ x: m.xx * x + m.xy * y + m.x,
+ y: m.yx * x + m.yy * y + m.y
+ };
+ }
+ });
+},202,[200],"node_modules\\art\\core\\transform.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var ReactNativeStyleAttributes = _$$_REQUIRE(_dependencyMap[1], "ReactNativeStyleAttributes");
+
+ var ReactNativeViewAttributes = {};
+ ReactNativeViewAttributes.UIView = {
+ pointerEvents: true,
+ accessible: true,
+ accessibilityActions: true,
+ accessibilityLabel: true,
+ accessibilityHint: true,
+ accessibilityComponentType: true,
+ accessibilityLiveRegion: true,
+ accessibilityRole: true,
+ accessibilityStates: true,
+ accessibilityTraits: true,
+ acceptsKeyboardFocus: true,
+ enableFocusRing: true,
+ importantForAccessibility: true,
+ nativeID: true,
+ testID: true,
+ tabIndex: true,
+ renderToHardwareTextureAndroid: true,
+ shouldRasterizeIOS: true,
+ onLayout: true,
+ onAccessibilityAction: true,
+ onAccessibilityTap: true,
+ onMagicTap: true,
+ onAccessibilityEscape: true,
+ collapsable: true,
+ needsOffscreenAlphaCompositing: true,
+ onMouseEnter: true,
+ onMouseLeave: true,
+ onDragEnter: true,
+ onDragLeave: true,
+ onDrop: true,
+ draggedTypes: true,
+ style: ReactNativeStyleAttributes
+ };
+ ReactNativeViewAttributes.RCTView = _objectSpread({}, ReactNativeViewAttributes.UIView, {
+ removeClippedSubviews: true
+ });
+ module.exports = ReactNativeViewAttributes;
+},203,[32,57],"node_modules\\react-native\\Libraries\\Components\\View\\ReactNativeViewAttributes.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ "use strict";
+
+ var mergeInto = _$$_REQUIRE(_dependencyMap[0], "mergeInto");
+
+ var merge = function merge(one, two) {
+ var result = {};
+ mergeInto(result, one);
+ mergeInto(result, two);
+ return result;
+ };
+
+ module.exports = merge;
+},204,[205],"node_modules\\react-native\\Libraries\\vendor\\core\\merge.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ "use strict";
+
+ var mergeHelpers = _$$_REQUIRE(_dependencyMap[0], "mergeHelpers");
+
+ var checkMergeObjectArg = mergeHelpers.checkMergeObjectArg;
+ var checkMergeIntoObjectArg = mergeHelpers.checkMergeIntoObjectArg;
+
+ function mergeInto(one, two) {
+ checkMergeIntoObjectArg(one);
+
+ if (two != null) {
+ checkMergeObjectArg(two);
+
+ for (var key in two) {
+ if (!Object.prototype.hasOwnProperty.call(two, key)) {
+ continue;
+ }
+
+ one[key] = two[key];
+ }
+ }
+ }
+
+ module.exports = mergeInto;
+},205,[206],"node_modules\\react-native\\Libraries\\vendor\\core\\mergeInto.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var invariant = _$$_REQUIRE(_dependencyMap[0], "invariant");
+
+ var MAX_MERGE_DEPTH = 36;
+
+ var isTerminal = function isTerminal(o) {
+ return typeof o !== 'object' || o instanceof Date || o === null;
+ };
+
+ var mergeHelpers = {
+ MAX_MERGE_DEPTH: MAX_MERGE_DEPTH,
+ isTerminal: isTerminal,
+ normalizeMergeArg: function normalizeMergeArg(arg) {
+ return arg === undefined || arg === null ? {} : arg;
+ },
+ checkMergeArrayArgs: function checkMergeArrayArgs(one, two) {
+ invariant(Array.isArray(one) && Array.isArray(two), 'Tried to merge arrays, instead got %s and %s.', one, two);
+ },
+ checkMergeObjectArgs: function checkMergeObjectArgs(one, two) {
+ mergeHelpers.checkMergeObjectArg(one);
+ mergeHelpers.checkMergeObjectArg(two);
+ },
+ checkMergeObjectArg: function checkMergeObjectArg(arg) {
+ invariant(!isTerminal(arg) && !Array.isArray(arg), 'Tried to merge an object, instead got %s.', arg);
+ },
+ checkMergeIntoObjectArg: function checkMergeIntoObjectArg(arg) {
+ invariant((!isTerminal(arg) || typeof arg === 'function') && !Array.isArray(arg), 'Tried to merge into an object, instead got %s.', arg);
+ },
+ checkMergeLevel: function checkMergeLevel(level) {
+ invariant(level < MAX_MERGE_DEPTH, 'Maximum deep merge depth exceeded. You may be attempting to merge ' + 'circular structures in an unsupported way.');
+ },
+ checkArrayStrategy: function checkArrayStrategy(strategy) {
+ invariant(strategy === undefined || strategy in mergeHelpers.ArrayStrategies, 'You must provide an array strategy to deep merge functions to ' + 'instruct the deep merge how to resolve merging two arrays.');
+ },
+ ArrayStrategies: {
+ Clobber: 'Clobber',
+ Concat: 'Concat',
+ IndexByIndex: 'IndexByIndex'
+ }
+ };
+ module.exports = mergeHelpers;
+},206,[19],"node_modules\\react-native\\Libraries\\vendor\\core\\mergeHelpers.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Components\\Button.js";
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var Platform = _$$_REQUIRE(_dependencyMap[6], "Platform");
+
+ var React = _$$_REQUIRE(_dependencyMap[7], "React");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[8], "StyleSheet");
+
+ var Text = _$$_REQUIRE(_dependencyMap[9], "Text");
+
+ var TouchableHighlight = _$$_REQUIRE(_dependencyMap[10], "TouchableHighlight");
+
+ var TouchableNativeFeedback = _$$_REQUIRE(_dependencyMap[11], "TouchableNativeFeedback");
+
+ var TouchableOpacity = _$$_REQUIRE(_dependencyMap[12], "TouchableOpacity");
+
+ var View = _$$_REQUIRE(_dependencyMap[13], "View");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[14], "invariant");
+
+ var Button = function (_React$Component) {
+ _inherits(Button, _React$Component);
+
+ function Button() {
+ _classCallCheck(this, Button);
+
+ return _possibleConstructorReturn(this, _getPrototypeOf(Button).apply(this, arguments));
+ }
+
+ _createClass(Button, [{
+ key: "render",
+ value: function render() {
+ var _this$props = this.props,
+ accessibilityLabel = _this$props.accessibilityLabel,
+ accessibilityHint = _this$props.accessibilityHint,
+ 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' || Platform.OS === 'macos') {
+ textStyles.push({
+ color: color
+ });
+ } else {
+ buttonStyles.push({
+ backgroundColor: color
+ });
+ }
+ }
+
+ var accessibilityStates = [];
+
+ if (disabled) {
+ buttonStyles.push(styles.buttonDisabled);
+ textStyles.push(styles.textDisabled);
+ accessibilityStates.push('disabled');
+ }
+
+ invariant(typeof title === 'string', 'The title prop of a Button must be a string');
+ var formattedTitle = Platform.OS === 'android' ? title.toUpperCase() : title;
+ var Touchable = Platform.OS === 'android' ? TouchableNativeFeedback : Platform.OS === 'uwp' || Platform.OS === 'windesktop' ? TouchableHighlight : TouchableOpacity;
+ return React.createElement(Touchable, {
+ accessibilityLabel: accessibilityLabel,
+ accessibilityHint: accessibilityHint,
+ accessibilityRole: "button",
+ accessibilityStates: accessibilityStates,
+ hasTVPreferredFocus: hasTVPreferredFocus,
+ testID: testID,
+ disabled: disabled,
+ onPress: onPress,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 137
+ }
+ }, React.createElement(View, {
+ style: buttonStyles,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 146
+ }
+ }, React.createElement(Text, {
+ style: textStyles,
+ disabled: disabled,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 147
+ }
+ }, formattedTitle)));
+ }
+ }]);
+
+ return Button;
+ }(React.Component);
+
+ var styles = StyleSheet.create({
+ button: Platform.select({
+ ios: {},
+ android: {
+ elevation: 4,
+ backgroundColor: '#2196F3',
+ borderRadius: 2
+ },
+ macos: {},
+ uwp: {
+ backgroundColor: '#2196F3',
+ borderRadius: 2
+ },
+ windesktop: {}
+ }),
+ text: _objectSpread({
+ textAlign: 'center',
+ padding: 8
+ }, Platform.select({
+ ios: {
+ color: '#007AFF',
+ fontSize: 18
+ },
+ android: {
+ color: 'white',
+ fontWeight: '500'
+ },
+ macos: {
+ color: '#007AFF',
+ fontSize: 18
+ },
+ uwp: {
+ color: 'white',
+ fontWeight: '500'
+ },
+ windesktop: {}
+ })),
+ buttonDisabled: Platform.select({
+ ios: {},
+ android: {
+ elevation: 0,
+ backgroundColor: '#dfdfdf'
+ },
+ macos: {},
+ uwp: {
+ backgroundColor: '#dfdfdf'
+ },
+ windesktop: {}
+ }),
+ textDisabled: Platform.select({
+ ios: {
+ color: '#cdcdcd'
+ },
+ macos: {
+ color: '#cdcdcd'
+ },
+ android: {
+ color: '#a1a1a1'
+ },
+ uwp: {
+ color: '#a1a1a1'
+ },
+ windesktop: {
+ color: '#a1a1a1'
+ }
+ })
+ });
+ module.exports = Button;
+},207,[32,3,4,5,8,9,35,52,53,208,221,235,236,81,19],"node_modules\\react-native\\Libraries\\Components\\Button.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _assertThisInitialized = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/assertThisInitialized");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits");
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/defineProperty");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Text\\Text.js";
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var DeprecatedTextPropTypes = _$$_REQUIRE(_dependencyMap[8], "DeprecatedTextPropTypes");
+
+ var React = _$$_REQUIRE(_dependencyMap[9], "React");
+
+ var ReactNativeViewAttributes = _$$_REQUIRE(_dependencyMap[10], "ReactNativeViewAttributes");
+
+ var TextAncestor = _$$_REQUIRE(_dependencyMap[11], "TextAncestor");
+
+ var Touchable = _$$_REQUIRE(_dependencyMap[12], "Touchable");
+
+ var UIManager = _$$_REQUIRE(_dependencyMap[13], "UIManager");
+
+ var createReactNativeComponentClass = _$$_REQUIRE(_dependencyMap[14], "createReactNativeComponentClass");
+
+ var nullthrows = _$$_REQUIRE(_dependencyMap[15], "nullthrows");
+
+ var processColor = _$$_REQUIRE(_dependencyMap[16], "processColor");
+
+ var PRESS_RECT_OFFSET = {
+ top: 20,
+ left: 20,
+ right: 20,
+ bottom: 30
+ };
+ var viewConfig = {
+ validAttributes: _objectSpread({}, ReactNativeViewAttributes.UIView, {
+ isHighlighted: true,
+ numberOfLines: true,
+ ellipsizeMode: true,
+ allowFontScaling: true,
+ maxFontSizeMultiplier: true,
+ disabled: true,
+ selectable: true,
+ selectionColor: true,
+ adjustsFontSizeToFit: true,
+ minimumFontScale: true,
+ textBreakStrategy: true,
+ onTextLayout: true
+ }),
+ directEventTypes: {
+ topTextLayout: {
+ registrationName: 'onTextLayout'
+ }
+ },
+ uiViewClassName: 'RCTText'
+ };
+
+ var TouchableText = function (_React$Component) {
+ _inherits(TouchableText, _React$Component);
+
+ function TouchableText() {
+ var _getPrototypeOf2;
+
+ var _this;
+
+ _classCallCheck(this, TouchableText);
+
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(TouchableText)).call.apply(_getPrototypeOf2, [this].concat(args)));
+ _this.state = _objectSpread({}, Touchable.Mixin.touchableGetInitialState(), {
+ isHighlighted: false,
+ createResponderHandlers: _this._createResponseHandlers.bind(_assertThisInitialized(_this)),
+ responseHandlers: null
+ });
+ return _this;
+ }
+
+ _createClass(TouchableText, [{
+ key: "render",
+ value: function render() {
+ var props = this.props;
+
+ if (isTouchable(props)) {
+ props = _objectSpread({}, props, {}, this.state.responseHandlers, {
+ isHighlighted: this.state.isHighlighted
+ });
+ }
+
+ if (props.selectionColor != null) {
+ props = _objectSpread({}, props, {
+ selectionColor: processColor(props.selectionColor)
+ });
+ }
+
+ if (__DEV__) {
+ if (Touchable.TOUCH_TARGET_DEBUG && props.onPress != null) {
+ props = _objectSpread({}, props, {
+ style: [props.style, {
+ color: 'magenta'
+ }]
+ });
+ }
+ }
+
+ return React.createElement(TextAncestor.Consumer, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 148
+ }
+ }, function (hasTextAncestor) {
+ return hasTextAncestor ? React.createElement(RCTVirtualText, _extends({}, props, {
+ ref: props.forwardedRef,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 151
+ }
+ })) : React.createElement(TextAncestor.Provider, {
+ value: true,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 153
+ }
+ }, React.createElement(RCTText, _extends({}, props, {
+ ref: props.forwardedRef,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 154
+ }
+ })));
+ });
+ }
+ }, {
+ key: "_createResponseHandlers",
+ value: function _createResponseHandlers() {
+ var _this2 = this;
+
+ return {
+ onStartShouldSetResponder: function onStartShouldSetResponder() {
+ var onStartShouldSetResponder = _this2.props.onStartShouldSetResponder;
+ var shouldSetResponder = (onStartShouldSetResponder == null ? false : onStartShouldSetResponder()) || isTouchable(_this2.props);
+
+ if (shouldSetResponder) {
+ _this2._attachTouchHandlers();
+ }
+
+ return shouldSetResponder;
+ },
+ onResponderGrant: function onResponderGrant(event, dispatchID) {
+ nullthrows(_this2.touchableHandleResponderGrant)(event, dispatchID);
+
+ if (_this2.props.onResponderGrant != null) {
+ _this2.props.onResponderGrant.call(_this2, event, dispatchID);
+ }
+ },
+ onResponderMove: function onResponderMove(event) {
+ nullthrows(_this2.touchableHandleResponderMove)(event);
+
+ if (_this2.props.onResponderMove != null) {
+ _this2.props.onResponderMove.call(_this2, event);
+ }
+ },
+ onResponderRelease: function onResponderRelease(event) {
+ nullthrows(_this2.touchableHandleResponderRelease)(event);
+
+ if (_this2.props.onResponderRelease != null) {
+ _this2.props.onResponderRelease.call(_this2, event);
+ }
+ },
+ onResponderTerminate: function onResponderTerminate(event) {
+ nullthrows(_this2.touchableHandleResponderTerminate)(event);
+
+ if (_this2.props.onResponderTerminate != null) {
+ _this2.props.onResponderTerminate.call(_this2, event);
+ }
+ },
+ onResponderTerminationRequest: function onResponderTerminationRequest() {
+ var onResponderTerminationRequest = _this2.props.onResponderTerminationRequest;
+
+ if (!nullthrows(_this2.touchableHandleResponderTerminationRequest)()) {
+ return false;
+ }
+
+ if (onResponderTerminationRequest == null) {
+ return true;
+ }
+
+ return onResponderTerminationRequest();
+ }
+ };
+ }
+ }, {
+ key: "_attachTouchHandlers",
+ value: function _attachTouchHandlers() {
+ var _this3 = this;
+
+ if (this.touchableGetPressRectOffset != null) {
+ return;
+ }
+
+ for (var key in Touchable.Mixin) {
+ if (typeof Touchable.Mixin[key] === 'function') {
+ this[key] = Touchable.Mixin[key].bind(this);
+ }
+ }
+
+ this.touchableHandleActivePressIn = function () {
+ if (!_this3.props.suppressHighlighting && isTouchable(_this3.props)) {
+ _this3.setState({
+ isHighlighted: true
+ });
+ }
+ };
+
+ this.touchableHandleActivePressOut = function () {
+ if (!_this3.props.suppressHighlighting && isTouchable(_this3.props)) {
+ _this3.setState({
+ isHighlighted: false
+ });
+ }
+ };
+
+ this.touchableHandlePress = function (event) {
+ if (_this3.props.onPress != null) {
+ _this3.props.onPress(event);
+ }
+ };
+
+ this.touchableHandleLongPress = function (event) {
+ if (_this3.props.onLongPress != null) {
+ _this3.props.onLongPress(event);
+ }
+ };
+
+ this.touchableGetPressRectOffset = function () {
+ return _this3.props.pressRetentionOffset == null ? PRESS_RECT_OFFSET : _this3.props.pressRetentionOffset;
+ };
+ }
+ }], [{
+ key: "getDerivedStateFromProps",
+ value: function getDerivedStateFromProps(nextProps, prevState) {
+ return prevState.responseHandlers == null && isTouchable(nextProps) ? {
+ responseHandlers: prevState.createResponderHandlers()
+ } : null;
+ }
+ }]);
+
+ return TouchableText;
+ }(React.Component);
+
+ TouchableText.defaultProps = {
+ accessible: true,
+ allowFontScaling: true,
+ ellipsizeMode: 'tail'
+ };
+ TouchableText.viewConfig = viewConfig;
+
+ var isTouchable = function isTouchable(props) {
+ return props.onPress != null || props.onLongPress != null || props.onStartShouldSetResponder != null;
+ };
+
+ var RCTText = createReactNativeComponentClass(viewConfig.uiViewClassName, function () {
+ return viewConfig;
+ });
+ var RCTVirtualText = UIManager.getViewManagerConfig('RCTVirtualText') == null ? RCTText : createReactNativeComponentClass('RCTVirtualText', function () {
+ return {
+ validAttributes: _objectSpread({}, ReactNativeViewAttributes.UIView, {
+ isHighlighted: true,
+ maxFontSizeMultiplier: true
+ }),
+ uiViewClassName: 'RCTVirtualText'
+ };
+ });
+
+ var Text = function Text(props, forwardedRef) {
+ return React.createElement(TouchableText, _extends({}, props, {
+ forwardedRef: forwardedRef,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 278
+ }
+ }));
+ };
+
+ var TextToExport = React.forwardRef(Text);
+ TextToExport.displayName = 'Text';
+ TextToExport.propTypes = DeprecatedTextPropTypes;
+ module.exports = TextToExport;
+},208,[14,3,4,5,8,7,9,32,209,52,203,82,213,71,185,220,75],"node_modules\\react-native\\Libraries\\Text\\Text.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var DeprecatedColorPropType = _$$_REQUIRE(_dependencyMap[0], "DeprecatedColorPropType");
+
+ var DeprecatedEdgeInsetsPropType = _$$_REQUIRE(_dependencyMap[1], "DeprecatedEdgeInsetsPropType");
+
+ var DeprecatedStyleSheetPropType = _$$_REQUIRE(_dependencyMap[2], "DeprecatedStyleSheetPropType");
+
+ var PropTypes = _$$_REQUIRE(_dependencyMap[3], "prop-types");
+
+ var TextStylePropTypes = _$$_REQUIRE(_dependencyMap[4], "TextStylePropTypes");
+
+ var stylePropType = DeprecatedStyleSheetPropType(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: DeprecatedEdgeInsetsPropType,
+ selectable: PropTypes.bool,
+ selectionColor: DeprecatedColorPropType,
+ suppressHighlighting: PropTypes.bool,
+ style: stylePropType,
+ testID: PropTypes.string,
+ nativeID: PropTypes.string,
+ allowFontScaling: PropTypes.bool,
+ maxFontSizeMultiplier: PropTypes.number,
+ accessible: PropTypes.bool,
+ adjustsFontSizeToFit: PropTypes.bool,
+ minimumFontScale: PropTypes.number,
+ disabled: PropTypes.bool
+ };
+},209,[59,210,211,62,73],"node_modules\\react-native\\Libraries\\DeprecatedPropTypes\\DeprecatedTextPropTypes.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var PropTypes = _$$_REQUIRE(_dependencyMap[0], "prop-types");
+
+ var DeprecatedEdgeInsetsPropType = PropTypes.shape({
+ top: PropTypes.number,
+ left: PropTypes.number,
+ bottom: PropTypes.number,
+ right: PropTypes.number
+ });
+ module.exports = DeprecatedEdgeInsetsPropType;
+},210,[62],"node_modules\\react-native\\Libraries\\DeprecatedPropTypes\\DeprecatedEdgeInsetsPropType.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var deprecatedCreateStrictShapeTypeChecker = _$$_REQUIRE(_dependencyMap[0], "deprecatedCreateStrictShapeTypeChecker");
+
+ var flattenStyle = _$$_REQUIRE(_dependencyMap[1], "flattenStyle");
+
+ function DeprecatedStyleSheetPropType(shape) {
+ var shapePropType = deprecatedCreateStrictShapeTypeChecker(shape);
+ return function (props, propName, componentName, location) {
+ var newProps = props;
+
+ if (props[propName]) {
+ newProps = {};
+ newProps[propName] = flattenStyle(props[propName]);
+ }
+
+ for (var _len = arguments.length, rest = new Array(_len > 4 ? _len - 4 : 0), _key = 4; _key < _len; _key++) {
+ rest[_key - 4] = arguments[_key];
+ }
+
+ return shapePropType.apply(void 0, [newProps, propName, componentName, location].concat(rest));
+ };
+ }
+
+ module.exports = DeprecatedStyleSheetPropType;
+},211,[212,80],"node_modules\\react-native\\Libraries\\DeprecatedPropTypes\\DeprecatedStyleSheetPropType.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var invariant = _$$_REQUIRE(_dependencyMap[0], "invariant");
+
+ var merge = _$$_REQUIRE(_dependencyMap[1], "merge");
+
+ function deprecatedCreateStrictShapeTypeChecker(shapeTypes) {
+ function checkType(isRequired, props, propName, componentName, location) {
+ if (!props[propName]) {
+ if (isRequired) {
+ invariant(false, "Required object `" + propName + "` was not specified in " + ("`" + componentName + "`."));
+ }
+
+ return;
+ }
+
+ var propValue = props[propName];
+ var propType = typeof propValue;
+ var locationName = location || '(unknown)';
+
+ if (propType !== 'object') {
+ invariant(false, "Invalid " + locationName + " `" + propName + "` of type `" + propType + "` " + ("supplied to `" + componentName + "`, expected `object`."));
+ }
+
+ var allKeys = merge(props[propName], shapeTypes);
+
+ for (var _len = arguments.length, rest = new Array(_len > 5 ? _len - 5 : 0), _key = 5; _key < _len; _key++) {
+ rest[_key - 5] = arguments[_key];
+ }
+
+ for (var _key2 in allKeys) {
+ var checker = shapeTypes[_key2];
+
+ if (!checker) {
+ invariant(false, "Invalid props." + propName + " key `" + _key2 + "` supplied to `" + componentName + "`." + '\nBad object: ' + JSON.stringify(props[propName], null, ' ') + '\nValid keys: ' + JSON.stringify(Object.keys(shapeTypes), null, ' '));
+ }
+
+ var error = checker.apply(void 0, [propValue, _key2, componentName, location].concat(rest));
+
+ if (error) {
+ invariant(false, error.message + '\nBad object: ' + JSON.stringify(props[propName], null, ' '));
+ }
+ }
+ }
+
+ function chainedCheckType(props, propName, componentName, location) {
+ for (var _len2 = arguments.length, rest = new Array(_len2 > 4 ? _len2 - 4 : 0), _key3 = 4; _key3 < _len2; _key3++) {
+ rest[_key3 - 4] = arguments[_key3];
+ }
+
+ return checkType.apply(void 0, [false, props, propName, componentName, location].concat(rest));
+ }
+
+ chainedCheckType.isRequired = checkType.bind(null, true);
+ return chainedCheckType;
+ }
+
+ module.exports = deprecatedCreateStrictShapeTypeChecker;
+},212,[19,204],"node_modules\\react-native\\Libraries\\DeprecatedPropTypes\\deprecatedCreateStrictShapeTypeChecker.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _objectWithoutProperties = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/objectWithoutProperties");
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/defineProperty");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Components\\Touchable\\Touchable.js";
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var BoundingDimensions = _$$_REQUIRE(_dependencyMap[2], "BoundingDimensions");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[3], "Platform");
+
+ var Position = _$$_REQUIRE(_dependencyMap[4], "Position");
+
+ var React = _$$_REQUIRE(_dependencyMap[5], "React");
+
+ var ReactNative = _$$_REQUIRE(_dependencyMap[6], "ReactNative");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[7], "StyleSheet");
+
+ var TVEventHandler = _$$_REQUIRE(_dependencyMap[8], "TVEventHandler");
+
+ var UIManager = _$$_REQUIRE(_dependencyMap[9], "UIManager");
+
+ var View = _$$_REQUIRE(_dependencyMap[10], "View");
+
+ var keyMirror = _$$_REQUIRE(_dependencyMap[11], "fbjs/lib/keyMirror");
+
+ var normalizeColor = _$$_REQUIRE(_dependencyMap[12], "normalizeColor");
+
+ var extractSingleTouch = function extractSingleTouch(nativeEvent) {
+ var touches = nativeEvent.touches;
+ var changedTouches = nativeEvent.changedTouches;
+ var hasTouches = touches && touches.length > 0;
+ var hasChangedTouches = changedTouches && changedTouches.length > 0;
+ return !hasTouches && hasChangedTouches ? changedTouches[0] : hasTouches ? touches[0] : nativeEvent;
+ };
+
+ var States = keyMirror({
+ NOT_RESPONDER: null,
+ RESPONDER_INACTIVE_PRESS_IN: null,
+ RESPONDER_INACTIVE_PRESS_OUT: null,
+ RESPONDER_ACTIVE_PRESS_IN: null,
+ RESPONDER_ACTIVE_PRESS_OUT: null,
+ RESPONDER_ACTIVE_LONG_PRESS_IN: null,
+ RESPONDER_ACTIVE_LONG_PRESS_OUT: null,
+ ERROR: null
+ });
+ var baseStatesConditions = {
+ NOT_RESPONDER: false,
+ RESPONDER_INACTIVE_PRESS_IN: false,
+ RESPONDER_INACTIVE_PRESS_OUT: false,
+ RESPONDER_ACTIVE_PRESS_IN: false,
+ RESPONDER_ACTIVE_PRESS_OUT: false,
+ RESPONDER_ACTIVE_LONG_PRESS_IN: false,
+ RESPONDER_ACTIVE_LONG_PRESS_OUT: false,
+ ERROR: false
+ };
+
+ var IsActive = _objectSpread({}, baseStatesConditions, {
+ RESPONDER_ACTIVE_PRESS_OUT: true,
+ RESPONDER_ACTIVE_PRESS_IN: true
+ });
+
+ var IsPressingIn = _objectSpread({}, baseStatesConditions, {
+ RESPONDER_INACTIVE_PRESS_IN: true,
+ RESPONDER_ACTIVE_PRESS_IN: true,
+ RESPONDER_ACTIVE_LONG_PRESS_IN: true
+ });
+
+ var IsLongPressingIn = _objectSpread({}, baseStatesConditions, {
+ RESPONDER_ACTIVE_LONG_PRESS_IN: true
+ });
+
+ var Signals = keyMirror({
+ DELAY: null,
+ RESPONDER_GRANT: null,
+ RESPONDER_RELEASE: null,
+ RESPONDER_TERMINATED: null,
+ ENTER_PRESS_RECT: null,
+ LEAVE_PRESS_RECT: null,
+ LONG_PRESS_DETECTED: null
+ });
+ var Transitions = {
+ NOT_RESPONDER: {
+ DELAY: States.ERROR,
+ RESPONDER_GRANT: States.RESPONDER_INACTIVE_PRESS_IN,
+ RESPONDER_RELEASE: States.ERROR,
+ RESPONDER_TERMINATED: States.ERROR,
+ ENTER_PRESS_RECT: States.ERROR,
+ LEAVE_PRESS_RECT: States.ERROR,
+ LONG_PRESS_DETECTED: States.ERROR
+ },
+ RESPONDER_INACTIVE_PRESS_IN: {
+ DELAY: States.RESPONDER_ACTIVE_PRESS_IN,
+ RESPONDER_GRANT: States.ERROR,
+ RESPONDER_RELEASE: States.NOT_RESPONDER,
+ RESPONDER_TERMINATED: States.NOT_RESPONDER,
+ ENTER_PRESS_RECT: States.RESPONDER_INACTIVE_PRESS_IN,
+ LEAVE_PRESS_RECT: States.RESPONDER_INACTIVE_PRESS_OUT,
+ LONG_PRESS_DETECTED: States.ERROR
+ },
+ RESPONDER_INACTIVE_PRESS_OUT: {
+ DELAY: States.RESPONDER_ACTIVE_PRESS_OUT,
+ RESPONDER_GRANT: States.ERROR,
+ RESPONDER_RELEASE: States.NOT_RESPONDER,
+ RESPONDER_TERMINATED: States.NOT_RESPONDER,
+ ENTER_PRESS_RECT: States.RESPONDER_INACTIVE_PRESS_IN,
+ LEAVE_PRESS_RECT: States.RESPONDER_INACTIVE_PRESS_OUT,
+ LONG_PRESS_DETECTED: States.ERROR
+ },
+ RESPONDER_ACTIVE_PRESS_IN: {
+ DELAY: States.ERROR,
+ RESPONDER_GRANT: States.ERROR,
+ RESPONDER_RELEASE: States.NOT_RESPONDER,
+ RESPONDER_TERMINATED: States.NOT_RESPONDER,
+ ENTER_PRESS_RECT: States.RESPONDER_ACTIVE_PRESS_IN,
+ LEAVE_PRESS_RECT: States.RESPONDER_ACTIVE_PRESS_OUT,
+ LONG_PRESS_DETECTED: States.RESPONDER_ACTIVE_LONG_PRESS_IN
+ },
+ RESPONDER_ACTIVE_PRESS_OUT: {
+ DELAY: States.ERROR,
+ RESPONDER_GRANT: States.ERROR,
+ RESPONDER_RELEASE: States.NOT_RESPONDER,
+ RESPONDER_TERMINATED: States.NOT_RESPONDER,
+ ENTER_PRESS_RECT: States.RESPONDER_ACTIVE_PRESS_IN,
+ LEAVE_PRESS_RECT: States.RESPONDER_ACTIVE_PRESS_OUT,
+ LONG_PRESS_DETECTED: States.ERROR
+ },
+ RESPONDER_ACTIVE_LONG_PRESS_IN: {
+ DELAY: States.ERROR,
+ RESPONDER_GRANT: States.ERROR,
+ RESPONDER_RELEASE: States.NOT_RESPONDER,
+ RESPONDER_TERMINATED: States.NOT_RESPONDER,
+ ENTER_PRESS_RECT: States.RESPONDER_ACTIVE_LONG_PRESS_IN,
+ LEAVE_PRESS_RECT: States.RESPONDER_ACTIVE_LONG_PRESS_OUT,
+ LONG_PRESS_DETECTED: States.RESPONDER_ACTIVE_LONG_PRESS_IN
+ },
+ RESPONDER_ACTIVE_LONG_PRESS_OUT: {
+ DELAY: States.ERROR,
+ RESPONDER_GRANT: States.ERROR,
+ RESPONDER_RELEASE: States.NOT_RESPONDER,
+ RESPONDER_TERMINATED: States.NOT_RESPONDER,
+ ENTER_PRESS_RECT: States.RESPONDER_ACTIVE_LONG_PRESS_IN,
+ LEAVE_PRESS_RECT: States.RESPONDER_ACTIVE_LONG_PRESS_OUT,
+ LONG_PRESS_DETECTED: States.ERROR
+ },
+ error: {
+ DELAY: States.NOT_RESPONDER,
+ RESPONDER_GRANT: States.RESPONDER_INACTIVE_PRESS_IN,
+ RESPONDER_RELEASE: States.NOT_RESPONDER,
+ RESPONDER_TERMINATED: States.NOT_RESPONDER,
+ ENTER_PRESS_RECT: States.NOT_RESPONDER,
+ LEAVE_PRESS_RECT: States.NOT_RESPONDER,
+ LONG_PRESS_DETECTED: States.NOT_RESPONDER
+ }
+ };
+ var HIGHLIGHT_DELAY_MS = 130;
+ var PRESS_EXPAND_PX = 20;
+ var LONG_PRESS_THRESHOLD = 500;
+ var LONG_PRESS_DELAY_MS = LONG_PRESS_THRESHOLD - HIGHLIGHT_DELAY_MS;
+ var LONG_PRESS_ALLOWED_MOVEMENT = 10;
+ var TouchableMixin = {
+ componentDidMount: function componentDidMount() {
+ if (!Platform.isTV) {
+ return;
+ }
+
+ this._tvEventHandler = new TVEventHandler();
+
+ this._tvEventHandler.enable(this, function (cmp, evt) {
+ var myTag = ReactNative.findNodeHandle(cmp);
+ evt.dispatchConfig = {};
+
+ if (myTag === evt.tag) {
+ if (evt.eventType === 'focus') {
+ cmp.touchableHandleFocus(evt);
+ } else if (evt.eventType === 'blur') {
+ cmp.touchableHandleBlur(evt);
+ } else if (evt.eventType === 'select') {
+ cmp.touchableHandlePress && !cmp.props.disabled && cmp.touchableHandlePress(evt);
+ }
+ }
+ });
+ },
+ componentWillUnmount: function componentWillUnmount() {
+ if (this._tvEventHandler) {
+ this._tvEventHandler.disable();
+
+ delete this._tvEventHandler;
+ }
+
+ this.touchableDelayTimeout && clearTimeout(this.touchableDelayTimeout);
+ this.longPressDelayTimeout && clearTimeout(this.longPressDelayTimeout);
+ this.pressOutDelayTimeout && clearTimeout(this.pressOutDelayTimeout);
+ },
+ touchableGetInitialState: function touchableGetInitialState() {
+ return {
+ touchable: {
+ touchState: undefined,
+ responderID: null
+ }
+ };
+ },
+ touchableHandleResponderTerminationRequest: function touchableHandleResponderTerminationRequest() {
+ return !this.props.rejectResponderTermination;
+ },
+ touchableHandleStartShouldSetResponder: function touchableHandleStartShouldSetResponder() {
+ return !this.props.disabled;
+ },
+ touchableLongPressCancelsPress: function touchableLongPressCancelsPress() {
+ return true;
+ },
+ touchableHandleResponderGrant: function touchableHandleResponderGrant(e) {
+ var dispatchID = e.currentTarget;
+ e.persist();
+ this.pressOutDelayTimeout && clearTimeout(this.pressOutDelayTimeout);
+ this.pressOutDelayTimeout = null;
+ this.state.touchable.touchState = States.NOT_RESPONDER;
+ this.state.touchable.responderID = dispatchID;
+
+ this._receiveSignal(Signals.RESPONDER_GRANT, e);
+
+ var delayMS = this.touchableGetHighlightDelayMS !== undefined ? Math.max(this.touchableGetHighlightDelayMS(), 0) : HIGHLIGHT_DELAY_MS;
+ delayMS = isNaN(delayMS) ? HIGHLIGHT_DELAY_MS : delayMS;
+
+ if (delayMS !== 0) {
+ this.touchableDelayTimeout = setTimeout(this._handleDelay.bind(this, e), delayMS);
+ } else {
+ this._handleDelay(e);
+ }
+
+ var longDelayMS = this.touchableGetLongPressDelayMS !== undefined ? Math.max(this.touchableGetLongPressDelayMS(), 10) : LONG_PRESS_DELAY_MS;
+ longDelayMS = isNaN(longDelayMS) ? LONG_PRESS_DELAY_MS : longDelayMS;
+ this.longPressDelayTimeout = setTimeout(this._handleLongDelay.bind(this, e), longDelayMS + delayMS);
+ },
+ touchableHandleResponderRelease: function touchableHandleResponderRelease(e) {
+ this._receiveSignal(Signals.RESPONDER_RELEASE, e);
+ },
+ touchableHandleResponderTerminate: function touchableHandleResponderTerminate(e) {
+ this._receiveSignal(Signals.RESPONDER_TERMINATED, e);
+ },
+ touchableHandleResponderMove: function touchableHandleResponderMove(e) {
+ if (!this.state.touchable.positionOnActivate) {
+ return;
+ }
+
+ var positionOnActivate = this.state.touchable.positionOnActivate;
+ var dimensionsOnActivate = this.state.touchable.dimensionsOnActivate;
+ var pressRectOffset = this.touchableGetPressRectOffset ? this.touchableGetPressRectOffset() : {
+ left: PRESS_EXPAND_PX,
+ right: PRESS_EXPAND_PX,
+ top: PRESS_EXPAND_PX,
+ bottom: PRESS_EXPAND_PX
+ };
+ var pressExpandLeft = pressRectOffset.left;
+ var pressExpandTop = pressRectOffset.top;
+ var pressExpandRight = pressRectOffset.right;
+ var pressExpandBottom = pressRectOffset.bottom;
+ var hitSlop = this.touchableGetHitSlop ? this.touchableGetHitSlop() : null;
+
+ if (hitSlop) {
+ pressExpandLeft += hitSlop.left || 0;
+ pressExpandTop += hitSlop.top || 0;
+ pressExpandRight += hitSlop.right || 0;
+ pressExpandBottom += hitSlop.bottom || 0;
+ }
+
+ var touch = extractSingleTouch(e.nativeEvent);
+ var pageX = touch && touch.pageX;
+ var pageY = touch && touch.pageY;
+
+ if (this.pressInLocation) {
+ var movedDistance = this._getDistanceBetweenPoints(pageX, pageY, this.pressInLocation.pageX, this.pressInLocation.pageY);
+
+ if (movedDistance > LONG_PRESS_ALLOWED_MOVEMENT) {
+ this._cancelLongPressDelayTimeout();
+ }
+ }
+
+ var isTouchWithinActive = pageX > positionOnActivate.left - pressExpandLeft && pageY > positionOnActivate.top - pressExpandTop && pageX < positionOnActivate.left + dimensionsOnActivate.width + pressExpandRight && pageY < positionOnActivate.top + dimensionsOnActivate.height + pressExpandBottom;
+
+ if (isTouchWithinActive) {
+ 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);
+ }
+ },
+ touchableHandleFocus: function touchableHandleFocus(e) {
+ this.props.onFocus && this.props.onFocus(e);
+ },
+ touchableHandleBlur: function touchableHandleBlur(e) {
+ this.props.onBlur && this.props.onBlur(e);
+ },
+ _remeasureMetricsOnActivation: function _remeasureMetricsOnActivation() {
+ var tag = this.state.touchable.responderID;
+
+ if (tag == null) {
+ return;
+ }
+
+ UIManager.measure(tag, this._handleQueryLayout);
+ },
+ _handleQueryLayout: function _handleQueryLayout(l, t, w, h, globalX, globalY) {
+ if (!l && !t && !w && !h && !globalX && !globalY) {
+ return;
+ }
+
+ this.state.touchable.positionOnActivate && Position.release(this.state.touchable.positionOnActivate);
+ this.state.touchable.dimensionsOnActivate && BoundingDimensions.release(this.state.touchable.dimensionsOnActivate);
+ this.state.touchable.positionOnActivate = Position.getPooled(globalX, globalY);
+ this.state.touchable.dimensionsOnActivate = BoundingDimensions.getPooled(w, h);
+ },
+ _handleDelay: function _handleDelay(e) {
+ this.touchableDelayTimeout = null;
+
+ this._receiveSignal(Signals.DELAY, e);
+ },
+ _handleLongDelay: function _handleLongDelay(e) {
+ this.longPressDelayTimeout = null;
+ var curState = this.state.touchable.touchState;
+
+ if (curState !== States.RESPONDER_ACTIVE_PRESS_IN && curState !== States.RESPONDER_ACTIVE_LONG_PRESS_IN) {
+ console.error('Attempted to transition from state `' + curState + '` to `' + States.RESPONDER_ACTIVE_LONG_PRESS_IN + '`, which is not supported. This is ' + 'most likely due to `Touchable.longPressDelayTimeout` not being cancelled.');
+ } else {
+ this._receiveSignal(Signals.LONG_PRESS_DETECTED, e);
+ }
+ },
+ _receiveSignal: function _receiveSignal(signal, e) {
+ var responderID = this.state.touchable.responderID;
+ var curState = this.state.touchable.touchState;
+ var nextState = Transitions[curState] && Transitions[curState][signal];
+
+ if (!responderID && signal === Signals.RESPONDER_RELEASE) {
+ return;
+ }
+
+ if (!nextState) {
+ throw new Error('Unrecognized signal `' + signal + '` or state `' + curState + '` for Touchable responder `' + responderID + '`');
+ }
+
+ if (nextState === States.ERROR) {
+ throw new Error('Touchable cannot transition from `' + curState + '` to `' + signal + '` for responder `' + responderID + '`');
+ }
+
+ if (curState !== nextState) {
+ this._performSideEffectsForTransition(curState, nextState, signal, e);
+
+ this.state.touchable.touchState = nextState;
+ }
+ },
+ _cancelLongPressDelayTimeout: function _cancelLongPressDelayTimeout() {
+ this.longPressDelayTimeout && clearTimeout(this.longPressDelayTimeout);
+ this.longPressDelayTimeout = null;
+ },
+ _isHighlight: function _isHighlight(state) {
+ return state === States.RESPONDER_ACTIVE_PRESS_IN || state === States.RESPONDER_ACTIVE_LONG_PRESS_IN;
+ },
+ _savePressInLocation: function _savePressInLocation(e) {
+ var touch = extractSingleTouch(e.nativeEvent);
+ var pageX = touch && touch.pageX;
+ var pageY = touch && touch.pageY;
+ var locationX = touch && touch.locationX;
+ var locationY = touch && touch.locationY;
+ this.pressInLocation = {
+ pageX: pageX,
+ pageY: pageY,
+ locationX: locationX,
+ locationY: locationY
+ };
+ },
+ _getDistanceBetweenPoints: function _getDistanceBetweenPoints(aX, aY, bX, bY) {
+ var deltaX = aX - bX;
+ var deltaY = aY - bY;
+ return Math.sqrt(deltaX * deltaX + deltaY * deltaY);
+ },
+ _performSideEffectsForTransition: function _performSideEffectsForTransition(curState, nextState, signal, e) {
+ var curIsHighlight = this._isHighlight(curState);
+
+ var newIsHighlight = this._isHighlight(nextState);
+
+ var isFinalSignal = signal === Signals.RESPONDER_TERMINATED || signal === Signals.RESPONDER_RELEASE;
+
+ if (isFinalSignal) {
+ this._cancelLongPressDelayTimeout();
+ }
+
+ var isInitialTransition = curState === States.NOT_RESPONDER && nextState === States.RESPONDER_INACTIVE_PRESS_IN;
+ var isActiveTransition = !IsActive[curState] && IsActive[nextState];
+
+ if (isInitialTransition || isActiveTransition) {
+ this._remeasureMetricsOnActivation();
+ }
+
+ if (IsPressingIn[curState] && signal === Signals.LONG_PRESS_DETECTED) {
+ this.touchableHandleLongPress && this.touchableHandleLongPress(e);
+ }
+
+ if (newIsHighlight && !curIsHighlight) {
+ this._startHighlight(e);
+ } else if (!newIsHighlight && curIsHighlight) {
+ this._endHighlight(e);
+ }
+
+ if (IsPressingIn[curState] && signal === Signals.RESPONDER_RELEASE) {
+ var hasLongPressHandler = !!this.props.onLongPress;
+ var pressIsLongButStillCallOnPress = IsLongPressingIn[curState] && (!hasLongPressHandler || !this.touchableLongPressCancelsPress());
+ var shouldInvokePress = !IsLongPressingIn[curState] || pressIsLongButStillCallOnPress;
+
+ if (shouldInvokePress && this.touchableHandlePress) {
+ if (!newIsHighlight && !curIsHighlight) {
+ this._startHighlight(e);
+
+ this._endHighlight(e);
+ }
+
+ if (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);
+ }
+ }
+ },
+ withoutDefaultFocusAndBlur: {}
+ };
+
+ var touchableHandleFocus = TouchableMixin.touchableHandleFocus,
+ touchableHandleBlur = TouchableMixin.touchableHandleBlur,
+ TouchableMixinWithoutDefaultFocusAndBlur = _objectWithoutProperties(TouchableMixin, ["touchableHandleFocus", "touchableHandleBlur"]);
+
+ TouchableMixin.withoutDefaultFocusAndBlur = TouchableMixinWithoutDefaultFocusAndBlur;
+ var Touchable = {
+ Mixin: TouchableMixin,
+ TOUCH_TARGET_DEBUG: false,
+ renderDebugView: function renderDebugView(_ref) {
+ var color = _ref.color,
+ hitSlop = _ref.hitSlop;
+
+ if (!Touchable.TOUCH_TARGET_DEBUG) {
+ return null;
+ }
+
+ if (!__DEV__) {
+ throw Error('Touchable.TOUCH_TARGET_DEBUG should not be enabled in prod!');
+ }
+
+ var debugHitSlopStyle = {};
+ hitSlop = hitSlop || {
+ top: 0,
+ bottom: 0,
+ left: 0,
+ right: 0
+ };
+
+ for (var key in hitSlop) {
+ debugHitSlopStyle[key] = -hitSlop[key];
+ }
+
+ var normalizedColor = normalizeColor(color);
+
+ if (typeof normalizedColor !== 'number') {
+ return null;
+ }
+
+ var hexColor = '#' + ('00000000' + normalizedColor.toString(16)).substr(-8);
+ return React.createElement(View, {
+ pointerEvents: "none",
+ style: [styles.debug, _objectSpread({
+ borderColor: hexColor.slice(0, -2) + '55',
+ backgroundColor: hexColor.slice(0, -2) + '0F'
+ }, debugHitSlopStyle)],
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 953
+ }
+ });
+ }
+ };
+ var styles = StyleSheet.create({
+ debug: {
+ position: 'absolute',
+ borderWidth: 1,
+ borderStyle: 'dashed'
+ }
+ });
+ module.exports = Touchable;
+},213,[33,32,214,35,216,52,84,53,217,71,81,218,60],"node_modules\\react-native\\Libraries\\Components\\Touchable\\Touchable.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var PooledClass = _$$_REQUIRE(_dependencyMap[0], "PooledClass");
+
+ var twoArgumentPooler = PooledClass.twoArgumentPooler;
+
+ function BoundingDimensions(width, height) {
+ this.width = width;
+ this.height = height;
+ }
+
+ BoundingDimensions.prototype.destructor = function () {
+ this.width = null;
+ this.height = null;
+ };
+
+ BoundingDimensions.getPooledFromElement = function (element) {
+ return BoundingDimensions.getPooled(element.offsetWidth, element.offsetHeight);
+ };
+
+ PooledClass.addPoolingTo(BoundingDimensions, twoArgumentPooler);
+ module.exports = BoundingDimensions;
+},214,[215],"node_modules\\react-native\\Libraries\\Components\\Touchable\\BoundingDimensions.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var invariant = _$$_REQUIRE(_dependencyMap[0], "invariant");
+
+ var oneArgumentPooler = function oneArgumentPooler(copyFieldsFrom) {
+ var Klass = this;
+
+ if (Klass.instancePool.length) {
+ var _instance = Klass.instancePool.pop();
+
+ Klass.call(_instance, copyFieldsFrom);
+ return _instance;
+ } else {
+ return new Klass(copyFieldsFrom);
+ }
+ };
+
+ var twoArgumentPooler = function twoArgumentPooler(a1, a2) {
+ var Klass = this;
+
+ if (Klass.instancePool.length) {
+ var _instance2 = Klass.instancePool.pop();
+
+ Klass.call(_instance2, a1, a2);
+ return _instance2;
+ } else {
+ return new Klass(a1, a2);
+ }
+ };
+
+ var threeArgumentPooler = function threeArgumentPooler(a1, a2, a3) {
+ var Klass = this;
+
+ if (Klass.instancePool.length) {
+ var _instance3 = Klass.instancePool.pop();
+
+ Klass.call(_instance3, a1, a2, a3);
+ return _instance3;
+ } else {
+ return new Klass(a1, a2, a3);
+ }
+ };
+
+ var fourArgumentPooler = function fourArgumentPooler(a1, a2, a3, a4) {
+ var Klass = this;
+
+ if (Klass.instancePool.length) {
+ var _instance4 = Klass.instancePool.pop();
+
+ Klass.call(_instance4, a1, a2, a3, a4);
+ return _instance4;
+ } else {
+ return new Klass(a1, a2, a3, a4);
+ }
+ };
+
+ var standardReleaser = function standardReleaser(instance) {
+ var Klass = this;
+ invariant(instance instanceof Klass, 'Trying to release an instance into a pool of a different type.');
+ instance.destructor();
+
+ if (Klass.instancePool.length < Klass.poolSize) {
+ Klass.instancePool.push(instance);
+ }
+ };
+
+ var DEFAULT_POOL_SIZE = 10;
+ var DEFAULT_POOLER = oneArgumentPooler;
+
+ var addPoolingTo = function addPoolingTo(CopyConstructor, pooler) {
+ var NewKlass = CopyConstructor;
+ NewKlass.instancePool = [];
+ NewKlass.getPooled = pooler || DEFAULT_POOLER;
+
+ if (!NewKlass.poolSize) {
+ NewKlass.poolSize = DEFAULT_POOL_SIZE;
+ }
+
+ NewKlass.release = standardReleaser;
+ return NewKlass;
+ };
+
+ var PooledClass = {
+ addPoolingTo: addPoolingTo,
+ oneArgumentPooler: oneArgumentPooler,
+ twoArgumentPooler: twoArgumentPooler,
+ threeArgumentPooler: threeArgumentPooler,
+ fourArgumentPooler: fourArgumentPooler
+ };
+ module.exports = PooledClass;
+},215,[19],"node_modules\\react-native\\Libraries\\Components\\Touchable\\PooledClass.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var PooledClass = _$$_REQUIRE(_dependencyMap[0], "PooledClass");
+
+ var twoArgumentPooler = PooledClass.twoArgumentPooler;
+
+ function Position(left, top) {
+ this.left = left;
+ this.top = top;
+ }
+
+ Position.prototype.destructor = function () {
+ this.left = null;
+ this.top = null;
+ };
+
+ PooledClass.addPoolingTo(Position, twoArgumentPooler);
+ module.exports = Position;
+},216,[215],"node_modules\\react-native\\Libraries\\Components\\Touchable\\Position.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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;
+},217,[35,36,131],"node_modules\\react-native\\Libraries\\Components\\AppleTV\\TVEventHandler.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var invariant = _$$_REQUIRE(_dependencyMap[0], "./invariant");
+
+ var keyMirror = function keyMirror(obj) {
+ var ret = {};
+ var key;
+ !(obj instanceof Object && !Array.isArray(obj)) ? process.env.NODE_ENV !== "production" ? invariant(false, 'keyMirror(...): Argument must be an object.') : invariant(false) : void 0;
+
+ for (key in obj) {
+ if (!obj.hasOwnProperty(key)) {
+ continue;
+ }
+
+ ret[key] = key;
+ }
+
+ return ret;
+ };
+
+ module.exports = keyMirror;
+},218,[219],"node_modules\\fbjs\\lib\\keyMirror.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var validateFormat = process.env.NODE_ENV !== "production" ? function (format) {} : function (format) {
+ if (format === undefined) {
+ throw new Error('invariant(...): Second argument must be a string.');
+ }
+ };
+
+ function invariant(condition, format) {
+ for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+ args[_key - 2] = arguments[_key];
+ }
+
+ validateFormat(format);
+
+ if (!condition) {
+ var error;
+
+ if (format === undefined) {
+ error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');
+ } else {
+ var argIndex = 0;
+ error = new Error(format.replace(/%s/g, function () {
+ return String(args[argIndex++]);
+ }));
+ error.name = 'Invariant Violation';
+ }
+
+ error.framesToPop = 1;
+ throw error;
+ }
+ }
+
+ module.exports = invariant;
+},219,[],"node_modules\\fbjs\\lib\\invariant.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ function nullthrows(x, message) {
+ if (x != null) {
+ return x;
+ }
+
+ var error = new Error(message !== undefined ? message : 'Got unexpected ' + x);
+ error.framesToPop = 1;
+ throw error;
+ }
+
+ module.exports = nullthrows;
+ module.exports.default = nullthrows;
+ Object.defineProperty(module.exports, '__esModule', {
+ value: true
+ });
+},220,[],"node_modules\\nullthrows\\nullthrows.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Components\\Touchable\\TouchableHighlight.js";
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var DeprecatedColorPropType = _$$_REQUIRE(_dependencyMap[1], "DeprecatedColorPropType");
+
+ var DeprecatedViewPropTypes = _$$_REQUIRE(_dependencyMap[2], "DeprecatedViewPropTypes");
+
+ var NativeMethodsMixin = _$$_REQUIRE(_dependencyMap[3], "NativeMethodsMixin");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[4], "Platform");
+
+ var PropTypes = _$$_REQUIRE(_dependencyMap[5], "prop-types");
+
+ var React = _$$_REQUIRE(_dependencyMap[6], "React");
+
+ var ReactNativeViewAttributes = _$$_REQUIRE(_dependencyMap[7], "ReactNativeViewAttributes");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[8], "StyleSheet");
+
+ var Touchable = _$$_REQUIRE(_dependencyMap[9], "Touchable");
+
+ var TouchableWithoutFeedback = _$$_REQUIRE(_dependencyMap[10], "TouchableWithoutFeedback");
+
+ var View = _$$_REQUIRE(_dependencyMap[11], "View");
+
+ var createReactClass = _$$_REQUIRE(_dependencyMap[12], "create-react-class");
+
+ var ensurePositiveDelayProps = _$$_REQUIRE(_dependencyMap[13], "ensurePositiveDelayProps");
+
+ var DEFAULT_PROPS = {
+ activeOpacity: 0.85,
+ delayPressOut: 100,
+ underlayColor: 'black'
+ };
+ var PRESS_RETENTION_OFFSET = {
+ top: 20,
+ left: 20,
+ right: 20,
+ bottom: 30
+ };
+ var TouchableHighlight = createReactClass({
+ displayName: 'TouchableHighlight',
+ propTypes: _objectSpread({}, TouchableWithoutFeedback.propTypes, {
+ activeOpacity: PropTypes.number,
+ underlayColor: DeprecatedColorPropType,
+ style: DeprecatedViewPropTypes.style,
+ onShowUnderlay: PropTypes.func,
+ onHideUnderlay: PropTypes.func,
+ hasTVPreferredFocus: PropTypes.bool,
+ tvParallaxProperties: PropTypes.object,
+ testOnly_pressed: PropTypes.bool
+ }),
+ mixins: [NativeMethodsMixin, Touchable.Mixin.withoutDefaultFocusAndBlur],
+ getDefaultProps: function getDefaultProps() {
+ return DEFAULT_PROPS;
+ },
+ getInitialState: function getInitialState() {
+ this._isMounted = false;
+
+ if (this.props.testOnly_pressed) {
+ return _objectSpread({}, this.touchableGetInitialState(), {
+ extraChildStyle: {
+ opacity: this.props.activeOpacity
+ },
+ extraUnderlayStyle: {
+ backgroundColor: this.props.underlayColor
+ }
+ });
+ } else {
+ return _objectSpread({}, this.touchableGetInitialState(), {
+ extraChildStyle: null,
+ extraUnderlayStyle: null
+ });
+ }
+ },
+ componentDidMount: function componentDidMount() {
+ this._isMounted = true;
+ ensurePositiveDelayProps(this.props);
+ },
+ componentWillUnmount: function componentWillUnmount() {
+ this._isMounted = false;
+ clearTimeout(this._hideTimeout);
+ },
+ UNSAFE_componentWillReceiveProps: function UNSAFE_componentWillReceiveProps(nextProps) {
+ ensurePositiveDelayProps(nextProps);
+ },
+ viewConfig: {
+ uiViewClassName: 'RCTView',
+ validAttributes: ReactNativeViewAttributes.RCTView
+ },
+ touchableHandleActivePressIn: function touchableHandleActivePressIn(e) {
+ clearTimeout(this._hideTimeout);
+ this._hideTimeout = null;
+
+ this._showUnderlay();
+
+ this.props.onPressIn && this.props.onPressIn(e);
+ },
+ touchableHandleActivePressOut: function touchableHandleActivePressOut(e) {
+ if (!this._hideTimeout) {
+ this._hideUnderlay();
+ }
+
+ this.props.onPressOut && this.props.onPressOut(e);
+ },
+ touchableHandleFocus: function touchableHandleFocus(e) {
+ if (Platform.isTV) {
+ this._showUnderlay();
+ }
+
+ this.props.onFocus && this.props.onFocus(e);
+ },
+ touchableHandleBlur: function touchableHandleBlur(e) {
+ if (Platform.isTV) {
+ this._hideUnderlay();
+ }
+
+ this.props.onBlur && this.props.onBlur(e);
+ },
+ touchableHandlePress: function touchableHandlePress(e) {
+ clearTimeout(this._hideTimeout);
+
+ if (!Platform.isTV) {
+ this._showUnderlay();
+
+ this._hideTimeout = setTimeout(this._hideUnderlay, this.props.delayPressOut);
+ }
+
+ this.props.onPress && this.props.onPress(e);
+ },
+ touchableHandleLongPress: function touchableHandleLongPress(e) {
+ this.props.onLongPress && this.props.onLongPress(e);
+ },
+ touchableGetPressRectOffset: function touchableGetPressRectOffset() {
+ return this.props.pressRetentionOffset || PRESS_RETENTION_OFFSET;
+ },
+ touchableGetHitSlop: function touchableGetHitSlop() {
+ return this.props.hitSlop;
+ },
+ touchableGetHighlightDelayMS: function touchableGetHighlightDelayMS() {
+ return this.props.delayPressIn;
+ },
+ touchableGetLongPressDelayMS: function touchableGetLongPressDelayMS() {
+ return this.props.delayLongPress;
+ },
+ touchableGetPressOutDelayMS: function touchableGetPressOutDelayMS() {
+ return this.props.delayPressOut;
+ },
+ _showUnderlay: function _showUnderlay() {
+ if (!this._isMounted || !this._hasPressHandler()) {
+ return;
+ }
+
+ this.setState({
+ extraChildStyle: {
+ opacity: this.props.activeOpacity
+ },
+ extraUnderlayStyle: {
+ backgroundColor: this.props.underlayColor
+ }
+ });
+ this.props.onShowUnderlay && this.props.onShowUnderlay();
+ },
+ _hideUnderlay: function _hideUnderlay() {
+ clearTimeout(this._hideTimeout);
+ this._hideTimeout = null;
+
+ if (this.props.testOnly_pressed) {
+ return;
+ }
+
+ if (this._hasPressHandler()) {
+ this.setState({
+ extraChildStyle: null,
+ extraUnderlayStyle: null
+ });
+ this.props.onHideUnderlay && this.props.onHideUnderlay();
+ }
+ },
+ _hasPressHandler: function _hasPressHandler() {
+ return !!(this.props.onPress || this.props.onPressIn || this.props.onPressOut || this.props.onLongPress);
+ },
+ render: function render() {
+ var child = React.Children.only(this.props.children);
+ return React.createElement(View, {
+ accessible: this.props.accessible !== false,
+ accessibilityLabel: this.props.accessibilityLabel,
+ accessibilityHint: this.props.accessibilityHint,
+ accessibilityRole: this.props.accessibilityRole,
+ accessibilityStates: this.props.accessibilityStates,
+ onAccessibilityTap: this.props.onAccessibilityTap,
+ acceptsKeyboardFocus: (this.props.acceptsKeyboardFocus === undefined || this.props.acceptsKeyboardFocus) && !this.props.disabled,
+ enableFocusRing: (this.props.enableFocusRing === undefined || this.props.enableFocusRing) && !this.props.disabled,
+ tabIndex: this.props.tabIndex,
+ 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,
+ tooltip: this.props.tooltip,
+ clickable: this.props.clickable !== false && this.props.onPress !== undefined,
+ onClick: this.touchableHandlePress,
+ onMouseEnter: this.props.onMouseEnter,
+ onMouseLeave: this.props.onMouseLeave,
+ onDragEnter: this.props.onDragEnter,
+ onDragLeave: this.props.onDragLeave,
+ onDrop: this.props.onDrop,
+ draggedTypes: this.props.draggedTypes,
+ nativeID: this.props.nativeID,
+ testID: this.props.testID,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 397
+ }
+ }, React.cloneElement(child, {
+ style: StyleSheet.compose(child.props.style, this.state.extraChildStyle)
+ }), Touchable.renderDebugView({
+ color: 'green',
+ hitSlop: this.props.hitSlop
+ }));
+ }
+ });
+ module.exports = TouchableHighlight;
+},221,[32,59,222,225,35,62,52,203,53,213,226,81,227,233],"node_modules\\react-native\\Libraries\\Components\\Touchable\\TouchableHighlight.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var DeprecatedEdgeInsetsPropType = _$$_REQUIRE(_dependencyMap[1], "DeprecatedEdgeInsetsPropType");
+
+ var PlatformViewPropTypes = _$$_REQUIRE(_dependencyMap[2], "PlatformViewPropTypes");
+
+ var PropTypes = _$$_REQUIRE(_dependencyMap[3], "prop-types");
+
+ var DeprecatedStyleSheetPropType = _$$_REQUIRE(_dependencyMap[4], "DeprecatedStyleSheetPropType");
+
+ var DeprecatedViewStylePropTypes = _$$_REQUIRE(_dependencyMap[5], "DeprecatedViewStylePropTypes");
+
+ var _require = _$$_REQUIRE(_dependencyMap[6], "DeprecatedViewAccessibility"),
+ DeprecatedAccessibilityComponentTypes = _require.DeprecatedAccessibilityComponentTypes,
+ DeprecatedAccessibilityTraits = _require.DeprecatedAccessibilityTraits,
+ DeprecatedAccessibilityRoles = _require.DeprecatedAccessibilityRoles,
+ DeprecatedAccessibilityStates = _require.DeprecatedAccessibilityStates;
+
+ var stylePropType = DeprecatedStyleSheetPropType(DeprecatedViewStylePropTypes);
+ module.exports = _objectSpread({
+ accessible: PropTypes.bool,
+ accessibilityLabel: PropTypes.node,
+ accessibilityHint: PropTypes.string,
+ accessibilityActions: PropTypes.arrayOf(PropTypes.string),
+ accessibilityIgnoresInvertColors: PropTypes.bool,
+ accessibilityComponentType: PropTypes.oneOf(DeprecatedAccessibilityComponentTypes),
+ accessibilityRole: PropTypes.oneOf(DeprecatedAccessibilityRoles),
+ accessibilityStates: PropTypes.arrayOf(PropTypes.oneOf(DeprecatedAccessibilityStates)),
+ accessibilityLiveRegion: PropTypes.oneOf(['none', 'polite', 'assertive']),
+ importantForAccessibility: PropTypes.oneOf(['auto', 'yes', 'no', 'no-hide-descendants']),
+ accessibilityTraits: PropTypes.oneOfType([PropTypes.oneOf(DeprecatedAccessibilityTraits), PropTypes.arrayOf(PropTypes.oneOf(DeprecatedAccessibilityTraits))]),
+ accessibilityViewIsModal: PropTypes.bool,
+ accessibilityElementsHidden: PropTypes.bool,
+ onAccessibilityAction: PropTypes.func,
+ onAccessibilityTap: PropTypes.func,
+ onMagicTap: PropTypes.func,
+ testID: PropTypes.string,
+ nativeID: PropTypes.string,
+ onResponderGrant: PropTypes.func,
+ onResponderMove: PropTypes.func,
+ onResponderReject: PropTypes.func,
+ onResponderRelease: PropTypes.func,
+ onResponderTerminate: PropTypes.func,
+ onResponderTerminationRequest: PropTypes.func,
+ onStartShouldSetResponder: PropTypes.func,
+ onStartShouldSetResponderCapture: PropTypes.func,
+ onMoveShouldSetResponder: PropTypes.func,
+ onMoveShouldSetResponderCapture: PropTypes.func,
+ hitSlop: DeprecatedEdgeInsetsPropType,
+ onLayout: PropTypes.func,
+ pointerEvents: PropTypes.oneOf(['box-none', 'none', 'box-only', 'auto']),
+ style: stylePropType,
+ removeClippedSubviews: PropTypes.bool,
+ renderToHardwareTextureAndroid: PropTypes.bool,
+ shouldRasterizeIOS: PropTypes.bool,
+ collapsable: PropTypes.bool,
+ needsOffscreenAlphaCompositing: PropTypes.bool
+ }, PlatformViewPropTypes);
+},222,[32,210,223,62,211,74,224],"node_modules\\react-native\\Libraries\\DeprecatedPropTypes\\DeprecatedViewPropTypes.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ module.export = {};
+},223,[],"Libraries\\Components\\View\\PlatformViewPropTypes.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ module.exports = {
+ DeprecatedAccessibilityTraits: ['none', 'button', 'link', 'header', 'search', 'image', 'selected', 'plays', 'key', 'text', 'summary', 'disabled', 'frequentUpdates', 'startsMedia', 'adjustable', 'allowsDirectInteraction', 'pageTurn'],
+ DeprecatedAccessibilityComponentTypes: ['none', 'button', 'radiobutton_checked', 'radiobutton_unchecked'],
+ DeprecatedAccessibilityRoles: ['none', 'button', 'link', 'search', 'image', 'keyboardkey', 'text', 'adjustable', 'imagebutton', 'header', 'summary', 'alert', 'checkbox', 'combobox', 'menu', 'menubar', 'menuitem', 'progressbar', 'radio', 'radiogroup', 'scrollbar', 'spinbutton', 'switch', 'tab', 'tablist', 'timer', 'toolbar'],
+ DeprecatedAccessibilityStates: ['selected', 'disabled', 'checked', 'unchecked', 'busy', 'expanded', 'collapsed']
+ };
+},224,[],"node_modules\\react-native\\Libraries\\DeprecatedPropTypes\\DeprecatedViewAccessibility.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _require = _$$_REQUIRE(_dependencyMap[0], "ReactNative"),
+ __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = _require.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+ var NativeMethodsMixin = __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.NativeMethodsMixin;
+ module.exports = NativeMethodsMixin;
+},225,[84],"node_modules\\react-native\\Libraries\\Renderer\\shims\\NativeMethodsMixin.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var DeprecatedEdgeInsetsPropType = _$$_REQUIRE(_dependencyMap[0], "DeprecatedEdgeInsetsPropType");
+
+ var React = _$$_REQUIRE(_dependencyMap[1], "React");
+
+ var PropTypes = _$$_REQUIRE(_dependencyMap[2], "prop-types");
+
+ var Touchable = _$$_REQUIRE(_dependencyMap[3], "Touchable");
+
+ var View = _$$_REQUIRE(_dependencyMap[4], "View");
+
+ var createReactClass = _$$_REQUIRE(_dependencyMap[5], "create-react-class");
+
+ var ensurePositiveDelayProps = _$$_REQUIRE(_dependencyMap[6], "ensurePositiveDelayProps");
+
+ var _require = _$$_REQUIRE(_dependencyMap[7], "DeprecatedViewAccessibility"),
+ DeprecatedAccessibilityComponentTypes = _require.DeprecatedAccessibilityComponentTypes,
+ DeprecatedAccessibilityRoles = _require.DeprecatedAccessibilityRoles,
+ DeprecatedAccessibilityStates = _require.DeprecatedAccessibilityStates,
+ DeprecatedAccessibilityTraits = _require.DeprecatedAccessibilityTraits;
+
+ var _require2 = _$$_REQUIRE(_dependencyMap[8], "DraggedType"),
+ DraggedTypes = _require2.DraggedTypes;
+
+ var PRESS_RETENTION_OFFSET = {
+ top: 20,
+ left: 20,
+ right: 20,
+ bottom: 30
+ };
+ var TouchableWithoutFeedback = createReactClass({
+ displayName: 'TouchableWithoutFeedback',
+ mixins: [Touchable.Mixin],
+ propTypes: {
+ accessible: PropTypes.bool,
+ accessibilityLabel: PropTypes.node,
+ accessibilityHint: PropTypes.string,
+ accessibilityComponentType: PropTypes.oneOf(DeprecatedAccessibilityComponentTypes),
+ accessibilityRole: PropTypes.oneOf(DeprecatedAccessibilityRoles),
+ accessibilityStates: PropTypes.arrayOf(PropTypes.oneOf(DeprecatedAccessibilityStates)),
+ accessibilityTraits: PropTypes.oneOfType([PropTypes.oneOf(DeprecatedAccessibilityTraits), PropTypes.arrayOf(PropTypes.oneOf(DeprecatedAccessibilityTraits))]),
+ onAccessibilityTap: PropTypes.func,
+ tabIndex: PropTypes.number,
+ onFocus: PropTypes.func,
+ onBlur: PropTypes.func,
+ disabled: PropTypes.bool,
+ onMouseEnter: PropTypes.func,
+ onMouseLeave: PropTypes.func,
+ onDragEnter: PropTypes.func,
+ onDragLeave: PropTypes.func,
+ onDrop: PropTypes.func,
+ draggedTypes: PropTypes.oneOfType([PropTypes.oneOf(DraggedTypes), PropTypes.arrayOf(PropTypes.oneOf(DraggedTypes))]),
+ tooltip: PropTypes.string,
+ 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: DeprecatedEdgeInsetsPropType,
+ hitSlop: DeprecatedEdgeInsetsPropType
+ },
+ getInitialState: function getInitialState() {
+ return this.touchableGetInitialState();
+ },
+ componentDidMount: function componentDidMount() {
+ ensurePositiveDelayProps(this.props);
+ },
+ UNSAFE_componentWillReceiveProps: function UNSAFE_componentWillReceiveProps(nextProps) {
+ ensurePositiveDelayProps(nextProps);
+ },
+ touchableHandlePress: function touchableHandlePress(e) {
+ this.props.onPress && this.props.onPress(e);
+ },
+ touchableHandleActivePressIn: function touchableHandleActivePressIn(e) {
+ this.props.onPressIn && this.props.onPressIn(e);
+ },
+ touchableHandleActivePressOut: function touchableHandleActivePressOut(e) {
+ this.props.onPressOut && this.props.onPressOut(e);
+ },
+ touchableHandleLongPress: function touchableHandleLongPress(e) {
+ this.props.onLongPress && this.props.onLongPress(e);
+ },
+ touchableGetPressRectOffset: function touchableGetPressRectOffset() {
+ return this.props.pressRetentionOffset || PRESS_RETENTION_OFFSET;
+ },
+ touchableGetHitSlop: function touchableGetHitSlop() {
+ return this.props.hitSlop;
+ },
+ touchableGetHighlightDelayMS: function touchableGetHighlightDelayMS() {
+ return this.props.delayPressIn || 0;
+ },
+ touchableGetLongPressDelayMS: function touchableGetLongPressDelayMS() {
+ return this.props.delayLongPress === 0 ? 0 : this.props.delayLongPress || 500;
+ },
+ touchableGetPressOutDelayMS: function touchableGetPressOutDelayMS() {
+ return this.props.delayPressOut || 0;
+ },
+ render: function render() {
+ var child = React.Children.only(this.props.children);
+ var children = child.props.children;
+
+ if (Touchable.TOUCH_TARGET_DEBUG && child.type === View) {
+ children = React.Children.toArray(children);
+ children.push(Touchable.renderDebugView({
+ color: 'red',
+ hitSlop: this.props.hitSlop
+ }));
+ }
+
+ return React.cloneElement(child, {
+ accessible: this.props.accessible !== false,
+ accessibilityLabel: this.props.accessibilityLabel,
+ accessibilityHint: this.props.accessibilityHint,
+ accessibilityComponentType: this.props.accessibilityComponentType,
+ accessibilityRole: this.props.accessibilityRole,
+ accessibilityStates: this.props.accessibilityStates,
+ accessibilityTraits: this.props.accessibilityTraits,
+ onAccessibilityTap: this.props.onAccessibilityTap,
+ acceptsKeyboardFocus: (this.props.acceptsKeyboardFocus === undefined || this.props.acceptsKeyboardFocus) && !this.props.disabled,
+ enableFocusRing: this.props.enableFocusRing === true && !this.props.disabled,
+ tabIndex: this.props.tabIndex,
+ 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,
+ tooltip: this.props.tooltip,
+ clickable: this.props.clickable !== false && this.props.onPress !== undefined,
+ onClick: this.touchableHandlePress,
+ onMouseEnter: this.props.onMouseEnter,
+ onMouseLeave: this.props.onMouseLeave,
+ onDragEnter: this.props.onDragEnter,
+ onDragLeave: this.props.onDragLeave,
+ onDrop: this.props.onDrop,
+ draggedTypes: this.props.draggedTypes,
+ children: children
+ });
+ }
+ });
+ module.exports = TouchableWithoutFeedback;
+},226,[210,52,62,213,81,227,233,224,234],"node_modules\\react-native\\Libraries\\Components\\Touchable\\TouchableWithoutFeedback.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var React = _$$_REQUIRE(_dependencyMap[0], "react");
+
+ var factory = _$$_REQUIRE(_dependencyMap[1], "./factory");
+
+ if (typeof React === 'undefined') {
+ throw Error('create-react-class could not find the React object. If you are using script tags, ' + 'make sure that React is being loaded before create-react-class.');
+ }
+
+ var ReactNoopUpdateQueue = new React.Component().updater;
+ module.exports = factory(React.Component, React.isValidElement, ReactNoopUpdateQueue);
+},227,[11,228],"node_modules\\create-react-class\\index.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _assign = _$$_REQUIRE(_dependencyMap[0], "object-assign");
+
+ var emptyObject = _$$_REQUIRE(_dependencyMap[1], "fbjs/lib/emptyObject");
+
+ var _invariant = _$$_REQUIRE(_dependencyMap[2], "fbjs/lib/invariant");
+
+ if (process.env.NODE_ENV !== 'production') {
+ var warning = _$$_REQUIRE(_dependencyMap[3], "fbjs/lib/warning");
+ }
+
+ var MIXINS_KEY = 'mixins';
+
+ function identity(fn) {
+ return fn;
+ }
+
+ var ReactPropTypeLocationNames;
+
+ if (process.env.NODE_ENV !== 'production') {
+ ReactPropTypeLocationNames = {
+ prop: 'prop',
+ context: 'context',
+ childContext: 'child context'
+ };
+ } else {
+ ReactPropTypeLocationNames = {};
+ }
+
+ function factory(ReactComponent, isValidElement, ReactNoopUpdateQueue) {
+ var injectedMixins = [];
+ var ReactClassInterface = {
+ mixins: 'DEFINE_MANY',
+ statics: 'DEFINE_MANY',
+ propTypes: 'DEFINE_MANY',
+ contextTypes: 'DEFINE_MANY',
+ childContextTypes: 'DEFINE_MANY',
+ getDefaultProps: 'DEFINE_MANY_MERGED',
+ getInitialState: 'DEFINE_MANY_MERGED',
+ getChildContext: 'DEFINE_MANY_MERGED',
+ render: 'DEFINE_ONCE',
+ componentWillMount: 'DEFINE_MANY',
+ componentDidMount: 'DEFINE_MANY',
+ componentWillReceiveProps: 'DEFINE_MANY',
+ shouldComponentUpdate: 'DEFINE_ONCE',
+ componentWillUpdate: 'DEFINE_MANY',
+ componentDidUpdate: 'DEFINE_MANY',
+ componentWillUnmount: 'DEFINE_MANY',
+ UNSAFE_componentWillMount: 'DEFINE_MANY',
+ UNSAFE_componentWillReceiveProps: 'DEFINE_MANY',
+ UNSAFE_componentWillUpdate: 'DEFINE_MANY',
+ updateComponent: 'OVERRIDE_BASE'
+ };
+ var ReactClassStaticInterface = {
+ getDerivedStateFromProps: 'DEFINE_MANY_MERGED'
+ };
+ var RESERVED_SPEC_KEYS = {
+ displayName: function displayName(Constructor, _displayName) {
+ Constructor.displayName = _displayName;
+ },
+ mixins: function mixins(Constructor, _mixins) {
+ if (_mixins) {
+ for (var i = 0; i < _mixins.length; i++) {
+ mixSpecIntoComponent(Constructor, _mixins[i]);
+ }
+ }
+ },
+ childContextTypes: function childContextTypes(Constructor, _childContextTypes) {
+ if (process.env.NODE_ENV !== 'production') {
+ validateTypeDef(Constructor, _childContextTypes, 'childContext');
+ }
+
+ Constructor.childContextTypes = _assign({}, Constructor.childContextTypes, _childContextTypes);
+ },
+ contextTypes: function contextTypes(Constructor, _contextTypes) {
+ if (process.env.NODE_ENV !== 'production') {
+ validateTypeDef(Constructor, _contextTypes, 'context');
+ }
+
+ Constructor.contextTypes = _assign({}, Constructor.contextTypes, _contextTypes);
+ },
+ getDefaultProps: function getDefaultProps(Constructor, _getDefaultProps) {
+ if (Constructor.getDefaultProps) {
+ Constructor.getDefaultProps = createMergedResultFunction(Constructor.getDefaultProps, _getDefaultProps);
+ } else {
+ Constructor.getDefaultProps = _getDefaultProps;
+ }
+ },
+ propTypes: function propTypes(Constructor, _propTypes) {
+ if (process.env.NODE_ENV !== 'production') {
+ validateTypeDef(Constructor, _propTypes, 'prop');
+ }
+
+ Constructor.propTypes = _assign({}, Constructor.propTypes, _propTypes);
+ },
+ statics: function statics(Constructor, _statics) {
+ mixStaticSpecIntoComponent(Constructor, _statics);
+ },
+ autobind: function autobind() {}
+ };
+
+ function validateTypeDef(Constructor, typeDef, location) {
+ for (var propName in typeDef) {
+ if (typeDef.hasOwnProperty(propName)) {
+ if (process.env.NODE_ENV !== 'production') {
+ warning(typeof typeDef[propName] === 'function', '%s: %s type `%s` is invalid; it must be a function, usually from ' + 'React.PropTypes.', Constructor.displayName || 'ReactClass', ReactPropTypeLocationNames[location], propName);
+ }
+ }
+ }
+ }
+
+ function validateMethodOverride(isAlreadyDefined, name) {
+ var specPolicy = ReactClassInterface.hasOwnProperty(name) ? ReactClassInterface[name] : null;
+
+ if (ReactClassMixin.hasOwnProperty(name)) {
+ _invariant(specPolicy === 'OVERRIDE_BASE', 'ReactClassInterface: You are attempting to override ' + '`%s` from your class specification. Ensure that your method names ' + 'do not overlap with React methods.', name);
+ }
+
+ if (isAlreadyDefined) {
+ _invariant(specPolicy === 'DEFINE_MANY' || specPolicy === 'DEFINE_MANY_MERGED', 'ReactClassInterface: You are attempting to define ' + '`%s` on your component more than once. This conflict may be due ' + 'to a mixin.', name);
+ }
+ }
+
+ function mixSpecIntoComponent(Constructor, spec) {
+ if (!spec) {
+ if (process.env.NODE_ENV !== 'production') {
+ var typeofSpec = typeof spec;
+ var isMixinValid = typeofSpec === 'object' && spec !== null;
+
+ if (process.env.NODE_ENV !== 'production') {
+ warning(isMixinValid, "%s: You're attempting to include a mixin that is either null " + 'or not an object. Check the mixins included by the component, ' + 'as well as any mixins they include themselves. ' + 'Expected object but got %s.', Constructor.displayName || 'ReactClass', spec === null ? null : typeofSpec);
+ }
+ }
+
+ return;
+ }
+
+ _invariant(typeof spec !== 'function', "ReactClass: You're attempting to " + 'use a component class or function as a mixin. Instead, just use a ' + 'regular object.');
+
+ _invariant(!isValidElement(spec), "ReactClass: You're attempting to " + 'use a component as a mixin. Instead, just use a regular object.');
+
+ var proto = Constructor.prototype;
+ var autoBindPairs = proto.__reactAutoBindPairs;
+
+ if (spec.hasOwnProperty(MIXINS_KEY)) {
+ RESERVED_SPEC_KEYS.mixins(Constructor, spec.mixins);
+ }
+
+ for (var name in spec) {
+ if (!spec.hasOwnProperty(name)) {
+ continue;
+ }
+
+ if (name === MIXINS_KEY) {
+ continue;
+ }
+
+ var property = spec[name];
+ var isAlreadyDefined = proto.hasOwnProperty(name);
+ validateMethodOverride(isAlreadyDefined, name);
+
+ if (RESERVED_SPEC_KEYS.hasOwnProperty(name)) {
+ RESERVED_SPEC_KEYS[name](Constructor, property);
+ } else {
+ var isReactClassMethod = ReactClassInterface.hasOwnProperty(name);
+ var isFunction = typeof property === 'function';
+ var shouldAutoBind = isFunction && !isReactClassMethod && !isAlreadyDefined && spec.autobind !== false;
+
+ if (shouldAutoBind) {
+ autoBindPairs.push(name, property);
+ proto[name] = property;
+ } else {
+ if (isAlreadyDefined) {
+ var specPolicy = ReactClassInterface[name];
+
+ _invariant(isReactClassMethod && (specPolicy === 'DEFINE_MANY_MERGED' || specPolicy === 'DEFINE_MANY'), 'ReactClass: Unexpected spec policy %s for key %s ' + 'when mixing in component specs.', specPolicy, name);
+
+ if (specPolicy === 'DEFINE_MANY_MERGED') {
+ proto[name] = createMergedResultFunction(proto[name], property);
+ } else if (specPolicy === 'DEFINE_MANY') {
+ proto[name] = createChainedFunction(proto[name], property);
+ }
+ } else {
+ proto[name] = property;
+
+ if (process.env.NODE_ENV !== 'production') {
+ if (typeof property === 'function' && spec.displayName) {
+ proto[name].displayName = spec.displayName + '_' + name;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ function mixStaticSpecIntoComponent(Constructor, statics) {
+ if (!statics) {
+ return;
+ }
+
+ for (var name in statics) {
+ var property = statics[name];
+
+ if (!statics.hasOwnProperty(name)) {
+ continue;
+ }
+
+ var isReserved = name in RESERVED_SPEC_KEYS;
+
+ _invariant(!isReserved, 'ReactClass: You are attempting to define a reserved ' + 'property, `%s`, that shouldn\'t be on the "statics" key. Define it ' + 'as an instance property instead; it will still be accessible on the ' + 'constructor.', name);
+
+ var isAlreadyDefined = name in Constructor;
+
+ if (isAlreadyDefined) {
+ var specPolicy = ReactClassStaticInterface.hasOwnProperty(name) ? ReactClassStaticInterface[name] : null;
+
+ _invariant(specPolicy === 'DEFINE_MANY_MERGED', 'ReactClass: You are attempting to define ' + '`%s` on your component more than once. This conflict may be ' + 'due to a mixin.', name);
+
+ Constructor[name] = createMergedResultFunction(Constructor[name], property);
+ return;
+ }
+
+ Constructor[name] = property;
+ }
+ }
+
+ function mergeIntoWithNoDuplicateKeys(one, two) {
+ _invariant(one && two && typeof one === 'object' && typeof two === 'object', 'mergeIntoWithNoDuplicateKeys(): Cannot merge non-objects.');
+
+ for (var key in two) {
+ if (two.hasOwnProperty(key)) {
+ _invariant(one[key] === undefined, 'mergeIntoWithNoDuplicateKeys(): ' + 'Tried to merge two objects with the same key: `%s`. This conflict ' + 'may be due to a mixin; in particular, this may be caused by two ' + 'getInitialState() or getDefaultProps() methods returning objects ' + 'with clashing keys.', key);
+
+ one[key] = two[key];
+ }
+ }
+
+ return one;
+ }
+
+ function createMergedResultFunction(one, two) {
+ return function mergedResult() {
+ var a = one.apply(this, arguments);
+ var b = two.apply(this, arguments);
+
+ if (a == null) {
+ return b;
+ } else if (b == null) {
+ return a;
+ }
+
+ var c = {};
+ mergeIntoWithNoDuplicateKeys(c, a);
+ mergeIntoWithNoDuplicateKeys(c, b);
+ return c;
+ };
+ }
+
+ function createChainedFunction(one, two) {
+ return function chainedFunction() {
+ one.apply(this, arguments);
+ two.apply(this, arguments);
+ };
+ }
+
+ function bindAutoBindMethod(component, method) {
+ var boundMethod = method.bind(component);
+
+ if (process.env.NODE_ENV !== 'production') {
+ boundMethod.__reactBoundContext = component;
+ boundMethod.__reactBoundMethod = method;
+ boundMethod.__reactBoundArguments = null;
+ var componentName = component.constructor.displayName;
+ var _bind = boundMethod.bind;
+
+ boundMethod.bind = function (newThis) {
+ for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+ args[_key - 1] = arguments[_key];
+ }
+
+ if (newThis !== component && newThis !== null) {
+ if (process.env.NODE_ENV !== 'production') {
+ warning(false, 'bind(): React component methods may only be bound to the ' + 'component instance. See %s', componentName);
+ }
+ } else if (!args.length) {
+ if (process.env.NODE_ENV !== 'production') {
+ warning(false, 'bind(): You are binding a component method to the component. ' + 'React does this for you automatically in a high-performance ' + 'way, so you can safely remove this call. See %s', componentName);
+ }
+
+ return boundMethod;
+ }
+
+ var reboundMethod = _bind.apply(boundMethod, arguments);
+
+ reboundMethod.__reactBoundContext = component;
+ reboundMethod.__reactBoundMethod = method;
+ reboundMethod.__reactBoundArguments = args;
+ return reboundMethod;
+ };
+ }
+
+ return boundMethod;
+ }
+
+ function bindAutoBindMethods(component) {
+ var pairs = component.__reactAutoBindPairs;
+
+ for (var i = 0; i < pairs.length; i += 2) {
+ var autoBindKey = pairs[i];
+ var method = pairs[i + 1];
+ component[autoBindKey] = bindAutoBindMethod(component, method);
+ }
+ }
+
+ var IsMountedPreMixin = {
+ componentDidMount: function componentDidMount() {
+ this.__isMounted = true;
+ }
+ };
+ var IsMountedPostMixin = {
+ componentWillUnmount: function componentWillUnmount() {
+ this.__isMounted = false;
+ }
+ };
+ var ReactClassMixin = {
+ replaceState: function replaceState(newState, callback) {
+ this.updater.enqueueReplaceState(this, newState, callback);
+ },
+ isMounted: function isMounted() {
+ if (process.env.NODE_ENV !== 'production') {
+ warning(this.__didWarnIsMounted, '%s: isMounted is deprecated. Instead, make sure to clean up ' + 'subscriptions and pending requests in componentWillUnmount to ' + 'prevent memory leaks.', this.constructor && this.constructor.displayName || this.name || 'Component');
+ this.__didWarnIsMounted = true;
+ }
+
+ return !!this.__isMounted;
+ }
+ };
+
+ var ReactClassComponent = function ReactClassComponent() {};
+
+ _assign(ReactClassComponent.prototype, ReactComponent.prototype, ReactClassMixin);
+
+ function createClass(spec) {
+ var Constructor = identity(function (props, context, updater) {
+ if (process.env.NODE_ENV !== 'production') {
+ warning(this instanceof Constructor, 'Something is calling a React component directly. Use a factory or ' + 'JSX instead. See: https://fb.me/react-legacyfactory');
+ }
+
+ if (this.__reactAutoBindPairs.length) {
+ bindAutoBindMethods(this);
+ }
+
+ this.props = props;
+ this.context = context;
+ this.refs = emptyObject;
+ this.updater = updater || ReactNoopUpdateQueue;
+ this.state = null;
+ var initialState = this.getInitialState ? this.getInitialState() : null;
+
+ if (process.env.NODE_ENV !== 'production') {
+ if (initialState === undefined && this.getInitialState._isMockFunction) {
+ initialState = null;
+ }
+ }
+
+ _invariant(typeof initialState === 'object' && !Array.isArray(initialState), '%s.getInitialState(): must return an object or null', Constructor.displayName || 'ReactCompositeComponent');
+
+ this.state = initialState;
+ });
+ Constructor.prototype = new ReactClassComponent();
+ Constructor.prototype.constructor = Constructor;
+ Constructor.prototype.__reactAutoBindPairs = [];
+ injectedMixins.forEach(mixSpecIntoComponent.bind(null, Constructor));
+ mixSpecIntoComponent(Constructor, IsMountedPreMixin);
+ mixSpecIntoComponent(Constructor, spec);
+ mixSpecIntoComponent(Constructor, IsMountedPostMixin);
+
+ if (Constructor.getDefaultProps) {
+ Constructor.defaultProps = Constructor.getDefaultProps();
+ }
+
+ if (process.env.NODE_ENV !== 'production') {
+ if (Constructor.getDefaultProps) {
+ Constructor.getDefaultProps.isReactClassApproved = {};
+ }
+
+ if (Constructor.prototype.getInitialState) {
+ Constructor.prototype.getInitialState.isReactClassApproved = {};
+ }
+ }
+
+ _invariant(Constructor.prototype.render, 'createClass(...): Class specification must implement a `render` method.');
+
+ if (process.env.NODE_ENV !== 'production') {
+ warning(!Constructor.prototype.componentShouldUpdate, '%s has a method called ' + 'componentShouldUpdate(). Did you mean shouldComponentUpdate()? ' + 'The name is phrased as a question because the function is ' + 'expected to return a value.', spec.displayName || 'A component');
+ warning(!Constructor.prototype.componentWillRecieveProps, '%s has a method called ' + 'componentWillRecieveProps(). Did you mean componentWillReceiveProps()?', spec.displayName || 'A component');
+ warning(!Constructor.prototype.UNSAFE_componentWillRecieveProps, '%s has a method called UNSAFE_componentWillRecieveProps(). ' + 'Did you mean UNSAFE_componentWillReceiveProps()?', spec.displayName || 'A component');
+ }
+
+ for (var methodName in ReactClassInterface) {
+ if (!Constructor.prototype[methodName]) {
+ Constructor.prototype[methodName] = null;
+ }
+ }
+
+ return Constructor;
+ }
+
+ return createClass;
+ }
+
+ module.exports = factory;
+},228,[13,229,230,231],"node_modules\\create-react-class\\factory.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var emptyObject = {};
+
+ if (process.env.NODE_ENV !== 'production') {
+ Object.freeze(emptyObject);
+ }
+
+ module.exports = emptyObject;
+},229,[],"node_modules\\create-react-class\\node_modules\\fbjs\\lib\\emptyObject.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var validateFormat = function validateFormat(format) {};
+
+ if (process.env.NODE_ENV !== 'production') {
+ validateFormat = function validateFormat(format) {
+ if (format === undefined) {
+ throw new Error('invariant requires an error message argument');
+ }
+ };
+ }
+
+ function invariant(condition, format, a, b, c, d, e, f) {
+ validateFormat(format);
+
+ if (!condition) {
+ var error;
+
+ if (format === undefined) {
+ error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');
+ } else {
+ var args = [a, b, c, d, e, f];
+ var argIndex = 0;
+ error = new Error(format.replace(/%s/g, function () {
+ return args[argIndex++];
+ }));
+ error.name = 'Invariant Violation';
+ }
+
+ error.framesToPop = 1;
+ throw error;
+ }
+ }
+
+ module.exports = invariant;
+},230,[],"node_modules\\create-react-class\\node_modules\\fbjs\\lib\\invariant.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var emptyFunction = _$$_REQUIRE(_dependencyMap[0], "./emptyFunction");
+
+ var warning = emptyFunction;
+
+ if (process.env.NODE_ENV !== 'production') {
+ var printWarning = function printWarning(format) {
+ for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+ args[_key - 1] = arguments[_key];
+ }
+
+ var argIndex = 0;
+ var message = 'Warning: ' + format.replace(/%s/g, function () {
+ return args[argIndex++];
+ });
+
+ if (typeof console !== 'undefined') {
+ console.error(message);
+ }
+
+ try {
+ throw new Error(message);
+ } catch (x) {}
+ };
+
+ warning = function warning(condition, format) {
+ if (format === undefined) {
+ throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument');
+ }
+
+ if (format.indexOf('Failed Composite propType: ') === 0) {
+ return;
+ }
+
+ if (!condition) {
+ for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
+ args[_key2 - 2] = arguments[_key2];
+ }
+
+ printWarning.apply(undefined, [format].concat(args));
+ }
+ };
+ }
+
+ module.exports = warning;
+},231,[232],"node_modules\\create-react-class\\node_modules\\fbjs\\lib\\warning.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ "use strict";
+
+ function makeEmptyFunction(arg) {
+ return function () {
+ return arg;
+ };
+ }
+
+ var emptyFunction = function emptyFunction() {};
+
+ emptyFunction.thatReturns = makeEmptyFunction;
+ emptyFunction.thatReturnsFalse = makeEmptyFunction(false);
+ emptyFunction.thatReturnsTrue = makeEmptyFunction(true);
+ emptyFunction.thatReturnsNull = makeEmptyFunction(null);
+
+ emptyFunction.thatReturnsThis = function () {
+ return this;
+ };
+
+ emptyFunction.thatReturnsArgument = function (arg) {
+ return arg;
+ };
+
+ module.exports = emptyFunction;
+},232,[],"node_modules\\create-react-class\\node_modules\\fbjs\\lib\\emptyFunction.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var invariant = _$$_REQUIRE(_dependencyMap[0], "invariant");
+
+ var ensurePositiveDelayProps = function ensurePositiveDelayProps(props) {
+ invariant(!(props.delayPressIn < 0 || props.delayPressOut < 0 || props.delayLongPress < 0), 'Touchable components cannot have negative delay properties');
+ };
+
+ module.exports = ensurePositiveDelayProps;
+},233,[19],"node_modules\\react-native\\Libraries\\Components\\Touchable\\ensurePositiveDelayProps.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ module.exports = {
+ DraggedTypes: ['fileUrl']
+ };
+},234,[],"node_modules\\react-native\\Libraries\\Components\\View\\DraggedType.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var __extends = this && this.__extends || function () {
+ var _extendStatics = function extendStatics(d, b) {
+ _extendStatics = Object.setPrototypeOf || {
+ __proto__: []
+ } instanceof Array && function (d, b) {
+ d.__proto__ = b;
+ } || function (d, b) {
+ for (var p in b) {
+ if (b.hasOwnProperty(p)) d[p] = b[p];
+ }
+ };
+
+ return _extendStatics(d, b);
+ };
+
+ return function (d, b) {
+ _extendStatics(d, b);
+
+ function __() {
+ this.constructor = d;
+ }
+
+ d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+ };
+ }();
+
+ Object.defineProperty(exports, "__esModule", {
+ value: true
+ });
+
+ var React = _$$_REQUIRE(_dependencyMap[0], "react");
+
+ var react_native_1 = _$$_REQUIRE(_dependencyMap[1], "react-native");
+
+ var styles = react_native_1.StyleSheet.create({
+ container: {
+ height: 100,
+ width: 300,
+ backgroundColor: '#ffbcbc',
+ borderWidth: 1,
+ borderColor: 'red',
+ alignItems: 'center',
+ justifyContent: 'center',
+ margin: 10
+ },
+ info: {
+ color: '#333333',
+ margin: 20
+ }
+ });
+
+ var DummyTouchableNativeFeedback = function (_super) {
+ __extends(DummyTouchableNativeFeedback, _super);
+
+ function DummyTouchableNativeFeedback() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+
+ DummyTouchableNativeFeedback.prototype.render = function () {
+ return React.createElement(react_native_1.View, {
+ style: [styles.container, this.props.style]
+ }, React.createElement(react_native_1.Text, {
+ style: styles.info
+ }, "TouchableNativeFeedback is not supported on this platform!"));
+ };
+
+ DummyTouchableNativeFeedback.SelectableBackground = function () {
+ return {};
+ };
+
+ DummyTouchableNativeFeedback.SelectableBackgroundBorderless = function () {
+ return {};
+ };
+
+ DummyTouchableNativeFeedback.Ripple = function () {
+ return {};
+ };
+
+ DummyTouchableNativeFeedback.canUseNativeForeground = function () {
+ return false;
+ };
+
+ return DummyTouchableNativeFeedback;
+ }(React.Component);
+
+ exports.default = DummyTouchableNativeFeedback;
+},235,[11,18],"Libraries\\Components\\Touchable\\TouchableNativeFeedback.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Components\\Touchable\\TouchableOpacity.js";
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var Animated = _$$_REQUIRE(_dependencyMap[1], "Animated");
+
+ var Easing = _$$_REQUIRE(_dependencyMap[2], "Easing");
+
+ var NativeMethodsMixin = _$$_REQUIRE(_dependencyMap[3], "NativeMethodsMixin");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[4], "Platform");
+
+ var React = _$$_REQUIRE(_dependencyMap[5], "React");
+
+ var PropTypes = _$$_REQUIRE(_dependencyMap[6], "prop-types");
+
+ var Touchable = _$$_REQUIRE(_dependencyMap[7], "Touchable");
+
+ var TouchableWithoutFeedback = _$$_REQUIRE(_dependencyMap[8], "TouchableWithoutFeedback");
+
+ var createReactClass = _$$_REQUIRE(_dependencyMap[9], "create-react-class");
+
+ var ensurePositiveDelayProps = _$$_REQUIRE(_dependencyMap[10], "ensurePositiveDelayProps");
+
+ var flattenStyle = _$$_REQUIRE(_dependencyMap[11], "flattenStyle");
+
+ var PRESS_RETENTION_OFFSET = {
+ top: 20,
+ left: 20,
+ right: 20,
+ bottom: 30
+ };
+ var TouchableOpacity = createReactClass({
+ displayName: 'TouchableOpacity',
+ mixins: [Touchable.Mixin.withoutDefaultFocusAndBlur, NativeMethodsMixin],
+ propTypes: _objectSpread({}, TouchableWithoutFeedback.propTypes, {
+ activeOpacity: PropTypes.number,
+ hasTVPreferredFocus: PropTypes.bool,
+ tvParallaxProperties: PropTypes.object
+ }),
+ getDefaultProps: function getDefaultProps() {
+ return {
+ activeOpacity: 0.2
+ };
+ },
+ getInitialState: function getInitialState() {
+ return _objectSpread({}, this.touchableGetInitialState(), {
+ anim: new Animated.Value(this._getChildStyleOpacityWithDefault())
+ });
+ },
+ componentDidMount: function componentDidMount() {
+ ensurePositiveDelayProps(this.props);
+ },
+ UNSAFE_componentWillReceiveProps: function UNSAFE_componentWillReceiveProps(nextProps) {
+ ensurePositiveDelayProps(nextProps);
+ },
+ componentDidUpdate: function componentDidUpdate(prevProps, prevState) {
+ if (this.props.disabled !== prevProps.disabled) {
+ this._opacityInactive(250);
+ }
+ },
+ setOpacityTo: function setOpacityTo(value, duration) {
+ Animated.timing(this.state.anim, {
+ toValue: value,
+ duration: duration,
+ easing: Easing.inOut(Easing.quad),
+ useNativeDriver: true
+ }).start();
+ },
+ touchableHandleActivePressIn: function touchableHandleActivePressIn(e) {
+ if (e.dispatchConfig.registrationName === 'onResponderGrant') {
+ this._opacityActive(0);
+ } else {
+ this._opacityActive(150);
+ }
+
+ this.props.onPressIn && this.props.onPressIn(e);
+ },
+ touchableHandleActivePressOut: function touchableHandleActivePressOut(e) {
+ this._opacityInactive(250);
+
+ this.props.onPressOut && this.props.onPressOut(e);
+ },
+ touchableHandleFocus: function touchableHandleFocus(e) {
+ if (Platform.isTV) {
+ this._opacityActive(150);
+ }
+
+ this.props.onFocus && this.props.onFocus(e);
+ },
+ touchableHandleBlur: function touchableHandleBlur(e) {
+ if (Platform.isTV) {
+ this._opacityInactive(250);
+ }
+
+ this.props.onBlur && this.props.onBlur(e);
+ },
+ touchableHandlePress: function touchableHandlePress(e) {
+ this.props.onPress && this.props.onPress(e);
+ },
+ touchableHandleLongPress: function touchableHandleLongPress(e) {
+ this.props.onLongPress && this.props.onLongPress(e);
+ },
+ touchableGetPressRectOffset: function touchableGetPressRectOffset() {
+ return this.props.pressRetentionOffset || PRESS_RETENTION_OFFSET;
+ },
+ touchableGetHitSlop: function touchableGetHitSlop() {
+ return this.props.hitSlop;
+ },
+ touchableGetHighlightDelayMS: function touchableGetHighlightDelayMS() {
+ return this.props.delayPressIn || 0;
+ },
+ touchableGetLongPressDelayMS: function touchableGetLongPressDelayMS() {
+ return this.props.delayLongPress === 0 ? 0 : this.props.delayLongPress || 500;
+ },
+ touchableGetPressOutDelayMS: function touchableGetPressOutDelayMS() {
+ return this.props.delayPressOut;
+ },
+ _opacityActive: function _opacityActive(duration) {
+ this.setOpacityTo(this.props.activeOpacity, duration);
+ },
+ _opacityInactive: function _opacityInactive(duration) {
+ this.setOpacityTo(this._getChildStyleOpacityWithDefault(), duration);
+ },
+ _getChildStyleOpacityWithDefault: function _getChildStyleOpacityWithDefault() {
+ var childStyle = flattenStyle(this.props.style) || {};
+ return childStyle.opacity == null ? 1 : childStyle.opacity;
+ },
+ render: function render() {
+ return React.createElement(Animated.View, {
+ accessible: this.props.accessible !== false,
+ accessibilityLabel: this.props.accessibilityLabel,
+ accessibilityHint: this.props.accessibilityHint,
+ accessibilityRole: this.props.accessibilityRole,
+ accessibilityStates: this.props.accessibilityStates,
+ onAccessibilityTap: this.props.onAccessibilityTap,
+ acceptsKeyboardFocus: (this.props.acceptsKeyboardFocus === undefined || this.props.acceptsKeyboardFocus) && !this.props.disabled,
+ enableFocusRing: (this.props.enableFocusRing === undefined || this.props.enableFocusRing) && !this.props.disabled,
+ tabIndex: this.props.tabIndex,
+ 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,
+ tooltip: this.props.tooltip,
+ clickable: this.props.clickable !== false && this.props.onPress !== undefined,
+ onClick: this.touchableHandlePress,
+ onMouseEnter: this.props.onMouseEnter,
+ onMouseLeave: this.props.onMouseLeave,
+ onDragEnter: this.props.onDragEnter,
+ onDragLeave: this.props.onDragLeave,
+ onDrop: this.props.onDrop,
+ draggedTypes: this.props.draggedTypes,
+ onResponderTerminate: this.touchableHandleResponderTerminate,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 282
+ }
+ }, this.props.children, Touchable.renderDebugView({
+ color: 'cyan',
+ hitSlop: this.props.hitSlop
+ }));
+ }
+ });
+ module.exports = TouchableOpacity;
+},236,[32,237,264,225,35,52,62,213,226,227,233,80],"node_modules\\react-native\\Libraries\\Components\\Touchable\\TouchableOpacity.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+
+ var _defineProperty2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/defineProperty"));
+
+ var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "Platform"));
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var AnimatedImplementation = _Platform.default.isTesting ? _$$_REQUIRE(_dependencyMap[3], "AnimatedMock") : _$$_REQUIRE(_dependencyMap[4], "AnimatedImplementation");
+ module.exports = _objectSpread({
+ get FlatList() {
+ return _$$_REQUIRE(_dependencyMap[5], "AnimatedFlatList");
+ },
+
+ get Image() {
+ return _$$_REQUIRE(_dependencyMap[6], "AnimatedImage");
+ },
+
+ get ScrollView() {
+ return _$$_REQUIRE(_dependencyMap[7], "AnimatedScrollView");
+ },
+
+ get SectionList() {
+ return _$$_REQUIRE(_dependencyMap[8], "AnimatedSectionList");
+ },
+
+ get Text() {
+ return _$$_REQUIRE(_dependencyMap[9], "AnimatedText");
+ },
+
+ get View() {
+ return _$$_REQUIRE(_dependencyMap[10], "AnimatedView");
+ }
+
+ }, AnimatedImplementation);
+},237,[1,32,35,238,247,267,286,290,291,294,295],"node_modules\\react-native\\Libraries\\Animated\\src\\Animated.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _require = _$$_REQUIRE(_dependencyMap[0], "./AnimatedEvent"),
+ AnimatedEvent = _require.AnimatedEvent,
+ attachNativeEvent = _require.attachNativeEvent;
+
+ var AnimatedImplementation = _$$_REQUIRE(_dependencyMap[1], "AnimatedImplementation");
+
+ var AnimatedInterpolation = _$$_REQUIRE(_dependencyMap[2], "./nodes/AnimatedInterpolation");
+
+ var AnimatedNode = _$$_REQUIRE(_dependencyMap[3], "./nodes/AnimatedNode");
+
+ var AnimatedProps = _$$_REQUIRE(_dependencyMap[4], "./nodes/AnimatedProps");
+
+ var AnimatedValue = _$$_REQUIRE(_dependencyMap[5], "./nodes/AnimatedValue");
+
+ var AnimatedValueXY = _$$_REQUIRE(_dependencyMap[6], "./nodes/AnimatedValueXY");
+
+ var createAnimatedComponent = _$$_REQUIRE(_dependencyMap[7], "./createAnimatedComponent");
+
+ var emptyAnimation = {
+ start: function start() {},
+ stop: function stop() {},
+ reset: function reset() {},
+ _startNativeLoop: function _startNativeLoop() {},
+ _isUsingNativeDriver: function _isUsingNativeDriver() {
+ return false;
+ }
+ };
+
+ var spring = function spring(value, config) {
+ return emptyAnimation;
+ };
+
+ var timing = function timing(value, config) {
+ return emptyAnimation;
+ };
+
+ var decay = function decay(value, config) {
+ return emptyAnimation;
+ };
+
+ var sequence = function sequence(animations) {
+ return emptyAnimation;
+ };
+
+ var parallel = function parallel(animations, config) {
+ return emptyAnimation;
+ };
+
+ var delay = function delay(time) {
+ return emptyAnimation;
+ };
+
+ var stagger = function stagger(time, animations) {
+ return emptyAnimation;
+ };
+
+ var loop = function loop(animation) {
+ var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+ _ref$iterations = _ref.iterations,
+ iterations = _ref$iterations === void 0 ? -1 : _ref$iterations;
+
+ return emptyAnimation;
+ };
+
+ var event = function event(argMapping, config) {
+ return null;
+ };
+
+ module.exports = {
+ Value: AnimatedValue,
+ ValueXY: AnimatedValueXY,
+ Interpolation: AnimatedInterpolation,
+ Node: AnimatedNode,
+ decay: decay,
+ timing: timing,
+ spring: spring,
+ add: AnimatedImplementation.add,
+ subtract: AnimatedImplementation.subtract,
+ divide: AnimatedImplementation.divide,
+ multiply: AnimatedImplementation.multiply,
+ modulo: AnimatedImplementation.modulo,
+ diffClamp: AnimatedImplementation.diffClamp,
+ delay: delay,
+ sequence: sequence,
+ parallel: parallel,
+ stagger: stagger,
+ loop: loop,
+ event: event,
+ createAnimatedComponent: createAnimatedComponent,
+ attachNativeEvent: attachNativeEvent,
+ forkEvent: AnimatedImplementation.forkEvent,
+ unforkEvent: AnimatedImplementation.unforkEvent,
+ Event: AnimatedEvent,
+ __PropsOnlyForTests: AnimatedProps
+ };
+},238,[239,247,241,242,253,240,258,266],"node_modules\\react-native\\Libraries\\Animated\\src\\AnimatedMock.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var AnimatedValue = _$$_REQUIRE(_dependencyMap[2], "./nodes/AnimatedValue");
+
+ var NativeAnimatedHelper = _$$_REQUIRE(_dependencyMap[3], "./NativeAnimatedHelper");
+
+ var ReactNative = _$$_REQUIRE(_dependencyMap[4], "ReactNative");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[5], "invariant");
+
+ var _require = _$$_REQUIRE(_dependencyMap[3], "./NativeAnimatedHelper"),
+ shouldUseNativeDriver = _require.shouldUseNativeDriver;
+
+ function attachNativeEvent(viewRef, eventName, argMapping) {
+ var eventMappings = [];
+
+ var traverse = function traverse(value, path) {
+ if (value instanceof AnimatedValue) {
+ value.__makeNative();
+
+ eventMappings.push({
+ nativeEventPath: path,
+ animatedValueTag: value.__getNativeTag()
+ });
+ } else if (typeof value === 'object') {
+ for (var _key in value) {
+ traverse(value[_key], path.concat(_key));
+ }
+ }
+ };
+
+ invariant(argMapping[0] && argMapping[0].nativeEvent, 'Native driven events only support animated values contained inside `nativeEvent`.');
+ traverse(argMapping[0].nativeEvent, []);
+ var viewTag = ReactNative.findNodeHandle(viewRef);
+ eventMappings.forEach(function (mapping) {
+ NativeAnimatedHelper.API.addAnimatedEventToView(viewTag, eventName, mapping);
+ });
+ return {
+ detach: function detach() {
+ eventMappings.forEach(function (mapping) {
+ NativeAnimatedHelper.API.removeAnimatedEventFromView(viewTag, eventName, mapping.animatedValueTag);
+ });
+ }
+ };
+ }
+
+ var AnimatedEvent = function () {
+ function AnimatedEvent(argMapping) {
+ var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+ _classCallCheck(this, AnimatedEvent);
+
+ this._listeners = [];
+ this._argMapping = argMapping;
+
+ if (config.listener) {
+ this.__addListener(config.listener);
+ }
+
+ this._callListeners = this._callListeners.bind(this);
+ this._attachedEvent = null;
+ this.__isNative = shouldUseNativeDriver(config);
+
+ if (__DEV__) {
+ this._validateMapping();
+ }
+ }
+
+ _createClass(AnimatedEvent, [{
+ key: "__addListener",
+ value: function __addListener(callback) {
+ this._listeners.push(callback);
+ }
+ }, {
+ key: "__removeListener",
+ value: function __removeListener(callback) {
+ this._listeners = this._listeners.filter(function (listener) {
+ return listener !== callback;
+ });
+ }
+ }, {
+ key: "__attach",
+ value: function __attach(viewRef, eventName) {
+ invariant(this.__isNative, 'Only native driven events need to be attached.');
+ this._attachedEvent = attachNativeEvent(viewRef, eventName, this._argMapping);
+ }
+ }, {
+ key: "__detach",
+ value: function __detach(viewTag, eventName) {
+ invariant(this.__isNative, 'Only native driven events need to be detached.');
+ this._attachedEvent && this._attachedEvent.detach();
+ }
+ }, {
+ key: "__getHandler",
+ value: function __getHandler() {
+ var _this = this;
+
+ if (this.__isNative) {
+ return this._callListeners;
+ }
+
+ return function () {
+ for (var _len = arguments.length, args = new Array(_len), _key2 = 0; _key2 < _len; _key2++) {
+ args[_key2] = arguments[_key2];
+ }
+
+ var traverse = function traverse(recMapping, recEvt, key) {
+ if (typeof recEvt === 'number' && recMapping instanceof AnimatedValue) {
+ recMapping.setValue(recEvt);
+ } else if (typeof recMapping === 'object') {
+ for (var mappingKey in recMapping) {
+ traverse(recMapping[mappingKey], recEvt[mappingKey], mappingKey);
+ }
+ }
+ };
+
+ if (!_this.__isNative) {
+ _this._argMapping.forEach(function (mapping, idx) {
+ traverse(mapping, args[idx], 'arg' + idx);
+ });
+ }
+
+ _this._callListeners.apply(_this, args);
+ };
+ }
+ }, {
+ key: "_callListeners",
+ value: function _callListeners() {
+ for (var _len2 = arguments.length, args = new Array(_len2), _key3 = 0; _key3 < _len2; _key3++) {
+ args[_key3] = arguments[_key3];
+ }
+
+ this._listeners.forEach(function (listener) {
+ return listener.apply(void 0, args);
+ });
+ }
+ }, {
+ key: "_validateMapping",
+ value: function _validateMapping() {
+ var traverse = function traverse(recMapping, recEvt, key) {
+ if (typeof recEvt === 'number') {
+ invariant(recMapping instanceof AnimatedValue, 'Bad mapping of type ' + typeof recMapping + ' for key ' + key + ', event value must map to AnimatedValue');
+ return;
+ }
+
+ invariant(typeof recMapping === 'object', 'Bad mapping of type ' + typeof recMapping + ' for key ' + key);
+ invariant(typeof recEvt === 'object', 'Bad event of type ' + typeof recEvt + ' for key ' + key);
+
+ for (var mappingKey in recMapping) {
+ traverse(recMapping[mappingKey], recEvt[mappingKey], mappingKey);
+ }
+ };
+ }
+ }]);
+
+ return AnimatedEvent;
+ }();
+
+ module.exports = {
+ AnimatedEvent: AnimatedEvent,
+ attachNativeEvent: attachNativeEvent
+ };
+},239,[3,4,240,243,84,19],"node_modules\\react-native\\Libraries\\Animated\\src\\AnimatedEvent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _get = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/get");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var AnimatedInterpolation = _$$_REQUIRE(_dependencyMap[6], "./AnimatedInterpolation");
+
+ var AnimatedWithChildren = _$$_REQUIRE(_dependencyMap[7], "./AnimatedWithChildren");
+
+ var InteractionManager = _$$_REQUIRE(_dependencyMap[8], "InteractionManager");
+
+ var NativeAnimatedHelper = _$$_REQUIRE(_dependencyMap[9], "../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) {
+ _inherits(AnimatedValue, _AnimatedWithChildren);
+
+ function AnimatedValue(value) {
+ var _this;
+
+ _classCallCheck(this, AnimatedValue);
+
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(AnimatedValue).call(this));
+ _this._startingValue = _this._value = value;
+ _this._offset = 0;
+ _this._animation = null;
+ _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
+ };
+ }
+ }]);
+
+ return AnimatedValue;
+ }(AnimatedWithChildren);
+
+ module.exports = AnimatedValue;
+},240,[3,4,5,8,25,9,241,244,245,243],"node_modules\\react-native\\Libraries\\Animated\\src\\nodes\\AnimatedValue.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _get = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/get");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/defineProperty");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var AnimatedNode = _$$_REQUIRE(_dependencyMap[7], "./AnimatedNode");
+
+ var AnimatedWithChildren = _$$_REQUIRE(_dependencyMap[8], "./AnimatedWithChildren");
+
+ var NativeAnimatedHelper = _$$_REQUIRE(_dependencyMap[9], "../NativeAnimatedHelper");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[10], "invariant");
+
+ var normalizeColor = _$$_REQUIRE(_dependencyMap[11], "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 || typeof int32Color !== 'number') {
+ 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) {
+ _inherits(AnimatedInterpolation, _AnimatedWithChildren);
+
+ function AnimatedInterpolation(parent, config) {
+ var _this;
+
+ _classCallCheck(this, AnimatedInterpolation);
+
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(AnimatedInterpolation).call(this));
+ _this._parent = parent;
+ _this._config = config;
+ _this._interpolation = createInterpolation(config);
+ return _this;
+ }
+
+ _createClass(AnimatedInterpolation, [{
+ key: "__makeNative",
+ value: function __makeNative() {
+ this._parent.__makeNative();
+
+ _get(_getPrototypeOf(AnimatedInterpolation.prototype), "__makeNative", this).call(this);
+ }
+ }, {
+ key: "__getValue",
+ value: function __getValue() {
+ var parentValue = this._parent.__getValue();
+
+ invariant(typeof parentValue === 'number', 'Cannot interpolate an input which is not a number.');
+ return this._interpolation(parentValue);
+ }
+ }, {
+ key: "interpolate",
+ value: function interpolate(config) {
+ return new AnimatedInterpolation(this, config);
+ }
+ }, {
+ key: "__attach",
+ value: function __attach() {
+ this._parent.__addChild(this);
+ }
+ }, {
+ key: "__detach",
+ value: function __detach() {
+ this._parent.__removeChild(this);
+
+ _get(_getPrototypeOf(AnimatedInterpolation.prototype), "__detach", this).call(this);
+ }
+ }, {
+ key: "__transformDataType",
+ value: function __transformDataType(range) {
+ return range.map(NativeAnimatedHelper.transformDataType);
+ }
+ }, {
+ key: "__getNativeConfig",
+ value: function __getNativeConfig() {
+ if (__DEV__) {
+ NativeAnimatedHelper.validateInterpolation(this._config);
+ }
+
+ return {
+ inputRange: this._config.inputRange,
+ outputRange: this.__transformDataType(this._config.outputRange),
+ extrapolateLeft: this._config.extrapolateLeft || this._config.extrapolate || 'extend',
+ extrapolateRight: this._config.extrapolateRight || this._config.extrapolate || 'extend',
+ type: 'interpolation'
+ };
+ }
+ }]);
+
+ return AnimatedInterpolation;
+ }(AnimatedWithChildren);
+
+ AnimatedInterpolation.__createInterpolation = createInterpolation;
+ module.exports = AnimatedInterpolation;
+},241,[3,4,5,8,25,9,32,242,244,243,19,60],"node_modules\\react-native\\Libraries\\Animated\\src\\nodes\\AnimatedInterpolation.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var NativeAnimatedHelper = _$$_REQUIRE(_dependencyMap[2], "../NativeAnimatedHelper");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[3], "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;
+},242,[3,4,243,19],"node_modules\\react-native\\Libraries\\Animated\\src\\nodes\\AnimatedNode.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var NativeAnimatedModule = _$$_REQUIRE(_dependencyMap[0], "NativeModules").NativeAnimatedModule;
+
+ var NativeEventEmitter = _$$_REQUIRE(_dependencyMap[1], "NativeEventEmitter");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[2], "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,
+ elevation: true,
+ shadowOpacity: true,
+ shadowRadius: true,
+ scaleX: true,
+ scaleY: true,
+ translateX: true,
+ translateY: true
+ };
+ var TRANSFORM_WHITELIST = {
+ translateX: true,
+ translateY: true,
+ scale: true,
+ scaleX: true,
+ scaleY: true,
+ rotate: true,
+ rotateX: true,
+ rotateY: true,
+ 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;
+ }
+
+ function transformDataType(value) {
+ if (typeof value !== 'string') {
+ return value;
+ }
+
+ if (/deg$/.test(value)) {
+ var degrees = parseFloat(value) || 0;
+ var radians = degrees * Math.PI / 180.0;
+ return radians;
+ } else {
+ return parseFloat(value) || 0;
+ }
+ }
+
+ module.exports = {
+ API: API,
+ addWhitelistedStyleProp: addWhitelistedStyleProp,
+ addWhitelistedTransformProp: addWhitelistedTransformProp,
+ addWhitelistedInterpolationParam: addWhitelistedInterpolationParam,
+ validateStyles: validateStyles,
+ validateTransform: validateTransform,
+ validateInterpolation: validateInterpolation,
+ generateNewNodeTag: generateNewNodeTag,
+ generateNewAnimationId: generateNewAnimationId,
+ assertNativeAnimatedModule: assertNativeAnimatedModule,
+ shouldUseNativeDriver: shouldUseNativeDriver,
+ transformDataType: transformDataType,
+
+ get nativeEventEmitter() {
+ if (!nativeEventEmitter) {
+ nativeEventEmitter = new NativeEventEmitter(NativeAnimatedModule);
+ }
+
+ return nativeEventEmitter;
+ }
+
+ };
+},243,[36,131,19],"node_modules\\react-native\\Libraries\\Animated\\src\\NativeAnimatedHelper.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var AnimatedNode = _$$_REQUIRE(_dependencyMap[5], "./AnimatedNode");
+
+ var NativeAnimatedHelper = _$$_REQUIRE(_dependencyMap[6], "../NativeAnimatedHelper");
+
+ var AnimatedWithChildren = function (_AnimatedNode) {
+ _inherits(AnimatedWithChildren, _AnimatedNode);
+
+ function AnimatedWithChildren() {
+ var _this;
+
+ _classCallCheck(this, AnimatedWithChildren);
+
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(AnimatedWithChildren).call(this));
+ _this._children = [];
+ return _this;
+ }
+
+ _createClass(AnimatedWithChildren, [{
+ key: "__makeNative",
+ value: function __makeNative() {
+ if (!this.__isNative) {
+ this.__isNative = true;
+
+ for (var _iterator = this._children, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();;) {
+ var _ref;
+
+ if (_isArray) {
+ if (_i >= _iterator.length) break;
+ _ref = _iterator[_i++];
+ } else {
+ _i = _iterator.next();
+ if (_i.done) break;
+ _ref = _i.value;
+ }
+
+ var _child = _ref;
+
+ _child.__makeNative();
+
+ NativeAnimatedHelper.API.connectAnimatedNodes(this.__getNativeTag(), _child.__getNativeTag());
+ }
+ }
+ }
+ }, {
+ 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;
+ }
+ }]);
+
+ return AnimatedWithChildren;
+ }(AnimatedNode);
+
+ module.exports = AnimatedWithChildren;
+},244,[3,4,5,8,9,242,243],"node_modules\\react-native\\Libraries\\Animated\\src\\nodes\\AnimatedWithChildren.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var BatchedBridge = _$$_REQUIRE(_dependencyMap[0], "BatchedBridge");
+
+ var EventEmitter = _$$_REQUIRE(_dependencyMap[1], "EventEmitter");
+
+ var TaskQueue = _$$_REQUIRE(_dependencyMap[2], "TaskQueue");
+
+ var infoLog = _$$_REQUIRE(_dependencyMap[3], "infoLog");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[4], "invariant");
+
+ var keyMirror = _$$_REQUIRE(_dependencyMap[5], "fbjs/lib/keyMirror");
+
+ var _emitter = new EventEmitter();
+
+ var DEBUG_DELAY = 0;
+ var DEBUG = false;
+ var InteractionManager = {
+ Events: keyMirror({
+ interactionStart: true,
+ interactionComplete: true
+ }),
+ runAfterInteractions: function runAfterInteractions(task) {
+ var tasks = [];
+ var promise = new Promise(function (resolve) {
+ _scheduleUpdate();
+
+ if (task) {
+ tasks.push(task);
+ }
+
+ tasks.push({
+ run: resolve,
+ name: 'resolve ' + (task && task.name || '?')
+ });
+
+ _taskQueue.enqueueTasks(tasks);
+ });
+ return {
+ then: promise.then.bind(promise),
+ done: function done() {
+ if (promise.done) {
+ return promise.done.apply(promise, arguments);
+ } else {
+ console.warn('Tried to call done when not supported by current Promise implementation.');
+ }
+ },
+ cancel: function cancel() {
+ _taskQueue.cancelTasks(tasks);
+ }
+ };
+ },
+ createInteractionHandle: function createInteractionHandle() {
+ DEBUG && infoLog('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;
+},245,[41,27,246,157,19,218],"node_modules\\react-native\\Libraries\\Interaction\\InteractionManager.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var infoLog = _$$_REQUIRE(_dependencyMap[3], "infoLog");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[4], "invariant");
+
+ var DEBUG = false;
+
+ var TaskQueue = function () {
+ function TaskQueue(_ref) {
+ var onMoreTasks = _ref.onMoreTasks;
+
+ _classCallCheck(this, TaskQueue);
+
+ this._onMoreTasks = onMoreTasks;
+ this._queueStack = [{
+ tasks: [],
+ popable: false
+ }];
+ }
+
+ _createClass(TaskQueue, [{
+ key: "enqueue",
+ value: function enqueue(task) {
+ this._getCurrentQueue().push(task);
+ }
+ }, {
+ key: "enqueueTasks",
+ value: function enqueueTasks(tasks) {
+ var _this = this;
+
+ tasks.forEach(function (task) {
+ return _this.enqueue(task);
+ });
+ }
+ }, {
+ key: "cancelTasks",
+ value: function cancelTasks(tasksToCancel) {
+ this._queueStack = this._queueStack.map(function (queue) {
+ return _objectSpread({}, queue, {
+ tasks: queue.tasks.filter(function (task) {
+ return tasksToCancel.indexOf(task) === -1;
+ })
+ });
+ }).filter(function (queue, idx) {
+ return queue.tasks.length > 0 || idx === 0;
+ });
+ }
+ }, {
+ key: "hasTasksToProcess",
+ value: function hasTasksToProcess() {
+ return this._getCurrentQueue().length > 0;
+ }
+ }, {
+ key: "processNext",
+ value: function processNext() {
+ var queue = this._getCurrentQueue();
+
+ if (queue.length) {
+ var task = queue.shift();
+
+ try {
+ if (task.gen) {
+ DEBUG && infoLog('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;
+},246,[32,3,4,157,19],"node_modules\\react-native\\Libraries\\Interaction\\TaskQueue.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var _require = _$$_REQUIRE(_dependencyMap[1], "./AnimatedEvent"),
+ AnimatedEvent = _require.AnimatedEvent,
+ attachNativeEvent = _require.attachNativeEvent;
+
+ var AnimatedAddition = _$$_REQUIRE(_dependencyMap[2], "./nodes/AnimatedAddition");
+
+ var AnimatedDiffClamp = _$$_REQUIRE(_dependencyMap[3], "./nodes/AnimatedDiffClamp");
+
+ var AnimatedDivision = _$$_REQUIRE(_dependencyMap[4], "./nodes/AnimatedDivision");
+
+ var AnimatedInterpolation = _$$_REQUIRE(_dependencyMap[5], "./nodes/AnimatedInterpolation");
+
+ var AnimatedModulo = _$$_REQUIRE(_dependencyMap[6], "./nodes/AnimatedModulo");
+
+ var AnimatedMultiplication = _$$_REQUIRE(_dependencyMap[7], "./nodes/AnimatedMultiplication");
+
+ var AnimatedNode = _$$_REQUIRE(_dependencyMap[8], "./nodes/AnimatedNode");
+
+ var AnimatedProps = _$$_REQUIRE(_dependencyMap[9], "./nodes/AnimatedProps");
+
+ var AnimatedSubtraction = _$$_REQUIRE(_dependencyMap[10], "./nodes/AnimatedSubtraction");
+
+ var AnimatedTracking = _$$_REQUIRE(_dependencyMap[11], "./nodes/AnimatedTracking");
+
+ var AnimatedValue = _$$_REQUIRE(_dependencyMap[12], "./nodes/AnimatedValue");
+
+ var AnimatedValueXY = _$$_REQUIRE(_dependencyMap[13], "./nodes/AnimatedValueXY");
+
+ var DecayAnimation = _$$_REQUIRE(_dependencyMap[14], "./animations/DecayAnimation");
+
+ var SpringAnimation = _$$_REQUIRE(_dependencyMap[15], "./animations/SpringAnimation");
+
+ var TimingAnimation = _$$_REQUIRE(_dependencyMap[16], "./animations/TimingAnimation");
+
+ var createAnimatedComponent = _$$_REQUIRE(_dependencyMap[17], "./createAnimatedComponent");
+
+ var add = function add(a, b) {
+ return new AnimatedAddition(a, b);
+ };
+
+ var subtract = function subtract(a, b) {
+ return new AnimatedSubtraction(a, b);
+ };
+
+ var divide = function divide(a, b) {
+ return new AnimatedDivision(a, b);
+ };
+
+ var multiply = function multiply(a, b) {
+ return new AnimatedMultiplication(a, b);
+ };
+
+ var modulo = function modulo(a, modulus) {
+ return new AnimatedModulo(a, modulus);
+ };
+
+ var diffClamp = function diffClamp(a, min, max) {
+ return new AnimatedDiffClamp(a, min, max);
+ };
+
+ var _combineCallbacks = function _combineCallbacks(callback, config) {
+ if (callback && config.onComplete) {
+ return function () {
+ config.onComplete && config.onComplete.apply(config, arguments);
+ callback && callback.apply(void 0, arguments);
+ };
+ } else {
+ return callback || config.onComplete;
+ }
+ };
+
+ var maybeVectorAnim = function maybeVectorAnim(value, config, anim) {
+ if (value instanceof AnimatedValueXY) {
+ var configX = _objectSpread({}, config);
+
+ var configY = _objectSpread({}, config);
+
+ for (var key in config) {
+ var _config$key = config[key],
+ x = _config$key.x,
+ y = _config$key.y;
+
+ if (x !== undefined && y !== undefined) {
+ configX[key] = x;
+ configY[key] = y;
+ }
+ }
+
+ var aX = anim(value.x, configX);
+ var aY = anim(value.y, configY);
+ return parallel([aX, aY], {
+ stopTogether: false
+ });
+ }
+
+ return null;
+ };
+
+ var spring = function spring(value, config) {
+ var _start = function start(animatedValue, configuration, callback) {
+ callback = _combineCallbacks(callback, configuration);
+ var singleValue = animatedValue;
+ var singleConfig = configuration;
+ singleValue.stopTracking();
+
+ if (configuration.toValue instanceof AnimatedNode) {
+ singleValue.track(new AnimatedTracking(singleValue, configuration.toValue, SpringAnimation, singleConfig, callback));
+ } else {
+ singleValue.animate(new SpringAnimation(singleConfig), callback);
+ }
+ };
+
+ return maybeVectorAnim(value, config, spring) || {
+ start: function start(callback) {
+ _start(value, config, callback);
+ },
+ stop: function stop() {
+ value.stopAnimation();
+ },
+ reset: function reset() {
+ value.resetAnimation();
+ },
+ _startNativeLoop: function _startNativeLoop(iterations) {
+ var singleConfig = _objectSpread({}, config, {
+ iterations: iterations
+ });
+
+ _start(value, singleConfig);
+ },
+ _isUsingNativeDriver: function _isUsingNativeDriver() {
+ return config.useNativeDriver || false;
+ }
+ };
+ };
+
+ var timing = function timing(value, config) {
+ var _start2 = function start(animatedValue, configuration, callback) {
+ callback = _combineCallbacks(callback, configuration);
+ var singleValue = animatedValue;
+ var singleConfig = configuration;
+ singleValue.stopTracking();
+
+ if (configuration.toValue instanceof AnimatedNode) {
+ singleValue.track(new AnimatedTracking(singleValue, configuration.toValue, TimingAnimation, singleConfig, callback));
+ } else {
+ singleValue.animate(new TimingAnimation(singleConfig), callback);
+ }
+ };
+
+ return maybeVectorAnim(value, config, timing) || {
+ start: function start(callback) {
+ _start2(value, config, callback);
+ },
+ stop: function stop() {
+ value.stopAnimation();
+ },
+ reset: function reset() {
+ value.resetAnimation();
+ },
+ _startNativeLoop: function _startNativeLoop(iterations) {
+ var singleConfig = _objectSpread({}, config, {
+ iterations: iterations
+ });
+
+ _start2(value, singleConfig);
+ },
+ _isUsingNativeDriver: function _isUsingNativeDriver() {
+ return config.useNativeDriver || false;
+ }
+ };
+ };
+
+ var decay = function decay(value, config) {
+ var _start3 = function start(animatedValue, configuration, callback) {
+ callback = _combineCallbacks(callback, configuration);
+ var singleValue = animatedValue;
+ var singleConfig = configuration;
+ singleValue.stopTracking();
+ singleValue.animate(new DecayAnimation(singleConfig), callback);
+ };
+
+ return maybeVectorAnim(value, config, decay) || {
+ start: function start(callback) {
+ _start3(value, config, callback);
+ },
+ stop: function stop() {
+ value.stopAnimation();
+ },
+ reset: function reset() {
+ value.resetAnimation();
+ },
+ _startNativeLoop: function _startNativeLoop(iterations) {
+ var singleConfig = _objectSpread({}, config, {
+ iterations: iterations
+ });
+
+ _start3(value, singleConfig);
+ },
+ _isUsingNativeDriver: function _isUsingNativeDriver() {
+ return config.useNativeDriver || false;
+ }
+ };
+ };
+
+ var sequence = function sequence(animations) {
+ var current = 0;
+ return {
+ start: function start(callback) {
+ var onComplete = function onComplete(result) {
+ if (!result.finished) {
+ callback && callback(result);
+ return;
+ }
+
+ current++;
+
+ if (current === animations.length) {
+ callback && callback(result);
+ return;
+ }
+
+ animations[current].start(onComplete);
+ };
+
+ if (animations.length === 0) {
+ callback && callback({
+ finished: true
+ });
+ } else {
+ animations[current].start(onComplete);
+ }
+ },
+ stop: function stop() {
+ if (current < animations.length) {
+ animations[current].stop();
+ }
+ },
+ reset: function reset() {
+ animations.forEach(function (animation, idx) {
+ if (idx <= current) {
+ animation.reset();
+ }
+ });
+ current = 0;
+ },
+ _startNativeLoop: function _startNativeLoop() {
+ throw new Error('Loops run using the native driver cannot contain Animated.sequence animations');
+ },
+ _isUsingNativeDriver: function _isUsingNativeDriver() {
+ return false;
+ }
+ };
+ };
+
+ var parallel = function parallel(animations, config) {
+ var doneCount = 0;
+ var hasEnded = {};
+ var stopTogether = !(config && config.stopTogether === false);
+ var result = {
+ start: function start(callback) {
+ if (doneCount === animations.length) {
+ callback && callback({
+ finished: true
+ });
+ return;
+ }
+
+ animations.forEach(function (animation, idx) {
+ var cb = function cb(endResult) {
+ hasEnded[idx] = true;
+ doneCount++;
+
+ if (doneCount === animations.length) {
+ doneCount = 0;
+ callback && callback(endResult);
+ return;
+ }
+
+ if (!endResult.finished && stopTogether) {
+ result.stop();
+ }
+ };
+
+ if (!animation) {
+ cb({
+ finished: true
+ });
+ } else {
+ animation.start(cb);
+ }
+ });
+ },
+ stop: function stop() {
+ animations.forEach(function (animation, idx) {
+ !hasEnded[idx] && animation.stop();
+ hasEnded[idx] = true;
+ });
+ },
+ reset: function reset() {
+ animations.forEach(function (animation, idx) {
+ animation.reset();
+ hasEnded[idx] = false;
+ doneCount = 0;
+ });
+ },
+ _startNativeLoop: function _startNativeLoop() {
+ throw new Error('Loops run using the native driver cannot contain Animated.parallel animations');
+ },
+ _isUsingNativeDriver: function _isUsingNativeDriver() {
+ return false;
+ }
+ };
+ return result;
+ };
+
+ var delay = function delay(time) {
+ return timing(new AnimatedValue(0), {
+ toValue: 0,
+ delay: time,
+ duration: 0
+ });
+ };
+
+ 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,
+ Event: AnimatedEvent,
+ __PropsOnlyForTests: AnimatedProps
+ };
+},247,[32,239,248,249,250,241,251,252,242,253,256,257,240,258,259,261,263,266],"node_modules\\react-native\\Libraries\\Animated\\src\\AnimatedImplementation.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _get = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/get");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var AnimatedInterpolation = _$$_REQUIRE(_dependencyMap[6], "./AnimatedInterpolation");
+
+ var AnimatedNode = _$$_REQUIRE(_dependencyMap[7], "./AnimatedNode");
+
+ var AnimatedValue = _$$_REQUIRE(_dependencyMap[8], "./AnimatedValue");
+
+ var AnimatedWithChildren = _$$_REQUIRE(_dependencyMap[9], "./AnimatedWithChildren");
+
+ var AnimatedAddition = function (_AnimatedWithChildren) {
+ _inherits(AnimatedAddition, _AnimatedWithChildren);
+
+ function AnimatedAddition(a, b) {
+ var _this;
+
+ _classCallCheck(this, AnimatedAddition);
+
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(AnimatedAddition).call(this));
+ _this._a = typeof a === 'number' ? new AnimatedValue(a) : a;
+ _this._b = typeof b === 'number' ? new AnimatedValue(b) : b;
+ return _this;
+ }
+
+ _createClass(AnimatedAddition, [{
+ key: "__makeNative",
+ value: function __makeNative() {
+ this._a.__makeNative();
+
+ this._b.__makeNative();
+
+ _get(_getPrototypeOf(AnimatedAddition.prototype), "__makeNative", this).call(this);
+ }
+ }, {
+ key: "__getValue",
+ value: function __getValue() {
+ return this._a.__getValue() + this._b.__getValue();
+ }
+ }, {
+ key: "interpolate",
+ value: function interpolate(config) {
+ return new AnimatedInterpolation(this, config);
+ }
+ }, {
+ key: "__attach",
+ value: function __attach() {
+ this._a.__addChild(this);
+
+ this._b.__addChild(this);
+ }
+ }, {
+ key: "__detach",
+ value: function __detach() {
+ this._a.__removeChild(this);
+
+ this._b.__removeChild(this);
+
+ _get(_getPrototypeOf(AnimatedAddition.prototype), "__detach", this).call(this);
+ }
+ }, {
+ key: "__getNativeConfig",
+ value: function __getNativeConfig() {
+ return {
+ type: 'addition',
+ input: [this._a.__getNativeTag(), this._b.__getNativeTag()]
+ };
+ }
+ }]);
+
+ return AnimatedAddition;
+ }(AnimatedWithChildren);
+
+ module.exports = AnimatedAddition;
+},248,[3,4,5,8,25,9,241,242,240,244],"node_modules\\react-native\\Libraries\\Animated\\src\\nodes\\AnimatedAddition.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _get = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/get");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var AnimatedInterpolation = _$$_REQUIRE(_dependencyMap[6], "./AnimatedInterpolation");
+
+ var AnimatedNode = _$$_REQUIRE(_dependencyMap[7], "./AnimatedNode");
+
+ var AnimatedWithChildren = _$$_REQUIRE(_dependencyMap[8], "./AnimatedWithChildren");
+
+ var AnimatedDiffClamp = function (_AnimatedWithChildren) {
+ _inherits(AnimatedDiffClamp, _AnimatedWithChildren);
+
+ function AnimatedDiffClamp(a, min, max) {
+ var _this;
+
+ _classCallCheck(this, AnimatedDiffClamp);
+
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(AnimatedDiffClamp).call(this));
+ _this._a = a;
+ _this._min = min;
+ _this._max = max;
+ _this._value = _this._lastValue = _this._a.__getValue();
+ return _this;
+ }
+
+ _createClass(AnimatedDiffClamp, [{
+ key: "__makeNative",
+ value: function __makeNative() {
+ this._a.__makeNative();
+
+ _get(_getPrototypeOf(AnimatedDiffClamp.prototype), "__makeNative", this).call(this);
+ }
+ }, {
+ key: "interpolate",
+ value: function interpolate(config) {
+ return new AnimatedInterpolation(this, config);
+ }
+ }, {
+ key: "__getValue",
+ value: function __getValue() {
+ var value = this._a.__getValue();
+
+ var diff = value - this._lastValue;
+ this._lastValue = value;
+ this._value = Math.min(Math.max(this._value + diff, this._min), this._max);
+ return this._value;
+ }
+ }, {
+ key: "__attach",
+ value: function __attach() {
+ this._a.__addChild(this);
+ }
+ }, {
+ key: "__detach",
+ value: function __detach() {
+ this._a.__removeChild(this);
+
+ _get(_getPrototypeOf(AnimatedDiffClamp.prototype), "__detach", this).call(this);
+ }
+ }, {
+ key: "__getNativeConfig",
+ value: function __getNativeConfig() {
+ return {
+ type: 'diffclamp',
+ input: this._a.__getNativeTag(),
+ min: this._min,
+ max: this._max
+ };
+ }
+ }]);
+
+ return AnimatedDiffClamp;
+ }(AnimatedWithChildren);
+
+ module.exports = AnimatedDiffClamp;
+},249,[3,4,5,8,25,9,241,242,244],"node_modules\\react-native\\Libraries\\Animated\\src\\nodes\\AnimatedDiffClamp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _get = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/get");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var AnimatedInterpolation = _$$_REQUIRE(_dependencyMap[6], "./AnimatedInterpolation");
+
+ var AnimatedNode = _$$_REQUIRE(_dependencyMap[7], "./AnimatedNode");
+
+ var AnimatedValue = _$$_REQUIRE(_dependencyMap[8], "./AnimatedValue");
+
+ var AnimatedWithChildren = _$$_REQUIRE(_dependencyMap[9], "./AnimatedWithChildren");
+
+ var AnimatedDivision = function (_AnimatedWithChildren) {
+ _inherits(AnimatedDivision, _AnimatedWithChildren);
+
+ function AnimatedDivision(a, b) {
+ var _this;
+
+ _classCallCheck(this, AnimatedDivision);
+
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(AnimatedDivision).call(this));
+ _this._a = typeof a === 'number' ? new AnimatedValue(a) : a;
+ _this._b = typeof b === 'number' ? new AnimatedValue(b) : b;
+ return _this;
+ }
+
+ _createClass(AnimatedDivision, [{
+ key: "__makeNative",
+ value: function __makeNative() {
+ this._a.__makeNative();
+
+ this._b.__makeNative();
+
+ _get(_getPrototypeOf(AnimatedDivision.prototype), "__makeNative", this).call(this);
+ }
+ }, {
+ key: "__getValue",
+ value: function __getValue() {
+ var a = this._a.__getValue();
+
+ var b = this._b.__getValue();
+
+ if (b === 0) {
+ console.error('Detected division by zero in AnimatedDivision');
+ }
+
+ return a / b;
+ }
+ }, {
+ key: "interpolate",
+ value: function interpolate(config) {
+ return new AnimatedInterpolation(this, config);
+ }
+ }, {
+ key: "__attach",
+ value: function __attach() {
+ this._a.__addChild(this);
+
+ this._b.__addChild(this);
+ }
+ }, {
+ key: "__detach",
+ value: function __detach() {
+ this._a.__removeChild(this);
+
+ this._b.__removeChild(this);
+
+ _get(_getPrototypeOf(AnimatedDivision.prototype), "__detach", this).call(this);
+ }
+ }, {
+ key: "__getNativeConfig",
+ value: function __getNativeConfig() {
+ return {
+ type: 'division',
+ input: [this._a.__getNativeTag(), this._b.__getNativeTag()]
+ };
+ }
+ }]);
+
+ return AnimatedDivision;
+ }(AnimatedWithChildren);
+
+ module.exports = AnimatedDivision;
+},250,[3,4,5,8,25,9,241,242,240,244],"node_modules\\react-native\\Libraries\\Animated\\src\\nodes\\AnimatedDivision.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _get = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/get");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var AnimatedInterpolation = _$$_REQUIRE(_dependencyMap[6], "./AnimatedInterpolation");
+
+ var AnimatedNode = _$$_REQUIRE(_dependencyMap[7], "./AnimatedNode");
+
+ var AnimatedWithChildren = _$$_REQUIRE(_dependencyMap[8], "./AnimatedWithChildren");
+
+ var AnimatedModulo = function (_AnimatedWithChildren) {
+ _inherits(AnimatedModulo, _AnimatedWithChildren);
+
+ function AnimatedModulo(a, modulus) {
+ var _this;
+
+ _classCallCheck(this, AnimatedModulo);
+
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(AnimatedModulo).call(this));
+ _this._a = a;
+ _this._modulus = modulus;
+ return _this;
+ }
+
+ _createClass(AnimatedModulo, [{
+ key: "__makeNative",
+ value: function __makeNative() {
+ this._a.__makeNative();
+
+ _get(_getPrototypeOf(AnimatedModulo.prototype), "__makeNative", this).call(this);
+ }
+ }, {
+ key: "__getValue",
+ value: function __getValue() {
+ return (this._a.__getValue() % this._modulus + this._modulus) % this._modulus;
+ }
+ }, {
+ key: "interpolate",
+ value: function interpolate(config) {
+ return new AnimatedInterpolation(this, config);
+ }
+ }, {
+ key: "__attach",
+ value: function __attach() {
+ this._a.__addChild(this);
+ }
+ }, {
+ key: "__detach",
+ value: function __detach() {
+ this._a.__removeChild(this);
+
+ _get(_getPrototypeOf(AnimatedModulo.prototype), "__detach", this).call(this);
+ }
+ }, {
+ key: "__getNativeConfig",
+ value: function __getNativeConfig() {
+ return {
+ type: 'modulus',
+ input: this._a.__getNativeTag(),
+ modulus: this._modulus
+ };
+ }
+ }]);
+
+ return AnimatedModulo;
+ }(AnimatedWithChildren);
+
+ module.exports = AnimatedModulo;
+},251,[3,4,5,8,25,9,241,242,244],"node_modules\\react-native\\Libraries\\Animated\\src\\nodes\\AnimatedModulo.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _get = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/get");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var AnimatedInterpolation = _$$_REQUIRE(_dependencyMap[6], "./AnimatedInterpolation");
+
+ var AnimatedNode = _$$_REQUIRE(_dependencyMap[7], "./AnimatedNode");
+
+ var AnimatedValue = _$$_REQUIRE(_dependencyMap[8], "./AnimatedValue");
+
+ var AnimatedWithChildren = _$$_REQUIRE(_dependencyMap[9], "./AnimatedWithChildren");
+
+ var AnimatedMultiplication = function (_AnimatedWithChildren) {
+ _inherits(AnimatedMultiplication, _AnimatedWithChildren);
+
+ function AnimatedMultiplication(a, b) {
+ var _this;
+
+ _classCallCheck(this, AnimatedMultiplication);
+
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(AnimatedMultiplication).call(this));
+ _this._a = typeof a === 'number' ? new AnimatedValue(a) : a;
+ _this._b = typeof b === 'number' ? new AnimatedValue(b) : b;
+ return _this;
+ }
+
+ _createClass(AnimatedMultiplication, [{
+ key: "__makeNative",
+ value: function __makeNative() {
+ this._a.__makeNative();
+
+ this._b.__makeNative();
+
+ _get(_getPrototypeOf(AnimatedMultiplication.prototype), "__makeNative", this).call(this);
+ }
+ }, {
+ key: "__getValue",
+ value: function __getValue() {
+ return this._a.__getValue() * this._b.__getValue();
+ }
+ }, {
+ key: "interpolate",
+ value: function interpolate(config) {
+ return new AnimatedInterpolation(this, config);
+ }
+ }, {
+ key: "__attach",
+ value: function __attach() {
+ this._a.__addChild(this);
+
+ this._b.__addChild(this);
+ }
+ }, {
+ key: "__detach",
+ value: function __detach() {
+ this._a.__removeChild(this);
+
+ this._b.__removeChild(this);
+
+ _get(_getPrototypeOf(AnimatedMultiplication.prototype), "__detach", this).call(this);
+ }
+ }, {
+ key: "__getNativeConfig",
+ value: function __getNativeConfig() {
+ return {
+ type: 'multiplication',
+ input: [this._a.__getNativeTag(), this._b.__getNativeTag()]
+ };
+ }
+ }]);
+
+ return AnimatedMultiplication;
+ }(AnimatedWithChildren);
+
+ module.exports = AnimatedMultiplication;
+},252,[3,4,5,8,25,9,241,242,240,244],"node_modules\\react-native\\Libraries\\Animated\\src\\nodes\\AnimatedMultiplication.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _get = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/get");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var _require = _$$_REQUIRE(_dependencyMap[7], "../AnimatedEvent"),
+ AnimatedEvent = _require.AnimatedEvent;
+
+ var AnimatedNode = _$$_REQUIRE(_dependencyMap[8], "./AnimatedNode");
+
+ var AnimatedStyle = _$$_REQUIRE(_dependencyMap[9], "./AnimatedStyle");
+
+ var NativeAnimatedHelper = _$$_REQUIRE(_dependencyMap[10], "../NativeAnimatedHelper");
+
+ var ReactNative = _$$_REQUIRE(_dependencyMap[11], "ReactNative");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[12], "invariant");
+
+ var AnimatedProps = function (_AnimatedNode) {
+ _inherits(AnimatedProps, _AnimatedNode);
+
+ function AnimatedProps(props, callback) {
+ var _this;
+
+ _classCallCheck(this, AnimatedProps);
+
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(AnimatedProps).call(this));
+
+ if (props.style) {
+ props = _objectSpread({}, props, {
+ style: new AnimatedStyle(props.style)
+ });
+ }
+
+ _this._props = props;
+ _this._callback = callback;
+
+ _this.__attach();
+
+ return _this;
+ }
+
+ _createClass(AnimatedProps, [{
+ key: "__getValue",
+ value: function __getValue() {
+ var props = {};
+
+ for (var key in this._props) {
+ var value = this._props[key];
+
+ if (value instanceof AnimatedNode) {
+ if (!value.__isNative || value instanceof AnimatedStyle) {
+ props[key] = value.__getValue();
+ }
+ } else if (value instanceof AnimatedEvent) {
+ props[key] = value.__getHandler();
+ } else {
+ props[key] = value;
+ }
+ }
+
+ return props;
+ }
+ }, {
+ key: "__getAnimatedValue",
+ value: function __getAnimatedValue() {
+ var props = {};
+
+ for (var key in this._props) {
+ var value = this._props[key];
+
+ if (value instanceof AnimatedNode) {
+ props[key] = value.__getAnimatedValue();
+ }
+ }
+
+ return props;
+ }
+ }, {
+ key: "__attach",
+ value: function __attach() {
+ for (var key in this._props) {
+ var value = this._props[key];
+
+ if (value instanceof AnimatedNode) {
+ value.__addChild(this);
+ }
+ }
+ }
+ }, {
+ key: "__detach",
+ value: function __detach() {
+ if (this.__isNative && this._animatedView) {
+ this.__disconnectAnimatedView();
+ }
+
+ for (var key in this._props) {
+ var value = this._props[key];
+
+ if (value instanceof AnimatedNode) {
+ value.__removeChild(this);
+ }
+ }
+
+ _get(_getPrototypeOf(AnimatedProps.prototype), "__detach", this).call(this);
+ }
+ }, {
+ key: "update",
+ value: function update() {
+ this._callback();
+ }
+ }, {
+ key: "__makeNative",
+ value: function __makeNative() {
+ if (!this.__isNative) {
+ this.__isNative = true;
+
+ for (var key in this._props) {
+ var value = this._props[key];
+
+ if (value instanceof AnimatedNode) {
+ value.__makeNative();
+ }
+ }
+
+ if (this._animatedView) {
+ this.__connectAnimatedView();
+ }
+ }
+ }
+ }, {
+ key: "setNativeView",
+ value: function setNativeView(animatedView) {
+ if (this._animatedView === animatedView) {
+ return;
+ }
+
+ this._animatedView = animatedView;
+
+ if (this.__isNative) {
+ this.__connectAnimatedView();
+ }
+ }
+ }, {
+ key: "__connectAnimatedView",
+ value: function __connectAnimatedView() {
+ invariant(this.__isNative, 'Expected node to be marked as "native"');
+ var nativeViewTag = ReactNative.findNodeHandle(this._animatedView);
+ invariant(nativeViewTag != null, 'Unable to locate attached view in the native tree');
+ NativeAnimatedHelper.API.connectAnimatedNodeToView(this.__getNativeTag(), nativeViewTag);
+ }
+ }, {
+ key: "__disconnectAnimatedView",
+ value: function __disconnectAnimatedView() {
+ invariant(this.__isNative, 'Expected node to be marked as "native"');
+ var nativeViewTag = ReactNative.findNodeHandle(this._animatedView);
+ invariant(nativeViewTag != null, 'Unable to locate attached view in the native tree');
+ NativeAnimatedHelper.API.disconnectAnimatedNodeFromView(this.__getNativeTag(), nativeViewTag);
+ }
+ }, {
+ key: "__getNativeConfig",
+ value: function __getNativeConfig() {
+ var propsConfig = {};
+
+ for (var propKey in this._props) {
+ var value = this._props[propKey];
+
+ if (value instanceof AnimatedNode) {
+ propsConfig[propKey] = value.__getNativeTag();
+ }
+ }
+
+ return {
+ type: 'props',
+ props: propsConfig
+ };
+ }
+ }]);
+
+ return AnimatedProps;
+ }(AnimatedNode);
+
+ module.exports = AnimatedProps;
+},253,[32,3,4,5,8,25,9,239,242,254,243,84,19],"node_modules\\react-native\\Libraries\\Animated\\src\\nodes\\AnimatedProps.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _get = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/get");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var AnimatedNode = _$$_REQUIRE(_dependencyMap[7], "./AnimatedNode");
+
+ var AnimatedTransform = _$$_REQUIRE(_dependencyMap[8], "./AnimatedTransform");
+
+ var AnimatedWithChildren = _$$_REQUIRE(_dependencyMap[9], "./AnimatedWithChildren");
+
+ var NativeAnimatedHelper = _$$_REQUIRE(_dependencyMap[10], "../NativeAnimatedHelper");
+
+ var flattenStyle = _$$_REQUIRE(_dependencyMap[11], "flattenStyle");
+
+ var AnimatedStyle = function (_AnimatedWithChildren) {
+ _inherits(AnimatedStyle, _AnimatedWithChildren);
+
+ function AnimatedStyle(style) {
+ var _this;
+
+ _classCallCheck(this, AnimatedStyle);
+
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(AnimatedStyle).call(this));
+ style = flattenStyle(style) || {};
+
+ if (style.transform) {
+ style = _objectSpread({}, style, {
+ transform: new AnimatedTransform(style.transform)
+ });
+ }
+
+ _this._style = style;
+ return _this;
+ }
+
+ _createClass(AnimatedStyle, [{
+ key: "_walkStyleAndGetValues",
+ value: function _walkStyleAndGetValues(style) {
+ var updatedStyle = {};
+
+ for (var key in style) {
+ var value = style[key];
+
+ if (value instanceof AnimatedNode) {
+ if (!value.__isNative) {
+ updatedStyle[key] = value.__getValue();
+ }
+ } else if (value && !Array.isArray(value) && typeof value === 'object') {
+ updatedStyle[key] = this._walkStyleAndGetValues(value);
+ } else {
+ updatedStyle[key] = value;
+ }
+ }
+
+ return updatedStyle;
+ }
+ }, {
+ key: "__getValue",
+ value: function __getValue() {
+ return this._walkStyleAndGetValues(this._style);
+ }
+ }, {
+ key: "_walkStyleAndGetAnimatedValues",
+ value: function _walkStyleAndGetAnimatedValues(style) {
+ var updatedStyle = {};
+
+ for (var key in style) {
+ var value = style[key];
+
+ if (value instanceof AnimatedNode) {
+ updatedStyle[key] = value.__getAnimatedValue();
+ } else if (value && !Array.isArray(value) && typeof value === 'object') {
+ updatedStyle[key] = this._walkStyleAndGetAnimatedValues(value);
+ }
+ }
+
+ return updatedStyle;
+ }
+ }, {
+ key: "__getAnimatedValue",
+ value: function __getAnimatedValue() {
+ return this._walkStyleAndGetAnimatedValues(this._style);
+ }
+ }, {
+ key: "__attach",
+ value: function __attach() {
+ for (var key in this._style) {
+ var value = this._style[key];
+
+ if (value instanceof AnimatedNode) {
+ value.__addChild(this);
+ }
+ }
+ }
+ }, {
+ key: "__detach",
+ value: function __detach() {
+ for (var key in this._style) {
+ var value = this._style[key];
+
+ if (value instanceof AnimatedNode) {
+ value.__removeChild(this);
+ }
+ }
+
+ _get(_getPrototypeOf(AnimatedStyle.prototype), "__detach", this).call(this);
+ }
+ }, {
+ key: "__makeNative",
+ value: function __makeNative() {
+ for (var key in this._style) {
+ var value = this._style[key];
+
+ if (value instanceof AnimatedNode) {
+ value.__makeNative();
+ }
+ }
+
+ _get(_getPrototypeOf(AnimatedStyle.prototype), "__makeNative", this).call(this);
+ }
+ }, {
+ key: "__getNativeConfig",
+ value: function __getNativeConfig() {
+ var styleConfig = {};
+
+ for (var styleKey in this._style) {
+ if (this._style[styleKey] instanceof AnimatedNode) {
+ styleConfig[styleKey] = this._style[styleKey].__getNativeTag();
+ }
+ }
+
+ NativeAnimatedHelper.validateStyles(styleConfig);
+ return {
+ type: 'style',
+ style: styleConfig
+ };
+ }
+ }]);
+
+ return AnimatedStyle;
+ }(AnimatedWithChildren);
+
+ module.exports = AnimatedStyle;
+},254,[32,3,4,5,8,25,9,242,255,244,243,80],"node_modules\\react-native\\Libraries\\Animated\\src\\nodes\\AnimatedStyle.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _get = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/get");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var AnimatedNode = _$$_REQUIRE(_dependencyMap[6], "./AnimatedNode");
+
+ var AnimatedWithChildren = _$$_REQUIRE(_dependencyMap[7], "./AnimatedWithChildren");
+
+ var NativeAnimatedHelper = _$$_REQUIRE(_dependencyMap[8], "../NativeAnimatedHelper");
+
+ var AnimatedTransform = function (_AnimatedWithChildren) {
+ _inherits(AnimatedTransform, _AnimatedWithChildren);
+
+ function AnimatedTransform(transforms) {
+ var _this;
+
+ _classCallCheck(this, AnimatedTransform);
+
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(AnimatedTransform).call(this));
+ _this._transforms = transforms;
+ return _this;
+ }
+
+ _createClass(AnimatedTransform, [{
+ key: "__makeNative",
+ value: function __makeNative() {
+ this._transforms.forEach(function (transform) {
+ for (var key in transform) {
+ var value = transform[key];
+
+ if (value instanceof AnimatedNode) {
+ value.__makeNative();
+ }
+ }
+ });
+
+ _get(_getPrototypeOf(AnimatedTransform.prototype), "__makeNative", this).call(this);
+ }
+ }, {
+ key: "__getValue",
+ value: function __getValue() {
+ return this._transforms.map(function (transform) {
+ var result = {};
+
+ for (var key in transform) {
+ var value = transform[key];
+
+ if (value instanceof AnimatedNode) {
+ result[key] = value.__getValue();
+ } else {
+ result[key] = value;
+ }
+ }
+
+ return result;
+ });
+ }
+ }, {
+ key: "__getAnimatedValue",
+ value: function __getAnimatedValue() {
+ return this._transforms.map(function (transform) {
+ var result = {};
+
+ for (var key in transform) {
+ var value = transform[key];
+
+ if (value instanceof AnimatedNode) {
+ result[key] = value.__getAnimatedValue();
+ } else {
+ result[key] = value;
+ }
+ }
+
+ return result;
+ });
+ }
+ }, {
+ key: "__attach",
+ value: function __attach() {
+ var _this2 = this;
+
+ this._transforms.forEach(function (transform) {
+ for (var key in transform) {
+ var value = transform[key];
+
+ if (value instanceof AnimatedNode) {
+ value.__addChild(_this2);
+ }
+ }
+ });
+ }
+ }, {
+ key: "__detach",
+ value: function __detach() {
+ var _this3 = this;
+
+ this._transforms.forEach(function (transform) {
+ for (var key in transform) {
+ var value = transform[key];
+
+ if (value instanceof AnimatedNode) {
+ value.__removeChild(_this3);
+ }
+ }
+ });
+
+ _get(_getPrototypeOf(AnimatedTransform.prototype), "__detach", this).call(this);
+ }
+ }, {
+ key: "__getNativeConfig",
+ value: function __getNativeConfig() {
+ var transConfigs = [];
+
+ this._transforms.forEach(function (transform) {
+ for (var key in transform) {
+ var value = transform[key];
+
+ if (value instanceof AnimatedNode) {
+ transConfigs.push({
+ type: 'animated',
+ property: key,
+ nodeTag: value.__getNativeTag()
+ });
+ } else {
+ transConfigs.push({
+ type: 'static',
+ property: key,
+ value: NativeAnimatedHelper.transformDataType(value)
+ });
+ }
+ }
+ });
+
+ NativeAnimatedHelper.validateTransform(transConfigs);
+ return {
+ type: 'transform',
+ transforms: transConfigs
+ };
+ }
+ }]);
+
+ return AnimatedTransform;
+ }(AnimatedWithChildren);
+
+ module.exports = AnimatedTransform;
+},255,[3,4,5,8,25,9,242,244,243],"node_modules\\react-native\\Libraries\\Animated\\src\\nodes\\AnimatedTransform.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _get = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/get");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var AnimatedInterpolation = _$$_REQUIRE(_dependencyMap[6], "./AnimatedInterpolation");
+
+ var AnimatedNode = _$$_REQUIRE(_dependencyMap[7], "./AnimatedNode");
+
+ var AnimatedValue = _$$_REQUIRE(_dependencyMap[8], "./AnimatedValue");
+
+ var AnimatedWithChildren = _$$_REQUIRE(_dependencyMap[9], "./AnimatedWithChildren");
+
+ var AnimatedSubtraction = function (_AnimatedWithChildren) {
+ _inherits(AnimatedSubtraction, _AnimatedWithChildren);
+
+ function AnimatedSubtraction(a, b) {
+ var _this;
+
+ _classCallCheck(this, AnimatedSubtraction);
+
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(AnimatedSubtraction).call(this));
+ _this._a = typeof a === 'number' ? new AnimatedValue(a) : a;
+ _this._b = typeof b === 'number' ? new AnimatedValue(b) : b;
+ return _this;
+ }
+
+ _createClass(AnimatedSubtraction, [{
+ key: "__makeNative",
+ value: function __makeNative() {
+ this._a.__makeNative();
+
+ this._b.__makeNative();
+
+ _get(_getPrototypeOf(AnimatedSubtraction.prototype), "__makeNative", this).call(this);
+ }
+ }, {
+ key: "__getValue",
+ value: function __getValue() {
+ return this._a.__getValue() - this._b.__getValue();
+ }
+ }, {
+ key: "interpolate",
+ value: function interpolate(config) {
+ return new AnimatedInterpolation(this, config);
+ }
+ }, {
+ key: "__attach",
+ value: function __attach() {
+ this._a.__addChild(this);
+
+ this._b.__addChild(this);
+ }
+ }, {
+ key: "__detach",
+ value: function __detach() {
+ this._a.__removeChild(this);
+
+ this._b.__removeChild(this);
+
+ _get(_getPrototypeOf(AnimatedSubtraction.prototype), "__detach", this).call(this);
+ }
+ }, {
+ key: "__getNativeConfig",
+ value: function __getNativeConfig() {
+ return {
+ type: 'subtraction',
+ input: [this._a.__getNativeTag(), this._b.__getNativeTag()]
+ };
+ }
+ }]);
+
+ return AnimatedSubtraction;
+ }(AnimatedWithChildren);
+
+ module.exports = AnimatedSubtraction;
+},256,[3,4,5,8,25,9,241,242,240,244],"node_modules\\react-native\\Libraries\\Animated\\src\\nodes\\AnimatedSubtraction.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _get = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/get");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var AnimatedValue = _$$_REQUIRE(_dependencyMap[7], "./AnimatedValue");
+
+ var AnimatedNode = _$$_REQUIRE(_dependencyMap[8], "./AnimatedNode");
+
+ var _require = _$$_REQUIRE(_dependencyMap[9], "../NativeAnimatedHelper"),
+ generateNewAnimationId = _require.generateNewAnimationId,
+ shouldUseNativeDriver = _require.shouldUseNativeDriver;
+
+ var AnimatedTracking = function (_AnimatedNode) {
+ _inherits(AnimatedTracking, _AnimatedNode);
+
+ function AnimatedTracking(value, parent, animationClass, animationConfig, callback) {
+ var _this;
+
+ _classCallCheck(this, AnimatedTracking);
+
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(AnimatedTracking).call(this));
+ _this._value = value;
+ _this._parent = parent;
+ _this._animationClass = animationClass;
+ _this._animationConfig = animationConfig;
+ _this._useNativeDriver = shouldUseNativeDriver(animationConfig);
+ _this._callback = callback;
+
+ _this.__attach();
+
+ return _this;
+ }
+
+ _createClass(AnimatedTracking, [{
+ key: "__makeNative",
+ value: function __makeNative() {
+ this.__isNative = true;
+
+ this._parent.__makeNative();
+
+ _get(_getPrototypeOf(AnimatedTracking.prototype), "__makeNative", this).call(this);
+
+ this._value.__makeNative();
+ }
+ }, {
+ key: "__getValue",
+ value: function __getValue() {
+ return this._parent.__getValue();
+ }
+ }, {
+ key: "__attach",
+ value: function __attach() {
+ this._parent.__addChild(this);
+
+ if (this._useNativeDriver) {
+ this.__makeNative();
+ }
+ }
+ }, {
+ key: "__detach",
+ value: function __detach() {
+ this._parent.__removeChild(this);
+
+ _get(_getPrototypeOf(AnimatedTracking.prototype), "__detach", this).call(this);
+ }
+ }, {
+ key: "update",
+ value: function update() {
+ this._value.animate(new this._animationClass(_objectSpread({}, this._animationConfig, {
+ toValue: this._animationConfig.toValue.__getValue()
+ })), this._callback);
+ }
+ }, {
+ key: "__getNativeConfig",
+ value: function __getNativeConfig() {
+ var animation = new this._animationClass(_objectSpread({}, this._animationConfig, {
+ toValue: undefined
+ }));
+
+ var animationConfig = animation.__getNativeAnimationConfig();
+
+ return {
+ type: 'tracking',
+ animationId: generateNewAnimationId(),
+ animationConfig: animationConfig,
+ toValue: this._parent.__getNativeTag(),
+ value: this._value.__getNativeTag()
+ };
+ }
+ }]);
+
+ return AnimatedTracking;
+ }(AnimatedNode);
+
+ module.exports = AnimatedTracking;
+},257,[32,3,4,5,8,25,9,240,242,243],"node_modules\\react-native\\Libraries\\Animated\\src\\nodes\\AnimatedTracking.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var AnimatedValue = _$$_REQUIRE(_dependencyMap[5], "./AnimatedValue");
+
+ var AnimatedWithChildren = _$$_REQUIRE(_dependencyMap[6], "./AnimatedWithChildren");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[7], "invariant");
+
+ var _uniqueId = 1;
+
+ var AnimatedValueXY = function (_AnimatedWithChildren) {
+ _inherits(AnimatedValueXY, _AnimatedWithChildren);
+
+ function AnimatedValueXY(valueIn) {
+ var _this;
+
+ _classCallCheck(this, AnimatedValueXY);
+
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(AnimatedValueXY).call(this));
+ var value = valueIn || {
+ x: 0,
+ y: 0
+ };
+
+ if (typeof value.x === 'number' && typeof value.y === 'number') {
+ _this.x = new AnimatedValue(value.x);
+ _this.y = new AnimatedValue(value.y);
+ } else {
+ invariant(value.x instanceof AnimatedValue && value.y instanceof AnimatedValue, 'AnimatedValueXY must be initialized with an object of numbers or ' + 'AnimatedValues.');
+ _this.x = value.x;
+ _this.y = value.y;
+ }
+
+ _this._listeners = {};
+ return _this;
+ }
+
+ _createClass(AnimatedValueXY, [{
+ key: "setValue",
+ value: function setValue(value) {
+ this.x.setValue(value.x);
+ this.y.setValue(value.y);
+ }
+ }, {
+ key: "setOffset",
+ value: function setOffset(offset) {
+ this.x.setOffset(offset.x);
+ this.y.setOffset(offset.y);
+ }
+ }, {
+ key: "flattenOffset",
+ value: function flattenOffset() {
+ this.x.flattenOffset();
+ this.y.flattenOffset();
+ }
+ }, {
+ key: "extractOffset",
+ value: function extractOffset() {
+ this.x.extractOffset();
+ this.y.extractOffset();
+ }
+ }, {
+ key: "__getValue",
+ value: function __getValue() {
+ return {
+ x: this.x.__getValue(),
+ y: this.y.__getValue()
+ };
+ }
+ }, {
+ key: "resetAnimation",
+ value: function resetAnimation(callback) {
+ this.x.resetAnimation();
+ this.y.resetAnimation();
+ callback && callback(this.__getValue());
+ }
+ }, {
+ key: "stopAnimation",
+ value: function stopAnimation(callback) {
+ this.x.stopAnimation();
+ this.y.stopAnimation();
+ callback && callback(this.__getValue());
+ }
+ }, {
+ key: "addListener",
+ value: function addListener(callback) {
+ var _this2 = this;
+
+ var id = String(_uniqueId++);
+
+ var jointCallback = function jointCallback(_ref) {
+ var number = _ref.value;
+ callback(_this2.__getValue());
+ };
+
+ this._listeners[id] = {
+ x: this.x.addListener(jointCallback),
+ y: this.y.addListener(jointCallback)
+ };
+ return id;
+ }
+ }, {
+ key: "removeListener",
+ value: function removeListener(id) {
+ this.x.removeListener(this._listeners[id].x);
+ this.y.removeListener(this._listeners[id].y);
+ delete this._listeners[id];
+ }
+ }, {
+ key: "removeAllListeners",
+ value: function removeAllListeners() {
+ this.x.removeAllListeners();
+ this.y.removeAllListeners();
+ this._listeners = {};
+ }
+ }, {
+ key: "getLayout",
+ value: function getLayout() {
+ return {
+ left: this.x,
+ top: this.y
+ };
+ }
+ }, {
+ key: "getTranslateTransform",
+ value: function getTranslateTransform() {
+ return [{
+ translateX: this.x
+ }, {
+ translateY: this.y
+ }];
+ }
+ }]);
+
+ return AnimatedValueXY;
+ }(AnimatedWithChildren);
+
+ module.exports = AnimatedValueXY;
+},258,[3,4,5,8,9,240,244,19],"node_modules\\react-native\\Libraries\\Animated\\src\\nodes\\AnimatedValueXY.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _get = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/get");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var Animation = _$$_REQUIRE(_dependencyMap[6], "./Animation");
+
+ var _require = _$$_REQUIRE(_dependencyMap[7], "../NativeAnimatedHelper"),
+ shouldUseNativeDriver = _require.shouldUseNativeDriver;
+
+ var DecayAnimation = function (_Animation) {
+ _inherits(DecayAnimation, _Animation);
+
+ function DecayAnimation(config) {
+ var _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
+ });
+ }
+ }]);
+
+ return DecayAnimation;
+ }(Animation);
+
+ module.exports = DecayAnimation;
+},259,[3,4,5,8,25,9,260,243],"node_modules\\react-native\\Libraries\\Animated\\src\\animations\\DecayAnimation.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var NativeAnimatedHelper = _$$_REQUIRE(_dependencyMap[2], "NativeAnimatedHelper");
+
+ var Animation = function () {
+ function Animation() {
+ _classCallCheck(this, Animation);
+ }
+
+ _createClass(Animation, [{
+ key: "start",
+ value: function start(fromValue, onUpdate, onEnd, previousAnimation, animatedValue) {}
+ }, {
+ key: "stop",
+ value: function stop() {
+ if (this.__nativeId) {
+ NativeAnimatedHelper.API.stopAnimation(this.__nativeId);
+ }
+ }
+ }, {
+ key: "__getNativeAnimationConfig",
+ value: function __getNativeAnimationConfig() {
+ throw new Error('This animation type cannot be offloaded to native');
+ }
+ }, {
+ key: "__debouncedOnEnd",
+ value: function __debouncedOnEnd(result) {
+ var onEnd = this.__onEnd;
+ this.__onEnd = null;
+ onEnd && onEnd(result);
+ }
+ }, {
+ key: "__startNativeAnimation",
+ value: function __startNativeAnimation(animatedValue) {
+ animatedValue.__makeNative();
+
+ this.__nativeId = NativeAnimatedHelper.generateNewAnimationId();
+ NativeAnimatedHelper.API.startAnimatingNode(this.__nativeId, animatedValue.__getNativeTag(), this.__getNativeAnimationConfig(), this.__debouncedOnEnd.bind(this));
+ }
+ }]);
+
+ return Animation;
+ }();
+
+ module.exports = Animation;
+},260,[3,4,243],"node_modules\\react-native\\Libraries\\Animated\\src\\animations\\Animation.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _get = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/get");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var AnimatedValue = _$$_REQUIRE(_dependencyMap[6], "../nodes/AnimatedValue");
+
+ var AnimatedValueXY = _$$_REQUIRE(_dependencyMap[7], "../nodes/AnimatedValueXY");
+
+ var Animation = _$$_REQUIRE(_dependencyMap[8], "./Animation");
+
+ var SpringConfig = _$$_REQUIRE(_dependencyMap[9], "../SpringConfig");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[10], "invariant");
+
+ var _require = _$$_REQUIRE(_dependencyMap[11], "../NativeAnimatedHelper"),
+ shouldUseNativeDriver = _require.shouldUseNativeDriver;
+
+ function withDefault(value, defaultValue) {
+ if (value === undefined || value === null) {
+ return defaultValue;
+ }
+
+ return value;
+ }
+
+ var SpringAnimation = function (_Animation) {
+ _inherits(SpringAnimation, _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
+ });
+ }
+ }]);
+
+ return SpringAnimation;
+ }(Animation);
+
+ module.exports = SpringAnimation;
+},261,[3,4,5,8,25,9,240,258,260,262,19,243],"node_modules\\react-native\\Libraries\\Animated\\src\\animations\\SpringAnimation.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ function stiffnessFromOrigamiValue(oValue) {
+ return (oValue - 30) * 3.62 + 194;
+ }
+
+ function dampingFromOrigamiValue(oValue) {
+ return (oValue - 8) * 3 + 25;
+ }
+
+ function fromOrigamiTensionAndFriction(tension, friction) {
+ return {
+ stiffness: stiffnessFromOrigamiValue(tension),
+ damping: dampingFromOrigamiValue(friction)
+ };
+ }
+
+ function fromBouncinessAndSpeed(bounciness, speed) {
+ function normalize(value, startValue, endValue) {
+ return (value - startValue) / (endValue - startValue);
+ }
+
+ function projectNormal(n, start, end) {
+ return start + n * (end - start);
+ }
+
+ function linearInterpolation(t, start, end) {
+ return t * end + (1 - t) * start;
+ }
+
+ function quadraticOutInterpolation(t, start, end) {
+ return linearInterpolation(2 * t - t * t, start, end);
+ }
+
+ function b3Friction1(x) {
+ return 0.0007 * Math.pow(x, 3) - 0.031 * Math.pow(x, 2) + 0.64 * x + 1.28;
+ }
+
+ function b3Friction2(x) {
+ return 0.000044 * Math.pow(x, 3) - 0.006 * Math.pow(x, 2) + 0.36 * x + 2;
+ }
+
+ function b3Friction3(x) {
+ return 0.00000045 * Math.pow(x, 3) - 0.000332 * Math.pow(x, 2) + 0.1078 * x + 5.84;
+ }
+
+ function b3Nobounce(tension) {
+ if (tension <= 18) {
+ return b3Friction1(tension);
+ } else if (tension > 18 && tension <= 44) {
+ return b3Friction2(tension);
+ } else {
+ return b3Friction3(tension);
+ }
+ }
+
+ var b = normalize(bounciness / 1.7, 0, 20);
+ b = projectNormal(b, 0, 0.8);
+ var s = normalize(speed / 1.7, 0, 20);
+ var bouncyTension = projectNormal(s, 0.5, 200);
+ var bouncyFriction = quadraticOutInterpolation(b, b3Nobounce(bouncyTension), 0.01);
+ return {
+ stiffness: stiffnessFromOrigamiValue(bouncyTension),
+ damping: dampingFromOrigamiValue(bouncyFriction)
+ };
+ }
+
+ module.exports = {
+ fromOrigamiTensionAndFriction: fromOrigamiTensionAndFriction,
+ fromBouncinessAndSpeed: fromBouncinessAndSpeed
+ };
+},262,[],"node_modules\\react-native\\Libraries\\Animated\\src\\SpringConfig.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _get = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/get");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var AnimatedValue = _$$_REQUIRE(_dependencyMap[6], "../nodes/AnimatedValue");
+
+ var AnimatedValueXY = _$$_REQUIRE(_dependencyMap[7], "../nodes/AnimatedValueXY");
+
+ var Animation = _$$_REQUIRE(_dependencyMap[8], "./Animation");
+
+ var _require = _$$_REQUIRE(_dependencyMap[9], "../NativeAnimatedHelper"),
+ shouldUseNativeDriver = _require.shouldUseNativeDriver;
+
+ var _easeInOut;
+
+ function easeInOut() {
+ if (!_easeInOut) {
+ var Easing = _$$_REQUIRE(_dependencyMap[10], "Easing");
+
+ _easeInOut = Easing.inOut(Easing.ease);
+ }
+
+ return _easeInOut;
+ }
+
+ var TimingAnimation = function (_Animation) {
+ _inherits(TimingAnimation, _Animation);
+
+ function TimingAnimation(config) {
+ var _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
+ });
+ }
+ }]);
+
+ return TimingAnimation;
+ }(Animation);
+
+ module.exports = TimingAnimation;
+},263,[3,4,5,8,25,9,240,258,260,243,264],"node_modules\\react-native\\Libraries\\Animated\\src\\animations\\TimingAnimation.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _ease;
+
+ var Easing = function () {
+ function Easing() {
+ _classCallCheck(this, Easing);
+ }
+
+ _createClass(Easing, null, [{
+ key: "step0",
+ value: function step0(n) {
+ return n > 0 ? 1 : 0;
+ }
+ }, {
+ key: "step1",
+ value: function step1(n) {
+ return n >= 1 ? 1 : 0;
+ }
+ }, {
+ key: "linear",
+ value: function linear(t) {
+ return t;
+ }
+ }, {
+ key: "ease",
+ value: function ease(t) {
+ if (!_ease) {
+ _ease = Easing.bezier(0.42, 0, 1, 1);
+ }
+
+ return _ease(t);
+ }
+ }, {
+ key: "quad",
+ value: function quad(t) {
+ return t * t;
+ }
+ }, {
+ key: "cubic",
+ value: function cubic(t) {
+ return t * t * t;
+ }
+ }, {
+ key: "poly",
+ value: function poly(n) {
+ return function (t) {
+ return Math.pow(t, n);
+ };
+ }
+ }, {
+ key: "sin",
+ value: function sin(t) {
+ return 1 - Math.cos(t * Math.PI / 2);
+ }
+ }, {
+ key: "circle",
+ value: function circle(t) {
+ return 1 - Math.sqrt(1 - t * t);
+ }
+ }, {
+ key: "exp",
+ value: function exp(t) {
+ return Math.pow(2, 10 * (t - 1));
+ }
+ }, {
+ key: "elastic",
+ value: function elastic() {
+ var bounciness = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
+ var p = bounciness * Math.PI;
+ return function (t) {
+ return 1 - Math.pow(Math.cos(t * Math.PI / 2), 3) * Math.cos(t * p);
+ };
+ }
+ }, {
+ key: "back",
+ value: function back() {
+ var s = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1.70158;
+ return function (t) {
+ return t * t * ((s + 1) * t - s);
+ };
+ }
+ }, {
+ key: "bounce",
+ value: function bounce(t) {
+ if (t < 1 / 2.75) {
+ return 7.5625 * t * t;
+ }
+
+ if (t < 2 / 2.75) {
+ var _t = t - 1.5 / 2.75;
+
+ return 7.5625 * _t * _t + 0.75;
+ }
+
+ if (t < 2.5 / 2.75) {
+ var _t2 = t - 2.25 / 2.75;
+
+ return 7.5625 * _t2 * _t2 + 0.9375;
+ }
+
+ var t2 = t - 2.625 / 2.75;
+ return 7.5625 * t2 * t2 + 0.984375;
+ }
+ }, {
+ key: "bezier",
+ value: function bezier(x1, y1, x2, y2) {
+ var _bezier = _$$_REQUIRE(_dependencyMap[2], "bezier");
+
+ return _bezier(x1, y1, x2, y2);
+ }
+ }, {
+ key: "in",
+ value: function _in(easing) {
+ return easing;
+ }
+ }, {
+ key: "out",
+ value: function out(easing) {
+ return function (t) {
+ return 1 - easing(1 - t);
+ };
+ }
+ }, {
+ key: "inOut",
+ value: function inOut(easing) {
+ return function (t) {
+ if (t < 0.5) {
+ return easing(t * 2) / 2;
+ }
+
+ return 1 - easing((1 - t) * 2) / 2;
+ };
+ }
+ }]);
+
+ return Easing;
+ }();
+
+ module.exports = Easing;
+},264,[3,4,265],"node_modules\\react-native\\Libraries\\Animated\\src\\Easing.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var NEWTON_ITERATIONS = 4;
+ var NEWTON_MIN_SLOPE = 0.001;
+ var SUBDIVISION_PRECISION = 0.0000001;
+ var SUBDIVISION_MAX_ITERATIONS = 10;
+ var kSplineTableSize = 11;
+ var kSampleStepSize = 1.0 / (kSplineTableSize - 1.0);
+ var float32ArraySupported = typeof Float32Array === 'function';
+
+ function A(aA1, aA2) {
+ return 1.0 - 3.0 * aA2 + 3.0 * aA1;
+ }
+
+ function B(aA1, aA2) {
+ return 3.0 * aA2 - 6.0 * aA1;
+ }
+
+ function C(aA1) {
+ return 3.0 * aA1;
+ }
+
+ function calcBezier(aT, aA1, aA2) {
+ return ((A(aA1, aA2) * aT + B(aA1, aA2)) * aT + C(aA1)) * aT;
+ }
+
+ function getSlope(aT, aA1, aA2) {
+ return 3.0 * A(aA1, aA2) * aT * aT + 2.0 * B(aA1, aA2) * aT + C(aA1);
+ }
+
+ function binarySubdivide(aX, _aA, _aB, mX1, mX2) {
+ var currentX,
+ currentT,
+ i = 0,
+ aA = _aA,
+ aB = _aB;
+
+ do {
+ currentT = aA + (aB - aA) / 2.0;
+ currentX = calcBezier(currentT, mX1, mX2) - aX;
+
+ if (currentX > 0.0) {
+ aB = currentT;
+ } else {
+ aA = currentT;
+ }
+ } while (Math.abs(currentX) > SUBDIVISION_PRECISION && ++i < SUBDIVISION_MAX_ITERATIONS);
+
+ return currentT;
+ }
+
+ function newtonRaphsonIterate(aX, _aGuessT, mX1, mX2) {
+ var aGuessT = _aGuessT;
+
+ for (var i = 0; i < NEWTON_ITERATIONS; ++i) {
+ var currentSlope = getSlope(aGuessT, mX1, mX2);
+
+ if (currentSlope === 0.0) {
+ return aGuessT;
+ }
+
+ var currentX = calcBezier(aGuessT, mX1, mX2) - aX;
+ aGuessT -= currentX / currentSlope;
+ }
+
+ return aGuessT;
+ }
+
+ module.exports = function bezier(mX1, mY1, mX2, mY2) {
+ if (!(mX1 >= 0 && mX1 <= 1 && mX2 >= 0 && mX2 <= 1)) {
+ throw new Error('bezier x values must be in [0, 1] range');
+ }
+
+ var sampleValues = float32ArraySupported ? new Float32Array(kSplineTableSize) : new Array(kSplineTableSize);
+
+ if (mX1 !== mY1 || mX2 !== mY2) {
+ for (var i = 0; i < kSplineTableSize; ++i) {
+ sampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2);
+ }
+ }
+
+ function getTForX(aX) {
+ var intervalStart = 0.0;
+ var currentSample = 1;
+ var lastSample = kSplineTableSize - 1;
+
+ for (; currentSample !== lastSample && sampleValues[currentSample] <= aX; ++currentSample) {
+ intervalStart += kSampleStepSize;
+ }
+
+ --currentSample;
+ var dist = (aX - sampleValues[currentSample]) / (sampleValues[currentSample + 1] - sampleValues[currentSample]);
+ var guessForT = intervalStart + dist * kSampleStepSize;
+ var initialSlope = getSlope(guessForT, mX1, mX2);
+
+ if (initialSlope >= NEWTON_MIN_SLOPE) {
+ return newtonRaphsonIterate(aX, guessForT, mX1, mX2);
+ } else if (initialSlope === 0.0) {
+ return guessForT;
+ } else {
+ return binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize, mX1, mX2);
+ }
+ }
+
+ return function BezierEasing(x) {
+ if (mX1 === mY1 && mX2 === mY2) {
+ return x;
+ }
+
+ if (x === 0) {
+ return 0;
+ }
+
+ if (x === 1) {
+ return 1;
+ }
+
+ return calcBezier(getTForX(x), mY1, mY2);
+ };
+ };
+},265,[],"node_modules\\react-native\\Libraries\\Animated\\src\\bezier.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Animated\\src\\createAnimatedComponent.js";
+
+ var _require = _$$_REQUIRE(_dependencyMap[6], "./AnimatedEvent"),
+ AnimatedEvent = _require.AnimatedEvent;
+
+ var AnimatedProps = _$$_REQUIRE(_dependencyMap[7], "./nodes/AnimatedProps");
+
+ var React = _$$_REQUIRE(_dependencyMap[8], "React");
+
+ var DeprecatedViewStylePropTypes = _$$_REQUIRE(_dependencyMap[9], "DeprecatedViewStylePropTypes");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[10], "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) {
+ _inherits(AnimatedComponent, _React$Component);
+
+ function AnimatedComponent(props) {
+ var _this;
+
+ _classCallCheck(this, AnimatedComponent);
+
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(AnimatedComponent).call(this, props));
+ _this._invokeAnimatedPropsCallbackOnMount = false;
+ _this._eventDetachers = [];
+
+ _this._animatedPropsCallback = function () {
+ if (_this._component == null) {
+ _this._invokeAnimatedPropsCallbackOnMount = true;
+ } else if (AnimatedComponent.__skipSetNativeProps_FOR_TESTS_ONLY || typeof _this._component.setNativeProps !== 'function') {
+ _this.forceUpdate();
+ } else if (!_this._propsAnimated.__isNative) {
+ _this._component.setNativeProps(_this._propsAnimated.__getAnimatedValue());
+ } else {
+ throw new Error('Attempting to run JS driven animation on animated ' + 'node that has been moved to "native" earlier by starting an ' + 'animation with `useNativeDriver: true`');
+ }
+ };
+
+ _this._setComponentRef = function (c) {
+ _this._prevComponent = _this._component;
+ _this._component = c;
+ };
+
+ return _this;
+ }
+
+ _createClass(AnimatedComponent, [{
+ key: "componentWillUnmount",
+ value: function componentWillUnmount() {
+ this._propsAnimated && this._propsAnimated.__detach();
+
+ this._detachNativeEvents();
+ }
+ }, {
+ key: "setNativeProps",
+ value: function setNativeProps(props) {
+ this._component.setNativeProps(props);
+ }
+ }, {
+ key: "UNSAFE_componentWillMount",
+ value: function UNSAFE_componentWillMount() {
+ this._attachProps(this.props);
+ }
+ }, {
+ key: "componentDidMount",
+ value: function componentDidMount() {
+ if (this._invokeAnimatedPropsCallbackOnMount) {
+ this._invokeAnimatedPropsCallbackOnMount = false;
+
+ this._animatedPropsCallback();
+ }
+
+ this._propsAnimated.setNativeView(this._component);
+
+ this._attachNativeEvents();
+ }
+ }, {
+ key: "_attachNativeEvents",
+ value: function _attachNativeEvents() {
+ var _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: 151
+ }
+ }));
+ }
+ }, {
+ key: "getNode",
+ value: function getNode() {
+ return this._component;
+ }
+ }]);
+
+ return AnimatedComponent;
+ }(React.Component);
+
+ AnimatedComponent.__skipSetNativeProps_FOR_TESTS_ONLY = false;
+ var propTypes = Component.propTypes;
+ AnimatedComponent.propTypes = {
+ style: function style(props, propName, componentName) {
+ if (!propTypes) {
+ return;
+ }
+
+ for (var key in DeprecatedViewStylePropTypes) {
+ if (!propTypes[key] && props[key] !== undefined) {
+ console.warn('You are setting the style `{ ' + key + ': ... }` as a prop. You ' + 'should nest it in a style object. ' + 'E.g. `{ style: { ' + key + ': ... } }`');
+ }
+ }
+ }
+ };
+ return AnimatedComponent;
+ }
+
+ module.exports = createAnimatedComponent;
+},266,[14,3,4,5,8,9,239,253,52,74,19],"node_modules\\react-native\\Libraries\\Animated\\src\\createAnimatedComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var FlatList = _$$_REQUIRE(_dependencyMap[0], "FlatList");
+
+ var createAnimatedComponent = _$$_REQUIRE(_dependencyMap[1], "createAnimatedComponent");
+
+ module.exports = createAnimatedComponent(FlatList);
+},267,[268,266],"node_modules\\react-native\\Libraries\\Animated\\src\\components\\AnimatedFlatList.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/createClass");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/defineProperty");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Lists\\FlatList.js";
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var Platform = _$$_REQUIRE(_dependencyMap[7], "Platform");
+
+ var deepDiffer = _$$_REQUIRE(_dependencyMap[8], "deepDiffer");
+
+ var React = _$$_REQUIRE(_dependencyMap[9], "React");
+
+ var View = _$$_REQUIRE(_dependencyMap[10], "View");
+
+ var VirtualizedList = _$$_REQUIRE(_dependencyMap[11], "VirtualizedList");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[12], "StyleSheet");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[13], "invariant");
+
+ var defaultProps = _objectSpread({}, VirtualizedList.defaultProps, {
+ numColumns: 1,
+ removeClippedSubviews: Platform.OS === 'android'
+ });
+
+ var FlatList = function (_React$PureComponent) {
+ _inherits(FlatList, _React$PureComponent);
+
+ _createClass(FlatList, [{
+ key: "scrollToEnd",
+ value: function scrollToEnd(params) {
+ if (this._listRef) {
+ this._listRef.scrollToEnd(params);
+ }
+ }
+ }, {
+ key: "scrollToIndex",
+ value: function scrollToIndex(params) {
+ if (this._listRef) {
+ this._listRef.scrollToIndex(params);
+ }
+ }
+ }, {
+ key: "scrollToItem",
+ value: function scrollToItem(params) {
+ if (this._listRef) {
+ this._listRef.scrollToItem(params);
+ }
+ }
+ }, {
+ key: "scrollToOffset",
+ value: function scrollToOffset(params) {
+ if (this._listRef) {
+ this._listRef.scrollToOffset(params);
+ }
+ }
+ }, {
+ key: "recordInteraction",
+ value: function recordInteraction() {
+ if (this._listRef) {
+ this._listRef.recordInteraction();
+ }
+ }
+ }, {
+ key: "flashScrollIndicators",
+ value: function flashScrollIndicators() {
+ if (this._listRef) {
+ this._listRef.flashScrollIndicators();
+ }
+ }
+ }, {
+ key: "getScrollResponder",
+ value: function getScrollResponder() {
+ if (this._listRef) {
+ return this._listRef.getScrollResponder();
+ }
+ }
+ }, {
+ key: "getScrollableNode",
+ value: function getScrollableNode() {
+ if (this._listRef) {
+ return this._listRef.getScrollableNode();
+ }
+ }
+ }, {
+ key: "setNativeProps",
+ value: function setNativeProps(props) {
+ if (this._listRef) {
+ this._listRef.setNativeProps(props);
+ }
+ }
+ }]);
+
+ function FlatList(props) {
+ var _this;
+
+ _classCallCheck(this, FlatList);
+
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(FlatList).call(this, props));
+ _this._virtualizedListPairs = [];
+
+ _this._captureRef = function (ref) {
+ _this._listRef = ref;
+ };
+
+ _this._getItem = function (data, index) {
+ var numColumns = _this.props.numColumns;
+
+ if (numColumns > 1) {
+ var ret = [];
+
+ for (var kk = 0; kk < numColumns; kk++) {
+ var _item = data[index * numColumns + kk];
+
+ if (_item != null) {
+ ret.push(_item);
+ }
+ }
+
+ return ret;
+ } else {
+ return data[index];
+ }
+ };
+
+ _this._getItemCount = function (data) {
+ return data ? Math.ceil(data.length / _this.props.numColumns) : 0;
+ };
+
+ _this._keyExtractor = function (items, index) {
+ var _this$props = _this.props,
+ keyExtractor = _this$props.keyExtractor,
+ numColumns = _this$props.numColumns;
+
+ if (numColumns > 1) {
+ invariant(Array.isArray(items), 'FlatList: Encountered internal consistency error, expected each item to consist of an ' + 'array with 1-%s columns; instead, received a single item.', numColumns);
+ return items.map(function (it, kk) {
+ return keyExtractor(it, index * numColumns + kk);
+ }).join(':');
+ } else {
+ return keyExtractor(items, index);
+ }
+ };
+
+ _this._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,
+ isSelected = info.isSelected;
+ 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: 610
+ }
+ }, _item2.map(function (it, kk) {
+ var element = renderItem({
+ item: it,
+ index: _index * numColumns + kk,
+ isSelected: isSelected,
+ 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(!deepDiffer(prevProps.viewabilityConfig, this.props.viewabilityConfig), 'Changing viewabilityConfig on the fly is not supported');
+ invariant(prevProps.viewabilityConfigCallbackPairs === this.props.viewabilityConfigCallbackPairs, 'Changing viewabilityConfigCallbackPairs on the fly is not supported');
+
+ this._checkProps(this.props);
+ }
+ }, {
+ key: "_checkProps",
+ value: function _checkProps(props) {
+ var getItem = props.getItem,
+ getItemCount = props.getItemCount,
+ horizontal = props.horizontal,
+ numColumns = props.numColumns,
+ columnWrapperStyle = props.columnWrapperStyle,
+ onViewableItemsChanged = props.onViewableItemsChanged,
+ viewabilityConfigCallbackPairs = props.viewabilityConfigCallbackPairs;
+ invariant(!getItem && !getItemCount, 'FlatList does not support custom data formats.');
+
+ if (numColumns > 1) {
+ invariant(!horizontal, 'numColumns does not support horizontal.');
+ } else {
+ invariant(!columnWrapperStyle, 'columnWrapperStyle not supported for single column lists');
+ }
+
+ invariant(!(onViewableItemsChanged && viewabilityConfigCallbackPairs), 'FlatList does not support setting both onViewableItemsChanged and ' + 'viewabilityConfigCallbackPairs.');
+ }
+ }, {
+ key: "_pushMultiColumnViewable",
+ value: function _pushMultiColumnViewable(arr, v) {
+ var _this$props3 = this.props,
+ numColumns = _this$props3.numColumns,
+ keyExtractor = _this$props3.keyExtractor;
+ v.item.forEach(function (item, ii) {
+ invariant(v.index != null, 'Missing index!');
+ var index = v.index * numColumns + ii;
+ arr.push(_objectSpread({}, v, {
+ item: item,
+ key: keyExtractor(item, index),
+ index: index
+ }));
+ });
+ }
+ }, {
+ key: "_createOnViewableItemsChanged",
+ value: function _createOnViewableItemsChanged(onViewableItemsChanged) {
+ var _this2 = this;
+
+ return function (info) {
+ var numColumns = _this2.props.numColumns;
+
+ if (onViewableItemsChanged) {
+ if (numColumns > 1) {
+ var changed = [];
+ var viewableItems = [];
+ info.viewableItems.forEach(function (v) {
+ return _this2._pushMultiColumnViewable(viewableItems, v);
+ });
+ info.changed.forEach(function (v) {
+ return _this2._pushMultiColumnViewable(changed, v);
+ });
+ onViewableItemsChanged({
+ viewableItems: viewableItems,
+ changed: changed
+ });
+ } else {
+ onViewableItemsChanged(info);
+ }
+ }
+ };
+ }
+ }, {
+ key: "render",
+ value: function render() {
+ return React.createElement(VirtualizedList, _extends({}, this.props, {
+ renderItem: this._renderItem,
+ getItem: this._getItem,
+ getItemCount: this._getItemCount,
+ keyExtractor: this._keyExtractor,
+ ref: this._captureRef,
+ viewabilityConfigCallbackPairs: this._virtualizedListPairs,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 633
+ }
+ }));
+ }
+ }]);
+
+ return FlatList;
+ }(React.PureComponent);
+
+ FlatList.defaultProps = defaultProps;
+ var styles = StyleSheet.create({
+ row: {
+ flexDirection: 'row'
+ }
+ });
+ module.exports = FlatList;
+},268,[14,3,5,8,4,9,32,35,175,52,81,269,53,19],"node_modules\\react-native\\Libraries\\Lists\\FlatList.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/defineProperty");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _assertThisInitialized = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/assertThisInitialized");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/createClass");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Lists\\VirtualizedList.js";
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var Batchinator = _$$_REQUIRE(_dependencyMap[8], "Batchinator");
+
+ var FillRateHelper = _$$_REQUIRE(_dependencyMap[9], "FillRateHelper");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[10], "Platform");
+
+ var PropTypes = _$$_REQUIRE(_dependencyMap[11], "prop-types");
+
+ var React = _$$_REQUIRE(_dependencyMap[12], "React");
+
+ var ReactNative = _$$_REQUIRE(_dependencyMap[13], "ReactNative");
+
+ var RefreshControl = _$$_REQUIRE(_dependencyMap[14], "RefreshControl");
+
+ var ScrollView = _$$_REQUIRE(_dependencyMap[15], "ScrollView");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[16], "StyleSheet");
+
+ var UIManager = _$$_REQUIRE(_dependencyMap[17], "UIManager");
+
+ var View = _$$_REQUIRE(_dependencyMap[18], "View");
+
+ var ViewabilityHelper = _$$_REQUIRE(_dependencyMap[19], "ViewabilityHelper");
+
+ var flattenStyle = _$$_REQUIRE(_dependencyMap[20], "flattenStyle");
+
+ var infoLog = _$$_REQUIRE(_dependencyMap[21], "infoLog");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[22], "invariant");
+
+ var warning = _$$_REQUIRE(_dependencyMap[23], "fbjs/lib/warning");
+
+ var _require = _$$_REQUIRE(_dependencyMap[24], "VirtualizeUtils"),
+ computeWindowedRenderLimits = _require.computeWindowedRenderLimits;
+
+ var _usedIndexForKey = false;
+ var _keylessItemComponentName = '';
+
+ var VirtualizedList = function (_React$PureComponent) {
+ _inherits(VirtualizedList, _React$PureComponent);
+
+ _createClass(VirtualizedList, [{
+ key: "scrollToEnd",
+ value: function scrollToEnd(params) {
+ var animated = params ? params.animated : true;
+ var veryLast = this.props.getItemCount(this.props.data) - 1;
+
+ var frame = this._getFrameMetricsApprox(veryLast);
+
+ var offset = Math.max(0, frame.offset + frame.length + this._footerLength - this._scrollMetrics.visibleLength);
+
+ this._scrollRef.scrollTo(this.props.horizontal ? {
+ x: offset,
+ animated: animated
+ } : {
+ y: offset,
+ animated: animated
+ });
+ }
+ }, {
+ key: "scrollToIndex",
+ value: function scrollToIndex(params) {
+ var _this$props = this.props,
+ data = _this$props.data,
+ horizontal = _this$props.horizontal,
+ getItemCount = _this$props.getItemCount,
+ getItemLayout = _this$props.getItemLayout,
+ onScrollToIndexFailed = _this$props.onScrollToIndexFailed;
+ var animated = params.animated,
+ index = params.index,
+ viewOffset = params.viewOffset,
+ viewPosition = params.viewPosition;
+ invariant(index >= 0 && index < getItemCount(data), "scrollToIndex out of range: " + 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.ensureItemAtIndexIsVisible = function (rowIndex) {
+ var frame = _this._getFrameMetricsApprox(rowIndex);
+
+ var visTop = _this._scrollMetrics.offset;
+ var visLen = _this._scrollMetrics.visibleLength;
+ var visEnd = visTop + visLen;
+ var contentLength = _this._scrollMetrics.contentLength;
+ var frameEnd = frame.offset + frame.length;
+
+ if (frameEnd > visEnd) {
+ var newOffset = Math.min(contentLength, visTop + (frameEnd - visEnd));
+
+ _this.scrollToOffset({
+ offset: newOffset
+ });
+ } else if (frame.offset < visTop) {
+ var _newOffset = Math.max(0, visTop - frame.length);
+
+ _this.scrollToOffset({
+ offset: _newOffset
+ });
+ }
+ };
+
+ _this._getScrollMetrics = function () {
+ return _this._scrollMetrics;
+ };
+
+ _this._getOutermostParentListRef = function () {
+ if (_this._isNestedWithSameOrientation()) {
+ return _this.context.virtualizedList.getOutermostParentListRef();
+ } else {
+ return _assertThisInitialized(_this);
+ }
+ };
+
+ _this._getNestedChildState = function (key) {
+ var existingChildData = _this._nestedChildLists.get(key);
+
+ return existingChildData && existingChildData.state;
+ };
+
+ _this._registerAsNestedChild = function (childList) {
+ var childListsInCell = _this._cellKeysToChildListKeys.get(childList.cellKey) || new Set();
+ childListsInCell.add(childList.key);
+
+ _this._cellKeysToChildListKeys.set(childList.cellKey, childListsInCell);
+
+ var existingChildData = _this._nestedChildLists.get(childList.key);
+
+ 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 keyEventHandler = _this.props.onKeyDown;
+
+ if (!keyEventHandler) {
+ keyEventHandler = _this.props.enableSelectionOnKeyPress ? _this._handleKeyDown : null;
+ }
+
+ var onRefresh = props.onRefresh;
+
+ if (_this._isNestedWithSameOrientation()) {
+ return React.createElement(View, _extends({}, props, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 1095
+ }
+ }));
+ } 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, {
+ onKeyDown: keyEventHandler,
+ refreshControl: props.refreshControl == null ? React.createElement(RefreshControl, {
+ refreshing: props.refreshing,
+ onRefresh: onRefresh,
+ progressViewOffset: props.progressViewOffset,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 1110
+ }
+ }) : props.refreshControl,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 1105
+ }
+ }));
+ } else {
+ return React.createElement(ScrollView, _extends({}, props, {
+ onKeyDown: keyEventHandler,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 1123
+ }
+ }));
+ }
+ };
+
+ _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._selectRowAboveIndex = function (rowIndex) {
+ var rowAbove = rowIndex > 0 ? rowIndex - 1 : rowIndex;
+
+ _this.setState(function (state) {
+ return {
+ selectedRowIndex: rowAbove
+ };
+ });
+
+ return rowAbove;
+ };
+
+ _this._selectRowBelowIndex = function (rowIndex) {
+ if (_this.props.getItemCount) {
+ var _data = _this.props.data;
+
+ var itemCount = _this.props.getItemCount(_data);
+
+ var rowBelow = rowIndex < itemCount - 1 ? rowIndex + 1 : rowIndex;
+
+ _this.setState(function (state) {
+ return {
+ selectedRowIndex: rowBelow
+ };
+ });
+
+ return rowBelow;
+ } else {
+ return rowIndex;
+ }
+ };
+
+ _this._handleKeyDown = function (e) {
+ if (_this.props.onKeyDown) {
+ _this.props.onKeyDown(e);
+ } else {
+ if (Platform.OS === 'macos') {
+ var _event = e.nativeEvent;
+ var _key = _event.key;
+ var prevIndex = -1;
+ var newIndex = -1;
+
+ if ('selectedRowIndex' in _this.state) {
+ prevIndex = _this.state.selectedRowIndex;
+ }
+
+ var _this$props3 = _this.props,
+ _data2 = _this$props3.data,
+ getItem = _this$props3.getItem;
+
+ if (_key === 'DOWN_ARROW') {
+ newIndex = _this._selectRowBelowIndex(prevIndex);
+
+ _this.ensureItemAtIndexIsVisible(newIndex);
+
+ if (_this.props.onSelectionChanged && prevIndex != newIndex) {
+ var _item = getItem(_data2, newIndex);
+
+ _this.props.onSelectionChanged({
+ previousSelection: prevIndex,
+ newSelection: newIndex,
+ item: _item
+ });
+ }
+ } else if (_key === 'UP_ARROW') {
+ newIndex = _this._selectRowAboveIndex(prevIndex);
+
+ _this.ensureItemAtIndexIsVisible(newIndex);
+
+ if (_this.props.onSelectionChanged && prevIndex != newIndex) {
+ var _item2 = getItem(_data2, newIndex);
+
+ _this.props.onSelectionChanged({
+ previousSelection: prevIndex,
+ newSelection: newIndex,
+ item: _item2
+ });
+ }
+ } else if (_key === 'ENTER') {
+ if (_this.props.onSelectionEntered) {
+ var _item3 = getItem(_data2, prevIndex);
+
+ _this.props.onSelectionEntered(_item3);
+ }
+ }
+ }
+ }
+ };
+
+ _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$props4 = _this.props,
+ data = _this$props4.data,
+ getItemCount = _this$props4.getItemCount,
+ onEndReachedThreshold = _this$props4.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$props5 = _this.props,
+ data = _this$props5.data,
+ getItem = _this$props5.getItem,
+ keyExtractor = _this$props5.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$props6 = _this.props,
+ data = _this$props6.data,
+ getItem = _this$props6.getItem,
+ getItemCount = _this$props6.getItemCount,
+ getItemLayout = _this$props6.getItemLayout,
+ keyExtractor = _this$props6.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,
+ selectedRowIndex: 0
+ };
+
+ 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$props7 = this.props,
+ CellRendererComponent = _this$props7.CellRendererComponent,
+ ItemSeparatorComponent = _this$props7.ItemSeparatorComponent,
+ data = _this$props7.data,
+ getItem = _this$props7.getItem,
+ getItemCount = _this$props7.getItemCount,
+ horizontal = _this$props7.horizontal,
+ keyExtractor = _this$props7.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,
+ isSelected: _this2.state.selectedRowIndex == ii ? true : false,
+ key: key,
+ prevCellKey: prevCellKey,
+ onUpdateSeparators: _this2._onUpdateSeparators,
+ onLayout: function onLayout(e) {
+ return _this2._onCellLayout(e, key, ii);
+ },
+ onUnmount: _this2._onCellUnmount,
+ parentProps: _this2.props,
+ ref: function ref(_ref2) {
+ _this2._cellRefs[key] = _ref2;
+ },
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 738
+ }
+ }));
+ 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$props8 = this.props,
+ ListEmptyComponent = _this$props8.ListEmptyComponent,
+ ListFooterComponent = _this$props8.ListFooterComponent,
+ ListHeaderComponent = _this$props8.ListHeaderComponent;
+ var _this$props9 = this.props,
+ data = _this$props9.data,
+ horizontal = _this$props9.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: 813
+ }
+ });
+ cells.push(React.createElement(VirtualizedCellWrapper, {
+ cellKey: this._getCellKey() + '-header',
+ key: "$header",
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 816
+ }
+ }, React.createElement(View, {
+ onLayout: this._onLayoutHeader,
+ style: StyleSheet.compose(inversionStyle, this.props.ListHeaderComponentStyle),
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 819
+ }
+ }, element)));
+ }
+
+ var itemCount = this.props.getItemCount(data);
+
+ if (itemCount > 0) {
+ _usedIndexForKey = false;
+ _keylessItemComponentName = '';
+ var spacerKey = !horizontal ? 'height' : 'width';
+ var lastInitialIndex = this.props.initialScrollIndex ? -1 : this.props.initialNumToRender - 1;
+ var _this$state = this.state,
+ first = _this$state.first,
+ last = _this$state.last;
+
+ this._pushCells(cells, stickyHeaderIndices, stickyIndicesFromProps, 0, lastInitialIndex, inversionStyle);
+
+ var firstAfterInitial = Math.max(lastInitialIndex + 1, first);
+
+ if (!isVirtualizationDisabled && first > lastInitialIndex + 1) {
+ var insertedStickySpacer = false;
+
+ if (stickyIndicesFromProps.size > 0) {
+ var stickyOffset = ListHeaderComponent ? 1 : 0;
+
+ for (var ii = firstAfterInitial - 1; ii > lastInitialIndex; ii--) {
+ if (stickyIndicesFromProps.has(ii + stickyOffset)) {
+ var initBlock = this._getFrameMetricsApprox(lastInitialIndex);
+
+ var stickyBlock = this._getFrameMetricsApprox(ii);
+
+ var leadSpace = stickyBlock.offset - initBlock.offset - (this.props.initialScrollIndex ? 0 : initBlock.length);
+ cells.push(React.createElement(View, {
+ key: "$sticky_lead",
+ style: _defineProperty({}, spacerKey, leadSpace),
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 865
+ }
+ }));
+
+ 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: 879
+ }
+ }));
+ 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: 892
+ }
+ }));
+ }
+ }
+
+ 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: 926
+ }
+ }));
+ }
+ } else if (ListEmptyComponent) {
+ var _element = React.isValidElement(ListEmptyComponent) ? ListEmptyComponent : React.createElement(ListEmptyComponent, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 936
+ }
+ });
+
+ 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: 956
+ }
+ });
+
+ cells.push(React.createElement(VirtualizedCellWrapper, {
+ cellKey: this._getCellKey() + '-footer',
+ key: "$footer",
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 959
+ }
+ }, React.createElement(View, {
+ onLayout: this._onLayoutFooter,
+ style: StyleSheet.compose(inversionStyle, this.props.ListFooterComponentStyle),
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 962
+ }
+ }, _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 && itemCount !== 0) {
+ 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: styles.debug,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 1012
+ }
+ }, ret, this._renderDebugOverlay());
+ } else {
+ return ret;
+ }
+ }
+ }, {
+ key: "componentDidUpdate",
+ value: function componentDidUpdate(prevProps) {
+ var _this$props10 = this.props,
+ data = _this$props10.data,
+ extraData = _this$props10.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;
+
+ try {
+ 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;
+ });
+ } catch (error) {
+ console.warn('measureLayoutRelativeToContainingList threw an error', error.stack);
+ }
+ }
+ }, {
+ 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;
+ return React.createElement(View, {
+ style: [styles.debugOverlayBase, styles.debugOverlay],
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 1334
+ }
+ }, framesInLayout.map(function (f, ii) {
+ return React.createElement(View, {
+ key: 'f' + ii,
+ style: [styles.debugOverlayBase, styles.debugOverlayFrame, {
+ top: f.offset * normalize,
+ height: f.length * normalize
+ }],
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 1336
+ }
+ });
+ }), React.createElement(View, {
+ style: [styles.debugOverlayBase, styles.debugOverlayFrameLast, {
+ top: windowTop * normalize,
+ height: windowLen * normalize
+ }],
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 1348
+ }
+ }), React.createElement(View, {
+ style: [styles.debugOverlayBase, styles.debugOverlayFrameVis, {
+ top: visTop * normalize,
+ height: visLen * normalize
+ }],
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 1358
+ }
+ }));
+ }
+ }, {
+ key: "_selectLength",
+ value: function _selectLength(metrics) {
+ return !this.props.horizontal ? metrics.height : metrics.width;
+ }
+ }, {
+ key: "_selectOffset",
+ value: function _selectOffset(metrics) {
+ return !this.props.horizontal ? metrics.y : metrics.x;
+ }
+ }, {
+ key: "_maybeCallOnEndReached",
+ value: function _maybeCallOnEndReached() {
+ var _this$props11 = this.props,
+ data = _this$props11.data,
+ getItemCount = _this$props11.getItemCount,
+ onEndReached = _this$props11.onEndReached,
+ onEndReachedThreshold = _this$props11.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,
+ getItemCount = newProps.getItemCount,
+ maxToRenderPerBatch = newProps.maxToRenderPerBatch;
+ return {
+ first: Math.max(0, Math.min(prevState.first, getItemCount(data) - 1 - maxToRenderPerBatch)),
+ last: Math.max(0, Math.min(prevState.last, getItemCount(data) - 1))
+ };
+ }
+ }]);
+
+ return VirtualizedList;
+ }(React.PureComponent);
+
+ VirtualizedList.defaultProps = {
+ disableVirtualization: false,
+ horizontal: false,
+ initialNumToRender: 10,
+ keyExtractor: function keyExtractor(item, index) {
+ if (item.key != null) {
+ return item.key;
+ }
+
+ _usedIndexForKey = true;
+
+ if (item.type && item.type.displayName) {
+ _keylessItemComponentName = item.type.displayName;
+ }
+
+ return String(index);
+ },
+ maxToRenderPerBatch: 10,
+ onEndReachedThreshold: 2,
+ scrollEventThrottle: 50,
+ updateCellsBatchingPeriod: 50,
+ windowSize: 21
+ };
+ VirtualizedList.contextTypes = {
+ virtualizedCell: PropTypes.shape({
+ cellKey: PropTypes.string
+ }),
+ virtualizedList: PropTypes.shape({
+ getScrollMetrics: PropTypes.func,
+ horizontal: PropTypes.bool,
+ getOutermostParentListRef: PropTypes.func,
+ getNestedChildState: PropTypes.func,
+ registerAsNestedChild: PropTypes.func,
+ unregisterAsNestedChild: PropTypes.func
+ })
+ };
+ VirtualizedList.childContextTypes = {
+ virtualizedList: PropTypes.shape({
+ getScrollMetrics: PropTypes.func,
+ horizontal: PropTypes.bool,
+ getOutermostParentListRef: PropTypes.func,
+ getNestedChildState: PropTypes.func,
+ registerAsNestedChild: PropTypes.func,
+ unregisterAsNestedChild: PropTypes.func
+ })
+ };
+
+ var CellRenderer = function (_React$Component) {
+ _inherits(CellRenderer, _React$Component);
+
+ function CellRenderer() {
+ var _getPrototypeOf2;
+
+ var _this6;
+
+ _classCallCheck(this, CellRenderer);
+
+ for (var _len = arguments.length, args = new Array(_len), _key2 = 0; _key2 < _len; _key2++) {
+ args[_key2] = arguments[_key2];
+ }
+
+ _this6 = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(CellRenderer)).call.apply(_getPrototypeOf2, [this].concat(args)));
+ _this6.state = {
+ separatorProps: {
+ highlighted: false,
+ leadingItem: _this6.props.item
+ }
+ };
+ _this6._separators = {
+ highlight: function highlight() {
+ var _this6$props = _this6.props,
+ cellKey = _this6$props.cellKey,
+ prevCellKey = _this6$props.prevCellKey;
+
+ _this6.props.onUpdateSeparators([cellKey, prevCellKey], {
+ highlighted: true
+ });
+ },
+ unhighlight: function unhighlight() {
+ var _this6$props2 = _this6.props,
+ cellKey = _this6$props2.cellKey,
+ prevCellKey = _this6$props2.prevCellKey;
+
+ _this6.props.onUpdateSeparators([cellKey, prevCellKey], {
+ highlighted: false
+ });
+ },
+ updateProps: function updateProps(select, newProps) {
+ var _this6$props3 = _this6.props,
+ cellKey = _this6$props3.cellKey,
+ prevCellKey = _this6$props3.prevCellKey;
+
+ _this6.props.onUpdateSeparators([select === 'leading' ? prevCellKey : cellKey], newProps);
+ }
+ };
+ return _this6;
+ }
+
+ _createClass(CellRenderer, [{
+ key: "getChildContext",
+ value: function getChildContext() {
+ return {
+ virtualizedCell: {
+ cellKey: this.props.cellKey
+ }
+ };
+ }
+ }, {
+ key: "updateSeparatorProps",
+ value: function updateSeparatorProps(newProps) {
+ this.setState(function (state) {
+ return {
+ separatorProps: _objectSpread({}, state.separatorProps, {}, newProps)
+ };
+ });
+ }
+ }, {
+ key: "componentWillUnmount",
+ value: function componentWillUnmount() {
+ this.props.onUnmount(this.props.cellKey);
+ }
+ }, {
+ key: "render",
+ value: function render() {
+ var _this$props12 = this.props,
+ CellRendererComponent = _this$props12.CellRendererComponent,
+ ItemSeparatorComponent = _this$props12.ItemSeparatorComponent,
+ fillRateHelper = _this$props12.fillRateHelper,
+ horizontal = _this$props12.horizontal,
+ item = _this$props12.item,
+ index = _this$props12.index,
+ inversionStyle = _this$props12.inversionStyle,
+ isSelected = _this$props12.isSelected,
+ parentProps = _this$props12.parentProps;
+ var renderItem = parentProps.renderItem,
+ getItemLayout = parentProps.getItemLayout;
+ invariant(renderItem, 'no renderItem!');
+ var element = renderItem({
+ item: item,
+ index: index,
+ isSelected: isSelected,
+ 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: 1861
+ }
+ }));
+ 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: 1875
+ }
+ }, element, itemSeparator);
+ }
+
+ return React.createElement(CellRendererComponent, _extends({}, this.props, {
+ style: cellStyle,
+ onLayout: onLayout,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 1882
+ }
+ }), element, itemSeparator);
+ }
+ }]);
+
+ return CellRenderer;
+ }(React.Component);
+
+ CellRenderer.childContextTypes = {
+ virtualizedCell: PropTypes.shape({
+ cellKey: PropTypes.string
+ })
+ };
+
+ var VirtualizedCellWrapper = function (_React$Component2) {
+ _inherits(VirtualizedCellWrapper, _React$Component2);
+
+ function VirtualizedCellWrapper() {
+ _classCallCheck(this, VirtualizedCellWrapper);
+
+ return _possibleConstructorReturn(this, _getPrototypeOf(VirtualizedCellWrapper).apply(this, arguments));
+ }
+
+ _createClass(VirtualizedCellWrapper, [{
+ key: "getChildContext",
+ value: function getChildContext() {
+ return {
+ virtualizedCell: {
+ cellKey: this.props.cellKey
+ }
+ };
+ }
+ }, {
+ key: "render",
+ value: function render() {
+ return this.props.children;
+ }
+ }]);
+
+ return VirtualizedCellWrapper;
+ }(React.Component);
+
+ VirtualizedCellWrapper.childContextTypes = {
+ virtualizedCell: PropTypes.shape({
+ cellKey: PropTypes.string
+ })
+ };
+ var styles = StyleSheet.create({
+ verticallyInverted: {
+ transform: [{
+ scaleY: -1
+ }]
+ },
+ horizontallyInverted: {
+ transform: [{
+ scaleX: -1
+ }]
+ },
+ debug: {
+ flex: 1
+ },
+ debugOverlayBase: {
+ position: 'absolute',
+ top: 0,
+ right: 0
+ },
+ debugOverlay: {
+ bottom: 0,
+ width: 20,
+ borderColor: 'blue',
+ borderWidth: 1
+ },
+ debugOverlayFrame: {
+ left: 0,
+ backgroundColor: 'orange'
+ },
+ debugOverlayFrameLast: {
+ left: 0,
+ borderColor: 'green',
+ borderWidth: 2
+ },
+ debugOverlayFrameVis: {
+ left: 0,
+ borderColor: 'red',
+ borderWidth: 2
+ }
+ });
+ module.exports = VirtualizedList;
+},269,[14,32,3,5,8,7,4,9,270,271,35,62,52,84,272,275,53,71,81,284,80,157,19,21,285],"node_modules\\react-native\\Libraries\\Lists\\VirtualizedList.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var InteractionManager = _$$_REQUIRE(_dependencyMap[2], "InteractionManager");
+
+ var Batchinator = function () {
+ function Batchinator(callback, delayMS) {
+ _classCallCheck(this, Batchinator);
+
+ this._delay = delayMS;
+ this._callback = callback;
+ }
+
+ _createClass(Batchinator, [{
+ key: "dispose",
+ value: function dispose() {
+ var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
+ abort: false
+ };
+
+ if (this._taskHandle) {
+ this._taskHandle.cancel();
+
+ if (!options.abort) {
+ this._callback();
+ }
+
+ this._taskHandle = null;
+ }
+ }
+ }, {
+ key: "schedule",
+ value: function schedule() {
+ var _this = this;
+
+ if (this._taskHandle) {
+ return;
+ }
+
+ var timeoutHandle = setTimeout(function () {
+ _this._taskHandle = InteractionManager.runAfterInteractions(function () {
+ _this._taskHandle = null;
+
+ _this._callback();
+ });
+ }, this._delay);
+ this._taskHandle = {
+ cancel: function cancel() {
+ return clearTimeout(timeoutHandle);
+ }
+ };
+ }
+ }]);
+
+ return Batchinator;
+ }();
+
+ module.exports = Batchinator;
+},270,[3,4,245],"node_modules\\react-native\\Libraries\\Interaction\\Batchinator.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var performanceNow = _$$_REQUIRE(_dependencyMap[3], "fbjs/lib/performanceNow");
+
+ var warning = _$$_REQUIRE(_dependencyMap[4], "fbjs/lib/warning");
+
+ var Info = function Info() {
+ _classCallCheck(this, Info);
+
+ this.any_blank_count = 0;
+ this.any_blank_ms = 0;
+ this.any_blank_speed_sum = 0;
+ this.mostly_blank_count = 0;
+ this.mostly_blank_ms = 0;
+ this.pixels_blank = 0;
+ this.pixels_sampled = 0;
+ this.pixels_scrolled = 0;
+ this.total_time_spent = 0;
+ this.sample_count = 0;
+ };
+
+ var DEBUG = false;
+ var _listeners = [];
+ var _minSampleCount = 10;
+
+ var _sampleRate = DEBUG ? 1 : null;
+
+ var FillRateHelper = function () {
+ _createClass(FillRateHelper, null, [{
+ key: "addListener",
+ value: function addListener(callback) {
+ warning(_sampleRate !== null, 'Call `FillRateHelper.setSampleRate` before `addListener`.');
+
+ _listeners.push(callback);
+
+ return {
+ remove: function remove() {
+ _listeners = _listeners.filter(function (listener) {
+ return callback !== listener;
+ });
+ }
+ };
+ }
+ }, {
+ key: "setSampleRate",
+ value: function setSampleRate(sampleRate) {
+ _sampleRate = sampleRate;
+ }
+ }, {
+ key: "setMinSampleCount",
+ value: function setMinSampleCount(minSampleCount) {
+ _minSampleCount = minSampleCount;
+ }
+ }]);
+
+ function FillRateHelper(getFrameMetrics) {
+ _classCallCheck(this, FillRateHelper);
+
+ this._anyBlankStartTime = null;
+ this._enabled = false;
+ this._info = new Info();
+ this._mostlyBlankStartTime = null;
+ this._samplesStartTime = null;
+ this._getFrameMetrics = getFrameMetrics;
+ this._enabled = (_sampleRate || 0) > Math.random();
+
+ this._resetData();
+ }
+
+ _createClass(FillRateHelper, [{
+ key: "activate",
+ value: function activate() {
+ if (this._enabled && this._samplesStartTime == null) {
+ DEBUG && console.debug('FillRateHelper: activate');
+ this._samplesStartTime = performanceNow();
+ }
+ }
+ }, {
+ key: "deactivateAndFlush",
+ value: function deactivateAndFlush() {
+ if (!this._enabled) {
+ return;
+ }
+
+ var start = this._samplesStartTime;
+
+ if (start == null) {
+ DEBUG && console.debug('FillRateHelper: bail on deactivate with no start time');
+ return;
+ }
+
+ if (this._info.sample_count < _minSampleCount) {
+ this._resetData();
+
+ return;
+ }
+
+ var total_time_spent = performanceNow() - start;
+
+ var info = _objectSpread({}, this._info, {
+ total_time_spent: total_time_spent
+ });
+
+ if (DEBUG) {
+ var derived = {
+ avg_blankness: this._info.pixels_blank / this._info.pixels_sampled,
+ avg_speed: this._info.pixels_scrolled / (total_time_spent / 1000),
+ avg_speed_when_any_blank: this._info.any_blank_speed_sum / this._info.any_blank_count,
+ any_blank_per_min: this._info.any_blank_count / (total_time_spent / 1000 / 60),
+ any_blank_time_frac: this._info.any_blank_ms / total_time_spent,
+ mostly_blank_per_min: this._info.mostly_blank_count / (total_time_spent / 1000 / 60),
+ mostly_blank_time_frac: this._info.mostly_blank_ms / total_time_spent
+ };
+
+ for (var key in derived) {
+ derived[key] = Math.round(1000 * derived[key]) / 1000;
+ }
+
+ console.debug('FillRateHelper deactivateAndFlush: ', {
+ derived: derived,
+ info: info
+ });
+ }
+
+ _listeners.forEach(function (listener) {
+ return listener(info);
+ });
+
+ this._resetData();
+ }
+ }, {
+ key: "computeBlankness",
+ value: function computeBlankness(props, state, scrollMetrics) {
+ if (!this._enabled || props.getItemCount(props.data) === 0 || this._samplesStartTime == null) {
+ return 0;
+ }
+
+ var dOffset = scrollMetrics.dOffset,
+ offset = scrollMetrics.offset,
+ velocity = scrollMetrics.velocity,
+ visibleLength = scrollMetrics.visibleLength;
+ this._info.sample_count++;
+ this._info.pixels_sampled += Math.round(visibleLength);
+ this._info.pixels_scrolled += Math.round(Math.abs(dOffset));
+ var scrollSpeed = Math.round(Math.abs(velocity) * 1000);
+ var now = performanceNow();
+
+ if (this._anyBlankStartTime != null) {
+ this._info.any_blank_ms += now - this._anyBlankStartTime;
+ }
+
+ this._anyBlankStartTime = null;
+
+ if (this._mostlyBlankStartTime != null) {
+ this._info.mostly_blank_ms += now - this._mostlyBlankStartTime;
+ }
+
+ this._mostlyBlankStartTime = null;
+ var blankTop = 0;
+ var first = state.first;
+
+ var firstFrame = this._getFrameMetrics(first);
+
+ while (first <= state.last && (!firstFrame || !firstFrame.inLayout)) {
+ firstFrame = this._getFrameMetrics(first);
+ first++;
+ }
+
+ if (firstFrame && first > 0) {
+ blankTop = Math.min(visibleLength, Math.max(0, firstFrame.offset - offset));
+ }
+
+ var blankBottom = 0;
+ var last = state.last;
+
+ var lastFrame = this._getFrameMetrics(last);
+
+ while (last >= state.first && (!lastFrame || !lastFrame.inLayout)) {
+ lastFrame = this._getFrameMetrics(last);
+ last--;
+ }
+
+ if (lastFrame && last < props.getItemCount(props.data) - 1) {
+ var bottomEdge = lastFrame.offset + lastFrame.length;
+ blankBottom = Math.min(visibleLength, Math.max(0, offset + visibleLength - bottomEdge));
+ }
+
+ var pixels_blank = Math.round(blankTop + blankBottom);
+ var blankness = pixels_blank / visibleLength;
+
+ if (blankness > 0) {
+ this._anyBlankStartTime = now;
+ this._info.any_blank_speed_sum += scrollSpeed;
+ this._info.any_blank_count++;
+ this._info.pixels_blank += pixels_blank;
+
+ if (blankness > 0.5) {
+ this._mostlyBlankStartTime = now;
+ this._info.mostly_blank_count++;
+ }
+ } else if (scrollSpeed < 0.01 || Math.abs(dOffset) < 1) {
+ this.deactivateAndFlush();
+ }
+
+ return blankness;
+ }
+ }, {
+ key: "enabled",
+ value: function enabled() {
+ return this._enabled;
+ }
+ }, {
+ key: "_resetData",
+ value: function _resetData() {
+ this._anyBlankStartTime = null;
+ this._info = new Info();
+ this._mostlyBlankStartTime = null;
+ this._samplesStartTime = null;
+ }
+ }]);
+
+ return FillRateHelper;
+ }();
+
+ module.exports = FillRateHelper;
+},271,[32,4,3,120,21],"node_modules\\react-native\\Libraries\\Lists\\FillRateHelper.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _objectWithoutProperties = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/objectWithoutProperties");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Components\\RefreshControl\\RefreshControl.js";
+
+ var Platform = _$$_REQUIRE(_dependencyMap[7], "Platform");
+
+ var React = _$$_REQUIRE(_dependencyMap[8], "React");
+
+ var _require = _$$_REQUIRE(_dependencyMap[9], "ReactNative"),
+ NativeComponent = _require.NativeComponent;
+
+ var AndroidSwipeRefreshLayoutNativeComponent = _$$_REQUIRE(_dependencyMap[10], "AndroidSwipeRefreshLayoutNativeComponent");
+
+ var RCTRefreshControlNativeComponent = _$$_REQUIRE(_dependencyMap[11], "RCTRefreshControlNativeComponent");
+
+ var nullthrows = _$$_REQUIRE(_dependencyMap[12], "nullthrows");
+
+ var RefreshLayoutConsts;
+
+ if (Platform.OS === 'android') {
+ var AndroidSwipeRefreshLayout = _$$_REQUIRE(_dependencyMap[13], "UIManager").getViewManagerConfig('AndroidSwipeRefreshLayout');
+
+ RefreshLayoutConsts = AndroidSwipeRefreshLayout ? AndroidSwipeRefreshLayout.Constants : {
+ SIZE: {}
+ };
+ } else {
+ RefreshLayoutConsts = {
+ SIZE: {}
+ };
+ }
+
+ var RefreshControl = function (_React$Component) {
+ _inherits(RefreshControl, _React$Component);
+
+ function RefreshControl() {
+ var _getPrototypeOf2;
+
+ var _this;
+
+ _classCallCheck(this, RefreshControl);
+
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(RefreshControl)).call.apply(_getPrototypeOf2, [this].concat(args)));
+ _this._lastNativeRefreshing = false;
+
+ _this._onRefresh = function () {
+ _this._lastNativeRefreshing = true;
+ _this.props.onRefresh && _this.props.onRefresh();
+
+ _this.forceUpdate();
+ };
+
+ return _this;
+ }
+
+ _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 && this._setNativePropsOnRef) {
+ this._setNativePropsOnRef({
+ refreshing: this.props.refreshing
+ });
+
+ this._lastNativeRefreshing = this.props.refreshing;
+ }
+ }
+ }, {
+ key: "render",
+ value: function render() {
+ var _this2 = this;
+
+ var setRef = function setRef(ref) {
+ return _this2._setNativePropsOnRef = ref ? ref.setNativeProps.bind(ref) : null;
+ };
+
+ if (Platform.OS === 'ios') {
+ var _this$props = this.props,
+ enabled = _this$props.enabled,
+ colors = _this$props.colors,
+ progressBackgroundColor = _this$props.progressBackgroundColor,
+ size = _this$props.size,
+ progressViewOffset = _this$props.progressViewOffset,
+ props = _objectWithoutProperties(_this$props, ["enabled", "colors", "progressBackgroundColor", "size", "progressViewOffset"]);
+
+ return React.createElement(RCTRefreshControlNativeComponent, _extends({}, props, {
+ ref: setRef,
+ onRefresh: this._onRefresh,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 178
+ }
+ }));
+ } else {
+ var _this$props2 = this.props,
+ tintColor = _this$props2.tintColor,
+ titleColor = _this$props2.titleColor,
+ title = _this$props2.title,
+ _props = _objectWithoutProperties(_this$props2, ["tintColor", "titleColor", "title"]);
+
+ return React.createElement(AndroidSwipeRefreshLayoutNativeComponent, _extends({}, _props, {
+ ref: setRef,
+ onRefresh: this._onRefresh,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 187
+ }
+ }));
+ }
+ }
+ }]);
+
+ return RefreshControl;
+ }(React.Component);
+
+ RefreshControl.SIZE = RefreshLayoutConsts.SIZE;
+ module.exports = RefreshControl;
+},272,[14,33,3,4,5,8,9,35,52,84,273,274,220,71],"node_modules\\react-native\\Libraries\\Components\\RefreshControl\\RefreshControl.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var requireNativeComponent = _$$_REQUIRE(_dependencyMap[0], "requireNativeComponent");
+
+ var AndroidSwipeRefreshLayout = _$$_REQUIRE(_dependencyMap[1], "UIManager").getViewManagerConfig('AndroidSwipeRefreshLayout');
+
+ var RefreshLayoutConsts = AndroidSwipeRefreshLayout ? AndroidSwipeRefreshLayout.Constants : {
+ SIZE: {}
+ };
+ module.exports = requireNativeComponent('AndroidSwipeRefreshLayout');
+},273,[184,71],"node_modules\\react-native\\Libraries\\Components\\RefreshControl\\AndroidSwipeRefreshLayoutNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var requireNativeComponent = _$$_REQUIRE(_dependencyMap[0], "requireNativeComponent");
+
+ module.exports = requireNativeComponent('RCTRefreshControl');
+},274,[184],"node_modules\\react-native\\Libraries\\Components\\RefreshControl\\RCTRefreshControlNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _assertThisInitialized = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/assertThisInitialized");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits");
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/defineProperty");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Components\\ScrollView\\ScrollView.js";
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var AnimatedImplementation = _$$_REQUIRE(_dependencyMap[8], "AnimatedImplementation");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[9], "Platform");
+
+ var React = _$$_REQUIRE(_dependencyMap[10], "React");
+
+ var ReactNative = _$$_REQUIRE(_dependencyMap[11], "ReactNative");
+
+ var ScrollResponder = _$$_REQUIRE(_dependencyMap[12], "ScrollResponder");
+
+ var ScrollViewStickyHeader = _$$_REQUIRE(_dependencyMap[13], "ScrollViewStickyHeader");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[14], "StyleSheet");
+
+ var View = _$$_REQUIRE(_dependencyMap[15], "View");
+
+ var InternalScrollViewType = _$$_REQUIRE(_dependencyMap[16], "InternalScrollViewType");
+
+ var dismissKeyboard = _$$_REQUIRE(_dependencyMap[17], "dismissKeyboard");
+
+ var flattenStyle = _$$_REQUIRE(_dependencyMap[18], "flattenStyle");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[19], "invariant");
+
+ var processDecelerationRate = _$$_REQUIRE(_dependencyMap[20], "processDecelerationRate");
+
+ var requireNativeComponent = _$$_REQUIRE(_dependencyMap[21], "requireNativeComponent");
+
+ var resolveAssetSource = _$$_REQUIRE(_dependencyMap[22], "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');
+ }
+
+ function createScrollResponder(node) {
+ var scrollResponder = _objectSpread({}, ScrollResponder.Mixin);
+
+ for (var key in scrollResponder) {
+ if (typeof scrollResponder[key] === 'function') {
+ scrollResponder[key] = scrollResponder[key].bind(node);
+ }
+ }
+
+ return scrollResponder;
+ }
+
+ var ScrollView = function (_React$Component) {
+ _inherits(ScrollView, _React$Component);
+
+ function ScrollView() {
+ var _getPrototypeOf2;
+
+ var _this;
+
+ _classCallCheck(this, ScrollView);
+
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(ScrollView)).call.apply(_getPrototypeOf2, [this].concat(args)));
+ _this._scrollResponder = createScrollResponder(_assertThisInitialized(_this));
+ _this._scrollAnimatedValue = new AnimatedImplementation.Value(0);
+ _this._scrollAnimatedValueAttachment = null;
+ _this._stickyHeaderRefs = new Map();
+ _this._headerLayoutYs = new Map();
+ _this.state = _objectSpread({
+ layoutHeight: null
+ }, ScrollResponder.Mixin.scrollResponderMixinGetInitialState());
+
+ _this._handleKeyDown = function (e) {
+ if (_this.props.onKeyDown) {
+ _this.props.onKeyDown(e);
+ } else {
+ var _event = e.nativeEvent;
+ var key = _event.key;
+ var kMinScrollOffset = 10;
+
+ if (Platform.OS === 'macos') {
+ if (key === 'PAGE_UP') {
+ _this._handleScrollByKeyDown(_event, {
+ x: _event.contentOffset.x,
+ y: _event.contentOffset.y + -_event.layoutMeasurement.height
+ });
+ } else if (key === 'PAGE_DOWN') {
+ _this._handleScrollByKeyDown(_event, {
+ x: _event.contentOffset.x,
+ y: _event.contentOffset.y + _event.layoutMeasurement.height
+ });
+ } else if (key === 'LEFT_ARROW') {
+ _this._handleScrollByKeyDown(_event, {
+ x: _event.contentOffset.x + -(_this.props.horizontalLineScroll || kMinScrollOffset),
+ y: _event.contentOffset.y
+ });
+ } else if (key === 'RIGHT_ARROW') {
+ _this._handleScrollByKeyDown(_event, {
+ x: _event.contentOffset.x + (_this.props.horizontalLineScroll || kMinScrollOffset),
+ y: _event.contentOffset.y
+ });
+ } else if (key === 'DOWN_ARROW') {
+ _this._handleScrollByKeyDown(_event, {
+ x: _event.contentOffset.x,
+ y: _event.contentOffset.y + (_this.props.verticalLineScroll || kMinScrollOffset)
+ });
+ } else if (key === 'UP_ARROW') {
+ _this._handleScrollByKeyDown(_event, {
+ x: _event.contentOffset.x,
+ y: _event.contentOffset.y + -(_this.props.verticalLineScroll || kMinScrollOffset)
+ });
+ }
+ }
+ }
+ };
+
+ _this._handleScrollByKeyDown = function (e, newOffset) {
+ var maxX = e.contentSize.width - e.layoutMeasurement.width;
+ var maxY = e.contentSize.height - e.layoutMeasurement.height;
+
+ _this.scrollTo({
+ x: Math.max(0, Math.min(maxX, newOffset.x)),
+ y: Math.max(0, Math.min(maxY, newOffset.y))
+ });
+ };
+
+ _this._handleScroll = function (e) {
+ if (__DEV__) {
+ if (_this.props.onScroll && _this.props.scrollEventThrottle == null && (Platform.OS === 'ios' || Platform.OS === 'macos')) {
+ console.log('You specified `onScroll` on a 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._scrollResponder.scrollResponderHandleScroll(e);
+ };
+
+ _this._handleLayout = function (e) {
+ if (_this.props.invertStickyHeaders) {
+ _this.setState({
+ layoutHeight: e.nativeEvent.layout.height
+ });
+ }
+
+ if (_this.props.onLayout) {
+ _this.props.onLayout(e);
+ }
+ };
+
+ _this._handleContentOnLayout = function (e) {
+ var _e$nativeEvent$layout = e.nativeEvent.layout,
+ width = _e$nativeEvent$layout.width,
+ height = _e$nativeEvent$layout.height;
+ _this.props.onContentSizeChange && _this.props.onContentSizeChange(width, height);
+ };
+
+ _this._scrollViewRef = null;
+
+ _this._setScrollViewRef = function (ref) {
+ _this._scrollViewRef = ref;
+ };
+
+ _this._innerViewRef = null;
+
+ _this._setInnerViewRef = function (ref) {
+ _this._innerViewRef = ref;
+ };
+
+ for (var key in ScrollResponder.Mixin) {
+ if (typeof ScrollResponder.Mixin[key] === 'function' && key.startsWith('scrollResponder')) {
+ _assertThisInitialized(_this)[key] = ScrollResponder.Mixin[key].bind(_assertThisInitialized(_this));
+ }
+ }
+
+ Object.keys(ScrollResponder.Mixin).filter(function (key) {
+ return typeof ScrollResponder.Mixin[key] !== 'function';
+ }).forEach(function (key) {
+ _assertThisInitialized(_this)[key] = ScrollResponder.Mixin[key];
+ });
+ return _this;
+ }
+
+ _createClass(ScrollView, [{
+ key: "UNSAFE_componentWillMount",
+ value: function UNSAFE_componentWillMount() {
+ this._scrollResponder.UNSAFE_componentWillMount();
+
+ this._scrollAnimatedValue = new AnimatedImplementation.Value(this.props.contentOffset ? this.props.contentOffset.y : 0);
+
+ this._scrollAnimatedValue.setOffset(this.props.contentInset ? this.props.contentInset.top : 0);
+
+ this._stickyHeaderRefs = new Map();
+ this._headerLayoutYs = new Map();
+ }
+ }, {
+ key: "componentDidMount",
+ value: function componentDidMount() {
+ this._updateAnimatedNodeAttachment();
+ }
+ }, {
+ key: "componentDidUpdate",
+ value: function componentDidUpdate() {
+ this._updateAnimatedNodeAttachment();
+ }
+ }, {
+ key: "componentWillUnmount",
+ value: function componentWillUnmount() {
+ this._scrollResponder.componentWillUnmount();
+
+ if (this._scrollAnimatedValueAttachment) {
+ this._scrollAnimatedValueAttachment.detach();
+ }
+ }
+ }, {
+ key: "setNativeProps",
+ value: function setNativeProps(props) {
+ this._scrollViewRef && this._scrollViewRef.setNativeProps(props);
+ }
+ }, {
+ key: "getScrollResponder",
+ value: function getScrollResponder() {
+ return this;
+ }
+ }, {
+ key: "getScrollableNode",
+ value: function getScrollableNode() {
+ return ReactNative.findNodeHandle(this._scrollViewRef);
+ }
+ }, {
+ key: "getInnerViewNode",
+ value: function getInnerViewNode() {
+ return ReactNative.findNodeHandle(this._innerViewRef);
+ }
+ }, {
+ key: "scrollTo",
+ value: 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._scrollResponder.scrollResponderScrollTo({
+ x: x || 0,
+ y: y || 0,
+ animated: animated !== false
+ });
+ }
+ }, {
+ key: "scrollToEnd",
+ value: function scrollToEnd(options) {
+ var animated = (options && options.animated) !== false;
+
+ this._scrollResponder.scrollResponderScrollToEnd({
+ animated: animated
+ });
+ }
+ }, {
+ key: "scrollWithoutAnimationTo",
+ value: function scrollWithoutAnimationTo() {
+ var y = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+ var x = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+ console.warn('`scrollWithoutAnimationTo` is deprecated. Use `scrollTo` instead');
+ this.scrollTo({
+ x: x,
+ y: y,
+ animated: false
+ });
+ }
+ }, {
+ key: "flashScrollIndicators",
+ value: function flashScrollIndicators() {
+ this._scrollResponder.scrollResponderFlashScrollIndicators();
+ }
+ }, {
+ key: "_getKeyForIndex",
+ value: function _getKeyForIndex(index, childArray) {
+ var child = childArray[index];
+ return child && child.key;
+ }
+ }, {
+ key: "_updateAnimatedNodeAttachment",
+ value: function _updateAnimatedNodeAttachment() {
+ if (this._scrollAnimatedValueAttachment) {
+ this._scrollAnimatedValueAttachment.detach();
+ }
+
+ if (this.props.stickyHeaderIndices && this.props.stickyHeaderIndices.length > 0) {
+ this._scrollAnimatedValueAttachment = AnimatedImplementation.attachNativeEvent(this._scrollViewRef, 'onScroll', [{
+ nativeEvent: {
+ contentOffset: {
+ y: this._scrollAnimatedValue
+ }
+ }
+ }]);
+ }
+ }
+ }, {
+ key: "_setStickyHeaderRef",
+ value: function _setStickyHeaderRef(key, ref) {
+ if (ref) {
+ this._stickyHeaderRefs.set(key, ref);
+ } else {
+ this._stickyHeaderRefs.delete(key);
+ }
+ }
+ }, {
+ key: "_onStickyHeaderLayout",
+ value: function _onStickyHeaderLayout(index, event, key) {
+ var stickyHeaderIndices = this.props.stickyHeaderIndices;
+
+ if (!stickyHeaderIndices) {
+ return;
+ }
+
+ var childArray = React.Children.toArray(this.props.children);
+
+ if (key !== this._getKeyForIndex(index, childArray)) {
+ return;
+ }
+
+ var layoutY = event.nativeEvent.layout.y;
+
+ this._headerLayoutYs.set(key, layoutY);
+
+ var indexOfIndex = stickyHeaderIndices.indexOf(index);
+ var previousHeaderIndex = stickyHeaderIndices[indexOfIndex - 1];
+
+ if (previousHeaderIndex != null) {
+ var previousHeader = this._stickyHeaderRefs.get(this._getKeyForIndex(previousHeaderIndex, childArray));
+
+ previousHeader && previousHeader.setNextHeaderY(layoutY);
+ }
+ }
+ }, {
+ key: "render",
+ value: function render() {
+ var _this2 = this;
+
+ var ScrollViewClass;
+ var ScrollContentContainerViewClass;
+
+ if (Platform.OS === 'android') {
+ if (this.props.horizontal) {
+ ScrollViewClass = AndroidHorizontalScrollView;
+ ScrollContentContainerViewClass = AndroidHorizontalScrollContentView;
+ } else {
+ ScrollViewClass = AndroidScrollView;
+ ScrollContentContainerViewClass = View;
+ }
+ } else if (Platform.OS === 'windesktop') {
+ ScrollViewClass = RCTScrollView;
+ ScrollContentContainerViewClass = View;
+ } else {
+ ScrollViewClass = RCTScrollView;
+ ScrollContentContainerViewClass = RCTScrollContentView;
+ }
+
+ invariant(ScrollViewClass !== undefined, 'ScrollViewClass must not be undefined');
+ invariant(ScrollContentContainerViewClass !== undefined, 'ScrollContentContainerViewClass must not be undefined');
+ var contentContainerStyle = [this.props.horizontal && 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 children = this.props.children;
+
+ if (stickyHeaderIndices != null && stickyHeaderIndices.length > 0) {
+ var childArray = React.Children.toArray(this.props.children);
+ children = childArray.map(function (child, index) {
+ var indexOfIndex = child ? stickyHeaderIndices.indexOf(index) : -1;
+
+ if (indexOfIndex > -1) {
+ var key = child.key;
+ var nextIndex = stickyHeaderIndices[indexOfIndex + 1];
+ return React.createElement(ScrollViewStickyHeader, {
+ key: key,
+ ref: function ref(_ref2) {
+ return _this2._setStickyHeaderRef(key, _ref2);
+ },
+ nextHeaderLayoutY: _this2._headerLayoutYs.get(_this2._getKeyForIndex(nextIndex, childArray)),
+ onLayout: function onLayout(event) {
+ return _this2._onStickyHeaderLayout(index, event, key);
+ },
+ scrollAnimatedValue: _this2._scrollAnimatedValue,
+ inverted: _this2.props.invertStickyHeaders,
+ scrollViewHeight: _this2.state.layoutHeight,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 1009
+ }
+ }, child);
+ } else {
+ return child;
+ }
+ });
+ }
+
+ var hasStickyHeaders = stickyHeaderIndices && stickyHeaderIndices.length > 0;
+ 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: 1032
+ }
+ }), 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,
+ onKeyDown: this._handleKeyDown,
+ onLayout: this._handleLayout,
+ onMomentumScrollBegin: this._scrollResponder.scrollResponderHandleMomentumScrollBegin,
+ onMomentumScrollEnd: this._scrollResponder.scrollResponderHandleMomentumScrollEnd,
+ onResponderGrant: this._scrollResponder.scrollResponderHandleResponderGrant,
+ onResponderReject: this._scrollResponder.scrollResponderHandleResponderReject,
+ onResponderRelease: this._scrollResponder.scrollResponderHandleResponderRelease,
+ onResponderTerminate: this._scrollResponder.scrollResponderHandleTerminate,
+ onResponderTerminationRequest: this._scrollResponder.scrollResponderHandleTerminationRequest,
+ onScrollBeginDrag: this._scrollResponder.scrollResponderHandleScrollBeginDrag,
+ onScrollEndDrag: this._scrollResponder.scrollResponderHandleScrollEndDrag,
+ onScrollShouldSetResponder: this._scrollResponder.scrollResponderHandleScrollShouldSetResponder,
+ onStartShouldSetResponder: this._scrollResponder.scrollResponderHandleStartShouldSetResponder,
+ onStartShouldSetResponderCapture: this._scrollResponder.scrollResponderHandleStartShouldSetResponderCapture,
+ onTouchEnd: this._scrollResponder.scrollResponderHandleTouchEnd,
+ onTouchMove: this._scrollResponder.scrollResponderHandleTouchMove,
+ onTouchStart: this._scrollResponder.scrollResponderHandleTouchStart,
+ onTouchCancel: this._scrollResponder.scrollResponderHandleTouchCancel,
+ onScroll: this._handleScroll,
+ scrollBarThumbImage: resolveAssetSource(this.props.scrollBarThumbImage),
+ scrollEventThrottle: hasStickyHeaders ? 1 : this.props.scrollEventThrottle,
+ sendMomentumEvents: this.props.onMomentumScrollBegin || this.props.onMomentumScrollEnd ? true : false,
+ DEPRECATED_sendUpdatedChildFrames: DEPRECATED_sendUpdatedChildFrames,
+ snapToStart: this.props.snapToStart !== false,
+ snapToEnd: this.props.snapToEnd !== false,
+ pagingEnabled: Platform.select({
+ ios: this.props.pagingEnabled && this.props.snapToInterval == null && this.props.snapToOffsets == null,
+ macos: this.props.pagingEnabled && this.props.snapToInterval == null && this.props.snapToOffsets == null,
+ android: this.props.pagingEnabled || this.props.snapToInterval != null || this.props.snapToOffsets != null
+ })
+ });
+
+ var decelerationRate = this.props.decelerationRate;
+
+ if (decelerationRate != null) {
+ props.decelerationRate = processDecelerationRate(decelerationRate);
+ }
+
+ var refreshControl = this.props.refreshControl;
+
+ if (refreshControl) {
+ if (Platform.OS === 'ios') {
+ return React.createElement(ScrollViewClass, _extends({}, props, {
+ ref: this._setScrollViewRef,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 1150
+ }
+ }), 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: 1165
+ }
+ }), contentContainer));
+ }
+ }
+
+ return React.createElement(ScrollViewClass, _extends({}, props, {
+ ref: this._setScrollViewRef,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 1177
+ }
+ }), contentContainer);
+ }
+ }]);
+
+ return ScrollView;
+ }(React.Component);
+
+ 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;
+},275,[14,3,4,5,8,7,9,32,247,35,52,84,276,281,53,81,282,280,80,19,283,184,190],"node_modules\\react-native\\Libraries\\Components\\ScrollView\\ScrollView.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var Dimensions = _$$_REQUIRE(_dependencyMap[0], "Dimensions");
+
+ var FrameRateLogger = _$$_REQUIRE(_dependencyMap[1], "FrameRateLogger");
+
+ var Keyboard = _$$_REQUIRE(_dependencyMap[2], "Keyboard");
+
+ var ReactNative = _$$_REQUIRE(_dependencyMap[3], "ReactNative");
+
+ var TextInputState = _$$_REQUIRE(_dependencyMap[4], "TextInputState");
+
+ var UIManager = _$$_REQUIRE(_dependencyMap[5], "UIManager");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[6], "invariant");
+
+ var nullthrows = _$$_REQUIRE(_dependencyMap[7], "nullthrows");
+
+ var performanceNow = _$$_REQUIRE(_dependencyMap[8], "fbjs/lib/performanceNow");
+
+ var warning = _$$_REQUIRE(_dependencyMap[9], "fbjs/lib/warning");
+
+ var _require = _$$_REQUIRE(_dependencyMap[10], "NativeModules"),
+ ScrollViewManager = _require.ScrollViewManager;
+
+ var IS_ANIMATING_TOUCH_START_THRESHOLD_MS = 16;
+ var ScrollResponderMixin = {
+ _subscriptionKeyboardWillShow: null,
+ _subscriptionKeyboardWillHide: null,
+ _subscriptionKeyboardDidShow: null,
+ _subscriptionKeyboardDidHide: null,
+ scrollResponderMixinGetInitialState: function scrollResponderMixinGetInitialState() {
+ return {
+ isTouching: false,
+ lastMomentumScrollBeginTime: 0,
+ lastMomentumScrollEndTime: 0,
+ observedScrollSinceBecomingResponder: false,
+ becameResponderWhileAnimating: false
+ };
+ },
+ scrollResponderHandleScrollShouldSetResponder: function scrollResponderHandleScrollShouldSetResponder() {
+ 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 && e.target && !TextInputState.isTextInput(e.target)) {
+ return true;
+ }
+
+ return false;
+ },
+ scrollResponderHandleResponderReject: function scrollResponderHandleResponderReject() {},
+ scrollResponderHandleTerminationRequest: function scrollResponderHandleTerminationRequest() {
+ return !this.state.observedScrollSinceBecomingResponder;
+ },
+ scrollResponderHandleTouchEnd: function scrollResponderHandleTouchEnd(e) {
+ var nativeEvent = e.nativeEvent;
+ this.state.isTouching = nativeEvent.touches.length !== 0;
+ this.props.onTouchEnd && this.props.onTouchEnd(e);
+ },
+ scrollResponderHandleTouchCancel: function scrollResponderHandleTouchCancel(e) {
+ this.state.isTouching = false;
+ this.props.onTouchCancel && this.props.onTouchCancel(e);
+ },
+ scrollResponderHandleResponderRelease: function scrollResponderHandleResponderRelease(e) {
+ this.props.onResponderRelease && this.props.onResponderRelease(e);
+ var currentlyFocusedTextInput = TextInputState.currentlyFocusedField();
+
+ if (this.props.keyboardShouldPersistTaps !== true && this.props.keyboardShouldPersistTaps !== 'always' && currentlyFocusedTextInput != null && e.target !== currentlyFocusedTextInput && !this.state.observedScrollSinceBecomingResponder && !this.state.becameResponderWhileAnimating) {
+ this.props.onScrollResponderKeyboardDismissed && this.props.onScrollResponderKeyboardDismissed(e);
+ TextInputState.blurTextInput(currentlyFocusedTextInput);
+ }
+ },
+ scrollResponderHandleScroll: function scrollResponderHandleScroll(e) {
+ this.state.observedScrollSinceBecomingResponder = true;
+ this.props.onScroll && this.props.onScroll(e);
+ },
+ scrollResponderHandleResponderGrant: function scrollResponderHandleResponderGrant(e) {
+ this.state.observedScrollSinceBecomingResponder = false;
+ this.props.onResponderGrant && this.props.onResponderGrant(e);
+ this.state.becameResponderWhileAnimating = this.scrollResponderIsAnimating();
+ },
+ scrollResponderHandleScrollBeginDrag: function scrollResponderHandleScrollBeginDrag(e) {
+ FrameRateLogger.beginScroll();
+ this.props.onScrollBeginDrag && this.props.onScrollBeginDrag(e);
+ },
+ scrollResponderHandleScrollEndDrag: function scrollResponderHandleScrollEndDrag(e) {
+ var velocity = e.nativeEvent.velocity;
+
+ if (!this.scrollResponderIsAnimating() && (!velocity || velocity.x === 0 && velocity.y === 0)) {
+ FrameRateLogger.endScroll();
+ }
+
+ this.props.onScrollEndDrag && this.props.onScrollEndDrag(e);
+ },
+ scrollResponderHandleMomentumScrollBegin: function scrollResponderHandleMomentumScrollBegin(e) {
+ this.state.lastMomentumScrollBeginTime = performanceNow();
+ this.props.onMomentumScrollBegin && this.props.onMomentumScrollBegin(e);
+ },
+ scrollResponderHandleMomentumScrollEnd: function scrollResponderHandleMomentumScrollEnd(e) {
+ FrameRateLogger.endScroll();
+ this.state.lastMomentumScrollEndTime = performanceNow();
+ this.props.onMomentumScrollEnd && this.props.onMomentumScrollEnd(e);
+ },
+ scrollResponderHandleTouchStart: function scrollResponderHandleTouchStart(e) {
+ this.state.isTouching = true;
+ this.props.onTouchStart && this.props.onTouchStart(e);
+ },
+ scrollResponderHandleTouchMove: function scrollResponderHandleTouchMove(e) {
+ this.props.onTouchMove && this.props.onTouchMove(e);
+ },
+ scrollResponderIsAnimating: function scrollResponderIsAnimating() {
+ var now = performanceNow();
+ var timeSinceLastMomentumScrollEnd = now - this.state.lastMomentumScrollEndTime;
+ var isAnimating = timeSinceLastMomentumScrollEnd < IS_ANIMATING_TOUCH_START_THRESHOLD_MS || this.state.lastMomentumScrollEndTime < this.state.lastMomentumScrollBeginTime;
+ return isAnimating;
+ },
+ scrollResponderGetScrollableNode: function scrollResponderGetScrollableNode() {
+ return this.getScrollableNode ? this.getScrollableNode() : ReactNative.findNodeHandle(this);
+ },
+ scrollResponderScrollTo: function scrollResponderScrollTo(x, y, animated) {
+ if (typeof x === 'number') {
+ console.warn('`scrollResponderScrollTo(x, y, animated)` is deprecated. Use `scrollResponderScrollTo({x: 5, y: 5, animated: true})` instead.');
+ } else {
+ var _ref = x || {};
+
+ x = _ref.x;
+ y = _ref.y;
+ animated = _ref.animated;
+ }
+
+ UIManager.dispatchViewManagerCommand(nullthrows(this.scrollResponderGetScrollableNode()), UIManager.getViewManagerConfig('RCTScrollView').Commands.scrollTo, [x || 0, y || 0, animated !== false]);
+ },
+ scrollResponderScrollToEnd: function scrollResponderScrollToEnd(options) {
+ var animated = (options && options.animated) !== false;
+ UIManager.dispatchViewManagerCommand(this.scrollResponderGetScrollableNode(), UIManager.getViewManagerConfig('RCTScrollView').Commands.scrollToEnd, [animated]);
+ },
+ scrollResponderScrollWithoutAnimationTo: function scrollResponderScrollWithoutAnimationTo(offsetX, offsetY) {
+ console.warn('`scrollResponderScrollWithoutAnimationTo` is deprecated. Use `scrollResponderScrollTo` instead');
+ this.scrollResponderScrollTo({
+ x: offsetX,
+ y: offsetY,
+ animated: false
+ });
+ },
+ scrollResponderZoomTo: function scrollResponderZoomTo(rect, animated) {
+ invariant(ScrollViewManager && ScrollViewManager.zoomToRect, 'zoomToRect is not implemented');
+
+ if ('animated' in rect) {
+ animated = rect.animated;
+ delete rect.animated;
+ } else if (typeof animated !== 'undefined') {
+ console.warn('`scrollResponderZoomTo` `animated` argument is deprecated. Use `options.animated` instead');
+ }
+
+ ScrollViewManager.zoomToRect(this.scrollResponderGetScrollableNode(), rect, animated !== false);
+ },
+ scrollResponderFlashScrollIndicators: function scrollResponderFlashScrollIndicators() {
+ UIManager.dispatchViewManagerCommand(this.scrollResponderGetScrollableNode(), UIManager.getViewManagerConfig('RCTScrollView').Commands.flashScrollIndicators, []);
+ },
+ scrollResponderScrollNativeHandleToKeyboard: function scrollResponderScrollNativeHandleToKeyboard(nodeHandle, additionalOffset, preventNegativeScrollOffset) {
+ this.additionalScrollOffset = additionalOffset || 0;
+ this.preventNegativeScrollOffset = !!preventNegativeScrollOffset;
+ UIManager.measureLayout(nodeHandle, ReactNative.findNodeHandle(this.getInnerViewNode()), this.scrollResponderTextInputFocusError, this.scrollResponderInputMeasureAndScrollToKeyboard);
+ },
+ scrollResponderInputMeasureAndScrollToKeyboard: function scrollResponderInputMeasureAndScrollToKeyboard(left, top, width, height) {
+ var keyboardScreenY = Dimensions.get('window').height;
+
+ if (this.keyboardWillOpenTo) {
+ keyboardScreenY = this.keyboardWillOpenTo.endCoordinates.screenY;
+ }
+
+ var scrollOffsetY = top - keyboardScreenY + height + this.additionalScrollOffset;
+
+ if (this.preventNegativeScrollOffset) {
+ scrollOffsetY = Math.max(0, scrollOffsetY);
+ }
+
+ this.scrollResponderScrollTo({
+ x: 0,
+ y: scrollOffsetY,
+ animated: true
+ });
+ this.additionalOffset = 0;
+ this.preventNegativeScrollOffset = false;
+ },
+ scrollResponderTextInputFocusError: function scrollResponderTextInputFocusError(msg) {
+ console.error('Error measuring text field: ', msg);
+ },
+ UNSAFE_componentWillMount: function UNSAFE_componentWillMount() {
+ var keyboardShouldPersistTaps = this.props.keyboardShouldPersistTaps;
+ warning(typeof keyboardShouldPersistTaps !== 'boolean', "'keyboardShouldPersistTaps={" + keyboardShouldPersistTaps + "}' is deprecated. " + ("Use 'keyboardShouldPersistTaps=\"" + (keyboardShouldPersistTaps ? 'always' : 'never') + "\"' instead"));
+ this.keyboardWillOpenTo = null;
+ this.additionalScrollOffset = 0;
+ this._subscriptionKeyboardWillShow = Keyboard.addListener('keyboardWillShow', this.scrollResponderKeyboardWillShow);
+ this._subscriptionKeyboardWillHide = Keyboard.addListener('keyboardWillHide', this.scrollResponderKeyboardWillHide);
+ this._subscriptionKeyboardDidShow = Keyboard.addListener('keyboardDidShow', this.scrollResponderKeyboardDidShow);
+ this._subscriptionKeyboardDidHide = Keyboard.addListener('keyboardDidHide', this.scrollResponderKeyboardDidHide);
+ },
+ componentWillUnmount: function componentWillUnmount() {
+ if (this._subscriptionKeyboardWillShow != null) {
+ this._subscriptionKeyboardWillShow.remove();
+ }
+
+ if (this._subscriptionKeyboardWillHide != null) {
+ this._subscriptionKeyboardWillHide.remove();
+ }
+
+ if (this._subscriptionKeyboardDidShow != null) {
+ this._subscriptionKeyboardDidShow.remove();
+ }
+
+ if (this._subscriptionKeyboardDidHide != null) {
+ this._subscriptionKeyboardDidHide.remove();
+ }
+ },
+ scrollResponderKeyboardWillShow: function scrollResponderKeyboardWillShow(e) {
+ this.keyboardWillOpenTo = e;
+ this.props.onKeyboardWillShow && this.props.onKeyboardWillShow(e);
+ },
+ scrollResponderKeyboardWillHide: function scrollResponderKeyboardWillHide(e) {
+ this.keyboardWillOpenTo = null;
+ this.props.onKeyboardWillHide && this.props.onKeyboardWillHide(e);
+ },
+ scrollResponderKeyboardDidShow: function scrollResponderKeyboardDidShow(e) {
+ if (e) {
+ this.keyboardWillOpenTo = e;
+ }
+
+ this.props.onKeyboardDidShow && this.props.onKeyboardDidShow(e);
+ },
+ scrollResponderKeyboardDidHide: function scrollResponderKeyboardDidHide(e) {
+ this.keyboardWillOpenTo = null;
+ this.props.onKeyboardDidHide && this.props.onKeyboardDidHide(e);
+ }
+ };
+ var ScrollResponder = {
+ Mixin: ScrollResponderMixin
+ };
+ module.exports = ScrollResponder;
+},276,[55,277,278,84,176,71,19,220,120,21,36],"node_modules\\react-native\\Libraries\\Components\\ScrollResponder.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var NativeModules = _$$_REQUIRE(_dependencyMap[0], "NativeModules");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[1], "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;
+},277,[36,19],"node_modules\\react-native\\Libraries\\Interaction\\FrameRateLogger.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var LayoutAnimation = _$$_REQUIRE(_dependencyMap[0], "LayoutAnimation");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[1], "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 != null && duration !== 0) {
+ LayoutAnimation.configureNext({
+ duration: duration,
+ update: {
+ duration: duration,
+ type: easing != null && LayoutAnimation.Types[easing] || 'keyboard'
+ }
+ });
+ }
+ };
+
+ module.exports = Keyboard;
+},278,[279,19,131,36,280],"node_modules\\react-native\\Libraries\\Components\\Keyboard\\Keyboard.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+
+ var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "Platform"));
+
+ var UIManager = _$$_REQUIRE(_dependencyMap[2], "UIManager");
+
+ function configureNext(config, onAnimationDidEnd) {
+ if (!_Platform.default.isTesting) {
+ var _onAnimationDidEnd;
+
+ UIManager.configureNextLayoutAnimation(config, (_onAnimationDidEnd = onAnimationDidEnd) != null ? _onAnimationDidEnd : function () {}, function () {});
+ }
+ }
+
+ function create(duration, type, property) {
+ return {
+ duration: duration,
+ create: {
+ type: type,
+ property: property
+ },
+ update: {
+ type: type
+ },
+ delete: {
+ type: type,
+ property: property
+ }
+ };
+ }
+
+ var Presets = {
+ easeInEaseOut: create(300, 'easeInEaseOut', 'opacity'),
+ linear: create(500, 'linear', 'opacity'),
+ spring: {
+ duration: 700,
+ create: {
+ type: 'linear',
+ property: 'opacity'
+ },
+ update: {
+ type: 'spring',
+ springDamping: 0.4
+ },
+ delete: {
+ type: 'linear',
+ property: 'opacity'
+ }
+ }
+ };
+ var LayoutAnimation = {
+ configureNext: configureNext,
+ create: create,
+ Types: Object.freeze({
+ spring: 'spring',
+ linear: 'linear',
+ easeInEaseOut: 'easeInEaseOut',
+ easeIn: 'easeIn',
+ easeOut: 'easeOut',
+ keyboard: 'keyboard'
+ }),
+ Properties: Object.freeze({
+ opacity: 'opacity',
+ scaleX: 'scaleX',
+ scaleY: 'scaleY',
+ scaleXY: 'scaleXY'
+ }),
+ checkConfig: function checkConfig() {
+ console.error('LayoutAnimation.checkConfig(...) has been disabled.');
+ },
+ Presets: Presets,
+ easeInEaseOut: configureNext.bind(null, Presets.easeInEaseOut),
+ linear: configureNext.bind(null, Presets.linear),
+ spring: configureNext.bind(null, Presets.spring)
+ };
+ module.exports = LayoutAnimation;
+},279,[1,35,71],"node_modules\\react-native\\Libraries\\LayoutAnimation\\LayoutAnimation.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var TextInputState = _$$_REQUIRE(_dependencyMap[0], "TextInputState");
+
+ function dismissKeyboard() {
+ TextInputState.blurTextInput(TextInputState.currentlyFocusedField());
+ }
+
+ module.exports = dismissKeyboard;
+},280,[176],"node_modules\\react-native\\Libraries\\Utilities\\dismissKeyboard.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Components\\ScrollView\\ScrollViewStickyHeader.js";
+
+ var AnimatedImplementation = _$$_REQUIRE(_dependencyMap[5], "AnimatedImplementation");
+
+ var React = _$$_REQUIRE(_dependencyMap[6], "React");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[7], "StyleSheet");
+
+ var View = _$$_REQUIRE(_dependencyMap[8], "View");
+
+ var AnimatedView = AnimatedImplementation.createAnimatedComponent(View);
+
+ var ScrollViewStickyHeader = function (_React$Component) {
+ _inherits(ScrollViewStickyHeader, _React$Component);
+
+ function ScrollViewStickyHeader() {
+ var _getPrototypeOf2;
+
+ var _this;
+
+ _classCallCheck(this, ScrollViewStickyHeader);
+
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(ScrollViewStickyHeader)).call.apply(_getPrototypeOf2, [this].concat(args)));
+ _this.state = {
+ measured: false,
+ layoutY: 0,
+ layoutHeight: 0,
+ nextHeaderLayoutY: _this.props.nextHeaderLayoutY
+ };
+
+ _this._onLayout = function (event) {
+ _this.setState({
+ measured: true,
+ layoutY: event.nativeEvent.layout.y,
+ layoutHeight: event.nativeEvent.layout.height
+ });
+
+ _this.props.onLayout(event);
+
+ var child = React.Children.only(_this.props.children);
+
+ if (child.props.onLayout) {
+ child.props.onLayout(event);
+ }
+ };
+
+ return _this;
+ }
+
+ _createClass(ScrollViewStickyHeader, [{
+ key: "setNextHeaderY",
+ value: function setNextHeaderY(y) {
+ this.setState({
+ nextHeaderLayoutY: y
+ });
+ }
+ }, {
+ key: "render",
+ value: function render() {
+ var _this$props = this.props,
+ inverted = _this$props.inverted,
+ scrollViewHeight = _this$props.scrollViewHeight;
+ var _this$state = this.state,
+ measured = _this$state.measured,
+ layoutHeight = _this$state.layoutHeight,
+ layoutY = _this$state.layoutY,
+ nextHeaderLayoutY = _this$state.nextHeaderLayoutY;
+ var inputRange = [-1, 0];
+ var outputRange = [0, 0];
+
+ if (measured) {
+ if (inverted) {
+ if (scrollViewHeight != null) {
+ var stickStartPoint = layoutY + layoutHeight - scrollViewHeight;
+
+ if (stickStartPoint > 0) {
+ inputRange.push(stickStartPoint);
+ outputRange.push(0);
+ inputRange.push(stickStartPoint + 1);
+ outputRange.push(1);
+ var collisionPoint = (nextHeaderLayoutY || 0) - layoutHeight - scrollViewHeight;
+
+ if (collisionPoint > stickStartPoint) {
+ inputRange.push(collisionPoint, collisionPoint + 1);
+ outputRange.push(collisionPoint - stickStartPoint, collisionPoint - stickStartPoint);
+ }
+ }
+ }
+ } else {
+ inputRange.push(layoutY);
+ outputRange.push(0);
+
+ var _collisionPoint = (nextHeaderLayoutY || 0) - layoutHeight;
+
+ if (_collisionPoint >= layoutY) {
+ inputRange.push(_collisionPoint, _collisionPoint + 1);
+ outputRange.push(_collisionPoint - layoutY, _collisionPoint - layoutY);
+ } else {
+ inputRange.push(layoutY + 1);
+ outputRange.push(1);
+ }
+ }
+ }
+
+ var translateY = this.props.scrollAnimatedValue.interpolate({
+ inputRange: inputRange,
+ outputRange: outputRange
+ });
+ var child = React.Children.only(this.props.children);
+ return React.createElement(AnimatedView, {
+ collapsable: false,
+ onLayout: this._onLayout,
+ style: [child.props.style, styles.header, {
+ transform: [{
+ translateY: translateY
+ }]
+ }],
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 141
+ }
+ }, React.cloneElement(child, {
+ style: styles.fill,
+ onLayout: undefined
+ }));
+ }
+ }]);
+
+ return ScrollViewStickyHeader;
+ }(React.Component);
+
+ var styles = StyleSheet.create({
+ header: {
+ zIndex: 10
+ },
+ fill: {
+ flex: 1
+ }
+ });
+ module.exports = ScrollViewStickyHeader;
+},281,[3,4,5,8,9,247,52,53,81],"node_modules\\react-native\\Libraries\\Components\\ScrollView\\ScrollViewStickyHeader.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var ReactNative = _$$_REQUIRE(_dependencyMap[5], "ReactNative");
+
+ var InternalScrollViewType = function (_ReactNative$NativeCo) {
+ "use strict";
+
+ _inherits(InternalScrollViewType, _ReactNative$NativeCo);
+
+ 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) {}
+ }]);
+
+ return InternalScrollViewType;
+ }(ReactNative.NativeComponent);
+
+ module.exports = InternalScrollViewType;
+},282,[3,4,5,8,9,84],"node_modules\\react-native\\Libraries\\Components\\ScrollView\\InternalScrollViewType.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var Platform = _$$_REQUIRE(_dependencyMap[0], "Platform");
+
+ function processDecelerationRate(decelerationRate) {
+ if (decelerationRate === 'normal') {
+ return Platform.select({
+ ios: 0.998,
+ android: 0.985
+ });
+ } else if (decelerationRate === 'fast') {
+ return Platform.select({
+ ios: 0.99,
+ android: 0.9
+ });
+ }
+
+ return decelerationRate;
+ }
+
+ module.exports = processDecelerationRate;
+},283,[35],"node_modules\\react-native\\Libraries\\Components\\ScrollView\\processDecelerationRate.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ var _slicedToArray = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var invariant = _$$_REQUIRE(_dependencyMap[4], "invariant");
+
+ var ViewabilityHelper = function () {
+ function ViewabilityHelper() {
+ var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
+ viewAreaCoveragePercentThreshold: 0
+ };
+
+ _classCallCheck(this, ViewabilityHelper);
+
+ this._hasInteracted = false;
+ this._timers = new Set();
+ this._viewableIndices = [];
+ this._viewableItems = new Map();
+ this._config = config;
+ }
+
+ _createClass(ViewabilityHelper, [{
+ key: "dispose",
+ value: function dispose() {
+ this._timers.forEach(clearTimeout);
+ }
+ }, {
+ key: "computeViewableItems",
+ value: function computeViewableItems(itemCount, scrollOffset, viewportHeight, getFrameMetrics, renderRange) {
+ var _this$_config = this._config,
+ itemVisiblePercentThreshold = _this$_config.itemVisiblePercentThreshold,
+ viewAreaCoveragePercentThreshold = _this$_config.viewAreaCoveragePercentThreshold;
+ var viewAreaMode = viewAreaCoveragePercentThreshold != null;
+ var viewablePercentThreshold = viewAreaMode ? viewAreaCoveragePercentThreshold : itemVisiblePercentThreshold;
+ invariant(viewablePercentThreshold != null && itemVisiblePercentThreshold != null !== (viewAreaCoveragePercentThreshold != null), 'Must set exactly one of itemVisiblePercentThreshold or viewAreaCoveragePercentThreshold');
+ var viewableIndices = [];
+
+ if (itemCount === 0) {
+ return viewableIndices;
+ }
+
+ var firstVisible = -1;
+
+ var _ref = renderRange || {
+ first: 0,
+ last: itemCount - 1
+ },
+ first = _ref.first,
+ last = _ref.last;
+
+ if (last >= itemCount) {
+ console.warn('Invalid render range computing viewability ' + JSON.stringify({
+ renderRange: renderRange,
+ itemCount: itemCount
+ }));
+ return [];
+ }
+
+ for (var idx = first; idx <= last; idx++) {
+ var metrics = getFrameMetrics(idx);
+
+ if (!metrics) {
+ continue;
+ }
+
+ var top = metrics.offset - scrollOffset;
+ var bottom = top + metrics.length;
+
+ if (top < viewportHeight && bottom > 0) {
+ firstVisible = idx;
+
+ if (_isViewable(viewAreaMode, viewablePercentThreshold, top, bottom, viewportHeight, metrics.length)) {
+ viewableIndices.push(idx);
+ }
+ } else if (firstVisible >= 0) {
+ break;
+ }
+ }
+
+ return viewableIndices;
+ }
+ }, {
+ key: "onUpdate",
+ value: function onUpdate(itemCount, scrollOffset, viewportHeight, getFrameMetrics, createViewToken, onViewableItemsChanged, renderRange) {
+ var _this = this;
+
+ if (this._config.waitForInteraction && !this._hasInteracted || itemCount === 0 || !getFrameMetrics(0)) {
+ return;
+ }
+
+ var viewableIndices = [];
+
+ if (itemCount) {
+ viewableIndices = this.computeViewableItems(itemCount, scrollOffset, viewportHeight, getFrameMetrics, renderRange);
+ }
+
+ if (this._viewableIndices.length === viewableIndices.length && this._viewableIndices.every(function (v, ii) {
+ return v === viewableIndices[ii];
+ })) {
+ return;
+ }
+
+ this._viewableIndices = viewableIndices;
+
+ if (this._config.minimumViewTime) {
+ var handle = setTimeout(function () {
+ _this._timers.delete(handle);
+
+ _this._onUpdateSync(viewableIndices, onViewableItemsChanged, createViewToken);
+ }, this._config.minimumViewTime);
+
+ this._timers.add(handle);
+ } else {
+ this._onUpdateSync(viewableIndices, onViewableItemsChanged, createViewToken);
+ }
+ }
+ }, {
+ key: "resetViewableIndices",
+ value: function resetViewableIndices() {
+ this._viewableIndices = [];
+ }
+ }, {
+ key: "recordInteraction",
+ value: function recordInteraction() {
+ this._hasInteracted = true;
+ }
+ }, {
+ key: "_onUpdateSync",
+ value: function _onUpdateSync(viewableIndicesToCheck, onViewableItemsChanged, createViewToken) {
+ var _this2 = this;
+
+ viewableIndicesToCheck = viewableIndicesToCheck.filter(function (ii) {
+ return _this2._viewableIndices.includes(ii);
+ });
+ var prevItems = this._viewableItems;
+ var nextItems = new Map(viewableIndicesToCheck.map(function (ii) {
+ var viewable = createViewToken(ii, true);
+ return [viewable.key, viewable];
+ }));
+ var changed = [];
+
+ for (var _iterator = nextItems, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();;) {
+ var _ref4;
+
+ if (_isArray) {
+ if (_i >= _iterator.length) break;
+ _ref4 = _iterator[_i++];
+ } else {
+ _i = _iterator.next();
+ if (_i.done) break;
+ _ref4 = _i.value;
+ }
+
+ var _ref8 = _ref4;
+
+ var _ref3 = _slicedToArray(_ref8, 2);
+
+ var _key2 = _ref3[0];
+ var _viewable2 = _ref3[1];
+
+ if (!prevItems.has(_key2)) {
+ changed.push(_viewable2);
+ }
+ }
+
+ for (var _iterator2 = prevItems, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();;) {
+ var _ref7;
+
+ if (_isArray2) {
+ if (_i2 >= _iterator2.length) break;
+ _ref7 = _iterator2[_i2++];
+ } else {
+ _i2 = _iterator2.next();
+ if (_i2.done) break;
+ _ref7 = _i2.value;
+ }
+
+ var _ref9 = _ref7;
+
+ var _ref6 = _slicedToArray(_ref9, 2);
+
+ var _key3 = _ref6[0];
+ var _viewable3 = _ref6[1];
+
+ if (!nextItems.has(_key3)) {
+ changed.push(_objectSpread({}, _viewable3, {
+ isViewable: false
+ }));
+ }
+ }
+
+ if (changed.length > 0) {
+ this._viewableItems = nextItems;
+ onViewableItemsChanged({
+ viewableItems: Array.from(nextItems.values()),
+ changed: changed,
+ viewabilityConfig: this._config
+ });
+ }
+ }
+ }]);
+
+ return ViewabilityHelper;
+ }();
+
+ function _isViewable(viewAreaMode, viewablePercentThreshold, top, bottom, viewportHeight, itemLength) {
+ if (_isEntirelyVisible(top, bottom, viewportHeight)) {
+ return true;
+ } else {
+ var pixels = _getPixelsVisible(top, bottom, viewportHeight);
+
+ var percent = 100 * (viewAreaMode ? pixels / viewportHeight : pixels / itemLength);
+ return percent >= viewablePercentThreshold;
+ }
+ }
+
+ function _getPixelsVisible(top, bottom, viewportHeight) {
+ var visibleHeight = Math.min(bottom, viewportHeight) - Math.max(top, 0);
+ return Math.max(0, visibleHeight);
+ }
+
+ function _isEntirelyVisible(top, bottom, viewportHeight) {
+ return top >= 0 && bottom <= viewportHeight && bottom > top;
+ }
+
+ module.exports = ViewabilityHelper;
+},284,[32,37,3,4,19],"node_modules\\react-native\\Libraries\\Lists\\ViewabilityHelper.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _slicedToArray = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/slicedToArray");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[1], "invariant");
+
+ function elementsThatOverlapOffsets(offsets, itemCount, getFrameMetrics) {
+ var out = [];
+ var outLength = 0;
+
+ for (var ii = 0; ii < itemCount; ii++) {
+ var frame = getFrameMetrics(ii);
+ var trailingOffset = frame.offset + frame.length;
+
+ for (var kk = 0; kk < offsets.length; kk++) {
+ if (out[kk] == null && trailingOffset >= offsets[kk]) {
+ out[kk] = ii;
+ outLength++;
+
+ if (kk === offsets.length - 1) {
+ invariant(outLength === offsets.length, 'bad offsets input, should be in increasing order: %s', JSON.stringify(offsets));
+ return out;
+ }
+ }
+ }
+ }
+
+ return out;
+ }
+
+ function newRangeCount(prev, next) {
+ return next.last - next.first + 1 - Math.max(0, 1 + Math.min(next.last, prev.last) - Math.max(next.first, prev.first));
+ }
+
+ function computeWindowedRenderLimits(props, prev, getFrameMetricsApprox, scrollMetrics) {
+ var data = props.data,
+ getItemCount = props.getItemCount,
+ maxToRenderPerBatch = props.maxToRenderPerBatch,
+ windowSize = props.windowSize;
+ var itemCount = getItemCount(data);
+
+ if (itemCount === 0) {
+ return prev;
+ }
+
+ var offset = scrollMetrics.offset,
+ velocity = scrollMetrics.velocity,
+ visibleLength = scrollMetrics.visibleLength;
+ var visibleBegin = Math.max(0, offset);
+ var visibleEnd = visibleBegin + visibleLength;
+ var overscanLength = (windowSize - 1) * visibleLength;
+ var leadFactor = 0.5;
+ var fillPreference = velocity > 1 ? 'after' : velocity < -1 ? 'before' : 'none';
+ var overscanBegin = Math.max(0, visibleBegin - (1 - leadFactor) * overscanLength);
+ var overscanEnd = Math.max(0, visibleEnd + leadFactor * overscanLength);
+ var lastItemOffset = getFrameMetricsApprox(itemCount - 1).offset;
+
+ if (lastItemOffset < overscanBegin) {
+ return {
+ first: Math.max(0, itemCount - 1 - maxToRenderPerBatch),
+ last: itemCount - 1
+ };
+ }
+
+ var _elementsThatOverlapO = elementsThatOverlapOffsets([overscanBegin, visibleBegin, visibleEnd, overscanEnd], props.getItemCount(props.data), getFrameMetricsApprox),
+ _elementsThatOverlapO2 = _slicedToArray(_elementsThatOverlapO, 4),
+ overscanFirst = _elementsThatOverlapO2[0],
+ first = _elementsThatOverlapO2[1],
+ last = _elementsThatOverlapO2[2],
+ overscanLast = _elementsThatOverlapO2[3];
+
+ overscanFirst = overscanFirst == null ? 0 : overscanFirst;
+ first = first == null ? Math.max(0, overscanFirst) : first;
+ overscanLast = overscanLast == null ? itemCount - 1 : overscanLast;
+ last = last == null ? Math.min(overscanLast, first + maxToRenderPerBatch - 1) : last;
+ var visible = {
+ first: first,
+ last: last
+ };
+ var newCellCount = newRangeCount(prev, visible);
+
+ while (true) {
+ if (first <= overscanFirst && last >= overscanLast) {
+ break;
+ }
+
+ var maxNewCells = newCellCount >= maxToRenderPerBatch;
+ var firstWillAddMore = first <= prev.first || first > prev.last;
+ var firstShouldIncrement = first > overscanFirst && (!maxNewCells || !firstWillAddMore);
+ var lastWillAddMore = last >= prev.last || last < prev.first;
+ var lastShouldIncrement = last < overscanLast && (!maxNewCells || !lastWillAddMore);
+
+ if (maxNewCells && !firstShouldIncrement && !lastShouldIncrement) {
+ break;
+ }
+
+ if (firstShouldIncrement && !(fillPreference === 'after' && lastShouldIncrement && lastWillAddMore)) {
+ if (firstWillAddMore) {
+ newCellCount++;
+ }
+
+ first--;
+ }
+
+ if (lastShouldIncrement && !(fillPreference === 'before' && firstShouldIncrement && firstWillAddMore)) {
+ if (lastWillAddMore) {
+ newCellCount++;
+ }
+
+ last++;
+ }
+ }
+
+ if (!(last >= first && first >= 0 && last < itemCount && first >= overscanFirst && last <= overscanLast && first <= visible.first && last >= visible.last)) {
+ throw new Error('Bad window calculation ' + JSON.stringify({
+ first: first,
+ last: last,
+ itemCount: itemCount,
+ overscanFirst: overscanFirst,
+ overscanLast: overscanLast,
+ visible: visible
+ }));
+ }
+
+ return {
+ first: first,
+ last: last
+ };
+ }
+
+ var VirtualizeUtils = {
+ computeWindowedRenderLimits: computeWindowedRenderLimits,
+ elementsThatOverlapOffsets: elementsThatOverlapOffsets,
+ newRangeCount: newRangeCount
+ };
+ module.exports = VirtualizeUtils;
+},285,[37,19],"node_modules\\react-native\\Libraries\\Lists\\VirtualizeUtils.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var Image = _$$_REQUIRE(_dependencyMap[0], "Image");
+
+ var createAnimatedComponent = _$$_REQUIRE(_dependencyMap[1], "createAnimatedComponent");
+
+ module.exports = createAnimatedComponent(Image);
+},286,[287,266],"node_modules\\react-native\\Libraries\\Animated\\src\\components\\AnimatedImage.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _regeneratorRuntime = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/regenerator");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\Libraries\\Image\\Image.uwp.js";
+
+ var DeprecatedImagePropType = _$$_REQUIRE(_dependencyMap[2], "DeprecatedImagePropType");
+
+ var NativeModules = _$$_REQUIRE(_dependencyMap[3], "NativeModules");
+
+ var React = _$$_REQUIRE(_dependencyMap[4], "React");
+
+ var ReactNative = _$$_REQUIRE(_dependencyMap[5], "ReactNative");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[6], "StyleSheet");
+
+ 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');
+
+ function getSize(uri, success, failure) {
+ ImageViewManager.getSize(uri, success, failure || function () {
+ console.warn('Failed to get size for image: ' + uri);
+ });
+ }
+
+ function prefetch(url) {
+ return ImageViewManager.prefetchImage(url);
+ }
+
+ function queryCache(urls) {
+ return _regeneratorRuntime.async(function queryCache$(_context) {
+ while (1) {
+ switch (_context.prev = _context.next) {
+ case 0:
+ _context.next = 2;
+ return _regeneratorRuntime.awrap(ImageViewManager.queryCache(urls));
+
+ case 2:
+ return _context.abrupt("return", _context.sent);
+
+ case 3:
+ case "end":
+ return _context.stop();
+ }
+ }
+ });
+ }
+
+ var Image = function Image(props, forwardedRef) {
+ var source = resolveAssetSource(props.source) || {
+ uri: undefined,
+ width: undefined,
+ height: undefined
+ };
+ var sources;
+ var style;
+
+ if (Array.isArray(source)) {
+ style = flattenStyle([styles.base, props.style]) || {};
+ sources = source;
+ } else {
+ var _width = source.width,
+ _height = source.height,
+ uri = source.uri;
+ style = flattenStyle([{
+ width: _width,
+ height: _height
+ }, styles.base, props.style]) || {};
+ sources = [source];
+
+ if (uri === '') {
+ console.warn('source.uri should not be an empty string');
+ }
+ }
+
+ var resizeMode = props.resizeMode || style.resizeMode || 'cover';
+ var tintColor = style.tintColor;
+
+ if (props.src != null) {
+ console.warn('The component requires a `source` property rather than `src`.');
+ }
+
+ if (props.children != null) {
+ throw new Error('The component cannot contain children. If you want to render content on top of the image, consider using the component or absolute positioning.');
+ }
+
+ return React.createElement(RCTImageView, _extends({}, props, {
+ ref: forwardedRef,
+ style: style,
+ resizeMode: resizeMode,
+ tintColor: tintColor,
+ source: sources,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 113
+ }
+ }));
+ };
+
+ Image = React.forwardRef(Image);
+ Image.displayName = 'Image';
+ Image.getSize = getSize;
+ Image.prefetch = prefetch;
+ Image.queryCache = queryCache;
+ Image.resolveAssetSource = resolveAssetSource;
+ Image.propTypes = DeprecatedImagePropType;
+ var styles = StyleSheet.create({
+ base: {
+ overflow: 'hidden'
+ }
+ });
+ module.exports = Image;
+},287,[14,102,288,36,52,84,53,80,184,190],"Libraries\\Image\\Image.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var DeprecatedEdgeInsetsPropType = _$$_REQUIRE(_dependencyMap[0], "DeprecatedEdgeInsetsPropType");
+
+ var DeprecatedImageSourcePropType = _$$_REQUIRE(_dependencyMap[1], "DeprecatedImageSourcePropType");
+
+ var DeprecatedImageStylePropTypes = _$$_REQUIRE(_dependencyMap[2], "DeprecatedImageStylePropTypes");
+
+ var DeprecatedStyleSheetPropType = _$$_REQUIRE(_dependencyMap[3], "DeprecatedStyleSheetPropType");
+
+ var PropTypes = _$$_REQUIRE(_dependencyMap[4], "prop-types");
+
+ module.exports = {
+ style: DeprecatedStyleSheetPropType(DeprecatedImageStylePropTypes),
+ source: DeprecatedImageSourcePropType,
+ 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: DeprecatedEdgeInsetsPropType,
+ 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
+ };
+},288,[210,289,58,211,62],"node_modules\\react-native\\Libraries\\DeprecatedPropTypes\\DeprecatedImagePropType.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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;
+},289,[62],"node_modules\\react-native\\Libraries\\DeprecatedPropTypes\\DeprecatedImageSourcePropType.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var ScrollView = _$$_REQUIRE(_dependencyMap[0], "ScrollView");
+
+ var createAnimatedComponent = _$$_REQUIRE(_dependencyMap[1], "createAnimatedComponent");
+
+ module.exports = createAnimatedComponent(ScrollView);
+},290,[275,266],"node_modules\\react-native\\Libraries\\Animated\\src\\components\\AnimatedScrollView.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var SectionList = _$$_REQUIRE(_dependencyMap[0], "SectionList");
+
+ var createAnimatedComponent = _$$_REQUIRE(_dependencyMap[1], "createAnimatedComponent");
+
+ module.exports = createAnimatedComponent(SectionList);
+},291,[292,266],"node_modules\\react-native\\Libraries\\Animated\\src\\components\\AnimatedSectionList.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/defineProperty");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Lists\\SectionList.js";
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var Platform = _$$_REQUIRE(_dependencyMap[7], "Platform");
+
+ var React = _$$_REQUIRE(_dependencyMap[8], "React");
+
+ var ScrollView = _$$_REQUIRE(_dependencyMap[9], "ScrollView");
+
+ var VirtualizedSectionList = _$$_REQUIRE(_dependencyMap[10], "VirtualizedSectionList");
+
+ var defaultProps = _objectSpread({}, VirtualizedSectionList.defaultProps, {
+ stickySectionHeadersEnabled: Platform.OS === 'ios'
+ });
+
+ var SectionList = function (_React$PureComponent) {
+ _inherits(SectionList, _React$PureComponent);
+
+ function SectionList() {
+ var _getPrototypeOf2;
+
+ var _this;
+
+ _classCallCheck(this, SectionList);
+
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(SectionList)).call.apply(_getPrototypeOf2, [this].concat(args)));
+
+ _this._captureRef = function (ref) {
+ _this._wrapperListRef = ref;
+ };
+
+ return _this;
+ }
+
+ _createClass(SectionList, [{
+ key: "scrollToLocation",
+ value: function scrollToLocation(params) {
+ if (this._wrapperListRef != null) {
+ this._wrapperListRef.scrollToLocation(params);
+ }
+ }
+ }, {
+ key: "recordInteraction",
+ value: function recordInteraction() {
+ var listRef = this._wrapperListRef && this._wrapperListRef.getListRef();
+
+ listRef && listRef.recordInteraction();
+ }
+ }, {
+ key: "flashScrollIndicators",
+ value: function flashScrollIndicators() {
+ var listRef = this._wrapperListRef && this._wrapperListRef.getListRef();
+
+ listRef && listRef.flashScrollIndicators();
+ }
+ }, {
+ key: "getScrollResponder",
+ value: function getScrollResponder() {
+ var listRef = this._wrapperListRef && this._wrapperListRef.getListRef();
+
+ if (listRef) {
+ return listRef.getScrollResponder();
+ }
+ }
+ }, {
+ key: "getScrollableNode",
+ value: function getScrollableNode() {
+ var listRef = this._wrapperListRef && this._wrapperListRef.getListRef();
+
+ if (listRef) {
+ return listRef.getScrollableNode();
+ }
+ }
+ }, {
+ key: "setNativeProps",
+ value: function setNativeProps(props) {
+ var listRef = this._wrapperListRef && this._wrapperListRef.getListRef();
+
+ if (listRef) {
+ listRef.setNativeProps(props);
+ }
+ }
+ }, {
+ key: "render",
+ value: function render() {
+ return React.createElement(VirtualizedSectionList, _extends({}, this.props, {
+ ref: this._captureRef,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 334
+ }
+ }));
+ }
+ }]);
+
+ return SectionList;
+ }(React.PureComponent);
+
+ SectionList.defaultProps = defaultProps;
+ module.exports = SectionList;
+},292,[14,3,4,5,8,9,32,35,52,275,293],"node_modules\\react-native\\Libraries\\Lists\\SectionList.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/defineProperty");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _assertThisInitialized = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/assertThisInitialized");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/createClass");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Lists\\VirtualizedSectionList.js";
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var Platform = _$$_REQUIRE(_dependencyMap[8], "Platform");
+
+ var React = _$$_REQUIRE(_dependencyMap[9], "React");
+
+ var View = _$$_REQUIRE(_dependencyMap[10], "View");
+
+ var VirtualizedList = _$$_REQUIRE(_dependencyMap[11], "VirtualizedList");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[12], "invariant");
+
+ var VirtualizedSectionList = function (_React$PureComponent) {
+ _inherits(VirtualizedSectionList, _React$PureComponent);
+
+ _createClass(VirtualizedSectionList, [{
+ key: "scrollToLocation",
+ value: function scrollToLocation(params) {
+ var index = Platform.OS === 'ios' ? params.itemIndex : 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._selectRowAboveIndexPath = function (rowIndexPath) {
+ var sectionIndex = rowIndexPath.sectionIndex;
+
+ if (sectionIndex >= _this.props.sections.length) {
+ return rowIndexPath;
+ }
+
+ var count = _this.props.sections[sectionIndex].data.length;
+ var row = rowIndexPath.rowIndex;
+ var rowAbove = row - 1;
+
+ if (rowAbove < 0) {
+ if (sectionIndex > 0) {
+ sectionIndex = sectionIndex - 1;
+ rowAbove = Math.max(0, _this.props.sections[sectionIndex].data.length - 1);
+ } else {
+ rowAbove = row;
+ }
+ }
+
+ var nextIndexPath = {
+ sectionIndex: sectionIndex,
+ rowIndex: rowAbove
+ };
+
+ _this.setState(function (state) {
+ return {
+ selectedRowIndexPath: nextIndexPath
+ };
+ });
+
+ return nextIndexPath;
+ };
+
+ _this._selectRowBelowIndexPath = function (rowIndexPath) {
+ var sectionIndex = rowIndexPath.sectionIndex;
+
+ if (sectionIndex >= _this.props.sections.length) {
+ return rowIndexPath;
+ }
+
+ var count = _this.props.sections[sectionIndex].data.length;
+ var row = rowIndexPath.rowIndex;
+ var rowBelow = row + 1;
+
+ if (rowBelow > count - 1) {
+ if (sectionIndex < _this.props.sections.length - 1) {
+ sectionIndex = sectionIndex + 1;
+ rowBelow = 0;
+ } else {
+ rowBelow = row;
+ }
+ }
+
+ var nextIndexPath = {
+ sectionIndex: sectionIndex,
+ rowIndex: rowBelow
+ };
+
+ _this.setState(function (state) {
+ return {
+ selectedRowIndexPath: nextIndexPath
+ };
+ });
+
+ return nextIndexPath;
+ };
+
+ _this._ensureItemAtIndexPathIsVisible = function (rowIndexPath) {
+ var index = rowIndexPath.rowIndex + 1;
+
+ for (var ii = 0; ii < rowIndexPath.sectionIndex; ii++) {
+ index += _this.props.sections[ii].data.length + 2;
+ }
+
+ _this._listRef.ensureItemAtIndexIsVisible(index);
+ };
+
+ _this._handleKeyDown = function (e) {
+ if (Platform.OS === 'macos') {
+ var event = e.nativeEvent;
+ var key = event.key;
+ var prevIndexPath = _this.state.selectedRowIndexPath;
+ var nextIndexPath = null;
+ var sectionIndex = _this.state.selectedRowIndexPath.sectionIndex;
+ var rowIndex = _this.state.selectedRowIndexPath.rowIndex;
+
+ if (key === 'DOWN_ARROW') {
+ nextIndexPath = _this._selectRowBelowIndexPath(prevIndexPath);
+
+ _this._ensureItemAtIndexPathIsVisible(nextIndexPath);
+
+ if (_this.props.onSelectionChanged) {
+ var _item = _this.props.sections[sectionIndex].data[rowIndex];
+
+ _this.props.onSelectionChanged({
+ previousSelection: prevIndexPath,
+ newSelection: nextIndexPath,
+ item: _item
+ });
+ }
+ } else if (key === 'UP_ARROW') {
+ nextIndexPath = _this._selectRowAboveIndexPath(prevIndexPath);
+
+ _this._ensureItemAtIndexPathIsVisible(nextIndexPath);
+
+ if (_this.props.onSelectionChanged) {
+ var _item2 = _this.props.sections[sectionIndex].data[rowIndex];
+
+ _this.props.onSelectionChanged({
+ previousSelection: prevIndexPath,
+ newSelection: nextIndexPath,
+ item: _item2
+ });
+ }
+ } else if (key === 'ENTER') {
+ if (_this.props.onSelectionEntered) {
+ var _item3 = _this.props.sections[sectionIndex].data[rowIndex];
+
+ _this.props.onSelectionEntered(_item3);
+ }
+ }
+ }
+ };
+
+ _this._keyExtractor = function (item, index) {
+ var info = _this._subExtractor(index);
+
+ return info && info.key || String(index);
+ };
+
+ _this._convertViewable = function (viewable) {
+ invariant(viewable.index != null, 'Received a broken ViewToken');
+
+ var info = _this._subExtractor(viewable.index);
+
+ if (!info) {
+ return null;
+ }
+
+ var keyExtractor = info.section.keyExtractor || _this.props.keyExtractor;
+ return _objectSpread({}, viewable, {
+ index: info.index,
+ key: keyExtractor(viewable.item, info.index),
+ section: info.section
+ });
+ };
+
+ _this._onViewableItemsChanged = function (_ref) {
+ var viewableItems = _ref.viewableItems,
+ changed = _ref.changed;
+
+ if (_this.props.onViewableItemsChanged) {
+ _this.props.onViewableItemsChanged({
+ viewableItems: viewableItems.map(_this._convertViewable, _assertThisInitialized(_this)).filter(Boolean),
+ changed: changed.map(_this._convertViewable, _assertThisInitialized(_this)).filter(Boolean)
+ });
+ }
+ };
+
+ _this._isItemSelected = function (item) {
+ var isSelected = false;
+
+ if (_this.state.selectedRowIndexPath) {
+ var selection = _this.state.selectedRowIndexPath;
+ var sections = _this.props.sections;
+
+ if (sections && selection.sectionIndex < sections.length) {
+ var section = sections[selection.sectionIndex];
+
+ if (selection.rowIndex < section.data.length) {
+ var selectedItem = section.data[selection.rowIndex];
+ isSelected = item == selectedItem;
+ }
+ }
+ }
+
+ return isSelected;
+ };
+
+ _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,
+ isSelected: _this._isItemSelected(item),
+ 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: 477
+ }
+ });
+ }
+ };
+
+ _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
+ }),
+ selectedRowIndexPath: {
+ sectionIndex: 0,
+ rowIndex: -1
+ }
+ };
+ }
+ }, {
+ key: "render",
+ value: function render() {
+ var keyEventHandler = this.props.onKeyDown;
+
+ if (!keyEventHandler) {
+ keyEventHandler = this.props.enableSelectionOnKeyPress ? this._handleKeyDown : null;
+ }
+
+ return React.createElement(VirtualizedList, _extends({}, this.state.childProps, {
+ ref: this._captureRef,
+ onKeyDown: keyEventHandler
+ }, this.state.selectedRowIndexPath, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 339
+ }
+ }));
+ }
+ }, {
+ 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 section = this.props.sections[ii];
+ var key = section.key || String(ii);
+ itemIndex -= 1;
+
+ if (itemIndex >= section.data.length + 1) {
+ itemIndex -= section.data.length + 1;
+ } else if (itemIndex === -1) {
+ return {
+ section: section,
+ key: key + ':header',
+ index: null,
+ header: true,
+ trailingSection: this.props.sections[ii + 1]
+ };
+ } else if (itemIndex === section.data.length) {
+ return {
+ section: section,
+ key: key + ':footer',
+ index: null,
+ header: false,
+ trailingSection: this.props.sections[ii + 1]
+ };
+ } else {
+ var keyExtractor = section.keyExtractor || defaultKeyExtractor;
+ return {
+ section: section,
+ key: key + ':' + keyExtractor(section.data[itemIndex], itemIndex),
+ index: itemIndex,
+ leadingItem: section.data[itemIndex - 1],
+ leadingSection: this.props.sections[ii - 1],
+ trailingItem: section.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;
+ }
+ }]);
+
+ return VirtualizedSectionList;
+ }(React.PureComponent);
+
+ VirtualizedSectionList.defaultProps = _objectSpread({}, VirtualizedList.defaultProps, {
+ data: []
+ });
+
+ var ItemWithSeparator = function (_React$Component) {
+ _inherits(ItemWithSeparator, _React$Component);
+
+ function ItemWithSeparator() {
+ var _getPrototypeOf2;
+
+ var _this2;
+
+ _classCallCheck(this, ItemWithSeparator);
+
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ _this2 = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(ItemWithSeparator)).call.apply(_getPrototypeOf2, [this].concat(args)));
+ _this2.state = {
+ separatorProps: {
+ highlighted: false,
+ leadingItem: _this2.props.item,
+ leadingSection: _this2.props.leadingSection,
+ section: _this2.props.section,
+ trailingItem: _this2.props.trailingItem,
+ trailingSection: _this2.props.trailingSection
+ },
+ leadingSeparatorProps: {
+ highlighted: false,
+ leadingItem: _this2.props.leadingItem,
+ leadingSection: _this2.props.leadingSection,
+ section: _this2.props.section,
+ trailingItem: _this2.props.item,
+ trailingSection: _this2.props.trailingSection
+ }
+ };
+ _this2._separators = {
+ highlight: function highlight() {
+ ['leading', 'trailing'].forEach(function (s) {
+ return _this2._separators.updateProps(s, {
+ highlighted: true
+ });
+ });
+ },
+ unhighlight: function unhighlight() {
+ ['leading', 'trailing'].forEach(function (s) {
+ return _this2._separators.updateProps(s, {
+ highlighted: false
+ });
+ });
+ },
+ updateProps: function updateProps(select, newProps) {
+ var _this2$props = _this2.props,
+ LeadingSeparatorComponent = _this2$props.LeadingSeparatorComponent,
+ cellKey = _this2$props.cellKey,
+ prevCellKey = _this2$props.prevCellKey;
+
+ if (select === 'leading' && LeadingSeparatorComponent != null) {
+ _this2.setState(function (state) {
+ return {
+ leadingSeparatorProps: _objectSpread({}, state.leadingSeparatorProps, {}, newProps)
+ };
+ });
+ } else {
+ _this2.props.onUpdateSeparator(select === 'leading' && prevCellKey || cellKey, newProps);
+ }
+ }
+ };
+ return _this2;
+ }
+
+ _createClass(ItemWithSeparator, [{
+ key: "updateSeparatorProps",
+ value: function updateSeparatorProps(newProps) {
+ this.setState(function (state) {
+ return {
+ separatorProps: _objectSpread({}, state.separatorProps, {}, newProps)
+ };
+ });
+ }
+ }, {
+ key: "render",
+ value: function render() {
+ var _this$props = this.props,
+ LeadingSeparatorComponent = _this$props.LeadingSeparatorComponent,
+ SeparatorComponent = _this$props.SeparatorComponent,
+ item = _this$props.item,
+ index = _this$props.index,
+ isSelected = _this$props.isSelected,
+ section = _this$props.section;
+ var element = this.props.renderItem({
+ item: item,
+ index: index,
+ isSelected: isSelected,
+ section: section,
+ separators: this._separators
+ });
+ var leadingSeparator = LeadingSeparatorComponent && React.createElement(LeadingSeparatorComponent, _extends({}, this.state.leadingSeparatorProps, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 667
+ }
+ }));
+ var separator = SeparatorComponent && React.createElement(SeparatorComponent, _extends({}, this.state.separatorProps, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 670
+ }
+ }));
+ return leadingSeparator || separator ? React.createElement(View, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 676
+ }
+ }, leadingSeparator, element, separator) : element;
+ }
+ }], [{
+ key: "getDerivedStateFromProps",
+ value: function getDerivedStateFromProps(props, prevState) {
+ return {
+ separatorProps: _objectSpread({}, prevState.separatorProps, {
+ leadingItem: props.item,
+ leadingSection: props.leadingSection,
+ section: props.section,
+ trailingItem: props.trailingItem,
+ trailingSection: props.trailingSection
+ }),
+ leadingSeparatorProps: _objectSpread({}, prevState.leadingSeparatorProps, {
+ leadingItem: props.leadingItem,
+ leadingSection: props.leadingSection,
+ section: props.section,
+ trailingItem: props.item,
+ trailingSection: props.trailingSection
+ })
+ };
+ }
+ }]);
+
+ return ItemWithSeparator;
+ }(React.Component);
+
+ function getItem(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;
+},293,[14,32,3,5,8,7,4,9,35,52,81,269,19],"node_modules\\react-native\\Libraries\\Lists\\VirtualizedSectionList.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var Text = _$$_REQUIRE(_dependencyMap[0], "Text");
+
+ var createAnimatedComponent = _$$_REQUIRE(_dependencyMap[1], "createAnimatedComponent");
+
+ module.exports = createAnimatedComponent(Text);
+},294,[208,266],"node_modules\\react-native\\Libraries\\Animated\\src\\components\\AnimatedText.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var View = _$$_REQUIRE(_dependencyMap[0], "View");
+
+ var createAnimatedComponent = _$$_REQUIRE(_dependencyMap[1], "createAnimatedComponent");
+
+ module.exports = createAnimatedComponent(View);
+},295,[81,266],"node_modules\\react-native\\Libraries\\Animated\\src\\components\\AnimatedView.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var __extends = this && this.__extends || function () {
+ var _extendStatics = function extendStatics(d, b) {
+ _extendStatics = Object.setPrototypeOf || {
+ __proto__: []
+ } instanceof Array && function (d, b) {
+ d.__proto__ = b;
+ } || function (d, b) {
+ for (var p in b) {
+ if (b.hasOwnProperty(p)) d[p] = b[p];
+ }
+ };
+
+ return _extendStatics(d, b);
+ };
+
+ return function (d, b) {
+ _extendStatics(d, b);
+
+ function __() {
+ this.constructor = d;
+ }
+
+ d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+ };
+ }();
+
+ var __assign = this && this.__assign || function () {
+ __assign = Object.assign || function (t) {
+ for (var s, i = 1, n = arguments.length; i < n; i++) {
+ s = arguments[i];
+
+ for (var p in s) {
+ if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+ }
+ }
+
+ return t;
+ };
+
+ return __assign.apply(this, arguments);
+ };
+
+ Object.defineProperty(exports, "__esModule", {
+ value: true
+ });
+
+ var React = _$$_REQUIRE(_dependencyMap[0], "react");
+
+ var react_native_1 = _$$_REQUIRE(_dependencyMap[1], "react-native");
+
+ var styles = react_native_1.StyleSheet.create({
+ rctCheckBox: {
+ height: 32,
+ width: 32
+ }
+ });
+ var RCTCheckBox = react_native_1.requireNativeComponent('RCTCheckBox');
+
+ var CheckBox = function (_super) {
+ __extends(CheckBox, _super);
+
+ function CheckBox(props) {
+ var _this = _super.call(this, props) || this;
+
+ _this._setRef = function (checkBox) {
+ _this._rctCheckBox = checkBox;
+ };
+
+ _this._onChange = function (event) {
+ if (_this._rctCheckBox) {
+ _this._rctCheckBox.setNativeProps({
+ checked: _this.props.checked
+ });
+ }
+
+ _this.props.onChange && _this.props.onChange(event);
+ _this.props.onValueChange && _this.props.onValueChange(event.nativeEvent.value);
+ };
+
+ _this._rctCheckBox = React.createRef();
+ return _this;
+ }
+
+ CheckBox.prototype.render = function () {
+ var props = __assign({}, this.props);
+
+ props.onStartShouldSetResponder = function () {
+ return true;
+ };
+
+ props.onResponderTerminationRequest = function () {
+ return false;
+ };
+
+ props.style = [styles.rctCheckBox, this.props.style];
+ return React.createElement(RCTCheckBox, __assign({}, props, {
+ onChange: this._onChange,
+ ref: this._setRef
+ }));
+ };
+
+ return CheckBox;
+ }(React.Component);
+
+ exports.CheckBox = CheckBox;
+ exports.default = CheckBox;
+},296,[11,18],"Libraries\\Components\\CheckBox\\CheckBox.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "UnimplementedView");
+},297,[196],"Libraries\\Components\\DatePicker\\DatePickerIOS.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "UnimplementedView");
+},298,[196],"Libraries\\Components\\DrawerAndroid\\DrawerLayoutAndroid.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _objectWithoutProperties = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/objectWithoutProperties");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Image\\ImageBackground.js";
+
+ var Image = _$$_REQUIRE(_dependencyMap[7], "Image");
+
+ var React = _$$_REQUIRE(_dependencyMap[8], "React");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[9], "StyleSheet");
+
+ var View = _$$_REQUIRE(_dependencyMap[10], "View");
+
+ var ensureComponentIsNative = _$$_REQUIRE(_dependencyMap[11], "ensureComponentIsNative");
+
+ var ImageBackground = function (_React$Component) {
+ _inherits(ImageBackground, _React$Component);
+
+ function ImageBackground() {
+ var _getPrototypeOf2;
+
+ var _this;
+
+ _classCallCheck(this, ImageBackground);
+
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(ImageBackground)).call.apply(_getPrototypeOf2, [this].concat(args)));
+ _this._viewRef = null;
+
+ _this._captureRef = function (ref) {
+ _this._viewRef = ref;
+ };
+
+ return _this;
+ }
+
+ _createClass(ImageBackground, [{
+ key: "setNativeProps",
+ value: function setNativeProps(props) {
+ var viewRef = this._viewRef;
+
+ if (viewRef) {
+ 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, {
+ accessibilityIgnoresInvertColors: true,
+ 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: 67
+ }
+ })), children);
+ }
+ }]);
+
+ return ImageBackground;
+ }(React.Component);
+
+ module.exports = ImageBackground;
+},299,[14,33,3,4,5,8,9,287,52,53,81,300],"node_modules\\react-native\\Libraries\\Image\\ImageBackground.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var invariant = _$$_REQUIRE(_dependencyMap[0], "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;
+},300,[19],"node_modules\\react-native\\Libraries\\Components\\Touchable\\ensureComponentIsNative.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var RCTImageEditingManager = _$$_REQUIRE(_dependencyMap[2], "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;
+},301,[3,4,36],"node_modules\\react-native\\Libraries\\Image\\ImageEditor.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var RCTImageStoreManager = _$$_REQUIRE(_dependencyMap[2], "NativeModules").ImageStoreManager;
+
+ var Platform = _$$_REQUIRE(_dependencyMap[3], "Platform");
+
+ var warnOnce = _$$_REQUIRE(_dependencyMap[4], "warnOnce");
+
+ function warnUnimplementedMethod(methodName) {
+ warnOnce("imagestore-" + methodName, "react-native: ImageStore." + methodName + "() is not implemented on " + Platform.OS);
+ }
+
+ 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 {
+ warnUnimplementedMethod('hasImageForTag');
+ }
+ }
+ }, {
+ key: "removeImageForTag",
+ value: function removeImageForTag(uri) {
+ if (RCTImageStoreManager.removeImageForTag) {
+ RCTImageStoreManager.removeImageForTag(uri);
+ } else {
+ warnUnimplementedMethod('removeImageForTag');
+ }
+ }
+ }, {
+ key: "addImageFromBase64",
+ value: function addImageFromBase64(base64ImageData, success, failure) {
+ if (RCTImageStoreManager.addImageFromBase64) {
+ RCTImageStoreManager.addImageFromBase64(base64ImageData, success, failure);
+ } else {
+ warnUnimplementedMethod('addImageFromBase64');
+ }
+ }
+ }, {
+ key: "getBase64ForTag",
+ value: function getBase64ForTag(uri, success, failure) {
+ if (RCTImageStoreManager.getBase64ForTag) {
+ RCTImageStoreManager.getBase64ForTag(uri, success, failure);
+ } else {
+ warnUnimplementedMethod('getBase64ForTag');
+ }
+ }
+ }]);
+
+ return ImageStore;
+ }();
+
+ module.exports = ImageStore;
+},302,[3,4,36,35,20],"node_modules\\react-native\\Libraries\\Image\\ImageStore.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Components\\TextInput\\InputAccessoryView.js";
+
+ var DeprecatedColorPropType = _$$_REQUIRE(_dependencyMap[5], "DeprecatedColorPropType");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[6], "Platform");
+
+ var React = _$$_REQUIRE(_dependencyMap[7], "React");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[8], "StyleSheet");
+
+ var RCTInputAccessoryViewNativeComponent = _$$_REQUIRE(_dependencyMap[9], "RCTInputAccessoryViewNativeComponent");
+
+ var InputAccessoryView = function (_React$Component) {
+ _inherits(InputAccessoryView, _React$Component);
+
+ function InputAccessoryView() {
+ _classCallCheck(this, InputAccessoryView);
+
+ return _possibleConstructorReturn(this, _getPrototypeOf(InputAccessoryView).apply(this, arguments));
+ }
+
+ _createClass(InputAccessoryView, [{
+ key: "render",
+ value: function render() {
+ if (Platform.OS !== 'ios') {
+ console.warn(' is only supported on iOS.');
+ }
+
+ if (React.Children.count(this.props.children) === 0) {
+ return null;
+ }
+
+ return React.createElement(RCTInputAccessoryViewNativeComponent, {
+ style: [this.props.style, styles.container],
+ nativeID: this.props.nativeID,
+ backgroundColor: this.props.backgroundColor,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 101
+ }
+ }, this.props.children);
+ }
+ }]);
+
+ return InputAccessoryView;
+ }(React.Component);
+
+ var styles = StyleSheet.create({
+ container: {
+ position: 'absolute'
+ }
+ });
+ module.exports = InputAccessoryView;
+},303,[3,4,5,8,9,59,35,52,53,304],"node_modules\\react-native\\Libraries\\Components\\TextInput\\InputAccessoryView.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var React = _$$_REQUIRE(_dependencyMap[0], "React");
+
+ var requireNativeComponent = _$$_REQUIRE(_dependencyMap[1], "requireNativeComponent");
+
+ module.exports = requireNativeComponent('RCTInputAccessoryView');
+},304,[52,184],"node_modules\\react-native\\Libraries\\Components\\TextInput\\RCTInputAccessoryViewNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _objectWithoutProperties = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/objectWithoutProperties");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Components\\Keyboard\\KeyboardAvoidingView.js";
+
+ var Keyboard = _$$_REQUIRE(_dependencyMap[7], "Keyboard");
+
+ var LayoutAnimation = _$$_REQUIRE(_dependencyMap[8], "LayoutAnimation");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[9], "Platform");
+
+ var React = _$$_REQUIRE(_dependencyMap[10], "React");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[11], "StyleSheet");
+
+ var View = _$$_REQUIRE(_dependencyMap[12], "View");
+
+ var KeyboardAvoidingView = function (_React$Component) {
+ _inherits(KeyboardAvoidingView, _React$Component);
+
+ function KeyboardAvoidingView(props) {
+ var _this;
+
+ _classCallCheck(this, KeyboardAvoidingView);
+
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(KeyboardAvoidingView).call(this, props));
+ _this._frame = null;
+ _this._subscriptions = [];
+
+ _this._onKeyboardChange = function (event) {
+ if (event == null) {
+ _this.setState({
+ bottom: 0
+ });
+
+ return;
+ }
+
+ var duration = event.duration,
+ easing = event.easing,
+ endCoordinates = event.endCoordinates;
+
+ var height = _this._relativeKeyboardHeight(endCoordinates);
+
+ if (_this.state.bottom === height) {
+ return;
+ }
+
+ if (duration && easing) {
+ LayoutAnimation.configureNext({
+ duration: duration > 10 ? duration : 10,
+ update: {
+ duration: duration > 10 ? duration : 10,
+ type: LayoutAnimation.Types[easing] || 'keyboard'
+ }
+ });
+ }
+
+ _this.setState({
+ bottom: height
+ });
+ };
+
+ _this._onLayout = function (event) {
+ _this._frame = event.nativeEvent.layout;
+ };
+
+ _this.state = {
+ bottom: 0
+ };
+ _this.viewRef = React.createRef();
+ return _this;
+ }
+
+ _createClass(KeyboardAvoidingView, [{
+ key: "_relativeKeyboardHeight",
+ value: function _relativeKeyboardHeight(keyboardFrame) {
+ var frame = this._frame;
+
+ if (!frame || !keyboardFrame) {
+ return 0;
+ }
+
+ var keyboardY = keyboardFrame.screenY - this.props.keyboardVerticalOffset;
+ return Math.max(frame.y + frame.height - keyboardY, 0);
+ }
+ }, {
+ key: "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 && this.state.bottom > 0) {
+ heightStyle = {
+ height: this._frame.height - bottomHeight,
+ flex: 0
+ };
+ }
+
+ return React.createElement(View, _extends({
+ ref: this.viewRef,
+ style: StyleSheet.compose(style, heightStyle),
+ onLayout: this._onLayout
+ }, props, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 174
+ }
+ }), children);
+
+ case 'position':
+ return React.createElement(View, _extends({
+ ref: this.viewRef,
+ style: style,
+ onLayout: this._onLayout
+ }, props, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 188
+ }
+ }), React.createElement(View, {
+ style: StyleSheet.compose(contentContainerStyle, {
+ bottom: bottomHeight
+ }),
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 193
+ }
+ }, children));
+
+ case 'padding':
+ return React.createElement(View, _extends({
+ ref: this.viewRef,
+ style: StyleSheet.compose(style, {
+ paddingBottom: bottomHeight
+ }),
+ onLayout: this._onLayout
+ }, props, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 207
+ }
+ }), children);
+
+ default:
+ return React.createElement(View, _extends({
+ ref: this.viewRef,
+ onLayout: this._onLayout,
+ style: style
+ }, props, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 221
+ }
+ }), children);
+ }
+ }
+ }]);
+
+ return KeyboardAvoidingView;
+ }(React.Component);
+
+ KeyboardAvoidingView.defaultProps = {
+ enabled: true,
+ keyboardVerticalOffset: 0
+ };
+ module.exports = KeyboardAvoidingView;
+},305,[14,33,3,4,5,8,9,278,279,35,52,53,81],"node_modules\\react-native\\Libraries\\Components\\Keyboard\\KeyboardAvoidingView.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _objectWithoutProperties = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/objectWithoutProperties");
+
+ var _extends = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/extends");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Lists\\ListView\\ListView.js";
+
+ var InternalListViewType = _$$_REQUIRE(_dependencyMap[2], "InternalListViewType");
+
+ var ListViewDataSource = _$$_REQUIRE(_dependencyMap[3], "ListViewDataSource");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[4], "Platform");
+
+ var React = _$$_REQUIRE(_dependencyMap[5], "React");
+
+ var ReactNative = _$$_REQUIRE(_dependencyMap[6], "ReactNative");
+
+ var RCTScrollViewManager = _$$_REQUIRE(_dependencyMap[7], "NativeModules").ScrollViewManager;
+
+ var ScrollView = _$$_REQUIRE(_dependencyMap[8], "ScrollView");
+
+ var ScrollResponder = _$$_REQUIRE(_dependencyMap[9], "ScrollResponder");
+
+ var StaticRenderer = _$$_REQUIRE(_dependencyMap[10], "StaticRenderer");
+
+ 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',
+ _rafIds: [],
+ _childFrames: [],
+ _sentEndForContentLength: null,
+ _scrollComponent: null,
+ _prevRenderedRowsCount: 0,
+ _visibleRows: {},
+ scrollProperties: {},
+ mixins: [ScrollResponder.Mixin],
+ statics: {
+ DataSource: ListViewDataSource
+ },
+ 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: 324
+ }
+ }));
+ },
+ 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 && this._scrollComponent.getInnerViewNode();
+ },
+ UNSAFE_componentWillMount: function UNSAFE_componentWillMount() {
+ this.scrollProperties = {
+ visibleLength: null,
+ contentLength: null,
+ offset: 0
+ };
+ this._rafIds = [];
+ this._childFrames = [];
+ this._visibleRows = {};
+ this._prevRenderedRowsCount = 0;
+ this._sentEndForContentLength = null;
+ },
+ componentWillUnmount: function componentWillUnmount() {
+ this._rafIds.forEach(cancelAnimationFrame);
+
+ this._rafIds = [];
+ },
+ 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], "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: 463
+ }
+ });
+ 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: 492
+ }
+ }, 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);
+ },
+ _requestAnimationFrame: function _requestAnimationFrame(fn) {
+ var _this4 = this;
+
+ var rafId = requestAnimationFrame(function () {
+ _this4._rafIds = _this4._rafIds.filter(function (id) {
+ return id !== rafId;
+ });
+ fn();
+ });
+
+ this._rafIds.push(rafId);
+ },
+ _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 _this5 = this;
+
+ this.setState(function (state, props) {
+ var rowsToRender = Math.min(state.curRenderedRowsCount + props.pageSize, props.enableEmptySections ? props.dataSource.getRowAndSectionCount() : props.dataSource.getRowCount());
+ _this5._prevRenderedRowsCount = state.curRenderedRowsCount;
+ return {
+ curRenderedRowsCount: rowsToRender
+ };
+ }, function () {
+ _this5._measureAndUpdateScrollProps();
+
+ _this5._prevRenderedRowsCount = _this5.state.curRenderedRowsCount;
+ });
+ },
+ _getDistanceFromEnd: function _getDistanceFromEnd(scrollProperties) {
+ return scrollProperties.contentLength - scrollProperties.visibleLength - scrollProperties.offset;
+ },
+ _updateVisibleRows: function _updateVisibleRows(updatedFrames) {
+ var _this6 = this;
+
+ if (!this.props.onChangeVisibleRows) {
+ return;
+ }
+
+ if (updatedFrames) {
+ updatedFrames.forEach(function (newFrame) {
+ _this6._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;
+},306,[33,14,307,308,35,52,84,36,275,276,310,81,311,227,309,204,21,19],"node_modules\\react-native\\Libraries\\Lists\\ListView\\ListView.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var React = _$$_REQUIRE(_dependencyMap[5], "React");
+
+ var ListViewDataSource = _$$_REQUIRE(_dependencyMap[6], "ListViewDataSource");
+
+ var InternalListViewType = function (_React$Component) {
+ "use strict";
+
+ _inherits(InternalListViewType, _React$Component);
+
+ 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) {}
+ }]);
+
+ return InternalListViewType;
+ }(React.Component);
+
+ InternalListViewType.DataSource = ListViewDataSource;
+ module.exports = InternalListViewType;
+},307,[3,4,5,8,9,52,308],"node_modules\\react-native\\Libraries\\Lists\\ListView\\InternalListViewType.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _toConsumableArray = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/toConsumableArray");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[3], "invariant");
+
+ var isEmpty = _$$_REQUIRE(_dependencyMap[4], "isEmpty");
+
+ var warning = _$$_REQUIRE(_dependencyMap[5], "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;
+},308,[43,3,4,19,309,21],"node_modules\\react-native\\Libraries\\Lists\\ListView\\ListViewDataSource.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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;
+},309,[],"node_modules\\react-native\\Libraries\\vendor\\core\\isEmpty.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var React = _$$_REQUIRE(_dependencyMap[5], "React");
+
+ var StaticRenderer = function (_React$Component) {
+ _inherits(StaticRenderer, _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();
+ }
+ }]);
+
+ return StaticRenderer;
+ }(React.Component);
+
+ module.exports = StaticRenderer;
+},310,[3,4,5,8,9,52],"node_modules\\react-native\\Libraries\\Components\\StaticRenderer.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var React = _$$_REQUIRE(_dependencyMap[1], "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;
+},311,[32,11],"node_modules\\react-clone-referenced-element\\cloneReferencedElement.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "UnimplementedView");
+},312,[196],"Libraries\\Components\\MaskedView\\MaskedViewIOS.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Modal\\Modal.js",
+ _container;
+
+ var AppContainer = _$$_REQUIRE(_dependencyMap[6], "AppContainer");
+
+ var I18nManager = _$$_REQUIRE(_dependencyMap[7], "I18nManager");
+
+ var NativeEventEmitter = _$$_REQUIRE(_dependencyMap[8], "NativeEventEmitter");
+
+ var NativeModules = _$$_REQUIRE(_dependencyMap[9], "NativeModules");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[10], "Platform");
+
+ var React = _$$_REQUIRE(_dependencyMap[11], "React");
+
+ var PropTypes = _$$_REQUIRE(_dependencyMap[12], "prop-types");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[13], "StyleSheet");
+
+ var View = _$$_REQUIRE(_dependencyMap[14], "View");
+
+ var RCTModalHostView = _$$_REQUIRE(_dependencyMap[15], "RCTModalHostViewNativeComponent");
+
+ var ModalEventEmitter = Platform.OS === 'ios' && NativeModules.ModalManager ? new NativeEventEmitter(NativeModules.ModalManager) : null;
+ var uniqueModalIdentifier = 0;
+
+ var Modal = function (_React$Component) {
+ _inherits(Modal, _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 !== true) {
+ return null;
+ }
+
+ var containerStyles = {
+ backgroundColor: this.props.transparent ? 'transparent' : 'white'
+ };
+ var animationType = this.props.animationType;
+
+ if (!animationType) {
+ animationType = 'none';
+
+ if (this.props.animated) {
+ animationType = 'slide';
+ }
+ }
+
+ var presentationStyle = this.props.presentationStyle;
+
+ if (!presentationStyle) {
+ presentationStyle = 'fullScreen';
+
+ if (this.props.transparent) {
+ presentationStyle = 'overFullScreen';
+ }
+ }
+
+ var innerChildren = __DEV__ ? React.createElement(AppContainer, {
+ rootTag: this.context.rootTag,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 244
+ }
+ }, 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: 252
+ }
+ }, React.createElement(View, {
+ style: [styles.container, containerStyles],
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 264
+ }
+ }, innerChildren));
+ }
+ }, {
+ key: "_shouldSetResponder",
+ value: function _shouldSetResponder() {
+ return true;
+ }
+ }], [{
+ key: "_confirmProps",
+ value: function _confirmProps(props) {
+ if (props.presentationStyle && props.presentationStyle !== 'overFullScreen' && props.transparent) {
+ console.warn("Modal with '" + props.presentationStyle + "' presentation style and 'transparent' value is not supported.");
+ }
+ }
+ }]);
+
+ return Modal;
+ }(React.Component);
+
+ Modal.defaultProps = {
+ visible: true,
+ hardwareAccelerated: false
+ };
+ Modal.contextTypes = {
+ rootTag: PropTypes.number
+ };
+ Modal.childContextTypes = {
+ virtualizedList: PropTypes.object
+ };
+ var side = I18nManager.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;
+},313,[32,3,4,5,8,9,314,320,131,36,35,52,62,53,81,349],"node_modules\\react-native\\Libraries\\Modal\\Modal.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\ReactNative\\AppContainer.js";
+
+ var EmitterSubscription = _$$_REQUIRE(_dependencyMap[5], "EmitterSubscription");
+
+ var PropTypes = _$$_REQUIRE(_dependencyMap[6], "prop-types");
+
+ var RCTDeviceEventEmitter = _$$_REQUIRE(_dependencyMap[7], "RCTDeviceEventEmitter");
+
+ var React = _$$_REQUIRE(_dependencyMap[8], "React");
+
+ var ReactNative = _$$_REQUIRE(_dependencyMap[9], "ReactNative");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[10], "StyleSheet");
+
+ var View = _$$_REQUIRE(_dependencyMap[11], "View");
+
+ var AppContainer = function (_React$Component) {
+ _inherits(AppContainer, _React$Component);
+
+ function AppContainer() {
+ var _getPrototypeOf2;
+
+ var _this;
+
+ _classCallCheck(this, AppContainer);
+
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(AppContainer)).call.apply(_getPrototypeOf2, [this].concat(args)));
+ _this.state = {
+ inspector: null,
+ mainKey: 1
+ };
+ _this._subscription = null;
+ return _this;
+ }
+
+ _createClass(AppContainer, [{
+ key: "getChildContext",
+ value: function getChildContext() {
+ return {
+ rootTag: this.props.rootTag
+ };
+ }
+ }, {
+ key: "componentDidMount",
+ value: function componentDidMount() {
+ var _this2 = this;
+
+ if (__DEV__) {
+ if (!global.__RCTProfileIsProfiling) {
+ this._subscription = RCTDeviceEventEmitter.addListener('toggleElementInspector', function () {
+ var Inspector = _$$_REQUIRE(_dependencyMap[12], "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[13], "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);
+ }
+ }]);
+
+ return AppContainer;
+ }(React.Component);
+
+ AppContainer.childContextTypes = {
+ rootTag: PropTypes.number
+ };
+ var styles = StyleSheet.create({
+ appContainer: {
+ flex: 1
+ }
+ });
+
+ if (__DEV__) {
+ if (!global.__RCTProfileIsProfiling) {
+ var YellowBox = _$$_REQUIRE(_dependencyMap[13], "YellowBox");
+
+ YellowBox.install();
+ }
+ }
+
+ module.exports = AppContainer;
+},314,[3,4,5,8,9,28,62,24,52,84,53,81,315,331],"node_modules\\react-native\\Libraries\\ReactNative\\AppContainer.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Inspector\\Inspector.js";
+
+ var Dimensions = _$$_REQUIRE(_dependencyMap[5], "Dimensions");
+
+ var InspectorOverlay = _$$_REQUIRE(_dependencyMap[6], "InspectorOverlay");
+
+ var InspectorPanel = _$$_REQUIRE(_dependencyMap[7], "InspectorPanel");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[8], "Platform");
+
+ var React = _$$_REQUIRE(_dependencyMap[9], "React");
+
+ var ReactNative = _$$_REQUIRE(_dependencyMap[10], "ReactNative");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[11], "StyleSheet");
+
+ var Touchable = _$$_REQUIRE(_dependencyMap[12], "Touchable");
+
+ var UIManager = _$$_REQUIRE(_dependencyMap[13], "UIManager");
+
+ var View = _$$_REQUIRE(_dependencyMap[14], "View");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[15], "invariant");
+
+ var hook = window.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+ var renderers = findRenderers();
+ hook.resolveRNStyle = _$$_REQUIRE(_dependencyMap[16], "flattenStyle");
+
+ function findRenderers() {
+ var allRenderers = Object.keys(hook._renderers).map(function (key) {
+ return hook._renderers[key];
+ });
+ invariant(allRenderers.length >= 1, 'Expected to find at least one React Native renderer on DevTools hook.');
+ return allRenderers;
+ }
+
+ function getInspectorDataForViewTag(touchedViewTag) {
+ for (var i = 0; i < renderers.length; i++) {
+ var renderer = renderers[i];
+
+ if (Object.prototype.hasOwnProperty.call(renderer, 'getInspectorDataForViewTag')) {
+ var inspectorData = renderer.getInspectorDataForViewTag(touchedViewTag);
+
+ if (inspectorData.hierarchy.length > 0) {
+ return inspectorData;
+ }
+ }
+ }
+
+ throw new Error('Expected to find at least one React renderer.');
+ }
+
+ var Inspector = function (_React$Component) {
+ _inherits(Inspector, _React$Component);
+
+ function Inspector(_props) {
+ var _this;
+
+ _classCallCheck(this, Inspector);
+
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(Inspector).call(this, _props));
+
+ _this.attachToDevtools = function (agent) {
+ var _hideWait = null;
+ var hlSub = agent.sub('highlight', function (_ref) {
+ var node = _ref.node,
+ name = _ref.name,
+ props = _ref.props;
+ clearTimeout(_hideWait);
+
+ if (typeof node !== 'number') {
+ node = ReactNative.findNodeHandle(node);
+ }
+
+ UIManager.measure(node, function (x, y, width, height, left, top) {
+ _this.setState({
+ hierarchy: [],
+ inspected: {
+ frame: {
+ left: left,
+ top: top,
+ width: width,
+ height: height
+ },
+ style: props ? props.style : {}
+ }
+ });
+ });
+ });
+ var hideSub = agent.sub('hideHighlight', function () {
+ if (_this.state.inspected === null) {
+ return;
+ }
+
+ _hideWait = setTimeout(function () {
+ _this.setState({
+ inspected: null
+ });
+ }, 100);
+ });
+ _this._subs = [hlSub, hideSub];
+ agent.on('shutdown', function () {
+ _this.setState({
+ devtoolsAgent: null
+ });
+
+ _this._subs = null;
+ });
+
+ _this.setState({
+ devtoolsAgent: agent
+ });
+ };
+
+ _this.state = {
+ devtoolsAgent: null,
+ hierarchy: null,
+ panelPos: 'bottom',
+ inspecting: true,
+ perfing: false,
+ inspected: null,
+ selection: null,
+ inspectedViewTag: _this.props.inspectedViewTag,
+ networking: false
+ };
+ return _this;
+ }
+
+ _createClass(Inspector, [{
+ key: "componentDidMount",
+ value: function componentDidMount() {
+ hook.on('react-devtools', this.attachToDevtools);
+
+ if (hook.reactDevtoolsAgent) {
+ this.attachToDevtools(hook.reactDevtoolsAgent);
+ }
+ }
+ }, {
+ key: "componentWillUnmount",
+ value: function componentWillUnmount() {
+ if (this._subs) {
+ this._subs.map(function (fn) {
+ return fn();
+ });
+ }
+
+ hook.off('react-devtools', this.attachToDevtools);
+ }
+ }, {
+ key: "UNSAFE_componentWillReceiveProps",
+ value: function UNSAFE_componentWillReceiveProps(newProps) {
+ this.setState({
+ inspectedViewTag: newProps.inspectedViewTag
+ });
+ }
+ }, {
+ key: "setSelection",
+ value: function setSelection(i) {
+ var _this2 = this;
+
+ var hierarchyItem = this.state.hierarchy[i];
+
+ var _hierarchyItem$getIns = hierarchyItem.getInspectorData(ReactNative.findNodeHandle),
+ measure = _hierarchyItem$getIns.measure,
+ props = _hierarchyItem$getIns.props,
+ source = _hierarchyItem$getIns.source;
+
+ measure(function (x, y, width, height, left, top) {
+ _this2.setState({
+ inspected: {
+ frame: {
+ left: left,
+ top: top,
+ width: width,
+ height: height
+ },
+ style: props.style,
+ source: source
+ },
+ selection: i
+ });
+ });
+ }
+ }, {
+ key: "onTouchViewTag",
+ value: function onTouchViewTag(touchedViewTag, frame, pointerY) {
+ var _getInspectorDataForV = getInspectorDataForViewTag(touchedViewTag),
+ hierarchy = _getInspectorDataForV.hierarchy,
+ props = _getInspectorDataForV.props,
+ selection = _getInspectorDataForV.selection,
+ source = _getInspectorDataForV.source;
+
+ if (this.state.devtoolsAgent) {
+ var offsetFromLeaf = hierarchy.length - 1 - selection;
+ this.state.devtoolsAgent.selectFromDOMNode(touchedViewTag, true, offsetFromLeaf);
+ }
+
+ this.setState({
+ panelPos: pointerY > Dimensions.get('window').height / 2 ? 'top' : 'bottom',
+ selection: selection,
+ hierarchy: hierarchy,
+ inspected: {
+ style: props.style,
+ frame: frame,
+ source: source
+ }
+ });
+ }
+ }, {
+ key: "setPerfing",
+ value: function setPerfing(val) {
+ this.setState({
+ perfing: val,
+ inspecting: false,
+ inspected: null,
+ networking: false
+ });
+ }
+ }, {
+ key: "setInspecting",
+ value: function setInspecting(val) {
+ this.setState({
+ inspecting: val,
+ inspected: null
+ });
+ }
+ }, {
+ key: "setTouchTargeting",
+ value: function setTouchTargeting(val) {
+ var _this3 = this;
+
+ Touchable.TOUCH_TARGET_DEBUG = val;
+ this.props.onRequestRerenderApp(function (inspectedViewTag) {
+ _this3.setState({
+ inspectedViewTag: inspectedViewTag
+ });
+ });
+ }
+ }, {
+ key: "setNetworking",
+ value: function setNetworking(val) {
+ this.setState({
+ networking: val,
+ perfing: false,
+ inspecting: false,
+ inspected: null
+ });
+ }
+ }, {
+ key: "render",
+ value: function render() {
+ var panelContainerStyle = this.state.panelPos === 'bottom' ? {
+ bottom: 0
+ } : {
+ top: Platform.OS === 'ios' ? 20 : 0
+ };
+ return React.createElement(View, {
+ style: styles.container,
+ pointerEvents: "box-none",
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 248
+ }
+ }, this.state.inspecting && React.createElement(InspectorOverlay, {
+ inspected: this.state.inspected,
+ inspectedViewTag: this.state.inspectedViewTag,
+ onTouchViewTag: this.onTouchViewTag.bind(this),
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 250
+ }
+ }), React.createElement(View, {
+ style: [styles.panelContainer, panelContainerStyle],
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 256
+ }
+ }, React.createElement(InspectorPanel, {
+ devtoolsIsOpen: !!this.state.devtoolsAgent,
+ inspecting: this.state.inspecting,
+ perfing: this.state.perfing,
+ setPerfing: this.setPerfing.bind(this),
+ setInspecting: this.setInspecting.bind(this),
+ inspected: this.state.inspected,
+ hierarchy: this.state.hierarchy,
+ selection: this.state.selection,
+ setSelection: this.setSelection.bind(this),
+ touchTargeting: Touchable.TOUCH_TARGET_DEBUG,
+ setTouchTargeting: this.setTouchTargeting.bind(this),
+ networking: this.state.networking,
+ setNetworking: this.setNetworking.bind(this),
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 257
+ }
+ })));
+ }
+ }]);
+
+ return Inspector;
+ }(React.Component);
+
+ var styles = StyleSheet.create({
+ container: {
+ position: 'absolute',
+ backgroundColor: 'transparent',
+ top: 0,
+ left: 0,
+ right: 0,
+ bottom: 0
+ },
+ panelContainer: {
+ position: 'absolute',
+ left: 0,
+ right: 0
+ }
+ });
+ module.exports = Inspector;
+},315,[3,4,5,8,9,55,316,321,35,52,84,53,213,71,81,19,80],"node_modules\\react-native\\Libraries\\Inspector\\Inspector.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Inspector\\InspectorOverlay.js";
+
+ var Dimensions = _$$_REQUIRE(_dependencyMap[5], "Dimensions");
+
+ var ElementBox = _$$_REQUIRE(_dependencyMap[6], "ElementBox");
+
+ var React = _$$_REQUIRE(_dependencyMap[7], "React");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[8], "StyleSheet");
+
+ var UIManager = _$$_REQUIRE(_dependencyMap[9], "UIManager");
+
+ var View = _$$_REQUIRE(_dependencyMap[10], "View");
+
+ var InspectorOverlay = function (_React$Component) {
+ _inherits(InspectorOverlay, _React$Component);
+
+ function InspectorOverlay() {
+ var _getPrototypeOf2;
+
+ var _this;
+
+ _classCallCheck(this, InspectorOverlay);
+
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(InspectorOverlay)).call.apply(_getPrototypeOf2, [this].concat(args)));
+
+ _this.findViewForTouchEvent = function (e) {
+ var _e$nativeEvent$touche = e.nativeEvent.touches[0],
+ locationX = _e$nativeEvent$touche.locationX,
+ locationY = _e$nativeEvent$touche.locationY;
+ UIManager.findSubviewIn(_this.props.inspectedViewTag, [locationX, locationY], function (nativeViewTag, left, top, width, height) {
+ _this.props.onTouchViewTag(nativeViewTag, {
+ left: left,
+ top: top,
+ width: width,
+ height: height
+ }, locationY);
+ });
+ };
+
+ _this.shouldSetResponser = function (e) {
+ _this.findViewForTouchEvent(e);
+
+ return true;
+ };
+
+ return _this;
+ }
+
+ _createClass(InspectorOverlay, [{
+ key: "render",
+ value: function render() {
+ var content = null;
+
+ if (this.props.inspected) {
+ content = React.createElement(ElementBox, {
+ frame: this.props.inspected.frame,
+ style: this.props.inspected.style,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 59
+ }
+ });
+ }
+
+ return React.createElement(View, {
+ onStartShouldSetResponder: this.shouldSetResponser,
+ onResponderMove: this.findViewForTouchEvent,
+ style: [styles.inspector, {
+ height: Dimensions.get('window').height
+ }],
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 67
+ }
+ }, content);
+ }
+ }]);
+
+ return InspectorOverlay;
+ }(React.Component);
+
+ var styles = StyleSheet.create({
+ inspector: {
+ backgroundColor: 'transparent',
+ position: 'absolute',
+ left: 0,
+ top: 0,
+ right: 0
+ }
+ });
+ module.exports = InspectorOverlay;
+},316,[3,4,5,8,9,55,317,52,53,71,81],"node_modules\\react-native\\Libraries\\Inspector\\InspectorOverlay.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Inspector\\ElementBox.js";
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var BorderBox = _$$_REQUIRE(_dependencyMap[6], "BorderBox");
+
+ var React = _$$_REQUIRE(_dependencyMap[7], "React");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[8], "StyleSheet");
+
+ var View = _$$_REQUIRE(_dependencyMap[9], "View");
+
+ var flattenStyle = _$$_REQUIRE(_dependencyMap[10], "flattenStyle");
+
+ var resolveBoxStyle = _$$_REQUIRE(_dependencyMap[11], "resolveBoxStyle");
+
+ var ElementBox = function (_React$Component) {
+ _inherits(ElementBox, _React$Component);
+
+ function ElementBox() {
+ _classCallCheck(this, ElementBox);
+
+ return _possibleConstructorReturn(this, _getPrototypeOf(ElementBox).apply(this, arguments));
+ }
+
+ _createClass(ElementBox, [{
+ key: "render",
+ value: function render() {
+ var style = flattenStyle(this.props.style) || {};
+ var margin = resolveBoxStyle('margin', style);
+ var padding = resolveBoxStyle('padding', style);
+
+ var frameStyle = _objectSpread({}, this.props.frame);
+
+ var contentStyle = {
+ width: this.props.frame.width,
+ height: this.props.frame.height
+ };
+
+ if (margin != null) {
+ frameStyle.top -= margin.top;
+ frameStyle.left -= margin.left;
+ frameStyle.height += margin.top + margin.bottom;
+ frameStyle.width += margin.left + margin.right;
+
+ if (margin.top < 0) {
+ contentStyle.height += margin.top;
+ }
+
+ if (margin.bottom < 0) {
+ contentStyle.height += margin.bottom;
+ }
+
+ if (margin.left < 0) {
+ contentStyle.width += margin.left;
+ }
+
+ if (margin.right < 0) {
+ contentStyle.width += margin.right;
+ }
+ }
+
+ if (padding != null) {
+ contentStyle.width -= padding.left + padding.right;
+ contentStyle.height -= padding.top + padding.bottom;
+ }
+
+ return React.createElement(View, {
+ style: [styles.frame, frameStyle],
+ pointerEvents: "none",
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 59
+ }
+ }, React.createElement(BorderBox, {
+ box: margin,
+ style: styles.margin,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 60
+ }
+ }, React.createElement(BorderBox, {
+ box: padding,
+ style: styles.padding,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 61
+ }
+ }, React.createElement(View, {
+ style: [styles.content, contentStyle],
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 62
+ }
+ }))));
+ }
+ }]);
+
+ return ElementBox;
+ }(React.Component);
+
+ var styles = StyleSheet.create({
+ frame: {
+ position: 'absolute'
+ },
+ content: {
+ backgroundColor: 'rgba(200, 230, 255, 0.8)'
+ },
+ padding: {
+ borderColor: 'rgba(77, 255, 0, 0.3)'
+ },
+ margin: {
+ borderColor: 'rgba(255, 132, 0, 0.3)'
+ }
+ });
+ module.exports = ElementBox;
+},317,[32,3,4,5,8,9,318,52,53,81,80,319],"node_modules\\react-native\\Libraries\\Inspector\\ElementBox.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Inspector\\BorderBox.js";
+
+ var React = _$$_REQUIRE(_dependencyMap[5], "React");
+
+ var View = _$$_REQUIRE(_dependencyMap[6], "View");
+
+ var BorderBox = function (_React$Component) {
+ _inherits(BorderBox, _React$Component);
+
+ function BorderBox() {
+ _classCallCheck(this, BorderBox);
+
+ return _possibleConstructorReturn(this, _getPrototypeOf(BorderBox).apply(this, arguments));
+ }
+
+ _createClass(BorderBox, [{
+ key: "render",
+ value: function render() {
+ var box = this.props.box;
+
+ if (!box) {
+ return this.props.children;
+ }
+
+ var style = {
+ borderTopWidth: box.top,
+ borderBottomWidth: box.bottom,
+ borderLeftWidth: box.left,
+ borderRightWidth: box.right
+ };
+ return React.createElement(View, {
+ style: [style, this.props.style],
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 28
+ }
+ }, this.props.children);
+ }
+ }]);
+
+ return BorderBox;
+ }(React.Component);
+
+ module.exports = BorderBox;
+},318,[3,4,5,8,9,52,81],"node_modules\\react-native\\Libraries\\Inspector\\BorderBox.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var I18nManager = _$$_REQUIRE(_dependencyMap[0], "I18nManager");
+
+ function resolveBoxStyle(prefix, style) {
+ var hasParts = false;
+ var result = {
+ bottom: 0,
+ left: 0,
+ right: 0,
+ top: 0
+ };
+ var styleForAll = style[prefix];
+
+ if (styleForAll != null) {
+ for (var _i = 0, _Object$keys = Object.keys(result); _i < _Object$keys.length; _i++) {
+ var key = _Object$keys[_i];
+ result[key] = styleForAll;
+ }
+
+ hasParts = true;
+ }
+
+ var styleForHorizontal = style[prefix + 'Horizontal'];
+
+ if (styleForHorizontal != null) {
+ result.left = styleForHorizontal;
+ result.right = styleForHorizontal;
+ hasParts = true;
+ } else {
+ var styleForLeft = style[prefix + 'Left'];
+
+ if (styleForLeft != null) {
+ result.left = styleForLeft;
+ hasParts = true;
+ }
+
+ var styleForRight = style[prefix + 'Right'];
+
+ if (styleForRight != null) {
+ result.right = styleForRight;
+ hasParts = true;
+ }
+
+ var styleForEnd = style[prefix + 'End'];
+
+ if (styleForEnd != null) {
+ if (I18nManager.isRTL && I18nManager.doLeftAndRightSwapInRTL) {
+ result.left = styleForEnd;
+ } else {
+ result.right = styleForEnd;
+ }
+
+ hasParts = true;
+ }
+
+ var styleForStart = style[prefix + 'Start'];
+
+ if (styleForStart != null) {
+ if (I18nManager.isRTL && I18nManager.doLeftAndRightSwapInRTL) {
+ result.right = styleForStart;
+ } else {
+ result.left = styleForStart;
+ }
+
+ hasParts = true;
+ }
+ }
+
+ var styleForVertical = style[prefix + 'Vertical'];
+
+ if (styleForVertical != null) {
+ result.bottom = styleForVertical;
+ result.top = styleForVertical;
+ hasParts = true;
+ } else {
+ var styleForBottom = style[prefix + 'Bottom'];
+
+ if (styleForBottom != null) {
+ result.bottom = styleForBottom;
+ hasParts = true;
+ }
+
+ var styleForTop = style[prefix + 'Top'];
+
+ if (styleForTop != null) {
+ result.top = styleForTop;
+ hasParts = true;
+ }
+ }
+
+ return hasParts ? result : null;
+ }
+
+ module.exports = resolveBoxStyle;
+},319,[320],"node_modules\\react-native\\Libraries\\Inspector\\resolveBoxStyle.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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;
+},320,[36],"node_modules\\react-native\\Libraries\\ReactNative\\I18nManager.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Inspector\\InspectorPanel.js";
+
+ var ElementProperties = _$$_REQUIRE(_dependencyMap[5], "ElementProperties");
+
+ var NetworkOverlay = _$$_REQUIRE(_dependencyMap[6], "NetworkOverlay");
+
+ var PerformanceOverlay = _$$_REQUIRE(_dependencyMap[7], "PerformanceOverlay");
+
+ var React = _$$_REQUIRE(_dependencyMap[8], "React");
+
+ var ScrollView = _$$_REQUIRE(_dependencyMap[9], "ScrollView");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[10], "StyleSheet");
+
+ var Text = _$$_REQUIRE(_dependencyMap[11], "Text");
+
+ var TouchableHighlight = _$$_REQUIRE(_dependencyMap[12], "TouchableHighlight");
+
+ var View = _$$_REQUIRE(_dependencyMap[13], "View");
+
+ var InspectorPanel = function (_React$Component) {
+ _inherits(InspectorPanel, _React$Component);
+
+ function InspectorPanel() {
+ _classCallCheck(this, InspectorPanel);
+
+ return _possibleConstructorReturn(this, _getPrototypeOf(InspectorPanel).apply(this, arguments));
+ }
+
+ _createClass(InspectorPanel, [{
+ key: "renderWaiting",
+ value: function renderWaiting() {
+ if (this.props.inspecting) {
+ return React.createElement(Text, {
+ style: styles.waitingText,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 57
+ }
+ }, "Tap something to inspect it");
+ }
+
+ return React.createElement(Text, {
+ style: styles.waitingText,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 60
+ }
+ }, "Nothing is inspected");
+ }
+ }, {
+ key: "render",
+ value: function render() {
+ var contents;
+
+ if (this.props.inspected) {
+ contents = React.createElement(ScrollView, {
+ style: styles.properties,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 67
+ }
+ }, React.createElement(ElementProperties, {
+ style: this.props.inspected.style,
+ frame: this.props.inspected.frame,
+ source: this.props.inspected.source,
+ hierarchy: this.props.hierarchy,
+ selection: this.props.selection,
+ setSelection: this.props.setSelection,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 68
+ }
+ }));
+ } else if (this.props.perfing) {
+ contents = React.createElement(PerformanceOverlay, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 80
+ }
+ });
+ } else if (this.props.networking) {
+ contents = React.createElement(NetworkOverlay, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 82
+ }
+ });
+ } else {
+ contents = React.createElement(View, {
+ style: styles.waiting,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 84
+ }
+ }, this.renderWaiting());
+ }
+
+ return React.createElement(View, {
+ style: styles.container,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 87
+ }
+ }, !this.props.devtoolsIsOpen && contents, React.createElement(View, {
+ style: styles.buttonRow,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 89
+ }
+ }, React.createElement(InspectorPanelButton, {
+ title: 'Inspect',
+ pressed: this.props.inspecting,
+ onClick: this.props.setInspecting,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 90
+ }
+ }), React.createElement(InspectorPanelButton, {
+ title: 'Perf',
+ pressed: this.props.perfing,
+ onClick: this.props.setPerfing,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 95
+ }
+ }), React.createElement(InspectorPanelButton, {
+ title: 'Network',
+ pressed: this.props.networking,
+ onClick: this.props.setNetworking,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 100
+ }
+ }), React.createElement(InspectorPanelButton, {
+ title: 'Touchables',
+ pressed: this.props.touchTargeting,
+ onClick: this.props.setTouchTargeting,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 105
+ }
+ })));
+ }
+ }]);
+
+ return InspectorPanel;
+ }(React.Component);
+
+ var InspectorPanelButton = function (_React$Component2) {
+ _inherits(InspectorPanelButton, _React$Component2);
+
+ function InspectorPanelButton() {
+ _classCallCheck(this, InspectorPanelButton);
+
+ return _possibleConstructorReturn(this, _getPrototypeOf(InspectorPanelButton).apply(this, arguments));
+ }
+
+ _createClass(InspectorPanelButton, [{
+ key: "render",
+ value: function render() {
+ var _this = this;
+
+ return React.createElement(TouchableHighlight, {
+ onPress: function onPress() {
+ return _this.props.onClick(!_this.props.pressed);
+ },
+ style: [styles.button, this.props.pressed && styles.buttonPressed],
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 125
+ }
+ }, React.createElement(Text, {
+ style: styles.buttonText,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 128
+ }
+ }, this.props.title));
+ }
+ }]);
+
+ return InspectorPanelButton;
+ }(React.Component);
+
+ var styles = StyleSheet.create({
+ buttonRow: {
+ flexDirection: 'row'
+ },
+ button: {
+ backgroundColor: 'rgba(0, 0, 0, 0.3)',
+ margin: 2,
+ height: 30,
+ justifyContent: 'center',
+ alignItems: 'center'
+ },
+ buttonPressed: {
+ backgroundColor: 'rgba(255, 255, 255, 0.3)'
+ },
+ buttonText: {
+ textAlign: 'center',
+ color: 'white',
+ margin: 5
+ },
+ container: {
+ backgroundColor: 'rgba(0, 0, 0, 0.7)'
+ },
+ properties: {
+ height: 200
+ },
+ waiting: {
+ height: 100
+ },
+ waitingText: {
+ fontSize: 20,
+ textAlign: 'center',
+ marginVertical: 20,
+ color: 'white'
+ }
+ });
+ module.exports = InspectorPanel;
+},321,[3,4,5,8,9,322,327,330,52,275,53,208,221,81],"node_modules\\react-native\\Libraries\\Inspector\\InspectorPanel.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Inspector\\ElementProperties.js";
+
+ var BoxInspector = _$$_REQUIRE(_dependencyMap[5], "BoxInspector");
+
+ var React = _$$_REQUIRE(_dependencyMap[6], "React");
+
+ var StyleInspector = _$$_REQUIRE(_dependencyMap[7], "StyleInspector");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[8], "StyleSheet");
+
+ var Text = _$$_REQUIRE(_dependencyMap[9], "Text");
+
+ var TouchableHighlight = _$$_REQUIRE(_dependencyMap[10], "TouchableHighlight");
+
+ var TouchableWithoutFeedback = _$$_REQUIRE(_dependencyMap[11], "TouchableWithoutFeedback");
+
+ var View = _$$_REQUIRE(_dependencyMap[12], "View");
+
+ var flattenStyle = _$$_REQUIRE(_dependencyMap[13], "flattenStyle");
+
+ var mapWithSeparator = _$$_REQUIRE(_dependencyMap[14], "mapWithSeparator");
+
+ var openFileInEditor = _$$_REQUIRE(_dependencyMap[15], "openFileInEditor");
+
+ var ElementProperties = function (_React$Component) {
+ _inherits(ElementProperties, _React$Component);
+
+ function ElementProperties() {
+ _classCallCheck(this, ElementProperties);
+
+ return _possibleConstructorReturn(this, _getPrototypeOf(ElementProperties).apply(this, arguments));
+ }
+
+ _createClass(ElementProperties, [{
+ key: "render",
+ value: function render() {
+ var _this = this;
+
+ var style = flattenStyle(this.props.style);
+ var selection = this.props.selection;
+ var openFileButton;
+ var source = this.props.source;
+
+ var _ref = source || {},
+ fileName = _ref.fileName,
+ lineNumber = _ref.lineNumber;
+
+ if (fileName && lineNumber) {
+ var parts = fileName.split('/');
+ var fileNameShort = parts[parts.length - 1];
+ openFileButton = React.createElement(TouchableHighlight, {
+ style: styles.openButton,
+ onPress: openFileInEditor.bind(null, fileName, lineNumber),
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 51
+ }
+ }, React.createElement(Text, {
+ style: styles.openButtonTitle,
+ numberOfLines: 1,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 54
+ }
+ }, fileNameShort, ":", lineNumber));
+ }
+
+ return React.createElement(TouchableWithoutFeedback, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 63
+ }
+ }, React.createElement(View, {
+ style: styles.info,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 64
+ }
+ }, React.createElement(View, {
+ style: styles.breadcrumb,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 65
+ }
+ }, mapWithSeparator(this.props.hierarchy, function (hierarchyItem, i) {
+ return React.createElement(TouchableHighlight, {
+ key: 'item-' + i,
+ style: [styles.breadItem, i === selection && styles.selected],
+ onPress: function onPress() {
+ return _this.props.setSelection(i);
+ },
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 69
+ }
+ }, React.createElement(Text, {
+ style: styles.breadItemText,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 74
+ }
+ }, hierarchyItem.name));
+ }, function (i) {
+ return React.createElement(Text, {
+ key: 'sep-' + i,
+ style: styles.breadSep,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 78
+ }
+ }, "\u25B8");
+ })), React.createElement(View, {
+ style: styles.row,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 84
+ }
+ }, React.createElement(View, {
+ style: styles.col,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 85
+ }
+ }, React.createElement(StyleInspector, {
+ style: style,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 86
+ }
+ }), openFileButton), React.createElement(BoxInspector, {
+ style: style,
+ frame: this.props.frame,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 89
+ }
+ }))));
+ }
+ }]);
+
+ return ElementProperties;
+ }(React.Component);
+
+ var styles = StyleSheet.create({
+ breadSep: {
+ fontSize: 8,
+ color: 'white'
+ },
+ breadcrumb: {
+ flexDirection: 'row',
+ flexWrap: 'wrap',
+ alignItems: 'flex-start',
+ marginBottom: 5
+ },
+ selected: {
+ borderColor: 'white',
+ borderRadius: 5
+ },
+ breadItem: {
+ borderWidth: 1,
+ borderColor: 'transparent',
+ marginHorizontal: 2
+ },
+ breadItemText: {
+ fontSize: 10,
+ color: 'white',
+ marginHorizontal: 5
+ },
+ row: {
+ flexDirection: 'row',
+ alignItems: 'center',
+ justifyContent: 'space-between'
+ },
+ col: {
+ flex: 1
+ },
+ info: {
+ padding: 10
+ },
+ openButton: {
+ padding: 10,
+ backgroundColor: '#000',
+ marginVertical: 5,
+ marginRight: 5,
+ borderRadius: 2
+ },
+ openButtonTitle: {
+ color: 'white',
+ fontSize: 8
+ }
+ });
+ module.exports = ElementProperties;
+},322,[3,4,5,8,9,323,52,324,53,208,221,226,81,80,325,326],"node_modules\\react-native\\Libraries\\Inspector\\ElementProperties.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Inspector\\BoxInspector.js";
+
+ var React = _$$_REQUIRE(_dependencyMap[5], "React");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[6], "StyleSheet");
+
+ var Text = _$$_REQUIRE(_dependencyMap[7], "Text");
+
+ var View = _$$_REQUIRE(_dependencyMap[8], "View");
+
+ var resolveBoxStyle = _$$_REQUIRE(_dependencyMap[9], "resolveBoxStyle");
+
+ var blank = {
+ top: 0,
+ left: 0,
+ right: 0,
+ bottom: 0
+ };
+
+ var BoxInspector = function (_React$Component) {
+ _inherits(BoxInspector, _React$Component);
+
+ function BoxInspector() {
+ _classCallCheck(this, BoxInspector);
+
+ return _possibleConstructorReturn(this, _getPrototypeOf(BoxInspector).apply(this, arguments));
+ }
+
+ _createClass(BoxInspector, [{
+ key: "render",
+ value: function render() {
+ var frame = this.props.frame;
+ var style = this.props.style;
+ var margin = style && resolveBoxStyle('margin', style) || blank;
+ var padding = style && resolveBoxStyle('padding', style) || blank;
+ return React.createElement(BoxContainer, {
+ title: "margin",
+ titleStyle: styles.marginLabel,
+ box: margin,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 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)))));
+ }
+ }]);
+
+ return BoxInspector;
+ }(React.Component);
+
+ var BoxContainer = function (_React$Component2) {
+ _inherits(BoxContainer, _React$Component2);
+
+ function BoxContainer() {
+ _classCallCheck(this, BoxContainer);
+
+ return _possibleConstructorReturn(this, _getPrototypeOf(BoxContainer).apply(this, arguments));
+ }
+
+ _createClass(BoxContainer, [{
+ key: "render",
+ value: function render() {
+ var box = this.props.box;
+ return React.createElement(View, {
+ style: styles.box,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 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));
+ }
+ }]);
+
+ return BoxContainer;
+ }(React.Component);
+
+ var styles = StyleSheet.create({
+ row: {
+ flexDirection: 'row',
+ alignItems: 'center',
+ justifyContent: 'space-around'
+ },
+ marginLabel: {
+ width: 60
+ },
+ label: {
+ fontSize: 10,
+ color: 'rgb(255,100,0)',
+ marginLeft: 5,
+ flex: 1,
+ textAlign: 'left',
+ top: -3
+ },
+ innerText: {
+ color: 'yellow',
+ fontSize: 12,
+ textAlign: 'center',
+ width: 70
+ },
+ box: {
+ borderWidth: 1,
+ borderColor: 'grey'
+ },
+ boxText: {
+ color: 'white',
+ fontSize: 12,
+ marginHorizontal: 3,
+ marginVertical: 2,
+ textAlign: 'center'
+ }
+ });
+ module.exports = BoxInspector;
+},323,[3,4,5,8,9,52,53,208,81,319],"node_modules\\react-native\\Libraries\\Inspector\\BoxInspector.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Inspector\\StyleInspector.js";
+
+ var React = _$$_REQUIRE(_dependencyMap[5], "React");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[6], "StyleSheet");
+
+ var Text = _$$_REQUIRE(_dependencyMap[7], "Text");
+
+ var View = _$$_REQUIRE(_dependencyMap[8], "View");
+
+ var StyleInspector = function (_React$Component) {
+ _inherits(StyleInspector, _React$Component);
+
+ function StyleInspector() {
+ _classCallCheck(this, StyleInspector);
+
+ return _possibleConstructorReturn(this, _getPrototypeOf(StyleInspector).apply(this, arguments));
+ }
+
+ _createClass(StyleInspector, [{
+ key: "render",
+ value: function render() {
+ var _this = this;
+
+ if (!this.props.style) {
+ return React.createElement(Text, {
+ style: styles.noStyle,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 21
+ }
+ }, "No style");
+ }
+
+ var names = Object.keys(this.props.style);
+ return React.createElement(View, {
+ style: styles.container,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 25
+ }
+ }, React.createElement(View, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 26
+ }
+ }, names.map(function (name) {
+ return React.createElement(Text, {
+ key: name,
+ style: styles.attr,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 28
+ }
+ }, name, ":");
+ })), React.createElement(View, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 34
+ }
+ }, names.map(function (name) {
+ var value = typeof _this.props.style[name] === 'object' ? JSON.stringify(_this.props.style[name]) : _this.props.style[name];
+ return React.createElement(Text, {
+ key: name,
+ style: styles.value,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 41
+ }
+ }, value);
+ })));
+ }
+ }]);
+
+ return StyleInspector;
+ }(React.Component);
+
+ var styles = StyleSheet.create({
+ container: {
+ flexDirection: 'row'
+ },
+ attr: {
+ fontSize: 10,
+ color: '#ccc'
+ },
+ value: {
+ fontSize: 10,
+ color: 'white',
+ marginLeft: 10
+ },
+ noStyle: {
+ color: 'white',
+ fontSize: 10
+ }
+ });
+ module.exports = StyleInspector;
+},324,[3,4,5,8,9,52,53,208,81],"node_modules\\react-native\\Libraries\\Inspector\\StyleInspector.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ function mapWithSeparator(items, itemRenderer, spacerRenderer) {
+ var mapped = [];
+
+ if (items.length > 0) {
+ mapped.push(itemRenderer(items[0], 0, items));
+
+ for (var ii = 1; ii < items.length; ii++) {
+ mapped.push(spacerRenderer(ii - 1), itemRenderer(items[ii], ii, items));
+ }
+ }
+
+ return mapped;
+ }
+
+ module.exports = mapWithSeparator;
+},325,[],"node_modules\\react-native\\Libraries\\Utilities\\mapWithSeparator.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var getDevServer = _$$_REQUIRE(_dependencyMap[0], "getDevServer");
+
+ function openFileInEditor(file, lineNumber) {
+ fetch(getDevServer().url + 'open-stack-frame', {
+ method: 'POST',
+ body: JSON.stringify({
+ file: file,
+ lineNumber: lineNumber
+ })
+ });
+ }
+
+ module.exports = openFileInEditor;
+},326,[104],"node_modules\\react-native\\Libraries\\Core\\Devtools\\openFileInEditor.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Inspector\\NetworkOverlay.js";
+
+ var FlatList = _$$_REQUIRE(_dependencyMap[5], "FlatList");
+
+ var React = _$$_REQUIRE(_dependencyMap[6], "React");
+
+ 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 WebSocketInterceptor = _$$_REQUIRE(_dependencyMap[12], "WebSocketInterceptor");
+
+ var XHRInterceptor = _$$_REQUIRE(_dependencyMap[13], "XHRInterceptor");
+
+ var LISTVIEW_CELL_HEIGHT = 15;
+ var nextXHRId = 0;
+
+ function getStringByValue(value) {
+ if (value === undefined) {
+ return 'undefined';
+ }
+
+ if (typeof value === 'object') {
+ return JSON.stringify(value);
+ }
+
+ if (typeof value === 'string' && value.length > 500) {
+ return String(value).substr(0, 500).concat('\n***TRUNCATED TO 500 CHARACTERS***');
+ }
+
+ return value;
+ }
+
+ function getTypeShortName(type) {
+ if (type === 'XMLHttpRequest') {
+ return 'XHR';
+ } else if (type === 'WebSocket') {
+ return 'WS';
+ }
+
+ return '';
+ }
+
+ function keyExtractor(request) {
+ return String(request.id);
+ }
+
+ var NetworkOverlay = function (_React$Component) {
+ _inherits(NetworkOverlay, _React$Component);
+
+ function NetworkOverlay() {
+ var _getPrototypeOf2;
+
+ var _this;
+
+ _classCallCheck(this, NetworkOverlay);
+
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(NetworkOverlay)).call.apply(_getPrototypeOf2, [this].concat(args)));
+ _this._socketIdMap = {};
+ _this._xhrIdMap = {};
+ _this.state = {
+ detailRowId: null,
+ requests: []
+ };
+
+ _this._renderItem = function (_ref) {
+ var item = _ref.item,
+ index = _ref.index;
+ var tableRowViewStyle = [styles.tableRow, index % 2 === 1 ? styles.tableRowOdd : styles.tableRowEven, index === _this.state.detailRowId && styles.tableRowPressed];
+ var urlCellViewStyle = styles.urlCellView;
+ var methodCellViewStyle = styles.methodCellView;
+ return React.createElement(TouchableHighlight, {
+ onPress: function onPress() {
+ _this._pressRow(index);
+ },
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 328
+ }
+ }, React.createElement(View, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 332
+ }
+ }, React.createElement(View, {
+ style: tableRowViewStyle,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 333
+ }
+ }, React.createElement(View, {
+ style: urlCellViewStyle,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 334
+ }
+ }, React.createElement(Text, {
+ style: styles.cellText,
+ numberOfLines: 1,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 335
+ }
+ }, item.url)), React.createElement(View, {
+ style: methodCellViewStyle,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 339
+ }
+ }, React.createElement(Text, {
+ style: styles.cellText,
+ numberOfLines: 1,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 340
+ }
+ }, getTypeShortName(item.type))))));
+ };
+
+ _this._scrollDetailToTop = function () {
+ if (_this._detailScrollView) {
+ _this._detailScrollView.scrollTo({
+ y: 0,
+ animated: false
+ });
+ }
+ };
+
+ _this._closeButtonClicked = function () {
+ _this.setState({
+ detailRowId: null
+ });
+ };
+
+ return _this;
+ }
+
+ _createClass(NetworkOverlay, [{
+ key: "_enableXHRInterception",
+ value: function _enableXHRInterception() {
+ var _this2 = this;
+
+ if (XHRInterceptor.isInterceptorEnabled()) {
+ return;
+ }
+
+ XHRInterceptor.setOpenCallback(function (method, url, xhr) {
+ xhr._index = nextXHRId++;
+ var xhrIndex = _this2.state.requests.length;
+ _this2._xhrIdMap[xhr._index] = xhrIndex;
+ var _xhr = {
+ id: xhrIndex,
+ type: 'XMLHttpRequest',
+ method: method,
+ url: url
+ };
+
+ _this2.setState({
+ requests: _this2.state.requests.concat(_xhr)
+ }, _this2._scrollRequestsToBottom);
+ });
+ XHRInterceptor.setRequestHeaderCallback(function (header, value, xhr) {
+ var xhrIndex = _this2._getRequestIndexByXHRID(xhr._index);
+
+ if (xhrIndex === -1) {
+ return;
+ }
+
+ _this2.setState(function (_ref2) {
+ var requests = _ref2.requests;
+ var networkRequestInfo = requests[xhrIndex];
+
+ if (!networkRequestInfo.requestHeaders) {
+ networkRequestInfo.requestHeaders = {};
+ }
+
+ networkRequestInfo.requestHeaders[header] = value;
+ return {
+ requests: requests
+ };
+ });
+ });
+ XHRInterceptor.setSendCallback(function (data, xhr) {
+ var xhrIndex = _this2._getRequestIndexByXHRID(xhr._index);
+
+ if (xhrIndex === -1) {
+ return;
+ }
+
+ _this2.setState(function (_ref3) {
+ var requests = _ref3.requests;
+ var networkRequestInfo = requests[xhrIndex];
+ networkRequestInfo.dataSent = data;
+ return {
+ requests: requests
+ };
+ });
+ });
+ XHRInterceptor.setHeaderReceivedCallback(function (type, size, responseHeaders, xhr) {
+ var xhrIndex = _this2._getRequestIndexByXHRID(xhr._index);
+
+ if (xhrIndex === -1) {
+ return;
+ }
+
+ _this2.setState(function (_ref4) {
+ var requests = _ref4.requests;
+ var networkRequestInfo = requests[xhrIndex];
+ networkRequestInfo.responseContentType = type;
+ networkRequestInfo.responseSize = size;
+ networkRequestInfo.responseHeaders = responseHeaders;
+ return {
+ requests: requests
+ };
+ });
+ });
+ XHRInterceptor.setResponseCallback(function (status, timeout, response, responseURL, responseType, xhr) {
+ var xhrIndex = _this2._getRequestIndexByXHRID(xhr._index);
+
+ if (xhrIndex === -1) {
+ return;
+ }
+
+ _this2.setState(function (_ref5) {
+ var requests = _ref5.requests;
+ var networkRequestInfo = requests[xhrIndex];
+ networkRequestInfo.status = status;
+ networkRequestInfo.timeout = timeout;
+ networkRequestInfo.response = response;
+ networkRequestInfo.responseURL = responseURL;
+ networkRequestInfo.responseType = responseType;
+ return {
+ requests: requests
+ };
+ });
+ });
+ XHRInterceptor.enableInterception();
+ }
+ }, {
+ key: "_enableWebSocketInterception",
+ value: function _enableWebSocketInterception() {
+ var _this3 = this;
+
+ if (WebSocketInterceptor.isInterceptorEnabled()) {
+ return;
+ }
+
+ WebSocketInterceptor.setConnectCallback(function (url, protocols, options, socketId) {
+ var socketIndex = _this3.state.requests.length;
+ _this3._socketIdMap[socketId] = socketIndex;
+ var _webSocket = {
+ id: socketIndex,
+ type: 'WebSocket',
+ url: url,
+ protocols: protocols
+ };
+
+ _this3.setState({
+ requests: _this3.state.requests.concat(_webSocket)
+ }, _this3._scrollRequestsToBottom);
+ });
+ WebSocketInterceptor.setCloseCallback(function (statusCode, closeReason, socketId) {
+ var socketIndex = _this3._socketIdMap[socketId];
+
+ if (socketIndex === undefined) {
+ return;
+ }
+
+ if (statusCode !== null && closeReason !== null) {
+ _this3.setState(function (_ref6) {
+ var requests = _ref6.requests;
+ var networkRequestInfo = requests[socketIndex];
+ networkRequestInfo.status = statusCode;
+ networkRequestInfo.closeReason = closeReason;
+ return {
+ requests: requests
+ };
+ });
+ }
+ });
+ WebSocketInterceptor.setSendCallback(function (data, socketId) {
+ var socketIndex = _this3._socketIdMap[socketId];
+
+ if (socketIndex === undefined) {
+ return;
+ }
+
+ _this3.setState(function (_ref7) {
+ var requests = _ref7.requests;
+ var networkRequestInfo = requests[socketIndex];
+
+ if (!networkRequestInfo.messages) {
+ networkRequestInfo.messages = '';
+ }
+
+ networkRequestInfo.messages += 'Sent: ' + JSON.stringify(data) + '\n';
+ return {
+ requests: requests
+ };
+ });
+ });
+ WebSocketInterceptor.setOnMessageCallback(function (socketId, message) {
+ var socketIndex = _this3._socketIdMap[socketId];
+
+ if (socketIndex === undefined) {
+ return;
+ }
+
+ _this3.setState(function (_ref8) {
+ var requests = _ref8.requests;
+ var networkRequestInfo = requests[socketIndex];
+
+ if (!networkRequestInfo.messages) {
+ networkRequestInfo.messages = '';
+ }
+
+ networkRequestInfo.messages += 'Received: ' + JSON.stringify(message) + '\n';
+ return {
+ requests: requests
+ };
+ });
+ });
+ WebSocketInterceptor.setOnCloseCallback(function (socketId, message) {
+ var socketIndex = _this3._socketIdMap[socketId];
+
+ if (socketIndex === undefined) {
+ return;
+ }
+
+ _this3.setState(function (_ref9) {
+ var requests = _ref9.requests;
+ var networkRequestInfo = requests[socketIndex];
+ networkRequestInfo.serverClose = message;
+ return {
+ requests: requests
+ };
+ });
+ });
+ WebSocketInterceptor.setOnErrorCallback(function (socketId, message) {
+ var socketIndex = _this3._socketIdMap[socketId];
+
+ if (socketIndex === undefined) {
+ return;
+ }
+
+ _this3.setState(function (_ref10) {
+ var requests = _ref10.requests;
+ var networkRequestInfo = requests[socketIndex];
+ networkRequestInfo.serverError = message;
+ return {
+ requests: requests
+ };
+ });
+ });
+ WebSocketInterceptor.enableInterception();
+ }
+ }, {
+ key: "componentDidMount",
+ value: function componentDidMount() {
+ this._enableXHRInterception();
+
+ this._enableWebSocketInterception();
+ }
+ }, {
+ key: "componentWillUnmount",
+ value: function componentWillUnmount() {
+ XHRInterceptor.disableInterception();
+ WebSocketInterceptor.disableInterception();
+ }
+ }, {
+ key: "_renderItemDetail",
+ value: function _renderItemDetail(id) {
+ var _this4 = this;
+
+ var requestItem = this.state.requests[id];
+ var details = Object.keys(requestItem).map(function (key) {
+ if (key === 'id') {
+ return;
+ }
+
+ return React.createElement(View, {
+ style: styles.detailViewRow,
+ key: key,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 357
+ }
+ }, React.createElement(Text, {
+ style: [styles.detailViewText, styles.detailKeyCellView],
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 358
+ }
+ }, key), React.createElement(Text, {
+ style: [styles.detailViewText, styles.detailValueCellView],
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 361
+ }
+ }, getStringByValue(requestItem[key])));
+ });
+ return React.createElement(View, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 369
+ }
+ }, React.createElement(TouchableHighlight, {
+ style: styles.closeButton,
+ onPress: this._closeButtonClicked,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 370
+ }
+ }, React.createElement(View, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 373
+ }
+ }, React.createElement(Text, {
+ style: styles.closeButtonText,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 374
+ }
+ }, "v"))), React.createElement(ScrollView, {
+ style: styles.detailScrollView,
+ ref: function ref(scrollRef) {
+ return _this4._detailScrollView = scrollRef;
+ },
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 377
+ }
+ }, details));
+ }
+ }, {
+ key: "_scrollRequestsToBottom",
+ value: function _scrollRequestsToBottom() {
+ if (this._requestsListView) {
+ this._requestsListView.scrollToEnd();
+ }
+ }
+ }, {
+ key: "_pressRow",
+ value: function _pressRow(rowId) {
+ this.setState({
+ detailRowId: rowId
+ }, this._scrollDetailToTop);
+ }
+ }, {
+ key: "_getRequestIndexByXHRID",
+ value: function _getRequestIndexByXHRID(index) {
+ if (index === undefined) {
+ return -1;
+ }
+
+ var xhrIndex = this._xhrIdMap[index];
+
+ if (xhrIndex === undefined) {
+ return -1;
+ } else {
+ return xhrIndex;
+ }
+ }
+ }, {
+ key: "render",
+ value: function render() {
+ var _this5 = this;
+
+ var _this$state = this.state,
+ requests = _this$state.requests,
+ detailRowId = _this$state.detailRowId;
+ return React.createElement(View, {
+ style: styles.container,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 429
+ }
+ }, detailRowId != null && this._renderItemDetail(detailRowId), React.createElement(View, {
+ style: styles.listViewTitle,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 431
+ }
+ }, requests.length > 0 && React.createElement(View, {
+ style: styles.tableRow,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 433
+ }
+ }, React.createElement(View, {
+ style: styles.urlTitleCellView,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 434
+ }
+ }, React.createElement(Text, {
+ style: styles.cellText,
+ numberOfLines: 1,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 435
+ }
+ }, "URL")), React.createElement(View, {
+ style: styles.methodTitleCellView,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 439
+ }
+ }, React.createElement(Text, {
+ style: styles.cellText,
+ numberOfLines: 1,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 440
+ }
+ }, "Type")))), React.createElement(FlatList, {
+ ref: function ref(listRef) {
+ return _this5._requestsListView = listRef;
+ },
+ style: styles.listView,
+ data: requests,
+ renderItem: this._renderItem,
+ keyExtractor: keyExtractor,
+ extraData: this.state,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 448
+ }
+ }));
+ }
+ }]);
+
+ return NetworkOverlay;
+ }(React.Component);
+
+ var styles = StyleSheet.create({
+ container: {
+ paddingTop: 10,
+ paddingBottom: 10,
+ paddingLeft: 5,
+ paddingRight: 5
+ },
+ listViewTitle: {
+ height: 20
+ },
+ listView: {
+ flex: 1,
+ height: 60
+ },
+ tableRow: {
+ flexDirection: 'row',
+ flex: 1,
+ height: LISTVIEW_CELL_HEIGHT
+ },
+ tableRowEven: {
+ backgroundColor: '#555'
+ },
+ tableRowOdd: {
+ backgroundColor: '#000'
+ },
+ tableRowPressed: {
+ backgroundColor: '#3B5998'
+ },
+ cellText: {
+ color: 'white',
+ fontSize: 12
+ },
+ methodTitleCellView: {
+ height: 18,
+ borderColor: '#DCD7CD',
+ borderTopWidth: 1,
+ borderBottomWidth: 1,
+ borderRightWidth: 1,
+ alignItems: 'center',
+ justifyContent: 'center',
+ backgroundColor: '#444',
+ flex: 1
+ },
+ urlTitleCellView: {
+ height: 18,
+ borderColor: '#DCD7CD',
+ borderTopWidth: 1,
+ borderBottomWidth: 1,
+ borderLeftWidth: 1,
+ borderRightWidth: 1,
+ justifyContent: 'center',
+ backgroundColor: '#444',
+ flex: 5,
+ paddingLeft: 3
+ },
+ methodCellView: {
+ height: 15,
+ borderColor: '#DCD7CD',
+ borderRightWidth: 1,
+ alignItems: 'center',
+ justifyContent: 'center',
+ flex: 1
+ },
+ urlCellView: {
+ height: 15,
+ borderColor: '#DCD7CD',
+ borderLeftWidth: 1,
+ borderRightWidth: 1,
+ justifyContent: 'center',
+ flex: 5,
+ paddingLeft: 3
+ },
+ detailScrollView: {
+ flex: 1,
+ height: 180,
+ marginTop: 5,
+ marginBottom: 5
+ },
+ detailKeyCellView: {
+ flex: 1.3
+ },
+ detailValueCellView: {
+ flex: 2
+ },
+ detailViewRow: {
+ flexDirection: 'row',
+ paddingHorizontal: 3
+ },
+ detailViewText: {
+ color: 'white',
+ fontSize: 11
+ },
+ closeButtonText: {
+ color: 'white',
+ fontSize: 10
+ },
+ closeButton: {
+ marginTop: 5,
+ backgroundColor: '#888',
+ justifyContent: 'center',
+ alignItems: 'center'
+ }
+ });
+ module.exports = NetworkOverlay;
+},327,[3,4,5,8,9,268,52,275,53,208,221,81,328,329],"node_modules\\react-native\\Libraries\\Inspector\\NetworkOverlay.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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;
+},328,[36,131,134],"node_modules\\react-native\\Libraries\\WebSocket\\WebSocketInterceptor.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var XMLHttpRequest = _$$_REQUIRE(_dependencyMap[0], "XMLHttpRequest");
+
+ var originalXHROpen = XMLHttpRequest.prototype.open;
+ var originalXHRSend = XMLHttpRequest.prototype.send;
+ var originalXHRSetRequestHeader = XMLHttpRequest.prototype.setRequestHeader;
+ var openCallback;
+ var sendCallback;
+ var requestHeaderCallback;
+ var headerReceivedCallback;
+ var responseCallback;
+ var _isInterceptorEnabled = false;
+ var XHRInterceptor = {
+ setOpenCallback: function setOpenCallback(callback) {
+ openCallback = callback;
+ },
+ setSendCallback: function setSendCallback(callback) {
+ sendCallback = callback;
+ },
+ setHeaderReceivedCallback: function setHeaderReceivedCallback(callback) {
+ headerReceivedCallback = callback;
+ },
+ setResponseCallback: function setResponseCallback(callback) {
+ responseCallback = callback;
+ },
+ setRequestHeaderCallback: function setRequestHeaderCallback(callback) {
+ requestHeaderCallback = callback;
+ },
+ isInterceptorEnabled: function isInterceptorEnabled() {
+ return _isInterceptorEnabled;
+ },
+ enableInterception: function enableInterception() {
+ if (_isInterceptorEnabled) {
+ return;
+ }
+
+ XMLHttpRequest.prototype.open = function (method, url) {
+ if (openCallback) {
+ openCallback(method, url, this);
+ }
+
+ originalXHROpen.apply(this, arguments);
+ };
+
+ XMLHttpRequest.prototype.setRequestHeader = function (header, value) {
+ if (requestHeaderCallback) {
+ requestHeaderCallback(header, value, this);
+ }
+
+ originalXHRSetRequestHeader.apply(this, arguments);
+ };
+
+ XMLHttpRequest.prototype.send = function (data) {
+ var _this = this;
+
+ if (sendCallback) {
+ sendCallback(data, this);
+ }
+
+ if (this.addEventListener) {
+ this.addEventListener('readystatechange', function () {
+ if (!_isInterceptorEnabled) {
+ return;
+ }
+
+ if (_this.readyState === _this.HEADERS_RECEIVED) {
+ var contentTypeString = _this.getResponseHeader('Content-Type');
+
+ var contentLengthString = _this.getResponseHeader('Content-Length');
+
+ var responseContentType, responseSize;
+
+ if (contentTypeString) {
+ responseContentType = contentTypeString.split(';')[0];
+ }
+
+ if (contentLengthString) {
+ responseSize = parseInt(contentLengthString, 10);
+ }
+
+ if (headerReceivedCallback) {
+ headerReceivedCallback(responseContentType, responseSize, _this.getAllResponseHeaders(), _this);
+ }
+ }
+
+ if (_this.readyState === _this.DONE) {
+ if (responseCallback) {
+ responseCallback(_this.status, _this.timeout, _this.response, _this.responseURL, _this.responseType, _this);
+ }
+ }
+ }, false);
+ }
+
+ originalXHRSend.apply(this, arguments);
+ };
+
+ _isInterceptorEnabled = true;
+ },
+ disableInterception: function disableInterception() {
+ if (!_isInterceptorEnabled) {
+ return;
+ }
+
+ _isInterceptorEnabled = false;
+ XMLHttpRequest.prototype.send = originalXHRSend;
+ XMLHttpRequest.prototype.open = originalXHROpen;
+ XMLHttpRequest.prototype.setRequestHeader = originalXHRSetRequestHeader;
+ responseCallback = null;
+ openCallback = null;
+ sendCallback = null;
+ headerReceivedCallback = null;
+ requestHeaderCallback = null;
+ }
+ };
+ module.exports = XHRInterceptor;
+},329,[124],"node_modules\\react-native\\Libraries\\Network\\XHRInterceptor.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Inspector\\PerformanceOverlay.js";
+
+ var PerformanceLogger = _$$_REQUIRE(_dependencyMap[5], "PerformanceLogger");
+
+ var React = _$$_REQUIRE(_dependencyMap[6], "React");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[7], "StyleSheet");
+
+ var Text = _$$_REQUIRE(_dependencyMap[8], "Text");
+
+ var View = _$$_REQUIRE(_dependencyMap[9], "View");
+
+ var PerformanceOverlay = function (_React$Component) {
+ _inherits(PerformanceOverlay, _React$Component);
+
+ function PerformanceOverlay() {
+ _classCallCheck(this, PerformanceOverlay);
+
+ return _possibleConstructorReturn(this, _getPrototypeOf(PerformanceOverlay).apply(this, arguments));
+ }
+
+ _createClass(PerformanceOverlay, [{
+ key: "render",
+ value: function render() {
+ var perfLogs = PerformanceLogger.getTimespans();
+ var items = [];
+
+ for (var key in perfLogs) {
+ if (perfLogs[key].totalTime) {
+ var unit = key === 'BundleSize' ? 'b' : 'ms';
+ items.push(React.createElement(View, {
+ style: styles.row,
+ key: key,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 28
+ }
+ }, React.createElement(Text, {
+ style: [styles.text, styles.label],
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 29
+ }
+ }, key), React.createElement(Text, {
+ style: [styles.text, styles.totalTime],
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 30
+ }
+ }, perfLogs[key].totalTime + unit)));
+ }
+ }
+
+ return React.createElement(View, {
+ style: styles.container,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 38
+ }
+ }, items);
+ }
+ }]);
+
+ return PerformanceOverlay;
+ }(React.Component);
+
+ var styles = StyleSheet.create({
+ container: {
+ height: 100,
+ paddingTop: 10
+ },
+ label: {
+ flex: 1
+ },
+ row: {
+ flexDirection: 'row',
+ paddingHorizontal: 10
+ },
+ text: {
+ color: 'white',
+ fontSize: 12
+ },
+ totalTime: {
+ paddingRight: 100
+ }
+ });
+ module.exports = PerformanceOverlay;
+},330,[3,4,5,8,9,156,52,53,208,81],"node_modules\\react-native\\Libraries\\Inspector\\PerformanceOverlay.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\YellowBox\\YellowBox.js";
+
+ var React = _$$_REQUIRE(_dependencyMap[5], "React");
+
+ var YellowBox;
+
+ if (__DEV__) {
+ var _temp;
+
+ var Platform = _$$_REQUIRE(_dependencyMap[6], "Platform");
+
+ var RCTLog = _$$_REQUIRE(_dependencyMap[7], "RCTLog");
+
+ var YellowBoxList = _$$_REQUIRE(_dependencyMap[8], "YellowBoxList");
+
+ var YellowBoxRegistry = _$$_REQUIRE(_dependencyMap[9], "YellowBoxRegistry");
+
+ var _console = console,
+ error = _console.error,
+ warn = _console.warn;
+ YellowBox = (_temp = function (_React$Component) {
+ _inherits(YellowBox, _React$Component);
+
+ function YellowBox() {
+ var _getPrototypeOf2;
+
+ var _this;
+
+ _classCallCheck(this, YellowBox);
+
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(YellowBox)).call.apply(_getPrototypeOf2, [this].concat(args)));
+ _this.state = {
+ registry: null
+ };
+
+ _this._handleDismiss = function (category) {
+ YellowBoxRegistry.delete(category);
+ };
+
+ return _this;
+ }
+
+ _createClass(YellowBox, [{
+ key: "render",
+ value: function render() {
+ return this.state.registry == null ? null : React.createElement(YellowBoxList, {
+ onDismiss: this._handleDismiss,
+ onDismissAll: this._handleDismissAll,
+ registry: this.state.registry,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 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;
+ }
+ }]);
+
+ return YellowBox;
+ }(React.Component), _temp);
+
+ var registerWarning = function registerWarning() {
+ for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+ args[_key4] = arguments[_key4];
+ }
+
+ YellowBoxRegistry.add({
+ args: args,
+ framesToPop: 2
+ });
+ };
+ } else {
+ YellowBox = function (_React$Component2) {
+ _inherits(YellowBox, _React$Component2);
+
+ function YellowBox() {
+ _classCallCheck(this, YellowBox);
+
+ return _possibleConstructorReturn(this, _getPrototypeOf(YellowBox).apply(this, arguments));
+ }
+
+ _createClass(YellowBox, [{
+ key: "render",
+ value: function render() {
+ return null;
+ }
+ }], [{
+ key: "ignoreWarnings",
+ value: function ignoreWarnings(patterns) {}
+ }, {
+ key: "install",
+ value: function install() {}
+ }, {
+ key: "uninstall",
+ value: function uninstall() {}
+ }]);
+
+ return YellowBox;
+ }(React.Component);
+ }
+
+ module.exports = YellowBox;
+},331,[3,4,5,8,9,52,35,154,332,348],"node_modules\\react-native\\Libraries\\YellowBox\\YellowBox.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _slicedToArray = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\YellowBox\\UI\\YellowBoxList.js";
+
+ var Dimensions = _$$_REQUIRE(_dependencyMap[7], "Dimensions");
+
+ var React = _$$_REQUIRE(_dependencyMap[8], "React");
+
+ var FlatList = _$$_REQUIRE(_dependencyMap[9], "FlatList");
+
+ var SafeAreaView = _$$_REQUIRE(_dependencyMap[10], "SafeAreaView");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[11], "StyleSheet");
+
+ var View = _$$_REQUIRE(_dependencyMap[12], "View");
+
+ var YellowBoxButton = _$$_REQUIRE(_dependencyMap[13], "YellowBoxButton");
+
+ var YellowBoxInspector = _$$_REQUIRE(_dependencyMap[14], "YellowBoxInspector");
+
+ var YellowBoxListRow = _$$_REQUIRE(_dependencyMap[15], "YellowBoxListRow");
+
+ var YellowBoxStyle = _$$_REQUIRE(_dependencyMap[16], "YellowBoxStyle");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[17], "Platform");
+
+ var VIEWPORT_RATIO = 0.5;
+ var MAX_ITEMS = Platform.OS === 'win32' || Platform.OS === 'windesktop' ? 3 : Math.floor(Dimensions.get('window').height * VIEWPORT_RATIO / (YellowBoxListRow.GUTTER + YellowBoxListRow.HEIGHT));
+
+ var YellowBoxList = function (_React$Component) {
+ _inherits(YellowBoxList, _React$Component);
+
+ function YellowBoxList() {
+ var _getPrototypeOf2;
+
+ var _this;
+
+ _classCallCheck(this, YellowBoxList);
+
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(YellowBoxList)).call.apply(_getPrototypeOf2, [this].concat(args)));
+ _this.state = {
+ selectedCategory: null
+ };
+
+ _this._handleInspectorDismiss = function () {
+ var category = _this.state.selectedCategory;
+
+ if (category == null) {
+ return;
+ }
+
+ _this.setState({
+ selectedCategory: null
+ }, function () {
+ _this.props.onDismiss(category);
+ });
+ };
+
+ _this._handleInspectorMinimize = function () {
+ _this.setState({
+ selectedCategory: null
+ });
+ };
+
+ _this._handleRowPress = function (category) {
+ _this.setState({
+ selectedCategory: category
+ });
+ };
+
+ return _this;
+ }
+
+ _createClass(YellowBoxList, [{
+ key: "render",
+ value: function render() {
+ var _this2 = this;
+
+ var selectedWarnings = this.state.selectedCategory == null ? null : this.props.registry.get(this.state.selectedCategory);
+
+ if (selectedWarnings != null) {
+ return React.createElement(View, {
+ style: StyleSheet.absoluteFill,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 60
+ }
+ }, React.createElement(YellowBoxInspector, {
+ onDismiss: this._handleInspectorDismiss,
+ onMinimize: this._handleInspectorMinimize,
+ warnings: selectedWarnings,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 61
+ }
+ }));
+ }
+
+ var items = [];
+
+ for (var _iterator = this.props.registry, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();;) {
+ var _ref3;
+
+ if (_isArray) {
+ if (_i >= _iterator.length) break;
+ _ref3 = _iterator[_i++];
+ } else {
+ _i = _iterator.next();
+ if (_i.done) break;
+ _ref3 = _i.value;
+ }
+
+ var _ref5 = _ref3;
+
+ var _ref2 = _slicedToArray(_ref5, 2);
+
+ var _category2 = _ref2[0];
+ var _warnings = _ref2[1];
+ items.unshift({
+ category: _category2,
+ warnings: _warnings
+ });
+ }
+
+ var listStyle = {
+ height: Math.min(items.length, MAX_ITEMS + 0.5) * (YellowBoxListRow.GUTTER + YellowBoxListRow.HEIGHT)
+ };
+ return items.length === 0 ? null : React.createElement(View, {
+ style: styles.list,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 83
+ }
+ }, React.createElement(View, {
+ pointerEvents: "box-none",
+ style: styles.dismissAll,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 84
+ }
+ }, React.createElement(YellowBoxButton, {
+ hitSlop: {
+ bottom: 4,
+ left: 4,
+ right: 4,
+ top: 4
+ },
+ label: "Dismiss All",
+ onPress: this.props.onDismissAll,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 85
+ }
+ })), 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: 95
+ }
+ }));
+ },
+ scrollEnabled: items.length > MAX_ITEMS,
+ scrollsToTop: false,
+ style: listStyle,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 91
+ }
+ }), React.createElement(SafeAreaView, {
+ style: styles.safeArea,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 101
+ }
+ }));
+ }
+ }]);
+
+ return YellowBoxList;
+ }(React.Component);
+
+ var styles = StyleSheet.create({
+ list: {
+ bottom: 0,
+ position: 'absolute',
+ width: Platform.OS === 'win32' ? 270 : '100%'
+ },
+ dismissAll: {
+ bottom: Platform.OS === 'win32' ? undefined : '100%',
+ flexDirection: 'row',
+ justifyContent: 'flex-end',
+ paddingBottom: 4,
+ paddingEnd: 4,
+ position: 'absolute',
+ width: Platform.OS === 'win32' ? 350 : '100%'
+ },
+ safeArea: {
+ backgroundColor: YellowBoxStyle.getBackgroundColor(0.95),
+ marginTop: StyleSheet.hairlineWidth
+ }
+ });
+ module.exports = YellowBoxList;
+},332,[14,37,3,4,5,8,9,55,52,268,333,53,81,334,337,345,336,35],"node_modules\\react-native\\Libraries\\YellowBox\\UI\\YellowBoxList.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "View");
+},333,[81],"Libraries\\Components\\SafeAreaView\\SafeAreaView.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\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;
+},334,[52,53,208,335,336],"node_modules\\react-native\\Libraries\\YellowBox\\UI\\YellowBoxButton.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\YellowBox\\UI\\YellowBoxPressable.js";
+
+ var React = _$$_REQUIRE(_dependencyMap[5], "React");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[6], "StyleSheet");
+
+ var TouchableWithoutFeedback = _$$_REQUIRE(_dependencyMap[7], "TouchableWithoutFeedback");
+
+ var View = _$$_REQUIRE(_dependencyMap[8], "View");
+
+ var YellowBoxStyle = _$$_REQUIRE(_dependencyMap[9], "YellowBoxStyle");
+
+ var YellowBoxPressable = function (_React$Component) {
+ _inherits(YellowBoxPressable, _React$Component);
+
+ function YellowBoxPressable() {
+ var _getPrototypeOf2;
+
+ var _this;
+
+ _classCallCheck(this, YellowBoxPressable);
+
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(YellowBoxPressable)).call.apply(_getPrototypeOf2, [this].concat(args)));
+ _this.state = {
+ pressed: false
+ };
+
+ _this._handlePressIn = function () {
+ _this.setState({
+ pressed: true
+ });
+ };
+
+ _this._handlePressOut = function () {
+ _this.setState({
+ pressed: false
+ });
+ };
+
+ return _this;
+ }
+
+ _createClass(YellowBoxPressable, [{
+ key: "render",
+ value: function render() {
+ var content = React.createElement(View, {
+ style: StyleSheet.compose({
+ backgroundColor: this.state.pressed ? this.props.backgroundColor.pressed : this.props.backgroundColor.default
+ }, this.props.style),
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 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);
+ }
+ }]);
+
+ return YellowBoxPressable;
+ }(React.Component);
+
+ YellowBoxPressable.defaultProps = {
+ backgroundColor: {
+ default: YellowBoxStyle.getBackgroundColor(0.95),
+ pressed: YellowBoxStyle.getHighlightColor(1)
+ }
+ };
+ module.exports = YellowBoxPressable;
+},335,[3,4,5,8,9,52,53,226,81,336],"node_modules\\react-native\\Libraries\\YellowBox\\UI\\YellowBoxPressable.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var YellowBoxStyle = {
+ getBackgroundColor: function getBackgroundColor(opacity) {
+ return "rgba(250, 186, 48, " + opacity + ")";
+ },
+ getDividerColor: function getDividerColor(opacity) {
+ return "rgba(255, 255, 255, " + opacity + ")";
+ },
+ getHighlightColor: function getHighlightColor(opacity) {
+ return "rgba(252, 176, 29, " + opacity + ")";
+ },
+ getTextColor: function getTextColor(opacity) {
+ return "rgba(255, 255, 255, " + opacity + ")";
+ }
+ };
+ module.exports = YellowBoxStyle;
+},336,[],"node_modules\\react-native\\Libraries\\YellowBox\\UI\\YellowBoxStyle.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\YellowBox\\UI\\YellowBoxInspector.js";
+
+ var Platform = _$$_REQUIRE(_dependencyMap[5], "Platform");
+
+ var React = _$$_REQUIRE(_dependencyMap[6], "React");
+
+ var ScrollView = _$$_REQUIRE(_dependencyMap[7], "ScrollView");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[8], "StyleSheet");
+
+ var Text = _$$_REQUIRE(_dependencyMap[9], "Text");
+
+ var View = _$$_REQUIRE(_dependencyMap[10], "View");
+
+ var YellowBoxCategory = _$$_REQUIRE(_dependencyMap[11], "YellowBoxCategory");
+
+ var YellowBoxInspectorFooter = _$$_REQUIRE(_dependencyMap[12], "YellowBoxInspectorFooter");
+
+ var YellowBoxInspectorHeader = _$$_REQUIRE(_dependencyMap[13], "YellowBoxInspectorHeader");
+
+ var YellowBoxInspectorSourceMapStatus = _$$_REQUIRE(_dependencyMap[14], "YellowBoxInspectorSourceMapStatus");
+
+ var YellowBoxInspectorStackFrame = _$$_REQUIRE(_dependencyMap[15], "YellowBoxInspectorStackFrame");
+
+ var YellowBoxStyle = _$$_REQUIRE(_dependencyMap[16], "YellowBoxStyle");
+
+ var openFileInEditor = _$$_REQUIRE(_dependencyMap[17], "openFileInEditor");
+
+ var YellowBoxInspector = function (_React$Component) {
+ _inherits(YellowBoxInspector, _React$Component);
+
+ function YellowBoxInspector() {
+ var _getPrototypeOf2;
+
+ var _this;
+
+ _classCallCheck(this, YellowBoxInspector);
+
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(YellowBoxInspector)).call.apply(_getPrototypeOf2, [this].concat(args)));
+ _this.state = {
+ selectedIndex: 0
+ };
+
+ _this._handleRetrySymbolication = function () {
+ _this._cancelSymbolication();
+
+ _this.forceUpdate(function () {
+ var warning = _this.props.warnings[_this.state.selectedIndex];
+ _this._symbolication = warning.retrySymbolicate(function () {
+ _this.forceUpdate();
+ });
+ });
+ };
+
+ _this._handleSelectIndex = function (selectedIndex) {
+ _this.setState({
+ selectedIndex: selectedIndex
+ });
+ };
+
+ return _this;
+ }
+
+ _createClass(YellowBoxInspector, [{
+ key: "render",
+ value: function render() {
+ var warnings = this.props.warnings;
+ var selectedIndex = this.state.selectedIndex;
+ var warning = warnings[selectedIndex];
+ return React.createElement(View, {
+ style: styles.root,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 55
+ }
+ }, React.createElement(YellowBoxInspectorHeader, {
+ onSelectIndex: this._handleSelectIndex,
+ selectedIndex: selectedIndex,
+ warnings: warnings,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 56
+ }
+ }), React.createElement(ScrollView, {
+ contentContainerStyle: styles.bodyContent,
+ key: selectedIndex,
+ style: styles.body,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 61
+ }
+ }, React.createElement(View, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 65
+ }
+ }, React.createElement(View, {
+ style: styles.bodyHeading,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 66
+ }
+ }, React.createElement(Text, {
+ style: styles.bodyHeadingText,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 67
+ }
+ }, "Warning")), React.createElement(Text, {
+ style: styles.bodyText,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 69
+ }
+ }, YellowBoxCategory.render(warning.message, styles.substitutionText))), React.createElement(View, {
+ style: styles.bodySection,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 76
+ }
+ }, React.createElement(View, {
+ style: styles.bodyHeading,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 77
+ }
+ }, React.createElement(Text, {
+ style: styles.bodyHeadingText,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 78
+ }
+ }, "Stack"), React.createElement(YellowBoxInspectorSourceMapStatus, {
+ onPress: warning.symbolicated.status === 'FAILED' ? this._handleRetrySymbolication : null,
+ status: warning.symbolicated.status,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 79
+ }
+ })), warning.getAvailableStack().map(function (frame, index) {
+ return React.createElement(YellowBoxInspectorStackFrame, {
+ key: index,
+ frame: frame,
+ onPress: warning.symbolicated.status === 'COMPLETE' ? function () {
+ openFileInEditor(frame.file, frame.lineNumber);
+ } : null,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 89
+ }
+ });
+ }))), React.createElement(YellowBoxInspectorFooter, {
+ onDismiss: this.props.onDismiss,
+ onMinimize: this.props.onMinimize,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 103
+ }
+ }));
+ }
+ }, {
+ key: "componentDidMount",
+ value: function componentDidMount() {
+ this._handleSymbolication();
+ }
+ }, {
+ key: "componentDidUpdate",
+ value: function componentDidUpdate(prevProps, prevState) {
+ if (prevProps.warnings !== this.props.warnings || prevState.selectedIndex !== this.state.selectedIndex) {
+ this._cancelSymbolication();
+
+ this._handleSymbolication();
+ }
+ }
+ }, {
+ key: "componentWillUnmount",
+ value: function componentWillUnmount() {
+ this._cancelSymbolication();
+ }
+ }, {
+ key: "_handleSymbolication",
+ value: function _handleSymbolication() {
+ var _this2 = this;
+
+ var warning = this.props.warnings[this.state.selectedIndex];
+
+ if (warning.symbolicated.status !== 'COMPLETE') {
+ this._symbolication = warning.symbolicate(function () {
+ _this2.forceUpdate();
+ });
+ }
+ }
+ }, {
+ key: "_cancelSymbolication",
+ value: function _cancelSymbolication() {
+ if (this._symbolication != null) {
+ this._symbolication.abort();
+
+ this._symbolication = null;
+ }
+ }
+ }]);
+
+ return YellowBoxInspector;
+ }(React.Component);
+
+ var styles = StyleSheet.create({
+ root: {
+ elevation: 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;
+},337,[3,4,5,8,9,35,52,275,53,208,81,338,340,341,343,344,336,326],"node_modules\\react-native\\Libraries\\YellowBox\\UI\\YellowBoxInspector.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _toConsumableArray = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/toConsumableArray");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\YellowBox\\Data\\YellowBoxCategory.js";
+
+ var React = _$$_REQUIRE(_dependencyMap[1], "React");
+
+ var Text = _$$_REQUIRE(_dependencyMap[2], "Text");
+
+ var UTFSequence = _$$_REQUIRE(_dependencyMap[3], "UTFSequence");
+
+ var stringifySafe = _$$_REQUIRE(_dependencyMap[4], "stringifySafe");
+
+ var SUBSTITUTION = UTFSequence.BOM + '%s';
+ var YellowBoxCategory = {
+ parse: function parse(args) {
+ var categoryParts = [];
+ var contentParts = [];
+ var substitutionOffsets = [];
+
+ var remaining = _toConsumableArray(args);
+
+ if (typeof remaining[0] === 'string') {
+ var formatString = String(remaining.shift());
+ var formatStringParts = formatString.split('%s');
+ var substitutionCount = formatStringParts.length - 1;
+ var substitutions = remaining.splice(0, substitutionCount);
+ var categoryString = '';
+ var contentString = '';
+ var substitutionIndex = 0;
+
+ for (var _iterator = formatStringParts, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();;) {
+ var _ref;
+
+ if (_isArray) {
+ if (_i >= _iterator.length) break;
+ _ref = _iterator[_i++];
+ } else {
+ _i = _iterator.next();
+ if (_i.done) break;
+ _ref = _i.value;
+ }
+
+ var _formatStringPart = _ref;
+ categoryString += _formatStringPart;
+ contentString += _formatStringPart;
+
+ if (substitutionIndex < substitutionCount) {
+ if (substitutionIndex < substitutions.length) {
+ var substitution = stringifySafe(substitutions[substitutionIndex]);
+ substitutionOffsets.push({
+ length: substitution.length,
+ offset: contentString.length
+ });
+ categoryString += SUBSTITUTION;
+ contentString += substitution;
+ } else {
+ substitutionOffsets.push({
+ length: 2,
+ offset: contentString.length
+ });
+ categoryString += '%s';
+ contentString += '%s';
+ }
+
+ substitutionIndex++;
+ }
+ }
+
+ categoryParts.push(categoryString);
+ contentParts.push(contentString);
+ }
+
+ var remainingArgs = remaining.map(stringifySafe);
+ categoryParts.push.apply(categoryParts, _toConsumableArray(remainingArgs));
+ contentParts.push.apply(contentParts, _toConsumableArray(remainingArgs));
+ return {
+ category: categoryParts.join(' '),
+ message: {
+ content: contentParts.join(' '),
+ substitutions: substitutionOffsets
+ }
+ };
+ },
+ render: function render(_ref2, substitutionStyle) {
+ var content = _ref2.content,
+ substitutions = _ref2.substitutions;
+ var elements = [];
+ var lastOffset = substitutions.reduce(function (prevOffset, substitution, index) {
+ var key = String(index);
+
+ if (substitution.offset > prevOffset) {
+ var prevPart = content.substr(prevOffset, substitution.offset - prevOffset);
+ elements.push(React.createElement(Text, {
+ key: key,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 119
+ }
+ }, prevPart));
+ }
+
+ var substititionPart = content.substr(substitution.offset, substitution.length);
+ elements.push(React.createElement(Text, {
+ key: key + '.5',
+ style: substitutionStyle,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 127
+ }
+ }, substititionPart));
+ return substitution.offset + substitution.length;
+ }, 0);
+
+ if (lastOffset < content.length) {
+ var lastPart = content.substr(lastOffset);
+ elements.push(React.createElement(Text, {
+ key: "-1",
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 139
+ }
+ }, lastPart));
+ }
+
+ return elements;
+ }
+ };
+ module.exports = YellowBoxCategory;
+},338,[43,52,208,339,50],"node_modules\\react-native\\Libraries\\YellowBox\\Data\\YellowBoxCategory.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var deepFreezeAndThrowOnMutationInDev = _$$_REQUIRE(_dependencyMap[0], "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;
+},339,[49],"node_modules\\react-native\\Libraries\\UTFSequence.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\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;
+},340,[52,333,53,208,81,335,336],"node_modules\\react-native\\Libraries\\YellowBox\\UI\\YellowBoxInspectorFooter.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\YellowBox\\UI\\YellowBoxInspectorHeader.js";
+
+ var Image = _$$_REQUIRE(_dependencyMap[0], "Image");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[1], "Platform");
+
+ var React = _$$_REQUIRE(_dependencyMap[2], "React");
+
+ var SafeAreaView = _$$_REQUIRE(_dependencyMap[3], "SafeAreaView");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[4], "StyleSheet");
+
+ var Text = _$$_REQUIRE(_dependencyMap[5], "Text");
+
+ var View = _$$_REQUIRE(_dependencyMap[6], "View");
+
+ var YellowBoxImageSource = _$$_REQUIRE(_dependencyMap[7], "YellowBoxImageSource");
+
+ var YellowBoxPressable = _$$_REQUIRE(_dependencyMap[8], "YellowBoxPressable");
+
+ var YellowBoxStyle = _$$_REQUIRE(_dependencyMap[9], "YellowBoxStyle");
+
+ var YellowBoxInspectorHeader = function YellowBoxInspectorHeader(props) {
+ var prevIndex = props.selectedIndex - 1;
+ var nextIndex = props.selectedIndex + 1;
+ var titleText = props.warnings.length === 1 ? 'Single Occurrence' : "Occurrence " + (props.selectedIndex + 1) + " of " + props.warnings.length;
+ return React.createElement(SafeAreaView, {
+ style: styles.root,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 42
+ }
+ }, React.createElement(View, {
+ style: styles.header,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 43
+ }
+ }, React.createElement(YellowBoxInspectorHeaderButton, {
+ disabled: props.warnings[prevIndex] == null,
+ image: YellowBoxImageSource.chevronLeft,
+ onPress: function onPress() {
+ return props.onSelectIndex(prevIndex);
+ },
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 44
+ }
+ }), React.createElement(View, {
+ style: styles.headerTitle,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 49
+ }
+ }, React.createElement(Text, {
+ style: styles.headerTitleText,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 50
+ }
+ }, titleText)), React.createElement(YellowBoxInspectorHeaderButton, {
+ disabled: props.warnings[nextIndex] == null,
+ image: YellowBoxImageSource.chevronRight,
+ onPress: function onPress() {
+ return props.onSelectIndex(nextIndex);
+ },
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 52
+ }
+ })));
+ };
+
+ var YellowBoxInspectorHeaderButton = function YellowBoxInspectorHeaderButton(props) {
+ return React.createElement(YellowBoxPressable, {
+ backgroundColor: {
+ default: 'transparent',
+ pressed: YellowBoxStyle.getHighlightColor(1)
+ },
+ onPress: props.disabled ? null : props.onPress,
+ style: styles.headerButton,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 69
+ }
+ }, props.disabled ? null : React.createElement(Image, {
+ source: {
+ height: 16,
+ uri: props.image,
+ width: 16
+ },
+ style: styles.headerButtonImage,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 77
+ }
+ }));
+ };
+
+ var styles = StyleSheet.create({
+ root: {
+ backgroundColor: YellowBoxStyle.getBackgroundColor(0.95)
+ },
+ header: {
+ flexDirection: 'row',
+ height: Platform.select({
+ android: 48,
+ ios: 44
+ })
+ },
+ headerButton: {
+ alignItems: 'center',
+ aspectRatio: 1,
+ justifyContent: 'center'
+ },
+ headerButtonImage: {
+ tintColor: YellowBoxStyle.getTextColor(1)
+ },
+ headerTitle: {
+ alignItems: 'center',
+ flex: 1,
+ justifyContent: 'center'
+ },
+ headerTitleText: {
+ color: YellowBoxStyle.getTextColor(1),
+ fontSize: 16,
+ fontWeight: '600',
+ includeFontPadding: false,
+ lineHeight: 20
+ }
+ });
+ module.exports = YellowBoxInspectorHeader;
+},341,[287,35,52,333,53,208,81,342,335,336],"node_modules\\react-native\\Libraries\\YellowBox\\UI\\YellowBoxInspectorHeader.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var PixelRatio = _$$_REQUIRE(_dependencyMap[0], "PixelRatio");
+
+ var scale = PixelRatio.get();
+ /**
+ * We use inline images for YellowBox in order to avoid display latency due to
+ * resource contention with symbolicating stack traces.
+ *
+ * The following steps were used to create these:
+ *
+ * 1. Download SVG files from: https://feathericons.com
+ * 2. Rasterize SVG files to PNG files at 16dp, 36dp, and 48dp.
+ * 3. Convert to Base64: https://www.google.com/search?q=base64+image+encoder
+ *
+ * @see https://github.com/feathericons/feather
+ * @copyright 2013-2017 Cole Bemis
+ * @license MIT
+ */
+
+ var YellowBoxImageSource = {
+ alertTriangle: scale > 2 ? 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAYAAABXAvmHAAAB60lEQVRoge2Z3W3DIBSFj9oFPAIjZARGyAiMkBHuJh4hI2QEj5AR3Me+tQ91JALHmD8bKvmTkCr5Auc6/kzUACcnRXzuvL4GoAB8Afjeea9qXADcAfw4475c65orgBl++NeYl5ouUQiHt5tQTRJuwB6b5zLY49QVGn7I0bo+kuv60IQbuHf5CWCIqOkCgX93maia1MkRAUMo+OI+AvUPp7a50EzcUCBF6psJrUkYiZgnZJ7eId8mMeIyhpW5hyLw72LKCXsl86VqwgAKceKapW5e/nZpJnSsuHaTM7muyDq7C63JprJS69YxhNTpSlkpKeLGNHCo0EJChcSNaQA4SGiFtBMXJFSI3YVOPXFB6kMoUl9NaE0Wl4h5KQ0AOwqde+KmNrCL0EKCxJ64qQ0AlYVWSBfXZusgW6Oa0Dni2hiEv0qsoci+yUJrsoikLlKAkP11ygK54taiSOgb/O5b/DMqS+gBZeLWJlnoEX7XwQkBDPIktlEkz7hWrEmxZG4M5L9GXYTk0qxwcopKxa3VABN6cosM/C5LxTUof4ReMKHf1nRlaSnuGsGM7kfU4w8RF5Bz4aNlokLe/HQ/ngl9/Qih4L9k3h4hA1+S3odxu3Q77Hl4r1Hg75n6D01M2Difbp02Mi3ZTk5OLH4BUyEtOlDYuK0AAAAASUVORK5CYII=' : scale > 1 ? 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAABVklEQVRYheWX4U3DMBBGH4gBMoJHyAgeoSNkAxjBG5QNOkJHCGzQDcoGZQP4gY3Oqe1cEscS4pNOqs9Jvqvv6ZrCf9fDhnutD4A3H810Br4mcW5l7hLmIdze5mZi+OJD5syeBYzC6CjyR5Ef9zI/CJMb0Im9zufC/qG2eQdchcGQuGYQ+9dJgZvl0B2xbJGrZW6IIevFXp9YVwcyB540syJfFcgSeJb0cVcDcg68XAFQCUhH+ShLBcBGIA158LQFqIB8zBRwEp9fgctcxQld/L2pZxZVAk/KkucjaDGQmoknrz35KEE2sABIRxm8tVIBaZgHb61UQOYmXk7aFgQVJ6QWPCnLAriYAVILnpTxD7yh/9EZiIEE4m+y29uMkGy1nQ6i9wYFRB5PwKdYP/v1msmnUe89gn695bG0iqjdXeMiRu9599csvGKZ0jlu0Ac/7d2rxX9Q37HW6QfX/ZguAAAAAElFTkSuQmCC' : 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAvUlEQVQ4jbWT4Q3CIBCFP40DdANxg24gIzhKuwEjuIFxAkcwTtARGicoG+iPXlMCB8UfvoQc4e7ePV4A/ogWuMlqc0W7AsEo0QMNcPplugMmwMia5KwKWkNIuIkHq3wLXGQ/Sq4IC3wkLpOfmZyKeEpIEKsDYB8VN0Afkfpg30uNiycbdKcNqXEOxdBEWoEAoqta8uZ0iqqkxwGDUrSFAXAHZpOWd/+ubD5Kz335Cx1wZna4Bh54AddauVl8ARfCLO9Xq7xGAAAAAElFTkSuQmCC',
+ check: scale > 2 ? 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAYAAABXAvmHAAAAqElEQVRoge3YTQ7CIBRF4bPUu/8JS6gTSaqilh95vuR+CaO2cGgYNAUzMzOzFgHlPhRaMkDAcRoltKaTeIxPtQHxGn+Q5AgJx8cQjo8hHB9DOP76Yiu/RcTmN18WLiQCjs3zBkYXVGOeLWd+xcIr5pgyEzDz7FIjISPP/FRPUM+9W4nvYVfuCSXeB3669ldEOzRFfCUSx1cicXwlEsdXIvEPKDMzM7PMbtugw3XTpNA2AAAAAElFTkSuQmCC' : scale > 1 ? 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAAf0lEQVRYhe2UvQ2AIBQGL3EBR3AESkv3bxxFN8DmWUgwvkI+En1X0cBd+IMg+DuDyDMCs413kfMiX4EMbD3l8oCaPIU85B4mYLEF5XJscrYFPRGvb/sZ4IlocubJGdH0wj1FSG77XYT0qdUi5O+8jOjyyZQRUnkZ0UUeBMF3OQC/0VsyGlxligAAAABJRU5ErkJggg==' : 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAASElEQVQ4jWNgGJHAgIGBIYESze8ZGBjWU6L5PAMDgwBNNCdAFZJt83qoQmRDSHK2AFQhzBCy/IxsCNkBJsDAwLAfiknWPBIBAETPFeuA4fr6AAAAAElFTkSuQmCC',
+ chevronLeft: scale > 2 ? 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAYAAABXAvmHAAAAgElEQVRoge3YMQ6DQBAEwRYvnf8nPAECbAnkyATsrt0lXUyPdAE6kCRJ/yXA+jopLbkhwHY6a2nNl8I1ftSA8Bm/MeQKBeNrBONrBONrBONrhMHxcPwOlMUvT32oszD8CoEj+giO6CE4oofgiB7Cj44Y86zyFoYPgOFPi5Ik6WwHji+QVIOyhqgAAAAASUVORK5CYII=' : scale > 1 ? 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACQAAAAkCAYAAADhAJiYAAAAaUlEQVRYhe3WsQ2AMAwAwRcs5LEYg3HpYANoQKKgcEEUI/6adM5LbgySfmZsNDeACdiApdEfaQGswH6+Xd1jugc9xYQxxhjz9RhaxwxvDuul3MrAqDyjsozKKnWgXUqdsJcAZgqsTFJ5B7gjUNw0n0HHAAAAAElFTkSuQmCC' : 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAARklEQVQ4jWNgGPKAmUh1AQwMDBIMDAwPyLEkgYGB4T/UELI1J9BdcwCxmpnIMZ1YkECsK+hmCNZoZCHCgAUMDAwfoHg4AgDJuQ/bcLyV+QAAAABJRU5ErkJggg==',
+ chevronRight: scale > 2 ? 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAYAAABXAvmHAAAAeElEQVRoge3YMQ6AIBQE0Ykn3fs3HEEbC6MdFp+v8xJaspNQAZIkqbcA4zwpXTJpAPvlpHTNhHtAu4jwDDCiQjBiDcGINQQj1hCMWEN4Boy3l25vL/iL0PgJBcfXCI6vERxfIzi+Rmg8Hj7wrdL+Yys0/1qUJEmzDvSAkFQ8EOdJAAAAAElFTkSuQmCC' : scale > 1 ? 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACQAAAAkCAYAAADhAJiYAAAAZElEQVRYhe3WsQmAQAxA0Y8ulLEcw3HtdANtBNvzCJjD/5pUgQ9pApJ+Zu7YCWABDmDLzemzA+c94+MW4AkqExUY1caoVka1GibqlSm7qJJSJzPGGGMylYqBgi9sACtFYiQN7wKC6VDcJ7tlpQAAAABJRU5ErkJggg==' : 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAANUlEQVQ4jWNgGLbAgYGBIYASAwIYGBj+MzAwJFBiSMLQMISJEpMptp2mmimORgcGChPSEAIAHGENPH8gqdYAAAAASUVORK5CYII=',
+ loader: scale > 2 ? 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAYAAABXAvmHAAABXElEQVRoge2a3W3DMAyEr+0CHkGjaISOcKN4k6zQETpCR+gGzgbpQ10kcamIpKQ6avQBBPxg3pHwL2UDg/8LASxrcNdKnCwATmssrUyeWgnju/DmXs8tRP+Sh2kgAJga1rFlWj2rcMD5YqQh77QJLbzIORjyRIJQCJW5ngYo5AVlrsgkCGqbsDbAhFfxqZsSZibP0oDXQ43HQPsg82i7sBoR+VcJq2YxKcPo0IoJLRZXmYGC6ezQmQUdVqhPBVH/CNBTSMkLVlzjA8Bbocb7GoPBoADi+umZilYzbrG/JrnljOvy734iu4To/BQaDB6Rl4LciPPF9Lmjhgvi+s7w6tCIGw3WKS0P8fvWNjt0ZkGHFeq7CQXTbkZKGg2JOxrqPUZ3s6ziNdju38IjS/dLi0EQpDLX2gDQYHEX6Hx5/YcA+6H0NgAYPnCMj3x7Mxq4wTGx3Q1E578aDDR8AX0mOGD6BEN/AAAAAElFTkSuQmCC' : scale > 1 ? 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAABN0lEQVRYhe2WzU3EMBCFP34KyJEjJaQDXAIlJJ24BSow2wEdhHSwJSwd7JHbcmC0mOxMnDiWDIInWbHkN29exo4n8IvRAEFGU8OAA04yulyR60Jm7msbyIZloAMGwBfI4UWrWxM08LW/weC4iOMNTog4g0awKjBG827GxBwC3996NHizAifsSrTRmlsZm23CT9adktyXSq6ZUPdxgiXnZzW8CLcLuC3lvqA/gCt5NtjlPQL7TP0Wu1HtRRu4PO3T4TKTz2kG+AG9IN6CR/Su9iojBw69egfghWgL/pGCp+JFVPUqTjWjlsuqeAo1o6rt2C8QcNiV0UxoHPMieojmz0CfMKyhl1hN84xbI3gnz5Ftp7kH3iT5LsFdDUf6pzSJ6r2glIFDbuDNhqRH4I7Pvv4EvG/QqocP2Jh/xzzX/zUAAAAASUVORK5CYII=' : 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAsklEQVQ4jaWTYRHCMAyFP7gJmIQ6oChgEpBQKXMwC3MADpAAEiphDuBHC4QuDRu8u9ylyWtem7Rgw2X7GT1wsghb4beAVzhtsfYyJgs44AoEQzBkjrMId1HkKPwyZ6oMSnxYsnk1NqT7yMo34Fzhd9meGJvs7Hh3NhqCLXDI/rT0lKsR+KOJgc9RdaRRarkZvELogYsi8HqxjUhGYE+aQg1jzketwFTZXHbbEpjB8eU7PwAbLiJz46707gAAAABJRU5ErkJggg=='
+ };
+ module.exports = YellowBoxImageSource;
+},342,[54],"node_modules\\react-native\\Libraries\\YellowBox\\UI\\YellowBoxImageSource.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\YellowBox\\UI\\YellowBoxInspectorSourceMapStatus.js";
+
+ var Animated = _$$_REQUIRE(_dependencyMap[5], "Animated");
+
+ var Easing = _$$_REQUIRE(_dependencyMap[6], "Easing");
+
+ var React = _$$_REQUIRE(_dependencyMap[7], "React");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[8], "StyleSheet");
+
+ var Text = _$$_REQUIRE(_dependencyMap[9], "Text");
+
+ var YellowBoxImageSource = _$$_REQUIRE(_dependencyMap[10], "YellowBoxImageSource");
+
+ var YellowBoxPressable = _$$_REQUIRE(_dependencyMap[11], "YellowBoxPressable");
+
+ var YellowBoxStyle = _$$_REQUIRE(_dependencyMap[12], "YellowBoxStyle");
+
+ var YellowBoxInspectorSourceMapStatus = function (_React$Component) {
+ _inherits(YellowBoxInspectorSourceMapStatus, _React$Component);
+
+ function YellowBoxInspectorSourceMapStatus() {
+ var _getPrototypeOf2;
+
+ var _this;
+
+ _classCallCheck(this, YellowBoxInspectorSourceMapStatus);
+
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(YellowBoxInspectorSourceMapStatus)).call.apply(_getPrototypeOf2, [this].concat(args)));
+ _this.state = {
+ animation: null,
+ rotate: null
+ };
+ return _this;
+ }
+
+ _createClass(YellowBoxInspectorSourceMapStatus, [{
+ key: "render",
+ value: function render() {
+ var image;
+
+ switch (this.props.status) {
+ case 'COMPLETE':
+ image = YellowBoxImageSource.check;
+ break;
+
+ case 'FAILED':
+ image = YellowBoxImageSource.alertTriangle;
+ break;
+
+ case 'PENDING':
+ image = YellowBoxImageSource.loader;
+ break;
+ }
+
+ return image == null ? null : React.createElement(YellowBoxPressable, {
+ backgroundColor: {
+ default: YellowBoxStyle.getTextColor(0.8),
+ pressed: YellowBoxStyle.getTextColor(0.6)
+ },
+ hitSlop: {
+ bottom: 8,
+ left: 8,
+ right: 8,
+ top: 8
+ },
+ onPress: this.props.onPress,
+ style: StyleSheet.compose(styles.root, this.props.status === 'PENDING' ? styles.pending : null),
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 57
+ }
+ }, React.createElement(Animated.Image, {
+ source: {
+ height: 16,
+ uri: image,
+ width: 16
+ },
+ style: StyleSheet.compose(styles.image, this.state.rotate == null ? null : {
+ transform: [{
+ rotate: this.state.rotate
+ }]
+ }),
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 68
+ }
+ }), React.createElement(Text, {
+ style: styles.text,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 77
+ }
+ }, "Source Map"));
+ }
+ }, {
+ key: "componentDidMount",
+ value: function componentDidMount() {
+ this._updateAnimation();
+ }
+ }, {
+ key: "componentDidUpdate",
+ value: function componentDidUpdate() {
+ this._updateAnimation();
+ }
+ }, {
+ key: "componentWillUnmount",
+ value: function componentWillUnmount() {
+ if (this.state.animation != null) {
+ this.state.animation.stop();
+ }
+ }
+ }, {
+ key: "_updateAnimation",
+ value: function _updateAnimation() {
+ if (this.props.status === 'PENDING') {
+ if (this.state.animation == null) {
+ var animated = new Animated.Value(0);
+ var animation = Animated.loop(Animated.timing(animated, {
+ duration: 2000,
+ easing: Easing.linear,
+ toValue: 1,
+ useNativeDriver: true
+ }));
+ this.setState({
+ animation: animation,
+ rotate: animated.interpolate({
+ inputRange: [0, 1],
+ outputRange: ['0deg', '360deg']
+ })
+ }, function () {
+ animation.start();
+ });
+ }
+ } else {
+ if (this.state.animation != null) {
+ this.state.animation.stop();
+ this.setState({
+ animation: null,
+ rotate: null
+ });
+ }
+ }
+ }
+ }]);
+
+ return YellowBoxInspectorSourceMapStatus;
+ }(React.Component);
+
+ var styles = StyleSheet.create({
+ root: {
+ alignItems: 'center',
+ borderRadius: 12,
+ flexDirection: 'row',
+ height: 24,
+ paddingHorizontal: 8
+ },
+ pending: {
+ backgroundColor: YellowBoxStyle.getTextColor(0.6)
+ },
+ image: {
+ marginEnd: 4,
+ tintColor: YellowBoxStyle.getBackgroundColor(1)
+ },
+ text: {
+ color: YellowBoxStyle.getBackgroundColor(1),
+ fontSize: 12,
+ includeFontPadding: false,
+ lineHeight: 16
+ }
+ });
+ module.exports = YellowBoxInspectorSourceMapStatus;
+},343,[3,4,5,8,9,237,264,52,53,208,342,335,336],"node_modules\\react-native\\Libraries\\YellowBox\\UI\\YellowBoxInspectorSourceMapStatus.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\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;
+},344,[52,53,208,335,336],"node_modules\\react-native\\Libraries\\YellowBox\\UI\\YellowBoxInspectorStackFrame.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\YellowBox\\UI\\YellowBoxListRow.js";
+
+ var React = _$$_REQUIRE(_dependencyMap[5], "React");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[6], "StyleSheet");
+
+ var Text = _$$_REQUIRE(_dependencyMap[7], "Text");
+
+ var YellowBoxPressable = _$$_REQUIRE(_dependencyMap[8], "YellowBoxPressable");
+
+ var View = _$$_REQUIRE(_dependencyMap[9], "View");
+
+ var YellowBoxCategory = _$$_REQUIRE(_dependencyMap[10], "YellowBoxCategory");
+
+ var YellowBoxStyle = _$$_REQUIRE(_dependencyMap[11], "YellowBoxStyle");
+
+ var YellowBoxWarning = _$$_REQUIRE(_dependencyMap[12], "YellowBoxWarning");
+
+ var YellowBoxListRow = function (_React$Component) {
+ _inherits(YellowBoxListRow, _React$Component);
+
+ function YellowBoxListRow() {
+ var _getPrototypeOf2;
+
+ var _this;
+
+ _classCallCheck(this, YellowBoxListRow);
+
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(YellowBoxListRow)).call.apply(_getPrototypeOf2, [this].concat(args)));
+
+ _this._handlePress = function () {
+ _this.props.onPress(_this.props.category);
+ };
+
+ return _this;
+ }
+
+ _createClass(YellowBoxListRow, [{
+ key: "shouldComponentUpdate",
+ value: function shouldComponentUpdate(nextProps) {
+ var prevProps = this.props;
+ return prevProps.category !== nextProps.category || prevProps.onPress !== nextProps.onPress || prevProps.warnings.length !== nextProps.warnings.length || prevProps.warnings.some(function (prevWarning, index) {
+ return prevWarning !== nextProps[index];
+ });
+ }
+ }, {
+ key: "render",
+ value: function render() {
+ var warnings = this.props.warnings;
+ return React.createElement(YellowBoxPressable, {
+ onPress: this._handlePress,
+ style: styles.root,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 50
+ }
+ }, React.createElement(View, {
+ style: styles.content,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 51
+ }
+ }, warnings.length < 2 ? null : React.createElement(Text, {
+ style: styles.metaText,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 53
+ }
+ }, '(' + warnings.length + ') '), React.createElement(Text, {
+ numberOfLines: 2,
+ style: styles.bodyText,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 55
+ }
+ }, YellowBoxCategory.render(warnings[warnings.length - 1].message, styles.substitutionText))));
+ }
+ }]);
+
+ return YellowBoxListRow;
+ }(React.Component);
+
+ YellowBoxListRow.GUTTER = StyleSheet.hairlineWidth;
+ YellowBoxListRow.HEIGHT = 48;
+ var styles = StyleSheet.create({
+ root: {
+ height: YellowBoxListRow.HEIGHT,
+ justifyContent: 'center',
+ marginTop: YellowBoxListRow.GUTTER,
+ paddingHorizontal: 12
+ },
+ content: {
+ alignItems: 'flex-start',
+ flexDirection: 'row'
+ },
+ bodyText: {
+ color: YellowBoxStyle.getTextColor(1),
+ flex: 1,
+ fontSize: 14,
+ includeFontPadding: false,
+ lineHeight: 18
+ },
+ metaText: {
+ color: YellowBoxStyle.getTextColor(0.5),
+ fontSize: 14,
+ includeFontPadding: false,
+ lineHeight: 18
+ },
+ substitutionText: {
+ color: YellowBoxStyle.getTextColor(0.6)
+ }
+ });
+ module.exports = YellowBoxListRow;
+},345,[3,4,5,8,9,52,53,208,335,81,338,336,346],"node_modules\\react-native\\Libraries\\YellowBox\\UI\\YellowBoxListRow.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var YellowBoxCategory = _$$_REQUIRE(_dependencyMap[3], "YellowBoxCategory");
+
+ var YellowBoxSymbolication = _$$_REQUIRE(_dependencyMap[4], "YellowBoxSymbolication");
+
+ var parseErrorStack = _$$_REQUIRE(_dependencyMap[5], "parseErrorStack");
+
+ var YellowBoxWarning = function () {
+ _createClass(YellowBoxWarning, null, [{
+ key: "parse",
+ value: function parse(_ref) {
+ var args = _ref.args,
+ framesToPop = _ref.framesToPop;
+ return _objectSpread({}, YellowBoxCategory.parse(args), {
+ stack: createStack({
+ framesToPop: framesToPop + 1
+ })
+ });
+ }
+ }]);
+
+ function YellowBoxWarning(message, stack) {
+ _classCallCheck(this, YellowBoxWarning);
+
+ this.symbolicated = {
+ error: null,
+ stack: null,
+ status: 'NONE'
+ };
+ this.message = message;
+ this.stack = stack;
+ }
+
+ _createClass(YellowBoxWarning, [{
+ key: "getAvailableStack",
+ value: function getAvailableStack() {
+ return this.symbolicated.status === 'COMPLETE' ? this.symbolicated.stack : this.stack;
+ }
+ }, {
+ key: "retrySymbolicate",
+ value: function retrySymbolicate(callback) {
+ YellowBoxSymbolication.delete(this.stack);
+ return this.symbolicate(callback);
+ }
+ }, {
+ key: "symbolicate",
+ value: function symbolicate(callback) {
+ var _this = this;
+
+ var aborted = false;
+
+ if (this.symbolicated.status !== 'COMPLETE') {
+ var updateStatus = function updateStatus(error, stack) {
+ if (error != null) {
+ _this.symbolicated = {
+ error: error,
+ stack: null,
+ status: 'FAILED'
+ };
+ } else if (stack != null) {
+ _this.symbolicated = {
+ error: null,
+ stack: stack,
+ status: 'COMPLETE'
+ };
+ } else {
+ _this.symbolicated = {
+ error: null,
+ stack: null,
+ status: 'PENDING'
+ };
+ }
+
+ if (!aborted) {
+ callback();
+ }
+ };
+
+ updateStatus(null, null);
+ YellowBoxSymbolication.symbolicate(this.stack).then(function (stack) {
+ updateStatus(null, stack);
+ }, function (error) {
+ updateStatus(error, null);
+ });
+ }
+
+ return {
+ abort: function abort() {
+ aborted = true;
+ }
+ };
+ }
+ }]);
+
+ return YellowBoxWarning;
+ }();
+
+ function createStack(_ref2) {
+ var framesToPop = _ref2.framesToPop;
+ var error = new Error();
+ error.framesToPop = framesToPop + 1;
+ return parseErrorStack(error);
+ }
+
+ module.exports = YellowBoxWarning;
+},346,[32,3,4,338,347,99],"node_modules\\react-native\\Libraries\\YellowBox\\Data\\YellowBoxWarning.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var symbolicateStackTrace = _$$_REQUIRE(_dependencyMap[0], "symbolicateStackTrace");
+
+ var cache = new Map();
+ var YellowBoxSymbolication = {
+ delete: function _delete(stack) {
+ cache.delete(getCacheKey(stack));
+ },
+ symbolicate: function symbolicate(stack) {
+ var key = getCacheKey(stack);
+ var promise = cache.get(key);
+
+ if (promise == null) {
+ promise = symbolicateStackTrace(stack).then(sanitize);
+ cache.set(key, promise);
+ }
+
+ return promise;
+ }
+ };
+
+ var getCacheKey = function getCacheKey(stack) {
+ return JSON.stringify(stack);
+ };
+
+ var sanitize = function sanitize(maybeStack) {
+ if (!Array.isArray(maybeStack)) {
+ throw new Error('Expected stack to be an array.');
+ }
+
+ var stack = [];
+
+ for (var _iterator = maybeStack, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();;) {
+ var _ref;
+
+ if (_isArray) {
+ if (_i >= _iterator.length) break;
+ _ref = _iterator[_i++];
+ } else {
+ _i = _iterator.next();
+ if (_i.done) break;
+ _ref = _i.value;
+ }
+
+ var _maybeFrame = _ref;
+
+ if (typeof _maybeFrame !== 'object' || _maybeFrame == null) {
+ throw new Error('Expected each stack frame to be an object.');
+ }
+
+ if (typeof _maybeFrame.column !== 'number' && _maybeFrame.column != null) {
+ throw new Error('Expected stack frame `column` to be a nullable number.');
+ }
+
+ if (typeof _maybeFrame.file !== 'string') {
+ throw new Error('Expected stack frame `file` to be a string.');
+ }
+
+ if (typeof _maybeFrame.lineNumber !== 'number') {
+ throw new Error('Expected stack frame `lineNumber` to be a number.');
+ }
+
+ if (typeof _maybeFrame.methodName !== 'string') {
+ throw new Error('Expected stack frame `methodName` to be a string.');
+ }
+
+ stack.push({
+ column: _maybeFrame.column,
+ file: _maybeFrame.file,
+ lineNumber: _maybeFrame.lineNumber,
+ methodName: _maybeFrame.methodName
+ });
+ }
+
+ return stack;
+ };
+
+ module.exports = YellowBoxSymbolication;
+},347,[101],"node_modules\\react-native\\Libraries\\YellowBox\\Data\\YellowBoxSymbolication.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _toConsumableArray = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/toConsumableArray");
+
+ var _slicedToArray = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray");
+
+ var YellowBoxWarning = _$$_REQUIRE(_dependencyMap[2], "YellowBoxWarning");
+
+ var observers = new Set();
+ var ignorePatterns = new Set();
+ var registry = new Map();
+ var disabled = false;
+ var projection = new Map();
+ var updateTimeout = null;
+
+ function isWarningIgnored(warning) {
+ for (var _iterator = ignorePatterns, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();;) {
+ var _ref;
+
+ if (_isArray) {
+ if (_i >= _iterator.length) break;
+ _ref = _iterator[_i++];
+ } else {
+ _i = _iterator.next();
+ if (_i.done) break;
+ _ref = _i.value;
+ }
+
+ var _pattern = _ref;
+
+ if (warning.message.content.includes(_pattern)) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ function handleUpdate() {
+ projection = new Map();
+
+ if (!disabled) {
+ for (var _iterator2 = registry, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();;) {
+ var _ref4;
+
+ if (_isArray2) {
+ if (_i2 >= _iterator2.length) break;
+ _ref4 = _iterator2[_i2++];
+ } else {
+ _i2 = _iterator2.next();
+ if (_i2.done) break;
+ _ref4 = _i2.value;
+ }
+
+ var _ref5 = _ref4;
+
+ var _ref3 = _slicedToArray(_ref5, 2);
+
+ var _category = _ref3[0];
+ var _warnings = _ref3[1];
+
+ var filtered = _warnings.filter(function (warning) {
+ return !isWarningIgnored(warning);
+ });
+
+ if (filtered.length > 0) {
+ projection.set(_category, filtered);
+ }
+ }
+ }
+
+ if (updateTimeout == null) {
+ updateTimeout = setImmediate(function () {
+ updateTimeout = null;
+
+ for (var _iterator3 = observers, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();;) {
+ var _ref7;
+
+ if (_isArray3) {
+ if (_i3 >= _iterator3.length) break;
+ _ref7 = _iterator3[_i3++];
+ } else {
+ _i3 = _iterator3.next();
+ if (_i3.done) break;
+ _ref7 = _i3.value;
+ }
+
+ var _ref8 = _ref7;
+ var _observer = _ref8.observer;
+
+ _observer(projection);
+ }
+ });
+ }
+ }
+
+ var YellowBoxRegistry = {
+ add: function add(_ref9) {
+ var args = _ref9.args,
+ framesToPop = _ref9.framesToPop;
+
+ if (typeof args[0] === 'string' && args[0].startsWith('(ADVICE)')) {
+ return;
+ }
+
+ var _YellowBoxWarning$par = YellowBoxWarning.parse({
+ args: args,
+ framesToPop: framesToPop + 1
+ }),
+ category = _YellowBoxWarning$par.category,
+ message = _YellowBoxWarning$par.message,
+ stack = _YellowBoxWarning$par.stack;
+
+ var warnings = registry.get(category);
+
+ if (warnings == null) {
+ warnings = [];
+ }
+
+ warnings = [].concat(_toConsumableArray(warnings), [new YellowBoxWarning(message, stack)]);
+ registry.delete(category);
+ registry.set(category, warnings);
+ handleUpdate();
+ },
+ delete: function _delete(category) {
+ if (registry.has(category)) {
+ registry.delete(category);
+ handleUpdate();
+ }
+ },
+ clear: function clear() {
+ if (registry.size > 0) {
+ registry.clear();
+ handleUpdate();
+ }
+ },
+ addIgnorePatterns: function addIgnorePatterns(patterns) {
+ var newPatterns = patterns.filter(function (pattern) {
+ 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;
+},348,[43,37,346],"node_modules\\react-native\\Libraries\\YellowBox\\Data\\YellowBoxRegistry.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var requireNativeComponent = _$$_REQUIRE(_dependencyMap[0], "requireNativeComponent");
+
+ module.exports = requireNativeComponent('RCTModalHostView');
+},349,[184],"node_modules\\react-native\\Libraries\\Modal\\RCTModalHostViewNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Components\\Picker\\Picker.js";
+
+ var PickerAndroid = _$$_REQUIRE(_dependencyMap[6], "PickerAndroid");
+
+ var PickerIOS = _$$_REQUIRE(_dependencyMap[7], "PickerIOS");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[8], "Platform");
+
+ var React = _$$_REQUIRE(_dependencyMap[9], "React");
+
+ var UnimplementedView = _$$_REQUIRE(_dependencyMap[10], "UnimplementedView");
+
+ var MODE_DIALOG = 'dialog';
+ var MODE_DROPDOWN = 'dropdown';
+
+ var PickerItem = function (_React$Component) {
+ _inherits(PickerItem, _React$Component);
+
+ function PickerItem() {
+ _classCallCheck(this, PickerItem);
+
+ return _possibleConstructorReturn(this, _getPrototypeOf(PickerItem).apply(this, arguments));
+ }
+
+ _createClass(PickerItem, [{
+ key: "render",
+ value: function render() {
+ throw null;
+ }
+ }]);
+
+ return PickerItem;
+ }(React.Component);
+
+ var Picker = function (_React$Component2) {
+ _inherits(Picker, _React$Component2);
+
+ function Picker() {
+ _classCallCheck(this, Picker);
+
+ return _possibleConstructorReturn(this, _getPrototypeOf(Picker).apply(this, arguments));
+ }
+
+ _createClass(Picker, [{
+ key: "render",
+ value: function render() {
+ if (Platform.OS === 'ios' || Platform.OS === 'macos') {
+ return React.createElement(PickerIOS, _extends({}, this.props, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 144
+ }
+ }), this.props.children);
+ } else if (Platform.OS === 'android') {
+ return React.createElement(PickerAndroid, _extends({}, this.props, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 149
+ }
+ }), this.props.children);
+ } else {
+ return React.createElement(UnimplementedView, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 152
+ }
+ });
+ }
+ }
+ }]);
+
+ return Picker;
+ }(React.Component);
+
+ Picker.MODE_DIALOG = MODE_DIALOG;
+ Picker.MODE_DROPDOWN = MODE_DROPDOWN;
+ Picker.Item = PickerItem;
+ Picker.defaultProps = {
+ mode: MODE_DIALOG
+ };
+ module.exports = Picker;
+},350,[14,3,4,5,8,9,351,352,35,52,196],"node_modules\\react-native\\Libraries\\Components\\Picker\\Picker.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "UnimplementedView");
+},351,[196],"Libraries\\Components\\Picker\\PickerAndroid.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "UnimplementedView");
+},352,[196],"Libraries\\Components\\Picker\\PickerIOS.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "UnimplementedView");
+},353,[196],"Libraries\\Components\\ProgressViewIOS\\ProgressViewIOS.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "UnimplementedView");
+},354,[196],"Libraries\\Components\\SegmentedControlIOS\\SegmentedControlIOS.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _objectWithoutProperties = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/objectWithoutProperties");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Components\\Slider\\Slider.js";
+
+ var Platform = _$$_REQUIRE(_dependencyMap[2], "Platform");
+
+ var RCTSliderNativeComponent = _$$_REQUIRE(_dependencyMap[3], "RCTSliderNativeComponent");
+
+ var React = _$$_REQUIRE(_dependencyMap[4], "React");
+
+ var ReactNative = _$$_REQUIRE(_dependencyMap[5], "ReactNative");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[6], "StyleSheet");
+
+ var Slider = function Slider(props, forwardedRef) {
+ var style = StyleSheet.compose(styles.slider, props.style);
+
+ var onValueChange = props.onValueChange,
+ onSlidingComplete = props.onSlidingComplete,
+ localProps = _objectWithoutProperties(props, ["onValueChange", "onSlidingComplete"]);
+
+ var onValueChangeEvent = onValueChange ? function (event) {
+ var userEvent = true;
+
+ if (Platform.OS === 'android') {
+ userEvent = event.nativeEvent.fromUser != null && event.nativeEvent.fromUser;
+ }
+
+ userEvent && onValueChange(event.nativeEvent.value);
+ } : null;
+ var onChangeEvent = onValueChangeEvent;
+ var onSlidingCompleteEvent = onSlidingComplete ? function (event) {
+ onSlidingComplete(event.nativeEvent.value);
+ } : null;
+ return React.createElement(RCTSliderNativeComponent, _extends({}, localProps, {
+ ref: forwardedRef,
+ style: style,
+ onChange: onChangeEvent,
+ onSlidingComplete: onSlidingCompleteEvent,
+ onValueChange: onValueChangeEvent,
+ enabled: !props.disabled,
+ onStartShouldSetResponder: function onStartShouldSetResponder() {
+ return true;
+ },
+ onResponderTerminationRequest: function onResponderTerminationRequest() {
+ return false;
+ },
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 230
+ }
+ }));
+ };
+
+ var SliderWithRef = React.forwardRef(Slider);
+ SliderWithRef.defaultProps = {
+ disabled: false,
+ value: 0,
+ minimumValue: 0,
+ maximumValue: 1,
+ step: 0
+ };
+ var styles;
+
+ if (Platform.OS === 'ios' || Platform.OS === 'macos') {
+ styles = StyleSheet.create({
+ slider: {
+ height: 40
+ }
+ });
+ } else {
+ styles = StyleSheet.create({
+ slider: {}
+ });
+ }
+
+ module.exports = SliderWithRef;
+},355,[14,33,35,356,52,84,53],"node_modules\\react-native\\Libraries\\Components\\Slider\\Slider.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var requireNativeComponent = _$$_REQUIRE(_dependencyMap[0], "requireNativeComponent");
+
+ module.exports = requireNativeComponent('RCTSlider');
+},356,[184],"node_modules\\react-native\\Libraries\\Components\\Slider\\RCTSliderNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "UnimplementedView");
+},357,[196],"Libraries\\RCTTest\\SnapshotViewIOS.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _objectWithoutProperties = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/objectWithoutProperties");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Components\\Switch\\Switch.js";
+
+ var SwitchNativeComponent = _$$_REQUIRE(_dependencyMap[7], "SwitchNativeComponent");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[8], "Platform");
+
+ var React = _$$_REQUIRE(_dependencyMap[9], "React");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[10], "StyleSheet");
+
+ var Switch = function (_React$Component) {
+ _inherits(Switch, _React$Component);
+
+ function Switch() {
+ var _getPrototypeOf2;
+
+ var _this;
+
+ _classCallCheck(this, Switch);
+
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(Switch)).call.apply(_getPrototypeOf2, [this].concat(args)));
+
+ _this._handleChange = function (event) {
+ if (_this._nativeSwitchRef == null) {
+ return;
+ }
+
+ var value = _this.props.value === true;
+
+ if (Platform.OS === 'android') {
+ _this._nativeSwitchRef.setNativeProps({
+ on: value
+ });
+ } else {
+ _this._nativeSwitchRef.setNativeProps({
+ value: value
+ });
+ }
+
+ if (_this.props.onChange != null) {
+ _this.props.onChange(event);
+ }
+
+ if (_this.props.onValueChange != null) {
+ _this.props.onValueChange(event.nativeEvent.value);
+ }
+ };
+
+ _this._handleSwitchNativeComponentRef = function (ref) {
+ _this._nativeSwitchRef = ref;
+ };
+
+ return _this;
+ }
+
+ _createClass(Switch, [{
+ key: "render",
+ value: function render() {
+ var _props$accessibilityR;
+
+ var _this$props = this.props,
+ disabled = _this$props.disabled,
+ ios_backgroundColor = _this$props.ios_backgroundColor,
+ onChange = _this$props.onChange,
+ onValueChange = _this$props.onValueChange,
+ style = _this$props.style,
+ thumbColor = _this$props.thumbColor,
+ trackColor = _this$props.trackColor,
+ value = _this$props.value,
+ props = _objectWithoutProperties(_this$props, ["disabled", "ios_backgroundColor", "onChange", "onValueChange", "style", "thumbColor", "trackColor", "value"]);
+
+ var _thumbColor = thumbColor;
+
+ var _trackColorForFalse = trackColor == null ? void 0 : trackColor.false;
+
+ var _trackColorForTrue = trackColor == null ? void 0 : trackColor.true;
+
+ var _ref = props,
+ thumbTintColor = _ref.thumbTintColor,
+ tintColor = _ref.tintColor,
+ onTintColor = _ref.onTintColor;
+
+ if (thumbTintColor != null) {
+ _thumbColor = thumbTintColor;
+
+ if (__DEV__) {
+ console.warn('Switch: `thumbTintColor` is deprecated, use `thumbColor` instead.');
+ }
+ }
+
+ if (tintColor != null) {
+ _trackColorForFalse = tintColor;
+
+ if (__DEV__) {
+ console.warn('Switch: `tintColor` is deprecated, use `trackColor` instead.');
+ }
+ }
+
+ if (onTintColor != null) {
+ _trackColorForTrue = onTintColor;
+
+ if (__DEV__) {
+ console.warn('Switch: `onTintColor` is deprecated, use `trackColor` instead.');
+ }
+ }
+
+ var platformProps = Platform.OS === 'android' ? {
+ enabled: disabled !== true,
+ on: value === true,
+ style: style,
+ thumbTintColor: _thumbColor,
+ trackTintColor: value === true ? _trackColorForTrue : _trackColorForFalse
+ } : {
+ disabled: disabled,
+ onTintColor: _trackColorForTrue,
+ style: StyleSheet.compose({
+ height: 31,
+ width: 51
+ }, StyleSheet.compose(style, ios_backgroundColor == null ? null : {
+ backgroundColor: ios_backgroundColor,
+ borderRadius: 16
+ })),
+ thumbTintColor: _thumbColor,
+ tintColor: _trackColorForFalse,
+ value: value === true
+ };
+ return React.createElement(SwitchNativeComponent, _extends({}, props, platformProps, {
+ accessibilityRole: (_props$accessibilityR = props.accessibilityRole) != null ? _props$accessibilityR : 'button',
+ onChange: this._handleChange,
+ onResponderTerminationRequest: returnsFalse,
+ onStartShouldSetResponder: returnsTrue,
+ ref: this._handleSwitchNativeComponentRef,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 164
+ }
+ }));
+ }
+ }]);
+
+ return Switch;
+ }(React.Component);
+
+ var returnsFalse = function returnsFalse() {
+ return false;
+ };
+
+ var returnsTrue = function returnsTrue() {
+ return true;
+ };
+
+ module.exports = Switch;
+},358,[14,33,3,4,5,8,9,359,35,52,53],"node_modules\\react-native\\Libraries\\Components\\Switch\\Switch.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var Platform = _$$_REQUIRE(_dependencyMap[0], "Platform");
+
+ var ReactNative = _$$_REQUIRE(_dependencyMap[1], "ReactNative");
+
+ var requireNativeComponent = _$$_REQUIRE(_dependencyMap[2], "requireNativeComponent");
+
+ var SwitchNativeComponent = Platform.OS === 'android' ? requireNativeComponent('AndroidSwitch') : requireNativeComponent('RCTSwitch');
+ module.exports = SwitchNativeComponent;
+},359,[35,84,184],"node_modules\\react-native\\Libraries\\Components\\Switch\\SwitchNativeComponent.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var _extends = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/extends");
+
+ var _StatusBarManager$DEF;
+
+ var React = _$$_REQUIRE(_dependencyMap[6], "React");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[7], "Platform");
+
+ var processColor = _$$_REQUIRE(_dependencyMap[8], "processColor");
+
+ var StatusBarManager = _$$_REQUIRE(_dependencyMap[9], "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) {
+ _inherits(StatusBar, _React$Component);
+
+ function StatusBar() {
+ var _getPrototypeOf2;
+
+ var _this;
+
+ _classCallCheck(this, StatusBar);
+
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(StatusBar)).call.apply(_getPrototypeOf2, [this].concat(args)));
+ _this._stackEntry = null;
+ return _this;
+ }
+
+ _createClass(StatusBar, [{
+ key: "componentDidMount",
+ value: function componentDidMount() {
+ this._stackEntry = StatusBar.pushStackEntry(this.props);
+ }
+ }, {
+ key: "componentWillUnmount",
+ value: function componentWillUnmount() {
+ StatusBar.popStackEntry(this._stackEntry);
+ }
+ }, {
+ key: "componentDidUpdate",
+ value: function componentDidUpdate() {
+ this._stackEntry = StatusBar.replaceStackEntry(this._stackEntry, this.props);
+ }
+ }, {
+ key: "render",
+ value: function render() {
+ return null;
+ }
+ }], [{
+ key: "setHidden",
+ value: function setHidden(hidden, animation) {
+ animation = animation || 'none';
+ StatusBar._defaultProps.hidden.value = hidden;
+
+ if (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);
+ }
+ }, {
+ key: "pushStackEntry",
+ value: function pushStackEntry(props) {
+ var entry = createStackEntry(props);
+
+ StatusBar._propsStack.push(entry);
+
+ StatusBar._updatePropsStack();
+
+ return entry;
+ }
+ }, {
+ key: "popStackEntry",
+ value: function popStackEntry(entry) {
+ var index = StatusBar._propsStack.indexOf(entry);
+
+ if (index !== -1) {
+ StatusBar._propsStack.splice(index, 1);
+ }
+
+ StatusBar._updatePropsStack();
+ }
+ }, {
+ key: "replaceStackEntry",
+ value: function replaceStackEntry(entry, props) {
+ var newEntry = createStackEntry(props);
+
+ var index = StatusBar._propsStack.indexOf(entry);
+
+ if (index !== -1) {
+ StatusBar._propsStack[index] = newEntry;
+ }
+
+ StatusBar._updatePropsStack();
+
+ return newEntry;
+ }
+ }]);
+
+ return StatusBar;
+ }(React.Component);
+
+ StatusBar._propsStack = [];
+ StatusBar._defaultProps = createStackEntry({
+ animated: false,
+ showHideTransition: 'fade',
+ backgroundColor: Platform.select({
+ android: (_StatusBarManager$DEF = StatusBarManager.DEFAULT_BACKGROUND_COLOR) != null ? _StatusBarManager$DEF : 'black',
+ ios: 'black'
+ }),
+ barStyle: 'default',
+ translucent: false,
+ hidden: false,
+ networkActivityIndicatorVisible: false
+ });
+ StatusBar._updateImmediate = null;
+ StatusBar._currentValues = null;
+ StatusBar.currentHeight = StatusBarManager.HEIGHT;
+ StatusBar.defaultProps = {
+ animated: false,
+ showHideTransition: 'fade'
+ };
+
+ StatusBar._updatePropsStack = function () {
+ clearImmediate(StatusBar._updateImmediate);
+ StatusBar._updateImmediate = setImmediate(function () {
+ var oldProps = StatusBar._currentValues;
+ var mergedProps = mergePropsStack(StatusBar._propsStack, StatusBar._defaultProps);
+
+ if (Platform.OS === 'ios') {
+ if (!oldProps || oldProps.barStyle.value !== mergedProps.barStyle.value) {
+ StatusBarManager.setStyle(mergedProps.barStyle.value, mergedProps.barStyle.animated || false);
+ }
+
+ 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;
+ });
+ };
+
+ module.exports = StatusBar;
+},360,[3,4,5,8,9,14,52,35,75,36],"node_modules\\react-native\\Libraries\\Components\\StatusBar\\StatusBar.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ var _extends = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/extends");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Experimental\\SwipeableRow\\SwipeableFlatList.js";
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var React = _$$_REQUIRE(_dependencyMap[7], "React");
+
+ var SwipeableRow = _$$_REQUIRE(_dependencyMap[8], "SwipeableRow");
+
+ var FlatList = _$$_REQUIRE(_dependencyMap[9], "FlatList");
+
+ var SwipeableFlatList = function (_React$Component) {
+ _inherits(SwipeableFlatList, _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: 122
+ }
+ }, _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,
+ extraData: this.state,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 83
+ }
+ }));
+ }
+ }, {
+ 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
+ });
+ }
+ }]);
+
+ return SwipeableFlatList;
+ }(React.Component);
+
+ SwipeableFlatList.defaultProps = _objectSpread({}, FlatList.defaultProps, {
+ bounceFirstRowOnMount: true,
+ renderQuickActions: function renderQuickActions() {
+ return null;
+ }
+ });
+ module.exports = SwipeableFlatList;
+},361,[32,14,3,4,5,8,9,52,362,268],"node_modules\\react-native\\Libraries\\Experimental\\SwipeableRow\\SwipeableFlatList.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Experimental\\SwipeableRow\\SwipeableRow.js";
+
+ var Animated = _$$_REQUIRE(_dependencyMap[6], "Animated");
+
+ var I18nManager = _$$_REQUIRE(_dependencyMap[7], "I18nManager");
+
+ var PanResponder = _$$_REQUIRE(_dependencyMap[8], "PanResponder");
+
+ var React = _$$_REQUIRE(_dependencyMap[9], "React");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[10], "StyleSheet");
+
+ var View = _$$_REQUIRE(_dependencyMap[11], "View");
+
+ 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 DEFAULT_SWIPE_THRESHOLD = 30;
+
+ var emptyFunction = function emptyFunction() {};
+
+ var SwipeableRow = function (_React$Component) {
+ _inherits(SwipeableRow, _React$Component);
+
+ function SwipeableRow() {
+ var _getPrototypeOf2;
+
+ var _this;
+
+ _classCallCheck(this, SwipeableRow);
+
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(SwipeableRow)).call.apply(_getPrototypeOf2, [this].concat(args)));
+
+ _this._handleMoveShouldSetPanResponderCapture = function (event, gestureState) {
+ return gestureState.dy < 10 && _this._isValidSwipe(gestureState);
+ };
+
+ _this._handlePanResponderGrant = function (event, gestureState) {};
+
+ _this._handlePanResponderMove = function (event, gestureState) {
+ if (_this._isSwipingExcessivelyRightFromClosedPosition(gestureState)) {
+ return;
+ }
+
+ _this.props.onSwipeStart && _this.props.onSwipeStart();
+
+ if (_this._isSwipingRightFromClosed(gestureState)) {
+ _this._swipeSlowSpeed(gestureState);
+ } else {
+ _this._swipeFullSpeed(gestureState);
+ }
+ };
+
+ _this._onPanResponderTerminationRequest = function (event, gestureState) {
+ return false;
+ };
+
+ _this._handlePanResponderEnd = function (event, gestureState) {
+ var horizontalDistance = IS_RTL ? -gestureState.dx : gestureState.dx;
+
+ if (_this._isSwipingRightFromClosed(gestureState)) {
+ _this.props.onOpen && _this.props.onOpen();
+
+ _this._animateBounceBack(RIGHT_SWIPE_BOUNCE_BACK_DURATION);
+ } else if (_this._shouldAnimateRemainder(gestureState)) {
+ if (horizontalDistance < 0) {
+ _this.props.onOpen && _this.props.onOpen();
+
+ _this._animateToOpenPositionWith(gestureState.vx, horizontalDistance);
+ } else {
+ _this.props.onClose && _this.props.onClose();
+
+ _this._animateToClosedPosition();
+ }
+ } else {
+ if (_this._previousLeft === CLOSED_LEFT_POSITION) {
+ _this._animateToClosedPosition();
+ } else {
+ _this._animateToOpenPosition();
+ }
+ }
+
+ _this.props.onSwipeEnd && _this.props.onSwipeEnd();
+ };
+
+ _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;
+ }
+ });
+ _this._previousLeft = CLOSED_LEFT_POSITION;
+ _this._timeoutID = null;
+ _this.state = {
+ currentLeft: new Animated.Value(_this._previousLeft),
+ isSwipeableViewRendered: false,
+ rowHeight: null
+ };
+
+ _this._onSwipeableViewLayout = function (event) {
+ _this.setState({
+ isSwipeableViewRendered: true,
+ rowHeight: event.nativeEvent.layout.height
+ });
+ };
+
+ _this._animateToClosedPositionDuringBounce = function () {
+ _this._animateToClosedPosition(RIGHT_SWIPE_BOUNCE_BACK_DURATION);
+ };
+
+ return _this;
+ }
+
+ _createClass(SwipeableRow, [{
+ key: "componentDidMount",
+ value: function componentDidMount() {
+ var _this2 = this;
+
+ if (this.props.shouldBounceOnMount) {
+ this._timeoutID = setTimeout(function () {
+ _this2._animateBounceBack(ON_MOUNT_BOUNCE_DURATION);
+ }, ON_MOUNT_BOUNCE_DELAY);
+ }
+ }
+ }, {
+ key: "UNSAFE_componentWillReceiveProps",
+ value: function UNSAFE_componentWillReceiveProps(nextProps) {
+ var _this$props$isOpen, _nextProps$isOpen;
+
+ var isOpen = (_this$props$isOpen = this.props.isOpen) != null ? _this$props$isOpen : false;
+ var nextIsOpen = (_nextProps$isOpen = nextProps.isOpen) != null ? _nextProps$isOpen : false;
+
+ if (isOpen && !nextIsOpen) {
+ this._animateToClosedPosition();
+ }
+ }
+ }, {
+ key: "componentWillUnmount",
+ value: function componentWillUnmount() {
+ if (this._timeoutID != null) {
+ clearTimeout(this._timeoutID);
+ }
+ }
+ }, {
+ key: "render",
+ value: 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: 214
+ }
+ }, this.props.slideoutView);
+ }
+
+ var swipeableView = React.createElement(Animated.View, {
+ onLayout: this._onSwipeableViewLayout,
+ style: {
+ transform: [{
+ translateX: this.state.currentLeft
+ }]
+ },
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 223
+ }
+ }, this.props.children);
+ return React.createElement(View, _extends({}, this._panResponder.panHandlers, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 231
+ }
+ }), slideOutView, swipeableView);
+ }
+ }, {
+ key: "close",
+ value: function close() {
+ this.props.onClose && this.props.onClose();
+
+ this._animateToClosedPosition();
+ }
+ }, {
+ key: "_isSwipingRightFromClosed",
+ value: function _isSwipingRightFromClosed(gestureState) {
+ var gestureStateDx = IS_RTL ? -gestureState.dx : gestureState.dx;
+ return this._previousLeft === CLOSED_LEFT_POSITION && gestureStateDx > 0;
+ }
+ }, {
+ key: "_swipeFullSpeed",
+ value: function _swipeFullSpeed(gestureState) {
+ this.state.currentLeft.setValue(this._previousLeft + gestureState.dx);
+ }
+ }, {
+ key: "_swipeSlowSpeed",
+ value: function _swipeSlowSpeed(gestureState) {
+ this.state.currentLeft.setValue(this._previousLeft + gestureState.dx / SLOW_SPEED_SWIPE_FACTOR);
+ }
+ }, {
+ key: "_isSwipingExcessivelyRightFromClosedPosition",
+ value: function _isSwipingExcessivelyRightFromClosedPosition(gestureState) {
+ var gestureStateDx = IS_RTL ? -gestureState.dx : gestureState.dx;
+ return this._isSwipingRightFromClosed(gestureState) && gestureStateDx > RIGHT_SWIPE_THRESHOLD;
+ }
+ }, {
+ key: "_animateTo",
+ value: function _animateTo(toValue) {
+ var _this3 = 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 () {
+ _this3._previousLeft = toValue;
+ callback();
+ });
+ }
+ }, {
+ key: "_animateToOpenPosition",
+ value: function _animateToOpenPosition() {
+ var _this$props$maxSwipeD;
+
+ var maxSwipeDistance = (_this$props$maxSwipeD = this.props.maxSwipeDistance) != null ? _this$props$maxSwipeD : 0;
+ var directionAwareMaxSwipeDistance = IS_RTL ? -maxSwipeDistance : maxSwipeDistance;
+
+ this._animateTo(-directionAwareMaxSwipeDistance);
+ }
+ }, {
+ key: "_animateToOpenPositionWith",
+ value: function _animateToOpenPositionWith(speed, distMoved) {
+ var _this$props$maxSwipeD2;
+
+ speed = speed > HORIZONTAL_FULL_SWIPE_SPEED_THRESHOLD ? speed : HORIZONTAL_FULL_SWIPE_SPEED_THRESHOLD;
+ var maxSwipeDistance = (_this$props$maxSwipeD2 = this.props.maxSwipeDistance) != null ? _this$props$maxSwipeD2 : 0;
+ var duration = Math.abs((maxSwipeDistance - Math.abs(distMoved)) / speed);
+ var directionAwareMaxSwipeDistance = IS_RTL ? -maxSwipeDistance : maxSwipeDistance;
+
+ this._animateTo(-directionAwareMaxSwipeDistance, duration);
+ }
+ }, {
+ key: "_animateToClosedPosition",
+ value: function _animateToClosedPosition() {
+ var duration = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : SWIPE_DURATION;
+
+ this._animateTo(CLOSED_LEFT_POSITION, duration);
+ }
+ }, {
+ key: "_animateBounceBack",
+ value: function _animateBounceBack(duration) {
+ var swipeBounceBackDistance = IS_RTL ? -RIGHT_SWIPE_BOUNCE_BACK_DISTANCE : RIGHT_SWIPE_BOUNCE_BACK_DISTANCE;
+
+ this._animateTo(-swipeBounceBackDistance, duration, this._animateToClosedPositionDuringBounce);
+ }
+ }, {
+ key: "_isValidSwipe",
+ value: function _isValidSwipe(gestureState) {
+ var _this$props$preventSw;
+
+ var preventSwipeRight = (_this$props$preventSw = this.props.preventSwipeRight) != null ? _this$props$preventSw : false;
+
+ if (preventSwipeRight && this._previousLeft === CLOSED_LEFT_POSITION && gestureState.dx > 0) {
+ return false;
+ }
+
+ return Math.abs(gestureState.dx) > HORIZONTAL_SWIPE_DISTANCE_THRESHOLD;
+ }
+ }, {
+ key: "_shouldAnimateRemainder",
+ value: function _shouldAnimateRemainder(gestureState) {
+ var _this$props$swipeThre;
+
+ var swipeThreshold = (_this$props$swipeThre = this.props.swipeThreshold) != null ? _this$props$swipeThre : DEFAULT_SWIPE_THRESHOLD;
+ return Math.abs(gestureState.dx) > swipeThreshold || gestureState.vx > HORIZONTAL_FULL_SWIPE_SPEED_THRESHOLD;
+ }
+ }]);
+
+ return SwipeableRow;
+ }(React.Component);
+
+ var styles = StyleSheet.create({
+ slideOutContainer: {
+ bottom: 0,
+ left: 0,
+ position: 'absolute',
+ right: 0,
+ top: 0
+ }
+ });
+ module.exports = SwipeableRow;
+},362,[14,3,4,5,8,9,237,320,363,52,53,81],"node_modules\\react-native\\Libraries\\Experimental\\SwipeableRow\\SwipeableRow.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var InteractionManager = _$$_REQUIRE(_dependencyMap[0], "./InteractionManager");
+
+ var TouchHistoryMath = _$$_REQUIRE(_dependencyMap[1], "./TouchHistoryMath");
+
+ var currentCentroidXOfTouchesChangedAfter = TouchHistoryMath.currentCentroidXOfTouchesChangedAfter;
+ var currentCentroidYOfTouchesChangedAfter = TouchHistoryMath.currentCentroidYOfTouchesChangedAfter;
+ var previousCentroidXOfTouchesChangedAfter = TouchHistoryMath.previousCentroidXOfTouchesChangedAfter;
+ var previousCentroidYOfTouchesChangedAfter = TouchHistoryMath.previousCentroidYOfTouchesChangedAfter;
+ var currentCentroidX = TouchHistoryMath.currentCentroidX;
+ var currentCentroidY = TouchHistoryMath.currentCentroidY;
+ var PanResponder = {
+ _initializeGestureState: function _initializeGestureState(gestureState) {
+ gestureState.moveX = 0;
+ gestureState.moveY = 0;
+ gestureState.x0 = 0;
+ gestureState.y0 = 0;
+ gestureState.dx = 0;
+ gestureState.dy = 0;
+ gestureState.vx = 0;
+ gestureState.vy = 0;
+ gestureState.numberActiveTouches = 0;
+ gestureState._accountsForMovesUpTo = 0;
+ },
+ _updateGestureStateOnMove: function _updateGestureStateOnMove(gestureState, touchHistory) {
+ gestureState.numberActiveTouches = touchHistory.numberActiveTouches;
+ gestureState.moveX = currentCentroidXOfTouchesChangedAfter(touchHistory, gestureState._accountsForMovesUpTo);
+ gestureState.moveY = currentCentroidYOfTouchesChangedAfter(touchHistory, gestureState._accountsForMovesUpTo);
+ var movedAfter = gestureState._accountsForMovesUpTo;
+ var prevX = previousCentroidXOfTouchesChangedAfter(touchHistory, movedAfter);
+ var x = currentCentroidXOfTouchesChangedAfter(touchHistory, movedAfter);
+ var prevY = previousCentroidYOfTouchesChangedAfter(touchHistory, movedAfter);
+ var y = currentCentroidYOfTouchesChangedAfter(touchHistory, movedAfter);
+ var nextDX = gestureState.dx + (x - prevX);
+ var nextDY = gestureState.dy + (y - prevY);
+ var dt = touchHistory.mostRecentTimeStamp - gestureState._accountsForMovesUpTo;
+ gestureState.vx = (nextDX - gestureState.dx) / dt;
+ gestureState.vy = (nextDY - gestureState.dy) / dt;
+ gestureState.dx = nextDX;
+ gestureState.dy = nextDY;
+ gestureState._accountsForMovesUpTo = touchHistory.mostRecentTimeStamp;
+ },
+ create: function create(config) {
+ var interactionState = {
+ handle: null
+ };
+ var gestureState = {
+ stateID: Math.random(),
+ moveX: 0,
+ moveY: 0,
+ x0: 0,
+ y0: 0,
+ dx: 0,
+ dy: 0,
+ vx: 0,
+ vy: 0,
+ numberActiveTouches: 0,
+ _accountsForMovesUpTo: 0
+ };
+ var panHandlers = {
+ onStartShouldSetResponder: function onStartShouldSetResponder(event) {
+ return config.onStartShouldSetPanResponder == null ? false : config.onStartShouldSetPanResponder(event, gestureState);
+ },
+ onMoveShouldSetResponder: function onMoveShouldSetResponder(event) {
+ return config.onMoveShouldSetPanResponder == null ? false : config.onMoveShouldSetPanResponder(event, gestureState);
+ },
+ onStartShouldSetResponderCapture: function onStartShouldSetResponderCapture(event) {
+ if (event.nativeEvent.touches.length === 1) {
+ PanResponder._initializeGestureState(gestureState);
+ }
+
+ gestureState.numberActiveTouches = event.touchHistory.numberActiveTouches;
+ return config.onStartShouldSetPanResponderCapture != null ? config.onStartShouldSetPanResponderCapture(event, gestureState) : false;
+ },
+ onMoveShouldSetResponderCapture: function onMoveShouldSetResponderCapture(event) {
+ var touchHistory = event.touchHistory;
+
+ if (gestureState._accountsForMovesUpTo === touchHistory.mostRecentTimeStamp) {
+ return false;
+ }
+
+ PanResponder._updateGestureStateOnMove(gestureState, touchHistory);
+
+ return config.onMoveShouldSetPanResponderCapture ? config.onMoveShouldSetPanResponderCapture(event, gestureState) : false;
+ },
+ onResponderGrant: function onResponderGrant(event) {
+ if (!interactionState.handle) {
+ interactionState.handle = InteractionManager.createInteractionHandle();
+ }
+
+ gestureState.x0 = currentCentroidX(event.touchHistory);
+ gestureState.y0 = currentCentroidY(event.touchHistory);
+ gestureState.dx = 0;
+ gestureState.dy = 0;
+
+ if (config.onPanResponderGrant) {
+ config.onPanResponderGrant(event, gestureState);
+ }
+
+ return config.onShouldBlockNativeResponder == null ? true : config.onShouldBlockNativeResponder(event, gestureState);
+ },
+ onResponderReject: function onResponderReject(event) {
+ clearInteractionHandle(interactionState, config.onPanResponderReject, event, gestureState);
+ },
+ onResponderRelease: function onResponderRelease(event) {
+ clearInteractionHandle(interactionState, config.onPanResponderRelease, event, gestureState);
+
+ PanResponder._initializeGestureState(gestureState);
+ },
+ onResponderStart: function onResponderStart(event) {
+ var touchHistory = event.touchHistory;
+ gestureState.numberActiveTouches = touchHistory.numberActiveTouches;
+
+ if (config.onPanResponderStart) {
+ config.onPanResponderStart(event, gestureState);
+ }
+ },
+ onResponderMove: function onResponderMove(event) {
+ var touchHistory = event.touchHistory;
+
+ if (gestureState._accountsForMovesUpTo === touchHistory.mostRecentTimeStamp) {
+ return;
+ }
+
+ PanResponder._updateGestureStateOnMove(gestureState, touchHistory);
+
+ if (config.onPanResponderMove) {
+ config.onPanResponderMove(event, gestureState);
+ }
+ },
+ onResponderEnd: function onResponderEnd(event) {
+ var touchHistory = event.touchHistory;
+ gestureState.numberActiveTouches = touchHistory.numberActiveTouches;
+ clearInteractionHandle(interactionState, config.onPanResponderEnd, event, gestureState);
+ },
+ onResponderTerminate: function onResponderTerminate(event) {
+ clearInteractionHandle(interactionState, config.onPanResponderTerminate, event, gestureState);
+
+ PanResponder._initializeGestureState(gestureState);
+ },
+ onResponderTerminationRequest: function onResponderTerminationRequest(event) {
+ return config.onPanResponderTerminationRequest == null ? true : config.onPanResponderTerminationRequest(event, gestureState);
+ }
+ };
+ return {
+ panHandlers: panHandlers,
+ getInteractionHandle: function getInteractionHandle() {
+ return interactionState.handle;
+ }
+ };
+ }
+ };
+
+ function clearInteractionHandle(interactionState, callback, event, gestureState) {
+ if (interactionState.handle) {
+ InteractionManager.clearInteractionHandle(interactionState.handle);
+ interactionState.handle = null;
+ }
+
+ if (callback) {
+ callback(event, gestureState);
+ }
+ }
+
+ module.exports = PanResponder;
+},363,[245,364],"node_modules\\react-native\\Libraries\\Interaction\\PanResponder.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var TouchHistoryMath = {
+ centroidDimension: function centroidDimension(touchHistory, touchesChangedAfter, isXAxis, ofCurrent) {
+ var touchBank = touchHistory.touchBank;
+ var total = 0;
+ var count = 0;
+ var oneTouchData = touchHistory.numberActiveTouches === 1 ? touchHistory.touchBank[touchHistory.indexOfSingleActiveTouch] : null;
+
+ if (oneTouchData !== null) {
+ if (oneTouchData.touchActive && oneTouchData.currentTimeStamp > touchesChangedAfter) {
+ total += ofCurrent && isXAxis ? oneTouchData.currentPageX : ofCurrent && !isXAxis ? oneTouchData.currentPageY : !ofCurrent && isXAxis ? oneTouchData.previousPageX : oneTouchData.previousPageY;
+ count = 1;
+ }
+ } else {
+ for (var i = 0; i < touchBank.length; i++) {
+ var touchTrack = touchBank[i];
+
+ if (touchTrack !== null && touchTrack !== undefined && touchTrack.touchActive && touchTrack.currentTimeStamp >= touchesChangedAfter) {
+ var toAdd = void 0;
+
+ if (ofCurrent && isXAxis) {
+ toAdd = touchTrack.currentPageX;
+ } else if (ofCurrent && !isXAxis) {
+ toAdd = touchTrack.currentPageY;
+ } else if (!ofCurrent && isXAxis) {
+ toAdd = touchTrack.previousPageX;
+ } else {
+ toAdd = touchTrack.previousPageY;
+ }
+
+ total += toAdd;
+ count++;
+ }
+ }
+ }
+
+ return count > 0 ? total / count : TouchHistoryMath.noCentroid;
+ },
+ currentCentroidXOfTouchesChangedAfter: function currentCentroidXOfTouchesChangedAfter(touchHistory, touchesChangedAfter) {
+ return TouchHistoryMath.centroidDimension(touchHistory, touchesChangedAfter, true, true);
+ },
+ currentCentroidYOfTouchesChangedAfter: function currentCentroidYOfTouchesChangedAfter(touchHistory, touchesChangedAfter) {
+ return TouchHistoryMath.centroidDimension(touchHistory, touchesChangedAfter, false, true);
+ },
+ previousCentroidXOfTouchesChangedAfter: function previousCentroidXOfTouchesChangedAfter(touchHistory, touchesChangedAfter) {
+ return TouchHistoryMath.centroidDimension(touchHistory, touchesChangedAfter, true, false);
+ },
+ previousCentroidYOfTouchesChangedAfter: function previousCentroidYOfTouchesChangedAfter(touchHistory, touchesChangedAfter) {
+ return TouchHistoryMath.centroidDimension(touchHistory, touchesChangedAfter, false, false);
+ },
+ currentCentroidX: function currentCentroidX(touchHistory) {
+ return TouchHistoryMath.centroidDimension(touchHistory, 0, true, true);
+ },
+ currentCentroidY: function currentCentroidY(touchHistory) {
+ return TouchHistoryMath.centroidDimension(touchHistory, 0, false, true);
+ },
+ noCentroid: -1
+ };
+ module.exports = TouchHistoryMath;
+},364,[],"node_modules\\react-native\\Libraries\\Interaction\\TouchHistoryMath.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/createClass");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\Experimental\\SwipeableRow\\SwipeableListView.js";
+
+ var ListView = _$$_REQUIRE(_dependencyMap[6], "ListView");
+
+ var React = _$$_REQUIRE(_dependencyMap[7], "React");
+
+ var SwipeableListViewDataSource = _$$_REQUIRE(_dependencyMap[8], "SwipeableListViewDataSource");
+
+ var SwipeableRow = _$$_REQUIRE(_dependencyMap[9], "SwipeableRow");
+
+ var SwipeableListView = function (_React$Component) {
+ _inherits(SwipeableListView, _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: 216
+ }
+ }, _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: 124
+ }
+ }));
+ }
+ }, {
+ 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)
+ });
+ }
+ }]);
+
+ return SwipeableListView;
+ }(React.Component);
+
+ SwipeableListView.defaultProps = {
+ bounceFirstRowOnMount: false,
+ renderQuickActions: function renderQuickActions() {
+ return null;
+ }
+ };
+ module.exports = SwipeableListView;
+},365,[14,3,5,8,4,9,306,52,366,362],"node_modules\\react-native\\Libraries\\Experimental\\SwipeableRow\\SwipeableListView.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var ListViewDataSource = _$$_REQUIRE(_dependencyMap[2], "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;
+},366,[3,4,308],"node_modules\\react-native\\Libraries\\Experimental\\SwipeableRow\\SwipeableListViewDataSource.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\Libraries\\Components\\TextInput\\TextInput.uwp.js";
+
+ var EventEmitter = _$$_REQUIRE(_dependencyMap[1], "EventEmitter");
+
+ var NativeMethodsMixin = _$$_REQUIRE(_dependencyMap[2], "NativeMethodsMixin");
+
+ var React = _$$_REQUIRE(_dependencyMap[3], "React");
+
+ var createReactClass = _$$_REQUIRE(_dependencyMap[4], "create-react-class");
+
+ var PropTypes = _$$_REQUIRE(_dependencyMap[5], "prop-types");
+
+ var ReactNative = _$$_REQUIRE(_dependencyMap[6], "ReactNative");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[7], "StyleSheet");
+
+ var TextAncestor = _$$_REQUIRE(_dependencyMap[8], "TextAncestor");
+
+ var TextInputState = _$$_REQUIRE(_dependencyMap[9], "TextInputState");
+
+ var TimerMixin = _$$_REQUIRE(_dependencyMap[10], "react-timer-mixin");
+
+ var requireNativeComponent = _$$_REQUIRE(_dependencyMap[11], "requireNativeComponent");
+
+ var RCTTextInput = requireNativeComponent('RCTTextInput');
+ var TextInput = createReactClass({
+ displayName: 'TextInput',
+ statics: {
+ State: {
+ currentlyFocusedField: TextInputState.currentlyFocusedField,
+ focusTextInput: TextInputState.focusTextInput,
+ blurTextInput: TextInputState.blurTextInput
+ }
+ },
+ getDefaultProps: function getDefaultProps() {
+ return {
+ allowFontScaling: true
+ };
+ },
+ mixins: [NativeMethodsMixin, TimerMixin],
+ isFocused: function isFocused() {
+ return TextInputState.currentlyFocusedField() === ReactNative.findNodeHandle(this._inputRef);
+ },
+ getTextViewHandle: function getTextViewHandle() {
+ return ReactNative.findNodeHandle(this._inputRef);
+ },
+ _inputRef: undefined,
+ _focusSubscription: undefined,
+ _lastNativeText: undefined,
+ _lastNativeSelection: undefined,
+ _rafId: null,
+ 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._rafId = requestAnimationFrame(_this.focus);
+ } else if (_this.isFocused()) {
+ _this.blur();
+ }
+ });
+
+ if (this.props.autoFocus) {
+ this.context.onFocusRequested(this);
+ }
+ } else {
+ if (this.props.autoFocus) {
+ this._rafId = requestAnimationFrame(this.focus);
+ }
+ }
+ },
+ componentWillUnmount: function componentWillUnmount() {
+ this._focusSubscription && this._focusSubscription.remove();
+
+ if (this.isFocused()) {
+ this.blur();
+ }
+
+ if (this._rafId != null) {
+ cancelAnimationFrame(this._rafId);
+ }
+ },
+ contextTypes: {
+ onFocusRequested: PropTypes.func,
+ focusEmitter: PropTypes.instanceOf(EventEmitter)
+ },
+ clear: function clear() {
+ this.setNativeProps({
+ text: ''
+ });
+ },
+ render: function render() {
+ var props = _extends({}, this.props);
+
+ props.style = [styles.input, this.props.style];
+ return React.createElement(TextAncestor.Provider, {
+ value: true,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 310
+ }
+ }, React.createElement(RCTTextInput, _extends({
+ ref: this._setNativeRef
+ }, props, {
+ mostRecentEventCount: 0,
+ onChange: this._onChange,
+ onBlur: this._onBlur,
+ onFocus: this._onFocus,
+ onSelectionChange: this._onSelectionChange,
+ text: this._getText(),
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 311
+ }
+ })));
+ },
+ _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;
+ },
+ _onFocus: function _onFocus(event) {
+ TextInputState.setFocusedTextInput(ReactNative.findNodeHandle(this._inputRef));
+
+ if (this.props.onFocus) {
+ this.props.onFocus(event);
+ }
+ },
+ _onPress: function _onPress(event) {
+ if (this.props.editable || this.props.editable === undefined) {
+ this.focus();
+ }
+ },
+ _onChange: function _onChange(event) {
+ if (this._inputRef && this._inputRef.setNativeProps) {
+ 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.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) {
+ this._inputRef.setNativeProps(nativeProps);
+ }
+ },
+ _onBlur: function _onBlur(event) {
+ TextInputState.clearFocusedTextInput(ReactNative.findNodeHandle(this._inputRef));
+
+ if (this.props.onBlur) {
+ this.props.onBlur(event);
+ }
+ },
+ _onTextInput: function _onTextInput(event) {
+ this.props.onTextInput && this.props.onTextInput(event);
+ },
+ _onScroll: function _onScroll(event) {
+ this.props.onScroll && this.props.onScroll(event);
+ }
+ });
+ var styles = StyleSheet.create({
+ multilineInput: {
+ paddingTop: 5
+ }
+ });
+ module.exports = TextInput;
+},367,[14,27,225,52,227,62,84,53,82,176,368,184],"Libraries\\Components\\TextInput\\TextInput.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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;
+},368,[],"node_modules\\react-timer-mixin\\TimerMixin.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "UnimplementedView");
+},369,[196],"Libraries\\Components\\ToolbarAndroid\\ToolbarAndroid.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "UnimplementedView");
+},370,[196],"Libraries\\Components\\ViewPager\\ViewPagerAndroid.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\Libraries\\Components\\WebView\\WebView.uwp.js";
+
+ var React = _$$_REQUIRE(_dependencyMap[0], "React");
+
+ var ReactNative = _$$_REQUIRE(_dependencyMap[1], "ReactNative");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[2], "StyleSheet");
+
+ var UIManager = _$$_REQUIRE(_dependencyMap[3], "UIManager");
+
+ var View = _$$_REQUIRE(_dependencyMap[4], "View");
+
+ var keyMirror = _$$_REQUIRE(_dependencyMap[5], "fbjs/lib/keyMirror");
+
+ var requireNativeComponent = _$$_REQUIRE(_dependencyMap[6], "requireNativeComponent");
+
+ var resolveAssetSource = _$$_REQUIRE(_dependencyMap[7], "resolveAssetSource");
+
+ var createReactClass = _$$_REQUIRE(_dependencyMap[8], "create-react-class");
+
+ var RCT_WEBVIEW_REF = 'webview';
+ var WebViewState = keyMirror({
+ IDLE: null,
+ LOADING: null,
+ ERROR: null
+ });
+ var WebView = createReactClass({
+ displayName: "WebView",
+ getInitialState: function getInitialState() {
+ return {
+ viewState: WebViewState.IDLE,
+ lastErrorEvent: null,
+ startInLoadingState: true
+ };
+ },
+ getDefaultProps: function getDefaultProps() {
+ return {
+ javaScriptEnabled: true
+ };
+ },
+ componentWillMount: function componentWillMount() {
+ if (this.props.startInLoadingState) {
+ this.setState({
+ viewState: WebViewState.LOADING
+ });
+ }
+ },
+ render: function render() {
+ var otherView = null;
+
+ if (this.state.viewState === WebViewState.LOADING) {
+ otherView = this.props.renderLoading && this.props.renderLoading();
+ } else if (this.state.viewState === WebViewState.ERROR) {
+ var errorEvent = this.state.lastErrorEvent;
+ otherView = this.props.renderError && this.props.renderError(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, this.props.style];
+
+ if (this.state.viewState === WebViewState.LOADING || this.state.viewState === WebViewState.ERROR) {
+ webViewStyles.push(styles.hidden);
+ }
+
+ 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 webView = React.createElement(RCTWebView, {
+ ref: RCT_WEBVIEW_REF,
+ key: "webViewKey",
+ style: webViewStyles,
+ source: resolveAssetSource(source),
+ injectedJavaScript: this.props.injectedJavaScript,
+ javaScriptEnabled: this.props.javaScriptEnabled,
+ indexedDbEnabled: this.props.indexedDbEnabled,
+ contentInset: this.props.contentInset,
+ automaticallyAdjustContentInsets: this.props.automaticallyAdjustContentInsets,
+ onLoadingStart: this.onLoadingStart,
+ onLoadingFinish: this.onLoadingFinish,
+ onLoadingError: this.onLoadingError,
+ testID: this.props.testID,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 98
+ }
+ });
+ return React.createElement(View, {
+ style: styles.container,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 118
+ }
+ }, webView, otherView);
+ },
+ goForward: function goForward() {
+ UIManager.dispatchViewManagerCommand(this.getWebViewHandle(), UIManager.RCTWebView.Commands.goForward, null);
+ },
+ goBack: function goBack() {
+ UIManager.dispatchViewManagerCommand(this.getWebViewHandle(), UIManager.RCTWebView.Commands.goBack, null);
+ },
+ reload: function reload() {
+ UIManager.dispatchViewManagerCommand(this.getWebViewHandle(), UIManager.RCTWebView.Commands.reload, null);
+ },
+ updateNavigationState: function updateNavigationState(event) {
+ if (this.props.onNavigationStateChange) {
+ this.props.onNavigationStateChange(event.nativeEvent);
+ }
+ },
+ getWebViewHandle: function getWebViewHandle() {
+ return ReactNative.findNodeHandle(this.refs[RCT_WEBVIEW_REF]);
+ },
+ onLoadingStart: function onLoadingStart(event) {
+ var onLoadStart = this.props.onLoadStart;
+ onLoadStart && onLoadStart(event);
+ this.updateNavigationState(event);
+ },
+ onLoadingError: function onLoadingError(event) {
+ event.persist();
+ var _this$props = this.props,
+ onError = _this$props.onError,
+ onLoadEnd = _this$props.onLoadEnd;
+ onError && onError(event);
+ onLoadEnd && onLoadEnd(event);
+ console.error('Encountered an error loading page', event.nativeEvent);
+ this.setState({
+ lastErrorEvent: event.nativeEvent,
+ viewState: WebViewState.ERROR
+ });
+ },
+ onLoadingFinish: function onLoadingFinish(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);
+ }
+ });
+ var RCTWebView = requireNativeComponent('RCTWebView', WebView);
+ var styles = StyleSheet.create({
+ container: {
+ flex: 1
+ },
+ hidden: {
+ height: 0,
+ flex: 0
+ },
+ loadingView: {
+ flex: 1,
+ justifyContent: 'center',
+ alignItems: 'center'
+ },
+ loadingProgressBar: {
+ height: 20
+ }
+ });
+ module.exports = WebView;
+},371,[52,84,53,71,81,218,184,190,227],"Libraries\\Components\\WebView\\WebView.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var RCTActionSheetManager = _$$_REQUIRE(_dependencyMap[1], "NativeModules").ActionSheetManager;
+
+ var invariant = _$$_REQUIRE(_dependencyMap[2], "invariant");
+
+ var processColor = _$$_REQUIRE(_dependencyMap[3], "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;
+},372,[32,36,19,75],"node_modules\\react-native\\Libraries\\ActionSheetIOS\\ActionSheetIOS.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var BatchedBridge = _$$_REQUIRE(_dependencyMap[1], "BatchedBridge");
+
+ var BugReporting = _$$_REQUIRE(_dependencyMap[2], "BugReporting");
+
+ var NativeModules = _$$_REQUIRE(_dependencyMap[3], "NativeModules");
+
+ var ReactNative = _$$_REQUIRE(_dependencyMap[4], "ReactNative");
+
+ var SceneTracker = _$$_REQUIRE(_dependencyMap[5], "SceneTracker");
+
+ var infoLog = _$$_REQUIRE(_dependencyMap[6], "infoLog");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[7], "invariant");
+
+ var renderApplication = _$$_REQUIRE(_dependencyMap[8], "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;
+},373,[32,41,374,36,84,376,157,19,377],"node_modules\\react-native\\Libraries\\ReactNative\\AppRegistry.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _slicedToArray = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/slicedToArray");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ var RCTDeviceEventEmitter = _$$_REQUIRE(_dependencyMap[3], "RCTDeviceEventEmitter");
+
+ var infoLog = _$$_REQUIRE(_dependencyMap[4], "infoLog");
+
+ function defaultExtras() {
+ BugReporting.addFileSource('react_hierarchy.txt', function () {
+ return _$$_REQUIRE(_dependencyMap[5], "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), _i = 0, _iterator = _isArray ? _iterator : _iterator[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();;) {
+ var _ref3;
+
+ if (_isArray) {
+ if (_i >= _iterator.length) break;
+ _ref3 = _iterator[_i++];
+ } else {
+ _i = _iterator.next();
+ if (_i.done) break;
+ _ref3 = _i.value;
+ }
+
+ var _ref7 = _ref3;
+
+ var _ref2 = _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), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();;) {
+ var _ref6;
+
+ if (_isArray2) {
+ if (_i2 >= _iterator2.length) break;
+ _ref6 = _iterator2[_i2++];
+ } else {
+ _i2 = _iterator2.next();
+ if (_i2.done) break;
+ _ref6 = _i2.value;
+ }
+
+ var _ref8 = _ref6;
+
+ var _ref5 = _slicedToArray(_ref8, 2);
+
+ var _key4 = _ref5[0];
+ var _callback3 = _ref5[1];
+ fileData[_key4] = _callback3();
+ }
+
+ infoLog('BugReporting extraData:', extraData);
+
+ var BugReportingNativeModule = _$$_REQUIRE(_dependencyMap[6], "NativeModules").BugReporting;
+
+ BugReportingNativeModule && BugReportingNativeModule.setExtraData && BugReportingNativeModule.setExtraData(extraData, fileData);
+
+ var RedBoxNativeModule = _$$_REQUIRE(_dependencyMap[6], "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;
+},374,[37,3,4,24,157,375,36],"node_modules\\react-native\\Libraries\\BugReporting\\BugReporting.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ function dumpReactTree() {
+ try {
+ return getReactTree();
+ } catch (e) {
+ return 'Failed to dump react tree: ' + e;
+ }
+ }
+
+ function getReactTree() {
+ return 'React tree dumps have been temporarily disabled while React is ' + 'upgraded to Fiber.';
+ }
+
+ module.exports = dumpReactTree;
+},375,[],"node_modules\\react-native\\Libraries\\BugReporting\\dumpReactTree.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _listeners = [];
+ var _activeScene = {
+ name: 'default'
+ };
+ var SceneTracker = {
+ setActiveScene: function setActiveScene(scene) {
+ _activeScene = scene;
+
+ _listeners.forEach(function (listener) {
+ return listener(_activeScene);
+ });
+ },
+ getActiveScene: function getActiveScene() {
+ return _activeScene;
+ },
+ addActiveSceneChangedListener: function addActiveSceneChangedListener(callback) {
+ _listeners.push(callback);
+
+ return {
+ remove: function remove() {
+ _listeners = _listeners.filter(function (listener) {
+ return callback !== listener;
+ });
+ }
+ };
+ }
+ };
+ module.exports = SceneTracker;
+},376,[],"node_modules\\react-native\\Libraries\\Utilities\\SceneTracker.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+
+ var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/extends"));
+
+ var _PerformanceLogger = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "PerformanceLogger"));
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\ReactNative\\renderApplication.js";
+
+ var AppContainer = _$$_REQUIRE(_dependencyMap[3], "AppContainer");
+
+ var React = _$$_REQUIRE(_dependencyMap[4], "React");
+
+ var ReactFabricIndicator = _$$_REQUIRE(_dependencyMap[5], "ReactFabricIndicator");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[6], "invariant");
+
+ _$$_REQUIRE(_dependencyMap[7], "BackHandler");
+
+ function renderApplication(RootComponent, initialProps, rootTag, WrapperComponent, fabric, showFabricIndicator) {
+ invariant(rootTag, 'Expect to have a valid rootTag, instead got ', rootTag);
+ var renderable = React.createElement(AppContainer, {
+ rootTag: rootTag,
+ WrapperComponent: WrapperComponent,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 34
+ }
+ }, React.createElement(RootComponent, (0, _extends2.default)({}, initialProps, {
+ rootTag: rootTag,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 35
+ }
+ })), fabric === true && showFabricIndicator === true ? React.createElement(ReactFabricIndicator, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 37
+ }
+ }) : null);
+
+ if (RootComponent.prototype != null && RootComponent.prototype.unstable_isAsyncReactComponent === true) {
+ var ConcurrentMode = React.unstable_ConcurrentMode;
+ renderable = React.createElement(ConcurrentMode, {
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 54
+ }
+ }, renderable);
+ }
+
+ _PerformanceLogger.default.startTimespan('renderApplication_React_render');
+
+ if (fabric) {
+ _$$_REQUIRE(_dependencyMap[8], "ReactFabric").render(renderable, rootTag);
+ } else {
+ _$$_REQUIRE(_dependencyMap[9], "ReactNative").render(renderable, rootTag);
+ }
+
+ _PerformanceLogger.default.stopTimespan('renderApplication_React_render');
+ }
+
+ module.exports = renderApplication;
+},377,[1,14,156,314,52,378,19,379,380,84],"node_modules\\react-native\\Libraries\\ReactNative\\renderApplication.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\node_modules\\react-native\\Libraries\\ReactNative\\ReactFabricIndicator.js";
+
+ var React = _$$_REQUIRE(_dependencyMap[0], "React");
+
+ var StyleSheet = _$$_REQUIRE(_dependencyMap[1], "StyleSheet");
+
+ var Text = _$$_REQUIRE(_dependencyMap[2], "Text");
+
+ var View = _$$_REQUIRE(_dependencyMap[3], "View");
+
+ function ReactFabricIndicator() {
+ return React.createElement(View, {
+ style: styles.container,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 20
+ }
+ }, React.createElement(Text, {
+ style: styles.text,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 21
+ }
+ }, "FABRIC"));
+ }
+
+ var styles = StyleSheet.create({
+ container: {
+ alignItems: 'center',
+ justifyContent: 'center',
+ backgroundColor: 'rgba(0,0,0, 0.25)',
+ position: 'absolute',
+ top: 0,
+ right: 0,
+ padding: 2
+ },
+ text: {
+ fontSize: 6,
+ color: '#ffffff'
+ }
+ });
+ module.exports = ReactFabricIndicator;
+},378,[52,53,208,81],"node_modules\\react-native\\Libraries\\ReactNative\\ReactFabricIndicator.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ function emptyFunction() {}
+
+ var BackHandler = {
+ exitApp: emptyFunction,
+ addEventListener: function addEventListener() {
+ return {
+ remove: emptyFunction
+ };
+ },
+ removeEventListener: emptyFunction
+ };
+ module.exports = BackHandler;
+},379,[],"Libraries\\Utilities\\BackHandler.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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;
+},380,[41,381,383],"node_modules\\react-native\\Libraries\\Renderer\\shims\\ReactFabric.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ if (__DEV__) {
+ (function () {
+ "use strict";
+
+ _$$_REQUIRE(_dependencyMap[1], "InitializeCore");
+
+ var ReactNativeViewConfigRegistry = _$$_REQUIRE(_dependencyMap[2], "ReactNativeViewConfigRegistry");
+
+ var UIManager = _$$_REQUIRE(_dependencyMap[3], "UIManager");
+
+ var React = _$$_REQUIRE(_dependencyMap[4], "react");
+
+ var deepDiffer = _$$_REQUIRE(_dependencyMap[5], "deepDiffer");
+
+ var flattenStyle = _$$_REQUIRE(_dependencyMap[6], "flattenStyle");
+
+ var deepFreezeAndThrowOnMutationInDev = _$$_REQUIRE(_dependencyMap[7], "deepFreezeAndThrowOnMutationInDev");
+
+ var TextInputState = _$$_REQUIRE(_dependencyMap[8], "TextInputState");
+
+ var FabricUIManager = _$$_REQUIRE(_dependencyMap[9], "FabricUIManager");
+
+ var checkPropTypes = _$$_REQUIRE(_dependencyMap[10], "prop-types/checkPropTypes");
+
+ var tracing = _$$_REQUIRE(_dependencyMap[11], "scheduler/tracing");
+
+ var scheduler = _$$_REQUIRE(_dependencyMap[12], "scheduler");
+
+ var ExceptionsManager = _$$_REQUIRE(_dependencyMap[13], "ExceptionsManager");
+
+ var validateFormat = function validateFormat() {};
+
+ {
+ 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 = void 0;
+
+ 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;
+ }
+ }
+
+ var invokeGuardedCallbackImpl = function invokeGuardedCallbackImpl(name, func, context, a, b, c, d, e, f) {
+ var funcArgs = Array.prototype.slice.call(arguments, 3);
+
+ try {
+ func.apply(context, funcArgs);
+ } catch (error) {
+ this.onError(error);
+ }
+ };
+
+ {
+ if (typeof window !== "undefined" && typeof window.dispatchEvent === "function" && typeof document !== "undefined" && typeof document.createEvent === "function") {
+ var fakeNode = document.createElement("react");
+
+ var invokeGuardedCallbackDev = function invokeGuardedCallbackDev(name, func, context, a, b, c, d, e, f) {
+ 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 windowEvent = window.event;
+ var windowEventDescriptor = Object.getOwnPropertyDescriptor(window, "event");
+ var funcArgs = Array.prototype.slice.call(arguments, 3);
+
+ function callCallback() {
+ fakeNode.removeEventListener(evtType, callCallback, false);
+
+ if (typeof window.event !== "undefined" && window.hasOwnProperty("event")) {
+ window.event = windowEvent;
+ }
+
+ func.apply(context, funcArgs);
+ didError = false;
+ }
+
+ var error = void 0;
+ var didSetError = false;
+ var isCrossOriginError = false;
+
+ function handleWindowError(event) {
+ error = event.error;
+ didSetError = true;
+
+ if (error === null && event.colno === 0 && event.lineno === 0) {
+ isCrossOriginError = true;
+ }
+
+ if (event.defaultPrevented) {
+ if (error != null && typeof error === "object") {
+ try {
+ error._suppressLogging = true;
+ } catch (inner) {}
+ }
+ }
+ }
+
+ var evtType = "react-" + (name ? name : "invokeguardedcallback");
+ window.addEventListener("error", handleWindowError);
+ fakeNode.addEventListener(evtType, callCallback, false);
+ evt.initEvent(evtType, false, false);
+ fakeNode.dispatchEvent(evt);
+
+ if (windowEventDescriptor) {
+ Object.defineProperty(window, "event", windowEventDescriptor);
+ }
+
+ if (didError) {
+ if (!didSetError) {
+ error = new Error("An error was thrown inside one of your components, but React " + "doesn't know what it was. This is likely due to browser " + 'flakiness. React does its best to preserve the "Pause on ' + 'exceptions" behavior of the DevTools, which requires some ' + "DEV-mode only tricks. It's possible that these don't work in " + "your browser. Try triggering the error in production mode, " + "or switching to a modern browser. If you suspect that this is " + "actually an issue with React, please file an issue.");
+ } else if (isCrossOriginError) {
+ error = new Error("A cross-origin error was thrown. React doesn't have access to " + "the actual error object in development. " + "See https://fb.me/react-crossorigin-error for more information.");
+ }
+
+ this.onError(error);
+ }
+
+ window.removeEventListener("error", handleWindowError);
+ };
+
+ invokeGuardedCallbackImpl = invokeGuardedCallbackDev;
+ }
+ }
+ var invokeGuardedCallbackImpl$1 = invokeGuardedCallbackImpl;
+ var hasError = false;
+ var caughtError = null;
+ var hasRethrowError = false;
+ var rethrowError = null;
+ var reporter = {
+ onError: function onError(error) {
+ hasError = true;
+ caughtError = error;
+ }
+ };
+
+ function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
+ hasError = false;
+ caughtError = null;
+ invokeGuardedCallbackImpl$1.apply(reporter, arguments);
+ }
+
+ function invokeGuardedCallbackAndCatchFirstError(name, func, context, a, b, c, d, e, f) {
+ invokeGuardedCallback.apply(this, arguments);
+
+ if (hasError) {
+ var error = clearCaughtError();
+
+ if (!hasRethrowError) {
+ hasRethrowError = true;
+ rethrowError = error;
+ }
+ }
+ }
+
+ function rethrowCaughtError() {
+ if (hasRethrowError) {
+ var error = rethrowError;
+ hasRethrowError = false;
+ rethrowError = null;
+ throw error;
+ }
+ }
+
+ function hasCaughtError() {
+ return hasError;
+ }
+
+ function clearCaughtError() {
+ if (hasError) {
+ var error = caughtError;
+ hasError = false;
+ caughtError = null;
+ return error;
+ } else {
+ 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 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 warningWithoutStack = function warningWithoutStack() {};
+
+ {
+ warningWithoutStack = function warningWithoutStack(condition, format) {
+ for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+ args[_key - 2] = arguments[_key];
+ }
+
+ if (format === undefined) {
+ throw new Error("`warningWithoutStack(condition, format, ...args)` requires a warning " + "message argument");
+ }
+
+ if (args.length > 8) {
+ throw new Error("warningWithoutStack() currently supports at most 8 arguments.");
+ }
+
+ if (condition) {
+ return;
+ }
+
+ if (typeof console !== "undefined") {
+ var argsWithFormat = args.map(function (item) {
+ return "" + item;
+ });
+ argsWithFormat.unshift("Warning: " + format);
+ Function.prototype.apply.call(console.error, console, argsWithFormat);
+ }
+
+ try {
+ var argIndex = 0;
+ var message = "Warning: " + format.replace(/%s/g, function () {
+ return args[argIndex++];
+ });
+ throw new Error(message);
+ } catch (x) {}
+ };
+ }
+ var warningWithoutStack$1 = warningWithoutStack;
+ var getFiberCurrentPropsFromNode = null;
+ var getInstanceFromNode = null;
+ var getNodeFromInstance = null;
+
+ function setComponentTree(getFiberCurrentPropsFromNodeImpl, getInstanceFromNodeImpl, getNodeFromInstanceImpl) {
+ getFiberCurrentPropsFromNode = getFiberCurrentPropsFromNodeImpl;
+ getInstanceFromNode = getInstanceFromNodeImpl;
+ getNodeFromInstance = getNodeFromInstanceImpl;
+ {
+ !(getNodeFromInstance && getInstanceFromNode) ? warningWithoutStack$1(false, "EventPluginUtils.setComponentTree(...): Injected " + "module is missing getNodeFromInstance or getInstanceFromNode.") : void 0;
+ }
+ }
+
+ var validateEventDispatches = void 0;
+ {
+ validateEventDispatches = function validateEventDispatches(event) {
+ var dispatchListeners = event._dispatchListeners;
+ var dispatchInstances = event._dispatchInstances;
+ var listenersIsArr = Array.isArray(dispatchListeners);
+ var listenersLen = listenersIsArr ? dispatchListeners.length : dispatchListeners ? 1 : 0;
+ var instancesIsArr = Array.isArray(dispatchInstances);
+ var instancesLen = instancesIsArr ? dispatchInstances.length : dispatchInstances ? 1 : 0;
+ !(instancesIsArr === listenersIsArr && instancesLen === listenersLen) ? warningWithoutStack$1(false, "EventPluginUtils: Invalid `event`.") : void 0;
+ };
+ }
+
+ function executeDispatch(event, listener, inst) {
+ var type = event.type || "unknown-event";
+ event.currentTarget = getNodeFromInstance(inst);
+ invokeGuardedCallbackAndCatchFirstError(type, listener, undefined, event);
+ event.currentTarget = null;
+ }
+
+ function executeDispatchesInOrder(event) {
+ var dispatchListeners = event._dispatchListeners;
+ var dispatchInstances = event._dispatchInstances;
+ {
+ validateEventDispatches(event);
+ }
+
+ if (Array.isArray(dispatchListeners)) {
+ for (var i = 0; i < dispatchListeners.length; i++) {
+ if (event.isPropagationStopped()) {
+ break;
+ }
+
+ executeDispatch(event, dispatchListeners[i], dispatchInstances[i]);
+ }
+ } else if (dispatchListeners) {
+ executeDispatch(event, dispatchListeners, dispatchInstances);
+ }
+
+ event._dispatchListeners = null;
+ event._dispatchInstances = null;
+ }
+
+ function executeDispatchesInOrderStopAtTrueImpl(event) {
+ var dispatchListeners = event._dispatchListeners;
+ var dispatchInstances = event._dispatchInstances;
+ {
+ validateEventDispatches(event);
+ }
+
+ if (Array.isArray(dispatchListeners)) {
+ for (var i = 0; i < dispatchListeners.length; i++) {
+ if (event.isPropagationStopped()) {
+ break;
+ }
+
+ if (dispatchListeners[i](event, dispatchInstances[i])) {
+ return dispatchInstances[i];
+ }
+ }
+ } else if (dispatchListeners) {
+ if (dispatchListeners(event, dispatchInstances)) {
+ return dispatchInstances;
+ }
+ }
+
+ return null;
+ }
+
+ function executeDispatchesInOrderStopAtTrue(event) {
+ var ret = executeDispatchesInOrderStopAtTrueImpl(event);
+ event._dispatchInstances = null;
+ event._dispatchListeners = null;
+ return ret;
+ }
+
+ function executeDirectDispatch(event) {
+ {
+ validateEventDispatches(event);
+ }
+ var dispatchListener = event._dispatchListeners;
+ var dispatchInstance = event._dispatchInstances;
+ 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) {
+ if (event) {
+ executeDispatchesInOrder(event);
+
+ if (!event.isPersistent()) {
+ event.constructor.release(event);
+ }
+ }
+ };
+
+ var executeDispatchesAndReleaseTopLevel = function executeDispatchesAndReleaseTopLevel(e) {
+ return executeDispatchesAndRelease(e);
+ };
+
+ 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) {
+ if (events !== null) {
+ eventQueue = accumulateInto(eventQueue, events);
+ }
+
+ var processingEventQueue = eventQueue;
+ eventQueue = null;
+
+ if (!processingEventQueue) {
+ return;
+ }
+
+ forEachAccumulated(processingEventQueue, executeDispatchesAndReleaseTopLevel);
+ invariant(!eventQueue, "processEventQueue(): Additional events were enqueued while processing " + "an event queue. Support for this has not yet been implemented.");
+ rethrowCaughtError();
+ }
+
+ function runExtractedEventsInBatch(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+ var events = extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget);
+ runEventsInBatch(events);
+ }
+
+ var FunctionComponent = 0;
+ var ClassComponent = 1;
+ var IndeterminateComponent = 2;
+ var HostRoot = 3;
+ var HostPortal = 4;
+ var HostComponent = 5;
+ var HostText = 6;
+ var Fragment = 7;
+ var Mode = 8;
+ var ContextConsumer = 9;
+ var ContextProvider = 10;
+ var ForwardRef = 11;
+ var Profiler = 12;
+ var SuspenseComponent = 13;
+ var MemoComponent = 14;
+ var SimpleMemoComponent = 15;
+ var LazyComponent = 16;
+ var IncompleteClassComponent = 17;
+ var DehydratedSuspenseComponent = 18;
+
+ function getParent(inst) {
+ do {
+ inst = inst.return;
+ } while (inst && inst.tag !== HostComponent);
+
+ if (inst) {
+ return inst;
+ }
+
+ return null;
+ }
+
+ function getLowestCommonAncestor(instA, instB) {
+ var depthA = 0;
+
+ for (var tempA = instA; tempA; tempA = getParent(tempA)) {
+ depthA++;
+ }
+
+ var depthB = 0;
+
+ for (var tempB = instB; tempB; tempB = getParent(tempB)) {
+ depthB++;
+ }
+
+ while (depthA - depthB > 0) {
+ instA = getParent(instA);
+ depthA--;
+ }
+
+ while (depthB - depthA > 0) {
+ instB = getParent(instB);
+ depthB--;
+ }
+
+ var depth = depthA;
+
+ while (depth--) {
+ if (instA === instB || instA === instB.alternate) {
+ return instA;
+ }
+
+ instA = getParent(instA);
+ instB = getParent(instB);
+ }
+
+ return null;
+ }
+
+ function isAncestor(instA, instB) {
+ while (instB) {
+ if (instA === instB || instA === instB.alternate) {
+ return true;
+ }
+
+ instB = getParent(instB);
+ }
+
+ return false;
+ }
+
+ function getParentInstance(inst) {
+ return getParent(inst);
+ }
+
+ function traverseTwoPhase(inst, fn, arg) {
+ var path = [];
+
+ while (inst) {
+ path.push(inst);
+ inst = getParent(inst);
+ }
+
+ var i = void 0;
+
+ for (i = path.length; i-- > 0;) {
+ fn(path[i], "captured", arg);
+ }
+
+ for (i = 0; i < path.length; i++) {
+ fn(path[i], "bubbled", arg);
+ }
+ }
+
+ function listenerAtPhase(inst, event, propagationPhase) {
+ var registrationName = event.dispatchConfig.phasedRegistrationNames[propagationPhase];
+ return getListener(inst, registrationName);
+ }
+
+ function accumulateDirectionalDispatches(inst, phase, event) {
+ {
+ !inst ? warningWithoutStack$1(false, "Dispatching inst must not be null") : void 0;
+ }
+ var listener = listenerAtPhase(inst, event, phase);
+
+ if (listener) {
+ event._dispatchListeners = accumulateInto(event._dispatchListeners, listener);
+ event._dispatchInstances = accumulateInto(event._dispatchInstances, inst);
+ }
+ }
+
+ function accumulateTwoPhaseDispatchesSingle(event) {
+ if (event && event.dispatchConfig.phasedRegistrationNames) {
+ traverseTwoPhase(event._targetInst, accumulateDirectionalDispatches, event);
+ }
+ }
+
+ function accumulateTwoPhaseDispatchesSingleSkipTarget(event) {
+ if (event && event.dispatchConfig.phasedRegistrationNames) {
+ var targetInst = event._targetInst;
+ var parentInst = targetInst ? getParentInstance(targetInst) : null;
+ traverseTwoPhase(parentInst, accumulateDirectionalDispatches, event);
+ }
+ }
+
+ function accumulateDispatches(inst, ignoredDirection, event) {
+ if (inst && event && event.dispatchConfig.registrationName) {
+ var registrationName = event.dispatchConfig.registrationName;
+ var listener = getListener(inst, registrationName);
+
+ if (listener) {
+ event._dispatchListeners = accumulateInto(event._dispatchListeners, listener);
+ event._dispatchInstances = accumulateInto(event._dispatchInstances, inst);
+ }
+ }
+ }
+
+ function accumulateDirectDispatchesSingle(event) {
+ if (event && event.dispatchConfig.registrationName) {
+ accumulateDispatches(event._targetInst, null, event);
+ }
+ }
+
+ function accumulateTwoPhaseDispatches(events) {
+ forEachAccumulated(events, accumulateTwoPhaseDispatchesSingle);
+ }
+
+ function accumulateTwoPhaseDispatchesSkipTarget(events) {
+ forEachAccumulated(events, accumulateTwoPhaseDispatchesSingleSkipTarget);
+ }
+
+ function accumulateDirectDispatches(events) {
+ forEachAccumulated(events, accumulateDirectDispatchesSingle);
+ }
+
+ var EVENT_POOL_SIZE = 10;
+ var EventInterface = {
+ type: null,
+ target: null,
+ currentTarget: function currentTarget() {
+ return null;
+ },
+ eventPhase: null,
+ bubbles: null,
+ cancelable: null,
+ timeStamp: function timeStamp(event) {
+ return event.timeStamp || Date.now();
+ },
+ defaultPrevented: null,
+ isTrusted: null
+ };
+
+ function functionThatReturnsTrue() {
+ return true;
+ }
+
+ function functionThatReturnsFalse() {
+ return false;
+ }
+
+ function SyntheticEvent(dispatchConfig, targetInst, nativeEvent, nativeEventTarget) {
+ {
+ delete this.nativeEvent;
+ delete this.preventDefault;
+ delete this.stopPropagation;
+ delete this.isDefaultPrevented;
+ delete this.isPropagationStopped;
+ }
+ this.dispatchConfig = dispatchConfig;
+ this._targetInst = targetInst;
+ this.nativeEvent = nativeEvent;
+ var Interface = this.constructor.Interface;
+
+ for (var propName in Interface) {
+ if (!Interface.hasOwnProperty(propName)) {
+ continue;
+ }
+
+ {
+ delete this[propName];
+ }
+ var normalize = Interface[propName];
+
+ if (normalize) {
+ this[propName] = normalize(nativeEvent);
+ } else {
+ if (propName === "target") {
+ this.target = nativeEventTarget;
+ } else {
+ this[propName] = nativeEvent[propName];
+ }
+ }
+ }
+
+ var defaultPrevented = nativeEvent.defaultPrevented != null ? nativeEvent.defaultPrevented : nativeEvent.returnValue === false;
+
+ if (defaultPrevented) {
+ this.isDefaultPrevented = functionThatReturnsTrue;
+ } else {
+ this.isDefaultPrevented = functionThatReturnsFalse;
+ }
+
+ this.isPropagationStopped = functionThatReturnsFalse;
+ return this;
+ }
+
+ _extends(SyntheticEvent.prototype, {
+ preventDefault: function preventDefault() {
+ this.defaultPrevented = true;
+ var event = this.nativeEvent;
+
+ if (!event) {
+ return;
+ }
+
+ if (event.preventDefault) {
+ event.preventDefault();
+ } else if (typeof event.returnValue !== "unknown") {
+ event.returnValue = false;
+ }
+
+ this.isDefaultPrevented = functionThatReturnsTrue;
+ },
+ stopPropagation: function stopPropagation() {
+ var event = this.nativeEvent;
+
+ if (!event) {
+ return;
+ }
+
+ if (event.stopPropagation) {
+ event.stopPropagation();
+ } else if (typeof event.cancelBubble !== "unknown") {
+ event.cancelBubble = true;
+ }
+
+ this.isPropagationStopped = functionThatReturnsTrue;
+ },
+ persist: function persist() {
+ this.isPersistent = functionThatReturnsTrue;
+ },
+ isPersistent: functionThatReturnsFalse,
+ destructor: function destructor() {
+ var Interface = this.constructor.Interface;
+
+ for (var propName in Interface) {
+ {
+ Object.defineProperty(this, propName, getPooledWarningPropertyDefinition(propName, Interface[propName]));
+ }
+ }
+
+ this.dispatchConfig = null;
+ this._targetInst = null;
+ this.nativeEvent = null;
+ this.isDefaultPrevented = functionThatReturnsFalse;
+ this.isPropagationStopped = functionThatReturnsFalse;
+ this._dispatchListeners = null;
+ this._dispatchInstances = null;
+ {
+ Object.defineProperty(this, "nativeEvent", getPooledWarningPropertyDefinition("nativeEvent", null));
+ Object.defineProperty(this, "isDefaultPrevented", getPooledWarningPropertyDefinition("isDefaultPrevented", functionThatReturnsFalse));
+ Object.defineProperty(this, "isPropagationStopped", getPooledWarningPropertyDefinition("isPropagationStopped", functionThatReturnsFalse));
+ Object.defineProperty(this, "preventDefault", getPooledWarningPropertyDefinition("preventDefault", function () {}));
+ Object.defineProperty(this, "stopPropagation", getPooledWarningPropertyDefinition("stopPropagation", function () {}));
+ }
+ }
+ });
+
+ SyntheticEvent.Interface = EventInterface;
+
+ SyntheticEvent.extend = function (Interface) {
+ var Super = this;
+
+ var E = function E() {};
+
+ E.prototype = Super.prototype;
+ var prototype = new E();
+
+ function Class() {
+ return Super.apply(this, arguments);
+ }
+
+ _extends(prototype, Class.prototype);
+
+ Class.prototype = prototype;
+ Class.prototype.constructor = Class;
+ Class.Interface = _extends({}, Super.Interface, Interface);
+ Class.extend = Super.extend;
+ addEventPoolingTo(Class);
+ return Class;
+ };
+
+ addEventPoolingTo(SyntheticEvent);
+
+ function getPooledWarningPropertyDefinition(propName, getVal) {
+ var isFunction = typeof getVal === "function";
+ return {
+ configurable: true,
+ set: set,
+ get: get$$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 ? warningWithoutStack$1(false, "This synthetic event is reused for performance reasons. If you're seeing this, " + "you're %s `%s` on a released/nullified synthetic event. %s. " + "If you must keep the original synthetic event around, use event.persist(). " + "See https://fb.me/react-event-pooling for more information.", action, propName, result) : void 0;
+ }
+ }
+
+ function getPooledEvent(dispatchConfig, targetInst, nativeEvent, nativeInst) {
+ var EventConstructor = this;
+
+ if (EventConstructor.eventPool.length) {
+ var instance = EventConstructor.eventPool.pop();
+ EventConstructor.call(instance, dispatchConfig, targetInst, nativeEvent, nativeInst);
+ return instance;
+ }
+
+ return new EventConstructor(dispatchConfig, targetInst, nativeEvent, nativeInst);
+ }
+
+ function releasePooledEvent(event) {
+ var EventConstructor = this;
+ 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 ResponderSyntheticEvent = SyntheticEvent.extend({
+ touchHistory: function touchHistory(nativeEvent) {
+ return null;
+ }
+ });
+ var TOP_TOUCH_START = "topTouchStart";
+ var TOP_TOUCH_MOVE = "topTouchMove";
+ var TOP_TOUCH_END = "topTouchEnd";
+ var TOP_TOUCH_CANCEL = "topTouchCancel";
+ var TOP_SCROLL = "topScroll";
+ var TOP_SELECTION_CHANGE = "topSelectionChange";
+
+ function isStartish(topLevelType) {
+ return topLevelType === TOP_TOUCH_START;
+ }
+
+ function isMoveish(topLevelType) {
+ return topLevelType === TOP_TOUCH_MOVE;
+ }
+
+ function isEndish(topLevelType) {
+ return topLevelType === TOP_TOUCH_END || topLevelType === TOP_TOUCH_CANCEL;
+ }
+
+ var startDependencies = [TOP_TOUCH_START];
+ var moveDependencies = [TOP_TOUCH_MOVE];
+ var endDependencies = [TOP_TOUCH_CANCEL, TOP_TOUCH_END];
+ var MAX_TOUCH_BANK = 20;
+ var touchBank = [];
+ var touchHistory = {
+ touchBank: touchBank,
+ numberActiveTouches: 0,
+ indexOfSingleActiveTouch: -1,
+ mostRecentTimeStamp: 0
+ };
+
+ function timestampForTouch(touch) {
+ return touch.timeStamp || touch.timestamp;
+ }
+
+ function createTouchRecord(touch) {
+ return {
+ touchActive: true,
+ startPageX: touch.pageX,
+ startPageY: touch.pageY,
+ startTimeStamp: timestampForTouch(touch),
+ currentPageX: touch.pageX,
+ currentPageY: touch.pageY,
+ currentTimeStamp: timestampForTouch(touch),
+ previousPageX: touch.pageX,
+ previousPageY: touch.pageY,
+ previousTimeStamp: timestampForTouch(touch)
+ };
+ }
+
+ function resetTouchRecord(touchRecord, touch) {
+ touchRecord.touchActive = true;
+ touchRecord.startPageX = touch.pageX;
+ touchRecord.startPageY = touch.pageY;
+ touchRecord.startTimeStamp = timestampForTouch(touch);
+ touchRecord.currentPageX = touch.pageX;
+ touchRecord.currentPageY = touch.pageY;
+ touchRecord.currentTimeStamp = timestampForTouch(touch);
+ touchRecord.previousPageX = touch.pageX;
+ touchRecord.previousPageY = touch.pageY;
+ touchRecord.previousTimeStamp = timestampForTouch(touch);
+ }
+
+ function getTouchIdentifier(_ref) {
+ var identifier = _ref.identifier;
+ invariant(identifier != null, "Touch object is missing identifier.");
+ {
+ !(identifier <= MAX_TOUCH_BANK) ? warningWithoutStack$1(false, "Touch identifier %s is greater than maximum supported %s which causes " + "performance issues backfilling array locations for all of the indices.", identifier, MAX_TOUCH_BANK) : void 0;
+ }
+ return identifier;
+ }
+
+ function recordTouchStart(touch) {
+ var identifier = getTouchIdentifier(touch);
+ var touchRecord = touchBank[identifier];
+
+ if (touchRecord) {
+ resetTouchRecord(touchRecord, touch);
+ } else {
+ touchBank[identifier] = createTouchRecord(touch);
+ }
+
+ touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
+ }
+
+ function recordTouchMove(touch) {
+ var touchRecord = touchBank[getTouchIdentifier(touch)];
+
+ if (touchRecord) {
+ touchRecord.touchActive = true;
+ touchRecord.previousPageX = touchRecord.currentPageX;
+ touchRecord.previousPageY = touchRecord.currentPageY;
+ touchRecord.previousTimeStamp = touchRecord.currentTimeStamp;
+ touchRecord.currentPageX = touch.pageX;
+ touchRecord.currentPageY = touch.pageY;
+ touchRecord.currentTimeStamp = timestampForTouch(touch);
+ touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
+ } else {
+ console.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) ? warningWithoutStack$1(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 ReactNativeBridgeEventPlugin = {
+ eventTypes: ReactNativeViewConfigRegistry.eventTypes,
+ extractEvents: function extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+ if (targetInst == null) {
+ return null;
+ }
+
+ var bubbleDispatchConfig = ReactNativeViewConfigRegistry.customBubblingEventTypes[topLevelType];
+ var directDispatchConfig = ReactNativeViewConfigRegistry.customDirectEventTypes[topLevelType];
+ invariant(bubbleDispatchConfig || directDispatchConfig, 'Unsupported top level event type "%s" dispatched', topLevelType);
+ var event = SyntheticEvent.getPooled(bubbleDispatchConfig || directDispatchConfig, targetInst, nativeEvent, nativeEventTarget);
+
+ if (bubbleDispatchConfig) {
+ accumulateTwoPhaseDispatches(event);
+ } else if (directDispatchConfig) {
+ accumulateDirectDispatches(event);
+ } else {
+ return null;
+ }
+
+ return event;
+ }
+ };
+ var ReactNativeEventPluginOrder = ["ResponderEventPlugin", "ReactNativeBridgeEventPlugin"];
+ injection.injectEventPluginOrder(ReactNativeEventPluginOrder);
+ injection.injectEventPluginsByName({
+ ResponderEventPlugin: ResponderEventPlugin,
+ ReactNativeBridgeEventPlugin: ReactNativeBridgeEventPlugin
+ });
+
+ function getInstanceFromInstance(instanceHandle) {
+ return instanceHandle;
+ }
+
+ function getTagFromInstance(inst) {
+ var tag = inst.stateNode.canonical._nativeTag;
+ invariant(tag, "All native instances should have a tag.");
+ return tag;
+ }
+
+ function getFiberCurrentPropsFromNode$1(inst) {
+ return inst.canonical.currentProps;
+ }
+
+ var ReactFabricGlobalResponderHandler = {
+ onChange: function onChange(from, to, blockNativeResponder) {
+ if (to !== null) {
+ var tag = to.stateNode.canonical._nativeTag;
+ UIManager.setJSResponder(tag, blockNativeResponder);
+ } else {
+ UIManager.clearJSResponder();
+ }
+ }
+ };
+ setComponentTree(getFiberCurrentPropsFromNode$1, getInstanceFromInstance, getTagFromInstance);
+ ResponderEventPlugin.injection.injectGlobalResponderHandler(ReactFabricGlobalResponderHandler);
+
+ function get$1(key) {
+ return key._reactInternalFiber;
+ }
+
+ function set(key, value) {
+ key._reactInternalFiber = value;
+ }
+
+ var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+ if (!ReactSharedInternals.hasOwnProperty("ReactCurrentDispatcher")) {
+ ReactSharedInternals.ReactCurrentDispatcher = {
+ current: null
+ };
+ }
+
+ var hasSymbol = typeof Symbol === "function" && (typeof Symbol === "function" ? Symbol.for : "@@for");
+ var REACT_ELEMENT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.element") : 0xeac7;
+ var REACT_PORTAL_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.portal") : 0xeaca;
+ var REACT_FRAGMENT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.fragment") : 0xeacb;
+ var REACT_STRICT_MODE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.strict_mode") : 0xeacc;
+ var REACT_PROFILER_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.profiler") : 0xead2;
+ var REACT_PROVIDER_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.provider") : 0xeacd;
+ var REACT_CONTEXT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.context") : 0xeace;
+ var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.concurrent_mode") : 0xeacf;
+ var REACT_FORWARD_REF_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.forward_ref") : 0xead0;
+ var REACT_SUSPENSE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.suspense") : 0xead1;
+ var REACT_MEMO_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.memo") : 0xead3;
+ var REACT_LAZY_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.lazy") : 0xead4;
+ var MAYBE_ITERATOR_SYMBOL = typeof Symbol === "function" && (typeof Symbol === "function" ? Symbol.iterator : "@@iterator");
+ var FAUX_ITERATOR_SYMBOL = "@@iterator";
+
+ function getIteratorFn(maybeIterable) {
+ if (maybeIterable === null || typeof maybeIterable !== "object") {
+ return null;
+ }
+
+ var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+ if (typeof maybeIterator === "function") {
+ return maybeIterator;
+ }
+
+ return null;
+ }
+
+ var Pending = 0;
+ var Resolved = 1;
+ var Rejected = 2;
+
+ function refineResolvedLazyComponent(lazyComponent) {
+ return lazyComponent._status === Resolved ? lazyComponent._result : null;
+ }
+
+ function getWrappedName(outerType, innerType, wrapperName) {
+ var functionName = innerType.displayName || innerType.name || "";
+ return outerType.displayName || (functionName !== "" ? wrapperName + "(" + functionName + ")" : wrapperName);
+ }
+
+ function getComponentName(type) {
+ if (type == null) {
+ return null;
+ }
+
+ {
+ if (typeof type.tag === "number") {
+ warningWithoutStack$1(false, "Received an unexpected object in getComponentName(). " + "This is likely a bug in React. Please file an issue.");
+ }
+ }
+
+ if (typeof type === "function") {
+ return type.displayName || type.name || null;
+ }
+
+ if (typeof type === "string") {
+ return type;
+ }
+
+ switch (type) {
+ case REACT_CONCURRENT_MODE_TYPE:
+ return "ConcurrentMode";
+
+ case REACT_FRAGMENT_TYPE:
+ return "Fragment";
+
+ case REACT_PORTAL_TYPE:
+ return "Portal";
+
+ case REACT_PROFILER_TYPE:
+ return "Profiler";
+
+ case REACT_STRICT_MODE_TYPE:
+ return "StrictMode";
+
+ case REACT_SUSPENSE_TYPE:
+ return "Suspense";
+ }
+
+ if (typeof type === "object") {
+ switch (type.$$typeof) {
+ case REACT_CONTEXT_TYPE:
+ return "Context.Consumer";
+
+ case REACT_PROVIDER_TYPE:
+ return "Context.Provider";
+
+ case REACT_FORWARD_REF_TYPE:
+ return getWrappedName(type, type.render, "ForwardRef");
+
+ case REACT_MEMO_TYPE:
+ return getComponentName(type.type);
+
+ case REACT_LAZY_TYPE:
+ {
+ var thenable = type;
+ var resolvedThenable = refineResolvedLazyComponent(thenable);
+
+ if (resolvedThenable) {
+ return getComponentName(resolvedThenable);
+ }
+ }
+ }
+ }
+
+ return null;
+ }
+
+ var NoEffect = 0;
+ var PerformedWork = 1;
+ var Placement = 2;
+ var Update = 4;
+ var PlacementAndUpdate = 6;
+ var Deletion = 8;
+ var ContentReset = 16;
+ var Callback = 32;
+ var DidCapture = 64;
+ var Ref = 128;
+ var Snapshot = 256;
+ var Passive = 512;
+ var LifecycleEffectMask = 932;
+ var HostEffectMask = 1023;
+ var Incomplete = 1024;
+ var ShouldCapture = 2048;
+ var ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner;
+ var MOUNTING = 1;
+ var MOUNTED = 2;
+ var UNMOUNTED = 3;
+
+ function isFiberMountedImpl(fiber) {
+ var node = fiber;
+
+ if (!fiber.alternate) {
+ if ((node.effectTag & Placement) !== NoEffect) {
+ return MOUNTING;
+ }
+
+ while (node.return) {
+ node = node.return;
+
+ if ((node.effectTag & Placement) !== NoEffect) {
+ return MOUNTING;
+ }
+ }
+ } else {
+ while (node.return) {
+ node = node.return;
+ }
+ }
+
+ if (node.tag === HostRoot) {
+ return MOUNTED;
+ }
+
+ return UNMOUNTED;
+ }
+
+ function isFiberMounted(fiber) {
+ return isFiberMountedImpl(fiber) === MOUNTED;
+ }
+
+ function isMounted(component) {
+ {
+ var owner = ReactCurrentOwner$1.current;
+
+ if (owner !== null && owner.tag === ClassComponent) {
+ var ownerFiber = owner;
+ var instance = ownerFiber.stateNode;
+ !instance._warnedAboutRefsInRender ? warningWithoutStack$1(false, "%s is accessing isMounted inside its render() function. " + "render() should be a pure function of props and state. It should " + "never access something that requires stale data from the previous " + "render, such as refs. Move this logic to componentDidMount and " + "componentDidUpdate instead.", getComponentName(ownerFiber.type) || "A component") : void 0;
+ instance._warnedAboutRefsInRender = true;
+ }
+ }
+ var fiber = get$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 mountSafeCallback_NOT_REALLY_SAFE(context, callback) {
+ return function () {
+ if (!callback) {
+ return undefined;
+ }
+
+ if (typeof context.__isMounted === "boolean") {
+ if (!context.__isMounted) {
+ return undefined;
+ }
+ }
+
+ return callback.apply(context, arguments);
+ };
+ }
+
+ function throwOnStylesProp(component, props) {
+ if (props.styles !== undefined) {
+ var owner = component._owner || null;
+ var name = component.constructor.displayName;
+ var msg = "`styles` is not a supported property of `" + name + "`, did " + "you mean `style` (singular)?";
+
+ if (owner && owner.constructor && owner.constructor.displayName) {
+ msg += "\n\nCheck the `" + owner.constructor.displayName + "` parent " + " component.";
+ }
+
+ throw new Error(msg);
+ }
+ }
+
+ function warnForStyleProps(props, validAttributes) {
+ for (var key in validAttributes.style) {
+ if (!(validAttributes[key] || props[key] === undefined)) {
+ console.error("You are setting the style `{ " + key + ": ... }` as a prop. You " + "should nest it in a style object. " + "E.g. `{ style: { " + key + ": ... } }`");
+ }
+ }
+ }
+
+ var emptyObject = {};
+ var removedKeys = null;
+ var removedKeyCount = 0;
+
+ function defaultDiffer(prevProp, nextProp) {
+ if (typeof nextProp !== "object" || nextProp === null) {
+ return true;
+ } else {
+ return 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, props, validAttributes);
+ }
+
+ function clearProperties(updatePayload, prevProps, validAttributes) {
+ return diffProperties(updatePayload, prevProps, emptyObject, validAttributes);
+ }
+
+ function create(props, validAttributes) {
+ return addProperties(null, props, validAttributes);
+ }
+
+ function diff(prevProps, nextProps, validAttributes) {
+ return diffProperties(null, prevProps, nextProps, validAttributes);
+ }
+
+ var 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;
+
+ function setTimeoutCallback() {
+ frameDeadline = now$1() + 5;
+ var callback = scheduledCallback;
+ scheduledCallback = null;
+
+ if (callback !== null) {
+ callback();
+ }
+ }
+
+ function scheduleDeferredCallback$1(callback, options) {
+ scheduledCallback = callback;
+ var timeoutId = setTimeout(setTimeoutCallback, 1);
+ return timeoutId;
+ }
+
+ function cancelDeferredCallback$1(callbackID) {
+ scheduledCallback = null;
+ clearTimeout(callbackID);
+ }
+
+ function shouldYield$1() {
+ return frameDeadline <= now$1();
+ }
+
+ var debugRenderPhaseSideEffects = false;
+ var debugRenderPhaseSideEffectsForStrictMode = false;
+ var enableUserTimingAPI = true;
+ var replayFailedUnitOfWorkWithInvokeGuardedCallback = true;
+ var warnAboutDeprecatedLifecycles = false;
+ var enableProfilerTimer = true;
+ var enableSchedulerTracing = true;
+ var enableSuspenseServerRenderer = false;
+ var warnAboutDeprecatedSetNativeProps = false;
+ var restoreImpl = null;
+ var restoreTarget = null;
+ var restoreQueue = null;
+
+ function restoreStateOfTarget(target) {
+ var internalInstance = getInstanceFromNode(target);
+
+ if (!internalInstance) {
+ return;
+ }
+
+ invariant(typeof restoreImpl === "function", "setRestoreImplementation() needs to be called to handle a target for controlled " + "events. This error is likely caused by a bug in React. Please file an issue.");
+ var props = getFiberCurrentPropsFromNode(internalInstance.stateNode);
+ restoreImpl(internalInstance.stateNode, internalInstance.type, props);
+ }
+
+ function needsStateRestore() {
+ return restoreTarget !== null || restoreQueue !== null;
+ }
+
+ function restoreStateIfNeeded() {
+ if (!restoreTarget) {
+ return;
+ }
+
+ var target = restoreTarget;
+ var queuedTargets = restoreQueue;
+ restoreTarget = null;
+ restoreQueue = null;
+ restoreStateOfTarget(target);
+
+ if (queuedTargets) {
+ for (var i = 0; i < queuedTargets.length; i++) {
+ restoreStateOfTarget(queuedTargets[i]);
+ }
+ }
+ }
+
+ var _batchedUpdatesImpl = function _batchedUpdatesImpl(fn, bookkeeping) {
+ return fn(bookkeeping);
+ };
+
+ var _flushInteractiveUpdatesImpl = function _flushInteractiveUpdatesImpl() {};
+
+ var isBatching = false;
+
+ function batchedUpdates(fn, bookkeeping) {
+ if (isBatching) {
+ return fn(bookkeeping);
+ }
+
+ isBatching = true;
+
+ try {
+ return _batchedUpdatesImpl(fn, bookkeeping);
+ } finally {
+ isBatching = false;
+ var controlledComponentsHavePendingUpdates = needsStateRestore();
+
+ if (controlledComponentsHavePendingUpdates) {
+ _flushInteractiveUpdatesImpl();
+
+ restoreStateIfNeeded();
+ }
+ }
+ }
+
+ function setBatchingImplementation(batchedUpdatesImpl, interactiveUpdatesImpl, flushInteractiveUpdatesImpl) {
+ _batchedUpdatesImpl = batchedUpdatesImpl;
+ _flushInteractiveUpdatesImpl = flushInteractiveUpdatesImpl;
+ }
+
+ 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;
+ var hideInstance = shim;
+ var hideTextInstance = shim;
+ var unhideInstance = shim;
+ var unhideTextInstance = shim;
+
+ function shim$1() {
+ invariant(false, "The current renderer does not support hydration. " + "This error is likely caused by a bug in React. " + "Please file an issue.");
+ }
+
+ var supportsHydration = false;
+ var canHydrateInstance = shim$1;
+ var canHydrateTextInstance = shim$1;
+ var canHydrateSuspenseInstance = shim$1;
+ var isSuspenseInstancePending = shim$1;
+ var isSuspenseInstanceFallback = shim$1;
+ var registerSuspenseInstanceRetry = shim$1;
+ var getNextHydratableSibling = shim$1;
+ var getFirstHydratableChild = shim$1;
+ var hydrateInstance = shim$1;
+ var hydrateTextInstance = shim$1;
+ var getNextHydratableInstanceAfterSuspenseInstance = shim$1;
+ var clearSuspenseBoundary = shim$1;
+ var clearSuspenseBoundaryFromContainer = shim$1;
+ var didNotMatchHydratedContainerTextInstance = shim$1;
+ var didNotMatchHydratedTextInstance = shim$1;
+ var didNotHydrateContainerInstance = shim$1;
+ var didNotHydrateInstance = shim$1;
+ var didNotFindHydratableContainerInstance = shim$1;
+ var didNotFindHydratableContainerTextInstance = shim$1;
+ var didNotFindHydratableContainerSuspenseInstance = shim$1;
+ var didNotFindHydratableInstance = shim$1;
+ var didNotFindHydratableTextInstance = shim$1;
+ var didNotFindHydratableSuspenseInstance = shim$1;
+
+ function _classCallCheck(instance, Constructor) {
+ if (!(instance instanceof Constructor)) {
+ throw new TypeError("Cannot call a class as a function");
+ }
+ }
+
+ var 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_NOT_REALLY_SAFE(this, callback));
+ };
+
+ ReactFabricHostComponent.prototype.measureInWindow = function measureInWindow(callback) {
+ UIManager.measureInWindow(this._nativeTag, mountSafeCallback_NOT_REALLY_SAFE(this, callback));
+ };
+
+ ReactFabricHostComponent.prototype.measureLayout = function measureLayout(relativeToNativeNode, onSuccess, onFail) {
+ UIManager.measureLayout(this._nativeTag, relativeToNativeNode, mountSafeCallback_NOT_REALLY_SAFE(this, onFail), mountSafeCallback_NOT_REALLY_SAFE(this, onSuccess));
+ };
+
+ ReactFabricHostComponent.prototype.setNativeProps = function setNativeProps(nativeProps) {
+ {
+ if (warnAboutDeprecatedSetNativeProps) {
+ warningWithoutStack$1(false, "Warning: Calling ref.setNativeProps(nativeProps) " + "is deprecated and will be removed in a future release. " + "Use the setNativeProps export from the react-native package instead." + "\n\timport {setNativeProps} from 'react-native';\n\tsetNativeProps(ref, nativeProps);\n");
+ }
+
+ warnForStyleProps(nativeProps, this.viewConfig.validAttributes);
+ }
+ var updatePayload = create(nativeProps, this.viewConfig.validAttributes);
+
+ if (updatePayload != null) {
+ 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 within 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 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$$1 = now$1;
+ var scheduleDeferredCallback$$1 = scheduleDeferredCallback$1;
+ var cancelDeferredCallback$$1 = cancelDeferredCallback$1;
+ var shouldYield$$1 = shouldYield$1;
+ var scheduleTimeout = setTimeout;
+ var cancelTimeout = clearTimeout;
+ var noTimeout = -1;
+ var schedulePassiveEffects = scheduleDeferredCallback$$1;
+ var cancelPassiveEffects = 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);
+ } else {
+ clone = FabricUIManager.cloneNode(node);
+ }
+ } else {
+ if (updatePayload !== null) {
+ clone = FabricUIManager.cloneNodeWithNewChildrenAndProps(node, updatePayload);
+ } else {
+ clone = FabricUIManager.cloneNodeWithNewChildren(node);
+ }
+ }
+
+ return {
+ node: clone,
+ canonical: instance.canonical
+ };
+ }
+
+ function cloneHiddenInstance(instance, type, props, internalInstanceHandle) {
+ var viewConfig = instance.canonical.viewConfig;
+ var node = instance.node;
+ var updatePayload = create({
+ style: {
+ display: "none"
+ }
+ }, viewConfig.validAttributes);
+ return {
+ node: FabricUIManager.cloneNodeWithNewProps(node, updatePayload),
+ canonical: instance.canonical
+ };
+ }
+
+ function cloneUnhiddenInstance(instance, type, props, internalInstanceHandle) {
+ var viewConfig = instance.canonical.viewConfig;
+ var node = instance.node;
+ var updatePayload = diff(_extends({}, props, {
+ style: [props.style, {
+ display: "none"
+ }]
+ }), props, viewConfig.validAttributes);
+ return {
+ node: FabricUIManager.cloneNodeWithNewProps(node, updatePayload),
+ canonical: instance.canonical
+ };
+ }
+
+ function createHiddenTextInstance(text, rootContainerInstance, hostContext, internalInstanceHandle) {
+ throw new Error("Not yet implemented.");
+ }
+
+ 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 BEFORE_SLASH_RE = /^(.*)[\\\/]/;
+
+ var describeComponentFrame = function describeComponentFrame(name, source, ownerName) {
+ var sourceInfo = "";
+
+ if (source) {
+ var path = source.fileName;
+ var fileName = path.replace(BEFORE_SLASH_RE, "");
+ {
+ if (/^index\./.test(fileName)) {
+ var match = path.match(BEFORE_SLASH_RE);
+
+ if (match) {
+ var pathBeforeSlash = match[1];
+
+ if (pathBeforeSlash) {
+ var folderName = pathBeforeSlash.replace(BEFORE_SLASH_RE, "");
+ fileName = folderName + "/" + fileName;
+ }
+ }
+ }
+ }
+ sourceInfo = " (at " + fileName + ":" + source.lineNumber + ")";
+ } else if (ownerName) {
+ sourceInfo = " (created by " + ownerName + ")";
+ }
+
+ return "\n in " + (name || "Unknown") + sourceInfo;
+ };
+
+ var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+
+ function describeFiber(fiber) {
+ switch (fiber.tag) {
+ case HostRoot:
+ case HostPortal:
+ case HostText:
+ case Fragment:
+ case ContextProvider:
+ case ContextConsumer:
+ return "";
+
+ default:
+ var owner = fiber._debugOwner;
+ var source = fiber._debugSource;
+ var name = getComponentName(fiber.type);
+ var ownerName = null;
+
+ if (owner) {
+ ownerName = getComponentName(owner.type);
+ }
+
+ return describeComponentFrame(name, source, ownerName);
+ }
+ }
+
+ function getStackByFiberInDevAndProd(workInProgress) {
+ var info = "";
+ var node = workInProgress;
+
+ do {
+ info += describeFiber(node);
+ node = node.return;
+ } while (node);
+
+ return info;
+ }
+
+ var current = null;
+ var phase = null;
+
+ function getCurrentFiberOwnerNameInDevOrNull() {
+ {
+ if (current === null) {
+ return null;
+ }
+
+ var owner = current._debugOwner;
+
+ if (owner !== null && typeof owner !== "undefined") {
+ return getComponentName(owner.type);
+ }
+ }
+ return null;
+ }
+
+ function getCurrentFiberStackInDev() {
+ {
+ if (current === null) {
+ return "";
+ }
+
+ return getStackByFiberInDevAndProd(current);
+ }
+ return "";
+ }
+
+ function resetCurrentFiber() {
+ {
+ ReactDebugCurrentFrame.getCurrentStack = null;
+ current = null;
+ phase = null;
+ }
+ }
+
+ function setCurrentFiber(fiber) {
+ {
+ ReactDebugCurrentFrame.getCurrentStack = getCurrentFiberStackInDev;
+ current = fiber;
+ phase = null;
+ }
+ }
+
+ function setCurrentPhase(lifeCyclePhase) {
+ {
+ phase = lifeCyclePhase;
+ }
+ }
+
+ var reactEmoji = "\u269B";
+ var warningEmoji = "\u26D4";
+ var supportsUserTiming = typeof performance !== "undefined" && typeof performance.mark === "function" && typeof performance.clearMarks === "function" && typeof performance.measure === "function" && typeof performance.clearMeasures === "function";
+ var currentFiber = null;
+ var currentPhase = null;
+ var currentPhaseFiber = null;
+ var isCommitting = false;
+ var hasScheduledUpdateInCurrentCommit = false;
+ var hasScheduledUpdateInCurrentPhase = false;
+ var commitCountInCurrentWorkLoop = 0;
+ var effectCountInCurrentCommit = 0;
+ var isWaitingForCallback = false;
+ var labelsInCurrentCommit = new Set();
+
+ var formatMarkName = function formatMarkName(markName) {
+ return reactEmoji + " " + markName;
+ };
+
+ var formatLabel = function formatLabel(label, warning) {
+ var prefix = warning ? warningEmoji + " " : reactEmoji + " ";
+ var suffix = warning ? " Warning: " + warning : "";
+ return "" + prefix + label + suffix;
+ };
+
+ var beginMark = function beginMark(markName) {
+ performance.mark(formatMarkName(markName));
+ };
+
+ var clearMark = function clearMark(markName) {
+ performance.clearMarks(formatMarkName(markName));
+ };
+
+ var endMark = function endMark(label, markName, warning) {
+ var formattedMarkName = formatMarkName(markName);
+ var formattedLabel = formatLabel(label, warning);
+
+ try {
+ performance.measure(formattedLabel, formattedMarkName);
+ } catch (err) {}
+
+ performance.clearMarks(formattedMarkName);
+ performance.clearMeasures(formattedLabel);
+ };
+
+ var getFiberMarkName = function getFiberMarkName(label, debugID) {
+ return label + " (#" + debugID + ")";
+ };
+
+ var getFiberLabel = function getFiberLabel(componentName, isMounted, phase) {
+ if (phase === null) {
+ return componentName + " [" + (isMounted ? "update" : "mount") + "]";
+ } else {
+ return componentName + "." + phase;
+ }
+ };
+
+ var beginFiberMark = function beginFiberMark(fiber, phase) {
+ var componentName = getComponentName(fiber.type) || "Unknown";
+ var debugID = fiber._debugID;
+ var isMounted = fiber.alternate !== null;
+ var label = getFiberLabel(componentName, isMounted, phase);
+
+ if (isCommitting && labelsInCurrentCommit.has(label)) {
+ return false;
+ }
+
+ labelsInCurrentCommit.add(label);
+ var markName = getFiberMarkName(label, debugID);
+ beginMark(markName);
+ return true;
+ };
+
+ var clearFiberMark = function clearFiberMark(fiber, phase) {
+ var componentName = getComponentName(fiber.type) || "Unknown";
+ var debugID = fiber._debugID;
+ var isMounted = fiber.alternate !== null;
+ var label = getFiberLabel(componentName, isMounted, phase);
+ var markName = getFiberMarkName(label, debugID);
+ clearMark(markName);
+ };
+
+ var endFiberMark = function endFiberMark(fiber, phase, warning) {
+ var componentName = getComponentName(fiber.type) || "Unknown";
+ var debugID = fiber._debugID;
+ var isMounted = fiber.alternate !== null;
+ var label = getFiberLabel(componentName, isMounted, phase);
+ var markName = getFiberMarkName(label, debugID);
+ endMark(label, markName, warning);
+ };
+
+ var shouldIgnoreFiber = function shouldIgnoreFiber(fiber) {
+ switch (fiber.tag) {
+ case HostRoot:
+ case HostComponent:
+ case HostText:
+ case HostPortal:
+ case Fragment:
+ case ContextProvider:
+ case ContextConsumer:
+ case Mode:
+ return true;
+
+ default:
+ return false;
+ }
+ };
+
+ var clearPendingPhaseMeasurement = function clearPendingPhaseMeasurement() {
+ if (currentPhase !== null && currentPhaseFiber !== null) {
+ clearFiberMark(currentPhaseFiber, currentPhase);
+ }
+
+ currentPhaseFiber = null;
+ currentPhase = null;
+ hasScheduledUpdateInCurrentPhase = false;
+ };
+
+ var pauseTimers = function pauseTimers() {
+ var fiber = currentFiber;
+
+ while (fiber) {
+ if (fiber._debugIsCurrentlyTiming) {
+ endFiberMark(fiber, null, null);
+ }
+
+ fiber = fiber.return;
+ }
+ };
+
+ var resumeTimersRecursively = function resumeTimersRecursively(fiber) {
+ if (fiber.return !== null) {
+ resumeTimersRecursively(fiber.return);
+ }
+
+ if (fiber._debugIsCurrentlyTiming) {
+ beginFiberMark(fiber, null);
+ }
+ };
+
+ var resumeTimers = function resumeTimers() {
+ if (currentFiber !== null) {
+ resumeTimersRecursively(currentFiber);
+ }
+ };
+
+ function recordEffect() {
+ if (enableUserTimingAPI) {
+ effectCountInCurrentCommit++;
+ }
+ }
+
+ function recordScheduleUpdate() {
+ if (enableUserTimingAPI) {
+ if (isCommitting) {
+ hasScheduledUpdateInCurrentCommit = true;
+ }
+
+ if (currentPhase !== null && currentPhase !== "componentWillMount" && currentPhase !== "componentWillReceiveProps") {
+ hasScheduledUpdateInCurrentPhase = true;
+ }
+ }
+ }
+
+ function startRequestCallbackTimer() {
+ if (enableUserTimingAPI) {
+ if (supportsUserTiming && !isWaitingForCallback) {
+ isWaitingForCallback = true;
+ beginMark("(Waiting for async callback...)");
+ }
+ }
+ }
+
+ function stopRequestCallbackTimer(didExpire, expirationTime) {
+ if (enableUserTimingAPI) {
+ if (supportsUserTiming) {
+ isWaitingForCallback = false;
+ var warning = didExpire ? "React was blocked by main thread" : null;
+ endMark("(Waiting for async callback... will force flush in " + expirationTime + " ms)", "(Waiting for async callback...)", warning);
+ }
+ }
+ }
+
+ function startWorkTimer(fiber) {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming || shouldIgnoreFiber(fiber)) {
+ return;
+ }
+
+ currentFiber = fiber;
+
+ if (!beginFiberMark(fiber, null)) {
+ return;
+ }
+
+ fiber._debugIsCurrentlyTiming = true;
+ }
+ }
+
+ function cancelWorkTimer(fiber) {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming || shouldIgnoreFiber(fiber)) {
+ return;
+ }
+
+ fiber._debugIsCurrentlyTiming = false;
+ clearFiberMark(fiber, null);
+ }
+ }
+
+ function stopWorkTimer(fiber) {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming || shouldIgnoreFiber(fiber)) {
+ return;
+ }
+
+ currentFiber = fiber.return;
+
+ if (!fiber._debugIsCurrentlyTiming) {
+ return;
+ }
+
+ fiber._debugIsCurrentlyTiming = false;
+ endFiberMark(fiber, null, null);
+ }
+ }
+
+ function stopFailedWorkTimer(fiber) {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming || shouldIgnoreFiber(fiber)) {
+ return;
+ }
+
+ currentFiber = fiber.return;
+
+ if (!fiber._debugIsCurrentlyTiming) {
+ return;
+ }
+
+ fiber._debugIsCurrentlyTiming = false;
+ var warning = fiber.tag === SuspenseComponent || fiber.tag === DehydratedSuspenseComponent ? "Rendering was suspended" : "An error was thrown inside this error boundary";
+ endFiberMark(fiber, null, warning);
+ }
+ }
+
+ function startPhaseTimer(fiber, phase) {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ clearPendingPhaseMeasurement();
+
+ if (!beginFiberMark(fiber, phase)) {
+ return;
+ }
+
+ currentPhaseFiber = fiber;
+ currentPhase = phase;
+ }
+ }
+
+ function stopPhaseTimer() {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ if (currentPhase !== null && currentPhaseFiber !== null) {
+ var warning = hasScheduledUpdateInCurrentPhase ? "Scheduled a cascading update" : null;
+ endFiberMark(currentPhaseFiber, currentPhase, warning);
+ }
+
+ currentPhase = null;
+ currentPhaseFiber = null;
+ }
+ }
+
+ function startWorkLoopTimer(nextUnitOfWork) {
+ if (enableUserTimingAPI) {
+ currentFiber = nextUnitOfWork;
+
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ commitCountInCurrentWorkLoop = 0;
+ beginMark("(React Tree Reconciliation)");
+ resumeTimers();
+ }
+ }
+
+ function stopWorkLoopTimer(interruptedBy, didCompleteRoot) {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ var warning = null;
+
+ if (interruptedBy !== null) {
+ if (interruptedBy.tag === HostRoot) {
+ warning = "A top-level update interrupted the previous render";
+ } else {
+ var componentName = getComponentName(interruptedBy.type) || "Unknown";
+ warning = "An update to " + componentName + " interrupted the previous render";
+ }
+ } else if (commitCountInCurrentWorkLoop > 1) {
+ warning = "There were cascading updates";
+ }
+
+ commitCountInCurrentWorkLoop = 0;
+ var label = didCompleteRoot ? "(React Tree Reconciliation: Completed Root)" : "(React Tree Reconciliation: Yielded)";
+ pauseTimers();
+ endMark(label, "(React Tree Reconciliation)", warning);
+ }
+ }
+
+ function startCommitTimer() {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ isCommitting = true;
+ hasScheduledUpdateInCurrentCommit = false;
+ labelsInCurrentCommit.clear();
+ beginMark("(Committing Changes)");
+ }
+ }
+
+ function stopCommitTimer() {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ var warning = null;
+
+ if (hasScheduledUpdateInCurrentCommit) {
+ warning = "Lifecycle hook scheduled a cascading update";
+ } else if (commitCountInCurrentWorkLoop > 0) {
+ warning = "Caused by a cascading update in earlier commit";
+ }
+
+ hasScheduledUpdateInCurrentCommit = false;
+ commitCountInCurrentWorkLoop++;
+ isCommitting = false;
+ labelsInCurrentCommit.clear();
+ endMark("(Committing Changes)", "(Committing Changes)", warning);
+ }
+ }
+
+ function startCommitSnapshotEffectsTimer() {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ effectCountInCurrentCommit = 0;
+ beginMark("(Committing Snapshot Effects)");
+ }
+ }
+
+ function stopCommitSnapshotEffectsTimer() {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ var count = effectCountInCurrentCommit;
+ effectCountInCurrentCommit = 0;
+ endMark("(Committing Snapshot Effects: " + count + " Total)", "(Committing Snapshot Effects)", null);
+ }
+ }
+
+ function startCommitHostEffectsTimer() {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ effectCountInCurrentCommit = 0;
+ beginMark("(Committing Host Effects)");
+ }
+ }
+
+ function stopCommitHostEffectsTimer() {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ var count = effectCountInCurrentCommit;
+ effectCountInCurrentCommit = 0;
+ endMark("(Committing Host Effects: " + count + " Total)", "(Committing Host Effects)", null);
+ }
+ }
+
+ function startCommitLifeCyclesTimer() {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ effectCountInCurrentCommit = 0;
+ beginMark("(Calling Lifecycle Methods)");
+ }
+ }
+
+ function stopCommitLifeCyclesTimer() {
+ if (enableUserTimingAPI) {
+ if (!supportsUserTiming) {
+ return;
+ }
+
+ var count = effectCountInCurrentCommit;
+ effectCountInCurrentCommit = 0;
+ endMark("(Calling Lifecycle Methods: " + count + " Total)", "(Calling Lifecycle Methods)", null);
+ }
+ }
+
+ var valueStack = [];
+ var fiberStack = void 0;
+ {
+ fiberStack = [];
+ }
+ var index = -1;
+
+ function createCursor(defaultValue) {
+ return {
+ current: defaultValue
+ };
+ }
+
+ function pop(cursor, fiber) {
+ if (index < 0) {
+ {
+ warningWithoutStack$1(false, "Unexpected pop.");
+ }
+ return;
+ }
+
+ {
+ if (fiber !== fiberStack[index]) {
+ warningWithoutStack$1(false, "Unexpected Fiber popped.");
+ }
+ }
+ cursor.current = valueStack[index];
+ valueStack[index] = null;
+ {
+ fiberStack[index] = null;
+ }
+ index--;
+ }
+
+ function push(cursor, value, fiber) {
+ index++;
+ valueStack[index] = cursor.current;
+ {
+ fiberStack[index] = fiber;
+ }
+ cursor.current = value;
+ }
+
+ function checkThatStackIsEmpty() {
+ {
+ if (index !== -1) {
+ warningWithoutStack$1(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 emptyContextObject = {};
+ {
+ Object.freeze(emptyContextObject);
+ }
+ var contextStackCursor = createCursor(emptyContextObject);
+ var didPerformWorkStackCursor = createCursor(false);
+ var previousContext = emptyContextObject;
+
+ function getUnmaskedContext(workInProgress, Component, didPushOwnContextIfProvider) {
+ if (didPushOwnContextIfProvider && isContextProvider(Component)) {
+ 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 emptyContextObject;
+ }
+
+ var instance = workInProgress.stateNode;
+
+ if (instance && instance.__reactInternalMemoizedUnmaskedChildContext === unmaskedContext) {
+ return instance.__reactInternalMemoizedMaskedChildContext;
+ }
+
+ var context = {};
+
+ for (var key in contextTypes) {
+ context[key] = unmaskedContext[key];
+ }
+
+ {
+ var name = getComponentName(type) || "Unknown";
+ checkPropTypes(contextTypes, context, "context", name, getCurrentFiberStackInDev);
+ }
+
+ if (instance) {
+ cacheContext(workInProgress, unmaskedContext, context);
+ }
+
+ return context;
+ }
+
+ function hasContextChanged() {
+ return didPerformWorkStackCursor.current;
+ }
+
+ function isContextProvider(type) {
+ var childContextTypes = type.childContextTypes;
+ return childContextTypes !== null && childContextTypes !== undefined;
+ }
+
+ function popContext(fiber) {
+ pop(didPerformWorkStackCursor, fiber);
+ pop(contextStackCursor, fiber);
+ }
+
+ function popTopLevelContextObject(fiber) {
+ pop(didPerformWorkStackCursor, fiber);
+ pop(contextStackCursor, fiber);
+ }
+
+ function pushTopLevelContextObject(fiber, context, didChange) {
+ invariant(contextStackCursor.current === emptyContextObject, "Unexpected context found on stack. " + "This error is likely caused by a bug in React. Please file an issue.");
+ push(contextStackCursor, context, fiber);
+ push(didPerformWorkStackCursor, didChange, fiber);
+ }
+
+ function processChildContext(fiber, type, parentContext) {
+ var instance = fiber.stateNode;
+ var childContextTypes = type.childContextTypes;
+
+ if (typeof instance.getChildContext !== "function") {
+ {
+ var componentName = getComponentName(type) || "Unknown";
+
+ if (!warnedAboutMissingGetChildContext[componentName]) {
+ warnedAboutMissingGetChildContext[componentName] = true;
+ warningWithoutStack$1(false, "%s.childContextTypes is specified but there is no getChildContext() method " + "on the instance. You can either define getChildContext() on %s or remove " + "childContextTypes from it.", componentName, componentName);
+ }
+ }
+ return parentContext;
+ }
+
+ var childContext = void 0;
+ {
+ setCurrentPhase("getChildContext");
+ }
+ startPhaseTimer(fiber, "getChildContext");
+ childContext = instance.getChildContext();
+ stopPhaseTimer();
+ {
+ setCurrentPhase(null);
+ }
+
+ for (var contextKey in childContext) {
+ invariant(contextKey in childContextTypes, '%s.getChildContext(): key "%s" is not defined in childContextTypes.', getComponentName(type) || "Unknown", contextKey);
+ }
+
+ {
+ var name = getComponentName(type) || "Unknown";
+ checkPropTypes(childContextTypes, childContext, "child context", name, getCurrentFiberStackInDev);
+ }
+ return _extends({}, parentContext, childContext);
+ }
+
+ function pushContextProvider(workInProgress) {
+ var instance = workInProgress.stateNode;
+ var memoizedMergedChildContext = instance && instance.__reactInternalMemoizedMergedChildContext || emptyContextObject;
+ previousContext = contextStackCursor.current;
+ push(contextStackCursor, memoizedMergedChildContext, workInProgress);
+ push(didPerformWorkStackCursor, didPerformWorkStackCursor.current, workInProgress);
+ return true;
+ }
+
+ function invalidateContextProvider(workInProgress, type, didChange) {
+ 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, type, previousContext);
+ instance.__reactInternalMemoizedMergedChildContext = mergedContext;
+ pop(didPerformWorkStackCursor, workInProgress);
+ pop(contextStackCursor, workInProgress);
+ push(contextStackCursor, mergedContext, workInProgress);
+ push(didPerformWorkStackCursor, didChange, workInProgress);
+ } else {
+ pop(didPerformWorkStackCursor, workInProgress);
+ push(didPerformWorkStackCursor, didChange, workInProgress);
+ }
+ }
+
+ function findCurrentUnmaskedContext(fiber) {
+ 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;
+
+ do {
+ switch (node.tag) {
+ case HostRoot:
+ return node.stateNode.context;
+
+ case ClassComponent:
+ {
+ var Component = node.type;
+
+ if (isContextProvider(Component)) {
+ return node.stateNode.__reactInternalMemoizedMergedChildContext;
+ }
+
+ break;
+ }
+ }
+
+ node = node.return;
+ } while (node !== null);
+
+ invariant(false, "Found unexpected detached subtree parent. " + "This error is likely caused by a bug in React. Please file an issue.");
+ }
+
+ 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;
+ warningWithoutStack$1(false, "React DevTools encountered an error: %s", err);
+ }
+ }
+ };
+ }
+
+ var isDevToolsPresent = typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined";
+
+ function injectInternals(internals) {
+ if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === "undefined") {
+ return false;
+ }
+
+ var hook = __REACT_DEVTOOLS_GLOBAL_HOOK__;
+
+ if (hook.isDisabled) {
+ return true;
+ }
+
+ if (!hook.supportsFiber) {
+ {
+ warningWithoutStack$1(false, "The installed version of React DevTools is too old and will not work " + "with the current version of React. Please update React DevTools. " + "https://fb.me/react-devtools");
+ }
+ return true;
+ }
+
+ try {
+ var rendererID = hook.inject(internals);
+ onCommitFiberRoot = catchErrors(function (root) {
+ return hook.onCommitFiberRoot(rendererID, root);
+ });
+ onCommitFiberUnmount = catchErrors(function (fiber) {
+ return hook.onCommitFiberUnmount(rendererID, fiber);
+ });
+ } catch (err) {
+ {
+ warningWithoutStack$1(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 maxSigned31BitInt = 1073741823;
+ var NoWork = 0;
+ var Never = 1;
+ var Sync = maxSigned31BitInt;
+ var UNIT_SIZE = 10;
+ var MAGIC_NUMBER_OFFSET = maxSigned31BitInt - 1;
+
+ function msToExpirationTime(ms) {
+ return MAGIC_NUMBER_OFFSET - (ms / UNIT_SIZE | 0);
+ }
+
+ function expirationTimeToMs(expirationTime) {
+ return (MAGIC_NUMBER_OFFSET - expirationTime) * UNIT_SIZE;
+ }
+
+ function ceiling(num, precision) {
+ return ((num / precision | 0) + 1) * precision;
+ }
+
+ function computeExpirationBucket(currentTime, expirationInMs, bucketSizeMs) {
+ return MAGIC_NUMBER_OFFSET - ceiling(MAGIC_NUMBER_OFFSET - currentTime + expirationInMs / UNIT_SIZE, bucketSizeMs / UNIT_SIZE);
+ }
+
+ var LOW_PRIORITY_EXPIRATION = 5000;
+ var LOW_PRIORITY_BATCH_SIZE = 250;
+
+ function computeAsyncExpiration(currentTime) {
+ return computeExpirationBucket(currentTime, LOW_PRIORITY_EXPIRATION, LOW_PRIORITY_BATCH_SIZE);
+ }
+
+ var HIGH_PRIORITY_EXPIRATION = 500;
+ var HIGH_PRIORITY_BATCH_SIZE = 100;
+
+ function computeInteractiveExpiration(currentTime) {
+ return computeExpirationBucket(currentTime, HIGH_PRIORITY_EXPIRATION, HIGH_PRIORITY_BATCH_SIZE);
+ }
+
+ var NoContext = 0;
+ var ConcurrentMode = 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.elementType = null;
+ this.type = null;
+ this.stateNode = null;
+ this.return = null;
+ this.child = null;
+ this.sibling = null;
+ this.index = 0;
+ this.ref = null;
+ this.pendingProps = pendingProps;
+ this.memoizedProps = null;
+ this.updateQueue = null;
+ this.memoizedState = null;
+ this.contextDependencies = null;
+ this.mode = mode;
+ this.effectTag = NoEffect;
+ this.nextEffect = null;
+ this.firstEffect = null;
+ this.lastEffect = null;
+ this.expirationTime = NoWork;
+ this.childExpirationTime = NoWork;
+ this.alternate = null;
+
+ if (enableProfilerTimer) {
+ this.actualDuration = Number.NaN;
+ this.actualStartTime = Number.NaN;
+ this.selfBaseDuration = Number.NaN;
+ this.treeBaseDuration = Number.NaN;
+ this.actualDuration = 0;
+ this.actualStartTime = -1;
+ this.selfBaseDuration = 0;
+ this.treeBaseDuration = 0;
+ }
+
+ {
+ this._debugID = debugCounter++;
+ this._debugSource = null;
+ this._debugOwner = null;
+ this._debugIsCurrentlyTiming = false;
+
+ if (!hasBadMapPolyfill && typeof Object.preventExtensions === "function") {
+ Object.preventExtensions(this);
+ }
+ }
+ }
+
+ var createFiber = function createFiber(tag, pendingProps, key, mode) {
+ return new FiberNode(tag, pendingProps, key, mode);
+ };
+
+ function shouldConstruct(Component) {
+ var prototype = Component.prototype;
+ return !!(prototype && prototype.isReactComponent);
+ }
+
+ function isSimpleFunctionComponent(type) {
+ return typeof type === "function" && !shouldConstruct(type) && type.defaultProps === undefined;
+ }
+
+ function resolveLazyComponentTag(Component) {
+ if (typeof Component === "function") {
+ return shouldConstruct(Component) ? ClassComponent : FunctionComponent;
+ } else if (Component !== undefined && Component !== null) {
+ var $$typeof = Component.$$typeof;
+
+ if ($$typeof === REACT_FORWARD_REF_TYPE) {
+ return ForwardRef;
+ }
+
+ if ($$typeof === REACT_MEMO_TYPE) {
+ return MemoComponent;
+ }
+ }
+
+ return IndeterminateComponent;
+ }
+
+ function createWorkInProgress(current, pendingProps, expirationTime) {
+ var workInProgress = current.alternate;
+
+ if (workInProgress === null) {
+ workInProgress = createFiber(current.tag, pendingProps, current.key, current.mode);
+ workInProgress.elementType = current.elementType;
+ workInProgress.type = current.type;
+ workInProgress.stateNode = current.stateNode;
+ {
+ workInProgress._debugID = current._debugID;
+ workInProgress._debugSource = current._debugSource;
+ workInProgress._debugOwner = current._debugOwner;
+ }
+ workInProgress.alternate = current;
+ current.alternate = workInProgress;
+ } else {
+ workInProgress.pendingProps = pendingProps;
+ workInProgress.effectTag = NoEffect;
+ workInProgress.nextEffect = null;
+ workInProgress.firstEffect = null;
+ workInProgress.lastEffect = null;
+
+ if (enableProfilerTimer) {
+ workInProgress.actualDuration = 0;
+ workInProgress.actualStartTime = -1;
+ }
+ }
+
+ workInProgress.childExpirationTime = current.childExpirationTime;
+ workInProgress.expirationTime = current.expirationTime;
+ workInProgress.child = current.child;
+ workInProgress.memoizedProps = current.memoizedProps;
+ workInProgress.memoizedState = current.memoizedState;
+ workInProgress.updateQueue = current.updateQueue;
+ workInProgress.contextDependencies = current.contextDependencies;
+ workInProgress.sibling = current.sibling;
+ workInProgress.index = current.index;
+ workInProgress.ref = current.ref;
+
+ if (enableProfilerTimer) {
+ workInProgress.selfBaseDuration = current.selfBaseDuration;
+ workInProgress.treeBaseDuration = current.treeBaseDuration;
+ }
+
+ return workInProgress;
+ }
+
+ function createHostRootFiber(isConcurrent) {
+ var mode = isConcurrent ? ConcurrentMode | StrictMode : NoContext;
+
+ if (enableProfilerTimer && isDevToolsPresent) {
+ mode |= ProfileMode;
+ }
+
+ return createFiber(HostRoot, null, null, mode);
+ }
+
+ function createFiberFromTypeAndProps(type, key, pendingProps, owner, mode, expirationTime) {
+ var fiber = void 0;
+ var fiberTag = IndeterminateComponent;
+ var resolvedType = type;
+
+ if (typeof type === "function") {
+ if (shouldConstruct(type)) {
+ fiberTag = ClassComponent;
+ }
+ } else if (typeof type === "string") {
+ fiberTag = HostComponent;
+ } else {
+ getTag: switch (type) {
+ case REACT_FRAGMENT_TYPE:
+ return createFiberFromFragment(pendingProps.children, mode, expirationTime, key);
+
+ case REACT_CONCURRENT_MODE_TYPE:
+ return createFiberFromMode(pendingProps, mode | ConcurrentMode | StrictMode, expirationTime, key);
+
+ case REACT_STRICT_MODE_TYPE:
+ return createFiberFromMode(pendingProps, mode | StrictMode, expirationTime, key);
+
+ case REACT_PROFILER_TYPE:
+ return createFiberFromProfiler(pendingProps, mode, expirationTime, key);
+
+ case REACT_SUSPENSE_TYPE:
+ return createFiberFromSuspense(pendingProps, mode, expirationTime, key);
+
+ default:
+ {
+ if (typeof type === "object" && type !== null) {
+ switch (type.$$typeof) {
+ case REACT_PROVIDER_TYPE:
+ fiberTag = ContextProvider;
+ break getTag;
+
+ case REACT_CONTEXT_TYPE:
+ fiberTag = ContextConsumer;
+ break getTag;
+
+ case REACT_FORWARD_REF_TYPE:
+ fiberTag = ForwardRef;
+ break getTag;
+
+ case REACT_MEMO_TYPE:
+ fiberTag = MemoComponent;
+ break getTag;
+
+ case REACT_LAZY_TYPE:
+ fiberTag = LazyComponent;
+ resolvedType = null;
+ break getTag;
+ }
+ }
+
+ var info = "";
+ {
+ if (type === undefined || typeof type === "object" && type !== null && Object.keys(type).length === 0) {
+ info += " You likely forgot to export your component from the file " + "it's defined in, or you might have mixed up default and " + "named imports.";
+ }
+
+ var ownerName = owner ? getComponentName(owner.type) : null;
+
+ if (ownerName) {
+ info += "\n\nCheck the render method of `" + ownerName + "`.";
+ }
+ }
+ 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);
+ }
+ }
+ }
+
+ fiber = createFiber(fiberTag, pendingProps, key, mode);
+ fiber.elementType = type;
+ fiber.type = resolvedType;
+ fiber.expirationTime = expirationTime;
+ return fiber;
+ }
+
+ function createFiberFromElement(element, mode, expirationTime) {
+ var owner = null;
+ {
+ owner = element._owner;
+ }
+ var type = element.type;
+ var key = element.key;
+ var pendingProps = element.props;
+ var fiber = createFiberFromTypeAndProps(type, key, pendingProps, owner, mode, expirationTime);
+ {
+ fiber._debugSource = element._source;
+ fiber._debugOwner = element._owner;
+ }
+ return fiber;
+ }
+
+ function createFiberFromFragment(elements, mode, expirationTime, key) {
+ var fiber = createFiber(Fragment, elements, key, mode);
+ fiber.expirationTime = expirationTime;
+ return fiber;
+ }
+
+ function createFiberFromProfiler(pendingProps, mode, expirationTime, key) {
+ {
+ if (typeof pendingProps.id !== "string" || typeof pendingProps.onRender !== "function") {
+ warningWithoutStack$1(false, 'Profiler must specify an "id" string and "onRender" function as props');
+ }
+ }
+ var fiber = createFiber(Profiler, pendingProps, key, mode | ProfileMode);
+ fiber.elementType = REACT_PROFILER_TYPE;
+ fiber.type = REACT_PROFILER_TYPE;
+ fiber.expirationTime = expirationTime;
+ return fiber;
+ }
+
+ function createFiberFromMode(pendingProps, mode, expirationTime, key) {
+ var fiber = createFiber(Mode, pendingProps, key, mode);
+ var type = (mode & ConcurrentMode) === NoContext ? REACT_STRICT_MODE_TYPE : REACT_CONCURRENT_MODE_TYPE;
+ fiber.elementType = type;
+ fiber.type = type;
+ fiber.expirationTime = expirationTime;
+ return fiber;
+ }
+
+ function createFiberFromSuspense(pendingProps, mode, expirationTime, key) {
+ var fiber = createFiber(SuspenseComponent, pendingProps, key, mode);
+ var type = REACT_SUSPENSE_TYPE;
+ fiber.elementType = type;
+ fiber.type = 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.elementType = "DELETED";
+ fiber.type = "DELETED";
+ return fiber;
+ }
+
+ function createFiberFromPortal(portal, mode, expirationTime) {
+ var pendingProps = portal.children !== null ? portal.children : [];
+ var fiber = createFiber(HostPortal, pendingProps, portal.key, mode);
+ fiber.expirationTime = expirationTime;
+ fiber.stateNode = {
+ containerInfo: portal.containerInfo,
+ pendingChildren: null,
+ implementation: portal.implementation
+ };
+ return fiber;
+ }
+
+ function assignFiberPropertiesInDEV(target, source) {
+ if (target === null) {
+ target = createFiber(IndeterminateComponent, null, null, NoContext);
+ }
+
+ target.tag = source.tag;
+ target.key = source.key;
+ target.elementType = source.elementType;
+ target.type = source.type;
+ target.stateNode = source.stateNode;
+ target.return = source.return;
+ target.child = source.child;
+ target.sibling = source.sibling;
+ target.index = source.index;
+ target.ref = source.ref;
+ target.pendingProps = source.pendingProps;
+ target.memoizedProps = source.memoizedProps;
+ target.updateQueue = source.updateQueue;
+ target.memoizedState = source.memoizedState;
+ target.contextDependencies = source.contextDependencies;
+ target.mode = source.mode;
+ target.effectTag = source.effectTag;
+ target.nextEffect = source.nextEffect;
+ target.firstEffect = source.firstEffect;
+ target.lastEffect = source.lastEffect;
+ target.expirationTime = source.expirationTime;
+ target.childExpirationTime = source.childExpirationTime;
+ target.alternate = source.alternate;
+
+ if (enableProfilerTimer) {
+ target.actualDuration = source.actualDuration;
+ target.actualStartTime = source.actualStartTime;
+ target.selfBaseDuration = source.selfBaseDuration;
+ target.treeBaseDuration = source.treeBaseDuration;
+ }
+
+ target._debugID = source._debugID;
+ target._debugSource = source._debugSource;
+ target._debugOwner = source._debugOwner;
+ target._debugIsCurrentlyTiming = source._debugIsCurrentlyTiming;
+ return target;
+ }
+
+ function createFiberRoot(containerInfo, isConcurrent, hydrate) {
+ var uninitializedFiber = createHostRootFiber(isConcurrent);
+ var root = void 0;
+
+ if (enableSchedulerTracing) {
+ root = {
+ current: uninitializedFiber,
+ containerInfo: containerInfo,
+ pendingChildren: null,
+ earliestPendingTime: NoWork,
+ latestPendingTime: NoWork,
+ earliestSuspendedTime: NoWork,
+ latestSuspendedTime: NoWork,
+ latestPingedTime: NoWork,
+ pingCache: null,
+ didError: false,
+ pendingCommitExpirationTime: NoWork,
+ finishedWork: null,
+ timeoutHandle: noTimeout,
+ context: null,
+ pendingContext: null,
+ hydrate: hydrate,
+ nextExpirationTimeToWorkOn: NoWork,
+ expirationTime: NoWork,
+ firstBatch: null,
+ nextScheduledRoot: null,
+ interactionThreadID: tracing.unstable_getThreadID(),
+ memoizedInteractions: new Set(),
+ pendingInteractionMap: new Map()
+ };
+ } else {
+ root = {
+ current: uninitializedFiber,
+ containerInfo: containerInfo,
+ pendingChildren: null,
+ pingCache: null,
+ earliestPendingTime: NoWork,
+ latestPendingTime: NoWork,
+ earliestSuspendedTime: NoWork,
+ latestSuspendedTime: NoWork,
+ latestPingedTime: NoWork,
+ didError: false,
+ pendingCommitExpirationTime: NoWork,
+ finishedWork: null,
+ timeoutHandle: noTimeout,
+ context: null,
+ pendingContext: null,
+ hydrate: hydrate,
+ nextExpirationTimeToWorkOn: NoWork,
+ expirationTime: NoWork,
+ firstBatch: null,
+ nextScheduledRoot: null
+ };
+ }
+
+ uninitializedFiber.stateNode = root;
+ return root;
+ }
+
+ var lowPriorityWarning = function lowPriorityWarning() {};
+
+ {
+ var printWarning = function printWarning(format) {
+ for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+ args[_key - 1] = arguments[_key];
+ }
+
+ var argIndex = 0;
+ var message = "Warning: " + format.replace(/%s/g, function () {
+ return args[argIndex++];
+ });
+
+ if (typeof console !== "undefined") {
+ console.warn(message);
+ }
+
+ try {
+ throw new Error(message);
+ } catch (x) {}
+ };
+
+ lowPriorityWarning = function lowPriorityWarning(condition, format) {
+ if (format === undefined) {
+ throw new Error("`lowPriorityWarning(condition, format, ...args)` requires a warning " + "message argument");
+ }
+
+ if (!condition) {
+ for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
+ args[_key2 - 2] = arguments[_key2];
+ }
+
+ printWarning.apply(undefined, [format].concat(args));
+ }
+ };
+ }
+ var lowPriorityWarning$1 = lowPriorityWarning;
+ var ReactStrictModeWarnings = {
+ 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 lifecyclesWarningMessages = [];
+ 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.type) || "Component");
+ didWarnAboutUnsafeLifecycles.add(fiber.type);
+ });
+ var formatted = lifecycle.replace("UNSAFE_", "");
+ var suggestion = LIFECYCLE_SUGGESTIONS[lifecycle];
+ var sortedComponentNames = setToSortedString(componentNames);
+ lifecyclesWarningMessages.push(formatted + ": Please update the following components to use " + (suggestion + " instead: " + sortedComponentNames));
+ }
+ });
+
+ if (lifecyclesWarningMessages.length > 0) {
+ var strictRootComponentStack = getStackByFiberInDevAndProd(strictRoot);
+ warningWithoutStack$1(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, lifecyclesWarningMessages.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.type) || "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.type) || "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.type) || "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) {
+ warningWithoutStack$1(false, "Expected to find a StrictMode component in a strict mode tree. " + "This error is likely caused by a bug in React. Please file an issue.");
+ return;
+ }
+
+ if (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) {
+ warningWithoutStack$1(false, "Expected to find a StrictMode component in a strict mode tree. " + "This error is likely caused by a bug in React. Please file an issue.");
+ return;
+ }
+
+ if (didWarnAboutLegacyContext.has(fiber.type)) {
+ return;
+ }
+
+ var warningsForRoot = pendingLegacyContextWarning.get(strictRoot);
+
+ if (fiber.type.contextTypes != null || fiber.type.childContextTypes != null || instance !== null && typeof instance.getChildContext === "function") {
+ if (warningsForRoot === undefined) {
+ warningsForRoot = [];
+ pendingLegacyContextWarning.set(strictRoot, warningsForRoot);
+ }
+
+ warningsForRoot.push(fiber);
+ }
+ };
+
+ ReactStrictModeWarnings.flushLegacyContextWarning = function () {
+ pendingLegacyContextWarning.forEach(function (fiberArray, strictRoot) {
+ var uniqueNames = new Set();
+ fiberArray.forEach(function (fiber) {
+ uniqueNames.add(getComponentName(fiber.type) || "Component");
+ didWarnAboutLegacyContext.add(fiber.type);
+ });
+ var sortedNames = setToSortedString(uniqueNames);
+ var strictRootComponentStack = getStackByFiberInDevAndProd(strictRoot);
+ warningWithoutStack$1(false, "Legacy context API has been detected within a strict-mode tree: %s" + "\n\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;
+ }
+ }
+ }
+
+ findNextExpirationTimeToWorkOn(expirationTime, root);
+ }
+
+ function markCommittedPriorityLevels(root, earliestRemainingTime) {
+ root.didError = false;
+
+ if (earliestRemainingTime === NoWork) {
+ root.earliestPendingTime = NoWork;
+ root.latestPendingTime = NoWork;
+ root.earliestSuspendedTime = NoWork;
+ root.latestSuspendedTime = NoWork;
+ root.latestPingedTime = NoWork;
+ findNextExpirationTimeToWorkOn(NoWork, root);
+ return;
+ }
+
+ if (earliestRemainingTime < root.latestPingedTime) {
+ root.latestPingedTime = NoWork;
+ }
+
+ 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);
+ findNextExpirationTimeToWorkOn(NoWork, root);
+ return;
+ }
+
+ var latestSuspendedTime = root.latestSuspendedTime;
+
+ if (earliestRemainingTime < latestSuspendedTime) {
+ root.earliestSuspendedTime = NoWork;
+ root.latestSuspendedTime = NoWork;
+ root.latestPingedTime = NoWork;
+ markPendingPriorityLevel(root, earliestRemainingTime);
+ findNextExpirationTimeToWorkOn(NoWork, root);
+ return;
+ }
+
+ if (earliestRemainingTime > earliestSuspendedTime) {
+ markPendingPriorityLevel(root, earliestRemainingTime);
+ findNextExpirationTimeToWorkOn(NoWork, root);
+ return;
+ }
+
+ findNextExpirationTimeToWorkOn(NoWork, root);
+ }
+
+ function hasLowerPriorityWork(root, erroredExpirationTime) {
+ var latestPendingTime = root.latestPendingTime;
+ var latestSuspendedTime = root.latestSuspendedTime;
+ var latestPingedTime = root.latestPingedTime;
+ return latestPendingTime !== NoWork && latestPendingTime < erroredExpirationTime || latestSuspendedTime !== NoWork && latestSuspendedTime < erroredExpirationTime || latestPingedTime !== NoWork && latestPingedTime < erroredExpirationTime;
+ }
+
+ function isPriorityLevelSuspended(root, expirationTime) {
+ var earliestSuspendedTime = root.earliestSuspendedTime;
+ var latestSuspendedTime = root.latestSuspendedTime;
+ return earliestSuspendedTime !== NoWork && expirationTime <= earliestSuspendedTime && expirationTime >= latestSuspendedTime;
+ }
+
+ function markSuspendedPriorityLevel(root, suspendedTime) {
+ root.didError = false;
+ clearPing(root, suspendedTime);
+ 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 earliestSuspendedTime = root.earliestSuspendedTime;
+ var latestSuspendedTime = root.latestSuspendedTime;
+
+ if (earliestSuspendedTime === NoWork) {
+ root.earliestSuspendedTime = root.latestSuspendedTime = suspendedTime;
+ } else {
+ if (earliestSuspendedTime < suspendedTime) {
+ root.earliestSuspendedTime = suspendedTime;
+ } else if (latestSuspendedTime > suspendedTime) {
+ root.latestSuspendedTime = suspendedTime;
+ }
+ }
+
+ findNextExpirationTimeToWorkOn(suspendedTime, root);
+ }
+
+ function markPingedPriorityLevel(root, pingedTime) {
+ root.didError = false;
+ var latestPingedTime = root.latestPingedTime;
+
+ if (latestPingedTime === NoWork || latestPingedTime > pingedTime) {
+ root.latestPingedTime = pingedTime;
+ }
+
+ findNextExpirationTimeToWorkOn(pingedTime, root);
+ }
+
+ function clearPing(root, completedTime) {
+ var latestPingedTime = root.latestPingedTime;
+
+ if (latestPingedTime >= completedTime) {
+ root.latestPingedTime = NoWork;
+ }
+ }
+
+ function findEarliestOutstandingPriorityLevel(root, renderExpirationTime) {
+ var earliestExpirationTime = renderExpirationTime;
+ var earliestPendingTime = root.earliestPendingTime;
+ var earliestSuspendedTime = root.earliestSuspendedTime;
+
+ if (earliestPendingTime > earliestExpirationTime) {
+ earliestExpirationTime = earliestPendingTime;
+ }
+
+ if (earliestSuspendedTime > earliestExpirationTime) {
+ earliestExpirationTime = earliestSuspendedTime;
+ }
+
+ return earliestExpirationTime;
+ }
+
+ function didExpireAtExpirationTime(root, currentTime) {
+ var expirationTime = root.expirationTime;
+
+ if (expirationTime !== NoWork && currentTime <= expirationTime) {
+ root.nextExpirationTimeToWorkOn = currentTime;
+ }
+ }
+
+ function findNextExpirationTimeToWorkOn(completedExpirationTime, root) {
+ var earliestSuspendedTime = root.earliestSuspendedTime;
+ var latestSuspendedTime = root.latestSuspendedTime;
+ var earliestPendingTime = root.earliestPendingTime;
+ var latestPingedTime = root.latestPingedTime;
+ var nextExpirationTimeToWorkOn = earliestPendingTime !== NoWork ? earliestPendingTime : latestPingedTime;
+
+ if (nextExpirationTimeToWorkOn === NoWork && (completedExpirationTime === NoWork || latestSuspendedTime < completedExpirationTime)) {
+ nextExpirationTimeToWorkOn = latestSuspendedTime;
+ }
+
+ var expirationTime = nextExpirationTimeToWorkOn;
+
+ if (expirationTime !== NoWork && earliestSuspendedTime > expirationTime) {
+ expirationTime = earliestSuspendedTime;
+ }
+
+ root.nextExpirationTimeToWorkOn = nextExpirationTimeToWorkOn;
+ root.expirationTime = expirationTime;
+ }
+
+ var warning = warningWithoutStack$1;
+ {
+ warning = function warning(condition, format) {
+ if (condition) {
+ return;
+ }
+
+ var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+ var stack = ReactDebugCurrentFrame.getStackAddendum();
+
+ for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+ args[_key - 2] = arguments[_key];
+ }
+
+ warningWithoutStack$1.apply(undefined, [false, format + "%s"].concat(args, [stack]));
+ };
+ }
+ var warning$1 = warning;
+
+ function is(x, y) {
+ return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y;
+ }
+
+ var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+ function shallowEqual(objA, objB) {
+ if (is(objA, objB)) {
+ return true;
+ }
+
+ if (typeof objA !== "object" || objA === null || typeof objB !== "object" || objB === null) {
+ return false;
+ }
+
+ var keysA = Object.keys(objA);
+ var keysB = Object.keys(objB);
+
+ if (keysA.length !== keysB.length) {
+ return false;
+ }
+
+ for (var i = 0; i < keysA.length; i++) {
+ if (!hasOwnProperty.call(objB, keysA[i]) || !is(objA[keysA[i]], objB[keysA[i]])) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ function resolveDefaultProps(Component, baseProps) {
+ if (Component && Component.defaultProps) {
+ var props = _extends({}, baseProps);
+
+ var defaultProps = Component.defaultProps;
+
+ for (var propName in defaultProps) {
+ if (props[propName] === undefined) {
+ props[propName] = defaultProps[propName];
+ }
+ }
+
+ return props;
+ }
+
+ return baseProps;
+ }
+
+ function readLazyComponentType(lazyComponent) {
+ var status = lazyComponent._status;
+ var result = lazyComponent._result;
+
+ switch (status) {
+ case Resolved:
+ {
+ var Component = result;
+ return Component;
+ }
+
+ case Rejected:
+ {
+ var error = result;
+ throw error;
+ }
+
+ case Pending:
+ {
+ var thenable = result;
+ throw thenable;
+ }
+
+ default:
+ {
+ lazyComponent._status = Pending;
+ var ctor = lazyComponent._ctor;
+
+ var _thenable = ctor();
+
+ _thenable.then(function (moduleObject) {
+ if (lazyComponent._status === Pending) {
+ var defaultExport = moduleObject.default;
+ {
+ if (defaultExport === undefined) {
+ warning$1(false, "lazy: Expected the result of a dynamic import() call. " + "Instead received: %s\n\nYour code should look like: \n " + "const MyComponent = lazy(() => import('./MyComponent'))", moduleObject);
+ }
+ }
+ lazyComponent._status = Resolved;
+ lazyComponent._result = defaultExport;
+ }
+ }, function (error) {
+ if (lazyComponent._status === Pending) {
+ lazyComponent._status = Rejected;
+ lazyComponent._result = error;
+ }
+ });
+
+ switch (lazyComponent._status) {
+ case Resolved:
+ return lazyComponent._result;
+
+ case Rejected:
+ throw lazyComponent._result;
+ }
+
+ lazyComponent._result = _thenable;
+ throw _thenable;
+ }
+ }
+ }
+
+ var fakeInternalInstance = {};
+ var isArray$1 = Array.isArray;
+ var emptyRefsObject = new React.Component().refs;
+ var didWarnAboutStateAssignmentForComponent = void 0;
+ var didWarnAboutUninitializedState = void 0;
+ var didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate = void 0;
+ var didWarnAboutLegacyLifecyclesAndDerivedState = void 0;
+ var didWarnAboutUndefinedDerivedState = void 0;
+ var warnOnUndefinedDerivedState = void 0;
+ var warnOnInvalidCallback = void 0;
+ var didWarnAboutDirectlyAssigningPropsToState = void 0;
+ var didWarnAboutContextTypeAndContextTypes = void 0;
+ var didWarnAboutInvalidateContextType = void 0;
+ {
+ didWarnAboutStateAssignmentForComponent = new Set();
+ didWarnAboutUninitializedState = new Set();
+ didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate = new Set();
+ didWarnAboutLegacyLifecyclesAndDerivedState = new Set();
+ didWarnAboutDirectlyAssigningPropsToState = new Set();
+ didWarnAboutUndefinedDerivedState = new Set();
+ didWarnAboutContextTypeAndContextTypes = new Set();
+ didWarnAboutInvalidateContextType = new Set();
+ var didWarnOnInvalidCallback = new Set();
+
+ warnOnInvalidCallback = function warnOnInvalidCallback(callback, callerName) {
+ if (callback === null || typeof callback === "function") {
+ return;
+ }
+
+ var key = callerName + "_" + callback;
+
+ if (!didWarnOnInvalidCallback.has(key)) {
+ didWarnOnInvalidCallback.add(key);
+ warningWithoutStack$1(false, "%s(...): Expected the last optional `callback` argument to be a " + "function. Instead received: %s.", callerName, callback);
+ }
+ };
+
+ warnOnUndefinedDerivedState = function warnOnUndefinedDerivedState(type, partialState) {
+ if (partialState === undefined) {
+ var componentName = getComponentName(type) || "Component";
+
+ if (!didWarnAboutUndefinedDerivedState.has(componentName)) {
+ didWarnAboutUndefinedDerivedState.add(componentName);
+ warningWithoutStack$1(false, "%s.getDerivedStateFromProps(): A valid state object (or null) must be returned. " + "You have returned undefined.", componentName);
+ }
+ }
+ };
+
+ Object.defineProperty(fakeInternalInstance, "_processChildContext", {
+ enumerable: false,
+ value: function value() {
+ 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, ctor, getDerivedStateFromProps, nextProps) {
+ var prevState = workInProgress.memoizedState;
+ {
+ if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
+ getDerivedStateFromProps(nextProps, prevState);
+ }
+ }
+ var partialState = getDerivedStateFromProps(nextProps, prevState);
+ {
+ warnOnUndefinedDerivedState(ctor, partialState);
+ }
+ var memoizedState = partialState === null || partialState === undefined ? prevState : _extends({}, prevState, partialState);
+ workInProgress.memoizedState = memoizedState;
+ var updateQueue = workInProgress.updateQueue;
+
+ if (updateQueue !== null && workInProgress.expirationTime === NoWork) {
+ updateQueue.baseState = memoizedState;
+ }
+ }
+
+ var classComponentUpdater = {
+ isMounted: isMounted,
+ enqueueSetState: function enqueueSetState(inst, payload, callback) {
+ var fiber = get$1(inst);
+ var currentTime = requestCurrentTime();
+ var expirationTime = computeExpirationForFiber(currentTime, fiber);
+ var update = createUpdate(expirationTime);
+ update.payload = payload;
+
+ if (callback !== undefined && callback !== null) {
+ {
+ warnOnInvalidCallback(callback, "setState");
+ }
+ update.callback = callback;
+ }
+
+ flushPassiveEffects();
+ enqueueUpdate(fiber, update);
+ scheduleWork(fiber, expirationTime);
+ },
+ enqueueReplaceState: function enqueueReplaceState(inst, payload, callback) {
+ var fiber = get$1(inst);
+ var currentTime = requestCurrentTime();
+ 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;
+ }
+
+ flushPassiveEffects();
+ enqueueUpdate(fiber, update);
+ scheduleWork(fiber, expirationTime);
+ },
+ enqueueForceUpdate: function enqueueForceUpdate(inst, callback) {
+ var fiber = get$1(inst);
+ var currentTime = requestCurrentTime();
+ var expirationTime = computeExpirationForFiber(currentTime, fiber);
+ var update = createUpdate(expirationTime);
+ update.tag = ForceUpdate;
+
+ if (callback !== undefined && callback !== null) {
+ {
+ warnOnInvalidCallback(callback, "forceUpdate");
+ }
+ update.callback = callback;
+ }
+
+ flushPassiveEffects();
+ enqueueUpdate(fiber, update);
+ scheduleWork(fiber, expirationTime);
+ }
+ };
+
+ function checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext) {
+ var instance = workInProgress.stateNode;
+
+ if (typeof instance.shouldComponentUpdate === "function") {
+ startPhaseTimer(workInProgress, "shouldComponentUpdate");
+ var shouldUpdate = instance.shouldComponentUpdate(newProps, newState, nextContext);
+ stopPhaseTimer();
+ {
+ !(shouldUpdate !== undefined) ? warningWithoutStack$1(false, "%s.shouldComponentUpdate(): Returned undefined instead of a " + "boolean value. Make sure to return true or false.", getComponentName(ctor) || "Component") : void 0;
+ }
+ return shouldUpdate;
+ }
+
+ if (ctor.prototype && ctor.prototype.isPureReactComponent) {
+ return !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState);
+ }
+
+ return true;
+ }
+
+ function checkClassInstance(workInProgress, ctor, newProps) {
+ var instance = workInProgress.stateNode;
+ {
+ var name = getComponentName(ctor) || "Component";
+ var renderPresent = instance.render;
+
+ if (!renderPresent) {
+ if (ctor.prototype && typeof ctor.prototype.render === "function") {
+ warningWithoutStack$1(false, "%s(...): No `render` method found on the returned component " + "instance: did you accidentally return an object from the constructor?", name);
+ } else {
+ warningWithoutStack$1(false, "%s(...): No `render` method found on the returned component " + "instance: you may have forgotten to define `render`.", name);
+ }
+ }
+
+ var noGetInitialStateOnES6 = !instance.getInitialState || instance.getInitialState.isReactClassApproved || instance.state;
+ !noGetInitialStateOnES6 ? warningWithoutStack$1(false, "getInitialState was defined on %s, a plain JavaScript class. " + "This is only supported for classes created using React.createClass. " + "Did you mean to define a state property instead?", name) : void 0;
+ var noGetDefaultPropsOnES6 = !instance.getDefaultProps || instance.getDefaultProps.isReactClassApproved;
+ !noGetDefaultPropsOnES6 ? warningWithoutStack$1(false, "getDefaultProps was defined on %s, a plain JavaScript class. " + "This is only supported for classes created using React.createClass. " + "Use a static property to define defaultProps instead.", name) : void 0;
+ var noInstancePropTypes = !instance.propTypes;
+ !noInstancePropTypes ? warningWithoutStack$1(false, "propTypes was defined as an instance property on %s. Use a static " + "property to define propTypes instead.", name) : void 0;
+ var noInstanceContextType = !instance.contextType;
+ !noInstanceContextType ? warningWithoutStack$1(false, "contextType was defined as an instance property on %s. Use a static " + "property to define contextType instead.", name) : void 0;
+ var noInstanceContextTypes = !instance.contextTypes;
+ !noInstanceContextTypes ? warningWithoutStack$1(false, "contextTypes was defined as an instance property on %s. Use a static " + "property to define contextTypes instead.", name) : void 0;
+
+ if (ctor.contextType && ctor.contextTypes && !didWarnAboutContextTypeAndContextTypes.has(ctor)) {
+ didWarnAboutContextTypeAndContextTypes.add(ctor);
+ warningWithoutStack$1(false, "%s declares both contextTypes and contextType static properties. " + "The legacy contextTypes property will be ignored.", name);
+ }
+
+ var noComponentShouldUpdate = typeof instance.componentShouldUpdate !== "function";
+ !noComponentShouldUpdate ? warningWithoutStack$1(false, "%s has a method called " + "componentShouldUpdate(). Did you mean shouldComponentUpdate()? " + "The name is phrased as a question because the function is " + "expected to return a value.", name) : void 0;
+
+ if (ctor.prototype && ctor.prototype.isPureReactComponent && typeof instance.shouldComponentUpdate !== "undefined") {
+ warningWithoutStack$1(false, "%s has a method called shouldComponentUpdate(). " + "shouldComponentUpdate should not be used when extending React.PureComponent. " + "Please extend React.Component if shouldComponentUpdate is used.", getComponentName(ctor) || "A pure component");
+ }
+
+ var noComponentDidUnmount = typeof instance.componentDidUnmount !== "function";
+ !noComponentDidUnmount ? warningWithoutStack$1(false, "%s has a method called " + "componentDidUnmount(). But there is no such lifecycle method. " + "Did you mean componentWillUnmount()?", name) : void 0;
+ var noComponentDidReceiveProps = typeof instance.componentDidReceiveProps !== "function";
+ !noComponentDidReceiveProps ? warningWithoutStack$1(false, "%s has a method called " + "componentDidReceiveProps(). But there is no such lifecycle method. " + "If you meant to update the state in response to changing props, " + "use componentWillReceiveProps(). If you meant to fetch data or " + "run side-effects or mutations after React has updated the UI, use componentDidUpdate().", name) : void 0;
+ var noComponentWillRecieveProps = typeof instance.componentWillRecieveProps !== "function";
+ !noComponentWillRecieveProps ? warningWithoutStack$1(false, "%s has a method called " + "componentWillRecieveProps(). Did you mean componentWillReceiveProps()?", name) : void 0;
+ var noUnsafeComponentWillRecieveProps = typeof instance.UNSAFE_componentWillRecieveProps !== "function";
+ !noUnsafeComponentWillRecieveProps ? warningWithoutStack$1(false, "%s has a method called " + "UNSAFE_componentWillRecieveProps(). Did you mean UNSAFE_componentWillReceiveProps()?", name) : void 0;
+ var hasMutatedProps = instance.props !== newProps;
+ !(instance.props === undefined || !hasMutatedProps) ? warningWithoutStack$1(false, "%s(...): When calling super() in `%s`, make sure to pass " + "up the same props that your component's constructor was passed.", name, name) : void 0;
+ var noInstanceDefaultProps = !instance.defaultProps;
+ !noInstanceDefaultProps ? warningWithoutStack$1(false, "Setting defaultProps as an instance property on %s is not supported and will be ignored." + " Instead, define defaultProps as a static property on %s.", name, name) : void 0;
+
+ if (typeof instance.getSnapshotBeforeUpdate === "function" && typeof instance.componentDidUpdate !== "function" && !didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.has(ctor)) {
+ didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.add(ctor);
+ warningWithoutStack$1(false, "%s: getSnapshotBeforeUpdate() should be used with componentDidUpdate(). " + "This component defines getSnapshotBeforeUpdate() only.", getComponentName(ctor));
+ }
+
+ var noInstanceGetDerivedStateFromProps = typeof instance.getDerivedStateFromProps !== "function";
+ !noInstanceGetDerivedStateFromProps ? warningWithoutStack$1(false, "%s: getDerivedStateFromProps() is defined as an instance method " + "and will be ignored. Instead, declare it as a static method.", name) : void 0;
+ var noInstanceGetDerivedStateFromCatch = typeof instance.getDerivedStateFromError !== "function";
+ !noInstanceGetDerivedStateFromCatch ? warningWithoutStack$1(false, "%s: getDerivedStateFromError() is defined as an instance method " + "and will be ignored. Instead, declare it as a static method.", name) : void 0;
+ var noStaticGetSnapshotBeforeUpdate = typeof ctor.getSnapshotBeforeUpdate !== "function";
+ !noStaticGetSnapshotBeforeUpdate ? warningWithoutStack$1(false, "%s: getSnapshotBeforeUpdate() is defined as a static method " + "and will be ignored. Instead, declare it as an instance method.", name) : void 0;
+ var _state = instance.state;
+
+ if (_state && (typeof _state !== "object" || isArray$1(_state))) {
+ warningWithoutStack$1(false, "%s.state: must be set to an object or null", name);
+ }
+
+ if (typeof instance.getChildContext === "function") {
+ !(typeof ctor.childContextTypes === "object") ? warningWithoutStack$1(false, "%s.getChildContext(): childContextTypes must be defined in order to " + "use getChildContext().", name) : void 0;
+ }
+ }
+ }
+
+ function adoptClassInstance(workInProgress, instance) {
+ instance.updater = classComponentUpdater;
+ workInProgress.stateNode = instance;
+ set(instance, workInProgress);
+ {
+ instance._reactInternalInstance = fakeInternalInstance;
+ }
+ }
+
+ function constructClassInstance(workInProgress, ctor, props, renderExpirationTime) {
+ var isLegacyContextConsumer = false;
+ var unmaskedContext = emptyContextObject;
+ var context = null;
+ var contextType = ctor.contextType;
+
+ if (typeof contextType === "object" && contextType !== null) {
+ {
+ if (contextType.$$typeof !== REACT_CONTEXT_TYPE && !didWarnAboutInvalidateContextType.has(ctor)) {
+ didWarnAboutInvalidateContextType.add(ctor);
+ warningWithoutStack$1(false, "%s defines an invalid contextType. " + "contextType should point to the Context object returned by React.createContext(). " + "Did you accidentally pass the Context.Provider instead?", getComponentName(ctor) || "Component");
+ }
+ }
+ context = _readContext(contextType);
+ } else {
+ unmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
+ var contextTypes = ctor.contextTypes;
+ isLegacyContextConsumer = contextTypes !== null && contextTypes !== undefined;
+ context = isLegacyContextConsumer ? getMaskedContext(workInProgress, unmaskedContext) : emptyContextObject;
+ }
+
+ {
+ if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
+ new ctor(props, context);
+ }
+ }
+ var instance = new ctor(props, context);
+ var state = workInProgress.memoizedState = instance.state !== null && instance.state !== undefined ? instance.state : null;
+ adoptClassInstance(workInProgress, instance);
+ {
+ if (typeof ctor.getDerivedStateFromProps === "function" && state === null) {
+ var componentName = getComponentName(ctor) || "Component";
+
+ if (!didWarnAboutUninitializedState.has(componentName)) {
+ didWarnAboutUninitializedState.add(componentName);
+ warningWithoutStack$1(false, "`%s` uses `getDerivedStateFromProps` but its initial state is " + "%s. This is not recommended. Instead, define the initial state by " + "assigning an object to `this.state` in the constructor of `%s`. " + "This ensures that `getDerivedStateFromProps` arguments have a consistent shape.", componentName, instance.state === null ? "null" : "undefined", componentName);
+ }
+ }
+
+ if (typeof ctor.getDerivedStateFromProps === "function" || typeof instance.getSnapshotBeforeUpdate === "function") {
+ var foundWillMountName = null;
+ var foundWillReceivePropsName = null;
+ var foundWillUpdateName = null;
+
+ if (typeof instance.componentWillMount === "function" && instance.componentWillMount.__suppressDeprecationWarning !== true) {
+ foundWillMountName = "componentWillMount";
+ } else if (typeof instance.UNSAFE_componentWillMount === "function") {
+ foundWillMountName = "UNSAFE_componentWillMount";
+ }
+
+ if (typeof instance.componentWillReceiveProps === "function" && instance.componentWillReceiveProps.__suppressDeprecationWarning !== true) {
+ foundWillReceivePropsName = "componentWillReceiveProps";
+ } else if (typeof instance.UNSAFE_componentWillReceiveProps === "function") {
+ foundWillReceivePropsName = "UNSAFE_componentWillReceiveProps";
+ }
+
+ if (typeof instance.componentWillUpdate === "function" && instance.componentWillUpdate.__suppressDeprecationWarning !== true) {
+ foundWillUpdateName = "componentWillUpdate";
+ } else if (typeof instance.UNSAFE_componentWillUpdate === "function") {
+ foundWillUpdateName = "UNSAFE_componentWillUpdate";
+ }
+
+ if (foundWillMountName !== null || foundWillReceivePropsName !== null || foundWillUpdateName !== null) {
+ var _componentName = getComponentName(ctor) || "Component";
+
+ var newApiName = typeof ctor.getDerivedStateFromProps === "function" ? "getDerivedStateFromProps()" : "getSnapshotBeforeUpdate()";
+
+ if (!didWarnAboutLegacyLifecyclesAndDerivedState.has(_componentName)) {
+ didWarnAboutLegacyLifecyclesAndDerivedState.add(_componentName);
+ warningWithoutStack$1(false, "Unsafe legacy lifecycles will not be called for components using new component APIs.\n\n" + "%s uses %s but also contains the following legacy lifecycles:%s%s%s\n\n" + "The above lifecycles should be removed. Learn more about this warning here:\n" + "https://fb.me/react-async-component-lifecycle-hooks", _componentName, newApiName, foundWillMountName !== null ? "\n " + foundWillMountName : "", foundWillReceivePropsName !== null ? "\n " + foundWillReceivePropsName : "", foundWillUpdateName !== null ? "\n " + foundWillUpdateName : "");
+ }
+ }
+ }
+ }
+
+ if (isLegacyContextConsumer) {
+ cacheContext(workInProgress, unmaskedContext, context);
+ }
+
+ return instance;
+ }
+
+ function callComponentWillMount(workInProgress, instance) {
+ startPhaseTimer(workInProgress, "componentWillMount");
+ var oldState = instance.state;
+
+ if (typeof instance.componentWillMount === "function") {
+ instance.componentWillMount();
+ }
+
+ if (typeof instance.UNSAFE_componentWillMount === "function") {
+ instance.UNSAFE_componentWillMount();
+ }
+
+ stopPhaseTimer();
+
+ if (oldState !== instance.state) {
+ {
+ warningWithoutStack$1(false, "%s.componentWillMount(): Assigning directly to this.state is " + "deprecated (except inside a component's " + "constructor). Use setState instead.", getComponentName(workInProgress.type) || "Component");
+ }
+ classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
+ }
+ }
+
+ function callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext) {
+ var oldState = instance.state;
+ startPhaseTimer(workInProgress, "componentWillReceiveProps");
+
+ if (typeof instance.componentWillReceiveProps === "function") {
+ instance.componentWillReceiveProps(newProps, nextContext);
+ }
+
+ if (typeof instance.UNSAFE_componentWillReceiveProps === "function") {
+ instance.UNSAFE_componentWillReceiveProps(newProps, nextContext);
+ }
+
+ stopPhaseTimer();
+
+ if (instance.state !== oldState) {
+ {
+ var componentName = getComponentName(workInProgress.type) || "Component";
+
+ if (!didWarnAboutStateAssignmentForComponent.has(componentName)) {
+ didWarnAboutStateAssignmentForComponent.add(componentName);
+ warningWithoutStack$1(false, "%s.componentWillReceiveProps(): Assigning directly to " + "this.state is deprecated (except inside a component's " + "constructor). Use setState instead.", componentName);
+ }
+ }
+ classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
+ }
+ }
+
+ function mountClassInstance(workInProgress, ctor, newProps, renderExpirationTime) {
+ {
+ checkClassInstance(workInProgress, ctor, newProps);
+ }
+ var instance = workInProgress.stateNode;
+ instance.props = newProps;
+ instance.state = workInProgress.memoizedState;
+ instance.refs = emptyRefsObject;
+ var contextType = ctor.contextType;
+
+ if (typeof contextType === "object" && contextType !== null) {
+ instance.context = _readContext(contextType);
+ } else {
+ var unmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
+ instance.context = getMaskedContext(workInProgress, unmaskedContext);
+ }
+
+ {
+ if (instance.state === newProps) {
+ var componentName = getComponentName(ctor) || "Component";
+
+ if (!didWarnAboutDirectlyAssigningPropsToState.has(componentName)) {
+ didWarnAboutDirectlyAssigningPropsToState.add(componentName);
+ warningWithoutStack$1(false, "%s: It is not recommended to assign props directly to state " + "because updates to props won't be reflected in state. " + "In most cases, it is better to use props directly.", componentName);
+ }
+ }
+
+ if (workInProgress.mode & StrictMode) {
+ ReactStrictModeWarnings.recordUnsafeLifecycleWarnings(workInProgress, instance);
+ ReactStrictModeWarnings.recordLegacyContextWarning(workInProgress, instance);
+ }
+
+ if (warnAboutDeprecatedLifecycles) {
+ ReactStrictModeWarnings.recordDeprecationWarnings(workInProgress, instance);
+ }
+ }
+ var updateQueue = workInProgress.updateQueue;
+
+ if (updateQueue !== null) {
+ processUpdateQueue(workInProgress, updateQueue, newProps, instance, renderExpirationTime);
+ instance.state = workInProgress.memoizedState;
+ }
+
+ var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+
+ if (typeof getDerivedStateFromProps === "function") {
+ applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, newProps);
+ instance.state = workInProgress.memoizedState;
+ }
+
+ if (typeof ctor.getDerivedStateFromProps !== "function" && typeof instance.getSnapshotBeforeUpdate !== "function" && (typeof instance.UNSAFE_componentWillMount === "function" || typeof instance.componentWillMount === "function")) {
+ callComponentWillMount(workInProgress, instance);
+ updateQueue = workInProgress.updateQueue;
+
+ if (updateQueue !== null) {
+ processUpdateQueue(workInProgress, updateQueue, newProps, instance, renderExpirationTime);
+ instance.state = workInProgress.memoizedState;
+ }
+ }
+
+ if (typeof instance.componentDidMount === "function") {
+ workInProgress.effectTag |= Update;
+ }
+ }
+
+ function resumeMountClassInstance(workInProgress, ctor, newProps, renderExpirationTime) {
+ var instance = workInProgress.stateNode;
+ var oldProps = workInProgress.memoizedProps;
+ instance.props = oldProps;
+ var oldContext = instance.context;
+ var contextType = ctor.contextType;
+ var nextContext = void 0;
+
+ if (typeof contextType === "object" && contextType !== null) {
+ nextContext = _readContext(contextType);
+ } else {
+ var nextLegacyUnmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
+ nextContext = getMaskedContext(workInProgress, nextLegacyUnmaskedContext);
+ }
+
+ var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+ var hasNewLifecycles = typeof getDerivedStateFromProps === "function" || typeof instance.getSnapshotBeforeUpdate === "function";
+
+ if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillReceiveProps === "function" || typeof instance.componentWillReceiveProps === "function")) {
+ if (oldProps !== newProps || oldContext !== nextContext) {
+ callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext);
+ }
+ }
+
+ resetHasForceUpdateBeforeProcessing();
+ var oldState = workInProgress.memoizedState;
+ var newState = instance.state = oldState;
+ var updateQueue = workInProgress.updateQueue;
+
+ if (updateQueue !== null) {
+ processUpdateQueue(workInProgress, updateQueue, newProps, instance, renderExpirationTime);
+ newState = workInProgress.memoizedState;
+ }
+
+ if (oldProps === newProps && oldState === newState && !hasContextChanged() && !checkHasForceUpdateAfterProcessing()) {
+ if (typeof instance.componentDidMount === "function") {
+ workInProgress.effectTag |= Update;
+ }
+
+ return false;
+ }
+
+ if (typeof getDerivedStateFromProps === "function") {
+ applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, newProps);
+ newState = workInProgress.memoizedState;
+ }
+
+ var shouldUpdate = checkHasForceUpdateAfterProcessing() || checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext);
+
+ if (shouldUpdate) {
+ if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillMount === "function" || typeof instance.componentWillMount === "function")) {
+ startPhaseTimer(workInProgress, "componentWillMount");
+
+ if (typeof instance.componentWillMount === "function") {
+ instance.componentWillMount();
+ }
+
+ if (typeof instance.UNSAFE_componentWillMount === "function") {
+ instance.UNSAFE_componentWillMount();
+ }
+
+ stopPhaseTimer();
+ }
+
+ if (typeof instance.componentDidMount === "function") {
+ workInProgress.effectTag |= Update;
+ }
+ } else {
+ if (typeof instance.componentDidMount === "function") {
+ workInProgress.effectTag |= Update;
+ }
+
+ workInProgress.memoizedProps = newProps;
+ workInProgress.memoizedState = newState;
+ }
+
+ instance.props = newProps;
+ instance.state = newState;
+ instance.context = nextContext;
+ return shouldUpdate;
+ }
+
+ function updateClassInstance(current, workInProgress, ctor, newProps, renderExpirationTime) {
+ var instance = workInProgress.stateNode;
+ var oldProps = workInProgress.memoizedProps;
+ instance.props = workInProgress.type === workInProgress.elementType ? oldProps : resolveDefaultProps(workInProgress.type, oldProps);
+ var oldContext = instance.context;
+ var contextType = ctor.contextType;
+ var nextContext = void 0;
+
+ if (typeof contextType === "object" && contextType !== null) {
+ nextContext = _readContext(contextType);
+ } else {
+ var nextUnmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
+ nextContext = getMaskedContext(workInProgress, nextUnmaskedContext);
+ }
+
+ var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
+ var hasNewLifecycles = typeof getDerivedStateFromProps === "function" || typeof instance.getSnapshotBeforeUpdate === "function";
+
+ if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillReceiveProps === "function" || typeof instance.componentWillReceiveProps === "function")) {
+ if (oldProps !== newProps || oldContext !== nextContext) {
+ callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext);
+ }
+ }
+
+ resetHasForceUpdateBeforeProcessing();
+ var oldState = workInProgress.memoizedState;
+ var newState = instance.state = oldState;
+ var updateQueue = workInProgress.updateQueue;
+
+ if (updateQueue !== null) {
+ processUpdateQueue(workInProgress, updateQueue, newProps, instance, renderExpirationTime);
+ newState = workInProgress.memoizedState;
+ }
+
+ if (oldProps === newProps && oldState === newState && !hasContextChanged() && !checkHasForceUpdateAfterProcessing()) {
+ if (typeof instance.componentDidUpdate === "function") {
+ if (oldProps !== current.memoizedProps || oldState !== current.memoizedState) {
+ workInProgress.effectTag |= Update;
+ }
+ }
+
+ if (typeof instance.getSnapshotBeforeUpdate === "function") {
+ if (oldProps !== current.memoizedProps || oldState !== current.memoizedState) {
+ workInProgress.effectTag |= Snapshot;
+ }
+ }
+
+ return false;
+ }
+
+ if (typeof getDerivedStateFromProps === "function") {
+ applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, newProps);
+ newState = workInProgress.memoizedState;
+ }
+
+ var shouldUpdate = checkHasForceUpdateAfterProcessing() || checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext);
+
+ if (shouldUpdate) {
+ if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillUpdate === "function" || typeof instance.componentWillUpdate === "function")) {
+ startPhaseTimer(workInProgress, "componentWillUpdate");
+
+ if (typeof instance.componentWillUpdate === "function") {
+ instance.componentWillUpdate(newProps, newState, nextContext);
+ }
+
+ if (typeof instance.UNSAFE_componentWillUpdate === "function") {
+ instance.UNSAFE_componentWillUpdate(newProps, newState, nextContext);
+ }
+
+ stopPhaseTimer();
+ }
+
+ if (typeof instance.componentDidUpdate === "function") {
+ workInProgress.effectTag |= Update;
+ }
+
+ if (typeof instance.getSnapshotBeforeUpdate === "function") {
+ workInProgress.effectTag |= Snapshot;
+ }
+ } else {
+ if (typeof instance.componentDidUpdate === "function") {
+ if (oldProps !== current.memoizedProps || oldState !== current.memoizedState) {
+ workInProgress.effectTag |= Update;
+ }
+ }
+
+ if (typeof instance.getSnapshotBeforeUpdate === "function") {
+ if (oldProps !== current.memoizedProps || oldState !== current.memoizedState) {
+ workInProgress.effectTag |= Snapshot;
+ }
+ }
+
+ workInProgress.memoizedProps = newProps;
+ workInProgress.memoizedState = newState;
+ }
+
+ instance.props = newProps;
+ instance.state = newState;
+ instance.context = nextContext;
+ return shouldUpdate;
+ }
+
+ var didWarnAboutMaps = void 0;
+ var didWarnAboutGenerators = void 0;
+ var didWarnAboutStringRefInStrictMode = void 0;
+ var ownerHasKeyUseWarning = void 0;
+ var ownerHasFunctionTypeWarning = void 0;
+
+ var warnForMissingKey = function warnForMissingKey(child) {};
+
+ {
+ didWarnAboutMaps = false;
+ didWarnAboutGenerators = 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 a list should have a unique " + '"key" prop. See https://fb.me/react-warning-keys for ' + "more information." + getCurrentFiberStackInDev();
+
+ if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {
+ return;
+ }
+
+ ownerHasKeyUseWarning[currentComponentErrorInfo] = true;
+ warning$1(false, "Each child in a list should have a unique " + '"key" prop. See https://fb.me/react-warning-keys for ' + "more information.");
+ };
+ }
+ var isArray = Array.isArray;
+
+ function coerceRef(returnFiber, current$$1, element) {
+ var mixedRef = element.ref;
+
+ if (mixedRef !== null && typeof mixedRef !== "function" && typeof mixedRef !== "object") {
+ {
+ if (returnFiber.mode & StrictMode) {
+ var componentName = getComponentName(returnFiber.type) || "Component";
+
+ if (!didWarnAboutStringRefInStrictMode[componentName]) {
+ warningWithoutStack$1(false, 'A string ref, "%s", has been found within a strict mode tree. ' + "String refs are a source of potential bugs and should be avoided. " + "We recommend using createRef() instead." + "\n%s" + "\n\nLearn more about using refs safely here:" + "\nhttps://fb.me/react-strict-mode-string-ref", mixedRef, getStackByFiberInDevAndProd(returnFiber));
+ didWarnAboutStringRefInStrictMode[componentName] = true;
+ }
+ }
+ }
+
+ if (element._owner) {
+ var owner = element._owner;
+ var inst = void 0;
+
+ if (owner) {
+ var ownerFiber = owner;
+ invariant(ownerFiber.tag === ClassComponent, "Function components cannot have refs. " + "Did you mean to use React.forwardRef()?");
+ 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$$1 !== null && current$$1.ref !== null && typeof current$$1.ref === "function" && current$$1.ref._stringRef === stringRef) {
+ return current$$1.ref;
+ }
+
+ var ref = function ref(value) {
+ var refs = inst.refs;
+
+ if (refs === emptyRefsObject) {
+ refs = inst.refs = {};
+ }
+
+ if (value === null) {
+ delete refs[stringRef];
+ } else {
+ refs[stringRef] = value;
+ }
+ };
+
+ ref._stringRef = stringRef;
+ return ref;
+ } else {
+ invariant(typeof mixedRef === "string", "Expected ref to be a function, a string, an object returned by React.createRef(), or null.");
+ 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 function 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." + getCurrentFiberStackInDev();
+ }
+ 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 from render. " + "Or maybe you meant to call this function rather than return it." + getCurrentFiberStackInDev();
+
+ if (ownerHasFunctionTypeWarning[currentComponentErrorInfo]) {
+ return;
+ }
+
+ ownerHasFunctionTypeWarning[currentComponentErrorInfo] = true;
+ warning$1(false, "Functions are not valid as a React child. This may happen if " + "you return a Component instead of from render. " + "Or maybe you meant to call this function rather than return it.");
+ }
+
+ function ChildReconciler(shouldTrackSideEffects) {
+ function deleteChild(returnFiber, childToDelete) {
+ if (!shouldTrackSideEffects) {
+ return;
+ }
+
+ var last = returnFiber.lastEffect;
+
+ if (last !== null) {
+ last.nextEffect = childToDelete;
+ returnFiber.lastEffect = childToDelete;
+ } else {
+ returnFiber.firstEffect = returnFiber.lastEffect = childToDelete;
+ }
+
+ childToDelete.nextEffect = null;
+ childToDelete.effectTag = Deletion;
+ }
+
+ function deleteRemainingChildren(returnFiber, currentFirstChild) {
+ if (!shouldTrackSideEffects) {
+ return null;
+ }
+
+ var childToDelete = currentFirstChild;
+
+ while (childToDelete !== null) {
+ deleteChild(returnFiber, childToDelete);
+ childToDelete = childToDelete.sibling;
+ }
+
+ return null;
+ }
+
+ function mapRemainingChildren(returnFiber, currentFirstChild) {
+ var existingChildren = new Map();
+ var existingChild = currentFirstChild;
+
+ while (existingChild !== null) {
+ if (existingChild.key !== null) {
+ existingChildren.set(existingChild.key, existingChild);
+ } else {
+ existingChildren.set(existingChild.index, existingChild);
+ }
+
+ existingChild = existingChild.sibling;
+ }
+
+ return existingChildren;
+ }
+
+ function useFiber(fiber, pendingProps, expirationTime) {
+ var clone = createWorkInProgress(fiber, pendingProps, expirationTime);
+ clone.index = 0;
+ clone.sibling = null;
+ return clone;
+ }
+
+ function placeChild(newFiber, lastPlacedIndex, newIndex) {
+ newFiber.index = newIndex;
+
+ if (!shouldTrackSideEffects) {
+ return lastPlacedIndex;
+ }
+
+ var current$$1 = newFiber.alternate;
+
+ if (current$$1 !== null) {
+ var oldIndex = current$$1.index;
+
+ if (oldIndex < lastPlacedIndex) {
+ newFiber.effectTag = Placement;
+ return lastPlacedIndex;
+ } else {
+ return oldIndex;
+ }
+ } else {
+ newFiber.effectTag = Placement;
+ return lastPlacedIndex;
+ }
+ }
+
+ function placeSingleChild(newFiber) {
+ if (shouldTrackSideEffects && newFiber.alternate === null) {
+ newFiber.effectTag = Placement;
+ }
+
+ return newFiber;
+ }
+
+ function updateTextNode(returnFiber, current$$1, textContent, expirationTime) {
+ if (current$$1 === null || current$$1.tag !== HostText) {
+ var created = createFiberFromText(textContent, returnFiber.mode, expirationTime);
+ created.return = returnFiber;
+ return created;
+ } else {
+ var existing = useFiber(current$$1, textContent, expirationTime);
+ existing.return = returnFiber;
+ return existing;
+ }
+ }
+
+ function updateElement(returnFiber, current$$1, element, expirationTime) {
+ if (current$$1 !== null && current$$1.elementType === element.type) {
+ var existing = useFiber(current$$1, element.props, expirationTime);
+ existing.ref = coerceRef(returnFiber, current$$1, element);
+ existing.return = returnFiber;
+ {
+ existing._debugSource = element._source;
+ existing._debugOwner = element._owner;
+ }
+ return existing;
+ } else {
+ var created = createFiberFromElement(element, returnFiber.mode, expirationTime);
+ created.ref = coerceRef(returnFiber, current$$1, element);
+ created.return = returnFiber;
+ return created;
+ }
+ }
+
+ function updatePortal(returnFiber, current$$1, portal, expirationTime) {
+ if (current$$1 === null || current$$1.tag !== HostPortal || current$$1.stateNode.containerInfo !== portal.containerInfo || current$$1.stateNode.implementation !== portal.implementation) {
+ var created = createFiberFromPortal(portal, returnFiber.mode, expirationTime);
+ created.return = returnFiber;
+ return created;
+ } else {
+ var existing = useFiber(current$$1, portal.children || [], expirationTime);
+ existing.return = returnFiber;
+ return existing;
+ }
+ }
+
+ function updateFragment(returnFiber, current$$1, fragment, expirationTime, key) {
+ if (current$$1 === null || current$$1.tag !== Fragment) {
+ var created = createFiberFromFragment(fragment, returnFiber.mode, expirationTime, key);
+ created.return = returnFiber;
+ return created;
+ } else {
+ var existing = useFiber(current$$1, fragment, expirationTime);
+ existing.return = returnFiber;
+ return existing;
+ }
+ }
+
+ function createChild(returnFiber, newChild, expirationTime) {
+ if (typeof newChild === "string" || typeof newChild === "number") {
+ var created = createFiberFromText("" + newChild, returnFiber.mode, expirationTime);
+ created.return = returnFiber;
+ return created;
+ }
+
+ if (typeof newChild === "object" && newChild !== null) {
+ switch (newChild.$$typeof) {
+ case REACT_ELEMENT_TYPE:
+ {
+ var _created = createFiberFromElement(newChild, returnFiber.mode, expirationTime);
+
+ _created.ref = coerceRef(returnFiber, null, newChild);
+ _created.return = returnFiber;
+ return _created;
+ }
+
+ case REACT_PORTAL_TYPE:
+ {
+ var _created2 = createFiberFromPortal(newChild, returnFiber.mode, expirationTime);
+
+ _created2.return = returnFiber;
+ return _created2;
+ }
+ }
+
+ if (isArray(newChild) || getIteratorFn(newChild)) {
+ var _created3 = createFiberFromFragment(newChild, returnFiber.mode, expirationTime, null);
+
+ _created3.return = returnFiber;
+ return _created3;
+ }
+
+ throwOnInvalidObjectType(returnFiber, newChild);
+ }
+
+ {
+ if (typeof newChild === "function") {
+ warnOnFunctionType();
+ }
+ }
+ return null;
+ }
+
+ function updateSlot(returnFiber, oldFiber, newChild, expirationTime) {
+ var key = oldFiber !== null ? oldFiber.key : null;
+
+ if (typeof newChild === "string" || typeof newChild === "number") {
+ if (key !== null) {
+ return null;
+ }
+
+ return updateTextNode(returnFiber, oldFiber, "" + newChild, expirationTime);
+ }
+
+ if (typeof newChild === "object" && newChild !== null) {
+ switch (newChild.$$typeof) {
+ case REACT_ELEMENT_TYPE:
+ {
+ if (newChild.key === key) {
+ if (newChild.type === REACT_FRAGMENT_TYPE) {
+ return updateFragment(returnFiber, oldFiber, newChild.props.children, expirationTime, key);
+ }
+
+ return updateElement(returnFiber, oldFiber, newChild, expirationTime);
+ } else {
+ return null;
+ }
+ }
+
+ case REACT_PORTAL_TYPE:
+ {
+ if (newChild.key === key) {
+ return updatePortal(returnFiber, oldFiber, newChild, expirationTime);
+ } else {
+ return null;
+ }
+ }
+ }
+
+ if (isArray(newChild) || getIteratorFn(newChild)) {
+ if (key !== null) {
+ return null;
+ }
+
+ return updateFragment(returnFiber, oldFiber, newChild, expirationTime, null);
+ }
+
+ throwOnInvalidObjectType(returnFiber, newChild);
+ }
+
+ {
+ if (typeof newChild === "function") {
+ warnOnFunctionType();
+ }
+ }
+ return null;
+ }
+
+ function updateFromMap(existingChildren, returnFiber, newIdx, newChild, expirationTime) {
+ if (typeof newChild === "string" || typeof newChild === "number") {
+ var matchedFiber = existingChildren.get(newIdx) || null;
+ return updateTextNode(returnFiber, matchedFiber, "" + newChild, expirationTime);
+ }
+
+ if (typeof newChild === "object" && newChild !== null) {
+ switch (newChild.$$typeof) {
+ case REACT_ELEMENT_TYPE:
+ {
+ var _matchedFiber = existingChildren.get(newChild.key === null ? newIdx : newChild.key) || null;
+
+ if (newChild.type === REACT_FRAGMENT_TYPE) {
+ return updateFragment(returnFiber, _matchedFiber, newChild.props.children, expirationTime, newChild.key);
+ }
+
+ return updateElement(returnFiber, _matchedFiber, newChild, expirationTime);
+ }
+
+ case REACT_PORTAL_TYPE:
+ {
+ var _matchedFiber2 = existingChildren.get(newChild.key === null ? newIdx : newChild.key) || null;
+
+ return updatePortal(returnFiber, _matchedFiber2, newChild, expirationTime);
+ }
+ }
+
+ if (isArray(newChild) || getIteratorFn(newChild)) {
+ var _matchedFiber3 = existingChildren.get(newIdx) || null;
+
+ return updateFragment(returnFiber, _matchedFiber3, newChild, expirationTime, null);
+ }
+
+ throwOnInvalidObjectType(returnFiber, newChild);
+ }
+
+ {
+ if (typeof newChild === "function") {
+ warnOnFunctionType();
+ }
+ }
+ return null;
+ }
+
+ function warnOnInvalidKey(child, knownKeys) {
+ {
+ if (typeof child !== "object" || child === null) {
+ return knownKeys;
+ }
+
+ switch (child.$$typeof) {
+ case REACT_ELEMENT_TYPE:
+ case REACT_PORTAL_TYPE:
+ warnForMissingKey(child);
+ var key = child.key;
+
+ if (typeof key !== "string") {
+ break;
+ }
+
+ if (knownKeys === null) {
+ knownKeys = new Set();
+ knownKeys.add(key);
+ break;
+ }
+
+ if (!knownKeys.has(key)) {
+ knownKeys.add(key);
+ break;
+ }
+
+ warning$1(false, "Encountered two children with the same key, `%s`. " + "Keys should be unique so that components maintain their identity " + "across updates. Non-unique keys may cause children to be " + "duplicated and/or omitted — the behavior is unsupported and " + "could change in a future version.", key);
+ break;
+
+ default:
+ break;
+ }
+ }
+ return knownKeys;
+ }
+
+ function reconcileChildrenArray(returnFiber, currentFirstChild, newChildren, expirationTime) {
+ {
+ var knownKeys = null;
+
+ for (var i = 0; i < newChildren.length; i++) {
+ var child = newChildren[i];
+ knownKeys = warnOnInvalidKey(child, knownKeys);
+ }
+ }
+ var resultingFirstChild = null;
+ var previousNewFiber = null;
+ var oldFiber = currentFirstChild;
+ var lastPlacedIndex = 0;
+ var newIdx = 0;
+ var nextOldFiber = null;
+
+ for (; oldFiber !== null && newIdx < newChildren.length; newIdx++) {
+ if (oldFiber.index > newIdx) {
+ nextOldFiber = oldFiber;
+ oldFiber = null;
+ } else {
+ nextOldFiber = oldFiber.sibling;
+ }
+
+ var newFiber = updateSlot(returnFiber, oldFiber, newChildren[newIdx], expirationTime);
+
+ if (newFiber === null) {
+ if (oldFiber === null) {
+ oldFiber = nextOldFiber;
+ }
+
+ break;
+ }
+
+ if (shouldTrackSideEffects) {
+ if (oldFiber && newFiber.alternate === null) {
+ deleteChild(returnFiber, oldFiber);
+ }
+ }
+
+ lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);
+
+ if (previousNewFiber === null) {
+ resultingFirstChild = newFiber;
+ } else {
+ previousNewFiber.sibling = newFiber;
+ }
+
+ previousNewFiber = newFiber;
+ oldFiber = nextOldFiber;
+ }
+
+ if (newIdx === newChildren.length) {
+ deleteRemainingChildren(returnFiber, oldFiber);
+ return resultingFirstChild;
+ }
+
+ if (oldFiber === null) {
+ for (; newIdx < newChildren.length; newIdx++) {
+ var _newFiber = createChild(returnFiber, newChildren[newIdx], expirationTime);
+
+ if (!_newFiber) {
+ 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 (typeof Symbol === "function" && newChildrenIterable[typeof Symbol === "function" ? Symbol.toStringTag : "@@toStringTag"] === "Generator") {
+ !didWarnAboutGenerators ? warning$1(false, "Using Generators as children is unsupported and will likely yield " + "unexpected results because enumerating a generator mutates it. " + "You may convert it to an array with `Array.from()` or the " + "`[...spread]` operator before rendering. Keep in mind " + "you might need to polyfill these features for older browsers.") : void 0;
+ didWarnAboutGenerators = true;
+ }
+
+ if (newChildrenIterable.entries === iteratorFn) {
+ !didWarnAboutMaps ? warning$1(false, "Using Maps as children is unsupported and will likely yield " + "unexpected results. Convert it to a sequence/iterable of keyed " + "ReactElements instead.") : void 0;
+ didWarnAboutMaps = true;
+ }
+
+ var _newChildren = iteratorFn.call(newChildrenIterable);
+
+ if (_newChildren) {
+ var knownKeys = null;
+
+ var _step = _newChildren.next();
+
+ for (; !_step.done; _step = _newChildren.next()) {
+ var child = _step.value;
+ knownKeys = warnOnInvalidKey(child, knownKeys);
+ }
+ }
+ }
+ var newChildren = iteratorFn.call(newChildrenIterable);
+ 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.elementType === 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(newChild)) {
+ return reconcileChildrenArray(returnFiber, currentFirstChild, newChild, expirationTime);
+ }
+
+ if (getIteratorFn(newChild)) {
+ return reconcileChildrenIterator(returnFiber, currentFirstChild, newChild, expirationTime);
+ }
+
+ if (isObject) {
+ throwOnInvalidObjectType(returnFiber, newChild);
+ }
+
+ {
+ if (typeof newChild === "function") {
+ warnOnFunctionType();
+ }
+ }
+
+ if (typeof newChild === "undefined" && !isUnkeyedTopLevelFragment) {
+ switch (returnFiber.tag) {
+ case ClassComponent:
+ {
+ {
+ var instance = returnFiber.stateNode;
+
+ if (instance.render._isMockFunction) {
+ break;
+ }
+ }
+ }
+
+ case FunctionComponent:
+ {
+ var Component = returnFiber.type;
+ 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$$1, workInProgress) {
+ invariant(current$$1 === null || workInProgress.child === current$$1.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 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 NoEffect$1 = 0;
+ var UnmountSnapshot = 2;
+ var UnmountMutation = 4;
+ var MountMutation = 8;
+ var UnmountLayout = 16;
+ var MountLayout = 32;
+ var MountPassive = 64;
+ var UnmountPassive = 128;
+ var ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher;
+ var didWarnAboutMismatchedHooksForComponent = void 0;
+ {
+ didWarnAboutMismatchedHooksForComponent = new Set();
+ }
+ var renderExpirationTime = NoWork;
+ var currentlyRenderingFiber$1 = null;
+ var firstCurrentHook = null;
+ var currentHook = null;
+ var nextCurrentHook = null;
+ var firstWorkInProgressHook = null;
+ var workInProgressHook = null;
+ var nextWorkInProgressHook = null;
+ var remainingExpirationTime = NoWork;
+ var componentUpdateQueue = null;
+ var sideEffectTag = 0;
+ var didScheduleRenderPhaseUpdate = false;
+ var renderPhaseUpdates = null;
+ var numberOfReRenders = 0;
+ var RE_RENDER_LIMIT = 25;
+ var currentHookNameInDev = null;
+
+ function warnOnHookMismatchInDev() {
+ {
+ var componentName = getComponentName(currentlyRenderingFiber$1.type);
+
+ if (!didWarnAboutMismatchedHooksForComponent.has(componentName)) {
+ didWarnAboutMismatchedHooksForComponent.add(componentName);
+ var secondColumnStart = 22;
+ var table = "";
+ var prevHook = firstCurrentHook;
+ var nextHook = firstWorkInProgressHook;
+ var n = 1;
+
+ while (prevHook !== null && nextHook !== null) {
+ var oldHookName = prevHook._debugType;
+ var newHookName = nextHook._debugType;
+ var row = n + ". " + oldHookName;
+
+ while (row.length < secondColumnStart) {
+ row += " ";
+ }
+
+ row += newHookName + "\n";
+ table += row;
+ prevHook = prevHook.next;
+ nextHook = nextHook.next;
+ n++;
+ }
+
+ warning$1(false, "React has detected a change in the order of Hooks called by %s. " + "This will lead to bugs and errors if not fixed. " + "For more information, read the Rules of Hooks: https://fb.me/rules-of-hooks\n\n" + " Previous render Next render\n" + " -------------------------------\n" + "%s" + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", componentName, table);
+ }
+ }
+ }
+
+ function throwInvalidHookError() {
+ invariant(false, "Hooks can only be called inside the body of a function component. " + "(https://fb.me/react-invalid-hook-call)");
+ }
+
+ function areHookInputsEqual(nextDeps, prevDeps) {
+ if (prevDeps === null) {
+ {
+ warning$1(false, "%s received a final argument during this render, but not during " + "the previous render. Even though the final argument is optional, " + "its type cannot change between renders.", currentHookNameInDev);
+ }
+ return false;
+ }
+
+ {
+ if (nextDeps.length !== prevDeps.length) {
+ warning$1(false, "The final argument passed to %s changed size between renders. The " + "order and size of this array must remain constant.\n\n" + "Previous: %s\n" + "Incoming: %s", currentHookNameInDev, "[" + nextDeps.join(", ") + "]", "[" + prevDeps.join(", ") + "]");
+ }
+ }
+
+ for (var i = 0; i < prevDeps.length && i < nextDeps.length; i++) {
+ if (is(nextDeps[i], prevDeps[i])) {
+ continue;
+ }
+
+ return false;
+ }
+
+ return true;
+ }
+
+ function renderWithHooks(current, workInProgress, Component, props, refOrContext, nextRenderExpirationTime) {
+ renderExpirationTime = nextRenderExpirationTime;
+ currentlyRenderingFiber$1 = workInProgress;
+ firstCurrentHook = nextCurrentHook = current !== null ? current.memoizedState : null;
+ {
+ ReactCurrentDispatcher$1.current = nextCurrentHook === null ? HooksDispatcherOnMountInDEV : HooksDispatcherOnUpdateInDEV;
+ }
+ var children = Component(props, refOrContext);
+
+ if (didScheduleRenderPhaseUpdate) {
+ do {
+ didScheduleRenderPhaseUpdate = false;
+ numberOfReRenders += 1;
+ firstCurrentHook = nextCurrentHook = current !== null ? current.memoizedState : null;
+ nextWorkInProgressHook = firstWorkInProgressHook;
+ currentHook = null;
+ workInProgressHook = null;
+ componentUpdateQueue = null;
+ ReactCurrentDispatcher$1.current = HooksDispatcherOnUpdateInDEV;
+ children = Component(props, refOrContext);
+ } while (didScheduleRenderPhaseUpdate);
+
+ renderPhaseUpdates = null;
+ numberOfReRenders = 0;
+ }
+
+ {
+ currentHookNameInDev = null;
+ }
+ ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
+ var renderedWork = currentlyRenderingFiber$1;
+ renderedWork.memoizedState = firstWorkInProgressHook;
+ renderedWork.expirationTime = remainingExpirationTime;
+ renderedWork.updateQueue = componentUpdateQueue;
+ renderedWork.effectTag |= sideEffectTag;
+ var didRenderTooFewHooks = currentHook !== null && currentHook.next !== null;
+ renderExpirationTime = NoWork;
+ currentlyRenderingFiber$1 = null;
+ firstCurrentHook = null;
+ currentHook = null;
+ nextCurrentHook = null;
+ firstWorkInProgressHook = null;
+ workInProgressHook = null;
+ nextWorkInProgressHook = null;
+ remainingExpirationTime = NoWork;
+ componentUpdateQueue = null;
+ sideEffectTag = 0;
+ invariant(!didRenderTooFewHooks, "Rendered fewer hooks than expected. This may be caused by an accidental " + "early return statement.");
+ return children;
+ }
+
+ function bailoutHooks(current, workInProgress, expirationTime) {
+ workInProgress.updateQueue = current.updateQueue;
+ workInProgress.effectTag &= ~(Passive | Update);
+
+ if (current.expirationTime <= expirationTime) {
+ current.expirationTime = NoWork;
+ }
+ }
+
+ function resetHooks() {
+ ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
+ renderExpirationTime = NoWork;
+ currentlyRenderingFiber$1 = null;
+ firstCurrentHook = null;
+ currentHook = null;
+ nextCurrentHook = null;
+ firstWorkInProgressHook = null;
+ workInProgressHook = null;
+ nextWorkInProgressHook = null;
+ remainingExpirationTime = NoWork;
+ componentUpdateQueue = null;
+ sideEffectTag = 0;
+ {
+ currentHookNameInDev = null;
+ }
+ didScheduleRenderPhaseUpdate = false;
+ renderPhaseUpdates = null;
+ numberOfReRenders = 0;
+ }
+
+ function mountWorkInProgressHook() {
+ var hook = {
+ memoizedState: null,
+ baseState: null,
+ queue: null,
+ baseUpdate: null,
+ next: null
+ };
+ {
+ hook._debugType = currentHookNameInDev;
+ }
+
+ if (workInProgressHook === null) {
+ firstWorkInProgressHook = workInProgressHook = hook;
+ } else {
+ workInProgressHook = workInProgressHook.next = hook;
+ }
+
+ return workInProgressHook;
+ }
+
+ function updateWorkInProgressHook() {
+ if (nextWorkInProgressHook !== null) {
+ workInProgressHook = nextWorkInProgressHook;
+ nextWorkInProgressHook = workInProgressHook.next;
+ currentHook = nextCurrentHook;
+ nextCurrentHook = currentHook !== null ? currentHook.next : null;
+ } else {
+ invariant(nextCurrentHook !== null, "Rendered more hooks than during the previous render.");
+ currentHook = nextCurrentHook;
+ var newHook = {
+ memoizedState: currentHook.memoizedState,
+ baseState: currentHook.baseState,
+ queue: currentHook.queue,
+ baseUpdate: currentHook.baseUpdate,
+ next: null
+ };
+
+ if (workInProgressHook === null) {
+ workInProgressHook = firstWorkInProgressHook = newHook;
+ } else {
+ workInProgressHook = workInProgressHook.next = newHook;
+ }
+
+ nextCurrentHook = currentHook.next;
+ {
+ newHook._debugType = currentHookNameInDev;
+
+ if (currentHookNameInDev !== currentHook._debugType) {
+ warnOnHookMismatchInDev();
+ }
+ }
+ }
+
+ return workInProgressHook;
+ }
+
+ function createFunctionComponentUpdateQueue() {
+ return {
+ lastEffect: null
+ };
+ }
+
+ function basicStateReducer(state, action) {
+ return typeof action === "function" ? action(state) : action;
+ }
+
+ function mountContext(context, observedBits) {
+ {
+ mountWorkInProgressHook();
+ }
+ return _readContext(context, observedBits);
+ }
+
+ function updateContext(context, observedBits) {
+ {
+ updateWorkInProgressHook();
+ }
+ return _readContext(context, observedBits);
+ }
+
+ function mountReducer(reducer, initialArg, init) {
+ var hook = mountWorkInProgressHook();
+ var initialState = void 0;
+
+ if (init !== undefined) {
+ initialState = init(initialArg);
+ } else {
+ initialState = initialArg;
+ }
+
+ hook.memoizedState = hook.baseState = initialState;
+ var queue = hook.queue = {
+ last: null,
+ dispatch: null,
+ eagerReducer: reducer,
+ eagerState: initialState
+ };
+ var dispatch = queue.dispatch = dispatchAction.bind(null, currentlyRenderingFiber$1, queue);
+ return [hook.memoizedState, dispatch];
+ }
+
+ function updateReducer(reducer, initialArg, init) {
+ var hook = updateWorkInProgressHook();
+ var queue = hook.queue;
+ invariant(queue !== null, "Should have a queue. This is likely a bug in React. Please file an issue.");
+
+ if (numberOfReRenders > 0) {
+ var _dispatch = queue.dispatch;
+
+ if (renderPhaseUpdates !== null) {
+ var firstRenderPhaseUpdate = renderPhaseUpdates.get(queue);
+
+ if (firstRenderPhaseUpdate !== undefined) {
+ renderPhaseUpdates.delete(queue);
+ var newState = hook.memoizedState;
+ var update = firstRenderPhaseUpdate;
+
+ do {
+ var _action = update.action;
+ newState = reducer(newState, _action);
+ update = update.next;
+ } while (update !== null);
+
+ if (!is(newState, hook.memoizedState)) {
+ markWorkInProgressReceivedUpdate();
+ }
+
+ hook.memoizedState = newState;
+
+ if (hook.baseUpdate === queue.last) {
+ hook.baseState = newState;
+ }
+
+ queue.eagerReducer = reducer;
+ queue.eagerState = newState;
+ return [newState, _dispatch];
+ }
+ }
+
+ return [hook.memoizedState, _dispatch];
+ }
+
+ var last = queue.last;
+ var baseUpdate = hook.baseUpdate;
+ var baseState = hook.baseState;
+ var first = void 0;
+
+ if (baseUpdate !== null) {
+ if (last !== null) {
+ last.next = null;
+ }
+
+ first = baseUpdate.next;
+ } else {
+ first = last !== null ? last.next : null;
+ }
+
+ if (first !== null) {
+ var _newState = baseState;
+ var newBaseState = null;
+ var newBaseUpdate = null;
+ var prevUpdate = baseUpdate;
+ var _update = first;
+ var didSkip = false;
+
+ do {
+ var updateExpirationTime = _update.expirationTime;
+
+ if (updateExpirationTime < renderExpirationTime) {
+ if (!didSkip) {
+ didSkip = true;
+ newBaseUpdate = prevUpdate;
+ newBaseState = _newState;
+ }
+
+ if (updateExpirationTime > remainingExpirationTime) {
+ remainingExpirationTime = updateExpirationTime;
+ }
+ } else {
+ if (_update.eagerReducer === reducer) {
+ _newState = _update.eagerState;
+ } else {
+ var _action2 = _update.action;
+ _newState = reducer(_newState, _action2);
+ }
+ }
+
+ prevUpdate = _update;
+ _update = _update.next;
+ } while (_update !== null && _update !== first);
+
+ if (!didSkip) {
+ newBaseUpdate = prevUpdate;
+ newBaseState = _newState;
+ }
+
+ if (!is(_newState, hook.memoizedState)) {
+ markWorkInProgressReceivedUpdate();
+ }
+
+ hook.memoizedState = _newState;
+ hook.baseUpdate = newBaseUpdate;
+ hook.baseState = newBaseState;
+ queue.eagerReducer = reducer;
+ queue.eagerState = _newState;
+ }
+
+ var dispatch = queue.dispatch;
+ return [hook.memoizedState, dispatch];
+ }
+
+ function mountState(initialState) {
+ var hook = mountWorkInProgressHook();
+
+ if (typeof initialState === "function") {
+ initialState = initialState();
+ }
+
+ hook.memoizedState = hook.baseState = initialState;
+ var queue = hook.queue = {
+ last: null,
+ dispatch: null,
+ eagerReducer: basicStateReducer,
+ eagerState: initialState
+ };
+ var dispatch = queue.dispatch = dispatchAction.bind(null, currentlyRenderingFiber$1, queue);
+ return [hook.memoizedState, dispatch];
+ }
+
+ function updateState(initialState) {
+ return updateReducer(basicStateReducer, initialState);
+ }
+
+ function pushEffect(tag, create, destroy, deps) {
+ var effect = {
+ tag: tag,
+ create: create,
+ destroy: destroy,
+ deps: deps,
+ next: null
+ };
+
+ if (componentUpdateQueue === null) {
+ componentUpdateQueue = createFunctionComponentUpdateQueue();
+ componentUpdateQueue.lastEffect = effect.next = effect;
+ } else {
+ var _lastEffect = componentUpdateQueue.lastEffect;
+
+ if (_lastEffect === null) {
+ componentUpdateQueue.lastEffect = effect.next = effect;
+ } else {
+ var firstEffect = _lastEffect.next;
+ _lastEffect.next = effect;
+ effect.next = firstEffect;
+ componentUpdateQueue.lastEffect = effect;
+ }
+ }
+
+ return effect;
+ }
+
+ function mountRef(initialValue) {
+ var hook = mountWorkInProgressHook();
+ var ref = {
+ current: initialValue
+ };
+ {
+ Object.seal(ref);
+ }
+ hook.memoizedState = ref;
+ return ref;
+ }
+
+ function updateRef(initialValue) {
+ var hook = updateWorkInProgressHook();
+ return hook.memoizedState;
+ }
+
+ function mountEffectImpl(fiberEffectTag, hookEffectTag, create, deps) {
+ var hook = mountWorkInProgressHook();
+ var nextDeps = deps === undefined ? null : deps;
+ sideEffectTag |= fiberEffectTag;
+ hook.memoizedState = pushEffect(hookEffectTag, create, undefined, nextDeps);
+ }
+
+ function updateEffectImpl(fiberEffectTag, hookEffectTag, create, deps) {
+ var hook = updateWorkInProgressHook();
+ var nextDeps = deps === undefined ? null : deps;
+ var destroy = undefined;
+
+ if (currentHook !== null) {
+ var prevEffect = currentHook.memoizedState;
+ destroy = prevEffect.destroy;
+
+ if (nextDeps !== null) {
+ var prevDeps = prevEffect.deps;
+
+ if (areHookInputsEqual(nextDeps, prevDeps)) {
+ pushEffect(NoEffect$1, create, destroy, nextDeps);
+ return;
+ }
+ }
+ }
+
+ sideEffectTag |= fiberEffectTag;
+ hook.memoizedState = pushEffect(hookEffectTag, create, destroy, nextDeps);
+ }
+
+ function mountEffect(create, deps) {
+ return mountEffectImpl(Update | Passive, UnmountPassive | MountPassive, create, deps);
+ }
+
+ function updateEffect(create, deps) {
+ return updateEffectImpl(Update | Passive, UnmountPassive | MountPassive, create, deps);
+ }
+
+ function mountLayoutEffect(create, deps) {
+ return mountEffectImpl(Update, UnmountMutation | MountLayout, create, deps);
+ }
+
+ function updateLayoutEffect(create, deps) {
+ return updateEffectImpl(Update, UnmountMutation | MountLayout, create, deps);
+ }
+
+ function imperativeHandleEffect(create, ref) {
+ if (typeof ref === "function") {
+ var refCallback = ref;
+
+ var _inst = create();
+
+ refCallback(_inst);
+ return function () {
+ refCallback(null);
+ };
+ } else if (ref !== null && ref !== undefined) {
+ var refObject = ref;
+ {
+ !refObject.hasOwnProperty("current") ? warning$1(false, "Expected useImperativeHandle() first argument to either be a " + "ref callback or React.createRef() object. Instead received: %s.", "an object with keys {" + Object.keys(refObject).join(", ") + "}") : void 0;
+ }
+
+ var _inst2 = create();
+
+ refObject.current = _inst2;
+ return function () {
+ refObject.current = null;
+ };
+ }
+ }
+
+ function mountImperativeHandle(ref, create, deps) {
+ {
+ !(typeof create === "function") ? warning$1(false, "Expected useImperativeHandle() second argument to be a function " + "that creates a handle. Instead received: %s.", create !== null ? typeof create : "null") : void 0;
+ }
+ var effectDeps = deps !== null && deps !== undefined ? deps.concat([ref]) : null;
+ return mountEffectImpl(Update, UnmountMutation | MountLayout, imperativeHandleEffect.bind(null, create, ref), effectDeps);
+ }
+
+ function updateImperativeHandle(ref, create, deps) {
+ {
+ !(typeof create === "function") ? warning$1(false, "Expected useImperativeHandle() second argument to be a function " + "that creates a handle. Instead received: %s.", create !== null ? typeof create : "null") : void 0;
+ }
+ var effectDeps = deps !== null && deps !== undefined ? deps.concat([ref]) : null;
+ return updateEffectImpl(Update, UnmountMutation | MountLayout, imperativeHandleEffect.bind(null, create, ref), effectDeps);
+ }
+
+ function mountDebugValue(value, formatterFn) {}
+
+ var updateDebugValue = mountDebugValue;
+
+ function mountCallback(callback, deps) {
+ var hook = mountWorkInProgressHook();
+ var nextDeps = deps === undefined ? null : deps;
+ hook.memoizedState = [callback, nextDeps];
+ return callback;
+ }
+
+ function updateCallback(callback, deps) {
+ var hook = updateWorkInProgressHook();
+ var nextDeps = deps === undefined ? null : deps;
+ var prevState = hook.memoizedState;
+
+ if (prevState !== null) {
+ if (nextDeps !== null) {
+ var prevDeps = prevState[1];
+
+ if (areHookInputsEqual(nextDeps, prevDeps)) {
+ return prevState[0];
+ }
+ }
+ }
+
+ hook.memoizedState = [callback, nextDeps];
+ return callback;
+ }
+
+ function mountMemo(nextCreate, deps) {
+ var hook = mountWorkInProgressHook();
+ var nextDeps = deps === undefined ? null : deps;
+ var nextValue = nextCreate();
+ hook.memoizedState = [nextValue, nextDeps];
+ return nextValue;
+ }
+
+ function updateMemo(nextCreate, deps) {
+ var hook = updateWorkInProgressHook();
+ var nextDeps = deps === undefined ? null : deps;
+ var prevState = hook.memoizedState;
+
+ if (prevState !== null) {
+ if (nextDeps !== null) {
+ var prevDeps = prevState[1];
+
+ if (areHookInputsEqual(nextDeps, prevDeps)) {
+ return prevState[0];
+ }
+ }
+ }
+
+ var nextValue = nextCreate();
+ hook.memoizedState = [nextValue, nextDeps];
+ return nextValue;
+ }
+
+ var shouldWarnForUnbatchedSetState = false;
+ {
+ if ("undefined" !== typeof jest) {
+ shouldWarnForUnbatchedSetState = true;
+ }
+ }
+
+ function dispatchAction(fiber, queue, action) {
+ invariant(numberOfReRenders < RE_RENDER_LIMIT, "Too many re-renders. React limits the number of renders to prevent " + "an infinite loop.");
+ {
+ !(arguments.length <= 3) ? warning$1(false, "State updates from the useState() and useReducer() Hooks don't support the " + "second callback argument. To execute a side effect after " + "rendering, declare it in the component body with useEffect().") : void 0;
+ }
+ var alternate = fiber.alternate;
+
+ if (fiber === currentlyRenderingFiber$1 || alternate !== null && alternate === currentlyRenderingFiber$1) {
+ didScheduleRenderPhaseUpdate = true;
+ var update = {
+ expirationTime: renderExpirationTime,
+ action: action,
+ eagerReducer: null,
+ eagerState: null,
+ next: null
+ };
+
+ if (renderPhaseUpdates === null) {
+ renderPhaseUpdates = new Map();
+ }
+
+ var firstRenderPhaseUpdate = renderPhaseUpdates.get(queue);
+
+ if (firstRenderPhaseUpdate === undefined) {
+ renderPhaseUpdates.set(queue, update);
+ } else {
+ var lastRenderPhaseUpdate = firstRenderPhaseUpdate;
+
+ while (lastRenderPhaseUpdate.next !== null) {
+ lastRenderPhaseUpdate = lastRenderPhaseUpdate.next;
+ }
+
+ lastRenderPhaseUpdate.next = update;
+ }
+ } else {
+ flushPassiveEffects();
+ var currentTime = requestCurrentTime();
+
+ var _expirationTime = computeExpirationForFiber(currentTime, fiber);
+
+ var _update2 = {
+ expirationTime: _expirationTime,
+ action: action,
+ eagerReducer: null,
+ eagerState: null,
+ next: null
+ };
+ var _last = queue.last;
+
+ if (_last === null) {
+ _update2.next = _update2;
+ } else {
+ var first = _last.next;
+
+ if (first !== null) {
+ _update2.next = first;
+ }
+
+ _last.next = _update2;
+ }
+
+ queue.last = _update2;
+
+ if (fiber.expirationTime === NoWork && (alternate === null || alternate.expirationTime === NoWork)) {
+ var _eagerReducer = queue.eagerReducer;
+
+ if (_eagerReducer !== null) {
+ var prevDispatcher = void 0;
+ {
+ prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;
+ }
+
+ try {
+ var currentState = queue.eagerState;
+
+ var _eagerState = _eagerReducer(currentState, action);
+
+ _update2.eagerReducer = _eagerReducer;
+ _update2.eagerState = _eagerState;
+
+ if (is(_eagerState, currentState)) {
+ return;
+ }
+ } catch (error) {} finally {
+ {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ }
+ }
+ }
+
+ {
+ if (shouldWarnForUnbatchedSetState === true) {
+ warnIfNotCurrentlyBatchingInDev(fiber);
+ }
+ }
+ scheduleWork(fiber, _expirationTime);
+ }
+ }
+
+ var ContextOnlyDispatcher = {
+ readContext: _readContext,
+ useCallback: throwInvalidHookError,
+ useContext: throwInvalidHookError,
+ useEffect: throwInvalidHookError,
+ useImperativeHandle: throwInvalidHookError,
+ useLayoutEffect: throwInvalidHookError,
+ useMemo: throwInvalidHookError,
+ useReducer: throwInvalidHookError,
+ useRef: throwInvalidHookError,
+ useState: throwInvalidHookError,
+ useDebugValue: throwInvalidHookError
+ };
+ var HooksDispatcherOnMountInDEV = null;
+ var HooksDispatcherOnUpdateInDEV = null;
+ var InvalidNestedHooksDispatcherOnMountInDEV = null;
+ var InvalidNestedHooksDispatcherOnUpdateInDEV = null;
+ {
+ var warnInvalidContextAccess = function warnInvalidContextAccess() {
+ warning$1(false, "Context can only be read while React is rendering. " + "In classes, you can read it in the render method or getDerivedStateFromProps. " + "In function components, you can read it directly in the function body, but not " + "inside Hooks like useReducer() or useMemo().");
+ };
+
+ var warnInvalidHookAccess = function warnInvalidHookAccess() {
+ warning$1(false, "Do not call Hooks inside useEffect(...), useMemo(...), or other built-in Hooks. " + "You can only call Hooks at the top level of your React function. " + "For more information, see " + "https://fb.me/rules-of-hooks");
+ };
+
+ HooksDispatcherOnMountInDEV = {
+ readContext: function readContext(context, observedBits) {
+ return _readContext(context, observedBits);
+ },
+ useCallback: function useCallback(callback, deps) {
+ currentHookNameInDev = "useCallback";
+ return mountCallback(callback, deps);
+ },
+ useContext: function useContext(context, observedBits) {
+ currentHookNameInDev = "useContext";
+ return mountContext(context, observedBits);
+ },
+ useEffect: function useEffect(create, deps) {
+ currentHookNameInDev = "useEffect";
+ return mountEffect(create, deps);
+ },
+ useImperativeHandle: function useImperativeHandle(ref, create, deps) {
+ currentHookNameInDev = "useImperativeHandle";
+ return mountImperativeHandle(ref, create, deps);
+ },
+ useLayoutEffect: function useLayoutEffect(create, deps) {
+ currentHookNameInDev = "useLayoutEffect";
+ return mountLayoutEffect(create, deps);
+ },
+ useMemo: function useMemo(create, deps) {
+ currentHookNameInDev = "useMemo";
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;
+
+ try {
+ return mountMemo(create, deps);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useReducer: function useReducer(reducer, initialArg, init) {
+ currentHookNameInDev = "useReducer";
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;
+
+ try {
+ return mountReducer(reducer, initialArg, init);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useRef: function useRef(initialValue) {
+ currentHookNameInDev = "useRef";
+ return mountRef(initialValue);
+ },
+ useState: function useState(initialState) {
+ currentHookNameInDev = "useState";
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;
+
+ try {
+ return mountState(initialState);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useDebugValue: function useDebugValue(value, formatterFn) {
+ currentHookNameInDev = "useDebugValue";
+ return mountDebugValue(value, formatterFn);
+ }
+ };
+ HooksDispatcherOnUpdateInDEV = {
+ readContext: function readContext(context, observedBits) {
+ return _readContext(context, observedBits);
+ },
+ useCallback: function useCallback(callback, deps) {
+ currentHookNameInDev = "useCallback";
+ return updateCallback(callback, deps);
+ },
+ useContext: function useContext(context, observedBits) {
+ currentHookNameInDev = "useContext";
+ return updateContext(context, observedBits);
+ },
+ useEffect: function useEffect(create, deps) {
+ currentHookNameInDev = "useEffect";
+ return updateEffect(create, deps);
+ },
+ useImperativeHandle: function useImperativeHandle(ref, create, deps) {
+ currentHookNameInDev = "useImperativeHandle";
+ return updateImperativeHandle(ref, create, deps);
+ },
+ useLayoutEffect: function useLayoutEffect(create, deps) {
+ currentHookNameInDev = "useLayoutEffect";
+ return updateLayoutEffect(create, deps);
+ },
+ useMemo: function useMemo(create, deps) {
+ currentHookNameInDev = "useMemo";
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;
+
+ try {
+ return updateMemo(create, deps);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useReducer: function useReducer(reducer, initialArg, init) {
+ currentHookNameInDev = "useReducer";
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;
+
+ try {
+ return updateReducer(reducer, initialArg, init);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useRef: function useRef(initialValue) {
+ currentHookNameInDev = "useRef";
+ return updateRef(initialValue);
+ },
+ useState: function useState(initialState) {
+ currentHookNameInDev = "useState";
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;
+
+ try {
+ return updateState(initialState);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useDebugValue: function useDebugValue(value, formatterFn) {
+ currentHookNameInDev = "useDebugValue";
+ return updateDebugValue(value, formatterFn);
+ }
+ };
+ InvalidNestedHooksDispatcherOnMountInDEV = {
+ readContext: function readContext(context, observedBits) {
+ warnInvalidContextAccess();
+ return _readContext(context, observedBits);
+ },
+ useCallback: function useCallback(callback, deps) {
+ currentHookNameInDev = "useCallback";
+ warnInvalidHookAccess();
+ return mountCallback(callback, deps);
+ },
+ useContext: function useContext(context, observedBits) {
+ currentHookNameInDev = "useContext";
+ warnInvalidHookAccess();
+ return mountContext(context, observedBits);
+ },
+ useEffect: function useEffect(create, deps) {
+ currentHookNameInDev = "useEffect";
+ warnInvalidHookAccess();
+ return mountEffect(create, deps);
+ },
+ useImperativeHandle: function useImperativeHandle(ref, create, deps) {
+ currentHookNameInDev = "useImperativeHandle";
+ warnInvalidHookAccess();
+ return mountImperativeHandle(ref, create, deps);
+ },
+ useLayoutEffect: function useLayoutEffect(create, deps) {
+ currentHookNameInDev = "useLayoutEffect";
+ warnInvalidHookAccess();
+ return mountLayoutEffect(create, deps);
+ },
+ useMemo: function useMemo(create, deps) {
+ currentHookNameInDev = "useMemo";
+ warnInvalidHookAccess();
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;
+
+ try {
+ return mountMemo(create, deps);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useReducer: function useReducer(reducer, initialArg, init) {
+ currentHookNameInDev = "useReducer";
+ warnInvalidHookAccess();
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;
+
+ try {
+ return mountReducer(reducer, initialArg, init);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useRef: function useRef(initialValue) {
+ currentHookNameInDev = "useRef";
+ warnInvalidHookAccess();
+ return mountRef(initialValue);
+ },
+ useState: function useState(initialState) {
+ currentHookNameInDev = "useState";
+ warnInvalidHookAccess();
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;
+
+ try {
+ return mountState(initialState);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useDebugValue: function useDebugValue(value, formatterFn) {
+ currentHookNameInDev = "useDebugValue";
+ warnInvalidHookAccess();
+ return mountDebugValue(value, formatterFn);
+ }
+ };
+ InvalidNestedHooksDispatcherOnUpdateInDEV = {
+ readContext: function readContext(context, observedBits) {
+ warnInvalidContextAccess();
+ return _readContext(context, observedBits);
+ },
+ useCallback: function useCallback(callback, deps) {
+ currentHookNameInDev = "useCallback";
+ warnInvalidHookAccess();
+ return updateCallback(callback, deps);
+ },
+ useContext: function useContext(context, observedBits) {
+ currentHookNameInDev = "useContext";
+ warnInvalidHookAccess();
+ return updateContext(context, observedBits);
+ },
+ useEffect: function useEffect(create, deps) {
+ currentHookNameInDev = "useEffect";
+ warnInvalidHookAccess();
+ return updateEffect(create, deps);
+ },
+ useImperativeHandle: function useImperativeHandle(ref, create, deps) {
+ currentHookNameInDev = "useImperativeHandle";
+ warnInvalidHookAccess();
+ return updateImperativeHandle(ref, create, deps);
+ },
+ useLayoutEffect: function useLayoutEffect(create, deps) {
+ currentHookNameInDev = "useLayoutEffect";
+ warnInvalidHookAccess();
+ return updateLayoutEffect(create, deps);
+ },
+ useMemo: function useMemo(create, deps) {
+ currentHookNameInDev = "useMemo";
+ warnInvalidHookAccess();
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;
+
+ try {
+ return updateMemo(create, deps);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useReducer: function useReducer(reducer, initialArg, init) {
+ currentHookNameInDev = "useReducer";
+ warnInvalidHookAccess();
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;
+
+ try {
+ return updateReducer(reducer, initialArg, init);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useRef: function useRef(initialValue) {
+ currentHookNameInDev = "useRef";
+ warnInvalidHookAccess();
+ return updateRef(initialValue);
+ },
+ useState: function useState(initialState) {
+ currentHookNameInDev = "useState";
+ warnInvalidHookAccess();
+ var prevDispatcher = ReactCurrentDispatcher$1.current;
+ ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;
+
+ try {
+ return updateState(initialState);
+ } finally {
+ ReactCurrentDispatcher$1.current = prevDispatcher;
+ }
+ },
+ useDebugValue: function useDebugValue(value, formatterFn) {
+ currentHookNameInDev = "useDebugValue";
+ warnInvalidHookAccess();
+ return updateDebugValue(value, formatterFn);
+ }
+ };
+ }
+ var commitTime = 0;
+ var profilerStartTime = -1;
+
+ function getCommitTime() {
+ return commitTime;
+ }
+
+ function recordCommitTime() {
+ if (!enableProfilerTimer) {
+ return;
+ }
+
+ commitTime = now$$1();
+ }
+
+ function startProfilerTimer(fiber) {
+ if (!enableProfilerTimer) {
+ return;
+ }
+
+ profilerStartTime = now$$1();
+
+ if (fiber.actualStartTime < 0) {
+ fiber.actualStartTime = now$$1();
+ }
+ }
+
+ function stopProfilerTimerIfRunning(fiber) {
+ if (!enableProfilerTimer) {
+ return;
+ }
+
+ profilerStartTime = -1;
+ }
+
+ function stopProfilerTimerIfRunningAndRecordDelta(fiber, overrideBaseTime) {
+ if (!enableProfilerTimer) {
+ return;
+ }
+
+ if (profilerStartTime >= 0) {
+ var elapsedTime = now$$1() - profilerStartTime;
+ fiber.actualDuration += elapsedTime;
+
+ if (overrideBaseTime) {
+ fiber.selfBaseDuration = elapsedTime;
+ }
+
+ profilerStartTime = -1;
+ }
+ }
+
+ var hydrationParentFiber = null;
+ var nextHydratableInstance = null;
+ var isHydrating = false;
+
+ function enterHydrationState(fiber) {
+ if (!supportsHydration) {
+ return false;
+ }
+
+ var parentInstance = fiber.stateNode.containerInfo;
+ nextHydratableInstance = getFirstHydratableChild(parentInstance);
+ hydrationParentFiber = fiber;
+ isHydrating = true;
+ return true;
+ }
+
+ function reenterHydrationStateFromDehydratedSuspenseInstance(fiber) {
+ if (!supportsHydration) {
+ return false;
+ }
+
+ var suspenseInstance = fiber.stateNode;
+ nextHydratableInstance = getNextHydratableSibling(suspenseInstance);
+ popToNextHostParent(fiber);
+ isHydrating = true;
+ return true;
+ }
+
+ function deleteHydratableInstance(returnFiber, instance) {
+ {
+ switch (returnFiber.tag) {
+ case HostRoot:
+ didNotHydrateContainerInstance(returnFiber.stateNode.containerInfo, instance);
+ break;
+
+ case HostComponent:
+ didNotHydrateInstance(returnFiber.type, returnFiber.memoizedProps, returnFiber.stateNode, instance);
+ break;
+ }
+ }
+ var childToDelete = createFiberFromHostInstanceForDeletion();
+ childToDelete.stateNode = instance;
+ childToDelete.return = returnFiber;
+ childToDelete.effectTag = Deletion;
+
+ if (returnFiber.lastEffect !== null) {
+ returnFiber.lastEffect.nextEffect = childToDelete;
+ returnFiber.lastEffect = childToDelete;
+ } else {
+ returnFiber.firstEffect = returnFiber.lastEffect = childToDelete;
+ }
+ }
+
+ function insertNonHydratedInstance(returnFiber, fiber) {
+ fiber.effectTag |= Placement;
+ {
+ switch (returnFiber.tag) {
+ case HostRoot:
+ {
+ var parentContainer = returnFiber.stateNode.containerInfo;
+
+ switch (fiber.tag) {
+ case HostComponent:
+ var type = fiber.type;
+ var props = fiber.pendingProps;
+ didNotFindHydratableContainerInstance(parentContainer, type, props);
+ break;
+
+ case HostText:
+ var text = fiber.pendingProps;
+ didNotFindHydratableContainerTextInstance(parentContainer, text);
+ break;
+
+ case SuspenseComponent:
+ didNotFindHydratableContainerSuspenseInstance(parentContainer);
+ break;
+ }
+
+ break;
+ }
+
+ case HostComponent:
+ {
+ var parentType = returnFiber.type;
+ var parentProps = returnFiber.memoizedProps;
+ var parentInstance = returnFiber.stateNode;
+
+ switch (fiber.tag) {
+ case HostComponent:
+ var _type = fiber.type;
+ var _props = fiber.pendingProps;
+ didNotFindHydratableInstance(parentType, parentProps, parentInstance, _type, _props);
+ break;
+
+ case HostText:
+ var _text = fiber.pendingProps;
+ didNotFindHydratableTextInstance(parentType, parentProps, parentInstance, _text);
+ break;
+
+ case SuspenseComponent:
+ didNotFindHydratableSuspenseInstance(parentType, parentProps, parentInstance);
+ break;
+ }
+
+ break;
+ }
+
+ default:
+ return;
+ }
+ }
+ }
+
+ function tryHydrate(fiber, nextInstance) {
+ switch (fiber.tag) {
+ case HostComponent:
+ {
+ var type = fiber.type;
+ var props = fiber.pendingProps;
+ var instance = canHydrateInstance(nextInstance, type, props);
+
+ if (instance !== null) {
+ fiber.stateNode = instance;
+ return true;
+ }
+
+ return false;
+ }
+
+ case HostText:
+ {
+ var text = fiber.pendingProps;
+ var textInstance = canHydrateTextInstance(nextInstance, text);
+
+ if (textInstance !== null) {
+ fiber.stateNode = textInstance;
+ return true;
+ }
+
+ return false;
+ }
+
+ case SuspenseComponent:
+ {
+ if (enableSuspenseServerRenderer) {
+ var suspenseInstance = canHydrateSuspenseInstance(nextInstance);
+
+ if (suspenseInstance !== null) {
+ fiber.tag = DehydratedSuspenseComponent;
+ fiber.stateNode = suspenseInstance;
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ default:
+ return false;
+ }
+ }
+
+ function tryToClaimNextHydratableInstance(fiber) {
+ if (!isHydrating) {
+ return;
+ }
+
+ var nextInstance = nextHydratableInstance;
+
+ if (!nextInstance) {
+ insertNonHydratedInstance(hydrationParentFiber, fiber);
+ isHydrating = false;
+ hydrationParentFiber = fiber;
+ return;
+ }
+
+ var firstAttemptedInstance = nextInstance;
+
+ if (!tryHydrate(fiber, nextInstance)) {
+ nextInstance = getNextHydratableSibling(firstAttemptedInstance);
+
+ if (!nextInstance || !tryHydrate(fiber, nextInstance)) {
+ insertNonHydratedInstance(hydrationParentFiber, fiber);
+ isHydrating = false;
+ hydrationParentFiber = fiber;
+ return;
+ }
+
+ deleteHydratableInstance(hydrationParentFiber, firstAttemptedInstance);
+ }
+
+ hydrationParentFiber = fiber;
+ nextHydratableInstance = getFirstHydratableChild(nextInstance);
+ }
+
+ function prepareToHydrateHostInstance(fiber, rootContainerInstance, hostContext) {
+ if (!supportsHydration) {
+ 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 skipPastDehydratedSuspenseInstance(fiber) {
+ if (!supportsHydration) {
+ invariant(false, "Expected skipPastDehydratedSuspenseInstance() to never be called. " + "This error is likely caused by a bug in React. Please file an issue.");
+ }
+
+ var suspenseInstance = fiber.stateNode;
+ invariant(suspenseInstance, "Expected to have a hydrated suspense instance. " + "This error is likely caused by a bug in React. Please file an issue.");
+ nextHydratableInstance = getNextHydratableInstanceAfterSuspenseInstance(suspenseInstance);
+ }
+
+ function popToNextHostParent(fiber) {
+ var parent = fiber.return;
+
+ while (parent !== null && parent.tag !== HostComponent && parent.tag !== HostRoot && parent.tag !== DehydratedSuspenseComponent) {
+ parent = parent.return;
+ }
+
+ hydrationParentFiber = parent;
+ }
+
+ function popHydrationState(fiber) {
+ if (!supportsHydration) {
+ return false;
+ }
+
+ if (fiber !== hydrationParentFiber) {
+ return false;
+ }
+
+ if (!isHydrating) {
+ popToNextHostParent(fiber);
+ isHydrating = true;
+ return false;
+ }
+
+ var type = fiber.type;
+
+ if (fiber.tag !== HostComponent || type !== "head" && type !== "body" && !shouldSetTextContent(type, fiber.memoizedProps)) {
+ var nextInstance = nextHydratableInstance;
+
+ while (nextInstance) {
+ deleteHydratableInstance(fiber, nextInstance);
+ nextInstance = getNextHydratableSibling(nextInstance);
+ }
+ }
+
+ popToNextHostParent(fiber);
+ nextHydratableInstance = hydrationParentFiber ? getNextHydratableSibling(fiber.stateNode) : null;
+ return true;
+ }
+
+ function resetHydrationState() {
+ if (!supportsHydration) {
+ return;
+ }
+
+ hydrationParentFiber = null;
+ nextHydratableInstance = null;
+ isHydrating = false;
+ }
+
+ var ReactCurrentOwner$3 = ReactSharedInternals.ReactCurrentOwner;
+ var didReceiveUpdate = false;
+ var didWarnAboutBadClass = void 0;
+ var didWarnAboutContextTypeOnFunctionComponent = void 0;
+ var didWarnAboutGetDerivedStateOnFunctionComponent = void 0;
+ var didWarnAboutFunctionRefs = void 0;
+ var didWarnAboutReassigningProps = void 0;
+ {
+ didWarnAboutBadClass = {};
+ didWarnAboutContextTypeOnFunctionComponent = {};
+ didWarnAboutGetDerivedStateOnFunctionComponent = {};
+ didWarnAboutFunctionRefs = {};
+ didWarnAboutReassigningProps = false;
+ }
+
+ function reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime) {
+ if (current$$1 === null) {
+ workInProgress.child = mountChildFibers(workInProgress, null, nextChildren, renderExpirationTime);
+ } else {
+ workInProgress.child = reconcileChildFibers(workInProgress, current$$1.child, nextChildren, renderExpirationTime);
+ }
+ }
+
+ function forceUnmountCurrentAndReconcile(current$$1, workInProgress, nextChildren, renderExpirationTime) {
+ workInProgress.child = reconcileChildFibers(workInProgress, current$$1.child, null, renderExpirationTime);
+ workInProgress.child = reconcileChildFibers(workInProgress, null, nextChildren, renderExpirationTime);
+ }
+
+ function updateForwardRef(current$$1, workInProgress, Component, nextProps, renderExpirationTime) {
+ {
+ if (workInProgress.type !== workInProgress.elementType) {
+ var innerPropTypes = Component.propTypes;
+
+ if (innerPropTypes) {
+ checkPropTypes(innerPropTypes, nextProps, "prop", getComponentName(Component), getCurrentFiberStackInDev);
+ }
+ }
+ }
+ var render = Component.render;
+ var ref = workInProgress.ref;
+ var nextChildren = void 0;
+ prepareToReadContext(workInProgress, renderExpirationTime);
+ {
+ ReactCurrentOwner$3.current = workInProgress;
+ setCurrentPhase("render");
+ nextChildren = renderWithHooks(current$$1, workInProgress, render, nextProps, ref, renderExpirationTime);
+
+ if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
+ if (workInProgress.memoizedState !== null) {
+ nextChildren = renderWithHooks(current$$1, workInProgress, render, nextProps, ref, renderExpirationTime);
+ }
+ }
+
+ setCurrentPhase(null);
+ }
+
+ if (current$$1 !== null && !didReceiveUpdate) {
+ bailoutHooks(current$$1, workInProgress, renderExpirationTime);
+ return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ }
+
+ workInProgress.effectTag |= PerformedWork;
+ reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
+ return workInProgress.child;
+ }
+
+ function updateMemoComponent(current$$1, workInProgress, Component, nextProps, updateExpirationTime, renderExpirationTime) {
+ if (current$$1 === null) {
+ var type = Component.type;
+
+ if (isSimpleFunctionComponent(type) && Component.compare === null && Component.defaultProps === undefined) {
+ workInProgress.tag = SimpleMemoComponent;
+ workInProgress.type = type;
+ {
+ validateFunctionComponentInDev(workInProgress, type);
+ }
+ return updateSimpleMemoComponent(current$$1, workInProgress, type, nextProps, updateExpirationTime, renderExpirationTime);
+ }
+
+ {
+ var innerPropTypes = type.propTypes;
+
+ if (innerPropTypes) {
+ checkPropTypes(innerPropTypes, nextProps, "prop", getComponentName(type), getCurrentFiberStackInDev);
+ }
+ }
+ var child = createFiberFromTypeAndProps(Component.type, null, nextProps, null, workInProgress.mode, renderExpirationTime);
+ child.ref = workInProgress.ref;
+ child.return = workInProgress;
+ workInProgress.child = child;
+ return child;
+ }
+
+ {
+ var _type = Component.type;
+ var _innerPropTypes = _type.propTypes;
+
+ if (_innerPropTypes) {
+ checkPropTypes(_innerPropTypes, nextProps, "prop", getComponentName(_type), getCurrentFiberStackInDev);
+ }
+ }
+ var currentChild = current$$1.child;
+
+ if (updateExpirationTime < renderExpirationTime) {
+ var prevProps = currentChild.memoizedProps;
+ var compare = Component.compare;
+ compare = compare !== null ? compare : shallowEqual;
+
+ if (compare(prevProps, nextProps) && current$$1.ref === workInProgress.ref) {
+ return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ }
+ }
+
+ workInProgress.effectTag |= PerformedWork;
+ var newChild = createWorkInProgress(currentChild, nextProps, renderExpirationTime);
+ newChild.ref = workInProgress.ref;
+ newChild.return = workInProgress;
+ workInProgress.child = newChild;
+ return newChild;
+ }
+
+ function updateSimpleMemoComponent(current$$1, workInProgress, Component, nextProps, updateExpirationTime, renderExpirationTime) {
+ {
+ if (workInProgress.type !== workInProgress.elementType) {
+ var outerMemoType = workInProgress.elementType;
+
+ if (outerMemoType.$$typeof === REACT_LAZY_TYPE) {
+ outerMemoType = refineResolvedLazyComponent(outerMemoType);
+ }
+
+ var outerPropTypes = outerMemoType && outerMemoType.propTypes;
+
+ if (outerPropTypes) {
+ checkPropTypes(outerPropTypes, nextProps, "prop", getComponentName(outerMemoType), getCurrentFiberStackInDev);
+ }
+ }
+ }
+
+ if (current$$1 !== null) {
+ var prevProps = current$$1.memoizedProps;
+
+ if (shallowEqual(prevProps, nextProps) && current$$1.ref === workInProgress.ref) {
+ didReceiveUpdate = false;
+
+ if (updateExpirationTime < renderExpirationTime) {
+ return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ }
+ }
+ }
+
+ return updateFunctionComponent(current$$1, workInProgress, Component, nextProps, renderExpirationTime);
+ }
+
+ function updateFragment(current$$1, workInProgress, renderExpirationTime) {
+ var nextChildren = workInProgress.pendingProps;
+ reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
+ return workInProgress.child;
+ }
+
+ function updateMode(current$$1, workInProgress, renderExpirationTime) {
+ var nextChildren = workInProgress.pendingProps.children;
+ reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
+ return workInProgress.child;
+ }
+
+ function updateProfiler(current$$1, workInProgress, renderExpirationTime) {
+ if (enableProfilerTimer) {
+ workInProgress.effectTag |= Update;
+ }
+
+ var nextProps = workInProgress.pendingProps;
+ var nextChildren = nextProps.children;
+ reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
+ return workInProgress.child;
+ }
+
+ function markRef(current$$1, workInProgress) {
+ var ref = workInProgress.ref;
+
+ if (current$$1 === null && ref !== null || current$$1 !== null && current$$1.ref !== ref) {
+ workInProgress.effectTag |= Ref;
+ }
+ }
+
+ function updateFunctionComponent(current$$1, workInProgress, Component, nextProps, renderExpirationTime) {
+ {
+ if (workInProgress.type !== workInProgress.elementType) {
+ var innerPropTypes = Component.propTypes;
+
+ if (innerPropTypes) {
+ checkPropTypes(innerPropTypes, nextProps, "prop", getComponentName(Component), getCurrentFiberStackInDev);
+ }
+ }
+ }
+ var unmaskedContext = getUnmaskedContext(workInProgress, Component, true);
+ var context = getMaskedContext(workInProgress, unmaskedContext);
+ var nextChildren = void 0;
+ prepareToReadContext(workInProgress, renderExpirationTime);
+ {
+ ReactCurrentOwner$3.current = workInProgress;
+ setCurrentPhase("render");
+ nextChildren = renderWithHooks(current$$1, workInProgress, Component, nextProps, context, renderExpirationTime);
+
+ if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
+ if (workInProgress.memoizedState !== null) {
+ nextChildren = renderWithHooks(current$$1, workInProgress, Component, nextProps, context, renderExpirationTime);
+ }
+ }
+
+ setCurrentPhase(null);
+ }
+
+ if (current$$1 !== null && !didReceiveUpdate) {
+ bailoutHooks(current$$1, workInProgress, renderExpirationTime);
+ return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ }
+
+ workInProgress.effectTag |= PerformedWork;
+ reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
+ return workInProgress.child;
+ }
+
+ function updateClassComponent(current$$1, workInProgress, Component, nextProps, renderExpirationTime) {
+ {
+ if (workInProgress.type !== workInProgress.elementType) {
+ var innerPropTypes = Component.propTypes;
+
+ if (innerPropTypes) {
+ checkPropTypes(innerPropTypes, nextProps, "prop", getComponentName(Component), getCurrentFiberStackInDev);
+ }
+ }
+ }
+ var hasContext = void 0;
+
+ if (isContextProvider(Component)) {
+ hasContext = true;
+ pushContextProvider(workInProgress);
+ } else {
+ hasContext = false;
+ }
+
+ prepareToReadContext(workInProgress, renderExpirationTime);
+ var instance = workInProgress.stateNode;
+ var shouldUpdate = void 0;
+
+ if (instance === null) {
+ if (current$$1 !== null) {
+ current$$1.alternate = null;
+ workInProgress.alternate = null;
+ workInProgress.effectTag |= Placement;
+ }
+
+ constructClassInstance(workInProgress, Component, nextProps, renderExpirationTime);
+ mountClassInstance(workInProgress, Component, nextProps, renderExpirationTime);
+ shouldUpdate = true;
+ } else if (current$$1 === null) {
+ shouldUpdate = resumeMountClassInstance(workInProgress, Component, nextProps, renderExpirationTime);
+ } else {
+ shouldUpdate = updateClassInstance(current$$1, workInProgress, Component, nextProps, renderExpirationTime);
+ }
+
+ var nextUnitOfWork = finishClassComponent(current$$1, workInProgress, Component, shouldUpdate, hasContext, renderExpirationTime);
+ {
+ var inst = workInProgress.stateNode;
+
+ if (inst.props !== nextProps) {
+ !didWarnAboutReassigningProps ? warning$1(false, "It looks like %s is reassigning its own `this.props` while rendering. " + "This is not supported and can lead to confusing bugs.", getComponentName(workInProgress.type) || "a component") : void 0;
+ didWarnAboutReassigningProps = true;
+ }
+ }
+ return nextUnitOfWork;
+ }
+
+ function finishClassComponent(current$$1, workInProgress, Component, shouldUpdate, hasContext, renderExpirationTime) {
+ markRef(current$$1, workInProgress);
+ var didCaptureError = (workInProgress.effectTag & DidCapture) !== NoEffect;
+
+ if (!shouldUpdate && !didCaptureError) {
+ if (hasContext) {
+ invalidateContextProvider(workInProgress, Component, false);
+ }
+
+ return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ }
+
+ var instance = workInProgress.stateNode;
+ ReactCurrentOwner$3.current = workInProgress;
+ var nextChildren = void 0;
+
+ if (didCaptureError && typeof Component.getDerivedStateFromError !== "function") {
+ nextChildren = null;
+
+ if (enableProfilerTimer) {
+ stopProfilerTimerIfRunning(workInProgress);
+ }
+ } else {
+ {
+ setCurrentPhase("render");
+ nextChildren = instance.render();
+
+ if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
+ instance.render();
+ }
+
+ setCurrentPhase(null);
+ }
+ }
+
+ workInProgress.effectTag |= PerformedWork;
+
+ if (current$$1 !== null && didCaptureError) {
+ forceUnmountCurrentAndReconcile(current$$1, workInProgress, nextChildren, renderExpirationTime);
+ } else {
+ reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
+ }
+
+ workInProgress.memoizedState = instance.state;
+
+ if (hasContext) {
+ invalidateContextProvider(workInProgress, Component, true);
+ }
+
+ return workInProgress.child;
+ }
+
+ function pushHostRootContext(workInProgress) {
+ var root = workInProgress.stateNode;
+
+ if (root.pendingContext) {
+ pushTopLevelContextObject(workInProgress, root.pendingContext, root.pendingContext !== root.context);
+ } else if (root.context) {
+ pushTopLevelContextObject(workInProgress, root.context, false);
+ }
+
+ pushHostContainer(workInProgress, root.containerInfo);
+ }
+
+ function updateHostRoot(current$$1, workInProgress, renderExpirationTime) {
+ pushHostRootContext(workInProgress);
+ var updateQueue = workInProgress.updateQueue;
+ invariant(updateQueue !== null, "If the root does not have an updateQueue, we should have already " + "bailed out. This error is likely caused by a bug in React. Please " + "file an issue.");
+ var nextProps = workInProgress.pendingProps;
+ var prevState = workInProgress.memoizedState;
+ var prevChildren = prevState !== null ? prevState.element : null;
+ processUpdateQueue(workInProgress, updateQueue, nextProps, null, renderExpirationTime);
+ var nextState = workInProgress.memoizedState;
+ var nextChildren = nextState.element;
+
+ if (nextChildren === prevChildren) {
+ resetHydrationState();
+ return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ }
+
+ var root = workInProgress.stateNode;
+
+ if ((current$$1 === null || current$$1.child === null) && root.hydrate && enterHydrationState(workInProgress)) {
+ workInProgress.effectTag |= Placement;
+ workInProgress.child = mountChildFibers(workInProgress, null, nextChildren, renderExpirationTime);
+ } else {
+ reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
+ resetHydrationState();
+ }
+
+ return workInProgress.child;
+ }
+
+ function updateHostComponent(current$$1, workInProgress, renderExpirationTime) {
+ pushHostContext(workInProgress);
+
+ if (current$$1 === null) {
+ tryToClaimNextHydratableInstance(workInProgress);
+ }
+
+ var type = workInProgress.type;
+ var nextProps = workInProgress.pendingProps;
+ var prevProps = current$$1 !== null ? current$$1.memoizedProps : null;
+ var nextChildren = nextProps.children;
+ var isDirectTextChild = shouldSetTextContent(type, nextProps);
+
+ if (isDirectTextChild) {
+ nextChildren = null;
+ } else if (prevProps !== null && shouldSetTextContent(type, prevProps)) {
+ workInProgress.effectTag |= ContentReset;
+ }
+
+ markRef(current$$1, workInProgress);
+
+ if (renderExpirationTime !== Never && workInProgress.mode & ConcurrentMode && shouldDeprioritizeSubtree(type, nextProps)) {
+ workInProgress.expirationTime = workInProgress.childExpirationTime = Never;
+ return null;
+ }
+
+ reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
+ return workInProgress.child;
+ }
+
+ function updateHostText(current$$1, workInProgress) {
+ if (current$$1 === null) {
+ tryToClaimNextHydratableInstance(workInProgress);
+ }
+
+ return null;
+ }
+
+ function mountLazyComponent(_current, workInProgress, elementType, updateExpirationTime, renderExpirationTime) {
+ if (_current !== null) {
+ _current.alternate = null;
+ workInProgress.alternate = null;
+ workInProgress.effectTag |= Placement;
+ }
+
+ var props = workInProgress.pendingProps;
+ cancelWorkTimer(workInProgress);
+ var Component = readLazyComponentType(elementType);
+ workInProgress.type = Component;
+ var resolvedTag = workInProgress.tag = resolveLazyComponentTag(Component);
+ startWorkTimer(workInProgress);
+ var resolvedProps = resolveDefaultProps(Component, props);
+ var child = void 0;
+
+ switch (resolvedTag) {
+ case FunctionComponent:
+ {
+ {
+ validateFunctionComponentInDev(workInProgress, Component);
+ }
+ child = updateFunctionComponent(null, workInProgress, Component, resolvedProps, renderExpirationTime);
+ break;
+ }
+
+ case ClassComponent:
+ {
+ child = updateClassComponent(null, workInProgress, Component, resolvedProps, renderExpirationTime);
+ break;
+ }
+
+ case ForwardRef:
+ {
+ child = updateForwardRef(null, workInProgress, Component, resolvedProps, renderExpirationTime);
+ break;
+ }
+
+ case MemoComponent:
+ {
+ {
+ if (workInProgress.type !== workInProgress.elementType) {
+ var outerPropTypes = Component.propTypes;
+
+ if (outerPropTypes) {
+ checkPropTypes(outerPropTypes, resolvedProps, "prop", getComponentName(Component), getCurrentFiberStackInDev);
+ }
+ }
+ }
+ child = updateMemoComponent(null, workInProgress, Component, resolveDefaultProps(Component.type, resolvedProps), updateExpirationTime, renderExpirationTime);
+ break;
+ }
+
+ default:
+ {
+ var hint = "";
+ {
+ if (Component !== null && typeof Component === "object" && Component.$$typeof === REACT_LAZY_TYPE) {
+ hint = " Did you wrap a component in React.lazy() more than once?";
+ }
+ }
+ invariant(false, "Element type is invalid. Received a promise that resolves to: %s. " + "Lazy element type must resolve to a class or function.%s", Component, hint);
+ }
+ }
+
+ return child;
+ }
+
+ function mountIncompleteClassComponent(_current, workInProgress, Component, nextProps, renderExpirationTime) {
+ if (_current !== null) {
+ _current.alternate = null;
+ workInProgress.alternate = null;
+ workInProgress.effectTag |= Placement;
+ }
+
+ workInProgress.tag = ClassComponent;
+ var hasContext = void 0;
+
+ if (isContextProvider(Component)) {
+ hasContext = true;
+ pushContextProvider(workInProgress);
+ } else {
+ hasContext = false;
+ }
+
+ prepareToReadContext(workInProgress, renderExpirationTime);
+ constructClassInstance(workInProgress, Component, nextProps, renderExpirationTime);
+ mountClassInstance(workInProgress, Component, nextProps, renderExpirationTime);
+ return finishClassComponent(null, workInProgress, Component, true, hasContext, renderExpirationTime);
+ }
+
+ function mountIndeterminateComponent(_current, workInProgress, Component, renderExpirationTime) {
+ if (_current !== null) {
+ _current.alternate = null;
+ workInProgress.alternate = null;
+ workInProgress.effectTag |= Placement;
+ }
+
+ var props = workInProgress.pendingProps;
+ var unmaskedContext = getUnmaskedContext(workInProgress, Component, false);
+ var context = getMaskedContext(workInProgress, unmaskedContext);
+ prepareToReadContext(workInProgress, renderExpirationTime);
+ var value = void 0;
+ {
+ if (Component.prototype && typeof Component.prototype.render === "function") {
+ var componentName = getComponentName(Component) || "Unknown";
+
+ if (!didWarnAboutBadClass[componentName]) {
+ warningWithoutStack$1(false, "The <%s /> component appears to have a render method, but doesn't extend React.Component. " + "This is likely to cause errors. Change %s to extend React.Component instead.", componentName, componentName);
+ didWarnAboutBadClass[componentName] = true;
+ }
+ }
+
+ if (workInProgress.mode & StrictMode) {
+ ReactStrictModeWarnings.recordLegacyContextWarning(workInProgress, null);
+ }
+
+ ReactCurrentOwner$3.current = workInProgress;
+ value = renderWithHooks(null, workInProgress, Component, props, context, renderExpirationTime);
+ }
+ workInProgress.effectTag |= PerformedWork;
+
+ if (typeof value === "object" && value !== null && typeof value.render === "function" && value.$$typeof === undefined) {
+ workInProgress.tag = ClassComponent;
+ resetHooks();
+ var hasContext = false;
+
+ if (isContextProvider(Component)) {
+ hasContext = true;
+ pushContextProvider(workInProgress);
+ } else {
+ hasContext = false;
+ }
+
+ workInProgress.memoizedState = value.state !== null && value.state !== undefined ? value.state : null;
+ var getDerivedStateFromProps = Component.getDerivedStateFromProps;
+
+ if (typeof getDerivedStateFromProps === "function") {
+ applyDerivedStateFromProps(workInProgress, Component, getDerivedStateFromProps, props);
+ }
+
+ adoptClassInstance(workInProgress, value);
+ mountClassInstance(workInProgress, Component, props, renderExpirationTime);
+ return finishClassComponent(null, workInProgress, Component, true, hasContext, renderExpirationTime);
+ } else {
+ workInProgress.tag = FunctionComponent;
+ {
+ if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
+ if (workInProgress.memoizedState !== null) {
+ value = renderWithHooks(null, workInProgress, Component, props, context, renderExpirationTime);
+ }
+ }
+ }
+ reconcileChildren(null, workInProgress, value, renderExpirationTime);
+ {
+ validateFunctionComponentInDev(workInProgress, Component);
+ }
+ return workInProgress.child;
+ }
+ }
+
+ function validateFunctionComponentInDev(workInProgress, Component) {
+ if (Component) {
+ !!Component.childContextTypes ? warningWithoutStack$1(false, "%s(...): childContextTypes cannot be defined on a function component.", Component.displayName || Component.name || "Component") : void 0;
+ }
+
+ if (workInProgress.ref !== null) {
+ var info = "";
+ var ownerName = getCurrentFiberOwnerNameInDevOrNull();
+
+ if (ownerName) {
+ info += "\n\nCheck the render method of `" + ownerName + "`.";
+ }
+
+ var warningKey = ownerName || workInProgress._debugID || "";
+ var debugSource = workInProgress._debugSource;
+
+ if (debugSource) {
+ warningKey = debugSource.fileName + ":" + debugSource.lineNumber;
+ }
+
+ if (!didWarnAboutFunctionRefs[warningKey]) {
+ didWarnAboutFunctionRefs[warningKey] = true;
+ warning$1(false, "Function components cannot be given refs. " + "Attempts to access this ref will fail. " + "Did you mean to use React.forwardRef()?%s", info);
+ }
+ }
+
+ if (typeof Component.getDerivedStateFromProps === "function") {
+ var componentName = getComponentName(Component) || "Unknown";
+
+ if (!didWarnAboutGetDerivedStateOnFunctionComponent[componentName]) {
+ warningWithoutStack$1(false, "%s: Function components do not support getDerivedStateFromProps.", componentName);
+ didWarnAboutGetDerivedStateOnFunctionComponent[componentName] = true;
+ }
+ }
+
+ if (typeof Component.contextType === "object" && Component.contextType !== null) {
+ var _componentName = getComponentName(Component) || "Unknown";
+
+ if (!didWarnAboutContextTypeOnFunctionComponent[_componentName]) {
+ warningWithoutStack$1(false, "%s: Function components do not support contextType.", _componentName);
+ didWarnAboutContextTypeOnFunctionComponent[_componentName] = true;
+ }
+ }
+ }
+
+ function updateSuspenseComponent(current$$1, workInProgress, renderExpirationTime) {
+ var mode = workInProgress.mode;
+ var nextProps = workInProgress.pendingProps;
+ var nextState = workInProgress.memoizedState;
+ var nextDidTimeout = void 0;
+
+ if ((workInProgress.effectTag & DidCapture) === NoEffect) {
+ nextState = null;
+ nextDidTimeout = false;
+ } else {
+ nextState = {
+ timedOutAt: nextState !== null ? nextState.timedOutAt : NoWork
+ };
+ nextDidTimeout = true;
+ workInProgress.effectTag &= ~DidCapture;
+ }
+
+ var child = void 0;
+ var next = void 0;
+
+ if (current$$1 === null) {
+ if (enableSuspenseServerRenderer) {
+ if (nextProps.fallback !== undefined) {
+ tryToClaimNextHydratableInstance(workInProgress);
+
+ if (workInProgress.tag === DehydratedSuspenseComponent) {
+ return updateDehydratedSuspenseComponent(null, workInProgress, renderExpirationTime);
+ }
+ }
+ }
+
+ if (nextDidTimeout) {
+ var nextFallbackChildren = nextProps.fallback;
+ var primaryChildFragment = createFiberFromFragment(null, mode, NoWork, null);
+
+ if ((workInProgress.mode & ConcurrentMode) === NoContext) {
+ var progressedState = workInProgress.memoizedState;
+ var progressedPrimaryChild = progressedState !== null ? workInProgress.child.child : workInProgress.child;
+ primaryChildFragment.child = progressedPrimaryChild;
+ }
+
+ var fallbackChildFragment = createFiberFromFragment(nextFallbackChildren, mode, renderExpirationTime, null);
+ primaryChildFragment.sibling = fallbackChildFragment;
+ child = primaryChildFragment;
+ next = fallbackChildFragment;
+ child.return = next.return = workInProgress;
+ } else {
+ var nextPrimaryChildren = nextProps.children;
+ child = next = mountChildFibers(workInProgress, null, nextPrimaryChildren, renderExpirationTime);
+ }
+ } else {
+ var prevState = current$$1.memoizedState;
+ var prevDidTimeout = prevState !== null;
+
+ if (prevDidTimeout) {
+ var currentPrimaryChildFragment = current$$1.child;
+ var currentFallbackChildFragment = currentPrimaryChildFragment.sibling;
+
+ if (nextDidTimeout) {
+ var _nextFallbackChildren = nextProps.fallback;
+
+ var _primaryChildFragment = createWorkInProgress(currentPrimaryChildFragment, currentPrimaryChildFragment.pendingProps, NoWork);
+
+ if ((workInProgress.mode & ConcurrentMode) === NoContext) {
+ var _progressedState = workInProgress.memoizedState;
+
+ var _progressedPrimaryChild = _progressedState !== null ? workInProgress.child.child : workInProgress.child;
+
+ if (_progressedPrimaryChild !== currentPrimaryChildFragment.child) {
+ _primaryChildFragment.child = _progressedPrimaryChild;
+ }
+ }
+
+ if (enableProfilerTimer && workInProgress.mode & ProfileMode) {
+ var treeBaseDuration = 0;
+ var hiddenChild = _primaryChildFragment.child;
+
+ while (hiddenChild !== null) {
+ treeBaseDuration += hiddenChild.treeBaseDuration;
+ hiddenChild = hiddenChild.sibling;
+ }
+
+ _primaryChildFragment.treeBaseDuration = treeBaseDuration;
+ }
+
+ var _fallbackChildFragment = _primaryChildFragment.sibling = createWorkInProgress(currentFallbackChildFragment, _nextFallbackChildren, currentFallbackChildFragment.expirationTime);
+
+ child = _primaryChildFragment;
+ _primaryChildFragment.childExpirationTime = NoWork;
+ next = _fallbackChildFragment;
+ child.return = next.return = workInProgress;
+ } else {
+ var _nextPrimaryChildren = nextProps.children;
+ var currentPrimaryChild = currentPrimaryChildFragment.child;
+ var primaryChild = reconcileChildFibers(workInProgress, currentPrimaryChild, _nextPrimaryChildren, renderExpirationTime);
+ child = next = primaryChild;
+ }
+ } else {
+ var _currentPrimaryChild = current$$1.child;
+
+ if (nextDidTimeout) {
+ var _nextFallbackChildren2 = nextProps.fallback;
+
+ var _primaryChildFragment2 = createFiberFromFragment(null, mode, NoWork, null);
+
+ _primaryChildFragment2.child = _currentPrimaryChild;
+
+ if ((workInProgress.mode & ConcurrentMode) === NoContext) {
+ var _progressedState2 = workInProgress.memoizedState;
+
+ var _progressedPrimaryChild2 = _progressedState2 !== null ? workInProgress.child.child : workInProgress.child;
+
+ _primaryChildFragment2.child = _progressedPrimaryChild2;
+ }
+
+ if (enableProfilerTimer && workInProgress.mode & ProfileMode) {
+ var _treeBaseDuration = 0;
+ var _hiddenChild = _primaryChildFragment2.child;
+
+ while (_hiddenChild !== null) {
+ _treeBaseDuration += _hiddenChild.treeBaseDuration;
+ _hiddenChild = _hiddenChild.sibling;
+ }
+
+ _primaryChildFragment2.treeBaseDuration = _treeBaseDuration;
+ }
+
+ var _fallbackChildFragment2 = _primaryChildFragment2.sibling = createFiberFromFragment(_nextFallbackChildren2, mode, renderExpirationTime, null);
+
+ _fallbackChildFragment2.effectTag |= Placement;
+ child = _primaryChildFragment2;
+ _primaryChildFragment2.childExpirationTime = NoWork;
+ next = _fallbackChildFragment2;
+ child.return = next.return = workInProgress;
+ } else {
+ var _nextPrimaryChildren2 = nextProps.children;
+ next = child = reconcileChildFibers(workInProgress, _currentPrimaryChild, _nextPrimaryChildren2, renderExpirationTime);
+ }
+ }
+
+ workInProgress.stateNode = current$$1.stateNode;
+ }
+
+ workInProgress.memoizedState = nextState;
+ workInProgress.child = child;
+ return next;
+ }
+
+ function updateDehydratedSuspenseComponent(current$$1, workInProgress, renderExpirationTime) {
+ if (current$$1 === null) {
+ workInProgress.expirationTime = Never;
+ return null;
+ }
+
+ if ((workInProgress.effectTag & DidCapture) !== NoEffect) {
+ workInProgress.child = null;
+ return null;
+ }
+
+ var hasContextChanged$$1 = current$$1.childExpirationTime >= renderExpirationTime;
+ var suspenseInstance = current$$1.stateNode;
+
+ if (didReceiveUpdate || hasContextChanged$$1 || isSuspenseInstanceFallback(suspenseInstance)) {
+ current$$1.alternate = null;
+ workInProgress.alternate = null;
+ var returnFiber = workInProgress.return;
+ invariant(returnFiber !== null, "Suspense boundaries are never on the root. " + "This is probably a bug in React.");
+ var last = returnFiber.lastEffect;
+
+ if (last !== null) {
+ last.nextEffect = current$$1;
+ returnFiber.lastEffect = current$$1;
+ } else {
+ returnFiber.firstEffect = returnFiber.lastEffect = current$$1;
+ }
+
+ current$$1.nextEffect = null;
+ current$$1.effectTag = Deletion;
+ workInProgress.tag = SuspenseComponent;
+ workInProgress.stateNode = null;
+ workInProgress.memoizedState = null;
+ workInProgress.effectTag |= Placement;
+ return updateSuspenseComponent(null, workInProgress, renderExpirationTime);
+ } else if (isSuspenseInstancePending(suspenseInstance)) {
+ workInProgress.effectTag |= DidCapture;
+ workInProgress.child = null;
+ registerSuspenseInstanceRetry(suspenseInstance, retryTimedOutBoundary.bind(null, current$$1));
+ return null;
+ } else {
+ reenterHydrationStateFromDehydratedSuspenseInstance(workInProgress);
+ var nextProps = workInProgress.pendingProps;
+ var nextChildren = nextProps.children;
+ workInProgress.child = mountChildFibers(workInProgress, null, nextChildren, renderExpirationTime);
+ return workInProgress.child;
+ }
+ }
+
+ function updatePortalComponent(current$$1, workInProgress, renderExpirationTime) {
+ pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+ var nextChildren = workInProgress.pendingProps;
+
+ if (current$$1 === null) {
+ workInProgress.child = reconcileChildFibers(workInProgress, null, nextChildren, renderExpirationTime);
+ } else {
+ reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
+ }
+
+ return workInProgress.child;
+ }
+
+ function updateContextProvider(current$$1, workInProgress, renderExpirationTime) {
+ var providerType = workInProgress.type;
+ var context = providerType._context;
+ var newProps = workInProgress.pendingProps;
+ var oldProps = workInProgress.memoizedProps;
+ var newValue = newProps.value;
+ {
+ var providerPropTypes = workInProgress.type.propTypes;
+
+ if (providerPropTypes) {
+ checkPropTypes(providerPropTypes, newProps, "prop", "Context.Provider", getCurrentFiberStackInDev);
+ }
+ }
+ pushProvider(workInProgress, newValue);
+
+ if (oldProps !== null) {
+ var oldValue = oldProps.value;
+ var changedBits = calculateChangedBits(context, newValue, oldValue);
+
+ if (changedBits === 0) {
+ if (oldProps.children === newProps.children && !hasContextChanged()) {
+ return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ }
+ } else {
+ propagateContextChange(workInProgress, context, changedBits, renderExpirationTime);
+ }
+ }
+
+ var newChildren = newProps.children;
+ reconcileChildren(current$$1, workInProgress, newChildren, renderExpirationTime);
+ return workInProgress.child;
+ }
+
+ var hasWarnedAboutUsingContextAsConsumer = false;
+
+ function updateContextConsumer(current$$1, workInProgress, renderExpirationTime) {
+ var context = workInProgress.type;
+ {
+ if (context._context === undefined) {
+ if (context !== context.Consumer) {
+ if (!hasWarnedAboutUsingContextAsConsumer) {
+ hasWarnedAboutUsingContextAsConsumer = true;
+ warning$1(false, "Rendering directly is not supported and will be removed in " + "a future major release. Did you mean to render instead?");
+ }
+ }
+ } else {
+ context = context._context;
+ }
+ }
+ var newProps = workInProgress.pendingProps;
+ var render = newProps.children;
+ {
+ !(typeof render === "function") ? warningWithoutStack$1(false, "A context consumer was rendered with multiple children, or a child " + "that isn't a function. A context consumer expects a single child " + "that is a function. If you did pass a function, make sure there " + "is no trailing or leading whitespace around it.") : void 0;
+ }
+ prepareToReadContext(workInProgress, renderExpirationTime);
+
+ var newValue = _readContext(context, newProps.unstable_observedBits);
+
+ var newChildren = void 0;
+ {
+ ReactCurrentOwner$3.current = workInProgress;
+ setCurrentPhase("render");
+ newChildren = render(newValue);
+ setCurrentPhase(null);
+ }
+ workInProgress.effectTag |= PerformedWork;
+ reconcileChildren(current$$1, workInProgress, newChildren, renderExpirationTime);
+ return workInProgress.child;
+ }
+
+ function markWorkInProgressReceivedUpdate() {
+ didReceiveUpdate = true;
+ }
+
+ function bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime) {
+ cancelWorkTimer(workInProgress);
+
+ if (current$$1 !== null) {
+ workInProgress.contextDependencies = current$$1.contextDependencies;
+ }
+
+ if (enableProfilerTimer) {
+ stopProfilerTimerIfRunning(workInProgress);
+ }
+
+ var childExpirationTime = workInProgress.childExpirationTime;
+
+ if (childExpirationTime < renderExpirationTime) {
+ return null;
+ } else {
+ cloneChildFibers(current$$1, workInProgress);
+ return workInProgress.child;
+ }
+ }
+
+ function beginWork(current$$1, workInProgress, renderExpirationTime) {
+ var updateExpirationTime = workInProgress.expirationTime;
+
+ if (current$$1 !== null) {
+ var oldProps = current$$1.memoizedProps;
+ var newProps = workInProgress.pendingProps;
+
+ if (oldProps !== newProps || hasContextChanged()) {
+ didReceiveUpdate = true;
+ } else if (updateExpirationTime < renderExpirationTime) {
+ didReceiveUpdate = false;
+
+ switch (workInProgress.tag) {
+ case HostRoot:
+ pushHostRootContext(workInProgress);
+ resetHydrationState();
+ break;
+
+ case HostComponent:
+ pushHostContext(workInProgress);
+ break;
+
+ case ClassComponent:
+ {
+ var Component = workInProgress.type;
+
+ if (isContextProvider(Component)) {
+ pushContextProvider(workInProgress);
+ }
+
+ break;
+ }
+
+ case HostPortal:
+ pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+ break;
+
+ case ContextProvider:
+ {
+ var newValue = workInProgress.memoizedProps.value;
+ pushProvider(workInProgress, newValue);
+ break;
+ }
+
+ case Profiler:
+ if (enableProfilerTimer) {
+ workInProgress.effectTag |= Update;
+ }
+
+ break;
+
+ case SuspenseComponent:
+ {
+ var state = workInProgress.memoizedState;
+ var didTimeout = state !== null;
+
+ if (didTimeout) {
+ var primaryChildFragment = workInProgress.child;
+ var primaryChildExpirationTime = primaryChildFragment.childExpirationTime;
+
+ if (primaryChildExpirationTime !== NoWork && primaryChildExpirationTime >= renderExpirationTime) {
+ return updateSuspenseComponent(current$$1, workInProgress, renderExpirationTime);
+ } else {
+ var child = bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+
+ if (child !== null) {
+ return child.sibling;
+ } else {
+ return null;
+ }
+ }
+ }
+
+ break;
+ }
+
+ case DehydratedSuspenseComponent:
+ {
+ if (enableSuspenseServerRenderer) {
+ workInProgress.effectTag |= DidCapture;
+ break;
+ }
+ }
+ }
+
+ return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ }
+ } else {
+ didReceiveUpdate = false;
+ }
+
+ workInProgress.expirationTime = NoWork;
+
+ switch (workInProgress.tag) {
+ case IndeterminateComponent:
+ {
+ var elementType = workInProgress.elementType;
+ return mountIndeterminateComponent(current$$1, workInProgress, elementType, renderExpirationTime);
+ }
+
+ case LazyComponent:
+ {
+ var _elementType = workInProgress.elementType;
+ return mountLazyComponent(current$$1, workInProgress, _elementType, updateExpirationTime, renderExpirationTime);
+ }
+
+ case FunctionComponent:
+ {
+ var _Component = workInProgress.type;
+ var unresolvedProps = workInProgress.pendingProps;
+ var resolvedProps = workInProgress.elementType === _Component ? unresolvedProps : resolveDefaultProps(_Component, unresolvedProps);
+ return updateFunctionComponent(current$$1, workInProgress, _Component, resolvedProps, renderExpirationTime);
+ }
+
+ case ClassComponent:
+ {
+ var _Component2 = workInProgress.type;
+ var _unresolvedProps = workInProgress.pendingProps;
+
+ var _resolvedProps = workInProgress.elementType === _Component2 ? _unresolvedProps : resolveDefaultProps(_Component2, _unresolvedProps);
+
+ return updateClassComponent(current$$1, workInProgress, _Component2, _resolvedProps, renderExpirationTime);
+ }
+
+ case HostRoot:
+ return updateHostRoot(current$$1, workInProgress, renderExpirationTime);
+
+ case HostComponent:
+ return updateHostComponent(current$$1, workInProgress, renderExpirationTime);
+
+ case HostText:
+ return updateHostText(current$$1, workInProgress);
+
+ case SuspenseComponent:
+ return updateSuspenseComponent(current$$1, workInProgress, renderExpirationTime);
+
+ case HostPortal:
+ return updatePortalComponent(current$$1, workInProgress, renderExpirationTime);
+
+ case ForwardRef:
+ {
+ var type = workInProgress.type;
+ var _unresolvedProps2 = workInProgress.pendingProps;
+
+ var _resolvedProps2 = workInProgress.elementType === type ? _unresolvedProps2 : resolveDefaultProps(type, _unresolvedProps2);
+
+ return updateForwardRef(current$$1, workInProgress, type, _resolvedProps2, renderExpirationTime);
+ }
+
+ case Fragment:
+ return updateFragment(current$$1, workInProgress, renderExpirationTime);
+
+ case Mode:
+ return updateMode(current$$1, workInProgress, renderExpirationTime);
+
+ case Profiler:
+ return updateProfiler(current$$1, workInProgress, renderExpirationTime);
+
+ case ContextProvider:
+ return updateContextProvider(current$$1, workInProgress, renderExpirationTime);
+
+ case ContextConsumer:
+ return updateContextConsumer(current$$1, workInProgress, renderExpirationTime);
+
+ case MemoComponent:
+ {
+ var _type2 = workInProgress.type;
+ var _unresolvedProps3 = workInProgress.pendingProps;
+
+ var _resolvedProps3 = resolveDefaultProps(_type2, _unresolvedProps3);
+
+ {
+ if (workInProgress.type !== workInProgress.elementType) {
+ var outerPropTypes = _type2.propTypes;
+
+ if (outerPropTypes) {
+ checkPropTypes(outerPropTypes, _resolvedProps3, "prop", getComponentName(_type2), getCurrentFiberStackInDev);
+ }
+ }
+ }
+ _resolvedProps3 = resolveDefaultProps(_type2.type, _resolvedProps3);
+ return updateMemoComponent(current$$1, workInProgress, _type2, _resolvedProps3, updateExpirationTime, renderExpirationTime);
+ }
+
+ case SimpleMemoComponent:
+ {
+ return updateSimpleMemoComponent(current$$1, workInProgress, workInProgress.type, workInProgress.pendingProps, updateExpirationTime, renderExpirationTime);
+ }
+
+ case IncompleteClassComponent:
+ {
+ var _Component3 = workInProgress.type;
+ var _unresolvedProps4 = workInProgress.pendingProps;
+
+ var _resolvedProps4 = workInProgress.elementType === _Component3 ? _unresolvedProps4 : resolveDefaultProps(_Component3, _unresolvedProps4);
+
+ return mountIncompleteClassComponent(current$$1, workInProgress, _Component3, _resolvedProps4, renderExpirationTime);
+ }
+
+ case DehydratedSuspenseComponent:
+ {
+ if (enableSuspenseServerRenderer) {
+ return updateDehydratedSuspenseComponent(current$$1, workInProgress, renderExpirationTime);
+ }
+
+ break;
+ }
+ }
+
+ invariant(false, "Unknown unit of work tag. This error is likely caused by a bug in " + "React. Please file an issue.");
+ }
+
+ var valueCursor = createCursor(null);
+ var rendererSigil = void 0;
+ {
+ rendererSigil = {};
+ }
+ var currentlyRenderingFiber = null;
+ var lastContextDependency = null;
+ var lastContextWithAllBitsObserved = null;
+ var isDisallowedContextReadInDEV = false;
+
+ function resetContextDependences() {
+ currentlyRenderingFiber = null;
+ lastContextDependency = null;
+ lastContextWithAllBitsObserved = null;
+ {
+ isDisallowedContextReadInDEV = false;
+ }
+ }
+
+ function enterDisallowedContextReadInDEV() {
+ {
+ isDisallowedContextReadInDEV = true;
+ }
+ }
+
+ function exitDisallowedContextReadInDEV() {
+ {
+ isDisallowedContextReadInDEV = false;
+ }
+ }
+
+ function pushProvider(providerFiber, nextValue) {
+ var context = providerFiber.type._context;
+
+ if (isPrimaryRenderer) {
+ push(valueCursor, context._currentValue, providerFiber);
+ context._currentValue = nextValue;
+ {
+ !(context._currentRenderer === undefined || context._currentRenderer === null || context._currentRenderer === rendererSigil) ? warningWithoutStack$1(false, "Detected multiple renderers concurrently rendering the " + "same context provider. This is currently unsupported.") : void 0;
+ context._currentRenderer = rendererSigil;
+ }
+ } else {
+ push(valueCursor, context._currentValue2, providerFiber);
+ context._currentValue2 = nextValue;
+ {
+ !(context._currentRenderer2 === undefined || context._currentRenderer2 === null || context._currentRenderer2 === rendererSigil) ? warningWithoutStack$1(false, "Detected multiple renderers concurrently rendering the " + "same context provider. This is currently unsupported.") : void 0;
+ context._currentRenderer2 = rendererSigil;
+ }
+ }
+ }
+
+ function popProvider(providerFiber) {
+ var currentValue = valueCursor.current;
+ pop(valueCursor, providerFiber);
+ var context = providerFiber.type._context;
+
+ if (isPrimaryRenderer) {
+ context._currentValue = currentValue;
+ } else {
+ context._currentValue2 = currentValue;
+ }
+ }
+
+ function calculateChangedBits(context, newValue, oldValue) {
+ if (is(oldValue, newValue)) {
+ return 0;
+ } else {
+ var changedBits = typeof context._calculateChangedBits === "function" ? context._calculateChangedBits(oldValue, newValue) : maxSigned31BitInt;
+ {
+ !((changedBits & maxSigned31BitInt) === changedBits) ? warning$1(false, "calculateChangedBits: Expected the return value to be a " + "31-bit integer. Instead received: %s", changedBits) : void 0;
+ }
+ return changedBits | 0;
+ }
+ }
+
+ function scheduleWorkOnParentPath(parent, renderExpirationTime) {
+ var node = parent;
+
+ while (node !== null) {
+ var alternate = node.alternate;
+
+ if (node.childExpirationTime < renderExpirationTime) {
+ node.childExpirationTime = renderExpirationTime;
+
+ if (alternate !== null && alternate.childExpirationTime < renderExpirationTime) {
+ alternate.childExpirationTime = renderExpirationTime;
+ }
+ } else if (alternate !== null && alternate.childExpirationTime < renderExpirationTime) {
+ alternate.childExpirationTime = renderExpirationTime;
+ } else {
+ break;
+ }
+
+ node = node.return;
+ }
+ }
+
+ function propagateContextChange(workInProgress, context, changedBits, renderExpirationTime) {
+ var fiber = workInProgress.child;
+
+ if (fiber !== null) {
+ fiber.return = workInProgress;
+ }
+
+ while (fiber !== null) {
+ var nextFiber = void 0;
+ var list = fiber.contextDependencies;
+
+ if (list !== null) {
+ nextFiber = fiber.child;
+ var dependency = list.first;
+
+ while (dependency !== null) {
+ if (dependency.context === context && (dependency.observedBits & changedBits) !== 0) {
+ if (fiber.tag === ClassComponent) {
+ var update = createUpdate(renderExpirationTime);
+ update.tag = ForceUpdate;
+ enqueueUpdate(fiber, update);
+ }
+
+ if (fiber.expirationTime < renderExpirationTime) {
+ fiber.expirationTime = renderExpirationTime;
+ }
+
+ var alternate = fiber.alternate;
+
+ if (alternate !== null && alternate.expirationTime < renderExpirationTime) {
+ alternate.expirationTime = renderExpirationTime;
+ }
+
+ scheduleWorkOnParentPath(fiber.return, renderExpirationTime);
+
+ if (list.expirationTime < renderExpirationTime) {
+ list.expirationTime = renderExpirationTime;
+ }
+
+ break;
+ }
+
+ dependency = dependency.next;
+ }
+ } else if (fiber.tag === ContextProvider) {
+ nextFiber = fiber.type === workInProgress.type ? null : fiber.child;
+ } else if (enableSuspenseServerRenderer && fiber.tag === DehydratedSuspenseComponent) {
+ if (fiber.expirationTime < renderExpirationTime) {
+ fiber.expirationTime = renderExpirationTime;
+ }
+
+ var _alternate = fiber.alternate;
+
+ if (_alternate !== null && _alternate.expirationTime < renderExpirationTime) {
+ _alternate.expirationTime = renderExpirationTime;
+ }
+
+ scheduleWorkOnParentPath(fiber, renderExpirationTime);
+ nextFiber = fiber.sibling;
+ } else {
+ nextFiber = fiber.child;
+ }
+
+ if (nextFiber !== null) {
+ nextFiber.return = fiber;
+ } else {
+ nextFiber = fiber;
+
+ while (nextFiber !== null) {
+ if (nextFiber === workInProgress) {
+ nextFiber = null;
+ break;
+ }
+
+ var sibling = nextFiber.sibling;
+
+ if (sibling !== null) {
+ sibling.return = nextFiber.return;
+ nextFiber = sibling;
+ break;
+ }
+
+ nextFiber = nextFiber.return;
+ }
+ }
+
+ fiber = nextFiber;
+ }
+ }
+
+ function prepareToReadContext(workInProgress, renderExpirationTime) {
+ currentlyRenderingFiber = workInProgress;
+ lastContextDependency = null;
+ lastContextWithAllBitsObserved = null;
+ var currentDependencies = workInProgress.contextDependencies;
+
+ if (currentDependencies !== null && currentDependencies.expirationTime >= renderExpirationTime) {
+ markWorkInProgressReceivedUpdate();
+ }
+
+ workInProgress.contextDependencies = null;
+ }
+
+ function _readContext(context, observedBits) {
+ {
+ !!isDisallowedContextReadInDEV ? warning$1(false, "Context can only be read while React is rendering. " + "In classes, you can read it in the render method or getDerivedStateFromProps. " + "In function components, you can read it directly in the function body, but not " + "inside Hooks like useReducer() or useMemo().") : void 0;
+ }
+
+ if (lastContextWithAllBitsObserved === context) {} else if (observedBits === false || observedBits === 0) {} else {
+ var resolvedObservedBits = void 0;
+
+ if (typeof observedBits !== "number" || observedBits === maxSigned31BitInt) {
+ lastContextWithAllBitsObserved = context;
+ resolvedObservedBits = maxSigned31BitInt;
+ } else {
+ resolvedObservedBits = observedBits;
+ }
+
+ var contextItem = {
+ context: context,
+ observedBits: resolvedObservedBits,
+ next: null
+ };
+
+ if (lastContextDependency === null) {
+ invariant(currentlyRenderingFiber !== null, "Context can only be read while React is rendering. " + "In classes, you can read it in the render method or getDerivedStateFromProps. " + "In function components, you can read it directly in the function body, but not " + "inside Hooks like useReducer() or useMemo().");
+ lastContextDependency = contextItem;
+ currentlyRenderingFiber.contextDependencies = {
+ first: contextItem,
+ expirationTime: NoWork
+ };
+ } else {
+ lastContextDependency = lastContextDependency.next = contextItem;
+ }
+ }
+
+ return isPrimaryRenderer ? context._currentValue : context._currentValue2;
+ }
+
+ var UpdateState = 0;
+ var ReplaceState = 1;
+ var ForceUpdate = 2;
+ var CaptureUpdate = 3;
+ var hasForceUpdate = false;
+ var didWarnUpdateInsideUpdate = void 0;
+ var currentlyProcessingQueue = void 0;
+ var resetCurrentlyProcessingQueue = void 0;
+ {
+ didWarnUpdateInsideUpdate = false;
+ currentlyProcessingQueue = null;
+
+ resetCurrentlyProcessingQueue = function resetCurrentlyProcessingQueue() {
+ currentlyProcessingQueue = null;
+ };
+ }
+
+ function createUpdateQueue(baseState) {
+ var queue = {
+ baseState: baseState,
+ firstUpdate: null,
+ lastUpdate: null,
+ firstCapturedUpdate: null,
+ lastCapturedUpdate: null,
+ firstEffect: null,
+ lastEffect: null,
+ firstCapturedEffect: null,
+ lastCapturedEffect: null
+ };
+ return queue;
+ }
+
+ function cloneUpdateQueue(currentQueue) {
+ var queue = {
+ baseState: currentQueue.baseState,
+ firstUpdate: currentQueue.firstUpdate,
+ lastUpdate: currentQueue.lastUpdate,
+ firstCapturedUpdate: null,
+ lastCapturedUpdate: null,
+ firstEffect: null,
+ lastEffect: null,
+ firstCapturedEffect: null,
+ lastCapturedEffect: null
+ };
+ return queue;
+ }
+
+ function createUpdate(expirationTime) {
+ return {
+ expirationTime: expirationTime,
+ tag: UpdateState,
+ payload: null,
+ callback: null,
+ next: null,
+ nextEffect: null
+ };
+ }
+
+ function appendUpdateToQueue(queue, update) {
+ if (queue.lastUpdate === null) {
+ queue.firstUpdate = queue.lastUpdate = update;
+ } else {
+ queue.lastUpdate.next = update;
+ queue.lastUpdate = update;
+ }
+ }
+
+ function enqueueUpdate(fiber, update) {
+ var alternate = fiber.alternate;
+ var queue1 = void 0;
+ var queue2 = void 0;
+
+ if (alternate === null) {
+ queue1 = fiber.updateQueue;
+ queue2 = null;
+
+ if (queue1 === null) {
+ queue1 = fiber.updateQueue = createUpdateQueue(fiber.memoizedState);
+ }
+ } else {
+ queue1 = fiber.updateQueue;
+ queue2 = alternate.updateQueue;
+
+ if (queue1 === null) {
+ if (queue2 === null) {
+ queue1 = fiber.updateQueue = createUpdateQueue(fiber.memoizedState);
+ queue2 = alternate.updateQueue = createUpdateQueue(alternate.memoizedState);
+ } else {
+ queue1 = fiber.updateQueue = cloneUpdateQueue(queue2);
+ }
+ } else {
+ if (queue2 === null) {
+ queue2 = alternate.updateQueue = cloneUpdateQueue(queue1);
+ } else {}
+ }
+ }
+
+ if (queue2 === null || queue1 === queue2) {
+ appendUpdateToQueue(queue1, update);
+ } else {
+ if (queue1.lastUpdate === null || queue2.lastUpdate === null) {
+ appendUpdateToQueue(queue1, update);
+ appendUpdateToQueue(queue2, update);
+ } else {
+ appendUpdateToQueue(queue1, update);
+ queue2.lastUpdate = update;
+ }
+ }
+
+ {
+ if (fiber.tag === ClassComponent && (currentlyProcessingQueue === queue1 || queue2 !== null && currentlyProcessingQueue === queue2) && !didWarnUpdateInsideUpdate) {
+ warningWithoutStack$1(false, "An update (setState, replaceState, or forceUpdate) was scheduled " + "from inside an update function. Update functions should be pure, " + "with zero side-effects. Consider using componentDidUpdate or a " + "callback.");
+ didWarnUpdateInsideUpdate = true;
+ }
+ }
+ }
+
+ function enqueueCapturedUpdate(workInProgress, update) {
+ var workInProgressQueue = workInProgress.updateQueue;
+
+ if (workInProgressQueue === null) {
+ workInProgressQueue = workInProgress.updateQueue = createUpdateQueue(workInProgress.memoizedState);
+ } else {
+ workInProgressQueue = ensureWorkInProgressQueueIsAClone(workInProgress, workInProgressQueue);
+ }
+
+ if (workInProgressQueue.lastCapturedUpdate === null) {
+ workInProgressQueue.firstCapturedUpdate = workInProgressQueue.lastCapturedUpdate = update;
+ } else {
+ workInProgressQueue.lastCapturedUpdate.next = update;
+ workInProgressQueue.lastCapturedUpdate = update;
+ }
+ }
+
+ function ensureWorkInProgressQueueIsAClone(workInProgress, queue) {
+ var current = workInProgress.alternate;
+
+ if (current !== null) {
+ if (queue === current.updateQueue) {
+ queue = workInProgress.updateQueue = cloneUpdateQueue(queue);
+ }
+ }
+
+ return queue;
+ }
+
+ function getStateFromUpdate(workInProgress, queue, update, prevState, nextProps, instance) {
+ switch (update.tag) {
+ case ReplaceState:
+ {
+ var _payload = update.payload;
+
+ if (typeof _payload === "function") {
+ {
+ enterDisallowedContextReadInDEV();
+
+ if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
+ _payload.call(instance, prevState, nextProps);
+ }
+ }
+
+ var nextState = _payload.call(instance, prevState, nextProps);
+
+ {
+ exitDisallowedContextReadInDEV();
+ }
+ return nextState;
+ }
+
+ return _payload;
+ }
+
+ case CaptureUpdate:
+ {
+ workInProgress.effectTag = workInProgress.effectTag & ~ShouldCapture | DidCapture;
+ }
+
+ case UpdateState:
+ {
+ var _payload2 = update.payload;
+ var partialState = void 0;
+
+ if (typeof _payload2 === "function") {
+ {
+ enterDisallowedContextReadInDEV();
+
+ if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
+ _payload2.call(instance, prevState, nextProps);
+ }
+ }
+ partialState = _payload2.call(instance, prevState, nextProps);
+ {
+ exitDisallowedContextReadInDEV();
+ }
+ } else {
+ partialState = _payload2;
+ }
+
+ if (partialState === null || partialState === undefined) {
+ return prevState;
+ }
+
+ return _extends({}, prevState, partialState);
+ }
+
+ case ForceUpdate:
+ {
+ hasForceUpdate = true;
+ return prevState;
+ }
+ }
+
+ return prevState;
+ }
+
+ function processUpdateQueue(workInProgress, queue, props, instance, renderExpirationTime) {
+ hasForceUpdate = false;
+ queue = ensureWorkInProgressQueueIsAClone(workInProgress, queue);
+ {
+ currentlyProcessingQueue = queue;
+ }
+ var newBaseState = queue.baseState;
+ var newFirstUpdate = null;
+ var newExpirationTime = NoWork;
+ var update = queue.firstUpdate;
+ var resultState = newBaseState;
+
+ while (update !== null) {
+ var updateExpirationTime = update.expirationTime;
+
+ if (updateExpirationTime < renderExpirationTime) {
+ if (newFirstUpdate === null) {
+ newFirstUpdate = update;
+ newBaseState = resultState;
+ }
+
+ if (newExpirationTime < updateExpirationTime) {
+ newExpirationTime = updateExpirationTime;
+ }
+ } else {
+ resultState = getStateFromUpdate(workInProgress, queue, update, resultState, props, instance);
+ var _callback = update.callback;
+
+ if (_callback !== null) {
+ workInProgress.effectTag |= Callback;
+ update.nextEffect = null;
+
+ if (queue.lastEffect === null) {
+ queue.firstEffect = queue.lastEffect = update;
+ } else {
+ queue.lastEffect.nextEffect = update;
+ queue.lastEffect = update;
+ }
+ }
+ }
+
+ update = update.next;
+ }
+
+ var newFirstCapturedUpdate = null;
+ update = queue.firstCapturedUpdate;
+
+ while (update !== null) {
+ var _updateExpirationTime = update.expirationTime;
+
+ if (_updateExpirationTime < renderExpirationTime) {
+ if (newFirstCapturedUpdate === null) {
+ newFirstCapturedUpdate = update;
+
+ if (newFirstUpdate === null) {
+ newBaseState = resultState;
+ }
+ }
+
+ if (newExpirationTime < _updateExpirationTime) {
+ newExpirationTime = _updateExpirationTime;
+ }
+ } else {
+ resultState = getStateFromUpdate(workInProgress, queue, update, resultState, props, instance);
+ var _callback2 = update.callback;
+
+ if (_callback2 !== null) {
+ workInProgress.effectTag |= Callback;
+ update.nextEffect = null;
+
+ if (queue.lastCapturedEffect === null) {
+ queue.firstCapturedEffect = queue.lastCapturedEffect = update;
+ } else {
+ queue.lastCapturedEffect.nextEffect = update;
+ queue.lastCapturedEffect = update;
+ }
+ }
+ }
+
+ update = update.next;
+ }
+
+ if (newFirstUpdate === null) {
+ queue.lastUpdate = null;
+ }
+
+ if (newFirstCapturedUpdate === null) {
+ queue.lastCapturedUpdate = null;
+ } else {
+ workInProgress.effectTag |= Callback;
+ }
+
+ if (newFirstUpdate === null && newFirstCapturedUpdate === null) {
+ newBaseState = resultState;
+ }
+
+ queue.baseState = newBaseState;
+ queue.firstUpdate = newFirstUpdate;
+ queue.firstCapturedUpdate = newFirstCapturedUpdate;
+ workInProgress.expirationTime = newExpirationTime;
+ workInProgress.memoizedState = resultState;
+ {
+ currentlyProcessingQueue = null;
+ }
+ }
+
+ function callCallback(callback, context) {
+ 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;
+ }
+
+ commitUpdateEffects(finishedQueue.firstEffect, instance);
+ finishedQueue.firstEffect = finishedQueue.lastEffect = null;
+ commitUpdateEffects(finishedQueue.firstCapturedEffect, instance);
+ finishedQueue.firstCapturedEffect = finishedQueue.lastCapturedEffect = null;
+ }
+
+ function commitUpdateEffects(effect, instance) {
+ while (effect !== null) {
+ var _callback3 = effect.callback;
+
+ if (_callback3 !== null) {
+ effect.callback = null;
+ callCallback(_callback3, instance);
+ }
+
+ effect = effect.nextEffect;
+ }
+ }
+
+ function createCapturedValue(value, source) {
+ return {
+ value: value,
+ source: source,
+ stack: getStackByFiberInDevAndProd(source)
+ };
+ }
+
+ function markUpdate(workInProgress) {
+ workInProgress.effectTag |= Update;
+ }
+
+ function markRef$1(workInProgress) {
+ workInProgress.effectTag |= Ref;
+ }
+
+ var _appendAllChildren = void 0;
+
+ var updateHostContainer = void 0;
+ var updateHostComponent$1 = void 0;
+ var updateHostText$1 = void 0;
+
+ if (supportsMutation) {
+ _appendAllChildren = function appendAllChildren(parent, workInProgress, needsVisibilityToggle, isHidden) {
+ var node = workInProgress.child;
+
+ while (node !== null) {
+ if (node.tag === HostComponent || node.tag === HostText) {
+ appendInitialChild(parent, node.stateNode);
+ } else if (node.tag === HostPortal) {} else if (node.child !== null) {
+ node.child.return = node;
+ node = node.child;
+ continue;
+ }
+
+ if (node === workInProgress) {
+ return;
+ }
+
+ while (node.sibling === null) {
+ if (node.return === null || node.return === workInProgress) {
+ return;
+ }
+
+ node = node.return;
+ }
+
+ node.sibling.return = node.return;
+ node = node.sibling;
+ }
+ };
+
+ updateHostContainer = function updateHostContainer(workInProgress) {};
+
+ updateHostComponent$1 = function updateHostComponent$1(current, workInProgress, type, newProps, rootContainerInstance) {
+ var oldProps = current.memoizedProps;
+
+ if (oldProps === newProps) {
+ return;
+ }
+
+ var instance = workInProgress.stateNode;
+ var currentHostContext = getHostContext();
+ var updatePayload = prepareUpdate(instance, type, oldProps, newProps, rootContainerInstance, currentHostContext);
+ workInProgress.updateQueue = updatePayload;
+
+ if (updatePayload) {
+ markUpdate(workInProgress);
+ }
+ };
+
+ updateHostText$1 = function updateHostText$1(current, workInProgress, oldText, newText) {
+ if (oldText !== newText) {
+ markUpdate(workInProgress);
+ }
+ };
+ } else if (supportsPersistence) {
+ _appendAllChildren = function appendAllChildren(parent, workInProgress, needsVisibilityToggle, isHidden) {
+ var node = workInProgress.child;
+
+ while (node !== null) {
+ branches: if (node.tag === HostComponent) {
+ var instance = node.stateNode;
+
+ if (needsVisibilityToggle) {
+ var props = node.memoizedProps;
+ var type = node.type;
+
+ if (isHidden) {
+ instance = cloneHiddenInstance(instance, type, props, node);
+ } else {
+ instance = cloneUnhiddenInstance(instance, type, props, node);
+ }
+
+ node.stateNode = instance;
+ }
+
+ appendInitialChild(parent, instance);
+ } else if (node.tag === HostText) {
+ var _instance = node.stateNode;
+
+ if (needsVisibilityToggle) {
+ var text = node.memoizedProps;
+ var rootContainerInstance = getRootHostContainer();
+ var currentHostContext = getHostContext();
+
+ if (isHidden) {
+ _instance = createHiddenTextInstance(text, rootContainerInstance, currentHostContext, workInProgress);
+ } else {
+ _instance = createTextInstance(text, rootContainerInstance, currentHostContext, workInProgress);
+ }
+
+ node.stateNode = _instance;
+ }
+
+ appendInitialChild(parent, _instance);
+ } else if (node.tag === HostPortal) {} else if (node.tag === SuspenseComponent) {
+ var current = node.alternate;
+
+ if (current !== null) {
+ var oldState = current.memoizedState;
+ var newState = node.memoizedState;
+ var oldIsHidden = oldState !== null;
+ var newIsHidden = newState !== null;
+
+ if (oldIsHidden !== newIsHidden) {
+ var primaryChildParent = newIsHidden ? node.child : node;
+
+ if (primaryChildParent !== null) {
+ _appendAllChildren(parent, primaryChildParent, true, newIsHidden);
+ }
+
+ break branches;
+ }
+ }
+
+ if (node.child !== null) {
+ node.child.return = node;
+ node = node.child;
+ continue;
+ }
+ } else if (node.child !== null) {
+ node.child.return = node;
+ node = node.child;
+ continue;
+ }
+
+ node = node;
+
+ if (node === workInProgress) {
+ return;
+ }
+
+ while (node.sibling === null) {
+ if (node.return === null || node.return === workInProgress) {
+ return;
+ }
+
+ node = node.return;
+ }
+
+ node.sibling.return = node.return;
+ node = node.sibling;
+ }
+ };
+
+ var appendAllChildrenToContainer = function appendAllChildrenToContainer(containerChildSet, workInProgress, needsVisibilityToggle, isHidden) {
+ var node = workInProgress.child;
+
+ while (node !== null) {
+ branches: if (node.tag === HostComponent) {
+ var instance = node.stateNode;
+
+ if (needsVisibilityToggle) {
+ var props = node.memoizedProps;
+ var type = node.type;
+
+ if (isHidden) {
+ instance = cloneHiddenInstance(instance, type, props, node);
+ } else {
+ instance = cloneUnhiddenInstance(instance, type, props, node);
+ }
+
+ node.stateNode = instance;
+ }
+
+ appendChildToContainerChildSet(containerChildSet, instance);
+ } else if (node.tag === HostText) {
+ var _instance2 = node.stateNode;
+
+ if (needsVisibilityToggle) {
+ var text = node.memoizedProps;
+ var rootContainerInstance = getRootHostContainer();
+ var currentHostContext = getHostContext();
+
+ if (isHidden) {
+ _instance2 = createHiddenTextInstance(text, rootContainerInstance, currentHostContext, workInProgress);
+ } else {
+ _instance2 = createTextInstance(text, rootContainerInstance, currentHostContext, workInProgress);
+ }
+
+ node.stateNode = _instance2;
+ }
+
+ appendChildToContainerChildSet(containerChildSet, _instance2);
+ } else if (node.tag === HostPortal) {} else if (node.tag === SuspenseComponent) {
+ var current = node.alternate;
+
+ if (current !== null) {
+ var oldState = current.memoizedState;
+ var newState = node.memoizedState;
+ var oldIsHidden = oldState !== null;
+ var newIsHidden = newState !== null;
+
+ if (oldIsHidden !== newIsHidden) {
+ var primaryChildParent = newIsHidden ? node.child : node;
+
+ if (primaryChildParent !== null) {
+ appendAllChildrenToContainer(containerChildSet, primaryChildParent, true, newIsHidden);
+ }
+
+ break branches;
+ }
+ }
+
+ if (node.child !== null) {
+ node.child.return = node;
+ node = node.child;
+ continue;
+ }
+ } else if (node.child !== null) {
+ node.child.return = node;
+ node = node.child;
+ continue;
+ }
+
+ node = node;
+
+ if (node === workInProgress) {
+ return;
+ }
+
+ while (node.sibling === null) {
+ if (node.return === null || node.return === workInProgress) {
+ return;
+ }
+
+ node = node.return;
+ }
+
+ node.sibling.return = node.return;
+ node = node.sibling;
+ }
+ };
+
+ updateHostContainer = function updateHostContainer(workInProgress) {
+ var portalOrRoot = workInProgress.stateNode;
+ var childrenUnchanged = workInProgress.firstEffect === null;
+
+ if (childrenUnchanged) {} else {
+ var container = portalOrRoot.containerInfo;
+ var newChildSet = createContainerChildSet(container);
+ appendAllChildrenToContainer(newChildSet, workInProgress, false, false);
+ portalOrRoot.pendingChildren = newChildSet;
+ markUpdate(workInProgress);
+ finalizeContainerChildren(container, newChildSet);
+ }
+ };
+
+ updateHostComponent$1 = function updateHostComponent$1(current, workInProgress, type, newProps, rootContainerInstance) {
+ var currentInstance = current.stateNode;
+ var oldProps = current.memoizedProps;
+ var childrenUnchanged = workInProgress.firstEffect === null;
+
+ if (childrenUnchanged && oldProps === newProps) {
+ workInProgress.stateNode = currentInstance;
+ return;
+ }
+
+ var recyclableInstance = workInProgress.stateNode;
+ var currentHostContext = getHostContext();
+ var updatePayload = null;
+
+ if (oldProps !== newProps) {
+ updatePayload = prepareUpdate(recyclableInstance, type, oldProps, newProps, rootContainerInstance, currentHostContext);
+ }
+
+ if (childrenUnchanged && updatePayload === null) {
+ workInProgress.stateNode = currentInstance;
+ return;
+ }
+
+ var newInstance = cloneInstance(currentInstance, updatePayload, type, oldProps, newProps, workInProgress, childrenUnchanged, recyclableInstance);
+
+ if (finalizeInitialChildren(newInstance, type, newProps, rootContainerInstance, currentHostContext)) {
+ markUpdate(workInProgress);
+ }
+
+ workInProgress.stateNode = newInstance;
+
+ if (childrenUnchanged) {
+ markUpdate(workInProgress);
+ } else {
+ _appendAllChildren(newInstance, workInProgress, false, false);
+ }
+ };
+
+ updateHostText$1 = function updateHostText$1(current, workInProgress, oldText, newText) {
+ if (oldText !== newText) {
+ var rootContainerInstance = getRootHostContainer();
+ var currentHostContext = getHostContext();
+ workInProgress.stateNode = createTextInstance(newText, rootContainerInstance, currentHostContext, workInProgress);
+ markUpdate(workInProgress);
+ }
+ };
+ } else {
+ updateHostContainer = function updateHostContainer(workInProgress) {};
+
+ updateHostComponent$1 = function updateHostComponent$1(current, workInProgress, type, newProps, rootContainerInstance) {};
+
+ updateHostText$1 = function updateHostText$1(current, workInProgress, oldText, newText) {};
+ }
+
+ function completeWork(current, workInProgress, renderExpirationTime) {
+ var newProps = workInProgress.pendingProps;
+
+ switch (workInProgress.tag) {
+ case IndeterminateComponent:
+ break;
+
+ case LazyComponent:
+ break;
+
+ case SimpleMemoComponent:
+ case FunctionComponent:
+ break;
+
+ case ClassComponent:
+ {
+ var Component = workInProgress.type;
+
+ if (isContextProvider(Component)) {
+ popContext(workInProgress);
+ }
+
+ break;
+ }
+
+ case HostRoot:
+ {
+ popHostContainer(workInProgress);
+ popTopLevelContextObject(workInProgress);
+ var fiberRoot = workInProgress.stateNode;
+
+ if (fiberRoot.pendingContext) {
+ fiberRoot.context = fiberRoot.pendingContext;
+ fiberRoot.pendingContext = null;
+ }
+
+ if (current === null || current.child === null) {
+ popHydrationState(workInProgress);
+ workInProgress.effectTag &= ~Placement;
+ }
+
+ updateHostContainer(workInProgress);
+ break;
+ }
+
+ case HostComponent:
+ {
+ popHostContext(workInProgress);
+ var rootContainerInstance = getRootHostContainer();
+ var type = workInProgress.type;
+
+ if (current !== null && workInProgress.stateNode != null) {
+ updateHostComponent$1(current, workInProgress, type, newProps, rootContainerInstance);
+
+ if (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.");
+ break;
+ }
+
+ 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, false, false);
+
+ if (finalizeInitialChildren(instance, type, newProps, rootContainerInstance, currentHostContext)) {
+ markUpdate(workInProgress);
+ }
+
+ workInProgress.stateNode = instance;
+ }
+
+ if (workInProgress.ref !== null) {
+ markRef$1(workInProgress);
+ }
+ }
+
+ break;
+ }
+
+ case HostText:
+ {
+ var newText = newProps;
+
+ if (current && workInProgress.stateNode != null) {
+ var oldText = current.memoizedProps;
+ updateHostText$1(current, workInProgress, oldText, newText);
+ } else {
+ if (typeof newText !== "string") {
+ 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.");
+ }
+
+ var _rootContainerInstance = getRootHostContainer();
+
+ var _currentHostContext = getHostContext();
+
+ var _wasHydrated = popHydrationState(workInProgress);
+
+ if (_wasHydrated) {
+ if (prepareToHydrateHostTextInstance(workInProgress)) {
+ markUpdate(workInProgress);
+ }
+ } else {
+ workInProgress.stateNode = createTextInstance(newText, _rootContainerInstance, _currentHostContext, workInProgress);
+ }
+ }
+
+ break;
+ }
+
+ case ForwardRef:
+ break;
+
+ case SuspenseComponent:
+ {
+ var nextState = workInProgress.memoizedState;
+
+ if ((workInProgress.effectTag & DidCapture) !== NoEffect) {
+ workInProgress.expirationTime = renderExpirationTime;
+ return workInProgress;
+ }
+
+ var nextDidTimeout = nextState !== null;
+ var prevDidTimeout = current !== null && current.memoizedState !== null;
+
+ if (current === null) {
+ popHydrationState(workInProgress);
+ } else if (!nextDidTimeout && prevDidTimeout) {
+ var currentFallbackChild = current.child.sibling;
+
+ if (currentFallbackChild !== null) {
+ var first = workInProgress.firstEffect;
+
+ if (first !== null) {
+ workInProgress.firstEffect = currentFallbackChild;
+ currentFallbackChild.nextEffect = first;
+ } else {
+ workInProgress.firstEffect = workInProgress.lastEffect = currentFallbackChild;
+ currentFallbackChild.nextEffect = null;
+ }
+
+ currentFallbackChild.effectTag = Deletion;
+ }
+ }
+
+ if (nextDidTimeout || prevDidTimeout) {
+ workInProgress.effectTag |= Update;
+ }
+
+ break;
+ }
+
+ case Fragment:
+ break;
+
+ case Mode:
+ break;
+
+ case Profiler:
+ break;
+
+ case HostPortal:
+ popHostContainer(workInProgress);
+ updateHostContainer(workInProgress);
+ break;
+
+ case ContextProvider:
+ popProvider(workInProgress);
+ break;
+
+ case ContextConsumer:
+ break;
+
+ case MemoComponent:
+ break;
+
+ case IncompleteClassComponent:
+ {
+ var _Component = workInProgress.type;
+
+ if (isContextProvider(_Component)) {
+ popContext(workInProgress);
+ }
+
+ break;
+ }
+
+ case DehydratedSuspenseComponent:
+ {
+ if (enableSuspenseServerRenderer) {
+ if (current === null) {
+ var _wasHydrated2 = popHydrationState(workInProgress);
+
+ invariant(_wasHydrated2, "A dehydrated suspense component was completed without a hydrated node. " + "This is probably a bug in React.");
+ skipPastDehydratedSuspenseInstance(workInProgress);
+ } else if ((workInProgress.effectTag & DidCapture) === NoEffect) {
+ current.alternate = null;
+ workInProgress.alternate = null;
+ workInProgress.tag = SuspenseComponent;
+ workInProgress.memoizedState = null;
+ workInProgress.stateNode = null;
+ }
+ }
+
+ break;
+ }
+
+ default:
+ invariant(false, "Unknown unit of work tag. This error is likely caused by a bug in " + "React. Please file an issue.");
+ }
+
+ return null;
+ }
+
+ function shouldCaptureSuspense(workInProgress) {
+ if (workInProgress.memoizedProps.fallback === undefined) {
+ return false;
+ }
+
+ var nextState = workInProgress.memoizedState;
+ return nextState === null;
+ }
+
+ 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 componentName = capturedError.componentName,
+ componentStack = capturedError.componentStack,
+ errorBoundaryName = capturedError.errorBoundaryName,
+ errorBoundaryFound = capturedError.errorBoundaryFound,
+ willRetry = capturedError.willRetry;
+
+ if (error != null && error._suppressLogging) {
+ if (errorBoundaryFound && willRetry) {
+ return;
+ }
+
+ console.error(error);
+ }
+
+ var componentNameMessage = componentName ? "The above error occurred in the <" + componentName + "> component:" : "The above error occurred in one of your React components:";
+ var errorBoundaryMessage = void 0;
+
+ if (errorBoundaryFound && errorBoundaryName) {
+ if (willRetry) {
+ errorBoundaryMessage = "React will try to recreate this component tree from scratch " + ("using the error boundary you provided, " + errorBoundaryName + ".");
+ } else {
+ errorBoundaryMessage = "This error was initially handled by the error boundary " + errorBoundaryName + ".\n" + "Recreating the tree from scratch failed so React will unmount the tree.";
+ }
+ } else {
+ errorBoundaryMessage = "Consider adding an error boundary to your tree to customize error handling behavior.\n" + "Visit https://fb.me/react-error-boundaries to learn more about error boundaries.";
+ }
+
+ var combinedMessage = "" + componentNameMessage + componentStack + "\n\n" + ("" + errorBoundaryMessage);
+ console.error(combinedMessage);
+ }
+ }
+
+ var didWarnAboutUndefinedSnapshotBeforeUpdate = null;
+ {
+ didWarnAboutUndefinedSnapshotBeforeUpdate = new Set();
+ }
+ var PossiblyWeakSet$1 = typeof WeakSet === "function" ? WeakSet : Set;
+
+ function logError(boundary, errorInfo) {
+ var source = errorInfo.source;
+ var stack = errorInfo.stack;
+
+ if (stack === null && source !== null) {
+ stack = getStackByFiberInDevAndProd(source);
+ }
+
+ var capturedError = {
+ componentName: source !== null ? getComponentName(source.type) : null,
+ componentStack: stack !== null ? stack : "",
+ error: errorInfo.value,
+ errorBoundary: null,
+ errorBoundaryName: null,
+ errorBoundaryFound: false,
+ willRetry: false
+ };
+
+ if (boundary !== null && boundary.tag === ClassComponent) {
+ capturedError.errorBoundary = boundary.stateNode;
+ capturedError.errorBoundaryName = getComponentName(boundary.type);
+ capturedError.errorBoundaryFound = true;
+ capturedError.willRetry = true;
+ }
+
+ try {
+ logCapturedError(capturedError);
+ } catch (e) {
+ setTimeout(function () {
+ throw e;
+ });
+ }
+ }
+
+ var callComponentWillUnmountWithTimer = function callComponentWillUnmountWithTimer(current$$1, instance) {
+ startPhaseTimer(current$$1, "componentWillUnmount");
+ instance.props = current$$1.memoizedProps;
+ instance.state = current$$1.memoizedState;
+ instance.componentWillUnmount();
+ stopPhaseTimer();
+ };
+
+ function safelyCallComponentWillUnmount(current$$1, instance) {
+ {
+ invokeGuardedCallback(null, callComponentWillUnmountWithTimer, null, current$$1, instance);
+
+ if (hasCaughtError()) {
+ var unmountError = clearCaughtError();
+ captureCommitPhaseError(current$$1, unmountError);
+ }
+ }
+ }
+
+ function safelyDetachRef(current$$1) {
+ var ref = current$$1.ref;
+
+ if (ref !== null) {
+ if (typeof ref === "function") {
+ {
+ invokeGuardedCallback(null, ref, null, null);
+
+ if (hasCaughtError()) {
+ var refError = clearCaughtError();
+ captureCommitPhaseError(current$$1, refError);
+ }
+ }
+ } else {
+ ref.current = null;
+ }
+ }
+ }
+
+ function safelyCallDestroy(current$$1, destroy) {
+ {
+ invokeGuardedCallback(null, destroy, null);
+
+ if (hasCaughtError()) {
+ var error = clearCaughtError();
+ captureCommitPhaseError(current$$1, error);
+ }
+ }
+ }
+
+ function commitBeforeMutationLifeCycles(current$$1, finishedWork) {
+ switch (finishedWork.tag) {
+ case FunctionComponent:
+ case ForwardRef:
+ case SimpleMemoComponent:
+ {
+ commitHookEffectList(UnmountSnapshot, NoEffect$1, finishedWork);
+ return;
+ }
+
+ case ClassComponent:
+ {
+ if (finishedWork.effectTag & Snapshot) {
+ if (current$$1 !== null) {
+ var prevProps = current$$1.memoizedProps;
+ var prevState = current$$1.memoizedState;
+ startPhaseTimer(finishedWork, "getSnapshotBeforeUpdate");
+ var instance = finishedWork.stateNode;
+ {
+ if (finishedWork.type === finishedWork.elementType && !didWarnAboutReassigningProps) {
+ !(instance.props === finishedWork.memoizedProps) ? warning$1(false, "Expected %s props to match memoized props before " + "getSnapshotBeforeUpdate. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
+ !(instance.state === finishedWork.memoizedState) ? warning$1(false, "Expected %s state to match memoized state before " + "getSnapshotBeforeUpdate. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
+ }
+ }
+ var snapshot = instance.getSnapshotBeforeUpdate(finishedWork.elementType === finishedWork.type ? prevProps : resolveDefaultProps(finishedWork.type, prevProps), prevState);
+ {
+ var didWarnSet = didWarnAboutUndefinedSnapshotBeforeUpdate;
+
+ if (snapshot === undefined && !didWarnSet.has(finishedWork.type)) {
+ didWarnSet.add(finishedWork.type);
+ warningWithoutStack$1(false, "%s.getSnapshotBeforeUpdate(): A snapshot value (or null) " + "must be returned. You have returned undefined.", getComponentName(finishedWork.type));
+ }
+ }
+ instance.__reactInternalSnapshotBeforeUpdate = snapshot;
+ stopPhaseTimer();
+ }
+ }
+
+ return;
+ }
+
+ case HostRoot:
+ case HostComponent:
+ case HostText:
+ case HostPortal:
+ case IncompleteClassComponent:
+ return;
+
+ default:
+ {
+ 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 commitHookEffectList(unmountTag, mountTag, finishedWork) {
+ var updateQueue = finishedWork.updateQueue;
+ var lastEffect = updateQueue !== null ? updateQueue.lastEffect : null;
+
+ if (lastEffect !== null) {
+ var firstEffect = lastEffect.next;
+ var effect = firstEffect;
+
+ do {
+ if ((effect.tag & unmountTag) !== NoEffect$1) {
+ var destroy = effect.destroy;
+ effect.destroy = undefined;
+
+ if (destroy !== undefined) {
+ destroy();
+ }
+ }
+
+ if ((effect.tag & mountTag) !== NoEffect$1) {
+ var create = effect.create;
+ effect.destroy = create();
+ {
+ var _destroy = effect.destroy;
+
+ if (_destroy !== undefined && typeof _destroy !== "function") {
+ var addendum = void 0;
+
+ if (_destroy === null) {
+ addendum = " You returned null. If your effect does not require clean " + "up, return undefined (or nothing).";
+ } else if (typeof _destroy.then === "function") {
+ addendum = "\n\nIt looks like you wrote useEffect(async () => ...) or returned a Promise. " + "Instead, you may write an async function separately " + "and then call it from inside the effect:\n\n" + "async function fetchComment(commentId) {\n" + " // You can await here\n" + "}\n\n" + "useEffect(() => {\n" + " fetchComment(commentId);\n" + "}, [commentId]);\n\n" + "In the future, React will provide a more idiomatic solution for data fetching " + "that doesn't involve writing effects manually.";
+ } else {
+ addendum = " You returned: " + _destroy;
+ }
+
+ warningWithoutStack$1(false, "An Effect function must not return anything besides a function, " + "which is used for clean-up.%s%s", addendum, getStackByFiberInDevAndProd(finishedWork));
+ }
+ }
+ }
+
+ effect = effect.next;
+ } while (effect !== firstEffect);
+ }
+ }
+
+ function commitPassiveHookEffects(finishedWork) {
+ commitHookEffectList(UnmountPassive, NoEffect$1, finishedWork);
+ commitHookEffectList(NoEffect$1, MountPassive, finishedWork);
+ }
+
+ function commitLifeCycles(finishedRoot, current$$1, finishedWork, committedExpirationTime) {
+ switch (finishedWork.tag) {
+ case FunctionComponent:
+ case ForwardRef:
+ case SimpleMemoComponent:
+ {
+ commitHookEffectList(UnmountLayout, MountLayout, finishedWork);
+ break;
+ }
+
+ case ClassComponent:
+ {
+ var instance = finishedWork.stateNode;
+
+ if (finishedWork.effectTag & Update) {
+ if (current$$1 === null) {
+ startPhaseTimer(finishedWork, "componentDidMount");
+ {
+ if (finishedWork.type === finishedWork.elementType && !didWarnAboutReassigningProps) {
+ !(instance.props === finishedWork.memoizedProps) ? warning$1(false, "Expected %s props to match memoized props before " + "componentDidMount. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
+ !(instance.state === finishedWork.memoizedState) ? warning$1(false, "Expected %s state to match memoized state before " + "componentDidMount. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
+ }
+ }
+ instance.componentDidMount();
+ stopPhaseTimer();
+ } else {
+ var prevProps = finishedWork.elementType === finishedWork.type ? current$$1.memoizedProps : resolveDefaultProps(finishedWork.type, current$$1.memoizedProps);
+ var prevState = current$$1.memoizedState;
+ startPhaseTimer(finishedWork, "componentDidUpdate");
+ {
+ if (finishedWork.type === finishedWork.elementType && !didWarnAboutReassigningProps) {
+ !(instance.props === finishedWork.memoizedProps) ? warning$1(false, "Expected %s props to match memoized props before " + "componentDidUpdate. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
+ !(instance.state === finishedWork.memoizedState) ? warning$1(false, "Expected %s state to match memoized state before " + "componentDidUpdate. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
+ }
+ }
+ instance.componentDidUpdate(prevProps, prevState, instance.__reactInternalSnapshotBeforeUpdate);
+ stopPhaseTimer();
+ }
+ }
+
+ var updateQueue = finishedWork.updateQueue;
+
+ if (updateQueue !== null) {
+ {
+ if (finishedWork.type === finishedWork.elementType && !didWarnAboutReassigningProps) {
+ !(instance.props === finishedWork.memoizedProps) ? warning$1(false, "Expected %s props to match memoized props before " + "processing the update queue. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
+ !(instance.state === finishedWork.memoizedState) ? warning$1(false, "Expected %s state to match memoized state before " + "processing the update queue. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
+ }
+ }
+ commitUpdateQueue(finishedWork, updateQueue, instance, committedExpirationTime);
+ }
+
+ return;
+ }
+
+ case HostRoot:
+ {
+ var _updateQueue = finishedWork.updateQueue;
+
+ if (_updateQueue !== null) {
+ var _instance = null;
+
+ if (finishedWork.child !== null) {
+ switch (finishedWork.child.tag) {
+ case HostComponent:
+ _instance = getPublicInstance(finishedWork.child.stateNode);
+ break;
+
+ case ClassComponent:
+ _instance = finishedWork.child.stateNode;
+ break;
+ }
+ }
+
+ commitUpdateQueue(finishedWork, _updateQueue, _instance, committedExpirationTime);
+ }
+
+ return;
+ }
+
+ case HostComponent:
+ {
+ var _instance2 = finishedWork.stateNode;
+
+ if (current$$1 === null && finishedWork.effectTag & Update) {
+ var type = finishedWork.type;
+ var props = finishedWork.memoizedProps;
+ commitMount(_instance2, type, props, finishedWork);
+ }
+
+ return;
+ }
+
+ case HostText:
+ {
+ return;
+ }
+
+ case HostPortal:
+ {
+ return;
+ }
+
+ case Profiler:
+ {
+ if (enableProfilerTimer) {
+ var onRender = finishedWork.memoizedProps.onRender;
+
+ if (enableSchedulerTracing) {
+ onRender(finishedWork.memoizedProps.id, current$$1 === null ? "mount" : "update", finishedWork.actualDuration, finishedWork.treeBaseDuration, finishedWork.actualStartTime, getCommitTime(), finishedRoot.memoizedInteractions);
+ } else {
+ onRender(finishedWork.memoizedProps.id, current$$1 === null ? "mount" : "update", finishedWork.actualDuration, finishedWork.treeBaseDuration, finishedWork.actualStartTime, getCommitTime());
+ }
+ }
+
+ return;
+ }
+
+ case SuspenseComponent:
+ break;
+
+ case IncompleteClassComponent:
+ break;
+
+ 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 hideOrUnhideAllChildren(finishedWork, isHidden) {
+ if (supportsMutation) {
+ var node = finishedWork;
+
+ while (true) {
+ if (node.tag === HostComponent) {
+ var instance = node.stateNode;
+
+ if (isHidden) {
+ hideInstance(instance);
+ } else {
+ unhideInstance(node.stateNode, node.memoizedProps);
+ }
+ } else if (node.tag === HostText) {
+ var _instance3 = node.stateNode;
+
+ if (isHidden) {
+ hideTextInstance(_instance3);
+ } else {
+ unhideTextInstance(_instance3, node.memoizedProps);
+ }
+ } else if (node.tag === SuspenseComponent && node.memoizedState !== null) {
+ var fallbackChildFragment = node.child.sibling;
+ fallbackChildFragment.return = node;
+ node = fallbackChildFragment;
+ continue;
+ } else if (node.child !== null) {
+ node.child.return = node;
+ node = node.child;
+ continue;
+ }
+
+ if (node === finishedWork) {
+ return;
+ }
+
+ while (node.sibling === null) {
+ if (node.return === null || node.return === finishedWork) {
+ return;
+ }
+
+ node = node.return;
+ }
+
+ node.sibling.return = node.return;
+ node = node.sibling;
+ }
+ }
+ }
+
+ function commitAttachRef(finishedWork) {
+ var ref = finishedWork.ref;
+
+ if (ref !== null) {
+ var instance = finishedWork.stateNode;
+ var instanceToUse = void 0;
+
+ switch (finishedWork.tag) {
+ case HostComponent:
+ instanceToUse = getPublicInstance(instance);
+ break;
+
+ default:
+ instanceToUse = instance;
+ }
+
+ if (typeof ref === "function") {
+ ref(instanceToUse);
+ } else {
+ {
+ if (!ref.hasOwnProperty("current")) {
+ warningWithoutStack$1(false, "Unexpected ref object provided for %s. " + "Use either a ref-setter function or React.createRef().%s", getComponentName(finishedWork.type), getStackByFiberInDevAndProd(finishedWork));
+ }
+ }
+ ref.current = instanceToUse;
+ }
+ }
+ }
+
+ function commitDetachRef(current$$1) {
+ var currentRef = current$$1.ref;
+
+ if (currentRef !== null) {
+ if (typeof currentRef === "function") {
+ currentRef(null);
+ } else {
+ currentRef.current = null;
+ }
+ }
+ }
+
+ function commitUnmount(current$$1) {
+ onCommitUnmount(current$$1);
+
+ switch (current$$1.tag) {
+ case FunctionComponent:
+ case ForwardRef:
+ case MemoComponent:
+ case SimpleMemoComponent:
+ {
+ var updateQueue = current$$1.updateQueue;
+
+ if (updateQueue !== null) {
+ var lastEffect = updateQueue.lastEffect;
+
+ if (lastEffect !== null) {
+ var firstEffect = lastEffect.next;
+ var effect = firstEffect;
+
+ do {
+ var destroy = effect.destroy;
+
+ if (destroy !== undefined) {
+ safelyCallDestroy(current$$1, destroy);
+ }
+
+ effect = effect.next;
+ } while (effect !== firstEffect);
+ }
+ }
+
+ break;
+ }
+
+ case ClassComponent:
+ {
+ safelyDetachRef(current$$1);
+ var instance = current$$1.stateNode;
+
+ if (typeof instance.componentWillUnmount === "function") {
+ safelyCallComponentWillUnmount(current$$1, instance);
+ }
+
+ return;
+ }
+
+ case HostComponent:
+ {
+ safelyDetachRef(current$$1);
+ return;
+ }
+
+ case HostPortal:
+ {
+ if (supportsMutation) {
+ unmountHostComponents(current$$1);
+ } else if (supportsPersistence) {
+ emptyPortalContainer(current$$1);
+ }
+
+ 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$$1) {
+ current$$1.return = null;
+ current$$1.child = null;
+ current$$1.memoizedState = null;
+ current$$1.updateQueue = null;
+ var alternate = current$$1.alternate;
+
+ if (alternate !== null) {
+ alternate.return = null;
+ alternate.child = null;
+ alternate.memoizedState = null;
+ alternate.updateQueue = null;
+ }
+ }
+
+ function emptyPortalContainer(current$$1) {
+ if (!supportsPersistence) {
+ return;
+ }
+
+ var portal = current$$1.stateNode;
+ var containerInfo = portal.containerInfo;
+ var emptyChildSet = createContainerChildSet(containerInfo);
+ }
+
+ function commitContainer(finishedWork) {
+ if (!supportsPersistence) {
+ return;
+ }
+
+ switch (finishedWork.tag) {
+ case ClassComponent:
+ {
+ 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 && node.tag !== DehydratedSuspenseComponent) {
+ if (node.effectTag & Placement) {
+ continue siblings;
+ }
+
+ if (node.child === null || node.tag === HostPortal) {
+ continue siblings;
+ } else {
+ node.child.return = node;
+ node = node.child;
+ }
+ }
+
+ if (!(node.effectTag & Placement)) {
+ return node.stateNode;
+ }
+ }
+ }
+
+ function commitPlacement(finishedWork) {
+ if (!supportsMutation) {
+ return;
+ }
+
+ var parentFiber = getHostParentFiber(finishedWork);
+ var parent = void 0;
+ var isContainer = void 0;
+
+ 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$$1) {
+ var node = current$$1;
+ var currentParentIsValid = false;
+ var currentParent = void 0;
+ var currentParentIsContainer = void 0;
+
+ while (true) {
+ if (!currentParentIsValid) {
+ var parent = node.return;
+
+ findParent: while (true) {
+ 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 (enableSuspenseServerRenderer && node.tag === DehydratedSuspenseComponent) {
+ if (currentParentIsContainer) {
+ clearSuspenseBoundaryFromContainer(currentParent, node.stateNode);
+ } else {
+ clearSuspenseBoundary(currentParent, node.stateNode);
+ }
+ } else if (node.tag === HostPortal) {
+ if (node.child !== null) {
+ currentParent = node.stateNode.containerInfo;
+ currentParentIsContainer = true;
+ node.child.return = node;
+ node = node.child;
+ continue;
+ }
+ } else {
+ commitUnmount(node);
+
+ if (node.child !== null) {
+ node.child.return = node;
+ node = node.child;
+ continue;
+ }
+ }
+
+ if (node === current$$1) {
+ return;
+ }
+
+ while (node.sibling === null) {
+ if (node.return === null || node.return === current$$1) {
+ return;
+ }
+
+ node = node.return;
+
+ if (node.tag === HostPortal) {
+ currentParentIsValid = false;
+ }
+ }
+
+ node.sibling.return = node.return;
+ node = node.sibling;
+ }
+ }
+
+ function commitDeletion(current$$1) {
+ if (supportsMutation) {
+ unmountHostComponents(current$$1);
+ } else {
+ commitNestedUnmounts(current$$1);
+ }
+
+ detachFiber(current$$1);
+ }
+
+ function commitWork(current$$1, finishedWork) {
+ if (!supportsMutation) {
+ switch (finishedWork.tag) {
+ case FunctionComponent:
+ case ForwardRef:
+ case MemoComponent:
+ case SimpleMemoComponent:
+ {
+ commitHookEffectList(UnmountMutation, MountMutation, finishedWork);
+ return;
+ }
+ }
+
+ commitContainer(finishedWork);
+ return;
+ }
+
+ switch (finishedWork.tag) {
+ case FunctionComponent:
+ case ForwardRef:
+ case MemoComponent:
+ case SimpleMemoComponent:
+ {
+ commitHookEffectList(UnmountMutation, MountMutation, finishedWork);
+ return;
+ }
+
+ case ClassComponent:
+ {
+ return;
+ }
+
+ case HostComponent:
+ {
+ var instance = finishedWork.stateNode;
+
+ if (instance != null) {
+ var newProps = finishedWork.memoizedProps;
+ var oldProps = current$$1 !== null ? current$$1.memoizedProps : newProps;
+ var type = finishedWork.type;
+ var updatePayload = finishedWork.updateQueue;
+ finishedWork.updateQueue = null;
+
+ if (updatePayload !== null) {
+ commitUpdate(instance, updatePayload, type, oldProps, newProps, finishedWork);
+ }
+ }
+
+ return;
+ }
+
+ case HostText:
+ {
+ 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$$1 !== null ? current$$1.memoizedProps : newText;
+ commitTextUpdate(textInstance, oldText, newText);
+ return;
+ }
+
+ case HostRoot:
+ {
+ return;
+ }
+
+ case Profiler:
+ {
+ return;
+ }
+
+ case SuspenseComponent:
+ {
+ var newState = finishedWork.memoizedState;
+ var newDidTimeout = void 0;
+ var primaryChildParent = finishedWork;
+
+ if (newState === null) {
+ newDidTimeout = false;
+ } else {
+ newDidTimeout = true;
+ primaryChildParent = finishedWork.child;
+
+ if (newState.timedOutAt === NoWork) {
+ newState.timedOutAt = requestCurrentTime();
+ }
+ }
+
+ if (primaryChildParent !== null) {
+ hideOrUnhideAllChildren(primaryChildParent, newDidTimeout);
+ }
+
+ var thenables = finishedWork.updateQueue;
+
+ if (thenables !== null) {
+ finishedWork.updateQueue = null;
+ var retryCache = finishedWork.stateNode;
+
+ if (retryCache === null) {
+ retryCache = finishedWork.stateNode = new PossiblyWeakSet$1();
+ }
+
+ thenables.forEach(function (thenable) {
+ var retry = resolveRetryThenable.bind(null, finishedWork, thenable);
+
+ if (enableSchedulerTracing) {
+ retry = tracing.unstable_wrap(retry);
+ }
+
+ if (!retryCache.has(thenable)) {
+ retryCache.add(thenable);
+ thenable.then(retry, retry);
+ }
+ });
+ }
+
+ return;
+ }
+
+ case IncompleteClassComponent:
+ {
+ 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$$1) {
+ if (!supportsMutation) {
+ return;
+ }
+
+ resetTextContent(current$$1.stateNode);
+ }
+
+ var PossiblyWeakSet = typeof WeakSet === "function" ? WeakSet : Set;
+ var PossiblyWeakMap = typeof WeakMap === "function" ? WeakMap : Map;
+
+ function createRootErrorUpdate(fiber, errorInfo, expirationTime) {
+ var update = createUpdate(expirationTime);
+ 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 getDerivedStateFromError = fiber.type.getDerivedStateFromError;
+
+ if (typeof getDerivedStateFromError === "function") {
+ var error = errorInfo.value;
+
+ update.payload = function () {
+ return getDerivedStateFromError(error);
+ };
+ }
+
+ var inst = fiber.stateNode;
+
+ if (inst !== null && typeof inst.componentDidCatch === "function") {
+ update.callback = function callback() {
+ if (typeof getDerivedStateFromError !== "function") {
+ markLegacyErrorBoundaryAsFailed(this);
+ }
+
+ var error = errorInfo.value;
+ var stack = errorInfo.stack;
+ logError(fiber, errorInfo);
+ this.componentDidCatch(error, {
+ componentStack: stack !== null ? stack : ""
+ });
+ {
+ if (typeof getDerivedStateFromError !== "function") {
+ !(fiber.expirationTime === Sync) ? warningWithoutStack$1(false, "%s: Error boundaries should implement getDerivedStateFromError(). " + "In that method, return a state update to display an error message or fallback UI.", getComponentName(fiber.type) || "Unknown") : void 0;
+ }
+ }
+ };
+ }
+
+ return update;
+ }
+
+ function attachPingListener(root, renderExpirationTime, thenable) {
+ var pingCache = root.pingCache;
+ var threadIDs = void 0;
+
+ if (pingCache === null) {
+ pingCache = root.pingCache = new PossiblyWeakMap();
+ threadIDs = new Set();
+ pingCache.set(thenable, threadIDs);
+ } else {
+ threadIDs = pingCache.get(thenable);
+
+ if (threadIDs === undefined) {
+ threadIDs = new Set();
+ pingCache.set(thenable, threadIDs);
+ }
+ }
+
+ if (!threadIDs.has(renderExpirationTime)) {
+ threadIDs.add(renderExpirationTime);
+ var ping = pingSuspendedRoot.bind(null, root, thenable, renderExpirationTime);
+
+ if (enableSchedulerTracing) {
+ ping = tracing.unstable_wrap(ping);
+ }
+
+ thenable.then(ping, ping);
+ }
+ }
+
+ function throwException(root, returnFiber, sourceFiber, value, renderExpirationTime) {
+ sourceFiber.effectTag |= Incomplete;
+ sourceFiber.firstEffect = sourceFiber.lastEffect = null;
+
+ if (value !== null && typeof value === "object" && typeof value.then === "function") {
+ var thenable = value;
+ var _workInProgress = returnFiber;
+ var earliestTimeoutMs = -1;
+ var startTimeMs = -1;
+
+ do {
+ if (_workInProgress.tag === SuspenseComponent) {
+ var current$$1 = _workInProgress.alternate;
+
+ if (current$$1 !== null) {
+ var currentState = current$$1.memoizedState;
+
+ if (currentState !== null) {
+ var timedOutAt = currentState.timedOutAt;
+ startTimeMs = expirationTimeToMs(timedOutAt);
+ break;
+ }
+ }
+
+ var timeoutPropMs = _workInProgress.pendingProps.maxDuration;
+
+ if (typeof timeoutPropMs === "number") {
+ if (timeoutPropMs <= 0) {
+ earliestTimeoutMs = 0;
+ } else if (earliestTimeoutMs === -1 || timeoutPropMs < earliestTimeoutMs) {
+ earliestTimeoutMs = timeoutPropMs;
+ }
+ }
+ }
+
+ _workInProgress = _workInProgress.return;
+ } while (_workInProgress !== null);
+
+ _workInProgress = returnFiber;
+
+ do {
+ if (_workInProgress.tag === SuspenseComponent && shouldCaptureSuspense(_workInProgress)) {
+ var thenables = _workInProgress.updateQueue;
+
+ if (thenables === null) {
+ var updateQueue = new Set();
+ updateQueue.add(thenable);
+ _workInProgress.updateQueue = updateQueue;
+ } else {
+ thenables.add(thenable);
+ }
+
+ if ((_workInProgress.mode & ConcurrentMode) === NoEffect) {
+ _workInProgress.effectTag |= DidCapture;
+ sourceFiber.effectTag &= ~(LifecycleEffectMask | Incomplete);
+
+ if (sourceFiber.tag === ClassComponent) {
+ var currentSourceFiber = sourceFiber.alternate;
+
+ if (currentSourceFiber === null) {
+ sourceFiber.tag = IncompleteClassComponent;
+ } else {
+ var update = createUpdate(Sync);
+ update.tag = ForceUpdate;
+ enqueueUpdate(sourceFiber, update);
+ }
+ }
+
+ sourceFiber.expirationTime = Sync;
+ return;
+ }
+
+ attachPingListener(root, renderExpirationTime, thenable);
+ var absoluteTimeoutMs = void 0;
+
+ if (earliestTimeoutMs === -1) {
+ absoluteTimeoutMs = maxSigned31BitInt;
+ } else {
+ if (startTimeMs === -1) {
+ var earliestExpirationTime = findEarliestOutstandingPriorityLevel(root, renderExpirationTime);
+ var earliestExpirationTimeMs = expirationTimeToMs(earliestExpirationTime);
+ startTimeMs = earliestExpirationTimeMs - LOW_PRIORITY_EXPIRATION;
+ }
+
+ absoluteTimeoutMs = startTimeMs + earliestTimeoutMs;
+ }
+
+ renderDidSuspend(root, absoluteTimeoutMs, renderExpirationTime);
+ _workInProgress.effectTag |= ShouldCapture;
+ _workInProgress.expirationTime = renderExpirationTime;
+ return;
+ } else if (enableSuspenseServerRenderer && _workInProgress.tag === DehydratedSuspenseComponent) {
+ attachPingListener(root, renderExpirationTime, thenable);
+ var retryCache = _workInProgress.memoizedState;
+
+ if (retryCache === null) {
+ retryCache = _workInProgress.memoizedState = new PossiblyWeakSet();
+ var _current = _workInProgress.alternate;
+ invariant(_current, "A dehydrated suspense boundary must commit before trying to render. " + "This is probably a bug in React.");
+ _current.memoizedState = retryCache;
+ }
+
+ if (!retryCache.has(thenable)) {
+ retryCache.add(thenable);
+ var retry = resolveRetryThenable.bind(null, _workInProgress, thenable);
+
+ if (enableSchedulerTracing) {
+ retry = tracing.unstable_wrap(retry);
+ }
+
+ thenable.then(retry, retry);
+ }
+
+ _workInProgress.effectTag |= ShouldCapture;
+ _workInProgress.expirationTime = renderExpirationTime;
+ return;
+ }
+
+ _workInProgress = _workInProgress.return;
+ } while (_workInProgress !== null);
+
+ value = new Error((getComponentName(sourceFiber.type) || "A React component") + " suspended while rendering, but no fallback UI was specified.\n" + "\n" + "Add a component higher in the tree to " + "provide a loading indicator or placeholder to display." + getStackByFiberInDevAndProd(sourceFiber));
+ }
+
+ renderDidError();
+ value = createCapturedValue(value, sourceFiber);
+ var workInProgress = returnFiber;
+
+ do {
+ switch (workInProgress.tag) {
+ case HostRoot:
+ {
+ var _errorInfo = value;
+ workInProgress.effectTag |= ShouldCapture;
+ workInProgress.expirationTime = renderExpirationTime;
+
+ var _update = createRootErrorUpdate(workInProgress, _errorInfo, renderExpirationTime);
+
+ enqueueCapturedUpdate(workInProgress, _update);
+ return;
+ }
+
+ case ClassComponent:
+ var errorInfo = value;
+ var ctor = workInProgress.type;
+ var instance = workInProgress.stateNode;
+
+ if ((workInProgress.effectTag & DidCapture) === NoEffect && (typeof ctor.getDerivedStateFromError === "function" || instance !== null && typeof instance.componentDidCatch === "function" && !isAlreadyFailedLegacyErrorBoundary(instance))) {
+ workInProgress.effectTag |= ShouldCapture;
+ workInProgress.expirationTime = renderExpirationTime;
+
+ var _update2 = createClassErrorUpdate(workInProgress, errorInfo, renderExpirationTime);
+
+ enqueueCapturedUpdate(workInProgress, _update2);
+ return;
+ }
+
+ break;
+
+ default:
+ break;
+ }
+
+ workInProgress = workInProgress.return;
+ } while (workInProgress !== null);
+ }
+
+ function unwindWork(workInProgress, renderExpirationTime) {
+ switch (workInProgress.tag) {
+ case ClassComponent:
+ {
+ var Component = workInProgress.type;
+
+ if (isContextProvider(Component)) {
+ popContext(workInProgress);
+ }
+
+ var effectTag = workInProgress.effectTag;
+
+ if (effectTag & ShouldCapture) {
+ workInProgress.effectTag = effectTag & ~ShouldCapture | DidCapture;
+ return workInProgress;
+ }
+
+ return null;
+ }
+
+ case HostRoot:
+ {
+ popHostContainer(workInProgress);
+ popTopLevelContextObject(workInProgress);
+ var _effectTag = workInProgress.effectTag;
+ invariant((_effectTag & DidCapture) === NoEffect, "The root failed to unmount after an error. This is likely a bug in " + "React. Please file an issue.");
+ workInProgress.effectTag = _effectTag & ~ShouldCapture | DidCapture;
+ return workInProgress;
+ }
+
+ case HostComponent:
+ {
+ popHostContext(workInProgress);
+ return null;
+ }
+
+ case SuspenseComponent:
+ {
+ var _effectTag2 = workInProgress.effectTag;
+
+ if (_effectTag2 & ShouldCapture) {
+ workInProgress.effectTag = _effectTag2 & ~ShouldCapture | DidCapture;
+ return workInProgress;
+ }
+
+ return null;
+ }
+
+ case DehydratedSuspenseComponent:
+ {
+ if (enableSuspenseServerRenderer) {
+ var _effectTag3 = workInProgress.effectTag;
+
+ if (_effectTag3 & ShouldCapture) {
+ workInProgress.effectTag = _effectTag3 & ~ShouldCapture | DidCapture;
+ return workInProgress;
+ }
+ }
+
+ return null;
+ }
+
+ case HostPortal:
+ popHostContainer(workInProgress);
+ return null;
+
+ case ContextProvider:
+ popProvider(workInProgress);
+ return null;
+
+ default:
+ return null;
+ }
+ }
+
+ function unwindInterruptedWork(interruptedWork) {
+ switch (interruptedWork.tag) {
+ case ClassComponent:
+ {
+ var childContextTypes = interruptedWork.type.childContextTypes;
+
+ if (childContextTypes !== null && childContextTypes !== undefined) {
+ popContext(interruptedWork);
+ }
+
+ break;
+ }
+
+ case HostRoot:
+ {
+ popHostContainer(interruptedWork);
+ popTopLevelContextObject(interruptedWork);
+ break;
+ }
+
+ case HostComponent:
+ {
+ popHostContext(interruptedWork);
+ break;
+ }
+
+ case HostPortal:
+ popHostContainer(interruptedWork);
+ break;
+
+ case ContextProvider:
+ popProvider(interruptedWork);
+ break;
+
+ default:
+ break;
+ }
+ }
+
+ var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+ var ReactCurrentOwner$2 = ReactSharedInternals.ReactCurrentOwner;
+ var didWarnAboutStateTransition = void 0;
+ var didWarnSetStateChildContext = void 0;
+ var warnAboutUpdateOnUnmounted = void 0;
+ var warnAboutInvalidUpdates = void 0;
+
+ if (enableSchedulerTracing) {
+ invariant(tracing.__interactionsRef != null && tracing.__interactionsRef.current != null, "It is not supported to run the profiling version of a renderer (for example, `react-dom/profiling`) " + "without also replacing the `scheduler/tracing` module with `scheduler/tracing-profiling`. " + "Your bundler might have a setting for aliasing both modules. " + "Learn more at http://fb.me/react-profiling");
+ }
+
+ {
+ didWarnAboutStateTransition = false;
+ didWarnSetStateChildContext = false;
+ var didWarnStateUpdateForUnmountedComponent = {};
+
+ warnAboutUpdateOnUnmounted = function warnAboutUpdateOnUnmounted(fiber, isClass) {
+ var componentName = getComponentName(fiber.type) || "ReactComponent";
+
+ if (didWarnStateUpdateForUnmountedComponent[componentName]) {
+ return;
+ }
+
+ warningWithoutStack$1(false, "Can't perform a React state update on an unmounted component. This " + "is a no-op, but it indicates a memory leak in your application. To " + "fix, cancel all subscriptions and asynchronous tasks in %s.%s", isClass ? "the componentWillUnmount method" : "a useEffect cleanup function", getStackByFiberInDevAndProd(fiber));
+ didWarnStateUpdateForUnmountedComponent[componentName] = true;
+ };
+
+ warnAboutInvalidUpdates = function warnAboutInvalidUpdates(instance) {
+ switch (phase) {
+ case "getChildContext":
+ if (didWarnSetStateChildContext) {
+ return;
+ }
+
+ warningWithoutStack$1(false, "setState(...): Cannot call setState() inside getChildContext()");
+ didWarnSetStateChildContext = true;
+ break;
+
+ case "render":
+ if (didWarnAboutStateTransition) {
+ return;
+ }
+
+ warningWithoutStack$1(false, "Cannot update during an existing state transition (such as within " + "`render`). Render methods should be a pure function of props and state.");
+ didWarnAboutStateTransition = true;
+ break;
+ }
+ };
+ }
+ var isWorking = false;
+ var nextUnitOfWork = null;
+ var nextRoot = null;
+ var nextRenderExpirationTime = NoWork;
+ var nextLatestAbsoluteTimeoutMs = -1;
+ var nextRenderDidError = false;
+ var nextEffect = null;
+ var isCommitting$1 = false;
+ var rootWithPendingPassiveEffects = null;
+ var passiveEffectCallbackHandle = null;
+ var passiveEffectCallback = null;
+ var legacyErrorBoundariesThatAlreadyFailed = null;
+ var interruptedBy = null;
+ var stashedWorkInProgressProperties = void 0;
+ var replayUnitOfWork = void 0;
+ var mayReplayFailedUnitOfWork = void 0;
+ var isReplayingFailedUnitOfWork = void 0;
+ var originalReplayError = void 0;
+ var rethrowOriginalError = void 0;
+
+ if (true && replayFailedUnitOfWorkWithInvokeGuardedCallback) {
+ stashedWorkInProgressProperties = null;
+ mayReplayFailedUnitOfWork = true;
+ isReplayingFailedUnitOfWork = false;
+ originalReplayError = null;
+
+ replayUnitOfWork = function replayUnitOfWork(failedUnitOfWork, thrownValue, isYieldy) {
+ if (thrownValue !== null && typeof thrownValue === "object" && typeof thrownValue.then === "function") {
+ return;
+ }
+
+ if (stashedWorkInProgressProperties === null) {
+ warningWithoutStack$1(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:
+ {
+ var Component = failedUnitOfWork.type;
+
+ if (isContextProvider(Component)) {
+ popContext(failedUnitOfWork);
+ }
+
+ break;
+ }
+
+ case HostPortal:
+ popHostContainer(failedUnitOfWork);
+ break;
+
+ case ContextProvider:
+ popProvider(failedUnitOfWork);
+ break;
+ }
+
+ isReplayingFailedUnitOfWork = true;
+ originalReplayError = thrownValue;
+ invokeGuardedCallback(null, workLoop, null, isYieldy);
+ isReplayingFailedUnitOfWork = false;
+ originalReplayError = null;
+
+ if (hasCaughtError()) {
+ var replayError = clearCaughtError();
+
+ if (replayError != null && thrownValue != null) {
+ try {
+ if (replayError._suppressLogging) {
+ thrownValue._suppressLogging = true;
+ }
+ } catch (inner) {}
+ }
+ } 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;
+ nextLatestAbsoluteTimeoutMs = -1;
+ nextRenderDidError = false;
+ nextUnitOfWork = null;
+ }
+
+ function commitAllHostEffects() {
+ while (nextEffect !== null) {
+ {
+ setCurrentFiber(nextEffect);
+ }
+ recordEffect();
+ var effectTag = nextEffect.effectTag;
+
+ if (effectTag & ContentReset) {
+ commitResetTextContent(nextEffect);
+ }
+
+ if (effectTag & Ref) {
+ var current$$1 = nextEffect.alternate;
+
+ if (current$$1 !== null) {
+ commitDetachRef(current$$1);
+ }
+ }
+
+ var primaryEffectTag = effectTag & (Placement | Update | Deletion);
+
+ switch (primaryEffectTag) {
+ case Placement:
+ {
+ commitPlacement(nextEffect);
+ nextEffect.effectTag &= ~Placement;
+ break;
+ }
+
+ case PlacementAndUpdate:
+ {
+ commitPlacement(nextEffect);
+ nextEffect.effectTag &= ~Placement;
+ var _current = nextEffect.alternate;
+ commitWork(_current, nextEffect);
+ break;
+ }
+
+ case Update:
+ {
+ var _current2 = nextEffect.alternate;
+ commitWork(_current2, nextEffect);
+ break;
+ }
+
+ case Deletion:
+ {
+ commitDeletion(nextEffect);
+ break;
+ }
+ }
+
+ nextEffect = nextEffect.nextEffect;
+ }
+
+ {
+ resetCurrentFiber();
+ }
+ }
+
+ function commitBeforeMutationLifecycles() {
+ while (nextEffect !== null) {
+ {
+ setCurrentFiber(nextEffect);
+ }
+ var effectTag = nextEffect.effectTag;
+
+ if (effectTag & Snapshot) {
+ recordEffect();
+ var current$$1 = nextEffect.alternate;
+ commitBeforeMutationLifeCycles(current$$1, nextEffect);
+ }
+
+ nextEffect = nextEffect.nextEffect;
+ }
+
+ {
+ resetCurrentFiber();
+ }
+ }
+
+ function commitAllLifeCycles(finishedRoot, committedExpirationTime) {
+ {
+ ReactStrictModeWarnings.flushPendingUnsafeLifecycleWarnings();
+ ReactStrictModeWarnings.flushLegacyContextWarning();
+
+ if (warnAboutDeprecatedLifecycles) {
+ ReactStrictModeWarnings.flushPendingDeprecationWarnings();
+ }
+ }
+
+ while (nextEffect !== null) {
+ {
+ setCurrentFiber(nextEffect);
+ }
+ var effectTag = nextEffect.effectTag;
+
+ if (effectTag & (Update | Callback)) {
+ recordEffect();
+ var current$$1 = nextEffect.alternate;
+ commitLifeCycles(finishedRoot, current$$1, nextEffect, committedExpirationTime);
+ }
+
+ if (effectTag & Ref) {
+ recordEffect();
+ commitAttachRef(nextEffect);
+ }
+
+ if (effectTag & Passive) {
+ rootWithPendingPassiveEffects = finishedRoot;
+ }
+
+ nextEffect = nextEffect.nextEffect;
+ }
+
+ {
+ resetCurrentFiber();
+ }
+ }
+
+ function commitPassiveEffects(root, firstEffect) {
+ rootWithPendingPassiveEffects = null;
+ passiveEffectCallbackHandle = null;
+ passiveEffectCallback = null;
+ var previousIsRendering = isRendering;
+ isRendering = true;
+ var effect = firstEffect;
+
+ do {
+ {
+ setCurrentFiber(effect);
+ }
+
+ if (effect.effectTag & Passive) {
+ var didError = false;
+ var error = void 0;
+ {
+ invokeGuardedCallback(null, commitPassiveHookEffects, null, effect);
+
+ if (hasCaughtError()) {
+ didError = true;
+ error = clearCaughtError();
+ }
+ }
+
+ if (didError) {
+ captureCommitPhaseError(effect, error);
+ }
+ }
+
+ effect = effect.nextEffect;
+ } while (effect !== null);
+
+ {
+ resetCurrentFiber();
+ }
+ isRendering = previousIsRendering;
+ var rootExpirationTime = root.expirationTime;
+
+ if (rootExpirationTime !== NoWork) {
+ requestWork(root, rootExpirationTime);
+ }
+
+ if (!isBatchingUpdates && !isRendering) {
+ performSyncWork();
+ }
+ }
+
+ function isAlreadyFailedLegacyErrorBoundary(instance) {
+ return legacyErrorBoundariesThatAlreadyFailed !== null && legacyErrorBoundariesThatAlreadyFailed.has(instance);
+ }
+
+ function markLegacyErrorBoundaryAsFailed(instance) {
+ if (legacyErrorBoundariesThatAlreadyFailed === null) {
+ legacyErrorBoundariesThatAlreadyFailed = new Set([instance]);
+ } else {
+ legacyErrorBoundariesThatAlreadyFailed.add(instance);
+ }
+ }
+
+ function flushPassiveEffects() {
+ if (passiveEffectCallbackHandle !== null) {
+ cancelPassiveEffects(passiveEffectCallbackHandle);
+ }
+
+ if (passiveEffectCallback !== null) {
+ passiveEffectCallback();
+ }
+ }
+
+ 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 updateExpirationTimeBeforeCommit = finishedWork.expirationTime;
+ var childExpirationTimeBeforeCommit = finishedWork.childExpirationTime;
+ var earliestRemainingTimeBeforeCommit = childExpirationTimeBeforeCommit > updateExpirationTimeBeforeCommit ? childExpirationTimeBeforeCommit : updateExpirationTimeBeforeCommit;
+ markCommittedPriorityLevels(root, earliestRemainingTimeBeforeCommit);
+ var prevInteractions = null;
+
+ if (enableSchedulerTracing) {
+ prevInteractions = tracing.__interactionsRef.current;
+ tracing.__interactionsRef.current = root.memoizedInteractions;
+ }
+
+ ReactCurrentOwner$2.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(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(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(null, commitAllLifeCycles, null, root, 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 (firstEffect !== null && rootWithPendingPassiveEffects !== null) {
+ var callback = commitPassiveEffects.bind(null, root, firstEffect);
+
+ if (enableSchedulerTracing) {
+ callback = tracing.unstable_wrap(callback);
+ }
+
+ passiveEffectCallbackHandle = scheduler.unstable_runWithPriority(scheduler.unstable_NormalPriority, function () {
+ return schedulePassiveEffects(callback);
+ });
+ passiveEffectCallback = callback;
+ }
+
+ isCommitting$1 = false;
+ isWorking = false;
+ stopCommitLifeCyclesTimer();
+ stopCommitTimer();
+ onCommitRoot(finishedWork.stateNode);
+
+ if (true && ReactFiberInstrumentation_1.debugTool) {
+ ReactFiberInstrumentation_1.debugTool.onCommitWork(finishedWork);
+ }
+
+ var updateExpirationTimeAfterCommit = finishedWork.expirationTime;
+ var childExpirationTimeAfterCommit = finishedWork.childExpirationTime;
+ var earliestRemainingTimeAfterCommit = childExpirationTimeAfterCommit > updateExpirationTimeAfterCommit ? childExpirationTimeAfterCommit : updateExpirationTimeAfterCommit;
+
+ if (earliestRemainingTimeAfterCommit === NoWork) {
+ legacyErrorBoundariesThatAlreadyFailed = null;
+ }
+
+ onCommit(root, earliestRemainingTimeAfterCommit);
+
+ if (enableSchedulerTracing) {
+ tracing.__interactionsRef.current = prevInteractions;
+ var subscriber = void 0;
+
+ try {
+ subscriber = tracing.__subscriberRef.current;
+
+ if (subscriber !== null && root.memoizedInteractions.size > 0) {
+ var threadID = computeThreadID(committedExpirationTime, root.interactionThreadID);
+ subscriber.onWorkStopped(root.memoizedInteractions, threadID);
+ }
+ } catch (error) {
+ if (!hasUnhandledError) {
+ hasUnhandledError = true;
+ unhandledError = error;
+ }
+ } finally {
+ var pendingInteractionMap = root.pendingInteractionMap;
+ pendingInteractionMap.forEach(function (scheduledInteractions, scheduledExpirationTime) {
+ if (scheduledExpirationTime > earliestRemainingTimeAfterCommit) {
+ pendingInteractionMap.delete(scheduledExpirationTime);
+ scheduledInteractions.forEach(function (interaction) {
+ interaction.__count--;
+
+ if (subscriber !== null && interaction.__count === 0) {
+ try {
+ subscriber.onInteractionScheduledWorkCompleted(interaction);
+ } catch (error) {
+ if (!hasUnhandledError) {
+ hasUnhandledError = true;
+ unhandledError = error;
+ }
+ }
+ }
+ });
+ }
+ });
+ }
+ }
+ }
+
+ function resetChildExpirationTime(workInProgress, renderTime) {
+ if (renderTime !== Never && workInProgress.childExpirationTime === Never) {
+ return;
+ }
+
+ var newChildExpirationTime = NoWork;
+
+ if (enableProfilerTimer && workInProgress.mode & ProfileMode) {
+ var actualDuration = workInProgress.actualDuration;
+ var treeBaseDuration = workInProgress.selfBaseDuration;
+ var shouldBubbleActualDurations = workInProgress.alternate === null || workInProgress.child !== workInProgress.alternate.child;
+ var child = workInProgress.child;
+
+ while (child !== null) {
+ var childUpdateExpirationTime = child.expirationTime;
+ var childChildExpirationTime = child.childExpirationTime;
+
+ if (childUpdateExpirationTime > newChildExpirationTime) {
+ newChildExpirationTime = childUpdateExpirationTime;
+ }
+
+ if (childChildExpirationTime > newChildExpirationTime) {
+ newChildExpirationTime = childChildExpirationTime;
+ }
+
+ if (shouldBubbleActualDurations) {
+ actualDuration += child.actualDuration;
+ }
+
+ treeBaseDuration += child.treeBaseDuration;
+ child = child.sibling;
+ }
+
+ workInProgress.actualDuration = actualDuration;
+ workInProgress.treeBaseDuration = treeBaseDuration;
+ } else {
+ var _child = workInProgress.child;
+
+ while (_child !== null) {
+ var _childUpdateExpirationTime = _child.expirationTime;
+ var _childChildExpirationTime = _child.childExpirationTime;
+
+ if (_childUpdateExpirationTime > newChildExpirationTime) {
+ newChildExpirationTime = _childUpdateExpirationTime;
+ }
+
+ if (_childChildExpirationTime > newChildExpirationTime) {
+ newChildExpirationTime = _childChildExpirationTime;
+ }
+
+ _child = _child.sibling;
+ }
+ }
+
+ workInProgress.childExpirationTime = newChildExpirationTime;
+ }
+
+ function completeUnitOfWork(workInProgress) {
+ while (true) {
+ var current$$1 = workInProgress.alternate;
+ {
+ setCurrentFiber(workInProgress);
+ }
+ var returnFiber = workInProgress.return;
+ var siblingFiber = workInProgress.sibling;
+
+ if ((workInProgress.effectTag & Incomplete) === NoEffect) {
+ if (true && replayFailedUnitOfWorkWithInvokeGuardedCallback) {
+ mayReplayFailedUnitOfWork = false;
+ }
+
+ nextUnitOfWork = workInProgress;
+
+ if (enableProfilerTimer) {
+ if (workInProgress.mode & ProfileMode) {
+ startProfilerTimer(workInProgress);
+ }
+
+ nextUnitOfWork = completeWork(current$$1, workInProgress, nextRenderExpirationTime);
+
+ if (workInProgress.mode & ProfileMode) {
+ stopProfilerTimerIfRunningAndRecordDelta(workInProgress, false);
+ }
+ } else {
+ nextUnitOfWork = completeWork(current$$1, workInProgress, nextRenderExpirationTime);
+ }
+
+ if (true && replayFailedUnitOfWorkWithInvokeGuardedCallback) {
+ mayReplayFailedUnitOfWork = true;
+ }
+
+ stopWorkTimer(workInProgress);
+ resetChildExpirationTime(workInProgress, nextRenderExpirationTime);
+ {
+ resetCurrentFiber();
+ }
+
+ if (nextUnitOfWork !== null) {
+ return nextUnitOfWork;
+ }
+
+ 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 {
+ if (enableProfilerTimer && workInProgress.mode & ProfileMode) {
+ stopProfilerTimerIfRunningAndRecordDelta(workInProgress, false);
+ var actualDuration = workInProgress.actualDuration;
+ var child = workInProgress.child;
+
+ while (child !== null) {
+ actualDuration += child.actualDuration;
+ child = child.sibling;
+ }
+
+ workInProgress.actualDuration = actualDuration;
+ }
+
+ var next = unwindWork(workInProgress, nextRenderExpirationTime);
+
+ if (workInProgress.effectTag & DidCapture) {
+ stopFailedWorkTimer(workInProgress);
+ } else {
+ stopWorkTimer(workInProgress);
+ }
+
+ {
+ 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$$1 = workInProgress.alternate;
+ startWorkTimer(workInProgress);
+ {
+ setCurrentFiber(workInProgress);
+ }
+
+ if (true && replayFailedUnitOfWorkWithInvokeGuardedCallback) {
+ stashedWorkInProgressProperties = assignFiberPropertiesInDEV(stashedWorkInProgressProperties, workInProgress);
+ }
+
+ var next = void 0;
+
+ if (enableProfilerTimer) {
+ if (workInProgress.mode & ProfileMode) {
+ startProfilerTimer(workInProgress);
+ }
+
+ next = beginWork(current$$1, workInProgress, nextRenderExpirationTime);
+ workInProgress.memoizedProps = workInProgress.pendingProps;
+
+ if (workInProgress.mode & ProfileMode) {
+ stopProfilerTimerIfRunningAndRecordDelta(workInProgress, true);
+ }
+ } else {
+ next = beginWork(current$$1, workInProgress, nextRenderExpirationTime);
+ workInProgress.memoizedProps = workInProgress.pendingProps;
+ }
+
+ {
+ resetCurrentFiber();
+
+ if (isReplayingFailedUnitOfWork) {
+ rethrowOriginalError();
+ }
+ }
+
+ if (true && ReactFiberInstrumentation_1.debugTool) {
+ ReactFiberInstrumentation_1.debugTool.onBeginWork(workInProgress);
+ }
+
+ if (next === null) {
+ next = completeUnitOfWork(workInProgress);
+ }
+
+ ReactCurrentOwner$2.current = null;
+ return next;
+ }
+
+ function workLoop(isYieldy) {
+ if (!isYieldy) {
+ while (nextUnitOfWork !== null) {
+ nextUnitOfWork = performUnitOfWork(nextUnitOfWork);
+ }
+ } else {
+ while (nextUnitOfWork !== null && !shouldYield$$1()) {
+ nextUnitOfWork = performUnitOfWork(nextUnitOfWork);
+ }
+ }
+ }
+
+ function renderRoot(root, isYieldy) {
+ invariant(!isWorking, "renderRoot was called recursively. This error is likely caused " + "by a bug in React. Please file an issue.");
+ flushPassiveEffects();
+ isWorking = true;
+ var previousDispatcher = ReactCurrentDispatcher.current;
+ ReactCurrentDispatcher.current = ContextOnlyDispatcher;
+ var expirationTime = root.nextExpirationTimeToWorkOn;
+
+ if (expirationTime !== nextRenderExpirationTime || root !== nextRoot || nextUnitOfWork === null) {
+ resetStack();
+ nextRoot = root;
+ nextRenderExpirationTime = expirationTime;
+ nextUnitOfWork = createWorkInProgress(nextRoot.current, null, nextRenderExpirationTime);
+ root.pendingCommitExpirationTime = NoWork;
+
+ if (enableSchedulerTracing) {
+ var interactions = new Set();
+ root.pendingInteractionMap.forEach(function (scheduledInteractions, scheduledExpirationTime) {
+ if (scheduledExpirationTime >= expirationTime) {
+ scheduledInteractions.forEach(function (interaction) {
+ return interactions.add(interaction);
+ });
+ }
+ });
+ root.memoizedInteractions = interactions;
+
+ if (interactions.size > 0) {
+ var subscriber = tracing.__subscriberRef.current;
+
+ if (subscriber !== null) {
+ var threadID = computeThreadID(expirationTime, root.interactionThreadID);
+
+ try {
+ subscriber.onWorkStarted(interactions, threadID);
+ } catch (error) {
+ if (!hasUnhandledError) {
+ hasUnhandledError = true;
+ unhandledError = error;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ var prevInteractions = null;
+
+ if (enableSchedulerTracing) {
+ prevInteractions = tracing.__interactionsRef.current;
+ tracing.__interactionsRef.current = root.memoizedInteractions;
+ }
+
+ var didFatal = false;
+ startWorkLoopTimer(nextUnitOfWork);
+
+ do {
+ try {
+ workLoop(isYieldy);
+ } catch (thrownValue) {
+ resetContextDependences();
+ resetHooks();
+ var mayReplay = void 0;
+
+ if (true && replayFailedUnitOfWorkWithInvokeGuardedCallback) {
+ mayReplay = mayReplayFailedUnitOfWork;
+ mayReplayFailedUnitOfWork = true;
+ }
+
+ if (nextUnitOfWork === null) {
+ didFatal = true;
+ onUncaughtError(thrownValue);
+ } else {
+ if (enableProfilerTimer && nextUnitOfWork.mode & ProfileMode) {
+ stopProfilerTimerIfRunningAndRecordDelta(nextUnitOfWork, true);
+ }
+
+ {
+ resetCurrentlyProcessingQueue();
+ }
+
+ if (true && replayFailedUnitOfWorkWithInvokeGuardedCallback) {
+ if (mayReplay) {
+ var failedUnitOfWork = nextUnitOfWork;
+ 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);
+ } else {
+ throwException(root, returnFiber, sourceFiber, thrownValue, nextRenderExpirationTime);
+ nextUnitOfWork = completeUnitOfWork(sourceFiber);
+ continue;
+ }
+ }
+ }
+
+ break;
+ } while (true);
+
+ if (enableSchedulerTracing) {
+ tracing.__interactionsRef.current = prevInteractions;
+ }
+
+ isWorking = false;
+ ReactCurrentDispatcher.current = previousDispatcher;
+ resetContextDependences();
+ resetHooks();
+
+ if (didFatal) {
+ var _didCompleteRoot = false;
+ stopWorkLoopTimer(interruptedBy, _didCompleteRoot);
+ interruptedBy = null;
+ {
+ resetStackAfterFatalErrorInDev();
+ }
+ nextRoot = null;
+ onFatal(root);
+ return;
+ }
+
+ if (nextUnitOfWork !== null) {
+ var _didCompleteRoot2 = false;
+ stopWorkLoopTimer(interruptedBy, _didCompleteRoot2);
+ interruptedBy = null;
+ onYield(root);
+ return;
+ }
+
+ var didCompleteRoot = true;
+ stopWorkLoopTimer(interruptedBy, didCompleteRoot);
+ 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.");
+ nextRoot = null;
+ interruptedBy = null;
+
+ if (nextRenderDidError) {
+ if (hasLowerPriorityWork(root, expirationTime)) {
+ markSuspendedPriorityLevel(root, expirationTime);
+ var suspendedExpirationTime = expirationTime;
+ var rootExpirationTime = root.expirationTime;
+ onSuspend(root, rootWorkInProgress, suspendedExpirationTime, rootExpirationTime, -1);
+ return;
+ } else if (!root.didError && isYieldy) {
+ root.didError = true;
+
+ var _suspendedExpirationTime = root.nextExpirationTimeToWorkOn = expirationTime;
+
+ var _rootExpirationTime = root.expirationTime = Sync;
+
+ onSuspend(root, rootWorkInProgress, _suspendedExpirationTime, _rootExpirationTime, -1);
+ return;
+ }
+ }
+
+ if (isYieldy && nextLatestAbsoluteTimeoutMs !== -1) {
+ var _suspendedExpirationTime2 = expirationTime;
+ markSuspendedPriorityLevel(root, _suspendedExpirationTime2);
+ var earliestExpirationTime = findEarliestOutstandingPriorityLevel(root, expirationTime);
+ var earliestExpirationTimeMs = expirationTimeToMs(earliestExpirationTime);
+
+ if (earliestExpirationTimeMs < nextLatestAbsoluteTimeoutMs) {
+ nextLatestAbsoluteTimeoutMs = earliestExpirationTimeMs;
+ }
+
+ var currentTimeMs = expirationTimeToMs(requestCurrentTime());
+ var msUntilTimeout = nextLatestAbsoluteTimeoutMs - currentTimeMs;
+ msUntilTimeout = msUntilTimeout < 0 ? 0 : msUntilTimeout;
+ var _rootExpirationTime2 = root.expirationTime;
+ onSuspend(root, rootWorkInProgress, _suspendedExpirationTime2, _rootExpirationTime2, msUntilTimeout);
+ return;
+ }
+
+ onComplete(root, rootWorkInProgress, expirationTime);
+ }
+
+ function captureCommitPhaseError(sourceFiber, value) {
+ var expirationTime = Sync;
+ var fiber = sourceFiber.return;
+
+ while (fiber !== null) {
+ switch (fiber.tag) {
+ case ClassComponent:
+ var ctor = fiber.type;
+ var instance = fiber.stateNode;
+
+ if (typeof ctor.getDerivedStateFromError === "function" || typeof instance.componentDidCatch === "function" && !isAlreadyFailedLegacyErrorBoundary(instance)) {
+ var errorInfo = createCapturedValue(value, sourceFiber);
+ var update = createClassErrorUpdate(fiber, errorInfo, expirationTime);
+ enqueueUpdate(fiber, update);
+ scheduleWork(fiber, expirationTime);
+ return;
+ }
+
+ break;
+
+ case HostRoot:
+ {
+ var _errorInfo = createCapturedValue(value, sourceFiber);
+
+ var _update = createRootErrorUpdate(fiber, _errorInfo, expirationTime);
+
+ enqueueUpdate(fiber, _update);
+ 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);
+ scheduleWork(rootFiber, expirationTime);
+ }
+ }
+
+ function computeThreadID(expirationTime, interactionThreadID) {
+ return expirationTime * 1000 + interactionThreadID;
+ }
+
+ function computeExpirationForFiber(currentTime, fiber) {
+ var priorityLevel = scheduler.unstable_getCurrentPriorityLevel();
+ var expirationTime = void 0;
+
+ if ((fiber.mode & ConcurrentMode) === NoContext) {
+ expirationTime = Sync;
+ } else if (isWorking && !isCommitting$1) {
+ expirationTime = nextRenderExpirationTime;
+ } else {
+ switch (priorityLevel) {
+ case scheduler.unstable_ImmediatePriority:
+ expirationTime = Sync;
+ break;
+
+ case scheduler.unstable_UserBlockingPriority:
+ expirationTime = computeInteractiveExpiration(currentTime);
+ break;
+
+ case scheduler.unstable_NormalPriority:
+ expirationTime = computeAsyncExpiration(currentTime);
+ break;
+
+ case scheduler.unstable_LowPriority:
+ case scheduler.unstable_IdlePriority:
+ expirationTime = Never;
+ break;
+
+ default:
+ invariant(false, "Unknown priority level. This error is likely caused by a bug in " + "React. Please file an issue.");
+ }
+
+ if (nextRoot !== null && expirationTime === nextRenderExpirationTime) {
+ expirationTime -= 1;
+ }
+ }
+
+ if (priorityLevel === scheduler.unstable_UserBlockingPriority && (lowestPriorityPendingInteractiveExpirationTime === NoWork || expirationTime < lowestPriorityPendingInteractiveExpirationTime)) {
+ lowestPriorityPendingInteractiveExpirationTime = expirationTime;
+ }
+
+ return expirationTime;
+ }
+
+ function renderDidSuspend(root, absoluteTimeoutMs, suspendedTime) {
+ if (absoluteTimeoutMs >= 0 && nextLatestAbsoluteTimeoutMs < absoluteTimeoutMs) {
+ nextLatestAbsoluteTimeoutMs = absoluteTimeoutMs;
+ }
+ }
+
+ function renderDidError() {
+ nextRenderDidError = true;
+ }
+
+ function pingSuspendedRoot(root, thenable, pingTime) {
+ var pingCache = root.pingCache;
+
+ if (pingCache !== null) {
+ pingCache.delete(thenable);
+ }
+
+ if (nextRoot !== null && nextRenderExpirationTime === pingTime) {
+ nextRoot = null;
+ } else {
+ if (isPriorityLevelSuspended(root, pingTime)) {
+ markPingedPriorityLevel(root, pingTime);
+ var rootExpirationTime = root.expirationTime;
+
+ if (rootExpirationTime !== NoWork) {
+ requestWork(root, rootExpirationTime);
+ }
+ }
+ }
+ }
+
+ function retryTimedOutBoundary(boundaryFiber) {
+ var currentTime = requestCurrentTime();
+ var retryTime = computeExpirationForFiber(currentTime, boundaryFiber);
+ var root = scheduleWorkToRoot(boundaryFiber, retryTime);
+
+ if (root !== null) {
+ markPendingPriorityLevel(root, retryTime);
+ var rootExpirationTime = root.expirationTime;
+
+ if (rootExpirationTime !== NoWork) {
+ requestWork(root, rootExpirationTime);
+ }
+ }
+ }
+
+ function resolveRetryThenable(boundaryFiber, thenable) {
+ var retryCache = void 0;
+
+ if (enableSuspenseServerRenderer) {
+ switch (boundaryFiber.tag) {
+ case SuspenseComponent:
+ retryCache = boundaryFiber.stateNode;
+ break;
+
+ case DehydratedSuspenseComponent:
+ retryCache = boundaryFiber.memoizedState;
+ break;
+
+ default:
+ invariant(false, "Pinged unknown suspense boundary type. " + "This is probably a bug in React.");
+ }
+ } else {
+ retryCache = boundaryFiber.stateNode;
+ }
+
+ if (retryCache !== null) {
+ retryCache.delete(thenable);
+ }
+
+ retryTimedOutBoundary(boundaryFiber);
+ }
+
+ function scheduleWorkToRoot(fiber, expirationTime) {
+ recordScheduleUpdate();
+ {
+ if (fiber.tag === ClassComponent) {
+ var instance = fiber.stateNode;
+ warnAboutInvalidUpdates(instance);
+ }
+ }
+
+ if (fiber.expirationTime < expirationTime) {
+ fiber.expirationTime = expirationTime;
+ }
+
+ var alternate = fiber.alternate;
+
+ if (alternate !== null && alternate.expirationTime < expirationTime) {
+ alternate.expirationTime = expirationTime;
+ }
+
+ var node = fiber.return;
+ var root = null;
+
+ if (node === null && fiber.tag === HostRoot) {
+ root = fiber.stateNode;
+ } else {
+ while (node !== null) {
+ alternate = node.alternate;
+
+ if (node.childExpirationTime < expirationTime) {
+ node.childExpirationTime = expirationTime;
+
+ if (alternate !== null && alternate.childExpirationTime < expirationTime) {
+ alternate.childExpirationTime = expirationTime;
+ }
+ } else if (alternate !== null && alternate.childExpirationTime < expirationTime) {
+ alternate.childExpirationTime = expirationTime;
+ }
+
+ if (node.return === null && node.tag === HostRoot) {
+ root = node.stateNode;
+ break;
+ }
+
+ node = node.return;
+ }
+ }
+
+ if (enableSchedulerTracing) {
+ if (root !== null) {
+ var interactions = tracing.__interactionsRef.current;
+
+ if (interactions.size > 0) {
+ var pendingInteractionMap = root.pendingInteractionMap;
+ var pendingInteractions = pendingInteractionMap.get(expirationTime);
+
+ if (pendingInteractions != null) {
+ interactions.forEach(function (interaction) {
+ if (!pendingInteractions.has(interaction)) {
+ interaction.__count++;
+ }
+
+ pendingInteractions.add(interaction);
+ });
+ } else {
+ pendingInteractionMap.set(expirationTime, new Set(interactions));
+ interactions.forEach(function (interaction) {
+ interaction.__count++;
+ });
+ }
+
+ var subscriber = tracing.__subscriberRef.current;
+
+ if (subscriber !== null) {
+ var threadID = computeThreadID(expirationTime, root.interactionThreadID);
+ subscriber.onWorkScheduled(interactions, threadID);
+ }
+ }
+ }
+ }
+
+ return root;
+ }
+
+ function warnIfNotCurrentlyBatchingInDev(fiber) {
+ {
+ if (isRendering === false && isBatchingUpdates === false) {
+ warningWithoutStack$1(false, "An update to %s inside a test was not wrapped in act(...).\n\n" + "When testing, code that causes React state updates should be wrapped into act(...):\n\n" + "act(() => {\n" + " /* fire events that update state */\n" + "});\n" + "/* assert on the output */\n\n" + "This ensures that you're testing the behavior the user would see in the browser." + " Learn more at https://fb.me/react-wrap-tests-with-act" + "%s", getComponentName(fiber.type), getStackByFiberInDevAndProd(fiber));
+ }
+ }
+ }
+
+ function scheduleWork(fiber, expirationTime) {
+ var root = scheduleWorkToRoot(fiber, expirationTime);
+
+ if (root === null) {
+ {
+ switch (fiber.tag) {
+ case ClassComponent:
+ warnAboutUpdateOnUnmounted(fiber, true);
+ break;
+
+ case FunctionComponent:
+ case ForwardRef:
+ case MemoComponent:
+ case SimpleMemoComponent:
+ warnAboutUpdateOnUnmounted(fiber, false);
+ break;
+ }
+ }
+ return;
+ }
+
+ 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) {
+ nestedUpdateCount = 0;
+ 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.");
+ }
+ }
+
+ var firstScheduledRoot = null;
+ var lastScheduledRoot = null;
+ var callbackExpirationTime = NoWork;
+ var callbackID = void 0;
+ var isRendering = false;
+ var nextFlushedRoot = null;
+ var nextFlushedExpirationTime = NoWork;
+ var lowestPriorityPendingInteractiveExpirationTime = NoWork;
+ var hasUnhandledError = false;
+ var unhandledError = null;
+ var isBatchingUpdates = false;
+ var isUnbatchingUpdates = false;
+ var completedBatches = null;
+ var originalStartTimeMs = now$$1();
+ var currentRendererTime = msToExpirationTime(originalStartTimeMs);
+ var currentSchedulerTime = currentRendererTime;
+ var NESTED_UPDATE_LIMIT = 50;
+ var nestedUpdateCount = 0;
+ var lastCommittedRootDuringThisBatch = null;
+
+ function recomputeCurrentRendererTime() {
+ var currentTimeMs = now$$1() - originalStartTimeMs;
+ currentRendererTime = msToExpirationTime(currentTimeMs);
+ }
+
+ function scheduleCallbackWithExpirationTime(root, expirationTime) {
+ if (callbackExpirationTime !== NoWork) {
+ if (expirationTime < callbackExpirationTime) {
+ return;
+ } else {
+ if (callbackID !== null) {
+ cancelDeferredCallback$$1(callbackID);
+ }
+ }
+ } else {
+ startRequestCallbackTimer();
+ }
+
+ callbackExpirationTime = expirationTime;
+ var currentMs = now$$1() - originalStartTimeMs;
+ var expirationTimeMs = expirationTimeToMs(expirationTime);
+ var timeout = expirationTimeMs - currentMs;
+ callbackID = scheduleDeferredCallback$$1(performAsyncWork, {
+ timeout: timeout
+ });
+ }
+
+ function onFatal(root) {
+ root.finishedWork = null;
+ }
+
+ function onComplete(root, finishedWork, expirationTime) {
+ root.pendingCommitExpirationTime = expirationTime;
+ root.finishedWork = finishedWork;
+ }
+
+ function onSuspend(root, finishedWork, suspendedExpirationTime, rootExpirationTime, msUntilTimeout) {
+ root.expirationTime = rootExpirationTime;
+
+ if (msUntilTimeout === 0 && !shouldYield$$1()) {
+ root.pendingCommitExpirationTime = suspendedExpirationTime;
+ root.finishedWork = finishedWork;
+ } else if (msUntilTimeout > 0) {
+ root.timeoutHandle = scheduleTimeout(onTimeout.bind(null, root, finishedWork, suspendedExpirationTime), msUntilTimeout);
+ }
+ }
+
+ function onYield(root) {
+ root.finishedWork = null;
+ }
+
+ function onTimeout(root, finishedWork, suspendedExpirationTime) {
+ root.pendingCommitExpirationTime = suspendedExpirationTime;
+ root.finishedWork = finishedWork;
+ recomputeCurrentRendererTime();
+ currentSchedulerTime = currentRendererTime;
+ flushRoot(root, suspendedExpirationTime);
+ }
+
+ function onCommit(root, expirationTime) {
+ root.expirationTime = expirationTime;
+ root.finishedWork = null;
+ }
+
+ function requestCurrentTime() {
+ if (isRendering) {
+ return currentSchedulerTime;
+ }
+
+ findHighestPriorityRoot();
+
+ if (nextFlushedExpirationTime === NoWork || nextFlushedExpirationTime === Never) {
+ recomputeCurrentRendererTime();
+ currentSchedulerTime = currentRendererTime;
+ return currentSchedulerTime;
+ }
+
+ return currentSchedulerTime;
+ }
+
+ 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(root, 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 (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 (remainingExpirationTime > highestPriorityWork) {
+ highestPriorityWork = remainingExpirationTime;
+ highestPriorityRoot = root;
+ }
+
+ if (root === lastScheduledRoot) {
+ break;
+ }
+
+ if (highestPriorityWork === Sync) {
+ break;
+ }
+
+ previousScheduledRoot = root;
+ root = root.nextScheduledRoot;
+ }
+ }
+ }
+
+ nextFlushedRoot = highestPriorityRoot;
+ nextFlushedExpirationTime = highestPriorityWork;
+ }
+
+ function performAsyncWork(didTimeout) {
+ if (didTimeout) {
+ if (firstScheduledRoot !== null) {
+ recomputeCurrentRendererTime();
+ var root = firstScheduledRoot;
+
+ do {
+ didExpireAtExpirationTime(root, currentRendererTime);
+ root = root.nextScheduledRoot;
+ } while (root !== firstScheduledRoot);
+ }
+ }
+
+ performWork(NoWork, true);
+ }
+
+ function performSyncWork() {
+ performWork(Sync, false);
+ }
+
+ function performWork(minExpirationTime, isYieldy) {
+ findHighestPriorityRoot();
+
+ if (isYieldy) {
+ recomputeCurrentRendererTime();
+ currentSchedulerTime = currentRendererTime;
+
+ if (enableUserTimingAPI) {
+ var didExpire = nextFlushedExpirationTime > currentRendererTime;
+ var timeout = expirationTimeToMs(nextFlushedExpirationTime);
+ stopRequestCallbackTimer(didExpire, timeout);
+ }
+
+ while (nextFlushedRoot !== null && nextFlushedExpirationTime !== NoWork && minExpirationTime <= nextFlushedExpirationTime && !(shouldYield$$1() && currentRendererTime > nextFlushedExpirationTime)) {
+ performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, currentRendererTime > nextFlushedExpirationTime);
+ findHighestPriorityRoot();
+ recomputeCurrentRendererTime();
+ currentSchedulerTime = currentRendererTime;
+ }
+ } else {
+ while (nextFlushedRoot !== null && nextFlushedExpirationTime !== NoWork && minExpirationTime <= nextFlushedExpirationTime) {
+ performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, false);
+ findHighestPriorityRoot();
+ }
+ }
+
+ if (isYieldy) {
+ callbackExpirationTime = NoWork;
+ callbackID = null;
+ }
+
+ if (nextFlushedExpirationTime !== NoWork) {
+ scheduleCallbackWithExpirationTime(nextFlushedRoot, nextFlushedExpirationTime);
+ }
+
+ 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();
+ }
+
+ function finishRendering() {
+ nestedUpdateCount = 0;
+ lastCommittedRootDuringThisBatch = null;
+
+ 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;
+ var timeoutHandle = root.timeoutHandle;
+
+ if (timeoutHandle !== noTimeout) {
+ root.timeoutHandle = noTimeout;
+ cancelTimeout(timeoutHandle);
+ }
+
+ renderRoot(root, isYieldy);
+ 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;
+ var _timeoutHandle = root.timeoutHandle;
+
+ if (_timeoutHandle !== noTimeout) {
+ root.timeoutHandle = noTimeout;
+ cancelTimeout(_timeoutHandle);
+ }
+
+ renderRoot(root, isYieldy);
+ _finishedWork = root.finishedWork;
+
+ if (_finishedWork !== null) {
+ if (!shouldYield$$1()) {
+ completeRoot$1(root, _finishedWork, expirationTime);
+ } else {
+ root.finishedWork = _finishedWork;
+ }
+ }
+ }
+ }
+
+ 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;
+
+ if (root === lastCommittedRootDuringThisBatch) {
+ nestedUpdateCount++;
+ } else {
+ lastCommittedRootDuringThisBatch = root;
+ nestedUpdateCount = 0;
+ }
+
+ scheduler.unstable_runWithPriority(scheduler.unstable_ImmediatePriority, function () {
+ commitRoot(root, finishedWork);
+ });
+ }
+
+ 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 interactiveUpdates$1(fn, a, b) {
+ if (!isBatchingUpdates && !isRendering && lowestPriorityPendingInteractiveExpirationTime !== NoWork) {
+ performWork(lowestPriorityPendingInteractiveExpirationTime, false);
+ lowestPriorityPendingInteractiveExpirationTime = NoWork;
+ }
+
+ var previousIsBatchingUpdates = isBatchingUpdates;
+ isBatchingUpdates = true;
+
+ try {
+ return scheduler.unstable_runWithPriority(scheduler.unstable_UserBlockingPriority, function () {
+ return fn(a, b);
+ });
+ } finally {
+ isBatchingUpdates = previousIsBatchingUpdates;
+
+ if (!isBatchingUpdates && !isRendering) {
+ performSyncWork();
+ }
+ }
+ }
+
+ function flushInteractiveUpdates$1() {
+ if (!isRendering && lowestPriorityPendingInteractiveExpirationTime !== NoWork) {
+ performWork(lowestPriorityPendingInteractiveExpirationTime, false);
+ lowestPriorityPendingInteractiveExpirationTime = NoWork;
+ }
+ }
+
+ var didWarnAboutNestedUpdates = void 0;
+ var didWarnAboutFindNodeInStrictMode = void 0;
+ {
+ didWarnAboutNestedUpdates = false;
+ didWarnAboutFindNodeInStrictMode = {};
+ }
+
+ function getContextForSubtree(parentComponent) {
+ if (!parentComponent) {
+ return emptyContextObject;
+ }
+
+ var fiber = get$1(parentComponent);
+ var parentContext = findCurrentUnmaskedContext(fiber);
+
+ if (fiber.tag === ClassComponent) {
+ var Component = fiber.type;
+
+ if (isContextProvider(Component)) {
+ return processChildContext(fiber, Component, parentContext);
+ }
+ }
+
+ return parentContext;
+ }
+
+ function scheduleRootUpdate(current$$1, element, expirationTime, callback) {
+ {
+ if (phase === "render" && current !== null && !didWarnAboutNestedUpdates) {
+ didWarnAboutNestedUpdates = true;
+ warningWithoutStack$1(false, "Render methods should be a pure function of props and state; " + "triggering nested component updates from render is not allowed. " + "If necessary, trigger nested updates in componentDidUpdate.\n\n" + "Check the render method of %s.", getComponentName(current.type) || "Unknown");
+ }
+ }
+ var update = createUpdate(expirationTime);
+ update.payload = {
+ element: element
+ };
+ callback = callback === undefined ? null : callback;
+
+ if (callback !== null) {
+ !(typeof callback === "function") ? warningWithoutStack$1(false, "render(...): Expected the last optional `callback` argument to be a " + "function. Instead received: %s.", callback) : void 0;
+ update.callback = callback;
+ }
+
+ flushPassiveEffects();
+ enqueueUpdate(current$$1, update);
+ scheduleWork(current$$1, expirationTime);
+ return expirationTime;
+ }
+
+ function updateContainerAtExpirationTime(element, container, parentComponent, expirationTime, callback) {
+ var current$$1 = container.current;
+ {
+ if (ReactFiberInstrumentation_1.debugTool) {
+ if (current$$1.alternate === null) {
+ ReactFiberInstrumentation_1.debugTool.onMountContainer(container);
+ } else if (element === null) {
+ ReactFiberInstrumentation_1.debugTool.onUnmountContainer(container);
+ } else {
+ ReactFiberInstrumentation_1.debugTool.onUpdateContainer(container);
+ }
+ }
+ }
+ var context = getContextForSubtree(parentComponent);
+
+ if (container.context === null) {
+ container.context = context;
+ } else {
+ container.pendingContext = context;
+ }
+
+ return scheduleRootUpdate(current$$1, element, expirationTime, callback);
+ }
+
+ function findHostInstance(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 findHostInstanceWithWarning(component, methodName) {
+ {
+ 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;
+ }
+
+ if (hostFiber.mode & StrictMode) {
+ var componentName = getComponentName(fiber.type) || "Component";
+
+ if (!didWarnAboutFindNodeInStrictMode[componentName]) {
+ didWarnAboutFindNodeInStrictMode[componentName] = true;
+
+ if (fiber.mode & StrictMode) {
+ warningWithoutStack$1(false, "%s is deprecated in StrictMode. " + "%s was passed an instance of %s which is inside StrictMode. " + "Instead, add a ref directly to the element you want to reference." + "\n%s" + "\n\nLearn more about using refs safely here:" + "\nhttps://fb.me/react-strict-mode-find-node", methodName, methodName, componentName, getStackByFiberInDevAndProd(hostFiber));
+ } else {
+ warningWithoutStack$1(false, "%s is deprecated in StrictMode. " + "%s was passed an instance of %s which renders StrictMode children. " + "Instead, add a ref directly to the element you want to reference." + "\n%s" + "\n\nLearn more about using refs safely here:" + "\nhttps://fb.me/react-strict-mode-find-node", methodName, methodName, componentName, getStackByFiberInDevAndProd(hostFiber));
+ }
+ }
+ }
+
+ return hostFiber.stateNode;
+ }
+ return findHostInstance(component);
+ }
+
+ function createContainer(containerInfo, isConcurrent, hydrate) {
+ return createFiberRoot(containerInfo, isConcurrent, hydrate);
+ }
+
+ function updateContainer(element, container, parentComponent, callback) {
+ var current$$1 = container.current;
+ var currentTime = requestCurrentTime();
+ var expirationTime = computeExpirationForFiber(currentTime, current$$1);
+ 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;
+ }
+ }
+
+ var overrideProps = null;
+ {
+ var copyWithSetImpl = function copyWithSetImpl(obj, path, idx, value) {
+ if (idx >= path.length) {
+ return value;
+ }
+
+ var key = path[idx];
+ var updated = Array.isArray(obj) ? obj.slice() : _extends({}, obj);
+ updated[key] = copyWithSetImpl(obj[key], path, idx + 1, value);
+ return updated;
+ };
+
+ var copyWithSet = function copyWithSet(obj, path, value) {
+ return copyWithSetImpl(obj, path, 0, value);
+ };
+
+ overrideProps = function overrideProps(fiber, path, value) {
+ flushPassiveEffects();
+ fiber.pendingProps = copyWithSet(fiber.memoizedProps, path, value);
+
+ if (fiber.alternate) {
+ fiber.alternate.pendingProps = fiber.pendingProps;
+ }
+
+ scheduleWork(fiber, Sync);
+ };
+ }
+
+ function injectIntoDevTools(devToolsConfig) {
+ var _findFiberByHostInstance = devToolsConfig.findFiberByHostInstance;
+ var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
+ return injectInternals(_extends({}, devToolsConfig, {
+ overrideProps: overrideProps,
+ currentDispatcherRef: ReactCurrentDispatcher,
+ findHostInstanceByFiber: function findHostInstanceByFiber(fiber) {
+ var hostFiber = findCurrentHostFiber(fiber);
+
+ if (hostFiber === null) {
+ return null;
+ }
+
+ return hostFiber.stateNode;
+ },
+ findFiberByHostInstance: function findFiberByHostInstance(instance) {
+ if (!_findFiberByHostInstance) {
+ return null;
+ }
+
+ return _findFiberByHostInstance(instance);
+ }
+ }));
+ }
+
+ function _createPortal(children, containerInfo, implementation) {
+ var key = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
+ return {
+ $$typeof: REACT_PORTAL_TYPE,
+ key: key == null ? null : "" + key,
+ children: children,
+ containerInfo: containerInfo,
+ implementation: implementation
+ };
+ }
+
+ var ReactVersion = "16.8.3";
+
+ var NativeMethodsMixin = function NativeMethodsMixin(findNodeHandle, findHostInstance) {
+ var NativeMethodsMixin = {
+ measure: function measure(callback) {
+ UIManager.measure(findNodeHandle(this), mountSafeCallback_NOT_REALLY_SAFE(this, callback));
+ },
+ measureInWindow: function measureInWindow(callback) {
+ UIManager.measureInWindow(findNodeHandle(this), mountSafeCallback_NOT_REALLY_SAFE(this, callback));
+ },
+ measureLayout: function measureLayout(relativeToNativeNode, onSuccess, onFail) {
+ UIManager.measureLayout(findNodeHandle(this), relativeToNativeNode, mountSafeCallback_NOT_REALLY_SAFE(this, onFail), mountSafeCallback_NOT_REALLY_SAFE(this, onSuccess));
+ },
+ setNativeProps: function setNativeProps(nativeProps) {
+ {
+ if (warnAboutDeprecatedSetNativeProps) {
+ warningWithoutStack$1(false, "Warning: Calling ref.setNativeProps(nativeProps) " + "is deprecated and will be removed in a future release. " + "Use the setNativeProps export from the react-native package instead." + "\n\timport {setNativeProps} from 'react-native';\n\tsetNativeProps(ref, nativeProps);\n");
+ }
+ }
+ var maybeInstance = void 0;
+
+ try {
+ maybeInstance = findHostInstance(this);
+ } catch (error) {}
+
+ if (maybeInstance == null) {
+ return;
+ }
+
+ var nativeTag = maybeInstance._nativeTag || maybeInstance.canonical._nativeTag;
+ var viewConfig = maybeInstance.viewConfig || maybeInstance.canonical.viewConfig;
+ {
+ warnForStyleProps(nativeProps, viewConfig.validAttributes);
+ }
+ var updatePayload = create(nativeProps, viewConfig.validAttributes);
+
+ if (updatePayload != null) {
+ UIManager.updateView(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_NOT_REALLY_SAFE(this, callback));
+ };
+
+ ReactNativeComponent.prototype.measureInWindow = function measureInWindow(callback) {
+ UIManager.measureInWindow(findNodeHandle(this), mountSafeCallback_NOT_REALLY_SAFE(this, callback));
+ };
+
+ ReactNativeComponent.prototype.measureLayout = function measureLayout(relativeToNativeNode, onSuccess, onFail) {
+ UIManager.measureLayout(findNodeHandle(this), relativeToNativeNode, mountSafeCallback_NOT_REALLY_SAFE(this, onFail), mountSafeCallback_NOT_REALLY_SAFE(this, onSuccess));
+ };
+
+ ReactNativeComponent.prototype.setNativeProps = function setNativeProps(nativeProps) {
+ {
+ if (warnAboutDeprecatedSetNativeProps) {
+ warningWithoutStack$1(false, "Warning: Calling ref.setNativeProps(nativeProps) " + "is deprecated and will be removed in a future release. " + "Use the setNativeProps export from the react-native package instead." + "\n\timport {setNativeProps} from 'react-native';\n\tsetNativeProps(ref, nativeProps);\n");
+ }
+ }
+ var maybeInstance = void 0;
+
+ try {
+ maybeInstance = findHostInstance(this);
+ } catch (error) {}
+
+ if (maybeInstance == null) {
+ return;
+ }
+
+ var nativeTag = maybeInstance._nativeTag || maybeInstance.canonical._nativeTag;
+ var viewConfig = maybeInstance.viewConfig || maybeInstance.canonical.viewConfig;
+ var updatePayload = create(nativeProps, viewConfig.validAttributes);
+
+ if (updatePayload != null) {
+ UIManager.updateView(nativeTag, viewConfig.uiViewClassName, updatePayload);
+ }
+ };
+
+ return ReactNativeComponent;
+ }(React.Component);
+
+ return ReactNativeComponent;
+ };
+
+ var instanceCache = {};
+
+ function getInstanceFromTag(tag) {
+ return instanceCache[tag] || null;
+ }
+
+ var emptyObject$1 = {};
+ {
+ Object.freeze(emptyObject$1);
+ }
+ 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$1;
+ }
+
+ return emptyObject$1;
+ };
+
+ var getHostNode = function getHostNode(fiber, findNodeHandle) {
+ var hostNode = void 0;
+
+ while (fiber) {
+ if (fiber.stateNode !== null && fiber.tag === HostComponent) {
+ hostNode = findNodeHandle(fiber.stateNode);
+ }
+
+ if (hostNode) {
+ return hostNode;
+ }
+
+ fiber = fiber.child;
+ }
+
+ return null;
+ };
+
+ var createHierarchy = function createHierarchy(fiberHierarchy) {
+ return fiberHierarchy.map(function (fiber) {
+ return {
+ name: getComponentName(fiber.type),
+ getInspectorData: function getInspectorData(findNodeHandle) {
+ return {
+ measure: function measure(callback) {
+ return 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$1,
+ selection: null,
+ source: null
+ };
+ }
+
+ var fiber = findCurrentFiberUsingSlowPath(closestInstance);
+ var fiberHierarchy = getOwnerHierarchy(fiber);
+ var instance = lastNonHostInstance(fiberHierarchy);
+ var hierarchy = createHierarchy(fiberHierarchy);
+ var props = getHostProps(instance);
+ var source = instance._debugSource;
+ var selection = fiberHierarchy.indexOf(instance);
+ return {
+ hierarchy: hierarchy,
+ props: props,
+ selection: selection,
+ source: source
+ };
+ };
+ }
+
+ function setNativeProps(handle, nativeProps) {
+ if (handle._nativeTag == null) {
+ !(handle._nativeTag != null) ? warningWithoutStack$1(false, "setNativeProps was called with a ref that isn't a " + "native component. Use React.forwardRef to get access to the underlying native component") : void 0;
+ return;
+ }
+
+ {
+ warnForStyleProps(nativeProps, handle.viewConfig.validAttributes);
+ }
+ var updatePayload = create(nativeProps, handle.viewConfig.validAttributes);
+
+ if (updatePayload != null) {
+ UIManager.updateView(handle._nativeTag, handle.viewConfig.uiViewClassName, updatePayload);
+ }
+ }
+
+ var ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner;
+
+ function findNodeHandle(componentOrHandle) {
+ {
+ var owner = ReactCurrentOwner.current;
+
+ if (owner !== null && owner.stateNode !== null) {
+ !owner.stateNode._warnedAboutRefsInRender ? warningWithoutStack$1(false, "%s is accessing findNodeHandle inside its render(). " + "render() should be a pure function of props and state. It should " + "never access something that requires stale data from the previous " + "render, such as refs. Move this logic to componentDidMount and " + "componentDidUpdate instead.", getComponentName(owner.type) || "A component") : void 0;
+ owner.stateNode._warnedAboutRefsInRender = true;
+ }
+ }
+
+ if (componentOrHandle == null) {
+ return null;
+ }
+
+ if (typeof componentOrHandle === "number") {
+ return componentOrHandle;
+ }
+
+ if (componentOrHandle._nativeTag) {
+ return componentOrHandle._nativeTag;
+ }
+
+ if (componentOrHandle.canonical && componentOrHandle.canonical._nativeTag) {
+ return componentOrHandle.canonical._nativeTag;
+ }
+
+ var hostInstance = void 0;
+ {
+ hostInstance = findHostInstanceWithWarning(componentOrHandle, "findNodeHandle");
+ }
+
+ if (hostInstance == null) {
+ return hostInstance;
+ }
+
+ if (hostInstance.canonical) {
+ return hostInstance.canonical._nativeTag;
+ }
+
+ return hostInstance._nativeTag;
+ }
+
+ setBatchingImplementation(batchedUpdates$1, interactiveUpdates$1, flushInteractiveUpdates$1);
+ var roots = new Map();
+ var ReactFabric = {
+ NativeComponent: ReactNativeComponent(findNodeHandle, findHostInstance),
+ findNodeHandle: findNodeHandle,
+ setNativeProps: setNativeProps,
+ 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;
+ module.exports = fabric;
+ })();
+ }
+},381,[14,86,173,71,11,175,80,49,176,382,16,177,180,98],"node_modules\\react-native\\Libraries\\Renderer\\oss\\ReactFabric-dev.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var FabricUIManager = global.nativeFabricUIManager;
+ module.exports = FabricUIManager;
+},382,[],"node_modules\\react-native\\Libraries\\ReactNative\\FabricUIManager.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ "use strict";
+
+ var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");
+
+ _$$_REQUIRE(_dependencyMap[1], "InitializeCore");
+
+ var ReactNativeViewConfigRegistry = _$$_REQUIRE(_dependencyMap[2], "ReactNativeViewConfigRegistry"),
+ UIManager = _$$_REQUIRE(_dependencyMap[3], "UIManager"),
+ React = _$$_REQUIRE(_dependencyMap[4], "react"),
+ deepDiffer = _$$_REQUIRE(_dependencyMap[5], "deepDiffer"),
+ flattenStyle = _$$_REQUIRE(_dependencyMap[6], "flattenStyle"),
+ TextInputState = _$$_REQUIRE(_dependencyMap[7], "TextInputState"),
+ FabricUIManager = _$$_REQUIRE(_dependencyMap[8], "FabricUIManager");
+
+ var scheduler = _$$_REQUIRE(_dependencyMap[9], "scheduler"),
+ ExceptionsManager = _$$_REQUIRE(_dependencyMap[10], "ExceptionsManager");
+
+ function invariant(condition, format, a, b, c, d, e, f) {
+ if (!condition) {
+ condition = void 0;
+ if (void 0 === format) condition = 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],
+ argIndex = 0;
+ condition = Error(format.replace(/%s/g, function () {
+ return args[argIndex++];
+ }));
+ condition.name = "Invariant Violation";
+ }
+ condition.framesToPop = 1;
+ throw condition;
+ }
+ }
+
+ function invokeGuardedCallbackImpl(name, func, context, a, b, c, d, e, f) {
+ var funcArgs = Array.prototype.slice.call(arguments, 3);
+
+ try {
+ func.apply(context, funcArgs);
+ } catch (error) {
+ this.onError(error);
+ }
+ }
+
+ var hasError = !1,
+ caughtError = null,
+ hasRethrowError = !1,
+ rethrowError = null,
+ reporter = {
+ onError: function onError(error) {
+ hasError = !0;
+ caughtError = error;
+ }
+ };
+
+ function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
+ hasError = !1;
+ caughtError = null;
+ invokeGuardedCallbackImpl.apply(reporter, arguments);
+ }
+
+ function invokeGuardedCallbackAndCatchFirstError(name, func, context, a, b, c, d, e, f) {
+ invokeGuardedCallback.apply(this, arguments);
+
+ if (hasError) {
+ if (hasError) {
+ var error = caughtError;
+ hasError = !1;
+ caughtError = null;
+ } else invariant(!1, "clearCaughtError was called but no error was captured. This error is likely caused by a bug in React. Please file an issue."), error = void 0;
+
+ hasRethrowError || (hasRethrowError = !0, rethrowError = 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, listener, inst) {
+ var type = event.type || "unknown-event";
+ event.currentTarget = getNodeFromInstance(inst);
+ invokeGuardedCallbackAndCatchFirstError(type, listener, void 0, event);
+ event.currentTarget = null;
+ }
+
+ function executeDirectDispatch(event) {
+ var dispatchListener = event._dispatchListeners,
+ dispatchInstance = event._dispatchInstances;
+ 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, dispatchListeners[i], dispatchInstances[i]);
+ } else dispatchListeners && executeDispatch(e, dispatchListeners, dispatchInstances);
+ e._dispatchListeners = null;
+ e._dispatchInstances = null;
+ e.isPersistent() || e.constructor.release(e);
+ }
+ }
+
+ var injection = {
+ injectEventPluginOrder: function injectEventPluginOrder(injectedEventPluginOrder) {
+ 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));
+ }
+ }
+ }
+
+ function functionThatReturnsTrue() {
+ return !0;
+ }
+
+ function functionThatReturnsFalse() {
+ return !1;
+ }
+
+ function SyntheticEvent(dispatchConfig, targetInst, nativeEvent, nativeEventTarget) {
+ this.dispatchConfig = dispatchConfig;
+ this._targetInst = targetInst;
+ this.nativeEvent = nativeEvent;
+ dispatchConfig = this.constructor.Interface;
+
+ for (var propName in dispatchConfig) {
+ dispatchConfig.hasOwnProperty(propName) && ((targetInst = dispatchConfig[propName]) ? this[propName] = targetInst(nativeEvent) : "target" === propName ? this.target = nativeEventTarget : this[propName] = nativeEvent[propName]);
+ }
+
+ this.isDefaultPrevented = (null != nativeEvent.defaultPrevented ? nativeEvent.defaultPrevented : !1 === nativeEvent.returnValue) ? functionThatReturnsTrue : functionThatReturnsFalse;
+ this.isPropagationStopped = functionThatReturnsFalse;
+ return this;
+ }
+
+ _extends(SyntheticEvent.prototype, {
+ preventDefault: function preventDefault() {
+ this.defaultPrevented = !0;
+ var event = this.nativeEvent;
+ event && (event.preventDefault ? event.preventDefault() : "unknown" !== typeof event.returnValue && (event.returnValue = !1), this.isDefaultPrevented = functionThatReturnsTrue);
+ },
+ stopPropagation: function stopPropagation() {
+ var event = this.nativeEvent;
+ event && (event.stopPropagation ? event.stopPropagation() : "unknown" !== typeof event.cancelBubble && (event.cancelBubble = !0), this.isPropagationStopped = functionThatReturnsTrue);
+ },
+ persist: function persist() {
+ this.isPersistent = functionThatReturnsTrue;
+ },
+ isPersistent: functionThatReturnsFalse,
+ destructor: function destructor() {
+ var Interface = this.constructor.Interface,
+ propName;
+
+ for (propName in Interface) {
+ this[propName] = null;
+ }
+
+ this.nativeEvent = this._targetInst = this.dispatchConfig = null;
+ this.isPropagationStopped = this.isDefaultPrevented = functionThatReturnsFalse;
+ this._dispatchInstances = this._dispatchListeners = null;
+ }
+ });
+
+ SyntheticEvent.Interface = {
+ type: null,
+ target: null,
+ currentTarget: function currentTarget() {
+ return null;
+ },
+ eventPhase: null,
+ bubbles: null,
+ cancelable: null,
+ timeStamp: function timeStamp(event) {
+ return event.timeStamp || Date.now();
+ },
+ defaultPrevented: null,
+ isTrusted: null
+ };
+
+ SyntheticEvent.extend = function (Interface) {
+ function E() {}
+
+ function Class() {
+ return Super.apply(this, arguments);
+ }
+
+ var Super = this;
+ E.prototype = Super.prototype;
+ var prototype = new E();
+
+ _extends(prototype, Class.prototype);
+
+ Class.prototype = prototype;
+ Class.prototype.constructor = Class;
+ Class.Interface = _extends({}, Super.Interface, Interface);
+ Class.extend = Super.extend;
+ addEventPoolingTo(Class);
+ return Class;
+ };
+
+ addEventPoolingTo(SyntheticEvent);
+
+ function getPooledEvent(dispatchConfig, targetInst, nativeEvent, nativeInst) {
+ if (this.eventPool.length) {
+ var instance = this.eventPool.pop();
+ this.call(instance, dispatchConfig, targetInst, nativeEvent, nativeInst);
+ return instance;
+ }
+
+ return new this(dispatchConfig, targetInst, nativeEvent, nativeInst);
+ }
+
+ function releasePooledEvent(event) {
+ 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;
+ }
+ }
+ },
+ ReactNativeBridgeEventPlugin = {
+ eventTypes: ReactNativeViewConfigRegistry.eventTypes,
+ extractEvents: function extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+ if (null == targetInst) return null;
+ var bubbleDispatchConfig = ReactNativeViewConfigRegistry.customBubblingEventTypes[topLevelType],
+ directDispatchConfig = ReactNativeViewConfigRegistry.customDirectEventTypes[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;
+ }
+
+ getFiberCurrentPropsFromNode = function getFiberCurrentPropsFromNode(inst) {
+ return inst.canonical.currentProps;
+ };
+
+ getInstanceFromNode = getInstanceFromInstance;
+
+ getNodeFromInstance = function getNodeFromInstance(inst) {
+ inst = inst.stateNode.canonical._nativeTag;
+ invariant(inst, "All native instances should have a tag.");
+ return inst;
+ };
+
+ ResponderEventPlugin.injection.injectGlobalResponderHandler({
+ onChange: function onChange(from, to, blockNativeResponder) {
+ null !== to ? UIManager.setJSResponder(to.stateNode.canonical._nativeTag, blockNativeResponder) : UIManager.clearJSResponder();
+ }
+ });
+ var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+ ReactSharedInternals.hasOwnProperty("ReactCurrentDispatcher") || (ReactSharedInternals.ReactCurrentDispatcher = {
+ current: null
+ });
+ var hasSymbol = "function" === typeof Symbol && (typeof Symbol === "function" ? Symbol.for : "@@for"),
+ REACT_ELEMENT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.element") : 60103,
+ REACT_PORTAL_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.portal") : 60106,
+ REACT_FRAGMENT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.fragment") : 60107,
+ REACT_STRICT_MODE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.strict_mode") : 60108,
+ REACT_PROFILER_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.profiler") : 60114,
+ REACT_PROVIDER_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.provider") : 60109,
+ REACT_CONTEXT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.context") : 60110,
+ REACT_CONCURRENT_MODE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.concurrent_mode") : 60111,
+ REACT_FORWARD_REF_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.forward_ref") : 60112,
+ REACT_SUSPENSE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.suspense") : 60113,
+ REACT_MEMO_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.memo") : 60115,
+ REACT_LAZY_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.lazy") : 60116,
+ MAYBE_ITERATOR_SYMBOL = "function" === typeof Symbol && (typeof Symbol === "function" ? Symbol.iterator : "@@iterator");
+
+ function getIteratorFn(maybeIterable) {
+ if (null === maybeIterable || "object" !== typeof maybeIterable) return null;
+ maybeIterable = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable["@@iterator"];
+ return "function" === typeof maybeIterable ? maybeIterable : null;
+ }
+
+ function getComponentName(type) {
+ if (null == type) return null;
+ if ("function" === typeof type) return type.displayName || type.name || null;
+ if ("string" === typeof type) return type;
+
+ switch (type) {
+ case REACT_CONCURRENT_MODE_TYPE:
+ return "ConcurrentMode";
+
+ case REACT_FRAGMENT_TYPE:
+ return "Fragment";
+
+ case REACT_PORTAL_TYPE:
+ return "Portal";
+
+ case REACT_PROFILER_TYPE:
+ return "Profiler";
+
+ case REACT_STRICT_MODE_TYPE:
+ return "StrictMode";
+
+ case REACT_SUSPENSE_TYPE:
+ return "Suspense";
+ }
+
+ if ("object" === typeof type) switch (type.$$typeof) {
+ case REACT_CONTEXT_TYPE:
+ return "Context.Consumer";
+
+ case REACT_PROVIDER_TYPE:
+ return "Context.Provider";
+
+ case REACT_FORWARD_REF_TYPE:
+ var innerType = type.render;
+ innerType = innerType.displayName || innerType.name || "";
+ return type.displayName || ("" !== innerType ? "ForwardRef(" + innerType + ")" : "ForwardRef");
+
+ case REACT_MEMO_TYPE:
+ return getComponentName(type.type);
+
+ case REACT_LAZY_TYPE:
+ if (type = 1 === type._status ? type._result : null) return getComponentName(type);
+ }
+ return null;
+ }
+
+ function isFiberMountedImpl(fiber) {
+ var node = fiber;
+ if (fiber.alternate) for (; node.return;) {
+ node = node.return;
+ } else {
+ if (0 !== (node.effectTag & 2)) return 1;
+
+ for (; node.return;) {
+ if (node = node.return, 0 !== (node.effectTag & 2)) return 1;
+ }
+ }
+ return 3 === node.tag ? 2 : 3;
+ }
+
+ function assertIsMounted(fiber) {
+ 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 mountSafeCallback_NOT_REALLY_SAFE(context, callback) {
+ return function () {
+ if (callback && ("boolean" !== typeof context.__isMounted || context.__isMounted)) return callback.apply(context, arguments);
+ };
+ }
+
+ var emptyObject = {},
+ removedKeys = null,
+ removedKeyCount = 0;
+
+ function restoreDeletedValuesInNestedArray(updatePayload, node, validAttributes) {
+ if (Array.isArray(node)) for (var i = node.length; i-- && 0 < removedKeyCount;) {
+ restoreDeletedValuesInNestedArray(updatePayload, node[i], validAttributes);
+ } else if (node && 0 < removedKeyCount) for (i in removedKeys) {
+ if (removedKeys[i]) {
+ var nextProp = node[i];
+
+ if (void 0 !== nextProp) {
+ var attributeConfig = validAttributes[i];
+
+ if (attributeConfig) {
+ "function" === typeof nextProp && (nextProp = !0);
+ "undefined" === typeof nextProp && (nextProp = null);
+ if ("object" !== typeof attributeConfig) updatePayload[i] = nextProp;else if ("function" === typeof attributeConfig.diff || "function" === typeof attributeConfig.process) nextProp = "function" === typeof attributeConfig.process ? attributeConfig.process(nextProp) : nextProp, updatePayload[i] = nextProp;
+ removedKeys[i] = !1;
+ removedKeyCount--;
+ }
+ }
+ }
+ }
+ }
+
+ function diffNestedProperty(updatePayload, prevProp, nextProp, validAttributes) {
+ if (!updatePayload && prevProp === nextProp) return updatePayload;
+ if (!prevProp || !nextProp) return nextProp ? addNestedProperty(updatePayload, nextProp, validAttributes) : prevProp ? clearNestedProperty(updatePayload, prevProp, validAttributes) : updatePayload;
+ if (!Array.isArray(prevProp) && !Array.isArray(nextProp)) return diffProperties(updatePayload, prevProp, nextProp, validAttributes);
+
+ if (Array.isArray(prevProp) && Array.isArray(nextProp)) {
+ var minLength = prevProp.length < nextProp.length ? prevProp.length : nextProp.length,
+ i;
+
+ for (i = 0; i < minLength; i++) {
+ updatePayload = diffNestedProperty(updatePayload, prevProp[i], nextProp[i], validAttributes);
+ }
+
+ for (; i < prevProp.length; i++) {
+ updatePayload = clearNestedProperty(updatePayload, prevProp[i], validAttributes);
+ }
+
+ for (; i < nextProp.length; i++) {
+ updatePayload = addNestedProperty(updatePayload, nextProp[i], validAttributes);
+ }
+
+ return updatePayload;
+ }
+
+ return Array.isArray(prevProp) ? diffProperties(updatePayload, 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, nextProp, validAttributes);
+
+ for (var i = 0; i < nextProp.length; i++) {
+ updatePayload = addNestedProperty(updatePayload, nextProp[i], validAttributes);
+ }
+
+ return updatePayload;
+ }
+
+ function clearNestedProperty(updatePayload, prevProp, validAttributes) {
+ if (!prevProp) return updatePayload;
+ if (!Array.isArray(prevProp)) return diffProperties(updatePayload, prevProp, emptyObject, validAttributes);
+
+ for (var i = 0; i < prevProp.length; i++) {
+ updatePayload = clearNestedProperty(updatePayload, prevProp[i], validAttributes);
+ }
+
+ return updatePayload;
+ }
+
+ function diffProperties(updatePayload, prevProps, nextProps, validAttributes) {
+ var attributeConfig, propKey;
+
+ for (propKey in nextProps) {
+ if (attributeConfig = validAttributes[propKey]) {
+ var prevProp = prevProps[propKey];
+ var nextProp = nextProps[propKey];
+ "function" === typeof nextProp && (nextProp = !0, "function" === typeof prevProp && (prevProp = !0));
+ "undefined" === typeof nextProp && (nextProp = null, "undefined" === typeof prevProp && (prevProp = null));
+ removedKeys && (removedKeys[propKey] = !1);
+ if (updatePayload && void 0 !== updatePayload[propKey]) {
+ if ("object" !== typeof attributeConfig) updatePayload[propKey] = nextProp;else {
+ if ("function" === typeof attributeConfig.diff || "function" === typeof attributeConfig.process) attributeConfig = "function" === typeof attributeConfig.process ? attributeConfig.process(nextProp) : nextProp, updatePayload[propKey] = attributeConfig;
+ }
+ } else if (prevProp !== nextProp) if ("object" !== typeof attributeConfig) ("object" !== typeof nextProp || null === nextProp || 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;
+
+ function setTimeoutCallback() {
+ frameDeadline = now$1() + 5;
+ var callback = scheduledCallback;
+ scheduledCallback = null;
+ null !== callback && callback();
+ }
+
+ function scheduleDeferredCallback$1(callback) {
+ scheduledCallback = callback;
+ return setTimeout(setTimeoutCallback, 1);
+ }
+
+ var restoreTarget = null,
+ restoreQueue = null;
+
+ function restoreStateOfTarget(target) {
+ if (target = getInstanceFromNode(target)) {
+ invariant(!1, "setRestoreImplementation() needs to be called to handle a target for controlled events. This error is likely caused by a bug in React. Please file an issue.");
+ var props = getFiberCurrentPropsFromNode(target.stateNode);
+ null(target.stateNode, target.type, props);
+ }
+ }
+
+ function _batchedUpdatesImpl(fn, bookkeeping) {
+ return fn(bookkeeping);
+ }
+
+ function _flushInteractiveUpdatesImpl() {}
+
+ var isBatching = !1;
+
+ function batchedUpdates(fn, bookkeeping) {
+ if (isBatching) return fn(bookkeeping);
+ isBatching = !0;
+
+ try {
+ return _batchedUpdatesImpl(fn, bookkeeping);
+ } finally {
+ if (isBatching = !1, null !== restoreTarget || null !== restoreQueue) if (_flushInteractiveUpdatesImpl(), 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;
+ if (events && (forEachAccumulated(events, executeDispatchesAndReleaseTopLevel), invariant(!eventQueue, "processEventQueue(): Additional events were enqueued while processing an event queue. Support for this has not yet been implemented."), hasRethrowError)) throw events = rethrowError, hasRethrowError = !1, rethrowError = null, events;
+ });
+ }
+
+ function shim$1() {
+ invariant(!1, "The current renderer does not support hydration. 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_NOT_REALLY_SAFE(this, callback));
+ };
+
+ ReactFabricHostComponent.prototype.measureInWindow = function (callback) {
+ UIManager.measureInWindow(this._nativeTag, mountSafeCallback_NOT_REALLY_SAFE(this, callback));
+ };
+
+ ReactFabricHostComponent.prototype.measureLayout = function (relativeToNativeNode, onSuccess, onFail) {
+ UIManager.measureLayout(this._nativeTag, relativeToNativeNode, mountSafeCallback_NOT_REALLY_SAFE(this, onFail), mountSafeCallback_NOT_REALLY_SAFE(this, onSuccess));
+ };
+
+ ReactFabricHostComponent.prototype.setNativeProps = function (nativeProps) {
+ nativeProps = diffProperties(null, emptyObject, 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 component.");
+ hostContext = nextReactTag;
+ nextReactTag += 2;
+ return {
+ node: FabricUIManager.createNode(hostContext, "RCTRawText", rootContainerInstance, {
+ text: text
+ }, internalInstanceHandle)
+ };
+ }
+
+ var scheduleTimeout = setTimeout,
+ cancelTimeout = clearTimeout;
+
+ function cloneHiddenInstance(instance) {
+ var node = instance.node;
+ var updatePayload = diffProperties(null, emptyObject, {
+ style: {
+ display: "none"
+ }
+ }, instance.canonical.viewConfig.validAttributes);
+ return {
+ node: FabricUIManager.cloneNodeWithNewProps(node, updatePayload),
+ canonical: instance.canonical
+ };
+ }
+
+ function cloneUnhiddenInstance(instance, type, props) {
+ var viewConfig = instance.canonical.viewConfig;
+ type = instance.node;
+
+ var prevProps = _extends({}, props, {
+ style: [props.style, {
+ display: "none"
+ }]
+ });
+
+ props = diffProperties(null, prevProps, props, viewConfig.validAttributes);
+ return {
+ node: FabricUIManager.cloneNodeWithNewProps(type, props),
+ canonical: instance.canonical
+ };
+ }
+
+ var BEFORE_SLASH_RE = /^(.*)[\\\/]/;
+
+ function getStackByFiberInDevAndProd(workInProgress) {
+ var info = "";
+
+ do {
+ a: switch (workInProgress.tag) {
+ case 3:
+ case 4:
+ case 6:
+ case 7:
+ case 10:
+ case 9:
+ var JSCompiler_inline_result = "";
+ break a;
+
+ default:
+ var owner = workInProgress._debugOwner,
+ source = workInProgress._debugSource,
+ name = getComponentName(workInProgress.type);
+ JSCompiler_inline_result = null;
+ owner && (JSCompiler_inline_result = getComponentName(owner.type));
+ owner = name;
+ name = "";
+ source ? name = " (at " + source.fileName.replace(BEFORE_SLASH_RE, "") + ":" + source.lineNumber + ")" : JSCompiler_inline_result && (name = " (created by " + JSCompiler_inline_result + ")");
+ JSCompiler_inline_result = "\n in " + (owner || "Unknown") + name;
+ }
+
+ info += JSCompiler_inline_result;
+ workInProgress = workInProgress.return;
+ } while (workInProgress);
+
+ return info;
+ }
+
+ new Set();
+ var valueStack = [],
+ index = -1;
+
+ function pop(cursor) {
+ 0 > index || (cursor.current = valueStack[index], valueStack[index] = null, index--);
+ }
+
+ function push(cursor, value) {
+ index++;
+ valueStack[index] = cursor.current;
+ cursor.current = value;
+ }
+
+ var emptyContextObject = {},
+ contextStackCursor = {
+ current: emptyContextObject
+ },
+ didPerformWorkStackCursor = {
+ current: !1
+ },
+ previousContext = emptyContextObject;
+
+ function getMaskedContext(workInProgress, unmaskedContext) {
+ var contextTypes = workInProgress.type.contextTypes;
+ if (!contextTypes) return emptyContextObject;
+ var instance = workInProgress.stateNode;
+ if (instance && instance.__reactInternalMemoizedUnmaskedChildContext === unmaskedContext) return instance.__reactInternalMemoizedMaskedChildContext;
+ var context = {},
+ key;
+
+ for (key in contextTypes) {
+ context[key] = unmaskedContext[key];
+ }
+
+ instance && (workInProgress = workInProgress.stateNode, workInProgress.__reactInternalMemoizedUnmaskedChildContext = unmaskedContext, workInProgress.__reactInternalMemoizedMaskedChildContext = context);
+ return context;
+ }
+
+ function isContextProvider(type) {
+ type = type.childContextTypes;
+ return null !== type && void 0 !== type;
+ }
+
+ function popContext(fiber) {
+ pop(didPerformWorkStackCursor, fiber);
+ pop(contextStackCursor, fiber);
+ }
+
+ function popTopLevelContextObject(fiber) {
+ pop(didPerformWorkStackCursor, fiber);
+ pop(contextStackCursor, fiber);
+ }
+
+ function pushTopLevelContextObject(fiber, context, didChange) {
+ invariant(contextStackCursor.current === emptyContextObject, "Unexpected context found on stack. This error is likely caused by a bug in React. Please file an issue.");
+ push(contextStackCursor, context, fiber);
+ push(didPerformWorkStackCursor, didChange, fiber);
+ }
+
+ function processChildContext(fiber, type, parentContext) {
+ var instance = fiber.stateNode;
+ fiber = type.childContextTypes;
+ if ("function" !== typeof instance.getChildContext) return parentContext;
+ instance = instance.getChildContext();
+
+ for (var contextKey in instance) {
+ invariant(contextKey in fiber, '%s.getChildContext(): key "%s" is not defined in childContextTypes.', getComponentName(type) || "Unknown", contextKey);
+ }
+
+ return _extends({}, parentContext, instance);
+ }
+
+ function pushContextProvider(workInProgress) {
+ var instance = workInProgress.stateNode;
+ instance = instance && instance.__reactInternalMemoizedMergedChildContext || emptyContextObject;
+ previousContext = contextStackCursor.current;
+ push(contextStackCursor, instance, workInProgress);
+ push(didPerformWorkStackCursor, didPerformWorkStackCursor.current, workInProgress);
+ return !0;
+ }
+
+ function invalidateContextProvider(workInProgress, type, didChange) {
+ var instance = workInProgress.stateNode;
+ invariant(instance, "Expected to have an instance by this point. This error is likely caused by a bug in React. Please file an issue.");
+ didChange ? (type = processChildContext(workInProgress, type, previousContext), instance.__reactInternalMemoizedMergedChildContext = type, pop(didPerformWorkStackCursor, workInProgress), pop(contextStackCursor, workInProgress), push(contextStackCursor, type, workInProgress)) : pop(didPerformWorkStackCursor, workInProgress);
+ push(didPerformWorkStackCursor, didChange, workInProgress);
+ }
+
+ var 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 FiberNode(tag, pendingProps, key, mode) {
+ this.tag = tag;
+ this.key = key;
+ this.sibling = this.child = this.return = this.stateNode = this.type = this.elementType = null;
+ this.index = 0;
+ this.ref = null;
+ this.pendingProps = pendingProps;
+ this.contextDependencies = this.memoizedState = this.updateQueue = this.memoizedProps = null;
+ this.mode = mode;
+ this.effectTag = 0;
+ this.lastEffect = this.firstEffect = this.nextEffect = null;
+ this.childExpirationTime = this.expirationTime = 0;
+ this.alternate = null;
+ }
+
+ function createFiber(tag, pendingProps, key, mode) {
+ return new FiberNode(tag, pendingProps, key, mode);
+ }
+
+ function shouldConstruct(Component) {
+ Component = Component.prototype;
+ return !(!Component || !Component.isReactComponent);
+ }
+
+ function resolveLazyComponentTag(Component) {
+ if ("function" === typeof Component) return shouldConstruct(Component) ? 1 : 0;
+
+ if (void 0 !== Component && null !== Component) {
+ Component = Component.$$typeof;
+ if (Component === REACT_FORWARD_REF_TYPE) return 11;
+ if (Component === REACT_MEMO_TYPE) return 14;
+ }
+
+ return 2;
+ }
+
+ function createWorkInProgress(current, pendingProps) {
+ var workInProgress = current.alternate;
+ null === workInProgress ? (workInProgress = createFiber(current.tag, pendingProps, current.key, current.mode), workInProgress.elementType = current.elementType, workInProgress.type = current.type, workInProgress.stateNode = current.stateNode, workInProgress.alternate = current, current.alternate = workInProgress) : (workInProgress.pendingProps = pendingProps, workInProgress.effectTag = 0, workInProgress.nextEffect = null, workInProgress.firstEffect = null, workInProgress.lastEffect = null);
+ workInProgress.childExpirationTime = current.childExpirationTime;
+ workInProgress.expirationTime = current.expirationTime;
+ workInProgress.child = current.child;
+ workInProgress.memoizedProps = current.memoizedProps;
+ workInProgress.memoizedState = current.memoizedState;
+ workInProgress.updateQueue = current.updateQueue;
+ workInProgress.contextDependencies = current.contextDependencies;
+ workInProgress.sibling = current.sibling;
+ workInProgress.index = current.index;
+ workInProgress.ref = current.ref;
+ return workInProgress;
+ }
+
+ function createFiberFromTypeAndProps(type, key, pendingProps, owner, mode, expirationTime) {
+ var fiberTag = 2;
+ owner = type;
+ if ("function" === typeof type) shouldConstruct(type) && (fiberTag = 1);else if ("string" === typeof type) fiberTag = 5;else a: switch (type) {
+ case REACT_FRAGMENT_TYPE:
+ return createFiberFromFragment(pendingProps.children, mode, expirationTime, key);
+
+ case REACT_CONCURRENT_MODE_TYPE:
+ return createFiberFromMode(pendingProps, mode | 3, expirationTime, key);
+
+ case REACT_STRICT_MODE_TYPE:
+ return createFiberFromMode(pendingProps, mode | 2, expirationTime, key);
+
+ case REACT_PROFILER_TYPE:
+ return type = createFiber(12, pendingProps, key, mode | 4), type.elementType = REACT_PROFILER_TYPE, type.type = REACT_PROFILER_TYPE, type.expirationTime = expirationTime, type;
+
+ case REACT_SUSPENSE_TYPE:
+ return type = createFiber(13, pendingProps, key, mode), type.elementType = REACT_SUSPENSE_TYPE, type.type = REACT_SUSPENSE_TYPE, type.expirationTime = expirationTime, type;
+
+ default:
+ if ("object" === typeof type && null !== type) switch (type.$$typeof) {
+ case REACT_PROVIDER_TYPE:
+ fiberTag = 10;
+ break a;
+
+ case REACT_CONTEXT_TYPE:
+ fiberTag = 9;
+ break a;
+
+ case REACT_FORWARD_REF_TYPE:
+ fiberTag = 11;
+ break a;
+
+ case REACT_MEMO_TYPE:
+ fiberTag = 14;
+ break a;
+
+ case REACT_LAZY_TYPE:
+ fiberTag = 16;
+ owner = null;
+ break a;
+ }
+ 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, "");
+ }
+ key = createFiber(fiberTag, pendingProps, key, mode);
+ key.elementType = type;
+ key.type = owner;
+ key.expirationTime = expirationTime;
+ return key;
+ }
+
+ function createFiberFromFragment(elements, mode, expirationTime, key) {
+ elements = createFiber(7, elements, key, mode);
+ elements.expirationTime = expirationTime;
+ return elements;
+ }
+
+ function createFiberFromMode(pendingProps, mode, expirationTime, key) {
+ pendingProps = createFiber(8, pendingProps, key, mode);
+ mode = 0 === (mode & 1) ? REACT_STRICT_MODE_TYPE : REACT_CONCURRENT_MODE_TYPE;
+ pendingProps.elementType = mode;
+ pendingProps.type = mode;
+ pendingProps.expirationTime = expirationTime;
+ return pendingProps;
+ }
+
+ function createFiberFromText(content, mode, expirationTime) {
+ content = createFiber(6, content, null, mode);
+ content.expirationTime = expirationTime;
+ return content;
+ }
+
+ function createFiberFromPortal(portal, mode, expirationTime) {
+ mode = createFiber(4, null !== portal.children ? portal.children : [], portal.key, mode);
+ mode.expirationTime = expirationTime;
+ mode.stateNode = {
+ containerInfo: portal.containerInfo,
+ pendingChildren: null,
+ implementation: portal.implementation
+ };
+ return mode;
+ }
+
+ function 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);
+ findNextExpirationTimeToWorkOn(expirationTime, root);
+ }
+
+ function markCommittedPriorityLevels(root, earliestRemainingTime) {
+ root.didError = !1;
+ if (0 === earliestRemainingTime) root.earliestPendingTime = 0, root.latestPendingTime = 0, root.earliestSuspendedTime = 0, root.latestSuspendedTime = 0, root.latestPingedTime = 0;else {
+ earliestRemainingTime < root.latestPingedTime && (root.latestPingedTime = 0);
+ var latestPendingTime = root.latestPendingTime;
+ 0 !== latestPendingTime && (latestPendingTime > earliestRemainingTime ? root.earliestPendingTime = root.latestPendingTime = 0 : root.earliestPendingTime > earliestRemainingTime && (root.earliestPendingTime = root.latestPendingTime));
+ latestPendingTime = root.earliestSuspendedTime;
+ 0 === latestPendingTime ? markPendingPriorityLevel(root, earliestRemainingTime) : earliestRemainingTime < root.latestSuspendedTime ? (root.earliestSuspendedTime = 0, root.latestSuspendedTime = 0, root.latestPingedTime = 0, markPendingPriorityLevel(root, earliestRemainingTime)) : earliestRemainingTime > latestPendingTime && markPendingPriorityLevel(root, earliestRemainingTime);
+ }
+ findNextExpirationTimeToWorkOn(0, root);
+ }
+
+ function markSuspendedPriorityLevel(root, suspendedTime) {
+ root.didError = !1;
+ root.latestPingedTime >= suspendedTime && (root.latestPingedTime = 0);
+ var earliestPendingTime = root.earliestPendingTime,
+ latestPendingTime = root.latestPendingTime;
+ earliestPendingTime === suspendedTime ? root.earliestPendingTime = latestPendingTime === suspendedTime ? root.latestPendingTime = 0 : latestPendingTime : latestPendingTime === suspendedTime && (root.latestPendingTime = earliestPendingTime);
+ earliestPendingTime = root.earliestSuspendedTime;
+ latestPendingTime = root.latestSuspendedTime;
+ 0 === earliestPendingTime ? root.earliestSuspendedTime = root.latestSuspendedTime = suspendedTime : earliestPendingTime < suspendedTime ? root.earliestSuspendedTime = suspendedTime : latestPendingTime > suspendedTime && (root.latestSuspendedTime = suspendedTime);
+ findNextExpirationTimeToWorkOn(suspendedTime, root);
+ }
+
+ function findEarliestOutstandingPriorityLevel(root, renderExpirationTime) {
+ var earliestPendingTime = root.earliestPendingTime;
+ root = root.earliestSuspendedTime;
+ earliestPendingTime > renderExpirationTime && (renderExpirationTime = earliestPendingTime);
+ root > renderExpirationTime && (renderExpirationTime = root);
+ return renderExpirationTime;
+ }
+
+ function findNextExpirationTimeToWorkOn(completedExpirationTime, root) {
+ var earliestSuspendedTime = root.earliestSuspendedTime,
+ latestSuspendedTime = root.latestSuspendedTime,
+ earliestPendingTime = root.earliestPendingTime,
+ latestPingedTime = root.latestPingedTime;
+ earliestPendingTime = 0 !== earliestPendingTime ? earliestPendingTime : latestPingedTime;
+ 0 === earliestPendingTime && (0 === completedExpirationTime || latestSuspendedTime < completedExpirationTime) && (earliestPendingTime = latestSuspendedTime);
+ completedExpirationTime = earliestPendingTime;
+ 0 !== completedExpirationTime && earliestSuspendedTime > completedExpirationTime && (completedExpirationTime = earliestSuspendedTime);
+ root.nextExpirationTimeToWorkOn = earliestPendingTime;
+ root.expirationTime = completedExpirationTime;
+ }
+
+ function is(x, y) {
+ return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
+ }
+
+ var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+ function shallowEqual(objA, objB) {
+ if (is(objA, objB)) return !0;
+ if ("object" !== typeof objA || null === objA || "object" !== typeof objB || null === objB) return !1;
+ var keysA = Object.keys(objA),
+ keysB = Object.keys(objB);
+ if (keysA.length !== keysB.length) return !1;
+
+ for (keysB = 0; keysB < keysA.length; keysB++) {
+ if (!hasOwnProperty.call(objB, keysA[keysB]) || !is(objA[keysA[keysB]], objB[keysA[keysB]])) return !1;
+ }
+
+ return !0;
+ }
+
+ function resolveDefaultProps(Component, baseProps) {
+ if (Component && Component.defaultProps) {
+ baseProps = _extends({}, baseProps);
+ Component = Component.defaultProps;
+
+ for (var propName in Component) {
+ void 0 === baseProps[propName] && (baseProps[propName] = Component[propName]);
+ }
+ }
+
+ return baseProps;
+ }
+
+ function readLazyComponentType(lazyComponent) {
+ var result = lazyComponent._result;
+
+ switch (lazyComponent._status) {
+ case 1:
+ return result;
+
+ case 2:
+ throw result;
+
+ case 0:
+ throw result;
+
+ default:
+ lazyComponent._status = 0;
+ result = lazyComponent._ctor;
+ result = result();
+ result.then(function (moduleObject) {
+ 0 === lazyComponent._status && (moduleObject = moduleObject.default, lazyComponent._status = 1, lazyComponent._result = moduleObject);
+ }, function (error) {
+ 0 === lazyComponent._status && (lazyComponent._status = 2, lazyComponent._result = error);
+ });
+
+ switch (lazyComponent._status) {
+ case 1:
+ return lazyComponent._result;
+
+ case 2:
+ throw lazyComponent._result;
+ }
+
+ lazyComponent._result = result;
+ throw result;
+ }
+ }
+
+ var emptyRefsObject = new React.Component().refs;
+
+ function applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, nextProps) {
+ ctor = workInProgress.memoizedState;
+ getDerivedStateFromProps = getDerivedStateFromProps(nextProps, ctor);
+ getDerivedStateFromProps = null === getDerivedStateFromProps || void 0 === getDerivedStateFromProps ? ctor : _extends({}, ctor, getDerivedStateFromProps);
+ workInProgress.memoizedState = getDerivedStateFromProps;
+ nextProps = workInProgress.updateQueue;
+ null !== nextProps && 0 === workInProgress.expirationTime && (nextProps.baseState = getDerivedStateFromProps);
+ }
+
+ var classComponentUpdater = {
+ isMounted: function isMounted(component) {
+ return (component = component._reactInternalFiber) ? 2 === isFiberMountedImpl(component) : !1;
+ },
+ enqueueSetState: function enqueueSetState(inst, payload, callback) {
+ inst = inst._reactInternalFiber;
+ var currentTime = requestCurrentTime();
+ currentTime = computeExpirationForFiber(currentTime, inst);
+ var update = createUpdate(currentTime);
+ update.payload = payload;
+ void 0 !== callback && null !== callback && (update.callback = callback);
+ flushPassiveEffects();
+ enqueueUpdate(inst, update);
+ scheduleWork(inst, currentTime);
+ },
+ enqueueReplaceState: function enqueueReplaceState(inst, payload, callback) {
+ inst = inst._reactInternalFiber;
+ var currentTime = requestCurrentTime();
+ currentTime = computeExpirationForFiber(currentTime, inst);
+ var update = createUpdate(currentTime);
+ update.tag = ReplaceState;
+ update.payload = payload;
+ void 0 !== callback && null !== callback && (update.callback = callback);
+ flushPassiveEffects();
+ enqueueUpdate(inst, update);
+ scheduleWork(inst, currentTime);
+ },
+ enqueueForceUpdate: function enqueueForceUpdate(inst, callback) {
+ inst = inst._reactInternalFiber;
+ var currentTime = requestCurrentTime();
+ currentTime = computeExpirationForFiber(currentTime, inst);
+ var update = createUpdate(currentTime);
+ update.tag = ForceUpdate;
+ void 0 !== callback && null !== callback && (update.callback = callback);
+ flushPassiveEffects();
+ enqueueUpdate(inst, update);
+ scheduleWork(inst, currentTime);
+ }
+ };
+
+ function checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext) {
+ workInProgress = workInProgress.stateNode;
+ return "function" === typeof workInProgress.shouldComponentUpdate ? workInProgress.shouldComponentUpdate(newProps, newState, nextContext) : ctor.prototype && ctor.prototype.isPureReactComponent ? !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState) : !0;
+ }
+
+ function constructClassInstance(workInProgress, ctor, props) {
+ var isLegacyContextConsumer = !1,
+ unmaskedContext = emptyContextObject;
+ var context = ctor.contextType;
+ "object" === typeof context && null !== context ? context = readContext(context) : (unmaskedContext = isContextProvider(ctor) ? previousContext : contextStackCursor.current, isLegacyContextConsumer = ctor.contextTypes, context = (isLegacyContextConsumer = null !== isLegacyContextConsumer && void 0 !== isLegacyContextConsumer) ? getMaskedContext(workInProgress, unmaskedContext) : emptyContextObject);
+ ctor = new ctor(props, context);
+ workInProgress.memoizedState = null !== ctor.state && void 0 !== ctor.state ? ctor.state : null;
+ ctor.updater = classComponentUpdater;
+ workInProgress.stateNode = ctor;
+ ctor._reactInternalFiber = workInProgress;
+ isLegacyContextConsumer && (workInProgress = workInProgress.stateNode, workInProgress.__reactInternalMemoizedUnmaskedChildContext = unmaskedContext, workInProgress.__reactInternalMemoizedMaskedChildContext = context);
+ return ctor;
+ }
+
+ function callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext) {
+ workInProgress = instance.state;
+ "function" === typeof instance.componentWillReceiveProps && instance.componentWillReceiveProps(newProps, nextContext);
+ "function" === typeof instance.UNSAFE_componentWillReceiveProps && instance.UNSAFE_componentWillReceiveProps(newProps, nextContext);
+ instance.state !== workInProgress && classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
+ }
+
+ function mountClassInstance(workInProgress, ctor, newProps, renderExpirationTime) {
+ var instance = workInProgress.stateNode;
+ instance.props = newProps;
+ instance.state = workInProgress.memoizedState;
+ instance.refs = emptyRefsObject;
+ var contextType = ctor.contextType;
+ "object" === typeof contextType && null !== contextType ? instance.context = readContext(contextType) : (contextType = isContextProvider(ctor) ? previousContext : contextStackCursor.current, instance.context = getMaskedContext(workInProgress, contextType));
+ contextType = workInProgress.updateQueue;
+ null !== contextType && (processUpdateQueue(workInProgress, contextType, newProps, instance, renderExpirationTime), instance.state = workInProgress.memoizedState);
+ contextType = ctor.getDerivedStateFromProps;
+ "function" === typeof contextType && (applyDerivedStateFromProps(workInProgress, ctor, contextType, newProps), instance.state = workInProgress.memoizedState);
+ "function" === typeof ctor.getDerivedStateFromProps || "function" === typeof instance.getSnapshotBeforeUpdate || "function" !== typeof instance.UNSAFE_componentWillMount && "function" !== typeof instance.componentWillMount || (ctor = instance.state, "function" === typeof instance.componentWillMount && instance.componentWillMount(), "function" === typeof instance.UNSAFE_componentWillMount && instance.UNSAFE_componentWillMount(), ctor !== instance.state && classComponentUpdater.enqueueReplaceState(instance, instance.state, null), contextType = workInProgress.updateQueue, null !== contextType && (processUpdateQueue(workInProgress, contextType, newProps, instance, renderExpirationTime), instance.state = workInProgress.memoizedState));
+ "function" === typeof instance.componentDidMount && (workInProgress.effectTag |= 4);
+ }
+
+ var isArray = Array.isArray;
+
+ function coerceRef(returnFiber, current$$1, element) {
+ returnFiber = element.ref;
+
+ if (null !== returnFiber && "function" !== typeof returnFiber && "object" !== typeof returnFiber) {
+ if (element._owner) {
+ element = element._owner;
+ var inst = void 0;
+ element && (invariant(1 === element.tag, "Function components cannot have refs. Did you mean to use React.forwardRef()?"), 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$$1 && null !== current$$1.ref && "function" === typeof current$$1.ref && current$$1.ref._stringRef === stringRef) return current$$1.ref;
+
+ current$$1 = function current$$1(value) {
+ var refs = inst.refs;
+ refs === emptyRefsObject && (refs = inst.refs = {});
+ null === value ? delete refs[stringRef] : refs[stringRef] = value;
+ };
+
+ current$$1._stringRef = stringRef;
+ return current$$1;
+ }
+
+ invariant("string" === typeof returnFiber, "Expected ref to be a function, a string, an object returned by React.createRef(), or null.");
+ 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 function component\n2. You may be adding a ref to a component that was not created inside a component's render method\n3. You have multiple copies of React loaded\nSee https://fb.me/react-refs-must-have-owner for more information.", 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$$1, textContent, expirationTime) {
+ if (null === current$$1 || 6 !== current$$1.tag) return current$$1 = createFiberFromText(textContent, returnFiber.mode, expirationTime), current$$1.return = returnFiber, current$$1;
+ current$$1 = useFiber(current$$1, textContent, expirationTime);
+ current$$1.return = returnFiber;
+ return current$$1;
+ }
+
+ function updateElement(returnFiber, current$$1, element, expirationTime) {
+ if (null !== current$$1 && current$$1.elementType === element.type) return expirationTime = useFiber(current$$1, element.props, expirationTime), expirationTime.ref = coerceRef(returnFiber, current$$1, element), expirationTime.return = returnFiber, expirationTime;
+ expirationTime = createFiberFromTypeAndProps(element.type, element.key, element.props, null, returnFiber.mode, expirationTime);
+ expirationTime.ref = coerceRef(returnFiber, current$$1, element);
+ expirationTime.return = returnFiber;
+ return expirationTime;
+ }
+
+ function updatePortal(returnFiber, current$$1, portal, expirationTime) {
+ if (null === current$$1 || 4 !== current$$1.tag || current$$1.stateNode.containerInfo !== portal.containerInfo || current$$1.stateNode.implementation !== portal.implementation) return current$$1 = createFiberFromPortal(portal, returnFiber.mode, expirationTime), current$$1.return = returnFiber, current$$1;
+ current$$1 = useFiber(current$$1, portal.children || [], expirationTime);
+ current$$1.return = returnFiber;
+ return current$$1;
+ }
+
+ function updateFragment(returnFiber, current$$1, fragment, expirationTime, key) {
+ if (null === current$$1 || 7 !== current$$1.tag) return current$$1 = createFiberFromFragment(fragment, returnFiber.mode, expirationTime, key), current$$1.return = returnFiber, current$$1;
+ current$$1 = useFiber(current$$1, fragment, expirationTime);
+ current$$1.return = returnFiber;
+ return current$$1;
+ }
+
+ function createChild(returnFiber, newChild, expirationTime) {
+ if ("string" === typeof newChild || "number" === typeof newChild) return newChild = createFiberFromText("" + newChild, returnFiber.mode, expirationTime), newChild.return = returnFiber, newChild;
+
+ if ("object" === typeof newChild && null !== newChild) {
+ switch (newChild.$$typeof) {
+ case REACT_ELEMENT_TYPE:
+ return expirationTime = createFiberFromTypeAndProps(newChild.type, newChild.key, newChild.props, null, returnFiber.mode, expirationTime), expirationTime.ref = coerceRef(returnFiber, null, newChild), expirationTime.return = returnFiber, expirationTime;
+
+ case REACT_PORTAL_TYPE:
+ return newChild = createFiberFromPortal(newChild, returnFiber.mode, expirationTime), newChild.return = returnFiber, newChild;
+ }
+
+ if (isArray(newChild) || getIteratorFn(newChild)) return newChild = createFiberFromFragment(newChild, returnFiber.mode, expirationTime, null), newChild.return = returnFiber, newChild;
+ throwOnInvalidObjectType(returnFiber, newChild);
+ }
+
+ return null;
+ }
+
+ function updateSlot(returnFiber, oldFiber, newChild, expirationTime) {
+ var key = null !== oldFiber ? oldFiber.key : null;
+ if ("string" === typeof newChild || "number" === typeof newChild) return null !== key ? null : updateTextNode(returnFiber, oldFiber, "" + newChild, expirationTime);
+
+ if ("object" === typeof newChild && null !== newChild) {
+ switch (newChild.$$typeof) {
+ case REACT_ELEMENT_TYPE:
+ return newChild.key === key ? newChild.type === REACT_FRAGMENT_TYPE ? updateFragment(returnFiber, oldFiber, newChild.props.children, expirationTime, key) : updateElement(returnFiber, oldFiber, newChild, expirationTime) : null;
+
+ case REACT_PORTAL_TYPE:
+ return newChild.key === key ? updatePortal(returnFiber, oldFiber, newChild, expirationTime) : null;
+ }
+
+ if (isArray(newChild) || getIteratorFn(newChild)) return null !== key ? null : updateFragment(returnFiber, oldFiber, newChild, expirationTime, null);
+ throwOnInvalidObjectType(returnFiber, newChild);
+ }
+
+ return null;
+ }
+
+ function updateFromMap(existingChildren, returnFiber, newIdx, newChild, expirationTime) {
+ if ("string" === typeof newChild || "number" === typeof newChild) return existingChildren = existingChildren.get(newIdx) || null, updateTextNode(returnFiber, existingChildren, "" + newChild, expirationTime);
+
+ if ("object" === typeof newChild && null !== newChild) {
+ switch (newChild.$$typeof) {
+ case REACT_ELEMENT_TYPE:
+ return existingChildren = existingChildren.get(null === newChild.key ? newIdx : newChild.key) || null, newChild.type === REACT_FRAGMENT_TYPE ? updateFragment(returnFiber, existingChildren, newChild.props.children, expirationTime, newChild.key) : updateElement(returnFiber, existingChildren, newChild, expirationTime);
+
+ case REACT_PORTAL_TYPE:
+ return existingChildren = existingChildren.get(null === newChild.key ? newIdx : newChild.key) || null, updatePortal(returnFiber, existingChildren, newChild, expirationTime);
+ }
+
+ if (isArray(newChild) || getIteratorFn(newChild)) return existingChildren = existingChildren.get(newIdx) || null, updateFragment(returnFiber, existingChildren, newChild, expirationTime, null);
+ throwOnInvalidObjectType(returnFiber, newChild);
+ }
+
+ return null;
+ }
+
+ function reconcileChildrenArray(returnFiber, currentFirstChild, newChildren, expirationTime) {
+ for (var resultingFirstChild = null, previousNewFiber = null, oldFiber = currentFirstChild, newIdx = currentFirstChild = 0, nextOldFiber = null; null !== oldFiber && newIdx < newChildren.length; newIdx++) {
+ oldFiber.index > newIdx ? (nextOldFiber = oldFiber, oldFiber = null) : nextOldFiber = oldFiber.sibling;
+ var newFiber = updateSlot(returnFiber, oldFiber, newChildren[newIdx], expirationTime);
+
+ if (null === newFiber) {
+ null === oldFiber && (oldFiber = nextOldFiber);
+ break;
+ }
+
+ shouldTrackSideEffects && oldFiber && null === newFiber.alternate && deleteChild(returnFiber, oldFiber);
+ currentFirstChild = placeChild(newFiber, currentFirstChild, newIdx);
+ null === previousNewFiber ? resultingFirstChild = newFiber : previousNewFiber.sibling = newFiber;
+ previousNewFiber = newFiber;
+ oldFiber = nextOldFiber;
+ }
+
+ if (newIdx === newChildren.length) return deleteRemainingChildren(returnFiber, oldFiber), resultingFirstChild;
+
+ if (null === oldFiber) {
+ for (; newIdx < newChildren.length; newIdx++) {
+ 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 (7 === isUnkeyedTopLevelFragment.tag ? newChild.type === REACT_FRAGMENT_TYPE : isUnkeyedTopLevelFragment.elementType === newChild.type) {
+ deleteRemainingChildren(returnFiber, isUnkeyedTopLevelFragment.sibling);
+ currentFirstChild = useFiber(isUnkeyedTopLevelFragment, newChild.type === REACT_FRAGMENT_TYPE ? newChild.props.children : newChild.props, expirationTime);
+ currentFirstChild.ref = coerceRef(returnFiber, isUnkeyedTopLevelFragment, newChild);
+ currentFirstChild.return = returnFiber;
+ returnFiber = currentFirstChild;
+ break a;
+ } 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 = createFiberFromTypeAndProps(newChild.type, newChild.key, newChild.props, null, returnFiber.mode, expirationTime), expirationTime.ref = coerceRef(returnFiber, currentFirstChild, newChild), expirationTime.return = returnFiber, returnFiber = expirationTime);
+ }
+
+ return placeSingleChild(returnFiber);
+
+ case REACT_PORTAL_TYPE:
+ a: {
+ for (isUnkeyedTopLevelFragment = newChild.key; null !== currentFirstChild;) {
+ if (currentFirstChild.key === isUnkeyedTopLevelFragment) {
+ if (4 === currentFirstChild.tag && currentFirstChild.stateNode.containerInfo === newChild.containerInfo && currentFirstChild.stateNode.implementation === newChild.implementation) {
+ deleteRemainingChildren(returnFiber, currentFirstChild.sibling);
+ currentFirstChild = useFiber(currentFirstChild, newChild.children || [], expirationTime);
+ currentFirstChild.return = returnFiber;
+ returnFiber = currentFirstChild;
+ break a;
+ } 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(newChild)) return reconcileChildrenArray(returnFiber, currentFirstChild, newChild, expirationTime);
+ if (getIteratorFn(newChild)) return reconcileChildrenIterator(returnFiber, currentFirstChild, newChild, expirationTime);
+ isObject && throwOnInvalidObjectType(returnFiber, newChild);
+ if ("undefined" === typeof newChild && !isUnkeyedTopLevelFragment) switch (returnFiber.tag) {
+ case 1:
+ case 0:
+ 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),
+ NO_CONTEXT = {},
+ contextStackCursor$1 = {
+ current: NO_CONTEXT
+ },
+ contextFiberStackCursor = {
+ current: NO_CONTEXT
+ },
+ rootInstanceStackCursor = {
+ current: 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 pushHostContext(fiber) {
+ requiredContext(rootInstanceStackCursor.current);
+ var context = requiredContext(contextStackCursor$1.current);
+ var nextContext = fiber.type;
+ nextContext = "AndroidTextInput" === nextContext || "RCTMultilineTextInputView" === nextContext || "RCTSinglelineTextInputView" === nextContext || "RCTText" === nextContext || "RCTVirtualText" === nextContext;
+ nextContext = context.isInAParentText !== nextContext ? {
+ isInAParentText: nextContext
+ } : context;
+ context !== nextContext && (push(contextFiberStackCursor, fiber, fiber), push(contextStackCursor$1, nextContext, fiber));
+ }
+
+ function popHostContext(fiber) {
+ contextFiberStackCursor.current === fiber && (pop(contextStackCursor$1, fiber), pop(contextFiberStackCursor, fiber));
+ }
+
+ var NoEffect$1 = 0,
+ UnmountSnapshot = 2,
+ UnmountMutation = 4,
+ MountMutation = 8,
+ UnmountLayout = 16,
+ MountLayout = 32,
+ MountPassive = 64,
+ UnmountPassive = 128,
+ ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher,
+ renderExpirationTime = 0,
+ currentlyRenderingFiber$1 = null,
+ currentHook = null,
+ nextCurrentHook = null,
+ firstWorkInProgressHook = null,
+ workInProgressHook = null,
+ nextWorkInProgressHook = null,
+ remainingExpirationTime = 0,
+ componentUpdateQueue = null,
+ sideEffectTag = 0,
+ didScheduleRenderPhaseUpdate = !1,
+ renderPhaseUpdates = null,
+ numberOfReRenders = 0;
+
+ function throwInvalidHookError() {
+ invariant(!1, "Hooks can only be called inside the body of a function component. (https://fb.me/react-invalid-hook-call)");
+ }
+
+ function areHookInputsEqual(nextDeps, prevDeps) {
+ if (null === prevDeps) return !1;
+
+ for (var i = 0; i < prevDeps.length && i < nextDeps.length; i++) {
+ if (!is(nextDeps[i], prevDeps[i])) return !1;
+ }
+
+ return !0;
+ }
+
+ function renderWithHooks(current, workInProgress, Component, props, refOrContext, nextRenderExpirationTime) {
+ renderExpirationTime = nextRenderExpirationTime;
+ currentlyRenderingFiber$1 = workInProgress;
+ nextCurrentHook = null !== current ? current.memoizedState : null;
+ ReactCurrentDispatcher$1.current = null === nextCurrentHook ? HooksDispatcherOnMount : HooksDispatcherOnUpdate;
+ workInProgress = Component(props, refOrContext);
+
+ if (didScheduleRenderPhaseUpdate) {
+ do {
+ didScheduleRenderPhaseUpdate = !1, numberOfReRenders += 1, nextCurrentHook = null !== current ? current.memoizedState : null, nextWorkInProgressHook = firstWorkInProgressHook, componentUpdateQueue = workInProgressHook = currentHook = null, ReactCurrentDispatcher$1.current = HooksDispatcherOnUpdate, workInProgress = Component(props, refOrContext);
+ } while (didScheduleRenderPhaseUpdate);
+
+ renderPhaseUpdates = null;
+ numberOfReRenders = 0;
+ }
+
+ ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
+ current = currentlyRenderingFiber$1;
+ current.memoizedState = firstWorkInProgressHook;
+ current.expirationTime = remainingExpirationTime;
+ current.updateQueue = componentUpdateQueue;
+ current.effectTag |= sideEffectTag;
+ current = null !== currentHook && null !== currentHook.next;
+ renderExpirationTime = 0;
+ nextWorkInProgressHook = workInProgressHook = firstWorkInProgressHook = nextCurrentHook = currentHook = currentlyRenderingFiber$1 = null;
+ remainingExpirationTime = 0;
+ componentUpdateQueue = null;
+ sideEffectTag = 0;
+ invariant(!current, "Rendered fewer hooks than expected. This may be caused by an accidental early return statement.");
+ return workInProgress;
+ }
+
+ function resetHooks() {
+ ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
+ renderExpirationTime = 0;
+ nextWorkInProgressHook = workInProgressHook = firstWorkInProgressHook = nextCurrentHook = currentHook = currentlyRenderingFiber$1 = null;
+ remainingExpirationTime = 0;
+ componentUpdateQueue = null;
+ sideEffectTag = 0;
+ didScheduleRenderPhaseUpdate = !1;
+ renderPhaseUpdates = null;
+ numberOfReRenders = 0;
+ }
+
+ function mountWorkInProgressHook() {
+ var hook = {
+ memoizedState: null,
+ baseState: null,
+ queue: null,
+ baseUpdate: null,
+ next: null
+ };
+ null === workInProgressHook ? firstWorkInProgressHook = workInProgressHook = hook : workInProgressHook = workInProgressHook.next = hook;
+ return workInProgressHook;
+ }
+
+ function updateWorkInProgressHook() {
+ if (null !== nextWorkInProgressHook) workInProgressHook = nextWorkInProgressHook, nextWorkInProgressHook = workInProgressHook.next, currentHook = nextCurrentHook, nextCurrentHook = null !== currentHook ? currentHook.next : null;else {
+ invariant(null !== nextCurrentHook, "Rendered more hooks than during the previous render.");
+ currentHook = nextCurrentHook;
+ var newHook = {
+ memoizedState: currentHook.memoizedState,
+ baseState: currentHook.baseState,
+ queue: currentHook.queue,
+ baseUpdate: currentHook.baseUpdate,
+ next: null
+ };
+ workInProgressHook = null === workInProgressHook ? firstWorkInProgressHook = newHook : workInProgressHook.next = newHook;
+ nextCurrentHook = currentHook.next;
+ }
+ return workInProgressHook;
+ }
+
+ function basicStateReducer(state, action) {
+ return "function" === typeof action ? action(state) : action;
+ }
+
+ function updateReducer(reducer) {
+ var hook = updateWorkInProgressHook(),
+ queue = hook.queue;
+ invariant(null !== queue, "Should have a queue. This is likely a bug in React. Please file an issue.");
+
+ if (0 < numberOfReRenders) {
+ var _dispatch = queue.dispatch;
+
+ if (null !== renderPhaseUpdates) {
+ var firstRenderPhaseUpdate = renderPhaseUpdates.get(queue);
+
+ if (void 0 !== firstRenderPhaseUpdate) {
+ renderPhaseUpdates.delete(queue);
+ var newState = hook.memoizedState;
+
+ do {
+ newState = reducer(newState, firstRenderPhaseUpdate.action), firstRenderPhaseUpdate = firstRenderPhaseUpdate.next;
+ } while (null !== firstRenderPhaseUpdate);
+
+ is(newState, hook.memoizedState) || (didReceiveUpdate = !0);
+ hook.memoizedState = newState;
+ hook.baseUpdate === queue.last && (hook.baseState = newState);
+ queue.eagerReducer = reducer;
+ queue.eagerState = newState;
+ return [newState, _dispatch];
+ }
+ }
+
+ return [hook.memoizedState, _dispatch];
+ }
+
+ _dispatch = queue.last;
+ var baseUpdate = hook.baseUpdate;
+ newState = hook.baseState;
+ null !== baseUpdate ? (null !== _dispatch && (_dispatch.next = null), _dispatch = baseUpdate.next) : _dispatch = null !== _dispatch ? _dispatch.next : null;
+
+ if (null !== _dispatch) {
+ var newBaseUpdate = firstRenderPhaseUpdate = null,
+ _update = _dispatch,
+ didSkip = !1;
+
+ do {
+ var updateExpirationTime = _update.expirationTime;
+ updateExpirationTime < renderExpirationTime ? (didSkip || (didSkip = !0, newBaseUpdate = baseUpdate, firstRenderPhaseUpdate = newState), updateExpirationTime > remainingExpirationTime && (remainingExpirationTime = updateExpirationTime)) : newState = _update.eagerReducer === reducer ? _update.eagerState : reducer(newState, _update.action);
+ baseUpdate = _update;
+ _update = _update.next;
+ } while (null !== _update && _update !== _dispatch);
+
+ didSkip || (newBaseUpdate = baseUpdate, firstRenderPhaseUpdate = newState);
+ is(newState, hook.memoizedState) || (didReceiveUpdate = !0);
+ hook.memoizedState = newState;
+ hook.baseUpdate = newBaseUpdate;
+ hook.baseState = firstRenderPhaseUpdate;
+ queue.eagerReducer = reducer;
+ queue.eagerState = newState;
+ }
+
+ return [hook.memoizedState, queue.dispatch];
+ }
+
+ function pushEffect(tag, create, destroy, deps) {
+ tag = {
+ tag: tag,
+ create: create,
+ destroy: destroy,
+ deps: deps,
+ next: null
+ };
+ null === componentUpdateQueue ? (componentUpdateQueue = {
+ lastEffect: null
+ }, componentUpdateQueue.lastEffect = tag.next = tag) : (create = componentUpdateQueue.lastEffect, null === create ? componentUpdateQueue.lastEffect = tag.next = tag : (destroy = create.next, create.next = tag, tag.next = destroy, componentUpdateQueue.lastEffect = tag));
+ return tag;
+ }
+
+ function mountEffectImpl(fiberEffectTag, hookEffectTag, create, deps) {
+ var hook = mountWorkInProgressHook();
+ sideEffectTag |= fiberEffectTag;
+ hook.memoizedState = pushEffect(hookEffectTag, create, void 0, void 0 === deps ? null : deps);
+ }
+
+ function updateEffectImpl(fiberEffectTag, hookEffectTag, create, deps) {
+ var hook = updateWorkInProgressHook();
+ deps = void 0 === deps ? null : deps;
+ var destroy = void 0;
+
+ if (null !== currentHook) {
+ var prevEffect = currentHook.memoizedState;
+ destroy = prevEffect.destroy;
+
+ if (null !== deps && areHookInputsEqual(deps, prevEffect.deps)) {
+ pushEffect(NoEffect$1, create, destroy, deps);
+ return;
+ }
+ }
+
+ sideEffectTag |= fiberEffectTag;
+ hook.memoizedState = pushEffect(hookEffectTag, create, destroy, deps);
+ }
+
+ function imperativeHandleEffect(create, ref) {
+ if ("function" === typeof ref) return create = create(), ref(create), function () {
+ ref(null);
+ };
+ if (null !== ref && void 0 !== ref) return create = create(), ref.current = create, function () {
+ ref.current = null;
+ };
+ }
+
+ function mountDebugValue() {}
+
+ function dispatchAction(fiber, queue, action) {
+ invariant(25 > numberOfReRenders, "Too many re-renders. React limits the number of renders to prevent an infinite loop.");
+ var alternate = fiber.alternate;
+ if (fiber === currentlyRenderingFiber$1 || null !== alternate && alternate === currentlyRenderingFiber$1) {
+ if (didScheduleRenderPhaseUpdate = !0, fiber = {
+ expirationTime: renderExpirationTime,
+ action: action,
+ eagerReducer: null,
+ eagerState: null,
+ next: null
+ }, null === renderPhaseUpdates && (renderPhaseUpdates = new Map()), action = renderPhaseUpdates.get(queue), void 0 === action) renderPhaseUpdates.set(queue, fiber);else {
+ for (queue = action; null !== queue.next;) {
+ queue = queue.next;
+ }
+
+ queue.next = fiber;
+ }
+ } else {
+ flushPassiveEffects();
+ var currentTime = requestCurrentTime();
+ currentTime = computeExpirationForFiber(currentTime, fiber);
+ var _update2 = {
+ expirationTime: currentTime,
+ action: action,
+ eagerReducer: null,
+ eagerState: null,
+ next: null
+ },
+ _last = queue.last;
+ if (null === _last) _update2.next = _update2;else {
+ var first = _last.next;
+ null !== first && (_update2.next = first);
+ _last.next = _update2;
+ }
+ queue.last = _update2;
+ if (0 === fiber.expirationTime && (null === alternate || 0 === alternate.expirationTime) && (alternate = queue.eagerReducer, null !== alternate)) try {
+ var currentState = queue.eagerState,
+ _eagerState = alternate(currentState, action);
+
+ _update2.eagerReducer = alternate;
+ _update2.eagerState = _eagerState;
+ if (is(_eagerState, currentState)) return;
+ } catch (error) {} finally {}
+ scheduleWork(fiber, currentTime);
+ }
+ }
+
+ var ContextOnlyDispatcher = {
+ readContext: readContext,
+ useCallback: throwInvalidHookError,
+ useContext: throwInvalidHookError,
+ useEffect: throwInvalidHookError,
+ useImperativeHandle: throwInvalidHookError,
+ useLayoutEffect: throwInvalidHookError,
+ useMemo: throwInvalidHookError,
+ useReducer: throwInvalidHookError,
+ useRef: throwInvalidHookError,
+ useState: throwInvalidHookError,
+ useDebugValue: throwInvalidHookError
+ },
+ HooksDispatcherOnMount = {
+ readContext: readContext,
+ useCallback: function useCallback(callback, deps) {
+ mountWorkInProgressHook().memoizedState = [callback, void 0 === deps ? null : deps];
+ return callback;
+ },
+ useContext: readContext,
+ useEffect: function useEffect(create, deps) {
+ return mountEffectImpl(516, UnmountPassive | MountPassive, create, deps);
+ },
+ useImperativeHandle: function useImperativeHandle(ref, create, deps) {
+ deps = null !== deps && void 0 !== deps ? deps.concat([ref]) : null;
+ return mountEffectImpl(4, UnmountMutation | MountLayout, imperativeHandleEffect.bind(null, create, ref), deps);
+ },
+ useLayoutEffect: function useLayoutEffect(create, deps) {
+ return mountEffectImpl(4, UnmountMutation | MountLayout, create, deps);
+ },
+ useMemo: function useMemo(nextCreate, deps) {
+ var hook = mountWorkInProgressHook();
+ deps = void 0 === deps ? null : deps;
+ nextCreate = nextCreate();
+ hook.memoizedState = [nextCreate, deps];
+ return nextCreate;
+ },
+ useReducer: function useReducer(reducer, initialArg, init) {
+ var hook = mountWorkInProgressHook();
+ initialArg = void 0 !== init ? init(initialArg) : initialArg;
+ hook.memoizedState = hook.baseState = initialArg;
+ reducer = hook.queue = {
+ last: null,
+ dispatch: null,
+ eagerReducer: reducer,
+ eagerState: initialArg
+ };
+ reducer = reducer.dispatch = dispatchAction.bind(null, currentlyRenderingFiber$1, reducer);
+ return [hook.memoizedState, reducer];
+ },
+ useRef: function useRef(initialValue) {
+ var hook = mountWorkInProgressHook();
+ initialValue = {
+ current: initialValue
+ };
+ return hook.memoizedState = initialValue;
+ },
+ useState: function useState(initialState) {
+ var hook = mountWorkInProgressHook();
+ "function" === typeof initialState && (initialState = initialState());
+ hook.memoizedState = hook.baseState = initialState;
+ initialState = hook.queue = {
+ last: null,
+ dispatch: null,
+ eagerReducer: basicStateReducer,
+ eagerState: initialState
+ };
+ initialState = initialState.dispatch = dispatchAction.bind(null, currentlyRenderingFiber$1, initialState);
+ return [hook.memoizedState, initialState];
+ },
+ useDebugValue: mountDebugValue
+ },
+ HooksDispatcherOnUpdate = {
+ readContext: readContext,
+ useCallback: function useCallback(callback, deps) {
+ var hook = updateWorkInProgressHook();
+ deps = void 0 === deps ? null : deps;
+ var prevState = hook.memoizedState;
+ if (null !== prevState && null !== deps && areHookInputsEqual(deps, prevState[1])) return prevState[0];
+ hook.memoizedState = [callback, deps];
+ return callback;
+ },
+ useContext: readContext,
+ useEffect: function useEffect(create, deps) {
+ return updateEffectImpl(516, UnmountPassive | MountPassive, create, deps);
+ },
+ useImperativeHandle: function useImperativeHandle(ref, create, deps) {
+ deps = null !== deps && void 0 !== deps ? deps.concat([ref]) : null;
+ return updateEffectImpl(4, UnmountMutation | MountLayout, imperativeHandleEffect.bind(null, create, ref), deps);
+ },
+ useLayoutEffect: function useLayoutEffect(create, deps) {
+ return updateEffectImpl(4, UnmountMutation | MountLayout, create, deps);
+ },
+ useMemo: function useMemo(nextCreate, deps) {
+ var hook = updateWorkInProgressHook();
+ deps = void 0 === deps ? null : deps;
+ var prevState = hook.memoizedState;
+ if (null !== prevState && null !== deps && areHookInputsEqual(deps, prevState[1])) return prevState[0];
+ nextCreate = nextCreate();
+ hook.memoizedState = [nextCreate, deps];
+ return nextCreate;
+ },
+ useReducer: updateReducer,
+ useRef: function useRef() {
+ return updateWorkInProgressHook().memoizedState;
+ },
+ useState: function useState(initialState) {
+ return updateReducer(basicStateReducer, initialState);
+ },
+ useDebugValue: mountDebugValue
+ },
+ hydrationParentFiber = null,
+ nextHydratableInstance = null,
+ isHydrating = !1;
+
+ function tryHydrate(fiber, nextInstance) {
+ switch (fiber.tag) {
+ case 5:
+ return nextInstance = shim$1(nextInstance, fiber.type, fiber.pendingProps), null !== nextInstance ? (fiber.stateNode = nextInstance, !0) : !1;
+
+ case 6:
+ return nextInstance = shim$1(nextInstance, fiber.pendingProps), null !== nextInstance ? (fiber.stateNode = nextInstance, !0) : !1;
+
+ case 13:
+ return !1;
+
+ default:
+ return !1;
+ }
+ }
+
+ function tryToClaimNextHydratableInstance(fiber$jscomp$0) {
+ if (isHydrating) {
+ var nextInstance = nextHydratableInstance;
+
+ if (nextInstance) {
+ var firstAttemptedInstance = nextInstance;
+
+ if (!tryHydrate(fiber$jscomp$0, nextInstance)) {
+ nextInstance = shim$1(firstAttemptedInstance);
+
+ if (!nextInstance || !tryHydrate(fiber$jscomp$0, nextInstance)) {
+ fiber$jscomp$0.effectTag |= 2;
+ isHydrating = !1;
+ hydrationParentFiber = fiber$jscomp$0;
+ return;
+ }
+
+ var returnFiber = hydrationParentFiber,
+ fiber = createFiber(5, null, null, 0);
+ fiber.elementType = "DELETED";
+ fiber.type = "DELETED";
+ fiber.stateNode = firstAttemptedInstance;
+ fiber.return = returnFiber;
+ fiber.effectTag = 8;
+ null !== returnFiber.lastEffect ? (returnFiber.lastEffect.nextEffect = fiber, returnFiber.lastEffect = fiber) : returnFiber.firstEffect = returnFiber.lastEffect = fiber;
+ }
+
+ hydrationParentFiber = fiber$jscomp$0;
+ nextHydratableInstance = shim$1(nextInstance);
+ } else fiber$jscomp$0.effectTag |= 2, isHydrating = !1, hydrationParentFiber = fiber$jscomp$0;
+ }
+ }
+
+ var ReactCurrentOwner$3 = ReactSharedInternals.ReactCurrentOwner,
+ didReceiveUpdate = !1;
+
+ function reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime) {
+ workInProgress.child = null === current$$1 ? mountChildFibers(workInProgress, null, nextChildren, renderExpirationTime) : reconcileChildFibers(workInProgress, current$$1.child, nextChildren, renderExpirationTime);
+ }
+
+ function updateForwardRef(current$$1, workInProgress, Component, nextProps, renderExpirationTime) {
+ Component = Component.render;
+ var ref = workInProgress.ref;
+ prepareToReadContext(workInProgress, renderExpirationTime);
+ nextProps = renderWithHooks(current$$1, workInProgress, Component, nextProps, ref, renderExpirationTime);
+ if (null !== current$$1 && !didReceiveUpdate) return workInProgress.updateQueue = current$$1.updateQueue, workInProgress.effectTag &= -517, current$$1.expirationTime <= renderExpirationTime && (current$$1.expirationTime = 0), bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ workInProgress.effectTag |= 1;
+ reconcileChildren(current$$1, workInProgress, nextProps, renderExpirationTime);
+ return workInProgress.child;
+ }
+
+ function updateMemoComponent(current$$1, workInProgress, Component, nextProps, updateExpirationTime, renderExpirationTime) {
+ if (null === current$$1) {
+ var type = Component.type;
+ if ("function" === typeof type && !shouldConstruct(type) && void 0 === type.defaultProps && null === Component.compare && void 0 === Component.defaultProps) return workInProgress.tag = 15, workInProgress.type = type, updateSimpleMemoComponent(current$$1, workInProgress, type, nextProps, updateExpirationTime, renderExpirationTime);
+ current$$1 = createFiberFromTypeAndProps(Component.type, null, nextProps, null, workInProgress.mode, renderExpirationTime);
+ current$$1.ref = workInProgress.ref;
+ current$$1.return = workInProgress;
+ return workInProgress.child = current$$1;
+ }
+
+ type = current$$1.child;
+ if (updateExpirationTime < renderExpirationTime && (updateExpirationTime = type.memoizedProps, Component = Component.compare, Component = null !== Component ? Component : shallowEqual, Component(updateExpirationTime, nextProps) && current$$1.ref === workInProgress.ref)) return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ workInProgress.effectTag |= 1;
+ current$$1 = createWorkInProgress(type, nextProps, renderExpirationTime);
+ current$$1.ref = workInProgress.ref;
+ current$$1.return = workInProgress;
+ return workInProgress.child = current$$1;
+ }
+
+ function updateSimpleMemoComponent(current$$1, workInProgress, Component, nextProps, updateExpirationTime, renderExpirationTime) {
+ return null !== current$$1 && shallowEqual(current$$1.memoizedProps, nextProps) && current$$1.ref === workInProgress.ref && (didReceiveUpdate = !1, updateExpirationTime < renderExpirationTime) ? bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime) : updateFunctionComponent(current$$1, workInProgress, Component, nextProps, renderExpirationTime);
+ }
+
+ function markRef(current$$1, workInProgress) {
+ var ref = workInProgress.ref;
+ if (null === current$$1 && null !== ref || null !== current$$1 && current$$1.ref !== ref) workInProgress.effectTag |= 128;
+ }
+
+ function updateFunctionComponent(current$$1, workInProgress, Component, nextProps, renderExpirationTime) {
+ var unmaskedContext = isContextProvider(Component) ? previousContext : contextStackCursor.current;
+ unmaskedContext = getMaskedContext(workInProgress, unmaskedContext);
+ prepareToReadContext(workInProgress, renderExpirationTime);
+ Component = renderWithHooks(current$$1, workInProgress, Component, nextProps, unmaskedContext, renderExpirationTime);
+ if (null !== current$$1 && !didReceiveUpdate) return workInProgress.updateQueue = current$$1.updateQueue, workInProgress.effectTag &= -517, current$$1.expirationTime <= renderExpirationTime && (current$$1.expirationTime = 0), bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ workInProgress.effectTag |= 1;
+ reconcileChildren(current$$1, workInProgress, Component, renderExpirationTime);
+ return workInProgress.child;
+ }
+
+ function updateClassComponent(current$$1, workInProgress, Component, nextProps, renderExpirationTime) {
+ if (isContextProvider(Component)) {
+ var hasContext = !0;
+ pushContextProvider(workInProgress);
+ } else hasContext = !1;
+
+ prepareToReadContext(workInProgress, renderExpirationTime);
+ if (null === workInProgress.stateNode) null !== current$$1 && (current$$1.alternate = null, workInProgress.alternate = null, workInProgress.effectTag |= 2), constructClassInstance(workInProgress, Component, nextProps, renderExpirationTime), mountClassInstance(workInProgress, Component, nextProps, renderExpirationTime), nextProps = !0;else if (null === current$$1) {
+ var instance = workInProgress.stateNode,
+ oldProps = workInProgress.memoizedProps;
+ instance.props = oldProps;
+ var oldContext = instance.context,
+ contextType = Component.contextType;
+ "object" === typeof contextType && null !== contextType ? contextType = readContext(contextType) : (contextType = isContextProvider(Component) ? previousContext : contextStackCursor.current, contextType = getMaskedContext(workInProgress, contextType));
+ var getDerivedStateFromProps = Component.getDerivedStateFromProps,
+ hasNewLifecycles = "function" === typeof getDerivedStateFromProps || "function" === typeof instance.getSnapshotBeforeUpdate;
+ hasNewLifecycles || "function" !== typeof instance.UNSAFE_componentWillReceiveProps && "function" !== typeof instance.componentWillReceiveProps || (oldProps !== nextProps || oldContext !== contextType) && callComponentWillReceiveProps(workInProgress, instance, nextProps, contextType);
+ hasForceUpdate = !1;
+ var oldState = workInProgress.memoizedState;
+ oldContext = instance.state = oldState;
+ var updateQueue = workInProgress.updateQueue;
+ null !== updateQueue && (processUpdateQueue(workInProgress, updateQueue, nextProps, instance, renderExpirationTime), oldContext = workInProgress.memoizedState);
+ oldProps !== nextProps || oldState !== oldContext || didPerformWorkStackCursor.current || hasForceUpdate ? ("function" === typeof getDerivedStateFromProps && (applyDerivedStateFromProps(workInProgress, Component, getDerivedStateFromProps, nextProps), oldContext = workInProgress.memoizedState), (oldProps = hasForceUpdate || checkShouldComponentUpdate(workInProgress, Component, oldProps, nextProps, oldState, oldContext, contextType)) ? (hasNewLifecycles || "function" !== typeof instance.UNSAFE_componentWillMount && "function" !== typeof instance.componentWillMount || ("function" === typeof instance.componentWillMount && instance.componentWillMount(), "function" === typeof instance.UNSAFE_componentWillMount && instance.UNSAFE_componentWillMount()), "function" === typeof instance.componentDidMount && (workInProgress.effectTag |= 4)) : ("function" === typeof instance.componentDidMount && (workInProgress.effectTag |= 4), workInProgress.memoizedProps = nextProps, workInProgress.memoizedState = oldContext), instance.props = nextProps, instance.state = oldContext, instance.context = contextType, nextProps = oldProps) : ("function" === typeof instance.componentDidMount && (workInProgress.effectTag |= 4), nextProps = !1);
+ } else instance = workInProgress.stateNode, oldProps = workInProgress.memoizedProps, instance.props = workInProgress.type === workInProgress.elementType ? oldProps : resolveDefaultProps(workInProgress.type, oldProps), oldContext = instance.context, contextType = Component.contextType, "object" === typeof contextType && null !== contextType ? contextType = readContext(contextType) : (contextType = isContextProvider(Component) ? previousContext : contextStackCursor.current, contextType = getMaskedContext(workInProgress, contextType)), getDerivedStateFromProps = Component.getDerivedStateFromProps, (hasNewLifecycles = "function" === typeof getDerivedStateFromProps || "function" === typeof instance.getSnapshotBeforeUpdate) || "function" !== typeof instance.UNSAFE_componentWillReceiveProps && "function" !== typeof instance.componentWillReceiveProps || (oldProps !== nextProps || oldContext !== contextType) && callComponentWillReceiveProps(workInProgress, instance, nextProps, contextType), hasForceUpdate = !1, oldContext = workInProgress.memoizedState, oldState = instance.state = oldContext, updateQueue = workInProgress.updateQueue, null !== updateQueue && (processUpdateQueue(workInProgress, updateQueue, nextProps, instance, renderExpirationTime), oldState = workInProgress.memoizedState), oldProps !== nextProps || oldContext !== oldState || didPerformWorkStackCursor.current || hasForceUpdate ? ("function" === typeof getDerivedStateFromProps && (applyDerivedStateFromProps(workInProgress, Component, getDerivedStateFromProps, nextProps), oldState = workInProgress.memoizedState), (getDerivedStateFromProps = hasForceUpdate || checkShouldComponentUpdate(workInProgress, Component, oldProps, nextProps, oldContext, oldState, contextType)) ? (hasNewLifecycles || "function" !== typeof instance.UNSAFE_componentWillUpdate && "function" !== typeof instance.componentWillUpdate || ("function" === typeof instance.componentWillUpdate && instance.componentWillUpdate(nextProps, oldState, contextType), "function" === typeof instance.UNSAFE_componentWillUpdate && instance.UNSAFE_componentWillUpdate(nextProps, oldState, contextType)), "function" === typeof instance.componentDidUpdate && (workInProgress.effectTag |= 4), "function" === typeof instance.getSnapshotBeforeUpdate && (workInProgress.effectTag |= 256)) : ("function" !== typeof instance.componentDidUpdate || oldProps === current$$1.memoizedProps && oldContext === current$$1.memoizedState || (workInProgress.effectTag |= 4), "function" !== typeof instance.getSnapshotBeforeUpdate || oldProps === current$$1.memoizedProps && oldContext === current$$1.memoizedState || (workInProgress.effectTag |= 256), workInProgress.memoizedProps = nextProps, workInProgress.memoizedState = oldState), instance.props = nextProps, instance.state = oldState, instance.context = contextType, nextProps = getDerivedStateFromProps) : ("function" !== typeof instance.componentDidUpdate || oldProps === current$$1.memoizedProps && oldContext === current$$1.memoizedState || (workInProgress.effectTag |= 4), "function" !== typeof instance.getSnapshotBeforeUpdate || oldProps === current$$1.memoizedProps && oldContext === current$$1.memoizedState || (workInProgress.effectTag |= 256), nextProps = !1);
+ return finishClassComponent(current$$1, workInProgress, Component, nextProps, hasContext, renderExpirationTime);
+ }
+
+ function finishClassComponent(current$$1, workInProgress, Component, shouldUpdate, hasContext, renderExpirationTime) {
+ markRef(current$$1, workInProgress);
+ var didCaptureError = 0 !== (workInProgress.effectTag & 64);
+ if (!shouldUpdate && !didCaptureError) return hasContext && invalidateContextProvider(workInProgress, Component, !1), bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ shouldUpdate = workInProgress.stateNode;
+ ReactCurrentOwner$3.current = workInProgress;
+ var nextChildren = didCaptureError && "function" !== typeof Component.getDerivedStateFromError ? null : shouldUpdate.render();
+ workInProgress.effectTag |= 1;
+ null !== current$$1 && didCaptureError ? (workInProgress.child = reconcileChildFibers(workInProgress, current$$1.child, null, renderExpirationTime), workInProgress.child = reconcileChildFibers(workInProgress, null, nextChildren, renderExpirationTime)) : reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
+ workInProgress.memoizedState = shouldUpdate.state;
+ hasContext && invalidateContextProvider(workInProgress, Component, !0);
+ return workInProgress.child;
+ }
+
+ function pushHostRootContext(workInProgress) {
+ var root = workInProgress.stateNode;
+ root.pendingContext ? pushTopLevelContextObject(workInProgress, root.pendingContext, root.pendingContext !== root.context) : root.context && pushTopLevelContextObject(workInProgress, root.context, !1);
+ pushHostContainer(workInProgress, root.containerInfo);
+ }
+
+ function updateSuspenseComponent(current$$1, workInProgress, renderExpirationTime) {
+ var mode = workInProgress.mode,
+ nextProps = workInProgress.pendingProps,
+ nextState = workInProgress.memoizedState;
+
+ if (0 === (workInProgress.effectTag & 64)) {
+ nextState = null;
+ var nextDidTimeout = !1;
+ } else nextState = {
+ timedOutAt: null !== nextState ? nextState.timedOutAt : 0
+ }, nextDidTimeout = !0, workInProgress.effectTag &= -65;
+
+ if (null === current$$1) {
+ if (nextDidTimeout) {
+ var nextFallbackChildren = nextProps.fallback;
+ current$$1 = createFiberFromFragment(null, mode, 0, null);
+ 0 === (workInProgress.mode & 1) && (current$$1.child = null !== workInProgress.memoizedState ? workInProgress.child.child : workInProgress.child);
+ mode = createFiberFromFragment(nextFallbackChildren, mode, renderExpirationTime, null);
+ current$$1.sibling = mode;
+ renderExpirationTime = current$$1;
+ renderExpirationTime.return = mode.return = workInProgress;
+ } else renderExpirationTime = mode = mountChildFibers(workInProgress, null, nextProps.children, renderExpirationTime);
+ } else null !== current$$1.memoizedState ? (mode = current$$1.child, nextFallbackChildren = mode.sibling, nextDidTimeout ? (renderExpirationTime = nextProps.fallback, nextProps = createWorkInProgress(mode, mode.pendingProps, 0), 0 === (workInProgress.mode & 1) && (nextDidTimeout = null !== workInProgress.memoizedState ? workInProgress.child.child : workInProgress.child, nextDidTimeout !== mode.child && (nextProps.child = nextDidTimeout)), mode = nextProps.sibling = createWorkInProgress(nextFallbackChildren, renderExpirationTime, nextFallbackChildren.expirationTime), renderExpirationTime = nextProps, nextProps.childExpirationTime = 0, renderExpirationTime.return = mode.return = workInProgress) : renderExpirationTime = mode = reconcileChildFibers(workInProgress, mode.child, nextProps.children, renderExpirationTime)) : (nextFallbackChildren = current$$1.child, nextDidTimeout ? (nextDidTimeout = nextProps.fallback, nextProps = createFiberFromFragment(null, mode, 0, null), nextProps.child = nextFallbackChildren, 0 === (workInProgress.mode & 1) && (nextProps.child = null !== workInProgress.memoizedState ? workInProgress.child.child : workInProgress.child), mode = nextProps.sibling = createFiberFromFragment(nextDidTimeout, mode, renderExpirationTime, null), mode.effectTag |= 2, renderExpirationTime = nextProps, nextProps.childExpirationTime = 0, renderExpirationTime.return = mode.return = workInProgress) : mode = renderExpirationTime = reconcileChildFibers(workInProgress, nextFallbackChildren, nextProps.children, renderExpirationTime)), workInProgress.stateNode = current$$1.stateNode;
+ workInProgress.memoizedState = nextState;
+ workInProgress.child = renderExpirationTime;
+ return mode;
+ }
+
+ function bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime) {
+ null !== current$$1 && (workInProgress.contextDependencies = current$$1.contextDependencies);
+ if (workInProgress.childExpirationTime < renderExpirationTime) return null;
+ invariant(null === current$$1 || workInProgress.child === current$$1.child, "Resuming work not yet implemented.");
+
+ if (null !== workInProgress.child) {
+ current$$1 = workInProgress.child;
+ renderExpirationTime = createWorkInProgress(current$$1, current$$1.pendingProps, current$$1.expirationTime);
+ workInProgress.child = renderExpirationTime;
+
+ for (renderExpirationTime.return = workInProgress; null !== current$$1.sibling;) {
+ current$$1 = current$$1.sibling, renderExpirationTime = renderExpirationTime.sibling = createWorkInProgress(current$$1, current$$1.pendingProps, current$$1.expirationTime), renderExpirationTime.return = workInProgress;
+ }
+
+ renderExpirationTime.sibling = null;
+ }
+
+ return workInProgress.child;
+ }
+
+ function beginWork(current$$1, workInProgress, renderExpirationTime) {
+ var updateExpirationTime = workInProgress.expirationTime;
+ if (null !== current$$1) {
+ if (current$$1.memoizedProps !== workInProgress.pendingProps || didPerformWorkStackCursor.current) didReceiveUpdate = !0;else {
+ if (updateExpirationTime < renderExpirationTime) {
+ didReceiveUpdate = !1;
+
+ switch (workInProgress.tag) {
+ case 3:
+ pushHostRootContext(workInProgress);
+ break;
+
+ case 5:
+ pushHostContext(workInProgress);
+ break;
+
+ case 1:
+ isContextProvider(workInProgress.type) && pushContextProvider(workInProgress);
+ break;
+
+ case 4:
+ pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+ break;
+
+ case 10:
+ pushProvider(workInProgress, workInProgress.memoizedProps.value);
+ break;
+
+ case 13:
+ if (null !== workInProgress.memoizedState) {
+ updateExpirationTime = workInProgress.child.childExpirationTime;
+ if (0 !== updateExpirationTime && updateExpirationTime >= renderExpirationTime) return updateSuspenseComponent(current$$1, workInProgress, renderExpirationTime);
+ workInProgress = bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ return null !== workInProgress ? workInProgress.sibling : null;
+ }
+
+ }
+
+ return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ }
+ }
+ } else didReceiveUpdate = !1;
+ workInProgress.expirationTime = 0;
+
+ switch (workInProgress.tag) {
+ case 2:
+ updateExpirationTime = workInProgress.elementType;
+ null !== current$$1 && (current$$1.alternate = null, workInProgress.alternate = null, workInProgress.effectTag |= 2);
+ current$$1 = workInProgress.pendingProps;
+ var context = getMaskedContext(workInProgress, contextStackCursor.current);
+ prepareToReadContext(workInProgress, renderExpirationTime);
+ context = renderWithHooks(null, workInProgress, updateExpirationTime, current$$1, context, renderExpirationTime);
+ workInProgress.effectTag |= 1;
+
+ if ("object" === typeof context && null !== context && "function" === typeof context.render && void 0 === context.$$typeof) {
+ workInProgress.tag = 1;
+ resetHooks();
+
+ if (isContextProvider(updateExpirationTime)) {
+ var hasContext = !0;
+ pushContextProvider(workInProgress);
+ } else hasContext = !1;
+
+ workInProgress.memoizedState = null !== context.state && void 0 !== context.state ? context.state : null;
+ var getDerivedStateFromProps = updateExpirationTime.getDerivedStateFromProps;
+ "function" === typeof getDerivedStateFromProps && applyDerivedStateFromProps(workInProgress, updateExpirationTime, getDerivedStateFromProps, current$$1);
+ context.updater = classComponentUpdater;
+ workInProgress.stateNode = context;
+ context._reactInternalFiber = workInProgress;
+ mountClassInstance(workInProgress, updateExpirationTime, current$$1, renderExpirationTime);
+ workInProgress = finishClassComponent(null, workInProgress, updateExpirationTime, !0, hasContext, renderExpirationTime);
+ } else workInProgress.tag = 0, reconcileChildren(null, workInProgress, context, renderExpirationTime), workInProgress = workInProgress.child;
+
+ return workInProgress;
+
+ case 16:
+ context = workInProgress.elementType;
+ null !== current$$1 && (current$$1.alternate = null, workInProgress.alternate = null, workInProgress.effectTag |= 2);
+ hasContext = workInProgress.pendingProps;
+ current$$1 = readLazyComponentType(context);
+ workInProgress.type = current$$1;
+ context = workInProgress.tag = resolveLazyComponentTag(current$$1);
+ hasContext = resolveDefaultProps(current$$1, hasContext);
+ getDerivedStateFromProps = void 0;
+
+ switch (context) {
+ case 0:
+ getDerivedStateFromProps = updateFunctionComponent(null, workInProgress, current$$1, hasContext, renderExpirationTime);
+ break;
+
+ case 1:
+ getDerivedStateFromProps = updateClassComponent(null, workInProgress, current$$1, hasContext, renderExpirationTime);
+ break;
+
+ case 11:
+ getDerivedStateFromProps = updateForwardRef(null, workInProgress, current$$1, hasContext, renderExpirationTime);
+ break;
+
+ case 14:
+ getDerivedStateFromProps = updateMemoComponent(null, workInProgress, current$$1, resolveDefaultProps(current$$1.type, hasContext), updateExpirationTime, renderExpirationTime);
+ break;
+
+ default:
+ invariant(!1, "Element type is invalid. Received a promise that resolves to: %s. Lazy element type must resolve to a class or function.%s", current$$1, "");
+ }
+
+ return getDerivedStateFromProps;
+
+ case 0:
+ return updateExpirationTime = workInProgress.type, context = workInProgress.pendingProps, context = workInProgress.elementType === updateExpirationTime ? context : resolveDefaultProps(updateExpirationTime, context), updateFunctionComponent(current$$1, workInProgress, updateExpirationTime, context, renderExpirationTime);
+
+ case 1:
+ return updateExpirationTime = workInProgress.type, context = workInProgress.pendingProps, context = workInProgress.elementType === updateExpirationTime ? context : resolveDefaultProps(updateExpirationTime, context), updateClassComponent(current$$1, workInProgress, updateExpirationTime, context, renderExpirationTime);
+
+ case 3:
+ return pushHostRootContext(workInProgress), updateExpirationTime = workInProgress.updateQueue, invariant(null !== updateExpirationTime, "If the root does not have an updateQueue, we should have already bailed out. This error is likely caused by a bug in React. Please file an issue."), context = workInProgress.memoizedState, context = null !== context ? context.element : null, processUpdateQueue(workInProgress, updateExpirationTime, workInProgress.pendingProps, null, renderExpirationTime), updateExpirationTime = workInProgress.memoizedState.element, updateExpirationTime === context ? workInProgress = bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime) : (reconcileChildren(current$$1, workInProgress, updateExpirationTime, renderExpirationTime), workInProgress = workInProgress.child), workInProgress;
+
+ case 5:
+ return pushHostContext(workInProgress), null === current$$1 && tryToClaimNextHydratableInstance(workInProgress), updateExpirationTime = workInProgress.pendingProps.children, markRef(current$$1, workInProgress), reconcileChildren(current$$1, workInProgress, updateExpirationTime, renderExpirationTime), workInProgress = workInProgress.child, workInProgress;
+
+ case 6:
+ return null === current$$1 && tryToClaimNextHydratableInstance(workInProgress), null;
+
+ case 13:
+ return updateSuspenseComponent(current$$1, workInProgress, renderExpirationTime);
+
+ case 4:
+ return pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo), updateExpirationTime = workInProgress.pendingProps, null === current$$1 ? workInProgress.child = reconcileChildFibers(workInProgress, null, updateExpirationTime, renderExpirationTime) : reconcileChildren(current$$1, workInProgress, updateExpirationTime, renderExpirationTime), workInProgress.child;
+
+ case 11:
+ return updateExpirationTime = workInProgress.type, context = workInProgress.pendingProps, context = workInProgress.elementType === updateExpirationTime ? context : resolveDefaultProps(updateExpirationTime, context), updateForwardRef(current$$1, workInProgress, updateExpirationTime, context, renderExpirationTime);
+
+ case 7:
+ return reconcileChildren(current$$1, workInProgress, workInProgress.pendingProps, renderExpirationTime), workInProgress.child;
+
+ case 8:
+ return reconcileChildren(current$$1, workInProgress, workInProgress.pendingProps.children, renderExpirationTime), workInProgress.child;
+
+ case 12:
+ return reconcileChildren(current$$1, workInProgress, workInProgress.pendingProps.children, renderExpirationTime), workInProgress.child;
+
+ case 10:
+ a: {
+ updateExpirationTime = workInProgress.type._context;
+ context = workInProgress.pendingProps;
+ getDerivedStateFromProps = workInProgress.memoizedProps;
+ hasContext = context.value;
+ pushProvider(workInProgress, hasContext);
+
+ if (null !== getDerivedStateFromProps) {
+ var oldValue = getDerivedStateFromProps.value;
+ hasContext = is(oldValue, hasContext) ? 0 : ("function" === typeof updateExpirationTime._calculateChangedBits ? updateExpirationTime._calculateChangedBits(oldValue, hasContext) : 1073741823) | 0;
+
+ if (0 === hasContext) {
+ if (getDerivedStateFromProps.children === context.children && !didPerformWorkStackCursor.current) {
+ workInProgress = bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
+ break a;
+ }
+ } else for (oldValue = workInProgress.child, null !== oldValue && (oldValue.return = workInProgress); null !== oldValue;) {
+ var list = oldValue.contextDependencies;
+
+ if (null !== list) {
+ getDerivedStateFromProps = oldValue.child;
+
+ for (var dependency = list.first; null !== dependency;) {
+ if (dependency.context === updateExpirationTime && 0 !== (dependency.observedBits & hasContext)) {
+ 1 === oldValue.tag && (dependency = createUpdate(renderExpirationTime), dependency.tag = ForceUpdate, enqueueUpdate(oldValue, dependency));
+ oldValue.expirationTime < renderExpirationTime && (oldValue.expirationTime = renderExpirationTime);
+ dependency = oldValue.alternate;
+ null !== dependency && dependency.expirationTime < renderExpirationTime && (dependency.expirationTime = renderExpirationTime);
+ dependency = renderExpirationTime;
+
+ for (var node = oldValue.return; null !== node;) {
+ var alternate = node.alternate;
+ if (node.childExpirationTime < dependency) node.childExpirationTime = dependency, null !== alternate && alternate.childExpirationTime < dependency && (alternate.childExpirationTime = dependency);else if (null !== alternate && alternate.childExpirationTime < dependency) alternate.childExpirationTime = dependency;else break;
+ node = node.return;
+ }
+
+ list.expirationTime < renderExpirationTime && (list.expirationTime = renderExpirationTime);
+ break;
+ }
+
+ dependency = dependency.next;
+ }
+ } else getDerivedStateFromProps = 10 === oldValue.tag ? oldValue.type === workInProgress.type ? null : oldValue.child : oldValue.child;
+
+ if (null !== getDerivedStateFromProps) getDerivedStateFromProps.return = oldValue;else for (getDerivedStateFromProps = oldValue; null !== getDerivedStateFromProps;) {
+ if (getDerivedStateFromProps === workInProgress) {
+ getDerivedStateFromProps = null;
+ break;
+ }
+
+ oldValue = getDerivedStateFromProps.sibling;
+
+ if (null !== oldValue) {
+ oldValue.return = getDerivedStateFromProps.return;
+ getDerivedStateFromProps = oldValue;
+ break;
+ }
+
+ getDerivedStateFromProps = getDerivedStateFromProps.return;
+ }
+ oldValue = getDerivedStateFromProps;
+ }
+ }
+
+ reconcileChildren(current$$1, workInProgress, context.children, renderExpirationTime);
+ workInProgress = workInProgress.child;
+ }
+
+ return workInProgress;
+
+ case 9:
+ return context = workInProgress.type, hasContext = workInProgress.pendingProps, updateExpirationTime = hasContext.children, prepareToReadContext(workInProgress, renderExpirationTime), context = readContext(context, hasContext.unstable_observedBits), updateExpirationTime = updateExpirationTime(context), workInProgress.effectTag |= 1, reconcileChildren(current$$1, workInProgress, updateExpirationTime, renderExpirationTime), workInProgress.child;
+
+ case 14:
+ return context = workInProgress.type, hasContext = resolveDefaultProps(context, workInProgress.pendingProps), hasContext = resolveDefaultProps(context.type, hasContext), updateMemoComponent(current$$1, workInProgress, context, hasContext, updateExpirationTime, renderExpirationTime);
+
+ case 15:
+ return updateSimpleMemoComponent(current$$1, workInProgress, workInProgress.type, workInProgress.pendingProps, updateExpirationTime, renderExpirationTime);
+
+ case 17:
+ return updateExpirationTime = workInProgress.type, context = workInProgress.pendingProps, context = workInProgress.elementType === updateExpirationTime ? context : resolveDefaultProps(updateExpirationTime, context), null !== current$$1 && (current$$1.alternate = null, workInProgress.alternate = null, workInProgress.effectTag |= 2), workInProgress.tag = 1, isContextProvider(updateExpirationTime) ? (current$$1 = !0, pushContextProvider(workInProgress)) : current$$1 = !1, prepareToReadContext(workInProgress, renderExpirationTime), constructClassInstance(workInProgress, updateExpirationTime, context, renderExpirationTime), mountClassInstance(workInProgress, updateExpirationTime, context, renderExpirationTime), finishClassComponent(null, workInProgress, updateExpirationTime, !0, current$$1, renderExpirationTime);
+ }
+
+ invariant(!1, "Unknown unit of work tag. This error is likely caused by a bug in React. Please file an issue.");
+ }
+
+ var valueCursor = {
+ current: null
+ },
+ currentlyRenderingFiber = null,
+ lastContextDependency = null,
+ lastContextWithAllBitsObserved = null;
+
+ function pushProvider(providerFiber, nextValue) {
+ var context = providerFiber.type._context;
+ push(valueCursor, context._currentValue2, providerFiber);
+ context._currentValue2 = nextValue;
+ }
+
+ function popProvider(providerFiber) {
+ var currentValue = valueCursor.current;
+ pop(valueCursor, providerFiber);
+ providerFiber.type._context._currentValue2 = currentValue;
+ }
+
+ function prepareToReadContext(workInProgress, renderExpirationTime) {
+ currentlyRenderingFiber = workInProgress;
+ lastContextWithAllBitsObserved = lastContextDependency = null;
+ var currentDependencies = workInProgress.contextDependencies;
+ null !== currentDependencies && currentDependencies.expirationTime >= renderExpirationTime && (didReceiveUpdate = !0);
+ workInProgress.contextDependencies = null;
+ }
+
+ function readContext(context, observedBits) {
+ if (lastContextWithAllBitsObserved !== context && !1 !== observedBits && 0 !== observedBits) {
+ if ("number" !== typeof observedBits || 1073741823 === observedBits) lastContextWithAllBitsObserved = context, observedBits = 1073741823;
+ observedBits = {
+ context: context,
+ observedBits: observedBits,
+ next: null
+ };
+ null === lastContextDependency ? (invariant(null !== currentlyRenderingFiber, "Context can only be read while React is rendering. In classes, you can read it in the render method or getDerivedStateFromProps. In function components, you can read it directly in the function body, but not inside Hooks like useReducer() or useMemo()."), lastContextDependency = observedBits, currentlyRenderingFiber.contextDependencies = {
+ first: observedBits,
+ expirationTime: 0
+ }) : lastContextDependency = lastContextDependency.next = observedBits;
+ }
+
+ return context._currentValue2;
+ }
+
+ var UpdateState = 0,
+ ReplaceState = 1,
+ ForceUpdate = 2,
+ CaptureUpdate = 3,
+ hasForceUpdate = !1;
+
+ function createUpdateQueue(baseState) {
+ return {
+ baseState: baseState,
+ firstUpdate: null,
+ lastUpdate: null,
+ firstCapturedUpdate: null,
+ lastCapturedUpdate: null,
+ firstEffect: null,
+ lastEffect: null,
+ firstCapturedEffect: null,
+ lastCapturedEffect: null
+ };
+ }
+
+ function cloneUpdateQueue(currentQueue) {
+ return {
+ baseState: currentQueue.baseState,
+ firstUpdate: currentQueue.firstUpdate,
+ lastUpdate: currentQueue.lastUpdate,
+ firstCapturedUpdate: null,
+ lastCapturedUpdate: null,
+ firstEffect: null,
+ lastEffect: null,
+ firstCapturedEffect: null,
+ lastCapturedEffect: null
+ };
+ }
+
+ function createUpdate(expirationTime) {
+ return {
+ expirationTime: expirationTime,
+ tag: UpdateState,
+ payload: null,
+ callback: null,
+ next: null,
+ nextEffect: null
+ };
+ }
+
+ function appendUpdateToQueue(queue, update) {
+ null === queue.lastUpdate ? queue.firstUpdate = queue.lastUpdate = update : (queue.lastUpdate.next = update, queue.lastUpdate = update);
+ }
+
+ function enqueueUpdate(fiber, update) {
+ var alternate = fiber.alternate;
+
+ if (null === alternate) {
+ var queue1 = fiber.updateQueue;
+ var queue2 = null;
+ null === queue1 && (queue1 = fiber.updateQueue = createUpdateQueue(fiber.memoizedState));
+ } else queue1 = fiber.updateQueue, queue2 = alternate.updateQueue, null === queue1 ? null === queue2 ? (queue1 = fiber.updateQueue = createUpdateQueue(fiber.memoizedState), queue2 = alternate.updateQueue = createUpdateQueue(alternate.memoizedState)) : queue1 = fiber.updateQueue = cloneUpdateQueue(queue2) : null === queue2 && (queue2 = alternate.updateQueue = cloneUpdateQueue(queue1));
+
+ null === queue2 || queue1 === queue2 ? appendUpdateToQueue(queue1, update) : null === queue1.lastUpdate || null === queue2.lastUpdate ? (appendUpdateToQueue(queue1, update), appendUpdateToQueue(queue2, update)) : (appendUpdateToQueue(queue1, update), queue2.lastUpdate = update);
+ }
+
+ function enqueueCapturedUpdate(workInProgress, update) {
+ var workInProgressQueue = workInProgress.updateQueue;
+ workInProgressQueue = null === workInProgressQueue ? workInProgress.updateQueue = createUpdateQueue(workInProgress.memoizedState) : ensureWorkInProgressQueueIsAClone(workInProgress, workInProgressQueue);
+ null === workInProgressQueue.lastCapturedUpdate ? workInProgressQueue.firstCapturedUpdate = workInProgressQueue.lastCapturedUpdate = update : (workInProgressQueue.lastCapturedUpdate.next = update, workInProgressQueue.lastCapturedUpdate = update);
+ }
+
+ function ensureWorkInProgressQueueIsAClone(workInProgress, queue) {
+ var current = workInProgress.alternate;
+ null !== current && queue === current.updateQueue && (queue = workInProgress.updateQueue = cloneUpdateQueue(queue));
+ return queue;
+ }
+
+ function getStateFromUpdate(workInProgress, queue, update, prevState, nextProps, instance) {
+ switch (update.tag) {
+ case ReplaceState:
+ return workInProgress = update.payload, "function" === typeof workInProgress ? workInProgress.call(instance, prevState, nextProps) : workInProgress;
+
+ case CaptureUpdate:
+ workInProgress.effectTag = workInProgress.effectTag & -2049 | 64;
+
+ case UpdateState:
+ 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 ForceUpdate:
+ hasForceUpdate = !0;
+ }
+
+ return prevState;
+ }
+
+ function processUpdateQueue(workInProgress, queue, props, instance, renderExpirationTime) {
+ hasForceUpdate = !1;
+ queue = ensureWorkInProgressQueueIsAClone(workInProgress, queue);
+
+ for (var newBaseState = queue.baseState, newFirstUpdate = null, newExpirationTime = 0, update = queue.firstUpdate, resultState = newBaseState; null !== update;) {
+ var updateExpirationTime = update.expirationTime;
+ updateExpirationTime < renderExpirationTime ? (null === newFirstUpdate && (newFirstUpdate = update, newBaseState = resultState), newExpirationTime < updateExpirationTime && (newExpirationTime = updateExpirationTime)) : (resultState = getStateFromUpdate(workInProgress, queue, update, resultState, props, instance), null !== update.callback && (workInProgress.effectTag |= 32, update.nextEffect = null, null === queue.lastEffect ? queue.firstEffect = queue.lastEffect = update : (queue.lastEffect.nextEffect = update, queue.lastEffect = update)));
+ update = update.next;
+ }
+
+ updateExpirationTime = null;
+
+ for (update = queue.firstCapturedUpdate; null !== update;) {
+ var _updateExpirationTime = update.expirationTime;
+ _updateExpirationTime < renderExpirationTime ? (null === updateExpirationTime && (updateExpirationTime = update, null === newFirstUpdate && (newBaseState = resultState)), newExpirationTime < _updateExpirationTime && (newExpirationTime = _updateExpirationTime)) : (resultState = getStateFromUpdate(workInProgress, queue, update, resultState, props, instance), null !== update.callback && (workInProgress.effectTag |= 32, update.nextEffect = null, null === queue.lastCapturedEffect ? queue.firstCapturedEffect = queue.lastCapturedEffect = update : (queue.lastCapturedEffect.nextEffect = update, queue.lastCapturedEffect = update)));
+ update = update.next;
+ }
+
+ null === newFirstUpdate && (queue.lastUpdate = null);
+ null === updateExpirationTime ? queue.lastCapturedUpdate = null : workInProgress.effectTag |= 32;
+ null === newFirstUpdate && null === updateExpirationTime && (newBaseState = resultState);
+ queue.baseState = newBaseState;
+ queue.firstUpdate = newFirstUpdate;
+ queue.firstCapturedUpdate = updateExpirationTime;
+ workInProgress.expirationTime = newExpirationTime;
+ workInProgress.memoizedState = resultState;
+ }
+
+ function commitUpdateQueue(finishedWork, finishedQueue, instance) {
+ null !== finishedQueue.firstCapturedUpdate && (null !== finishedQueue.lastUpdate && (finishedQueue.lastUpdate.next = finishedQueue.firstCapturedUpdate, finishedQueue.lastUpdate = finishedQueue.lastCapturedUpdate), finishedQueue.firstCapturedUpdate = finishedQueue.lastCapturedUpdate = null);
+ commitUpdateEffects(finishedQueue.firstEffect, instance);
+ finishedQueue.firstEffect = finishedQueue.lastEffect = null;
+ commitUpdateEffects(finishedQueue.firstCapturedEffect, instance);
+ finishedQueue.firstCapturedEffect = finishedQueue.lastCapturedEffect = null;
+ }
+
+ function commitUpdateEffects(effect, instance) {
+ for (; null !== effect;) {
+ var _callback3 = effect.callback;
+
+ if (null !== _callback3) {
+ effect.callback = null;
+ var context = instance;
+ invariant("function" === typeof _callback3, "Invalid argument passed as callback. Expected a function. Instead received: %s", _callback3);
+
+ _callback3.call(context);
+ }
+
+ effect = effect.nextEffect;
+ }
+ }
+
+ function createCapturedValue(value, source) {
+ return {
+ value: value,
+ source: source,
+ stack: getStackByFiberInDevAndProd(source)
+ };
+ }
+
+ var _appendAllChildren = void 0,
+ updateHostContainer = void 0,
+ updateHostComponent$1 = void 0,
+ updateHostText$1 = void 0;
+
+ _appendAllChildren = function appendAllChildren(parent, workInProgress, needsVisibilityToggle, isHidden) {
+ for (var node = workInProgress.child; null !== node;) {
+ a: if (5 === node.tag) {
+ var instance = node.stateNode;
+
+ if (needsVisibilityToggle) {
+ var props = node.memoizedProps,
+ type = node.type;
+ instance = isHidden ? cloneHiddenInstance(instance, type, props, node) : cloneUnhiddenInstance(instance, type, props, node);
+ node.stateNode = instance;
+ }
+
+ FabricUIManager.appendChild(parent.node, instance.node);
+ } else if (6 === node.tag) {
+ instance = node.stateNode;
+
+ if (needsVisibilityToggle) {
+ instance = node.memoizedProps;
+ props = requiredContext(rootInstanceStackCursor.current);
+ type = requiredContext(contextStackCursor$1.current);
+ if (isHidden) throw Error("Not yet implemented.");
+ instance = createTextInstance(instance, props, type, workInProgress);
+ node.stateNode = instance;
+ }
+
+ FabricUIManager.appendChild(parent.node, instance.node);
+ } else if (4 !== node.tag) {
+ if (13 === node.tag && (props = node.alternate, null !== props && (instance = null !== node.memoizedState, null !== props.memoizedState !== instance))) {
+ props = instance ? node.child : node;
+ null !== props && _appendAllChildren(parent, props, !0, instance);
+ break a;
+ }
+
+ if (null !== node.child) {
+ node.child.return = node;
+ node = node.child;
+ continue;
+ }
+ }
+
+ if (node === workInProgress) break;
+
+ for (; null === node.sibling;) {
+ if (null === node.return || node.return === workInProgress) return;
+ node = node.return;
+ }
+
+ node.sibling.return = node.return;
+ node = node.sibling;
+ }
+ };
+
+ function appendAllChildrenToContainer(containerChildSet, workInProgress, needsVisibilityToggle, isHidden) {
+ for (var node = workInProgress.child; null !== node;) {
+ a: if (5 === node.tag) {
+ var instance = node.stateNode;
+
+ if (needsVisibilityToggle) {
+ var props = node.memoizedProps,
+ type = node.type;
+ instance = isHidden ? cloneHiddenInstance(instance, type, props, node) : cloneUnhiddenInstance(instance, type, props, node);
+ node.stateNode = instance;
+ }
+
+ FabricUIManager.appendChildToSet(containerChildSet, instance.node);
+ } else if (6 === node.tag) {
+ instance = node.stateNode;
+
+ if (needsVisibilityToggle) {
+ instance = node.memoizedProps;
+ props = requiredContext(rootInstanceStackCursor.current);
+ type = requiredContext(contextStackCursor$1.current);
+ if (isHidden) throw Error("Not yet implemented.");
+ instance = createTextInstance(instance, props, type, workInProgress);
+ node.stateNode = instance;
+ }
+
+ FabricUIManager.appendChildToSet(containerChildSet, instance.node);
+ } else if (4 !== node.tag) {
+ if (13 === node.tag && (props = node.alternate, null !== props && (instance = null !== node.memoizedState, null !== props.memoizedState !== instance))) {
+ props = instance ? node.child : node;
+ null !== props && appendAllChildrenToContainer(containerChildSet, props, !0, instance);
+ break a;
+ }
+
+ if (null !== node.child) {
+ node.child.return = node;
+ node = node.child;
+ continue;
+ }
+ }
+
+ if (node === workInProgress) break;
+
+ for (; null === node.sibling;) {
+ if (null === node.return || node.return === workInProgress) return;
+ node = node.return;
+ }
+
+ node.sibling.return = node.return;
+ node = node.sibling;
+ }
+ }
+
+ updateHostContainer = function updateHostContainer(workInProgress) {
+ var portalOrRoot = workInProgress.stateNode;
+
+ if (null !== workInProgress.firstEffect) {
+ var container = portalOrRoot.containerInfo,
+ newChildSet = FabricUIManager.createChildSet(container);
+ appendAllChildrenToContainer(newChildSet, workInProgress, !1, !1);
+ portalOrRoot.pendingChildren = newChildSet;
+ workInProgress.effectTag |= 4;
+ FabricUIManager.completeRoot(container, newChildSet);
+ }
+ };
+
+ updateHostComponent$1 = function updateHostComponent$1(current, workInProgress, type, newProps) {
+ type = current.stateNode;
+ var oldProps = current.memoizedProps;
+ if ((current = null === workInProgress.firstEffect) && oldProps === newProps) workInProgress.stateNode = type;else {
+ var recyclableInstance = workInProgress.stateNode;
+ requiredContext(contextStackCursor$1.current);
+ var updatePayload = null;
+ oldProps !== newProps && (oldProps = diffProperties(null, oldProps, newProps, recyclableInstance.canonical.viewConfig.validAttributes), recyclableInstance.canonical.currentProps = newProps, updatePayload = oldProps);
+ current && null === updatePayload ? workInProgress.stateNode = type : (newProps = updatePayload, recyclableInstance = type.node, type = {
+ node: current ? null !== newProps ? FabricUIManager.cloneNodeWithNewProps(recyclableInstance, newProps) : FabricUIManager.cloneNode(recyclableInstance) : null !== newProps ? FabricUIManager.cloneNodeWithNewChildrenAndProps(recyclableInstance, newProps) : FabricUIManager.cloneNodeWithNewChildren(recyclableInstance),
+ canonical: type.canonical
+ }, workInProgress.stateNode = type, current ? workInProgress.effectTag |= 4 : _appendAllChildren(type, workInProgress, !1, !1));
+ }
+ };
+
+ updateHostText$1 = function updateHostText$1(current, workInProgress, oldText, newText) {
+ oldText !== newText && (current = requiredContext(rootInstanceStackCursor.current), oldText = requiredContext(contextStackCursor$1.current), workInProgress.stateNode = createTextInstance(newText, current, oldText, workInProgress), workInProgress.effectTag |= 4);
+ };
+
+ function logCapturedError(capturedError) {
+ var componentStack = capturedError.componentStack,
+ error = capturedError.error;
+
+ if (error instanceof Error) {
+ capturedError = error.message;
+ var name = error.name;
+
+ try {
+ error.message = (capturedError ? name + ": " + capturedError : name) + "\n\nThis error is located at:" + componentStack;
+ } catch (e) {}
+ } else error = "string" === typeof error ? Error(error + "\n\nThis error is located at:" + componentStack) : Error("Unspecified error at:" + componentStack);
+
+ ExceptionsManager.handleException(error, !1);
+ }
+
+ function logError(boundary, errorInfo) {
+ var source = errorInfo.source,
+ stack = errorInfo.stack;
+ null === stack && null !== source && (stack = getStackByFiberInDevAndProd(source));
+ errorInfo = {
+ componentName: null !== source ? getComponentName(source.type) : null,
+ componentStack: null !== stack ? stack : "",
+ error: errorInfo.value,
+ errorBoundary: null,
+ errorBoundaryName: null,
+ errorBoundaryFound: !1,
+ willRetry: !1
+ };
+ null !== boundary && 1 === boundary.tag && (errorInfo.errorBoundary = boundary.stateNode, errorInfo.errorBoundaryName = getComponentName(boundary.type), errorInfo.errorBoundaryFound = !0, errorInfo.willRetry = !0);
+
+ try {
+ logCapturedError(errorInfo);
+ } catch (e) {
+ setTimeout(function () {
+ throw e;
+ });
+ }
+ }
+
+ function safelyDetachRef(current$$1) {
+ var ref = current$$1.ref;
+ if (null !== ref) if ("function" === typeof ref) try {
+ ref(null);
+ } catch (refError) {
+ captureCommitPhaseError(current$$1, refError);
+ } else ref.current = null;
+ }
+
+ function commitHookEffectList(unmountTag, mountTag, finishedWork) {
+ finishedWork = finishedWork.updateQueue;
+ finishedWork = null !== finishedWork ? finishedWork.lastEffect : null;
+
+ if (null !== finishedWork) {
+ var effect = finishedWork = finishedWork.next;
+
+ do {
+ if ((effect.tag & unmountTag) !== NoEffect$1) {
+ var destroy = effect.destroy;
+ effect.destroy = void 0;
+ void 0 !== destroy && destroy();
+ }
+
+ (effect.tag & mountTag) !== NoEffect$1 && (destroy = effect.create, effect.destroy = destroy());
+ effect = effect.next;
+ } while (effect !== finishedWork);
+ }
+ }
+
+ function commitWork(current$$1, finishedWork) {
+ switch (finishedWork.tag) {
+ case 0:
+ case 11:
+ case 14:
+ case 15:
+ commitHookEffectList(UnmountMutation, MountMutation, finishedWork);
+ return;
+ }
+
+ switch (finishedWork.tag) {
+ case 1:
+ 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.");
+ }
+ }
+
+ var PossiblyWeakMap = "function" === typeof WeakMap ? WeakMap : Map;
+
+ function createRootErrorUpdate(fiber, errorInfo, expirationTime) {
+ expirationTime = createUpdate(expirationTime);
+ expirationTime.tag = CaptureUpdate;
+ 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 = CaptureUpdate;
+ var getDerivedStateFromError = fiber.type.getDerivedStateFromError;
+
+ if ("function" === typeof getDerivedStateFromError) {
+ var error$jscomp$0 = errorInfo.value;
+
+ expirationTime.payload = function () {
+ return getDerivedStateFromError(error$jscomp$0);
+ };
+ }
+
+ var inst = fiber.stateNode;
+ null !== inst && "function" === typeof inst.componentDidCatch && (expirationTime.callback = function () {
+ "function" !== typeof getDerivedStateFromError && (null === legacyErrorBoundariesThatAlreadyFailed ? legacyErrorBoundariesThatAlreadyFailed = new Set([this]) : legacyErrorBoundariesThatAlreadyFailed.add(this));
+ 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 1:
+ isContextProvider(workInProgress.type) && popContext(workInProgress);
+ var effectTag = workInProgress.effectTag;
+ return effectTag & 2048 ? (workInProgress.effectTag = effectTag & -2049 | 64, workInProgress) : null;
+
+ case 3:
+ return popHostContainer(workInProgress), popTopLevelContextObject(workInProgress), effectTag = workInProgress.effectTag, invariant(0 === (effectTag & 64), "The root failed to unmount after an error. This is likely a bug in React. Please file an issue."), workInProgress.effectTag = effectTag & -2049 | 64, workInProgress;
+
+ case 5:
+ return popHostContext(workInProgress), null;
+
+ case 13:
+ return effectTag = workInProgress.effectTag, effectTag & 2048 ? (workInProgress.effectTag = effectTag & -2049 | 64, workInProgress) : null;
+
+ case 18:
+ return null;
+
+ case 4:
+ return popHostContainer(workInProgress), null;
+
+ case 10:
+ return popProvider(workInProgress), null;
+
+ default:
+ return null;
+ }
+ }
+
+ var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher,
+ ReactCurrentOwner$2 = ReactSharedInternals.ReactCurrentOwner,
+ isWorking = !1,
+ nextUnitOfWork = null,
+ nextRoot = null,
+ nextRenderExpirationTime = 0,
+ nextLatestAbsoluteTimeoutMs = -1,
+ nextRenderDidError = !1,
+ nextEffect = null,
+ isCommitting$1 = !1,
+ rootWithPendingPassiveEffects = null,
+ passiveEffectCallbackHandle = null,
+ passiveEffectCallback = null,
+ 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 1:
+ var childContextTypes = interruptedWork$jscomp$0.type.childContextTypes;
+ null !== childContextTypes && void 0 !== childContextTypes && popContext(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 10:
+ popProvider(interruptedWork$jscomp$0);
+ }
+
+ interruptedWork = interruptedWork.return;
+ }
+ nextRoot = null;
+ nextRenderExpirationTime = 0;
+ nextLatestAbsoluteTimeoutMs = -1;
+ nextRenderDidError = !1;
+ nextUnitOfWork = null;
+ }
+
+ function commitAllHostEffects() {
+ for (; null !== nextEffect;) {
+ var effectTag = nextEffect.effectTag;
+
+ if (effectTag & 128) {
+ var current$$1 = nextEffect.alternate;
+ null !== current$$1 && (current$$1 = current$$1.ref, null !== current$$1 && ("function" === typeof current$$1 ? current$$1(null) : current$$1.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:
+ effectTag = nextEffect;
+
+ a: for (var node = current$$1 = effectTag;;) {
+ var current$$1$jscomp$0 = node;
+ "function" === typeof onCommitFiberUnmount && onCommitFiberUnmount(current$$1$jscomp$0);
+
+ switch (current$$1$jscomp$0.tag) {
+ case 0:
+ case 11:
+ case 14:
+ case 15:
+ var updateQueue = current$$1$jscomp$0.updateQueue;
+
+ if (null !== updateQueue && (updateQueue = updateQueue.lastEffect, null !== updateQueue)) {
+ var effect = updateQueue = updateQueue.next;
+
+ do {
+ var destroy = effect.destroy;
+
+ if (void 0 !== destroy) {
+ var current$$1$jscomp$1 = current$$1$jscomp$0;
+
+ try {
+ destroy();
+ } catch (error) {
+ captureCommitPhaseError(current$$1$jscomp$1, error);
+ }
+ }
+
+ effect = effect.next;
+ } while (effect !== updateQueue);
+ }
+
+ break;
+
+ case 1:
+ safelyDetachRef(current$$1$jscomp$0);
+ updateQueue = current$$1$jscomp$0.stateNode;
+ if ("function" === typeof updateQueue.componentWillUnmount) try {
+ updateQueue.props = current$$1$jscomp$0.memoizedProps, updateQueue.state = current$$1$jscomp$0.memoizedState, updateQueue.componentWillUnmount();
+ } catch (unmountError) {
+ captureCommitPhaseError(current$$1$jscomp$0, unmountError);
+ }
+ break;
+
+ case 5:
+ safelyDetachRef(current$$1$jscomp$0);
+ break;
+
+ case 4:
+ FabricUIManager.createChildSet(current$$1$jscomp$0.stateNode.containerInfo);
+ }
+
+ if (null !== node.child) node.child.return = node, node = node.child;else {
+ if (node === current$$1) break;
+
+ for (; null === node.sibling;) {
+ if (null === node.return || node.return === current$$1) break a;
+ node = node.return;
+ }
+
+ node.sibling.return = node.return;
+ node = node.sibling;
+ }
+ }
+
+ effectTag.return = null;
+ effectTag.child = null;
+ effectTag.memoizedState = null;
+ effectTag.updateQueue = null;
+ effectTag = effectTag.alternate;
+ null !== effectTag && (effectTag.return = null, effectTag.child = null, effectTag.memoizedState = null, effectTag.updateQueue = null);
+ }
+
+ nextEffect = nextEffect.nextEffect;
+ }
+ }
+
+ function commitBeforeMutationLifecycles() {
+ for (; null !== nextEffect;) {
+ if (nextEffect.effectTag & 256) a: {
+ var current$$1 = nextEffect.alternate,
+ finishedWork = nextEffect;
+
+ switch (finishedWork.tag) {
+ case 0:
+ case 11:
+ case 15:
+ commitHookEffectList(UnmountSnapshot, NoEffect$1, finishedWork);
+ break a;
+
+ case 1:
+ if (finishedWork.effectTag & 256 && null !== current$$1) {
+ var prevProps = current$$1.memoizedProps,
+ prevState = current$$1.memoizedState;
+ current$$1 = finishedWork.stateNode;
+ finishedWork = current$$1.getSnapshotBeforeUpdate(finishedWork.elementType === finishedWork.type ? prevProps : resolveDefaultProps(finishedWork.type, prevProps), prevState);
+ current$$1.__reactInternalSnapshotBeforeUpdate = finishedWork;
+ }
+
+ break a;
+
+ case 3:
+ case 5:
+ case 6:
+ case 4:
+ case 17:
+ break a;
+
+ 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;
+ }
+ }
+
+ function commitAllLifeCycles(finishedRoot, committedExpirationTime$jscomp$0) {
+ for (; null !== nextEffect;) {
+ var effectTag = nextEffect.effectTag;
+
+ if (effectTag & 36) {
+ var current$$1 = nextEffect.alternate,
+ finishedWork = nextEffect,
+ committedExpirationTime = committedExpirationTime$jscomp$0;
+
+ switch (finishedWork.tag) {
+ case 0:
+ case 11:
+ case 15:
+ commitHookEffectList(UnmountLayout, MountLayout, finishedWork);
+ break;
+
+ case 1:
+ var instance = finishedWork.stateNode;
+ if (finishedWork.effectTag & 4) if (null === current$$1) instance.componentDidMount();else {
+ var prevProps = finishedWork.elementType === finishedWork.type ? current$$1.memoizedProps : resolveDefaultProps(finishedWork.type, current$$1.memoizedProps);
+ instance.componentDidUpdate(prevProps, current$$1.memoizedState, instance.__reactInternalSnapshotBeforeUpdate);
+ }
+ current$$1 = finishedWork.updateQueue;
+ null !== current$$1 && commitUpdateQueue(finishedWork, current$$1, instance, committedExpirationTime);
+ break;
+
+ case 3:
+ instance = finishedWork.updateQueue;
+
+ if (null !== instance) {
+ current$$1 = null;
+ if (null !== finishedWork.child) switch (finishedWork.child.tag) {
+ case 5:
+ current$$1 = finishedWork.child.stateNode.canonical;
+ break;
+
+ case 1:
+ current$$1 = finishedWork.child.stateNode;
+ }
+ commitUpdateQueue(finishedWork, instance, current$$1, committedExpirationTime);
+ }
+
+ break;
+
+ case 5:
+ null === current$$1 && finishedWork.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 12:
+ break;
+
+ case 13:
+ break;
+
+ case 17:
+ 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 & 128 && (finishedWork = nextEffect.ref, null !== finishedWork)) {
+ committedExpirationTime = nextEffect.stateNode;
+
+ switch (nextEffect.tag) {
+ case 5:
+ committedExpirationTime = committedExpirationTime.canonical;
+ }
+
+ "function" === typeof finishedWork ? finishedWork(committedExpirationTime) : finishedWork.current = committedExpirationTime;
+ }
+
+ effectTag & 512 && (rootWithPendingPassiveEffects = finishedRoot);
+ nextEffect = nextEffect.nextEffect;
+ }
+ }
+
+ function commitPassiveEffects(root, firstEffect) {
+ passiveEffectCallback = passiveEffectCallbackHandle = rootWithPendingPassiveEffects = null;
+ var previousIsRendering = isRendering;
+ isRendering = !0;
+
+ do {
+ if (firstEffect.effectTag & 512) {
+ var didError = !1,
+ error = void 0;
+
+ try {
+ var finishedWork = firstEffect;
+ commitHookEffectList(UnmountPassive, NoEffect$1, finishedWork);
+ commitHookEffectList(NoEffect$1, MountPassive, finishedWork);
+ } catch (e) {
+ didError = !0, error = e;
+ }
+
+ didError && captureCommitPhaseError(firstEffect, error);
+ }
+
+ firstEffect = firstEffect.nextEffect;
+ } while (null !== firstEffect);
+
+ isRendering = previousIsRendering;
+ previousIsRendering = root.expirationTime;
+ 0 !== previousIsRendering && requestWork(root, previousIsRendering);
+ isBatchingUpdates || isRendering || performWork(1073741823, !1);
+ }
+
+ function flushPassiveEffects() {
+ if (null !== passiveEffectCallbackHandle) {
+ var callbackID = passiveEffectCallbackHandle;
+ scheduledCallback = null;
+ clearTimeout(callbackID);
+ }
+
+ null !== passiveEffectCallback && passiveEffectCallback();
+ }
+
+ function commitRoot(root, finishedWork) {
+ isCommitting$1 = isWorking = !0;
+ 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(0 !== committedExpirationTime, "Cannot commit an incomplete root. This error is likely caused by a bug in React. Please file an issue.");
+ root.pendingCommitExpirationTime = 0;
+ var updateExpirationTimeBeforeCommit = finishedWork.expirationTime,
+ childExpirationTimeBeforeCommit = finishedWork.childExpirationTime;
+ markCommittedPriorityLevels(root, childExpirationTimeBeforeCommit > updateExpirationTimeBeforeCommit ? childExpirationTimeBeforeCommit : updateExpirationTimeBeforeCommit);
+ ReactCurrentOwner$2.current = null;
+ updateExpirationTimeBeforeCommit = void 0;
+ 1 < finishedWork.effectTag ? null !== finishedWork.lastEffect ? (finishedWork.lastEffect.nextEffect = finishedWork, updateExpirationTimeBeforeCommit = finishedWork.firstEffect) : updateExpirationTimeBeforeCommit = finishedWork : updateExpirationTimeBeforeCommit = finishedWork.firstEffect;
+
+ for (nextEffect = updateExpirationTimeBeforeCommit; null !== nextEffect;) {
+ childExpirationTimeBeforeCommit = !1;
+ var error = void 0;
+
+ try {
+ commitBeforeMutationLifecycles();
+ } catch (e) {
+ childExpirationTimeBeforeCommit = !0, error = e;
+ }
+
+ childExpirationTimeBeforeCommit && (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 = updateExpirationTimeBeforeCommit; null !== nextEffect;) {
+ childExpirationTimeBeforeCommit = !1;
+ error = void 0;
+
+ try {
+ commitAllHostEffects();
+ } catch (e) {
+ childExpirationTimeBeforeCommit = !0, error = e;
+ }
+
+ childExpirationTimeBeforeCommit && (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));
+ }
+
+ root.current = finishedWork;
+
+ for (nextEffect = updateExpirationTimeBeforeCommit; null !== nextEffect;) {
+ childExpirationTimeBeforeCommit = !1;
+ error = void 0;
+
+ try {
+ commitAllLifeCycles(root, committedExpirationTime);
+ } catch (e) {
+ childExpirationTimeBeforeCommit = !0, error = e;
+ }
+
+ childExpirationTimeBeforeCommit && (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));
+ }
+
+ if (null !== updateExpirationTimeBeforeCommit && null !== rootWithPendingPassiveEffects) {
+ var callback = commitPassiveEffects.bind(null, root, updateExpirationTimeBeforeCommit);
+ passiveEffectCallbackHandle = scheduler.unstable_runWithPriority(scheduler.unstable_NormalPriority, function () {
+ return scheduleDeferredCallback$1(callback);
+ });
+ passiveEffectCallback = callback;
+ }
+
+ isWorking = isCommitting$1 = !1;
+ "function" === typeof onCommitFiberRoot && onCommitFiberRoot(finishedWork.stateNode);
+ committedExpirationTime = finishedWork.expirationTime;
+ finishedWork = finishedWork.childExpirationTime;
+ finishedWork = finishedWork > committedExpirationTime ? finishedWork : committedExpirationTime;
+ 0 === finishedWork && (legacyErrorBoundariesThatAlreadyFailed = null);
+ onCommit(root, finishedWork);
+ }
+
+ function completeUnitOfWork(workInProgress) {
+ for (;;) {
+ var current$$1 = workInProgress.alternate,
+ returnFiber = workInProgress.return,
+ siblingFiber = workInProgress.sibling;
+
+ if (0 === (workInProgress.effectTag & 1024)) {
+ nextUnitOfWork = workInProgress;
+
+ a: {
+ var current = current$$1;
+ current$$1 = workInProgress;
+ var renderExpirationTime = nextRenderExpirationTime;
+ var instance = current$$1.pendingProps;
+
+ switch (current$$1.tag) {
+ case 2:
+ break;
+
+ case 16:
+ break;
+
+ case 15:
+ case 0:
+ break;
+
+ case 1:
+ isContextProvider(current$$1.type) && popContext(current$$1);
+ break;
+
+ case 3:
+ popHostContainer(current$$1);
+ popTopLevelContextObject(current$$1);
+ instance = current$$1.stateNode;
+ instance.pendingContext && (instance.context = instance.pendingContext, instance.pendingContext = null);
+ if (null === current || null === current.child) current$$1.effectTag &= -3;
+ updateHostContainer(current$$1);
+ break;
+
+ case 5:
+ popHostContext(current$$1);
+ renderExpirationTime = requiredContext(rootInstanceStackCursor.current);
+ var type = current$$1.type;
+ if (null !== current && null != current$$1.stateNode) updateHostComponent$1(current, current$$1, type, instance, renderExpirationTime), current.ref !== current$$1.ref && (current$$1.effectTag |= 128);else if (instance) {
+ var currentHostContext = requiredContext(contextStackCursor$1.current),
+ internalInstanceHandle = current$$1;
+ current = nextReactTag;
+ nextReactTag += 2;
+ var viewConfig = ReactNativeViewConfigRegistry.get(type);
+ invariant("RCTView" !== type || !currentHostContext.isInAParentText, "Nesting of within is not currently supported.");
+ type = diffProperties(null, emptyObject, instance, viewConfig.validAttributes);
+ renderExpirationTime = FabricUIManager.createNode(current, viewConfig.uiViewClassName, renderExpirationTime, type, internalInstanceHandle);
+ instance = new ReactFabricHostComponent(current, viewConfig, instance);
+ instance = {
+ node: renderExpirationTime,
+ canonical: instance
+ };
+
+ _appendAllChildren(instance, current$$1, !1, !1);
+
+ current$$1.stateNode = instance;
+ null !== current$$1.ref && (current$$1.effectTag |= 128);
+ } else invariant(null !== current$$1.stateNode, "We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue.");
+ break;
+
+ case 6:
+ current && null != current$$1.stateNode ? updateHostText$1(current, current$$1, current.memoizedProps, instance) : ("string" !== typeof instance && invariant(null !== current$$1.stateNode, "We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue."), current = requiredContext(rootInstanceStackCursor.current), renderExpirationTime = requiredContext(contextStackCursor$1.current), current$$1.stateNode = createTextInstance(instance, current, renderExpirationTime, current$$1));
+ break;
+
+ case 11:
+ break;
+
+ case 13:
+ instance = current$$1.memoizedState;
+
+ if (0 !== (current$$1.effectTag & 64)) {
+ current$$1.expirationTime = renderExpirationTime;
+ nextUnitOfWork = current$$1;
+ break a;
+ }
+
+ instance = null !== instance;
+ renderExpirationTime = null !== current && null !== current.memoizedState;
+ null !== current && !instance && renderExpirationTime && (current = current.child.sibling, null !== current && (viewConfig = current$$1.firstEffect, null !== viewConfig ? (current$$1.firstEffect = current, current.nextEffect = viewConfig) : (current$$1.firstEffect = current$$1.lastEffect = current, current.nextEffect = null), current.effectTag = 8));
+ if (instance || renderExpirationTime) current$$1.effectTag |= 4;
+ break;
+
+ case 7:
+ break;
+
+ case 8:
+ break;
+
+ case 12:
+ break;
+
+ case 4:
+ popHostContainer(current$$1);
+ updateHostContainer(current$$1);
+ break;
+
+ case 10:
+ popProvider(current$$1);
+ break;
+
+ case 9:
+ break;
+
+ case 14:
+ break;
+
+ case 17:
+ isContextProvider(current$$1.type) && popContext(current$$1);
+ break;
+
+ case 18:
+ break;
+
+ default:
+ invariant(!1, "Unknown unit of work tag. This error is likely caused by a bug in React. Please file an issue.");
+ }
+
+ nextUnitOfWork = null;
+ }
+
+ current$$1 = workInProgress;
+
+ if (1 === nextRenderExpirationTime || 1 !== current$$1.childExpirationTime) {
+ instance = 0;
+
+ for (current = current$$1.child; null !== current;) {
+ renderExpirationTime = current.expirationTime, viewConfig = current.childExpirationTime, renderExpirationTime > instance && (instance = renderExpirationTime), viewConfig > instance && (instance = viewConfig), current = current.sibling;
+ }
+
+ current$$1.childExpirationTime = instance;
+ }
+
+ if (null !== nextUnitOfWork) return nextUnitOfWork;
+ null !== returnFiber && 0 === (returnFiber.effectTag & 1024) && (null === returnFiber.firstEffect && (returnFiber.firstEffect = workInProgress.firstEffect), null !== workInProgress.lastEffect && (null !== returnFiber.lastEffect && (returnFiber.lastEffect.nextEffect = workInProgress.firstEffect), returnFiber.lastEffect = workInProgress.lastEffect), 1 < workInProgress.effectTag && (null !== returnFiber.lastEffect ? returnFiber.lastEffect.nextEffect = workInProgress : returnFiber.firstEffect = workInProgress, returnFiber.lastEffect = workInProgress));
+ } else {
+ workInProgress = unwindWork(workInProgress, nextRenderExpirationTime);
+ if (null !== workInProgress) return workInProgress.effectTag &= 1023, workInProgress;
+ null !== returnFiber && (returnFiber.firstEffect = returnFiber.lastEffect = null, returnFiber.effectTag |= 1024);
+ }
+
+ if (null !== siblingFiber) return siblingFiber;
+ if (null !== returnFiber) workInProgress = returnFiber;else break;
+ }
+
+ return null;
+ }
+
+ function performUnitOfWork(workInProgress) {
+ var next = beginWork(workInProgress.alternate, workInProgress, nextRenderExpirationTime);
+ workInProgress.memoizedProps = workInProgress.pendingProps;
+ null === next && (next = completeUnitOfWork(workInProgress));
+ ReactCurrentOwner$2.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.");
+ flushPassiveEffects();
+ isWorking = !0;
+ var previousDispatcher = ReactCurrentDispatcher.current;
+ ReactCurrentDispatcher.current = ContextOnlyDispatcher;
+ var expirationTime = root$jscomp$0.nextExpirationTimeToWorkOn;
+ if (expirationTime !== nextRenderExpirationTime || root$jscomp$0 !== nextRoot || null === nextUnitOfWork) resetStack(), nextRoot = root$jscomp$0, nextRenderExpirationTime = expirationTime, nextUnitOfWork = createWorkInProgress(nextRoot.current, null, nextRenderExpirationTime), root$jscomp$0.pendingCommitExpirationTime = 0;
+ var didFatal = !1;
+
+ do {
+ try {
+ if (isYieldy) for (; null !== nextUnitOfWork && !(frameDeadline <= now$1());) {
+ nextUnitOfWork = performUnitOfWork(nextUnitOfWork);
+ } else for (; null !== nextUnitOfWork;) {
+ nextUnitOfWork = performUnitOfWork(nextUnitOfWork);
+ }
+ } catch (thrownValue) {
+ if (lastContextWithAllBitsObserved = lastContextDependency = currentlyRenderingFiber = null, resetHooks(), 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.");
+ var sourceFiber = nextUnitOfWork,
+ returnFiber = sourceFiber.return;
+ if (null === returnFiber) didFatal = !0, onUncaughtError(thrownValue);else {
+ a: {
+ var root = root$jscomp$0,
+ returnFiber$jscomp$0 = returnFiber,
+ sourceFiber$jscomp$0 = sourceFiber,
+ value = thrownValue;
+ returnFiber = nextRenderExpirationTime;
+ sourceFiber$jscomp$0.effectTag |= 1024;
+ sourceFiber$jscomp$0.firstEffect = sourceFiber$jscomp$0.lastEffect = null;
+
+ if (null !== value && "object" === typeof value && "function" === typeof value.then) {
+ var thenable = value;
+ value = returnFiber$jscomp$0;
+ var earliestTimeoutMs = -1,
+ startTimeMs = -1;
+
+ do {
+ if (13 === value.tag) {
+ var current$$1 = value.alternate;
+
+ if (null !== current$$1 && (current$$1 = current$$1.memoizedState, null !== current$$1)) {
+ startTimeMs = 10 * (1073741822 - current$$1.timedOutAt);
+ break;
+ }
+
+ current$$1 = value.pendingProps.maxDuration;
+ if ("number" === typeof current$$1) if (0 >= current$$1) earliestTimeoutMs = 0;else if (-1 === earliestTimeoutMs || current$$1 < earliestTimeoutMs) earliestTimeoutMs = current$$1;
+ }
+
+ value = value.return;
+ } while (null !== value);
+
+ value = returnFiber$jscomp$0;
+
+ do {
+ if (current$$1 = 13 === value.tag) current$$1 = void 0 === value.memoizedProps.fallback ? !1 : null === value.memoizedState;
+
+ if (current$$1) {
+ returnFiber$jscomp$0 = value.updateQueue;
+ null === returnFiber$jscomp$0 ? (returnFiber$jscomp$0 = new Set(), returnFiber$jscomp$0.add(thenable), value.updateQueue = returnFiber$jscomp$0) : returnFiber$jscomp$0.add(thenable);
+
+ if (0 === (value.mode & 1)) {
+ value.effectTag |= 64;
+ sourceFiber$jscomp$0.effectTag &= -1957;
+ 1 === sourceFiber$jscomp$0.tag && (null === sourceFiber$jscomp$0.alternate ? sourceFiber$jscomp$0.tag = 17 : (returnFiber = createUpdate(1073741823), returnFiber.tag = ForceUpdate, enqueueUpdate(sourceFiber$jscomp$0, returnFiber)));
+ sourceFiber$jscomp$0.expirationTime = 1073741823;
+ break a;
+ }
+
+ sourceFiber$jscomp$0 = root;
+ returnFiber$jscomp$0 = returnFiber;
+ var pingCache = sourceFiber$jscomp$0.pingCache;
+ null === pingCache ? (pingCache = sourceFiber$jscomp$0.pingCache = new PossiblyWeakMap(), current$$1 = new Set(), pingCache.set(thenable, current$$1)) : (current$$1 = pingCache.get(thenable), void 0 === current$$1 && (current$$1 = new Set(), pingCache.set(thenable, current$$1)));
+ current$$1.has(returnFiber$jscomp$0) || (current$$1.add(returnFiber$jscomp$0), sourceFiber$jscomp$0 = pingSuspendedRoot.bind(null, sourceFiber$jscomp$0, thenable, returnFiber$jscomp$0), thenable.then(sourceFiber$jscomp$0, sourceFiber$jscomp$0));
+ -1 === earliestTimeoutMs ? root = 1073741823 : (-1 === startTimeMs && (startTimeMs = 10 * (1073741822 - findEarliestOutstandingPriorityLevel(root, returnFiber)) - 5e3), root = startTimeMs + earliestTimeoutMs);
+ 0 <= root && nextLatestAbsoluteTimeoutMs < root && (nextLatestAbsoluteTimeoutMs = root);
+ value.effectTag |= 2048;
+ value.expirationTime = returnFiber;
+ break a;
+ }
+
+ value = value.return;
+ } while (null !== value);
+
+ value = Error((getComponentName(sourceFiber$jscomp$0.type) || "A React component") + " suspended while rendering, but no fallback UI was specified.\n\nAdd a component higher in the tree to provide a loading indicator or placeholder to display." + getStackByFiberInDevAndProd(sourceFiber$jscomp$0));
+ }
+
+ nextRenderDidError = !0;
+ value = createCapturedValue(value, sourceFiber$jscomp$0);
+ root = returnFiber$jscomp$0;
+
+ do {
+ switch (root.tag) {
+ case 3:
+ root.effectTag |= 2048;
+ root.expirationTime = returnFiber;
+ returnFiber = createRootErrorUpdate(root, value, returnFiber);
+ enqueueCapturedUpdate(root, returnFiber);
+ break a;
+
+ case 1:
+ if (earliestTimeoutMs = value, startTimeMs = root.type, sourceFiber$jscomp$0 = root.stateNode, 0 === (root.effectTag & 64) && ("function" === typeof startTimeMs.getDerivedStateFromError || null !== sourceFiber$jscomp$0 && "function" === typeof sourceFiber$jscomp$0.componentDidCatch && (null === legacyErrorBoundariesThatAlreadyFailed || !legacyErrorBoundariesThatAlreadyFailed.has(sourceFiber$jscomp$0)))) {
+ root.effectTag |= 2048;
+ root.expirationTime = returnFiber;
+ returnFiber = createClassErrorUpdate(root, earliestTimeoutMs, returnFiber);
+ enqueueCapturedUpdate(root, returnFiber);
+ break a;
+ }
+
+ }
+
+ root = root.return;
+ } while (null !== root);
+ }
+
+ nextUnitOfWork = completeUnitOfWork(sourceFiber);
+ continue;
+ }
+ }
+ }
+
+ break;
+ } while (1);
+
+ isWorking = !1;
+ ReactCurrentDispatcher.current = previousDispatcher;
+ lastContextWithAllBitsObserved = lastContextDependency = currentlyRenderingFiber = null;
+ resetHooks();
+ if (didFatal) nextRoot = null, root$jscomp$0.finishedWork = null;else if (null !== nextUnitOfWork) root$jscomp$0.finishedWork = null;else {
+ previousDispatcher = root$jscomp$0.current.alternate;
+ invariant(null !== previousDispatcher, "Finished root should have a work-in-progress. This error is likely caused by a bug in React. Please file an issue.");
+ nextRoot = null;
+
+ if (nextRenderDidError) {
+ didFatal = root$jscomp$0.latestPendingTime;
+ sourceFiber = root$jscomp$0.latestSuspendedTime;
+ returnFiber = root$jscomp$0.latestPingedTime;
+
+ if (0 !== didFatal && didFatal < expirationTime || 0 !== sourceFiber && sourceFiber < expirationTime || 0 !== returnFiber && returnFiber < expirationTime) {
+ markSuspendedPriorityLevel(root$jscomp$0, expirationTime);
+ onSuspend(root$jscomp$0, previousDispatcher, expirationTime, root$jscomp$0.expirationTime, -1);
+ return;
+ }
+
+ if (!root$jscomp$0.didError && isYieldy) {
+ root$jscomp$0.didError = !0;
+ expirationTime = root$jscomp$0.nextExpirationTimeToWorkOn = expirationTime;
+ isYieldy = root$jscomp$0.expirationTime = 1073741823;
+ onSuspend(root$jscomp$0, previousDispatcher, expirationTime, isYieldy, -1);
+ return;
+ }
+ }
+
+ isYieldy && -1 !== nextLatestAbsoluteTimeoutMs ? (markSuspendedPriorityLevel(root$jscomp$0, expirationTime), isYieldy = 10 * (1073741822 - findEarliestOutstandingPriorityLevel(root$jscomp$0, expirationTime)), isYieldy < nextLatestAbsoluteTimeoutMs && (nextLatestAbsoluteTimeoutMs = isYieldy), isYieldy = 10 * (1073741822 - requestCurrentTime()), isYieldy = nextLatestAbsoluteTimeoutMs - isYieldy, onSuspend(root$jscomp$0, previousDispatcher, expirationTime, root$jscomp$0.expirationTime, 0 > isYieldy ? 0 : isYieldy)) : (root$jscomp$0.pendingCommitExpirationTime = expirationTime, root$jscomp$0.finishedWork = previousDispatcher);
+ }
+ }
+
+ function captureCommitPhaseError(sourceFiber, value) {
+ for (var fiber = sourceFiber.return; null !== fiber;) {
+ switch (fiber.tag) {
+ case 1:
+ var instance = fiber.stateNode;
+
+ if ("function" === typeof fiber.type.getDerivedStateFromError || "function" === typeof instance.componentDidCatch && (null === legacyErrorBoundariesThatAlreadyFailed || !legacyErrorBoundariesThatAlreadyFailed.has(instance))) {
+ sourceFiber = createCapturedValue(value, sourceFiber);
+ sourceFiber = createClassErrorUpdate(fiber, sourceFiber, 1073741823);
+ enqueueUpdate(fiber, sourceFiber);
+ scheduleWork(fiber, 1073741823);
+ return;
+ }
+
+ break;
+
+ case 3:
+ sourceFiber = createCapturedValue(value, sourceFiber);
+ sourceFiber = createRootErrorUpdate(fiber, sourceFiber, 1073741823);
+ enqueueUpdate(fiber, sourceFiber);
+ scheduleWork(fiber, 1073741823);
+ return;
+ }
+
+ fiber = fiber.return;
+ }
+
+ 3 === sourceFiber.tag && (fiber = createCapturedValue(value, sourceFiber), fiber = createRootErrorUpdate(sourceFiber, fiber, 1073741823), enqueueUpdate(sourceFiber, fiber), scheduleWork(sourceFiber, 1073741823));
+ }
+
+ function computeExpirationForFiber(currentTime, fiber) {
+ var priorityLevel = scheduler.unstable_getCurrentPriorityLevel(),
+ expirationTime = void 0;
+ if (0 === (fiber.mode & 1)) expirationTime = 1073741823;else if (isWorking && !isCommitting$1) expirationTime = nextRenderExpirationTime;else {
+ switch (priorityLevel) {
+ case scheduler.unstable_ImmediatePriority:
+ expirationTime = 1073741823;
+ break;
+
+ case scheduler.unstable_UserBlockingPriority:
+ expirationTime = 1073741822 - 10 * (((1073741822 - currentTime + 15) / 10 | 0) + 1);
+ break;
+
+ case scheduler.unstable_NormalPriority:
+ expirationTime = 1073741822 - 25 * (((1073741822 - currentTime + 500) / 25 | 0) + 1);
+ break;
+
+ case scheduler.unstable_LowPriority:
+ case scheduler.unstable_IdlePriority:
+ expirationTime = 1;
+ break;
+
+ default:
+ invariant(!1, "Unknown priority level. This error is likely caused by a bug in React. Please file an issue.");
+ }
+
+ null !== nextRoot && expirationTime === nextRenderExpirationTime && --expirationTime;
+ }
+ priorityLevel === scheduler.unstable_UserBlockingPriority && (0 === lowestPriorityPendingInteractiveExpirationTime || expirationTime < lowestPriorityPendingInteractiveExpirationTime) && (lowestPriorityPendingInteractiveExpirationTime = expirationTime);
+ return expirationTime;
+ }
+
+ function pingSuspendedRoot(root, thenable, pingTime) {
+ var pingCache = root.pingCache;
+ null !== pingCache && pingCache.delete(thenable);
+ if (null !== nextRoot && nextRenderExpirationTime === pingTime) nextRoot = null;else if (thenable = root.earliestSuspendedTime, pingCache = root.latestSuspendedTime, 0 !== thenable && pingTime <= thenable && pingTime >= pingCache) {
+ root.didError = !1;
+ thenable = root.latestPingedTime;
+ if (0 === thenable || thenable > pingTime) root.latestPingedTime = pingTime;
+ findNextExpirationTimeToWorkOn(pingTime, root);
+ pingTime = root.expirationTime;
+ 0 !== pingTime && requestWork(root, pingTime);
+ }
+ }
+
+ function scheduleWork(fiber, expirationTime) {
+ fiber.expirationTime < expirationTime && (fiber.expirationTime = expirationTime);
+ var alternate = fiber.alternate;
+ null !== alternate && alternate.expirationTime < expirationTime && (alternate.expirationTime = expirationTime);
+ var node = fiber.return,
+ root = null;
+ if (null === node && 3 === fiber.tag) root = fiber.stateNode;else for (; null !== node;) {
+ alternate = node.alternate;
+ node.childExpirationTime < expirationTime && (node.childExpirationTime = expirationTime);
+ null !== alternate && alternate.childExpirationTime < expirationTime && (alternate.childExpirationTime = expirationTime);
+
+ if (null === node.return && 3 === node.tag) {
+ root = node.stateNode;
+ break;
+ }
+
+ node = node.return;
+ }
+ fiber = root;
+ null !== fiber && (!isWorking && 0 !== nextRenderExpirationTime && expirationTime > nextRenderExpirationTime && resetStack(), markPendingPriorityLevel(fiber, expirationTime), isWorking && !isCommitting$1 && nextRoot === fiber || requestWork(fiber, fiber.expirationTime), nestedUpdateCount > NESTED_UPDATE_LIMIT && (nestedUpdateCount = 0, 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.")));
+ }
+
+ var firstScheduledRoot = null,
+ lastScheduledRoot = null,
+ callbackExpirationTime = 0,
+ callbackID = void 0,
+ isRendering = !1,
+ nextFlushedRoot = null,
+ nextFlushedExpirationTime = 0,
+ lowestPriorityPendingInteractiveExpirationTime = 0,
+ hasUnhandledError = !1,
+ unhandledError = null,
+ isBatchingUpdates = !1,
+ isUnbatchingUpdates = !1,
+ completedBatches = null,
+ originalStartTimeMs = now$1(),
+ currentRendererTime = 1073741822 - (originalStartTimeMs / 10 | 0),
+ currentSchedulerTime = currentRendererTime,
+ NESTED_UPDATE_LIMIT = 50,
+ nestedUpdateCount = 0,
+ lastCommittedRootDuringThisBatch = null;
+
+ function recomputeCurrentRendererTime() {
+ currentRendererTime = 1073741822 - ((now$1() - originalStartTimeMs) / 10 | 0);
+ }
+
+ function scheduleCallbackWithExpirationTime(root, expirationTime) {
+ if (0 !== callbackExpirationTime) {
+ if (expirationTime < callbackExpirationTime) return;
+ null !== callbackID && (root = callbackID, scheduledCallback = null, clearTimeout(root));
+ }
+
+ callbackExpirationTime = expirationTime;
+ root = now$1() - originalStartTimeMs;
+ callbackID = scheduleDeferredCallback$1(performAsyncWork, {
+ timeout: 10 * (1073741822 - expirationTime) - root
+ });
+ }
+
+ function onSuspend(root, finishedWork, suspendedExpirationTime, rootExpirationTime, msUntilTimeout) {
+ root.expirationTime = rootExpirationTime;
+ 0 !== msUntilTimeout || frameDeadline <= now$1() ? 0 < msUntilTimeout && (root.timeoutHandle = scheduleTimeout(onTimeout.bind(null, root, finishedWork, suspendedExpirationTime), msUntilTimeout)) : (root.pendingCommitExpirationTime = suspendedExpirationTime, root.finishedWork = finishedWork);
+ }
+
+ function onTimeout(root, finishedWork, suspendedExpirationTime) {
+ root.pendingCommitExpirationTime = suspendedExpirationTime;
+ root.finishedWork = finishedWork;
+ recomputeCurrentRendererTime();
+ currentSchedulerTime = currentRendererTime;
+ invariant(!isRendering, "work.commit(): Cannot commit while already rendering. This likely means you attempted to commit from inside a lifecycle method.");
+ nextFlushedRoot = root;
+ nextFlushedExpirationTime = suspendedExpirationTime;
+ performWorkOnRoot(root, suspendedExpirationTime, !1);
+ performWork(1073741823, !1);
+ }
+
+ function onCommit(root, expirationTime) {
+ root.expirationTime = expirationTime;
+ root.finishedWork = null;
+ }
+
+ function requestCurrentTime() {
+ if (isRendering) return currentSchedulerTime;
+ findHighestPriorityRoot();
+ if (0 === nextFlushedExpirationTime || 1 === nextFlushedExpirationTime) recomputeCurrentRendererTime(), currentSchedulerTime = currentRendererTime;
+ return currentSchedulerTime;
+ }
+
+ function requestWork(root, expirationTime) {
+ null === root.nextScheduledRoot ? (root.expirationTime = expirationTime, null === lastScheduledRoot ? (firstScheduledRoot = lastScheduledRoot = root, root.nextScheduledRoot = root) : (lastScheduledRoot = lastScheduledRoot.nextScheduledRoot = root, lastScheduledRoot.nextScheduledRoot = firstScheduledRoot)) : expirationTime > root.expirationTime && (root.expirationTime = expirationTime);
+ isRendering || (isBatchingUpdates ? isUnbatchingUpdates && (nextFlushedRoot = root, nextFlushedExpirationTime = 1073741823, performWorkOnRoot(root, 1073741823, !1)) : 1073741823 === expirationTime ? performWork(1073741823, !1) : scheduleCallbackWithExpirationTime(root, 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 {
+ remainingExpirationTime > highestPriorityWork && (highestPriorityWork = remainingExpirationTime, highestPriorityRoot = root);
+ if (root === lastScheduledRoot) break;
+ if (1073741823 === highestPriorityWork) break;
+ previousScheduledRoot = root;
+ root = root.nextScheduledRoot;
+ }
+ }
+ nextFlushedRoot = highestPriorityRoot;
+ nextFlushedExpirationTime = highestPriorityWork;
+ }
+
+ function performAsyncWork(didTimeout) {
+ if (didTimeout && null !== firstScheduledRoot) {
+ recomputeCurrentRendererTime();
+ didTimeout = firstScheduledRoot;
+
+ do {
+ var expirationTime = didTimeout.expirationTime;
+ 0 !== expirationTime && currentRendererTime <= expirationTime && (didTimeout.nextExpirationTimeToWorkOn = currentRendererTime);
+ didTimeout = didTimeout.nextScheduledRoot;
+ } while (didTimeout !== firstScheduledRoot);
+ }
+
+ performWork(0, !0);
+ }
+
+ function performWork(minExpirationTime, isYieldy) {
+ findHighestPriorityRoot();
+ if (isYieldy) for (recomputeCurrentRendererTime(), currentSchedulerTime = currentRendererTime; null !== nextFlushedRoot && 0 !== nextFlushedExpirationTime && minExpirationTime <= nextFlushedExpirationTime && !(frameDeadline <= now$1() && currentRendererTime > nextFlushedExpirationTime);) {
+ performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, currentRendererTime > nextFlushedExpirationTime), findHighestPriorityRoot(), recomputeCurrentRendererTime(), currentSchedulerTime = currentRendererTime;
+ } else for (; null !== nextFlushedRoot && 0 !== nextFlushedExpirationTime && minExpirationTime <= nextFlushedExpirationTime;) {
+ performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, !1), findHighestPriorityRoot();
+ }
+ isYieldy && (callbackExpirationTime = 0, callbackID = null);
+ 0 !== nextFlushedExpirationTime && scheduleCallbackWithExpirationTime(nextFlushedRoot, nextFlushedExpirationTime);
+ nestedUpdateCount = 0;
+ lastCommittedRootDuringThisBatch = null;
+ if (null !== completedBatches) for (minExpirationTime = completedBatches, completedBatches = null, isYieldy = 0; isYieldy < minExpirationTime.length; isYieldy++) {
+ var batch = minExpirationTime[isYieldy];
+
+ try {
+ batch._onComplete();
+ } catch (error) {
+ hasUnhandledError || (hasUnhandledError = !0, unhandledError = error);
+ }
+ }
+ if (hasUnhandledError) throw minExpirationTime = unhandledError, unhandledError = null, hasUnhandledError = !1, minExpirationTime;
+ }
+
+ 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;
+
+ if (isYieldy) {
+ var _finishedWork = root.finishedWork;
+ null !== _finishedWork ? completeRoot$1(root, _finishedWork, expirationTime) : (root.finishedWork = null, _finishedWork = root.timeoutHandle, -1 !== _finishedWork && (root.timeoutHandle = -1, cancelTimeout(_finishedWork)), renderRoot(root, isYieldy), _finishedWork = root.finishedWork, null !== _finishedWork && (frameDeadline <= now$1() ? root.finishedWork = _finishedWork : completeRoot$1(root, _finishedWork, expirationTime)));
+ } else _finishedWork = root.finishedWork, null !== _finishedWork ? completeRoot$1(root, _finishedWork, expirationTime) : (root.finishedWork = null, _finishedWork = root.timeoutHandle, -1 !== _finishedWork && (root.timeoutHandle = -1, cancelTimeout(_finishedWork)), renderRoot(root, isYieldy), _finishedWork = root.finishedWork, null !== _finishedWork && completeRoot$1(root, _finishedWork, expirationTime));
+
+ isRendering = !1;
+ }
+
+ function completeRoot$1(root, finishedWork, expirationTime) {
+ var firstBatch = root.firstBatch;
+
+ if (null !== firstBatch && firstBatch._expirationTime >= expirationTime && (null === completedBatches ? completedBatches = [firstBatch] : completedBatches.push(firstBatch), firstBatch._defer)) {
+ root.finishedWork = finishedWork;
+ root.expirationTime = 0;
+ return;
+ }
+
+ root.finishedWork = null;
+ root === lastCommittedRootDuringThisBatch ? nestedUpdateCount++ : (lastCommittedRootDuringThisBatch = root, nestedUpdateCount = 0);
+ scheduler.unstable_runWithPriority(scheduler.unstable_ImmediatePriority, function () {
+ commitRoot(root, finishedWork);
+ });
+ }
+
+ 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 findHostInstance(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$$1 = container.current,
+ currentTime = requestCurrentTime();
+ current$$1 = computeExpirationForFiber(currentTime, current$$1);
+ currentTime = container.current;
+
+ a: if (parentComponent) {
+ parentComponent = parentComponent._reactInternalFiber;
+
+ b: {
+ invariant(2 === isFiberMountedImpl(parentComponent) && 1 === 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.");
+ var parentContext = parentComponent;
+
+ do {
+ switch (parentContext.tag) {
+ case 3:
+ parentContext = parentContext.stateNode.context;
+ break b;
+
+ case 1:
+ if (isContextProvider(parentContext.type)) {
+ parentContext = parentContext.stateNode.__reactInternalMemoizedMergedChildContext;
+ break b;
+ }
+
+ }
+
+ parentContext = parentContext.return;
+ } while (null !== parentContext);
+
+ invariant(!1, "Found unexpected detached subtree parent. This error is likely caused by a bug in React. Please file an issue.");
+ parentContext = void 0;
+ }
+
+ if (1 === parentComponent.tag) {
+ var Component = parentComponent.type;
+
+ if (isContextProvider(Component)) {
+ parentComponent = processChildContext(parentComponent, Component, parentContext);
+ break a;
+ }
+ }
+
+ parentComponent = parentContext;
+ } else parentComponent = emptyContextObject;
+
+ null === container.context ? container.context = parentComponent : container.pendingContext = parentComponent;
+ container = callback;
+ callback = createUpdate(current$$1);
+ callback.payload = {
+ element: element
+ };
+ container = void 0 === container ? null : container;
+ null !== container && (callback.callback = container);
+ flushPassiveEffects();
+ enqueueUpdate(currentTime, callback);
+ scheduleWork(currentTime, current$$1);
+ return current$$1;
+ }
+
+ function _createPortal(children, containerInfo, implementation) {
+ var key = 3 < arguments.length && void 0 !== arguments[3] ? arguments[3] : null;
+ return {
+ $$typeof: REACT_PORTAL_TYPE,
+ key: null == key ? null : "" + key,
+ children: children,
+ containerInfo: containerInfo,
+ implementation: implementation
+ };
+ }
+
+ function _inherits(subClass, superClass) {
+ if ("function" !== typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+ subClass.prototype = Object.create(superClass && superClass.prototype, {
+ constructor: {
+ value: subClass,
+ enumerable: !1,
+ writable: !0,
+ configurable: !0
+ }
+ });
+ superClass && (Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass);
+ }
+
+ var getInspectorDataForViewTag = void 0;
+
+ getInspectorDataForViewTag = function getInspectorDataForViewTag() {
+ 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(componentOrHandle);
+ return null == componentOrHandle ? componentOrHandle : componentOrHandle.canonical ? componentOrHandle.canonical._nativeTag : componentOrHandle._nativeTag;
+ }
+
+ _batchedUpdatesImpl = function _batchedUpdatesImpl(fn, a) {
+ var previousIsBatchingUpdates = isBatchingUpdates;
+ isBatchingUpdates = !0;
+
+ try {
+ return fn(a);
+ } finally {
+ (isBatchingUpdates = previousIsBatchingUpdates) || isRendering || performWork(1073741823, !1);
+ }
+ };
+
+ _flushInteractiveUpdatesImpl = function _flushInteractiveUpdatesImpl() {
+ isRendering || 0 === lowestPriorityPendingInteractiveExpirationTime || (performWork(lowestPriorityPendingInteractiveExpirationTime, !1), lowestPriorityPendingInteractiveExpirationTime = 0);
+ };
+
+ 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_NOT_REALLY_SAFE(this, callback));
+ };
+
+ ReactNativeComponent.prototype.measureInWindow = function (callback) {
+ UIManager.measureInWindow(findNodeHandle(this), mountSafeCallback_NOT_REALLY_SAFE(this, callback));
+ };
+
+ ReactNativeComponent.prototype.measureLayout = function (relativeToNativeNode, onSuccess, onFail) {
+ UIManager.measureLayout(findNodeHandle(this), relativeToNativeNode, mountSafeCallback_NOT_REALLY_SAFE(this, onFail), mountSafeCallback_NOT_REALLY_SAFE(this, onSuccess));
+ };
+
+ ReactNativeComponent.prototype.setNativeProps = function (nativeProps) {
+ var maybeInstance = void 0;
+
+ try {
+ maybeInstance = findHostInstance(this);
+ } catch (error) {}
+
+ if (null != maybeInstance) {
+ var nativeTag = maybeInstance._nativeTag || maybeInstance.canonical._nativeTag;
+ maybeInstance = maybeInstance.viewConfig || maybeInstance.canonical.viewConfig;
+ nativeProps = diffProperties(null, emptyObject, nativeProps, maybeInstance.validAttributes);
+ null != nativeProps && UIManager.updateView(nativeTag, maybeInstance.uiViewClassName, nativeProps);
+ }
+ };
+
+ return ReactNativeComponent;
+ }(React.Component);
+ }(findNodeHandle, findHostInstance),
+ findNodeHandle: findNodeHandle,
+ setNativeProps: function setNativeProps(handle, nativeProps) {
+ null != handle._nativeTag && (nativeProps = diffProperties(null, emptyObject, nativeProps, handle.viewConfig.validAttributes), null != nativeProps && UIManager.updateView(handle._nativeTag, handle.viewConfig.uiViewClassName, nativeProps));
+ },
+ render: function render(element, containerTag, callback) {
+ var root = roots.get(containerTag);
+
+ if (!root) {
+ root = createFiber(3, null, null, 0);
+ var root$jscomp$0 = {
+ current: root,
+ containerInfo: containerTag,
+ pendingChildren: null,
+ pingCache: null,
+ earliestPendingTime: 0,
+ latestPendingTime: 0,
+ earliestSuspendedTime: 0,
+ latestSuspendedTime: 0,
+ latestPingedTime: 0,
+ didError: !1,
+ pendingCommitExpirationTime: 0,
+ finishedWork: null,
+ timeoutHandle: -1,
+ context: null,
+ pendingContext: null,
+ hydrate: !1,
+ nextExpirationTimeToWorkOn: 0,
+ expirationTime: 0,
+ firstBatch: null,
+ nextScheduledRoot: null
+ };
+ root = root.stateNode = root$jscomp$0;
+ roots.set(containerTag, root);
+ }
+
+ updateContainer(element, root, null, callback);
+
+ a: if (element = root.current, element.child) switch (element.child.tag) {
+ case 5:
+ element = element.child.stateNode.canonical;
+ break a;
+
+ default:
+ element = element.child.stateNode;
+ } else element = null;
+
+ return element;
+ },
+ unmountComponentAtNode: function unmountComponentAtNode(containerTag) {
+ var root = roots.get(containerTag);
+ root && updateContainer(null, root, null, function () {
+ roots.delete(containerTag);
+ });
+ },
+ createPortal: function createPortal(children, containerTag) {
+ return _createPortal(children, containerTag, null, 2 < arguments.length && void 0 !== arguments[2] ? arguments[2] : null);
+ },
+ __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: {
+ NativeMethodsMixin: function (findNodeHandle, findHostInstance) {
+ return {
+ measure: function measure(callback) {
+ UIManager.measure(findNodeHandle(this), mountSafeCallback_NOT_REALLY_SAFE(this, callback));
+ },
+ measureInWindow: function measureInWindow(callback) {
+ UIManager.measureInWindow(findNodeHandle(this), mountSafeCallback_NOT_REALLY_SAFE(this, callback));
+ },
+ measureLayout: function measureLayout(relativeToNativeNode, onSuccess, onFail) {
+ UIManager.measureLayout(findNodeHandle(this), relativeToNativeNode, mountSafeCallback_NOT_REALLY_SAFE(this, onFail), mountSafeCallback_NOT_REALLY_SAFE(this, onSuccess));
+ },
+ setNativeProps: function setNativeProps(nativeProps) {
+ var maybeInstance = void 0;
+
+ try {
+ maybeInstance = findHostInstance(this);
+ } catch (error) {}
+
+ if (null != maybeInstance) {
+ var nativeTag = maybeInstance._nativeTag || maybeInstance.canonical._nativeTag;
+ maybeInstance = maybeInstance.viewConfig || maybeInstance.canonical.viewConfig;
+ nativeProps = diffProperties(null, emptyObject, nativeProps, maybeInstance.validAttributes);
+ null != nativeProps && UIManager.updateView(nativeTag, maybeInstance.uiViewClassName, nativeProps);
+ }
+ },
+ focus: function focus() {
+ TextInputState.focusTextInput(findNodeHandle(this));
+ },
+ blur: function blur() {
+ TextInputState.blurTextInput(findNodeHandle(this));
+ }
+ };
+ }(findNodeHandle, findHostInstance)
+ }
+ };
+
+ (function (devToolsConfig) {
+ var _findFiberByHostInstance = devToolsConfig.findFiberByHostInstance;
+ return injectInternals(_extends({}, devToolsConfig, {
+ overrideProps: null,
+ currentDispatcherRef: ReactSharedInternals.ReactCurrentDispatcher,
+ findHostInstanceByFiber: function findHostInstanceByFiber(fiber) {
+ fiber = findCurrentHostFiber(fiber);
+ return null === fiber ? null : fiber.stateNode;
+ },
+ findFiberByHostInstance: function findFiberByHostInstance(instance) {
+ return _findFiberByHostInstance ? _findFiberByHostInstance(instance) : null;
+ }
+ }));
+ })({
+ findFiberByHostInstance: getInstanceFromInstance,
+ getInspectorDataForViewTag: getInspectorDataForViewTag,
+ bundleType: 0,
+ version: "16.8.3",
+ rendererPackageName: "react-native-renderer"
+ });
+
+ var ReactFabric$2 = {
+ default: ReactFabric
+ },
+ ReactFabric$3 = ReactFabric$2 && ReactFabric || ReactFabric$2;
+ module.exports = ReactFabric$3.default || ReactFabric$3;
+},383,[14,86,173,71,11,175,80,176,382,180,98],"node_modules\\react-native\\Libraries\\Renderer\\oss\\ReactFabric-prod.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _slicedToArray = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/slicedToArray");
+
+ var NativeModules = _$$_REQUIRE(_dependencyMap[1], "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;
+},384,[37,36],"node_modules\\react-native\\Libraries\\Storage\\AsyncStorage.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var PropTypes = _$$_REQUIRE(_dependencyMap[2], "prop-types");
+
+ var checkPropTypes = PropTypes.checkPropTypes;
+
+ var RCTCameraRollManager = _$$_REQUIRE(_dependencyMap[3], "NativeModules").CameraRollManager;
+
+ var deprecatedCreateStrictShapeTypeChecker = _$$_REQUIRE(_dependencyMap[4], "deprecatedCreateStrictShapeTypeChecker");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[5], "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 = deprecatedCreateStrictShapeTypeChecker({
+ 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 = deprecatedCreateStrictShapeTypeChecker({
+ edges: PropTypes.arrayOf(deprecatedCreateStrictShapeTypeChecker({
+ node: deprecatedCreateStrictShapeTypeChecker({
+ type: PropTypes.string.isRequired,
+ group_name: PropTypes.string.isRequired,
+ image: deprecatedCreateStrictShapeTypeChecker({
+ 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: deprecatedCreateStrictShapeTypeChecker({
+ latitude: PropTypes.number,
+ longitude: PropTypes.number,
+ altitude: PropTypes.number,
+ heading: PropTypes.number,
+ speed: PropTypes.number
+ })
+ }).isRequired
+ })).isRequired,
+ page_info: deprecatedCreateStrictShapeTypeChecker({
+ 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;
+},385,[3,4,62,36,212,19],"node_modules\\react-native\\Libraries\\CameraRoll\\CameraRoll.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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);
+ }
+ };
+},386,[36],"node_modules\\react-native\\Libraries\\Components\\Clipboard\\Clipboard.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "UnimplementedView");
+},387,[196],"Libraries\\Components\\DatePickerAndroid\\DatePickerAndroid.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "UnimplementedView");
+},388,[196],"Libraries\\Components\\DatePickerMacOS\\DatePickerMacOS.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var RCTImagePicker = _$$_REQUIRE(_dependencyMap[1], "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;
+},389,[32,36],"node_modules\\react-native\\Libraries\\CameraRoll\\ImagePickerIOS.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");
+
+ var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");
+
+ var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");
+
+ var NativeEventEmitter = _$$_REQUIRE(_dependencyMap[5], "NativeEventEmitter");
+
+ var NativeModules = _$$_REQUIRE(_dependencyMap[6], "NativeModules");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[7], "Platform");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[8], "invariant");
+
+ var LinkingManager = Platform.OS === 'android' ? NativeModules.IntentAndroid : NativeModules.LinkingManager;
+
+ var Linking = function (_NativeEventEmitter) {
+ _inherits(Linking, _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: "sendIntent",
+ value: function sendIntent(action, extras) {
+ return LinkingManager.sendIntent(action, extras);
+ }
+ }, {
+ key: "_validateURL",
+ value: function _validateURL(url) {
+ invariant(typeof url === 'string', 'Invalid URL: should be a string. Was: ' + url);
+ invariant(url, 'Invalid URL: cannot be empty');
+ }
+ }]);
+
+ return Linking;
+ }(NativeEventEmitter);
+
+ module.exports = new Linking();
+},390,[3,4,5,8,9,131,36,35,19],"node_modules\\react-native\\Libraries\\Linking\\Linking.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var NativeEventEmitter = _$$_REQUIRE(_dependencyMap[0], "NativeEventEmitter");
+
+ var NativeModules = _$$_REQUIRE(_dependencyMap[1], "NativeModules");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[2], "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' || Platform.OS === 'macos') {
+ _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 only supported on android'));
+ }
+ };
+ module.exports = NetInfo;
+},391,[131,36,35],"node_modules\\react-native\\Libraries\\Network\\NetInfo.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");
+
+ var NativeEventEmitter = _$$_REQUIRE(_dependencyMap[2], "NativeEventEmitter");
+
+ var Platform = _$$_REQUIRE(_dependencyMap[3], "Platform");
+
+ var RCTPushNotificationManager = _$$_REQUIRE(_dependencyMap[4], "NativeModules").PushNotificationManager;
+
+ var invariant = _$$_REQUIRE(_dependencyMap[5], "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 || Platform.OS === 'macos') {
+ 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;
+},392,[3,4,131,35,36,19],"node_modules\\react-native\\Libraries\\PushNotificationIOS\\PushNotificationIOS.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var Settings = {
+ get: function get(key) {
+ console.warn('Settings is not yet supported on UWP');
+ return null;
+ },
+ set: function set(settings) {
+ console.warn('Settings is not yet supported on UWP');
+ },
+ watchKeys: function watchKeys(keys, callback) {
+ console.warn('Settings is not yet supported on UWP');
+ return -1;
+ },
+ clearWatch: function clearWatch(watchId) {
+ console.warn('Settings is not yet supported on UWP');
+ }
+ };
+ module.exports = Settings;
+},393,[],"Libraries\\Settings\\Settings.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");
+
+ var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");
+
+ var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");
+
+ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+ var Platform = _$$_REQUIRE(_dependencyMap[3], "Platform");
+
+ var invariant = _$$_REQUIRE(_dependencyMap[4], "invariant");
+
+ var processColor = _$$_REQUIRE(_dependencyMap[5], "processColor");
+
+ var _require = _$$_REQUIRE(_dependencyMap[6], "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;
+},394,[32,3,4,35,19,75,36],"node_modules\\react-native\\Libraries\\Share\\Share.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "UnimplementedView");
+},395,[196],"Libraries\\Components\\StatusBar\\StatusBarIOS.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "UnimplementedView");
+},396,[196],"Libraries\\Components\\TimePickerAndroid\\TimePickerAndroid.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "UnimplementedView");
+},397,[196],"Libraries\\Components\\ToastAndroid\\ToastAndroid.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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;
+},398,[36,35],"node_modules\\react-native\\Libraries\\Vibration\\Vibration.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ module.exports = _$$_REQUIRE(_dependencyMap[0], "UnimplementedView");
+},399,[196],"Libraries\\Vibration\\VibrationIOS.uwp.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, 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);
+ };
+},400,[84,71],"node_modules\\react-native\\Libraries\\ReactNative\\takeSnapshot.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ 'use strict';
+
+ var PropTypes = _$$_REQUIRE(_dependencyMap[0], "prop-types");
+
+ var PointPropType = PropTypes.shape({
+ x: PropTypes.number,
+ y: PropTypes.number
+ });
+ module.exports = PointPropType;
+},401,[62],"node_modules\\react-native\\Libraries\\DeprecatedPropTypes\\DeprecatedPointPropType.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+
+ var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireWildcard");
+
+ Object.defineProperty(exports, "__esModule", {
+ value: true
+ });
+ exports.default = void 0;
+
+ var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));
+
+ var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));
+
+ var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn"));
+
+ var _getPrototypeOf3 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf"));
+
+ var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));
+
+ var _react = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[7], "react"));
+
+ var _reactNativeWindows = _$$_REQUIRE(_dependencyMap[8], "react-native-windows");
+
+ var _ToDoItemList = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "./ToDoItemList"));
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\ToDoList.js";
+
+ var ToDoList = function (_Component) {
+ (0, _inherits2.default)(ToDoList, _Component);
+
+ function ToDoList() {
+ var _getPrototypeOf2;
+
+ var _this;
+
+ (0, _classCallCheck2.default)(this, ToDoList);
+
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ _this = (0, _possibleConstructorReturn2.default)(this, (_getPrototypeOf2 = (0, _getPrototypeOf3.default)(ToDoList)).call.apply(_getPrototypeOf2, [this].concat(args)));
+ _this.state = {
+ tasks: _this.props.tasks
+ };
+ return _this;
+ }
+
+ (0, _createClass2.default)(ToDoList, [{
+ key: "render",
+ value: function render() {
+ return _react.default.createElement(_reactNativeWindows.StackPanel, {
+ Orientation: "Vertical",
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 19
+ }
+ }, this.renderToDoList());
+ }
+ }, {
+ key: "renderToDoList",
+ value: function renderToDoList() {
+ var items = [];
+ var tasks = this.state.tasks;
+
+ for (var i = 0; i < tasks.length; i++) {
+ items.push(_react.default.createElement(_ToDoItemList.default, {
+ key: i,
+ taskList: tasks[i],
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 27
+ }
+ }));
+ }
+
+ return items;
+ }
+ }]);
+ return ToDoList;
+ }(_react.Component);
+
+ exports.default = ToDoList;
+},402,[1,2,3,4,5,8,9,11,0,403],"ToDoList.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+
+ var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireWildcard");
+
+ Object.defineProperty(exports, "__esModule", {
+ value: true
+ });
+ exports.default = void 0;
+
+ var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));
+
+ var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));
+
+ var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn"));
+
+ var _getPrototypeOf3 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf"));
+
+ var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));
+
+ var _react = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[7], "react"));
+
+ var _reactNativeWindows = _$$_REQUIRE(_dependencyMap[8], "react-native-windows");
+
+ var _ToDoItem = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "./ToDoItem"));
+
+ var _TaskList = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "./data/TaskList"));
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\ToDoItemList.js";
+
+ var ToDoItemList = function (_Component) {
+ (0, _inherits2.default)(ToDoItemList, _Component);
+
+ function ToDoItemList() {
+ var _getPrototypeOf2;
+
+ var _this;
+
+ (0, _classCallCheck2.default)(this, ToDoItemList);
+
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ _this = (0, _possibleConstructorReturn2.default)(this, (_getPrototypeOf2 = (0, _getPrototypeOf3.default)(ToDoItemList)).call.apply(_getPrototypeOf2, [this].concat(args)));
+ _this.state = {
+ name: _this.props.taskList.name,
+ completionRate: _this.props.taskList.completionRate,
+ pointerPressed: false,
+ expanded: true
+ };
+
+ _this.updateTaskList = function () {
+ _this.setState({
+ completionRate: _this.props.taskList.completionRate
+ });
+ };
+
+ _this.onPointerPressed = function () {
+ _this.setState({
+ pointerPressed: true
+ });
+ };
+
+ _this.onPointerReleased = function () {
+ if (_this.state.pointerPressed) {
+ _this.setState({
+ expanded: !_this.state.expanded
+ });
+ }
+ };
+
+ return _this;
+ }
+
+ (0, _createClass2.default)(ToDoItemList, [{
+ key: "toPercentage",
+ value: function toPercentage(value) {
+ return (100 * value).toFixed(0).toString() + '%';
+ }
+ }, {
+ key: "render",
+ value: function render() {
+ return _react.default.createElement(_reactNativeWindows.StackPanel, {
+ Orientation: "Vertical",
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 47
+ }
+ }, _react.default.createElement(_reactNativeWindows.Grid, {
+ Orientation: "Horizontal",
+ Background: this.state.completionRate === 0 ? 'Red' : this.state.completionRate < 1.0 ? 'Yellow' : 'Green',
+ PointerPressed: this.onPointerPressed,
+ PointerReleased: this.onPointerReleased,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 48
+ }
+ }, _react.default.createElement(_reactNativeWindows.TextBlock, {
+ FontSize: "24",
+ Text: this.state.name,
+ HorizontalAlignment: "Left",
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 59
+ }
+ }), _react.default.createElement(_reactNativeWindows.TextBlock, {
+ FontSize: "24",
+ Text: this.toPercentage(this.state.completionRate),
+ HorizontalAlignment: "Right",
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 64
+ }
+ })), this.state.expanded && this.renderItems());
+ }
+ }, {
+ key: "renderItems",
+ value: function renderItems() {
+ var items = [];
+ var tasks = this.props.taskList.tasks;
+
+ for (var i = 0; i < tasks.length; i++) {
+ items.push(_react.default.createElement(_ToDoItem.default, {
+ key: i,
+ task: tasks[i],
+ updateTaskList: this.updateTaskList,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 80
+ }
+ }));
+ }
+
+ return items;
+ }
+ }]);
+ return ToDoItemList;
+ }(_react.Component);
+
+ exports.default = ToDoItemList;
+},403,[1,2,3,4,5,8,9,11,0,404,406],"ToDoItemList.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+
+ var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireWildcard");
+
+ Object.defineProperty(exports, "__esModule", {
+ value: true
+ });
+ exports.default = void 0;
+
+ var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));
+
+ var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));
+
+ var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn"));
+
+ var _getPrototypeOf3 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf"));
+
+ var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));
+
+ var _react = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[7], "react"));
+
+ var _reactNativeWindows = _$$_REQUIRE(_dependencyMap[8], "react-native-windows");
+
+ var _ToggleSwitch = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "./Controls/ToggleSwitch"));
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\ToDoItem.js";
+
+ var ToDoItem = function (_Component) {
+ (0, _inherits2.default)(ToDoItem, _Component);
+
+ function ToDoItem() {
+ var _getPrototypeOf2;
+
+ var _this;
+
+ (0, _classCallCheck2.default)(this, ToDoItem);
+
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ _this = (0, _possibleConstructorReturn2.default)(this, (_getPrototypeOf2 = (0, _getPrototypeOf3.default)(ToDoItem)).call.apply(_getPrototypeOf2, [this].concat(args)));
+ _this.state = {
+ name: _this.props.task.name
+ };
+
+ _this.onToggleSwitchChanged = function (value) {
+ _this.props.task.isCompleted = value;
+
+ _this.props.updateTaskList();
+ };
+
+ _this.onPointerEntered = function () {
+ _this.setState({
+ showHover: true
+ });
+ };
+
+ _this.onPointerExited = function () {
+ _this.setState({
+ showHover: false
+ });
+ };
+
+ return _this;
+ }
+
+ (0, _createClass2.default)(ToDoItem, [{
+ key: "render",
+ value: function render() {
+ return _react.default.createElement(_reactNativeWindows.StackPanel, {
+ Orientation: "Horizontal",
+ Background: this.state.showHover ? 'AliceBlue' : 'Transparent',
+ BorderBrush: this.state.showHover ? 'Blue' : 'Transparent',
+ BorderThickness: "1",
+ PointerEntered: this.onPointerEntered,
+ PointerExited: this.onPointerExited,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 25
+ }
+ }, _react.default.createElement(_ToggleSwitch.default, {
+ onToggleSwitchChanged: this.onToggleSwitchChanged,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 32
+ }
+ }), _react.default.createElement(_reactNativeWindows.TextBlock, {
+ Text: this.state.name,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 33
+ }
+ }));
+ }
+ }]);
+ return ToDoItem;
+ }(_react.Component);
+
+ exports.default = ToDoItem;
+},404,[1,2,3,4,5,8,9,11,0,405],"ToDoItem.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+
+ var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireWildcard");
+
+ Object.defineProperty(exports, "__esModule", {
+ value: true
+ });
+ exports.default = void 0;
+
+ var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));
+
+ var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));
+
+ var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn"));
+
+ var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf"));
+
+ var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));
+
+ var _react = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[7], "react"));
+
+ var _reactNativeWindows = _$$_REQUIRE(_dependencyMap[8], "react-native-windows");
+
+ var _jsxFileName = "D:\\rnw_xaml\\vnext\\Controls\\ToggleSwitch.js";
+
+ var ToggleSwitch = function (_Component) {
+ (0, _inherits2.default)(ToggleSwitch, _Component);
+
+ function ToggleSwitch() {
+ var _this;
+
+ (0, _classCallCheck2.default)(this, ToggleSwitch);
+ _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(ToggleSwitch).call(this));
+
+ _this.onPointerPressed = function () {
+ _this.setState({
+ pointerDown: true
+ });
+ };
+
+ _this.onPointerReleased = function () {
+ if (_this.state.pointerDown) {
+ _this.updateToggleState(!_this.state.on);
+ }
+
+ _this.setState({
+ pointerDown: false
+ });
+ };
+
+ _this.state = {
+ on: false,
+ pointerDown: false
+ };
+ return _this;
+ }
+
+ (0, _createClass2.default)(ToggleSwitch, [{
+ key: "render",
+ value: function render() {
+ return _react.default.createElement(_reactNativeWindows.Grid, {
+ Width: "50",
+ Height: "20",
+ Background: this.state.on ? 'Blue' : 'Transparent',
+ BorderBrush: this.state.on ? 'Blue' : 'Black',
+ BorderThickness: "2",
+ CornerRadius: "10",
+ PointerPressed: this.onPointerPressed,
+ PointerReleased: this.onPointerReleased,
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 22
+ }
+ }, _react.default.createElement(_reactNativeWindows.Rectangle, {
+ HorizontalAlignment: "Left",
+ Translation: this.state.on ? '33,0,0' : '3,0,0',
+ Fill: this.state.on ? 'White' : 'Black',
+ Width: "10",
+ Height: "10",
+ RadiusX: "5",
+ RadiusY: "5",
+ __source: {
+ fileName: _jsxFileName,
+ lineNumber: 31
+ }
+ }));
+ }
+ }, {
+ key: "updateToggleState",
+ value: function updateToggleState(toggleState) {
+ this.setState({
+ on: toggleState
+ });
+ this.props.onToggleSwitchChanged(toggleState);
+ }
+ }]);
+ return ToggleSwitch;
+ }(_react.Component);
+
+ exports.default = ToggleSwitch;
+},405,[1,2,3,4,5,8,9,11,0],"Controls\\ToggleSwitch.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+
+ Object.defineProperty(exports, "__esModule", {
+ value: true
+ });
+ exports.default = void 0;
+
+ var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+
+ var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+
+ var _Task = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "./Task"));
+
+ var TaskList = function () {
+ function TaskList(name) {
+ (0, _classCallCheck2.default)(this, TaskList);
+ this.name = name;
+ this.tasks = [];
+ }
+
+ (0, _createClass2.default)(TaskList, [{
+ key: "addTask",
+ value: function addTask(name) {
+ var task = new _Task.default(name);
+ this.tasks.push(task);
+ }
+ }, {
+ key: "completionRate",
+ get: function get() {
+ if (this.tasks.length == 0) {
+ return 1.0;
+ }
+
+ return this.tasks.filter(function (t) {
+ return t.isCompleted;
+ }).length / this.tasks.length;
+ }
+ }]);
+ return TaskList;
+ }();
+
+ exports.default = TaskList;
+},406,[1,3,4,407],"data\\TaskList.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+
+ Object.defineProperty(exports, "__esModule", {
+ value: true
+ });
+ exports.default = void 0;
+
+ var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));
+
+ var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));
+
+ var Task = function () {
+ function Task(name) {
+ (0, _classCallCheck2.default)(this, Task);
+ this.name = name;
+ this.isCompleted = false;
+ }
+
+ (0, _createClass2.default)(Task, [{
+ key: "toggleCompleted",
+ value: function toggleCompleted() {
+ this.isCompleted = !this.isCompleted;
+ }
+ }]);
+ return Task;
+ }();
+
+ exports.default = Task;
+},407,[1,3,4],"data\\Task.js");
+__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
+ var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");
+
+ var _TaskList = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./TaskList"));
+
+ var tolkien = new _TaskList.default('J.R.R. Tolkien');
+ tolkien.addTask('Finish work on Recipes of Middle Earth');
+ tolkien.addTask('Continue Orc experiments');
+ tolkien.addTask('Replenish pipe tabacco supplies');
+ var columbus = new _TaskList.default('Christopher Columbus');
+ columbus.addTask('Investor meeting to secure funding');
+ columbus.addTask('Practice sea navigation techniques');
+ columbus.addTask('Test whether dining table is round or flat');
+ columbus.addTask('Attend geography class');
+ var caesar = new _TaskList.default('Julius Caesar');
+ caesar.addTask('Work on Senate speech (due Mar 15)');
+ caesar.addTask('Experiment with various salad dressings');
+ caesar.addTask('Pose for sculpture');
+ caesar.addTask('Coffee with Brutus');
+ var vader = new _TaskList.default('Darth Vader');
+ vader.addTask('Meet with color consultant for Death Star decor');
+ vader.addTask('Attend anger management class');
+ vader.addTask('Lead troops in deep breathing exercises');
+ var tasks = [tolkien, columbus, caesar, vader];
+ module.exports = {
+ getTasks: function getTasks() {
+ return tasks.concat();
+ }
+ };
+},408,[1,406],"data\\SampleData.js");
+__r(86);
+__r(0);
\ No newline at end of file
diff --git a/vnext/Playground/Playground/MainPage.xaml.cs b/vnext/Playground/Playground/MainPage.xaml.cs
index 0d4b0c836cb..2ab7d397453 100644
--- a/vnext/Playground/Playground/MainPage.xaml.cs
+++ b/vnext/Playground/Playground/MainPage.xaml.cs
@@ -35,8 +35,8 @@ public MainPage()
private void LoadReact()
{
InstanceSettings settings;
- settings.UseWebDebugger = true;
- settings.UseLiveReload = true;
+ settings.UseWebDebugger = false;
+ settings.UseLiveReload = false;
var instance = Instance.Create(JSFILENAME);
diff --git a/vnext/Playground/Playground/Playground.csproj b/vnext/Playground/Playground/Playground.csproj
index baab2f144bf..e6c540f7879 100644
--- a/vnext/Playground/Playground/Playground.csproj
+++ b/vnext/Playground/Playground/Playground.csproj
@@ -19,6 +19,13 @@
true
Playground_TemporaryKey.pfx
23BDB1C8DDEE071750D95E22EA986ABE9475ECD7
+ False
+ True
+ False
+ Always
+ x86
+ 1
+ OnApplicationRun
true
@@ -129,6 +136,7 @@
Designer
+
@@ -162,6 +170,9 @@
ReactUWP
+
+
+
16.0
diff --git a/vnext/ReactUWP/Base/UwpReactInstance.cpp b/vnext/ReactUWP/Base/UwpReactInstance.cpp
index 7480acb8193..e73f9a43bcd 100644
--- a/vnext/ReactUWP/Base/UwpReactInstance.cpp
+++ b/vnext/ReactUWP/Base/UwpReactInstance.cpp
@@ -44,6 +44,12 @@
#include
#include
+// HACKATHON: ReactXaml types
+#include
+#include
+#include
+#include
+
// Modules
#include
#include
@@ -127,6 +133,12 @@ CreateUIManager(
viewManagers.push_back(
std::make_unique(instance));
+ // HACKATHON: ReactXaml ViewManagers
+ viewManagers.push_back(std::make_unique(instance));
+ viewManagers.push_back(std::make_unique(instance));
+ viewManagers.push_back(std::make_unique(instance));
+ viewManagers.push_back(std::make_unique(instance));
+
// Create UIManager, passing in ViewManagers
return createBatchingUIManager(
std::move(viewManagers), new NativeUIManager());
diff --git a/vnext/ReactUWP/Modules/NativeUIManager.cpp b/vnext/ReactUWP/Modules/NativeUIManager.cpp
index 66e2eb6aa0a..d30e559c120 100644
--- a/vnext/ReactUWP/Modules/NativeUIManager.cpp
+++ b/vnext/ReactUWP/Modules/NativeUIManager.cpp
@@ -1020,6 +1020,7 @@ void NativeUIManager::UpdateExtraLayout(int64_t tag) {
}
void NativeUIManager::DoLayout() {
+ return;
auto &rootTags = m_host->GetAllRootTags();
for (int64_t rootTag : rootTags) {
UpdateExtraLayout(rootTag);
diff --git a/vnext/ReactUWP/ReactUWP.vcxproj b/vnext/ReactUWP/ReactUWP.vcxproj
index a3fae6d8e5f..86f314c6435 100644
--- a/vnext/ReactUWP/ReactUWP.vcxproj
+++ b/vnext/ReactUWP/ReactUWP.vcxproj
@@ -237,6 +237,11 @@
+
+
+
+
+
@@ -332,6 +337,11 @@
+
+
+
+
+
diff --git a/vnext/ReactUWP/ReactUWP.vcxproj.filters b/vnext/ReactUWP/ReactUWP.vcxproj.filters
index 4ced0ef83d0..e031c20a272 100644
--- a/vnext/ReactUWP/ReactUWP.vcxproj.filters
+++ b/vnext/ReactUWP/ReactUWP.vcxproj.filters
@@ -286,6 +286,21 @@
Modules\Animated
+
+ Views\ReactXaml
+
+
+ Views\ReactXaml
+
+
+ Views\ReactXaml
+
+
+ Views\ReactXaml
+
+
+ Views\ReactXaml
+
@@ -624,6 +639,21 @@
Modules\Animated
+
+ Views\ReactXaml
+
+
+ Views\ReactXaml
+
+
+ Views\ReactXaml
+
+
+ Views\ReactXaml
+
+
+ Views\ReactXaml
+
@@ -755,6 +785,9 @@
{24ea7245-f460-4176-82b1-3cac4cd54621}
+
+ {031a8270-a785-4228-bf45-f5e9a9ec7c9a}
+
diff --git a/vnext/ReactUWP/Utils/PropertyUtils.h b/vnext/ReactUWP/Utils/PropertyUtils.h
index 984eaa80073..d083659d9a8 100644
--- a/vnext/ReactUWP/Utils/PropertyUtils.h
+++ b/vnext/ReactUWP/Utils/PropertyUtils.h
@@ -565,9 +565,9 @@ inline bool TryUpdateMouseEvents(
ShadowNodeBase *node,
const std::string &propertyName,
const folly::dynamic &propertyValue) {
- if (propertyName == "onMouseEnter")
+ if (propertyName == "onMouseEnter" || propertyName == "PointerEntered")
node->m_onMouseEnter = !propertyValue.isNull() && propertyValue.asBool();
- else if (propertyName == "onMouseLeave")
+ else if (propertyName == "onMouseLeave" || propertyName == "PointerExited")
node->m_onMouseLeave = !propertyValue.isNull() && propertyValue.asBool();
else if (propertyName == "onMouseMove")
node->m_onMouseMove = !propertyValue.isNull() && propertyValue.asBool();
diff --git a/vnext/ReactUWP/Utils/ValueUtils.cpp b/vnext/ReactUWP/Utils/ValueUtils.cpp
index 42cca93a34c..31804b8ec8b 100644
--- a/vnext/ReactUWP/Utils/ValueUtils.cpp
+++ b/vnext/ReactUWP/Utils/ValueUtils.cpp
@@ -132,6 +132,22 @@ SolidColorBrushFrom(const folly::dynamic &d) {
return brush;
}
+winrt::Windows::UI::Xaml::Media::SolidColorBrush SolidColorBrushFromColor(
+ const std::string &color) {
+ winrt::hstring xamlString =
+ L"";
+
+ auto brush{winrt::unbox_value(
+ winrt::Markup::XamlReader::Load(xamlString))};
+
+ return brush;
+}
+
REACTWINDOWS_API_(winrt::Brush) BrushFrom(const folly::dynamic &d) {
return SolidColorBrushFrom(d);
}
diff --git a/vnext/ReactUWP/Views/FrameworkElementViewManager.cpp b/vnext/ReactUWP/Views/FrameworkElementViewManager.cpp
index 6010c3d722b..d3e12b68424 100644
--- a/vnext/ReactUWP/Views/FrameworkElementViewManager.cpp
+++ b/vnext/ReactUWP/Views/FrameworkElementViewManager.cpp
@@ -20,6 +20,7 @@
#include
#include
#include
+#include
#include "DynamicAutomationProperties.h"
@@ -30,6 +31,8 @@ using namespace Windows::UI::Xaml::Automation;
using namespace Windows::UI::Xaml::Automation::Peers;
} // namespace winrt
+using namespace Windows::Foundation::Numerics;
+
namespace react {
namespace uwp {
@@ -110,7 +113,9 @@ folly::dynamic FrameworkElementViewManager::GetNativeProps() const {
"accessibilityRole", "string")("accessibilityStates", "array")(
"accessibilityHint", "string")("accessibilityLabel", "string")(
"accessibilityPosInSet", "number")("accessibilitySetSize", "number")(
- "testID", "string")("tooltip", "string"));
+ "testID", "string")("tooltip", "string")("Width", "string")(
+ "Height", "string")("HorizontalAlignment", "string")("VerticalAlignment", "string")("Translation", "string")
+ ("PointerEntered", "function")("PointerExited", "function")("PointerPressed", "function")("PointerReleased", "function"));
return props;
}
@@ -202,6 +207,96 @@ void FrameworkElementViewManager::UpdateProperties(
element.ClearValue(winrt::FrameworkElement::HeightProperty());
continue;
}
+ } else if (propertyName == "Width") {
+ if (propertyValue.isString()) {
+ double width = atof(propertyValue.asString().c_str());
+ if (width >= 0)
+ element.Width(width);
+ } else if (propertyValue.isNull()) {
+ element.ClearValue(winrt::FrameworkElement::WidthProperty());
+ continue;
+ }
+ } else if (propertyName == "Height") {
+ if (propertyValue.isString()) {
+ double height = atof(propertyValue.asString().c_str());
+ if (height >= 0)
+ element.Height(height);
+ } else if (propertyValue.isNull()) {
+ element.ClearValue(winrt::FrameworkElement::HeightProperty());
+ continue;
+ }
+ }
+ else if (propertyName == "HorizontalAlignment") {
+ if (propertyValue.isString()) {
+ if (propertyValue.asString() == "Left")
+ element.HorizontalAlignment(
+ winrt::Windows::UI::Xaml::HorizontalAlignment::Left);
+ if (propertyValue.asString() == "Center")
+ element.HorizontalAlignment(
+ winrt::Windows::UI::Xaml::HorizontalAlignment::Center);
+ if (propertyValue.asString() == "Right")
+ element.HorizontalAlignment(
+ winrt::Windows::UI::Xaml::HorizontalAlignment::Right);
+ if (propertyValue.asString() == "Stretch")
+ element.HorizontalAlignment(
+ winrt::Windows::UI::Xaml::HorizontalAlignment::Stretch);
+ }
+ else if (propertyValue.isNull()) {
+ element.ClearValue(winrt::FrameworkElement::HorizontalAlignmentProperty());
+ continue;
+ }
+ }
+ else if (propertyName == "VerticalAlignment") {
+ if (propertyValue.isString()) {
+ if (propertyValue.asString() == "Top")
+ element.VerticalAlignment(
+ winrt::Windows::UI::Xaml::VerticalAlignment::Top);
+ if (propertyValue.asString() == "Center")
+ element.VerticalAlignment(
+ winrt::Windows::UI::Xaml::VerticalAlignment::Center);
+ if (propertyValue.asString() == "Bottom")
+ element.VerticalAlignment(
+ winrt::Windows::UI::Xaml::VerticalAlignment::Bottom);
+ if (propertyValue.asString() == "Stretch")
+ element.VerticalAlignment(
+ winrt::Windows::UI::Xaml::VerticalAlignment::Stretch);
+ }
+ else if (propertyValue.isNull()) {
+ element.ClearValue(winrt::FrameworkElement::VerticalAlignmentProperty());
+ continue;
+ }
+ }
+ else if (propertyName == "Translation") {
+ if (propertyValue.isString()) {
+ float3 translation;
+ std::istringstream overallStream(propertyValue.asString());
+ {
+ std::string component;
+ getline(overallStream, component, ',');
+ translation.x = static_cast(atof(component.c_str()));
+ }
+ {
+ std::string component;
+ getline(overallStream, component, ',');
+ translation.y = static_cast(atof(component.c_str()));
+ }
+ {
+ std::string component;
+ getline(overallStream, component, ',');
+ translation.z = static_cast(atof(component.c_str()));
+ }
+ element.Translation({ translation.x, translation.y, translation.z });
+ }
+ else {
+ element.Translation({ 0,0,0 });
+ }
+ }
+ else if (TryUpdateMouseEvents(nodeToUpdate, propertyName, propertyValue)) {
+ continue;
+ } else if (propertyName == "PointerPressed") {
+ nodeToUpdate->AddPointerPressedHandler();
+ } else if (propertyName == "PointerReleased") {
+ nodeToUpdate->AddPointerReleasedHandler();
} else if (propertyName == "minWidth") {
if (propertyValue.isNumber()) {
double minWidth = propertyValue.asDouble();
diff --git a/vnext/ReactUWP/Views/ReactXaml/GridViewManager.cpp b/vnext/ReactUWP/Views/ReactXaml/GridViewManager.cpp
new file mode 100644
index 00000000000..c4a131f68e9
--- /dev/null
+++ b/vnext/ReactUWP/Views/ReactXaml/GridViewManager.cpp
@@ -0,0 +1,132 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "pch.h"
+
+#include "GridViewManager.h"
+
+#include
+
+#include
+#include
+
+#include
+
+namespace winrt {
+using namespace Windows::UI::Xaml::Documents;
+} // namespace winrt
+
+namespace react {
+namespace uwp {
+
+GridViewManager::GridViewManager(
+ const std::shared_ptr &reactInstance)
+ : Super(reactInstance) {}
+
+const char *GridViewManager::GetName() const {
+ return "RCTGrid";
+}
+
+XamlView GridViewManager::CreateViewCore(int64_t tag) {
+ auto grid = winrt::Grid();
+ return grid;
+}
+
+folly::dynamic GridViewManager::GetNativeProps() const {
+ auto props = Super::GetNativeProps();
+
+ props.update(folly::dynamic::object("RowDefinitions", "string")(
+ "ColumnDefinitions", "string")("CornerRadius", "string")(
+ "BorderBrush", "string")("BorderThickness", "string"));
+
+ return props;
+}
+void GridViewManager::UpdateProperties(
+ ShadowNodeBase *nodeToUpdate,
+ const folly::dynamic &reactDiffMap) {
+ auto grid = nodeToUpdate->GetView().as();
+ if (grid == nullptr)
+ return;
+
+ for (const auto &pair : reactDiffMap.items()) {
+ const std::string &propertyName = pair.first.getString();
+ const folly::dynamic &propertyValue = pair.second;
+
+ if (propertyName == "RowDefinitions") {
+ if (propertyValue.isString()) {
+ std::istringstream overallStream(propertyValue.asString());
+ std::string rowdef;
+ while (getline(overallStream, rowdef, ',')) {
+ std::istringstream rowdefstream(rowdef);
+ std::string type;
+ std::string value;
+ getline(rowdefstream, type, '=');
+ getline(rowdefstream, value, '=');
+ auto rd = winrt::Windows::UI::Xaml::Controls::RowDefinition();
+ if (type == "Height") {
+ if (value == "*") {
+ rd.Height({1.0, winrt::Windows::UI::Xaml::GridUnitType::Star});
+ } else if (value == "Auto") {
+ rd.Height({1.0, winrt::Windows::UI::Xaml::GridUnitType::Auto});
+ } else {
+ rd.Height({atof(value.c_str()),
+ winrt::Windows::UI::Xaml::GridUnitType::Pixel});
+ }
+ }
+ grid.RowDefinitions().Append(rd);
+ }
+ }
+ } else if (propertyName == "ColumnDefinitions") {
+ if (propertyValue.isString()) {
+ std::istringstream overallStream(propertyValue.asString());
+ std::string columndef;
+ while (getline(overallStream, columndef, ',')) {
+ std::istringstream columndefstream(columndef);
+ std::string type;
+ std::string value;
+ getline(columndefstream, type, '=');
+ getline(columndefstream, value, '=');
+ auto cd = winrt::Windows::UI::Xaml::Controls::ColumnDefinition();
+ if (type == "Width") {
+ if (value == "*") {
+ cd.Width({1.0, winrt::Windows::UI::Xaml::GridUnitType::Star});
+ } else if (value == "Auto") {
+ cd.Width({1.0, winrt::Windows::UI::Xaml::GridUnitType::Auto});
+ } else {
+ cd.Width({atof(value.c_str()),
+ winrt::Windows::UI::Xaml::GridUnitType::Pixel});
+ }
+ }
+ grid.ColumnDefinitions().Append(cd);
+ }
+ }
+ } else if (propertyName == "CornerRadius") {
+ if (propertyValue.isString()) {
+ double radius = atof(propertyValue.asString().c_str());
+ grid.CornerRadius({radius, radius, radius, radius});
+ } else if (propertyValue.isNull()) {
+ grid.ClearValue(winrt::Grid::CornerRadiusProperty());
+ }
+ } else if (propertyName == "BorderBrush") {
+ if (propertyValue.isString()) {
+ grid.BorderBrush(
+ SolidColorBrushFromColor(propertyValue.asString()));
+ } else if (propertyValue.isNull()) {
+ grid.ClearValue(winrt::StackPanel::BorderBrushProperty());
+ }
+ } else if (propertyName == "BorderThickness") {
+ if (propertyValue.isString()) {
+ auto thickness = atof(propertyValue.asString().c_str());
+ grid.BorderThickness(
+ {thickness, thickness, thickness, thickness});
+ } else if (propertyValue.isNull()) {
+ grid.ClearValue(winrt::StackPanel::BorderThicknessProperty());
+ }
+ }
+ }
+
+ Super::UpdateProperties(nodeToUpdate, reactDiffMap);
+}
+
+} // namespace uwp
+} // namespace react
diff --git a/vnext/ReactUWP/Views/ReactXaml/GridViewManager.h b/vnext/ReactUWP/Views/ReactXaml/GridViewManager.h
new file mode 100644
index 00000000000..b0fee6d26a7
--- /dev/null
+++ b/vnext/ReactUWP/Views/ReactXaml/GridViewManager.h
@@ -0,0 +1,28 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include
+
+namespace react {
+namespace uwp {
+
+class GridViewManager : public PanelViewManager {
+ using Super = PanelViewManager;
+
+ public:
+ GridViewManager(const std::shared_ptr &reactInstance);
+
+ const char *GetName() const override;
+ folly::dynamic GetNativeProps() const override;
+ void UpdateProperties(
+ ShadowNodeBase *nodeToUpdate,
+ const folly::dynamic &reactDiffMap) override;
+
+ protected:
+ XamlView CreateViewCore(int64_t tag) override;
+};
+
+} // namespace uwp
+} // namespace react
diff --git a/vnext/ReactUWP/Views/ReactXaml/PanelViewManager.cpp b/vnext/ReactUWP/Views/ReactXaml/PanelViewManager.cpp
new file mode 100644
index 00000000000..f630b36ea0d
--- /dev/null
+++ b/vnext/ReactUWP/Views/ReactXaml/PanelViewManager.cpp
@@ -0,0 +1,72 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "pch.h"
+
+#include "PanelViewManager.h"
+
+#include
+
+#include
+#include
+
+#include
+
+namespace winrt {
+using namespace Windows::UI::Xaml::Documents;
+} // namespace winrt
+
+namespace react {
+namespace uwp {
+
+PanelViewManager::PanelViewManager(
+ const std::shared_ptr &reactInstance)
+ : Super(reactInstance) {}
+
+folly::dynamic PanelViewManager::GetNativeProps() const {
+ auto props = Super::GetNativeProps();
+
+ props.update(folly::dynamic::object("Background", "string"));
+
+ return props;
+}
+void PanelViewManager::UpdateProperties(
+ ShadowNodeBase *nodeToUpdate,
+ const folly::dynamic &reactDiffMap) {
+ auto panel = nodeToUpdate->GetView().as();
+ if (panel == nullptr)
+ return;
+
+ for (const auto &pair : reactDiffMap.items()) {
+ const std::string &propertyName = pair.first.getString();
+ const folly::dynamic &propertyValue = pair.second;
+
+ if (propertyName == "Background") {
+ if (propertyValue.isString()) {
+ panel.Background(SolidColorBrushFromColor(propertyValue.asString()));
+ } else if (propertyValue.isNull()) {
+ panel.ClearValue(winrt::Panel::BackgroundProperty());
+ }
+ }
+ }
+ Super::UpdateProperties(nodeToUpdate, reactDiffMap);
+}
+
+void PanelViewManager::AddView(XamlView parent, XamlView child, int64_t index) {
+ auto panel(parent.as());
+ auto childElement(child.as());
+ panel.Children().InsertAt(static_cast(index), childElement);
+}
+
+void PanelViewManager::RemoveAllChildren(XamlView parent) {
+ auto panel(parent.as());
+ panel.Children().Clear();
+}
+
+void PanelViewManager::RemoveChildAt(XamlView parent, int64_t index) {
+ auto panel(parent.as());
+ panel.Children().RemoveAt(static_cast(index));
+}
+
+} // namespace uwp
+} // namespace react
diff --git a/vnext/ReactUWP/Views/ReactXaml/PanelViewManager.h b/vnext/ReactUWP/Views/ReactXaml/PanelViewManager.h
new file mode 100644
index 00000000000..da5c696ec06
--- /dev/null
+++ b/vnext/ReactUWP/Views/ReactXaml/PanelViewManager.h
@@ -0,0 +1,28 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include
+
+namespace react {
+namespace uwp {
+
+class PanelViewManager : public FrameworkElementViewManager {
+ using Super = FrameworkElementViewManager;
+
+ public:
+ PanelViewManager(const std::shared_ptr &reactInstance);
+
+ folly::dynamic GetNativeProps() const override;
+ void UpdateProperties(
+ ShadowNodeBase *nodeToUpdate,
+ const folly::dynamic &reactDiffMap) override;
+
+ void AddView(XamlView parent, XamlView child, int64_t index) override;
+ void RemoveAllChildren(XamlView parent) override;
+ void RemoveChildAt(XamlView parent, int64_t index) override;
+};
+
+} // namespace uwp
+} // namespace react
diff --git a/vnext/ReactUWP/Views/ReactXaml/RectangleViewManager.cpp b/vnext/ReactUWP/Views/ReactXaml/RectangleViewManager.cpp
new file mode 100644
index 00000000000..5a09cce111e
--- /dev/null
+++ b/vnext/ReactUWP/Views/ReactXaml/RectangleViewManager.cpp
@@ -0,0 +1,99 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "pch.h"
+
+#include "RectangleViewManager.h"
+
+#include
+
+#include
+#include
+
+#include
+#include
+
+using namespace ::winrt::Windows::UI::Xaml::Shapes;
+
+namespace winrt {
+using namespace Windows::UI::Xaml::Documents;
+} // namespace winrt
+
+namespace react {
+namespace uwp {
+
+RectangleViewManager::RectangleViewManager(
+ const std::shared_ptr &reactInstance)
+ : Super(reactInstance) {}
+
+const char *RectangleViewManager::GetName() const {
+ return "RCTRectangle";
+}
+
+XamlView RectangleViewManager::CreateViewCore(int64_t tag) {
+ auto rectangle = winrt::Windows::UI::Xaml::Shapes::Rectangle();
+ return rectangle;
+}
+
+folly::dynamic RectangleViewManager::GetNativeProps() const {
+ auto props = Super::GetNativeProps();
+
+ props.update(folly::dynamic::object("Fill", "string")("RadiusX", "string")(
+ "RadiusY", "string"));
+
+ return props;
+}
+
+void RectangleViewManager::UpdateProperties(
+ ShadowNodeBase *nodeToUpdate,
+ const folly::dynamic &reactDiffMap) {
+ auto rectangle =
+ nodeToUpdate->GetView().as();
+ if (rectangle == nullptr)
+ return;
+
+ for (const auto &pair : reactDiffMap.items()) {
+ const std::string &propertyName = pair.first.getString();
+ const folly::dynamic &propertyValue = pair.second;
+
+ if (propertyName == "Fill") {
+ if (propertyValue.isString()) {
+ rectangle.Fill(SolidColorBrushFromColor(propertyValue.asString()));
+ } else if (propertyValue.isNull()) {
+ rectangle.ClearValue(Shape::FillProperty());
+ }
+ }
+ else if (propertyName == "RadiusX") {
+ if (propertyValue.isString()) {
+ rectangle.RadiusX(atof(propertyValue.asString().c_str()));
+ } else if (propertyValue.isNull()) {
+ rectangle.ClearValue(Rectangle::RadiusXProperty());
+ }
+ }
+ else if (propertyName == "RadiusY") {
+ if (propertyValue.isString()) {
+ rectangle.RadiusY(atof(propertyValue.asString().c_str()));
+ } else if (propertyValue.isNull()) {
+ rectangle.ClearValue(Rectangle::RadiusYProperty());
+ }
+ }
+ }
+ Super::UpdateProperties(nodeToUpdate, reactDiffMap);
+}
+
+void RectangleViewManager::AddView(
+ XamlView parent,
+ XamlView child,
+ int64_t index) {
+ assert(false);
+}
+
+void RectangleViewManager::RemoveAllChildren(XamlView parent) {
+}
+
+void RectangleViewManager::RemoveChildAt(XamlView parent, int64_t index) {
+ assert(false);
+}
+
+} // namespace uwp
+} // namespace react
diff --git a/vnext/ReactUWP/Views/ReactXaml/RectangleViewManager.h b/vnext/ReactUWP/Views/ReactXaml/RectangleViewManager.h
new file mode 100644
index 00000000000..22cf371fbca
--- /dev/null
+++ b/vnext/ReactUWP/Views/ReactXaml/RectangleViewManager.h
@@ -0,0 +1,32 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include
+
+namespace react {
+namespace uwp {
+
+class RectangleViewManager : public FrameworkElementViewManager {
+ using Super = FrameworkElementViewManager;
+
+ public:
+ RectangleViewManager(const std::shared_ptr &reactInstance);
+
+ const char *GetName() const override;
+ folly::dynamic GetNativeProps() const override;
+ void UpdateProperties(
+ ShadowNodeBase *nodeToUpdate,
+ const folly::dynamic &reactDiffMap) override;
+
+ void AddView(XamlView parent, XamlView child, int64_t index) override;
+ void RemoveAllChildren(XamlView parent) override;
+ void RemoveChildAt(XamlView parent, int64_t index) override;
+
+ protected:
+ XamlView CreateViewCore(int64_t tag) override;
+};
+
+} // namespace uwp
+} // namespace react
diff --git a/vnext/ReactUWP/Views/ReactXaml/StackPanelViewManager.cpp b/vnext/ReactUWP/Views/ReactXaml/StackPanelViewManager.cpp
new file mode 100644
index 00000000000..013cccf37c1
--- /dev/null
+++ b/vnext/ReactUWP/Views/ReactXaml/StackPanelViewManager.cpp
@@ -0,0 +1,90 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "pch.h"
+
+#include "StackPanelViewManager.h"
+
+#include
+
+#include
+#include
+
+#include
+
+namespace winrt {
+using namespace Windows::UI::Xaml::Documents;
+} // namespace winrt
+
+namespace react {
+namespace uwp {
+
+StackPanelViewManager::StackPanelViewManager(
+ const std::shared_ptr &reactInstance)
+ : Super(reactInstance) {}
+
+
+const char *StackPanelViewManager::GetName() const {
+ return "RCTStackPanel";
+}
+
+XamlView StackPanelViewManager::CreateViewCore(int64_t tag) {
+ auto stackPanel = winrt::StackPanel();
+ return stackPanel;
+}
+
+folly::dynamic StackPanelViewManager::GetNativeProps() const {
+ auto props = Super::GetNativeProps();
+
+ props.update(folly::dynamic::object("Orientation", "string")(
+ "BorderBrush", "string")("BorderThickness", "string"));
+
+ return props;
+}
+void StackPanelViewManager::UpdateProperties(
+ ShadowNodeBase *nodeToUpdate,
+ const folly::dynamic &reactDiffMap) {
+ auto stackPanel = nodeToUpdate->GetView().as();
+ if (stackPanel == nullptr)
+ return;
+
+ for (const auto &pair : reactDiffMap.items()) {
+ const std::string &propertyName = pair.first.getString();
+ const folly::dynamic &propertyValue = pair.second;
+
+ if (propertyName == "Orientation") {
+ if (propertyValue.isString()) {
+ if (propertyValue.asString() == "Horizontal") {
+ stackPanel.Orientation(
+ winrt::Windows::UI::Xaml::Controls::Orientation::Horizontal);
+ }
+ else if (propertyValue.asString() == "Vertical") {
+ stackPanel.Orientation(
+ winrt::Windows::UI::Xaml::Controls::Orientation::Vertical);
+ }
+ } else if (propertyValue.isNull()) {
+ stackPanel.ClearValue(winrt::StackPanel::OrientationProperty());
+ }
+ } else if (propertyName == "BorderBrush") {
+ if (propertyValue.isString()) {
+ stackPanel.BorderBrush(
+ SolidColorBrushFromColor(propertyValue.asString()));
+ } else if (propertyValue.isNull()) {
+ stackPanel.ClearValue(winrt::StackPanel::BorderBrushProperty());
+ }
+ } else if (propertyName == "BorderThickness") {
+ if (propertyValue.isString()) {
+ auto thickness = atof(propertyValue.asString().c_str());
+ stackPanel.BorderThickness(
+ {thickness, thickness, thickness, thickness});
+ } else if (propertyValue.isNull()) {
+ stackPanel.ClearValue(winrt::StackPanel::BorderThicknessProperty());
+ }
+ }
+ }
+
+ Super::UpdateProperties(nodeToUpdate, reactDiffMap);
+}
+
+} // namespace uwp
+} // namespace react
diff --git a/vnext/ReactUWP/Views/ReactXaml/StackPanelViewManager.h b/vnext/ReactUWP/Views/ReactXaml/StackPanelViewManager.h
new file mode 100644
index 00000000000..3ece098a11b
--- /dev/null
+++ b/vnext/ReactUWP/Views/ReactXaml/StackPanelViewManager.h
@@ -0,0 +1,28 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include
+
+namespace react {
+namespace uwp {
+
+class StackPanelViewManager : public PanelViewManager {
+ using Super = PanelViewManager;
+
+ public:
+ StackPanelViewManager(const std::shared_ptr &reactInstance);
+
+ const char *GetName() const override;
+ folly::dynamic GetNativeProps() const override;
+ void UpdateProperties(
+ ShadowNodeBase *nodeToUpdate,
+ const folly::dynamic &reactDiffMap) override;
+
+ protected:
+ XamlView CreateViewCore(int64_t tag) override;
+};
+
+} // namespace uwp
+} // namespace react
diff --git a/vnext/ReactUWP/Views/ReactXaml/TextBlockViewManager.cpp b/vnext/ReactUWP/Views/ReactXaml/TextBlockViewManager.cpp
new file mode 100644
index 00000000000..5b61dbaffc6
--- /dev/null
+++ b/vnext/ReactUWP/Views/ReactXaml/TextBlockViewManager.cpp
@@ -0,0 +1,156 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "pch.h"
+
+#include "TextBlockViewManager.h"
+
+#include
+
+#include
+#include
+
+#include
+
+namespace winrt {
+using namespace Windows::UI::Xaml::Documents;
+} // namespace winrt
+
+namespace react {
+namespace uwp {
+
+class TextBlockShadowNode : public ShadowNodeBase {
+ using Super = ShadowNodeBase;
+
+ public:
+ TextBlockShadowNode() = default;
+ bool ImplementsPadding() override {
+ return true;
+ }
+};
+
+TextBlockViewManager::TextBlockViewManager(
+ const std::shared_ptr &reactInstance)
+ : Super(reactInstance) {}
+
+facebook::react::ShadowNode *TextBlockViewManager::createShadow() const {
+ return new TextBlockShadowNode();
+}
+
+const char *TextBlockViewManager::GetName() const {
+ return "RCTTextBlock";
+}
+
+XamlView TextBlockViewManager::CreateViewCore(int64_t tag) {
+ auto textBlock = winrt::TextBlock();
+ return textBlock;
+}
+
+folly::dynamic TextBlockViewManager::GetNativeProps() const {
+ auto props = Super::GetNativeProps();
+
+ props.update(
+ folly::dynamic::object
+ ("Text", "string")
+ ("FontSize", "string")
+ );
+
+ return props;
+}
+void TextBlockViewManager::UpdateProperties(
+ ShadowNodeBase *nodeToUpdate,
+ const folly::dynamic &reactDiffMap) {
+ auto textBlock = nodeToUpdate->GetView().as();
+ if (textBlock == nullptr)
+ return;
+
+ for (const auto &pair : reactDiffMap.items()) {
+ const std::string &propertyName = pair.first.getString();
+ const folly::dynamic &propertyValue = pair.second;
+
+ if (TryUpdateForeground(textBlock, propertyName, propertyValue)) {
+ continue;
+ } else if (TryUpdateFontProperties(
+ textBlock, propertyName, propertyValue)) {
+ continue;
+ } else if (TryUpdatePadding(
+ nodeToUpdate, textBlock, propertyName, propertyValue)) {
+ continue;
+ } else if (TryUpdateTextAlignment(textBlock, propertyName, propertyValue)) {
+ continue;
+ } else if (TryUpdateTextTrimming(textBlock, propertyName, propertyValue)) {
+ continue;
+ } else if (TryUpdateTextDecorationLine(
+ textBlock, propertyName, propertyValue)) {
+ continue;
+ } else if (TryUpdateCharacterSpacing(
+ textBlock, propertyName, propertyValue)) {
+ continue;
+ } else if (propertyName == "numberOfLines") {
+ if (propertyValue.isNumber())
+ textBlock.MaxLines(static_cast(propertyValue.asDouble()));
+ else if (propertyValue.isNull())
+ textBlock.ClearValue(winrt::TextBlock::MaxLinesProperty());
+ } else if (propertyName == "lineHeight") {
+ if (propertyValue.isNumber())
+ textBlock.LineHeight(static_cast(propertyValue.asDouble()));
+ else if (propertyValue.isNull())
+ textBlock.ClearValue(winrt::TextBlock::LineHeightProperty());
+ } else if (propertyName == "selectable") {
+ if (propertyValue.isBool())
+ textBlock.IsTextSelectionEnabled(propertyValue.asBool());
+ else if (propertyValue.isNull())
+ textBlock.ClearValue(
+ winrt::TextBlock::IsTextSelectionEnabledProperty());
+ } else if (propertyName == "allowFontScaling") {
+ if (propertyValue.isBool())
+ textBlock.IsTextScaleFactorEnabled(propertyValue.asBool());
+ else
+ textBlock.ClearValue(
+ winrt::TextBlock::IsTextScaleFactorEnabledProperty());
+ } else if (propertyName == "selectionColor") {
+ if (IsValidColorValue(propertyValue)) {
+ textBlock.SelectionHighlightColor(SolidColorBrushFrom(propertyValue));
+ } else
+ textBlock.ClearValue(
+ winrt::TextBlock::SelectionHighlightColorProperty());
+ } else if (propertyName == "Text") {
+ if (propertyValue.isString()) {
+ textBlock.Text(winrt::to_hstring(propertyValue.asString()));
+ } else
+ textBlock.ClearValue(
+ winrt::TextBlock::TextProperty());
+ } else if (propertyName == "FontSize") {
+ if (propertyValue.isString()) {
+ textBlock.FontSize(atof(propertyValue.asString().c_str()));
+ } else
+ textBlock.ClearValue(
+ winrt::TextBlock::FontSizeProperty());
+ }
+ }
+
+ Super::UpdateProperties(nodeToUpdate, reactDiffMap);
+}
+
+void TextBlockViewManager::AddView(XamlView parent, XamlView child, int64_t index) {
+ auto textBlock(parent.as());
+ auto childInline(child.as());
+ textBlock.Inlines().InsertAt(static_cast(index), childInline);
+}
+
+void TextBlockViewManager::RemoveAllChildren(XamlView parent) {
+ auto textBlock(parent.as());
+ textBlock.Inlines().Clear();
+}
+
+void TextBlockViewManager::RemoveChildAt(XamlView parent, int64_t index) {
+ auto textBlock(parent.as());
+ return textBlock.Inlines().RemoveAt(static_cast(index));
+}
+
+YGMeasureFunc TextBlockViewManager::GetYogaCustomMeasureFunc() const {
+ return DefaultYogaSelfMeasureFunc;
+}
+
+} // namespace uwp
+} // namespace react
diff --git a/vnext/ReactUWP/Views/ReactXaml/TextBlockViewManager.h b/vnext/ReactUWP/Views/ReactXaml/TextBlockViewManager.h
new file mode 100644
index 00000000000..31f123938de
--- /dev/null
+++ b/vnext/ReactUWP/Views/ReactXaml/TextBlockViewManager.h
@@ -0,0 +1,36 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include
+
+namespace react {
+namespace uwp {
+
+class TextBlockViewManager : public FrameworkElementViewManager {
+ using Super = FrameworkElementViewManager;
+
+ public:
+ TextBlockViewManager(const std::shared_ptr &reactInstance);
+
+ facebook::react::ShadowNode *createShadow() const override;
+
+ const char *GetName() const override;
+ folly::dynamic GetNativeProps() const override;
+ void UpdateProperties(
+ ShadowNodeBase *nodeToUpdate,
+ const folly::dynamic &reactDiffMap) override;
+
+ void AddView(XamlView parent, XamlView child, int64_t index) override;
+ void RemoveAllChildren(XamlView parent) override;
+ void RemoveChildAt(XamlView parent, int64_t index) override;
+
+ YGMeasureFunc GetYogaCustomMeasureFunc() const override;
+
+ protected:
+ XamlView CreateViewCore(int64_t tag) override;
+};
+
+} // namespace uwp
+} // namespace react
diff --git a/vnext/ReactUWP/Views/ShadowNodeBase.cpp b/vnext/ReactUWP/Views/ShadowNodeBase.cpp
index 7ddb264119c..483a3248b14 100644
--- a/vnext/ReactUWP/Views/ShadowNodeBase.cpp
+++ b/vnext/ReactUWP/Views/ShadowNodeBase.cpp
@@ -134,5 +134,29 @@ void ShadowNodeBase::EnsureHandledKeyboardEventHandler() {
}
}
+void ShadowNodeBase::AddPointerPressedHandler() {
+ auto element(GetView().as());
+ m_pointerPressedRevoker =
+ element.PointerPressed(winrt::auto_revoke, [=](auto &&, auto &&args) {
+ auto instance = GetViewManager()->GetReactInstance().lock();
+ if (instance != nullptr) {
+ instance->DispatchEvent(m_tag, "topPointerPressed", std::move(folly::dynamic::object("target", m_tag)));
+ args.Handled(true);
+ }
+ });
+}
+
+void ShadowNodeBase::AddPointerReleasedHandler() {
+ auto element(GetView().as());
+ m_pointerReleasedRevoker =
+ element.PointerReleased(winrt::auto_revoke, [=](auto &&, auto &&args) {
+ auto instance = GetViewManager()->GetReactInstance().lock();
+ if (instance != nullptr) {
+ instance->DispatchEvent(m_tag, "topPointerReleased", std::move(folly::dynamic::object("target", m_tag)));
+ args.Handled(true);
+ }
+ });
+}
+
} // namespace uwp
} // namespace react
diff --git a/vnext/ReactUWP/Views/TouchEventHandler.cpp b/vnext/ReactUWP/Views/TouchEventHandler.cpp
index caf628f87b3..381e1793187 100644
--- a/vnext/ReactUWP/Views/TouchEventHandler.cpp
+++ b/vnext/ReactUWP/Views/TouchEventHandler.cpp
@@ -274,10 +274,12 @@ void TouchEventHandler::UpdatePointersInViews(
continue;
ShadowNodeBase *node = static_cast(
- puiManagerHost->FindShadowNodeForTag(existingTag));
+ puiManagerHost->FindShadowNodeForTag(existingTag));
if (node != nullptr && node->m_onMouseLeave)
- instance->DispatchEvent(
- existingTag, "topMouseLeave", GetPointerJson(pointer, existingTag));
+ {
+ instance->DispatchEvent(existingTag, "topMouseLeave", GetPointerJson(pointer, existingTag));
+ instance->DispatchEvent(existingTag, "topPointerExited", GetPointerJson(pointer, existingTag));
+ }
}
// Notify tags new in the list
@@ -286,10 +288,12 @@ void TouchEventHandler::UpdatePointersInViews(
continue;
ShadowNodeBase *node = static_cast(
- puiManagerHost->FindShadowNodeForTag(newTag));
+ puiManagerHost->FindShadowNodeForTag(newTag));
if (node != nullptr && node->m_onMouseEnter)
- instance->DispatchEvent(
- newTag, "topMouseEnter", GetPointerJson(pointer, newTag));
+ {
+ instance->DispatchEvent(newTag, "topMouseEnter", GetPointerJson(pointer, newTag));
+ instance->DispatchEvent(newTag, "topPointerEntered", GetPointerJson(pointer, newTag));
+ }
}
m_pointersInViews[pointerId] = std::move(newViews);
@@ -330,6 +334,7 @@ void TouchEventHandler::SendPointerMove(
folly::dynamic touch = GetPointerJson(pointer, pointer.target);
instance->DispatchEvent(tag, "topMouseEnter", GetPointerJson(pointer, tag));
+ instance->DispatchEvent(tag, "topPointerEntered", GetPointerJson(pointer, tag));
}
folly::dynamic TouchEventHandler::GetPointerJson(
diff --git a/vnext/ReactUWP/Views/ViewManagerBase.cpp b/vnext/ReactUWP/Views/ViewManagerBase.cpp
index 0dc22f7103d..006837bab70 100644
--- a/vnext/ReactUWP/Views/ViewManagerBase.cpp
+++ b/vnext/ReactUWP/Views/ViewManagerBase.cpp
@@ -177,15 +177,15 @@ dynamic ViewManagerBase::GetExportedCustomBubblingEventTypeConstants() const {
dynamic ViewManagerBase::GetExportedCustomDirectEventTypeConstants() const {
folly::dynamic eventTypes = folly::dynamic::object();
- eventTypes.update(folly::dynamic::object(
- "topLayout", folly::dynamic::object("registrationName", "onLayout"))(
- "topMouseEnter",
- folly::dynamic::object("registrationName", "onMouseEnter"))(
- "topMouseLeave",
- folly::dynamic::object("registrationName", "onMouseLeave"))
- // ("topMouseMove",
- // folly::dynamic::object("registrationName",
- // "onMouseMove"))
+ eventTypes.update(
+ folly::dynamic::object
+ ("topLayout", folly::dynamic::object("registrationName", "onLayout"))
+ ("topMouseEnter", folly::dynamic::object("registrationName", "onMouseEnter"))
+ ("topMouseLeave", folly::dynamic::object("registrationName", "onMouseLeave"))
+ ("topPointerEntered", folly::dynamic::object("registrationName", "PointerEntered"))
+ ("topPointerExited", folly::dynamic::object("registrationName", "PointerExited"))
+ ("topPointerPressed", folly::dynamic::object("registrationName", "PointerPressed"))
+ ("topPointerReleased", folly::dynamic::object("registrationName", "PointerReleased"))
);
return eventTypes;
}
diff --git a/vnext/ReactUWP/Views/ViewPanel.cpp b/vnext/ReactUWP/Views/ViewPanel.cpp
index 8dd3bf0c86d..b3d41bbe039 100644
--- a/vnext/ReactUWP/Views/ViewPanel.cpp
+++ b/vnext/ReactUWP/Views/ViewPanel.cpp
@@ -148,6 +148,18 @@ winrt::AutomationPeer ViewPanel::OnCreateAutomationPeer() {
}
winrt::Size ViewPanel::MeasureOverride(winrt::Size availableSize) {
+
+ // HACKATHON: Disable all flexbox-related layout.
+ // Just making ViePanel behave like a Grid with one child
+ winrt::Size desiredSize = {};
+ for (winrt::UIElement child : Children()) {
+ child.Measure(availableSize);
+ desiredSize = child.DesiredSize();
+ break;
+ }
+ return desiredSize;
+
+#if 0
// All children are given as much size as they'd like
winrt::Size childConstraint(INFINITY, INFINITY);
@@ -157,9 +169,20 @@ winrt::Size ViewPanel::MeasureOverride(winrt::Size availableSize) {
// ViewPanels never choose their size, that is completely up to the parent -
// so return no size
return winrt::Size(0, 0);
+#endif
}
winrt::Size ViewPanel::ArrangeOverride(winrt::Size finalSize) {
+
+ // HACKATHON: Disable all flexbox-related layout.
+ // Just making ViePanel behave like a Grid with one child
+ for (winrt::UIElement child : Children()) {
+ child.Arrange({0,0,finalSize.Width,finalSize.Height});
+ break;
+ }
+ return finalSize;
+
+#if 0
for (winrt::UIElement child : Children()) {
double childHeight = 0.0;
double childWidth = 0.0;
@@ -197,6 +220,7 @@ winrt::Size ViewPanel::ArrangeOverride(winrt::Size finalSize) {
UpdateClip(finalSize);
return finalSize;
+#endif
}
void ViewPanel::InsertAt(uint32_t const index, winrt::UIElement const &value)
diff --git a/vnext/Shared/OInstance.cpp b/vnext/Shared/OInstance.cpp
index 69a713099fb..b4cd4372f85 100644
--- a/vnext/Shared/OInstance.cpp
+++ b/vnext/Shared/OInstance.cpp
@@ -622,6 +622,8 @@ void InstanceImpl::loadBundleInternal(
std::string bundlePath =
m_devSettings->bundleRootPath + jsBundleRelativePath + ".bundle";
+ bundlePath = "ms-appx:///Assets/index.uwp.bundle";
+
auto bundleString =
std::make_unique<::react::uwp::StorageFileBigString>(bundlePath);
m_innerInstance->loadScriptFromString(
diff --git a/vnext/ToDoItem.js b/vnext/ToDoItem.js
new file mode 100644
index 00000000000..e602247f1e7
--- /dev/null
+++ b/vnext/ToDoItem.js
@@ -0,0 +1,49 @@
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ * @format
+ * @flow
+ */
+
+import React, {Component} from 'react';
+import {StackPanel, TextBlock} from 'react-native-windows';
+import ToggleSwitch from './Controls/ToggleSwitch';
+
+export default class ToDoItem extends Component {
+ state = {
+ name: this.props.task.name,
+ };
+ /*
+ onSetCompleted(value) {
+ this.props.item.isCompleted = value;
+ this.props.updatePerson();
+ }
+ */
+
+ render() {
+ return (
+
+
+
+
+ );
+ }
+
+ onToggleSwitchChanged = value => {
+ this.props.task.isCompleted = value;
+ this.props.updateTaskList();
+ };
+
+ onPointerEntered = () => {
+ this.setState({showHover: true});
+ };
+ onPointerExited = () => {
+ this.setState({showHover: false});
+ };
+}
diff --git a/vnext/ToDoItemList.js b/vnext/ToDoItemList.js
new file mode 100644
index 00000000000..8d822ee6694
--- /dev/null
+++ b/vnext/ToDoItemList.js
@@ -0,0 +1,89 @@
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ * @format
+ * @flow
+ */
+
+import React, {Component} from 'react';
+import {StackPanel, Grid, TextBlock} from 'react-native-windows';
+import ToDoItem from './ToDoItem';
+import TaskList from './data/TaskList';
+
+export default class ToDoItemList extends Component {
+ state = {
+ name: this.props.taskList.name,
+ completionRate: this.props.taskList.completionRate,
+ pointerPressed: false,
+ expanded: true,
+ };
+
+ toPercentage(value) {
+ return (100 * value).toFixed(0).toString() + '%';
+ }
+
+ updateTaskList = () => {
+ this.setState({
+ completionRate: this.props.taskList.completionRate,
+ });
+ };
+
+ onPointerPressed = () => {
+ this.setState({
+ pointerPressed: true,
+ });
+ };
+
+ onPointerReleased = () => {
+ if (this.state.pointerPressed) {
+ this.setState({
+ expanded: !this.state.expanded,
+ });
+ }
+ };
+
+ render() {
+ return (
+
+
+
+
+
+ {this.state.expanded && this.renderItems()}
+
+ );
+ }
+
+ renderItems() {
+ const items = [];
+ var tasks = this.props.taskList.tasks;
+ for (var i = 0; i < tasks.length; i++) {
+ items.push(
+ ,
+ );
+ }
+ return items;
+ }
+}
diff --git a/vnext/ToDoList.js b/vnext/ToDoList.js
new file mode 100644
index 00000000000..3ae7df34a2b
--- /dev/null
+++ b/vnext/ToDoList.js
@@ -0,0 +1,31 @@
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ * @format
+ * @flow
+ */
+
+import React, {Component} from 'react';
+import {StackPanel} from 'react-native-windows';
+import ToDoItemList from './ToDoItemList';
+
+export default class ToDoList extends Component {
+ state = {
+ tasks: this.props.tasks,
+ };
+
+ render() {
+ return (
+ {this.renderToDoList()}
+ );
+ }
+
+ renderToDoList() {
+ const items = [];
+ var tasks = this.state.tasks;
+ for (var i = 0; i < tasks.length; i++) {
+ items.push();
+ }
+ return items;
+ }
+}
diff --git a/vnext/Universal.SampleApp/index.uwp.js b/vnext/Universal.SampleApp/index.uwp.js
index 1af72288dbb..a87bb52ce5e 100644
--- a/vnext/Universal.SampleApp/index.uwp.js
+++ b/vnext/Universal.SampleApp/index.uwp.js
@@ -21,7 +21,15 @@ import {
TouchableHighlight,
ActivityIndicator,
} from 'react-native';
-import {CheckBox, DatePicker, Popup, Picker} from 'react-native-windows';
+import {
+ CheckBox,
+ DatePicker,
+ Popup,
+ Picker,
+ TextBlock,
+ Grid,
+ StackPanel,
+} from 'react-native-windows';
class TicTacButton extends Component {
constructor(props) {
@@ -67,6 +75,10 @@ class PopupButton extends Component {
return (
isLightDismissEnabled:
+
+
+
+
this.setState({isLightDismissEnabled: value})}
diff --git a/vnext/Universal.SampleApp/reactxaml.uwp.js b/vnext/Universal.SampleApp/reactxaml.uwp.js
new file mode 100644
index 00000000000..8ae4880890d
--- /dev/null
+++ b/vnext/Universal.SampleApp/reactxaml.uwp.js
@@ -0,0 +1,68 @@
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ * @format
+ * @flow
+ */
+
+import React, {Component} from 'react';
+import {AppRegistry} from 'react-native';
+import {TextBlock, Grid, StackPanel, Rectangle} from 'react-native-windows';
+
+export default class Bootstrap extends Component {
+ constructor() {
+ super();
+ this.state = {
+ pointerEntered: false,
+ pointerPressed: false,
+ };
+ }
+
+ render() {
+ return (
+
+
+
+
+
+
+
+
+ );
+ }
+
+ onPointerEnter = () => {
+ this.setState({pointerEntered: true});
+ };
+ onPointerExit = () => {
+ this.setState({pointerEntered: false});
+ };
+ onPointerPressed = () => {
+ this.setState({pointerPressed: true});
+ };
+ onPointerReleased = () => {
+ this.setState({pointerPressed: false});
+ };
+}
+
+AppRegistry.registerComponent('Bootstrap', () => Bootstrap);
diff --git a/vnext/data/SampleData.js b/vnext/data/SampleData.js
new file mode 100644
index 00000000000..02de4fed79a
--- /dev/null
+++ b/vnext/data/SampleData.js
@@ -0,0 +1,36 @@
+// © Microsoft Corporation. All rights reserved.
+
+import TaskList from './TaskList';
+
+const tolkien = new TaskList('J.R.R. Tolkien');
+tolkien.addTask('Finish work on Recipes of Middle Earth');
+tolkien.addTask('Continue Orc experiments');
+tolkien.addTask('Replenish pipe tabacco supplies');
+
+const columbus = new TaskList('Christopher Columbus');
+columbus.addTask('Investor meeting to secure funding');
+columbus.addTask('Practice sea navigation techniques');
+columbus.addTask('Test whether dining table is round or flat');
+columbus.addTask('Attend geography class');
+
+const caesar = new TaskList('Julius Caesar');
+caesar.addTask('Work on Senate speech (due Mar 15)');
+caesar.addTask('Experiment with various salad dressings');
+caesar.addTask('Pose for sculpture');
+caesar.addTask('Coffee with Brutus');
+
+const vader = new TaskList('Darth Vader');
+vader.addTask('Meet with color consultant for Death Star decor');
+vader.addTask('Attend anger management class');
+vader.addTask('Lead troops in deep breathing exercises');
+
+const tasks = [
+ tolkien,
+ columbus,
+ caesar,
+ vader,
+];
+
+module.exports = {
+ getTasks: () => tasks.concat(),
+};
diff --git a/vnext/data/Task.js b/vnext/data/Task.js
new file mode 100644
index 00000000000..ee2cec7dd6f
--- /dev/null
+++ b/vnext/data/Task.js
@@ -0,0 +1,12 @@
+// © Microsoft Corporation. All rights reserved.
+
+export default class Task {
+ constructor(name) {
+ this.name = name;
+ this.isCompleted = false;
+ }
+
+ toggleCompleted() {
+ this.isCompleted = !this.isCompleted;
+ }
+}
diff --git a/vnext/data/TaskList.js b/vnext/data/TaskList.js
new file mode 100644
index 00000000000..a32d47e5e73
--- /dev/null
+++ b/vnext/data/TaskList.js
@@ -0,0 +1,24 @@
+// © Microsoft Corporation. All rights reserved.
+
+import Task from './Task';
+
+export default class TaskList {
+ constructor(name) {
+ this.name = name;
+ this.tasks = [];
+ }
+
+ get completionRate() {
+ if (this.tasks.length == 0) {
+ return 1.0;
+ }
+
+ return this.tasks.filter((t) => t.isCompleted).length / this.tasks.length;
+ }
+
+ addTask(name) {
+ let task = new Task(name);
+
+ this.tasks.push(task);
+ }
+}
diff --git a/vnext/include/CppWinRTIncludes.h b/vnext/include/CppWinRTIncludes.h
index bbd92514dfa..bb812ba50ca 100644
--- a/vnext/include/CppWinRTIncludes.h
+++ b/vnext/include/CppWinRTIncludes.h
@@ -11,6 +11,7 @@
#include
#include
#include
+#include
namespace winrt {
using namespace ::winrt::Windows::UI::Xaml;
@@ -22,4 +23,5 @@ using namespace Windows::UI::Xaml::Controls;
using namespace Windows::UI::Xaml::Controls::Primitives;
using namespace Windows::UI::Composition;
using namespace Windows::UI::Xaml::Hosting;
+using namespace ::winrt::Windows::UI::Xaml::Shapes;
} // namespace winrt
diff --git a/vnext/include/ReactUWP/Utils/ValueUtils.h b/vnext/include/ReactUWP/Utils/ValueUtils.h
index 8d153288eb2..f3bc5324162 100644
--- a/vnext/include/ReactUWP/Utils/ValueUtils.h
+++ b/vnext/include/ReactUWP/Utils/ValueUtils.h
@@ -23,6 +23,7 @@ REACTWINDOWS_API_(winrt::Windows::UI::Xaml::Media::Brush)
BrushFrom(const folly::dynamic &d);
REACTWINDOWS_API_(winrt::Windows::UI::Xaml::Media::SolidColorBrush)
SolidColorBrushFrom(const folly::dynamic &d);
+winrt::Windows::UI::Xaml::Media::SolidColorBrush SolidColorBrushFromColor(const std::string& color);
REACTWINDOWS_API_(winrt::Windows::UI::Xaml::VerticalAlignment)
VerticalAlignmentFrom(const folly::dynamic &d);
REACTWINDOWS_API_(winrt::Windows::UI::Xaml::HorizontalAlignment)
diff --git a/vnext/include/ReactUWP/Views/FrameworkElementViewManager.h b/vnext/include/ReactUWP/Views/FrameworkElementViewManager.h
index 942b46c0b54..5a13e2b30d6 100644
--- a/vnext/include/ReactUWP/Views/FrameworkElementViewManager.h
+++ b/vnext/include/ReactUWP/Views/FrameworkElementViewManager.h
@@ -9,6 +9,7 @@
namespace react {
namespace uwp {
+#pragma warning (disable : 4251)
class REACTWINDOWS_EXPORT FrameworkElementViewManager : public ViewManagerBase {
using Super = ViewManagerBase;
diff --git a/vnext/include/ReactUWP/Views/ShadowNodeBase.h b/vnext/include/ReactUWP/Views/ShadowNodeBase.h
index a366235acf7..0b180ba5ea2 100644
--- a/vnext/include/ReactUWP/Views/ShadowNodeBase.h
+++ b/vnext/include/ReactUWP/Views/ShadowNodeBase.h
@@ -104,6 +104,10 @@ struct REACTWINDOWS_EXPORT ShadowNodeBase : public facebook::react::ShadowNode {
winrt::Windows::UI::Composition::CompositionPropertySet EnsureTransformPS();
void UpdateTransformPS();
+ // HACKATHON: pointer event handlers for everyone
+ void AddPointerPressedHandler();
+ void AddPointerReleasedHandler();
+
protected:
XamlView m_view;
bool m_updating = false;
@@ -130,6 +134,8 @@ struct REACTWINDOWS_EXPORT ShadowNodeBase : public facebook::react::ShadowNode {
private:
void EnsureHandledKeyboardEventHandler();
std::unique_ptr m_handledKeyboardEventHandler;
+ winrt::FrameworkElement::PointerPressed_revoker m_pointerPressedRevoker{};
+ winrt::FrameworkElement::PointerReleased_revoker m_pointerReleasedRevoker{};
};
#pragma warning(pop)
diff --git a/vnext/index.js b/vnext/index.js
index d4d46c76a54..093d7de9019 100644
--- a/vnext/index.js
+++ b/vnext/index.js
@@ -18,5 +18,9 @@ __export(require("./Libraries/Components/Popup/Popup"));
__export(require("./Libraries/Components/Keyboard/KeyboardExt"));
__export(require("./Libraries/Components/Keyboard/KeyboardExtProps"));
__export(require("./Libraries/Components/View/ViewWindows"));
+__export(require("./Libraries/Components/ReactXaml/TextBlock"));
+__export(require("./Libraries/Components/ReactXaml/Grid"));
+__export(require("./Libraries/Components/ReactXaml/StackPanel"));
+__export(require("./Libraries/Components/ReactXaml/Rectangle"));
__export(require("./Libraries/AppTheme/AppTheme"));
//# sourceMappingURL=index.js.map
\ No newline at end of file
diff --git a/vnext/index.uwp.js b/vnext/index.uwp.js
index bf6346a0f08..fe8613d07a0 100644
--- a/vnext/index.uwp.js
+++ b/vnext/index.uwp.js
@@ -1,22 +1,37 @@
-"use strict";
-function __export(m) {
- for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
-Object.defineProperty(exports, "__esModule", { value: true });
/**
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License.
* @format
+ * @flow
*/
-__export(require("./Libraries/Components/CheckBox/CheckBox.uwp"));
-__export(require("./Libraries/Components/DatePicker/DatePicker.uwp"));
-__export(require("./Libraries/Components/DatePicker/DatePickerProps"));
-__export(require("./Libraries/Components/Flyout/Flyout.uwp"));
-__export(require("./Libraries/Components/Glyph/Glyph.uwp"));
-__export(require("./Libraries/Components/Picker/PickerUWP.uwp"));
-__export(require("./Libraries/Components/Popup/Popup.uwp"));
-__export(require("./Libraries/Components/Keyboard/KeyboardExt.uwp"));
-__export(require("./Libraries/Components/Keyboard/KeyboardExtProps"));
-__export(require("./Libraries/Components/View/ViewWindows.uwp"));
-__export(require("./Libraries/AppTheme/AppTheme.uwp"));
-//# sourceMappingURL=index.uwp.js.map
\ No newline at end of file
+
+import React, {Component} from 'react';
+import {AppRegistry} from 'react-native';
+import {StackPanel} from 'react-native-windows';
+import ToDoList from './ToDoList';
+import SampleData from './data/SampleData';
+
+const initialState = {
+ tasks: SampleData.getTasks(),
+};
+
+export default class ToDoListApp extends Component {
+ constructor() {
+ super();
+ this.state = initialState;
+ }
+
+ render() {
+ return (
+
+
+
+ );
+ }
+
+ toggleSwitchChanged(toggleState) {
+ this.setState({dude: toggleState});
+ }
+}
+
+AppRegistry.registerComponent('ToDoListApp', () => ToDoListApp);
diff --git a/vnext/src/Libraries/Components/ReactXaml/FrameworkElementProps.ts b/vnext/src/Libraries/Components/ReactXaml/FrameworkElementProps.ts
new file mode 100644
index 00000000000..23fdf9db1d9
--- /dev/null
+++ b/vnext/src/Libraries/Components/ReactXaml/FrameworkElementProps.ts
@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ * @format
+ */
+import {ViewProps} from 'react-native';
+
+export interface IFrameworkElementProps extends ViewProps {
+ Width?: string;
+ Height?: string;
+ HorizontalAlignment?: string;
+ VerticalAlignment?: string;
+ Translation?: string;
+ PointerEntered?: () => void;
+ PointerExited?: () => void;
+ PointerPressed?: () => void;
+ PointerReleased?: () => void;
+}
diff --git a/vnext/src/Libraries/Components/ReactXaml/Grid.tsx b/vnext/src/Libraries/Components/ReactXaml/Grid.tsx
new file mode 100644
index 00000000000..8e3e23c509b
--- /dev/null
+++ b/vnext/src/Libraries/Components/ReactXaml/Grid.tsx
@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ * @format
+ */
+'use strict';
+
+import * as React from 'react';
+import {IGridProps} from './GridProps';
+
+export class Grid extends React.Component {
+ public render(): JSX.Element | null {
+ return null;
+ }
+}
+
+export default Grid;
diff --git a/vnext/src/Libraries/Components/ReactXaml/Grid.uwp.tsx b/vnext/src/Libraries/Components/ReactXaml/Grid.uwp.tsx
new file mode 100644
index 00000000000..da92fa9a383
--- /dev/null
+++ b/vnext/src/Libraries/Components/ReactXaml/Grid.uwp.tsx
@@ -0,0 +1,34 @@
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ * @format
+ */
+'use strict';
+
+import * as React from 'react';
+import {requireNativeComponent} from 'react-native';
+import {IGridProps} from './GridProps';
+
+/*
+const styles = StyleSheet.create({
+ rctFlyout: {
+ position: 'absolute',
+ },
+});
+*/
+
+const RCTGrid = requireNativeComponent('RCTGrid');
+
+export class Grid extends React.Component {
+ constructor(props: IGridProps) {
+ super(props);
+ }
+
+ public render(): JSX.Element {
+ const props = {...this.props};
+
+ return ;
+ }
+}
+
+export default Grid;
diff --git a/vnext/src/Libraries/Components/ReactXaml/GridProps.ts b/vnext/src/Libraries/Components/ReactXaml/GridProps.ts
new file mode 100644
index 00000000000..e8e969d746f
--- /dev/null
+++ b/vnext/src/Libraries/Components/ReactXaml/GridProps.ts
@@ -0,0 +1,14 @@
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ * @format
+ */
+import {IPanelProps} from './PanelProps';
+
+export interface IGridProps extends IPanelProps {
+ RowDefinitions?: string;
+ ColumnDefinitions?: string;
+ CornerRadius?: string;
+ BorderBrush?: string;
+ BorderThickness?: string;
+}
diff --git a/vnext/src/Libraries/Components/ReactXaml/PanelProps.ts b/vnext/src/Libraries/Components/ReactXaml/PanelProps.ts
new file mode 100644
index 00000000000..330ca3dcda1
--- /dev/null
+++ b/vnext/src/Libraries/Components/ReactXaml/PanelProps.ts
@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ * @format
+ */
+import {IFrameworkElementProps} from './FrameworkElementProps';
+
+export interface IPanelProps extends IFrameworkElementProps {
+ Background?: string;
+}
diff --git a/vnext/src/Libraries/Components/ReactXaml/Rectangle.tsx b/vnext/src/Libraries/Components/ReactXaml/Rectangle.tsx
new file mode 100644
index 00000000000..c3173d14eeb
--- /dev/null
+++ b/vnext/src/Libraries/Components/ReactXaml/Rectangle.tsx
@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ * @format
+ */
+'use strict';
+
+import * as React from 'react';
+import {IRectangleProps} from './RectangleProps';
+
+export class Rectangle extends React.Component {
+ public render(): JSX.Element | null {
+ return null;
+ }
+}
+
+export default Rectangle;
diff --git a/vnext/src/Libraries/Components/ReactXaml/Rectangle.uwp.tsx b/vnext/src/Libraries/Components/ReactXaml/Rectangle.uwp.tsx
new file mode 100644
index 00000000000..d0bc74c3e8f
--- /dev/null
+++ b/vnext/src/Libraries/Components/ReactXaml/Rectangle.uwp.tsx
@@ -0,0 +1,34 @@
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ * @format
+ */
+'use strict';
+
+import * as React from 'react';
+import {requireNativeComponent} from 'react-native';
+import {IRectangleProps} from './RectangleProps';
+
+/*
+const styles = StyleSheet.create({
+ rctFlyout: {
+ position: 'absolute',
+ },
+});
+*/
+
+const RCTRectangle = requireNativeComponent('RCTRectangle');
+
+export class Rectangle extends React.Component {
+ constructor(props: IRectangleProps) {
+ super(props);
+ }
+
+ public render(): JSX.Element {
+ const props = {...this.props};
+
+ return ;
+ }
+}
+
+export default Rectangle;
diff --git a/vnext/src/Libraries/Components/ReactXaml/RectangleProps.ts b/vnext/src/Libraries/Components/ReactXaml/RectangleProps.ts
new file mode 100644
index 00000000000..caa1c50df59
--- /dev/null
+++ b/vnext/src/Libraries/Components/ReactXaml/RectangleProps.ts
@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ * @format
+ */
+import {IFrameworkElementProps} from './FrameworkElementProps';
+
+export interface IRectangleProps extends IFrameworkElementProps {
+ Fill?: string;
+ RadiusX?: string;
+ RadiusY?: string;
+}
diff --git a/vnext/src/Libraries/Components/ReactXaml/StackPanel.tsx b/vnext/src/Libraries/Components/ReactXaml/StackPanel.tsx
new file mode 100644
index 00000000000..c1f986a804a
--- /dev/null
+++ b/vnext/src/Libraries/Components/ReactXaml/StackPanel.tsx
@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ * @format
+ */
+'use strict';
+
+import * as React from 'react';
+import {IStackPanelProps} from './StackPanelProps';
+
+export class StackPanel extends React.Component {
+ public render(): JSX.Element | null {
+ return null;
+ }
+}
+
+export default StackPanel;
diff --git a/vnext/src/Libraries/Components/ReactXaml/StackPanel.uwp.tsx b/vnext/src/Libraries/Components/ReactXaml/StackPanel.uwp.tsx
new file mode 100644
index 00000000000..75fa27ca6e8
--- /dev/null
+++ b/vnext/src/Libraries/Components/ReactXaml/StackPanel.uwp.tsx
@@ -0,0 +1,34 @@
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ * @format
+ */
+'use strict';
+
+import * as React from 'react';
+import {requireNativeComponent} from 'react-native';
+import {IStackPanelProps} from './StackPanelProps';
+
+/*
+const styles = StyleSheet.create({
+ rctFlyout: {
+ position: 'absolute',
+ },
+});
+*/
+
+const RCTStackPanel = requireNativeComponent('RCTStackPanel');
+
+export class StackPanel extends React.Component {
+ constructor(props: IStackPanelProps) {
+ super(props);
+ }
+
+ public render(): JSX.Element {
+ const props = {...this.props};
+
+ return ;
+ }
+}
+
+export default StackPanel;
diff --git a/vnext/src/Libraries/Components/ReactXaml/StackPanelProps.ts b/vnext/src/Libraries/Components/ReactXaml/StackPanelProps.ts
new file mode 100644
index 00000000000..af223b03c45
--- /dev/null
+++ b/vnext/src/Libraries/Components/ReactXaml/StackPanelProps.ts
@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ * @format
+ */
+import {IPanelProps} from './PanelProps';
+
+export interface IStackPanelProps extends IPanelProps {
+ Orientation?: string;
+ BorderBrush?: string;
+ BorderThickness?: string;
+}
diff --git a/vnext/src/Libraries/Components/ReactXaml/TextBlock.tsx b/vnext/src/Libraries/Components/ReactXaml/TextBlock.tsx
new file mode 100644
index 00000000000..d2a6d27b27a
--- /dev/null
+++ b/vnext/src/Libraries/Components/ReactXaml/TextBlock.tsx
@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ * @format
+ */
+'use strict';
+
+import * as React from 'react';
+import {ITextBlockProps} from './TextBlockProps';
+
+export class TextBlock extends React.Component {
+ public render(): JSX.Element | null {
+ return null;
+ }
+}
+
+export default TextBlock;
diff --git a/vnext/src/Libraries/Components/ReactXaml/TextBlock.uwp.tsx b/vnext/src/Libraries/Components/ReactXaml/TextBlock.uwp.tsx
new file mode 100644
index 00000000000..4762ced56e9
--- /dev/null
+++ b/vnext/src/Libraries/Components/ReactXaml/TextBlock.uwp.tsx
@@ -0,0 +1,34 @@
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ * @format
+ */
+'use strict';
+
+import * as React from 'react';
+import {requireNativeComponent} from 'react-native';
+import {ITextBlockProps} from './TextBlockProps';
+
+/*
+const styles = StyleSheet.create({
+ rctFlyout: {
+ position: 'absolute',
+ },
+});
+*/
+
+const RCTTextBlock = requireNativeComponent('RCTTextBlock');
+
+export class TextBlock extends React.Component {
+ constructor(props: ITextBlockProps) {
+ super(props);
+ }
+
+ public render(): JSX.Element {
+ const props = {...this.props};
+
+ return ;
+ }
+}
+
+export default TextBlock;
diff --git a/vnext/src/Libraries/Components/ReactXaml/TextBlockProps.ts b/vnext/src/Libraries/Components/ReactXaml/TextBlockProps.ts
new file mode 100644
index 00000000000..ea745aea55b
--- /dev/null
+++ b/vnext/src/Libraries/Components/ReactXaml/TextBlockProps.ts
@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ * @format
+ */
+import {IFrameworkElementProps} from './FrameworkElementProps';
+
+export interface ITextBlockProps extends IFrameworkElementProps {
+ Text?: string;
+ FontSize?: string;
+}
diff --git a/vnext/src/index.ts b/vnext/src/index.ts
index 70e20173e27..2a30e33feec 100644
--- a/vnext/src/index.ts
+++ b/vnext/src/index.ts
@@ -14,5 +14,9 @@ export * from './Libraries/Components/Keyboard/KeyboardExt';
export * from './Libraries/Components/Keyboard/KeyboardExtProps';
export * from './Libraries/Components/View/ViewWindowsProps';
export * from './Libraries/Components/View/ViewWindows';
+export * from './Libraries/Components/ReactXaml/TextBlock';
+export * from './Libraries/Components/ReactXaml/Grid';
+export * from './Libraries/Components/ReactXaml/StackPanel';
+export * from './Libraries/Components/ReactXaml/Rectangle';
export * from './Libraries/AppTheme/AppTheme';
export * from './Libraries/AppTheme/AppThemeTypes';
diff --git a/vnext/src/index.uwp.ts b/vnext/src/index.uwp.ts
index 6262e5e3351..b7449a3d47e 100644
--- a/vnext/src/index.uwp.ts
+++ b/vnext/src/index.uwp.ts
@@ -14,5 +14,9 @@ export * from './Libraries/Components/Keyboard/KeyboardExt.uwp';
export * from './Libraries/Components/Keyboard/KeyboardExtProps';
export * from './Libraries/Components/View/ViewWindowsProps';
export * from './Libraries/Components/View/ViewWindows.uwp';
+export * from './Libraries/Components/ReactXaml/TextBlock.uwp';
+export * from './Libraries/Components/ReactXaml/Grid.uwp';
+export * from './Libraries/Components/ReactXaml/StackPanel.uwp';
+export * from './Libraries/Components/ReactXaml/Rectangle.uwp';
export * from './Libraries/AppTheme/AppTheme.uwp';
export * from './Libraries/AppTheme/AppThemeTypes';
diff --git a/vnext/todolist/App.js b/vnext/todolist/App.js
new file mode 100644
index 00000000000..fe8613d07a0
--- /dev/null
+++ b/vnext/todolist/App.js
@@ -0,0 +1,37 @@
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ * @format
+ * @flow
+ */
+
+import React, {Component} from 'react';
+import {AppRegistry} from 'react-native';
+import {StackPanel} from 'react-native-windows';
+import ToDoList from './ToDoList';
+import SampleData from './data/SampleData';
+
+const initialState = {
+ tasks: SampleData.getTasks(),
+};
+
+export default class ToDoListApp extends Component {
+ constructor() {
+ super();
+ this.state = initialState;
+ }
+
+ render() {
+ return (
+
+
+
+ );
+ }
+
+ toggleSwitchChanged(toggleState) {
+ this.setState({dude: toggleState});
+ }
+}
+
+AppRegistry.registerComponent('ToDoListApp', () => ToDoListApp);
diff --git a/vnext/todolist/Controls/ToggleSwitch.js b/vnext/todolist/Controls/ToggleSwitch.js
new file mode 100644
index 00000000000..b7b13c91bf9
--- /dev/null
+++ b/vnext/todolist/Controls/ToggleSwitch.js
@@ -0,0 +1,59 @@
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ * @format
+ * @flow
+ */
+
+import React, {Component} from 'react';
+import {Grid, Rectangle} from 'react-native-windows';
+
+export default class ToggleSwitch extends Component {
+ constructor() {
+ super();
+ this.state = {
+ on: false,
+ pointerDown: false,
+ };
+ }
+
+ render() {
+ return (
+
+
+
+ );
+ }
+
+ onPointerPressed = () => {
+ this.setState({pointerDown: true});
+ };
+
+ onPointerReleased = () => {
+ if (this.state.pointerDown) {
+ this.updateToggleState(!this.state.on);
+ }
+ this.setState({pointerDown: false});
+ };
+
+ updateToggleState(toggleState) {
+ this.setState({on: toggleState});
+ this.props.onToggleSwitchChanged(toggleState);
+ }
+}
diff --git a/vnext/todolist/ToDoItem.js b/vnext/todolist/ToDoItem.js
new file mode 100644
index 00000000000..e602247f1e7
--- /dev/null
+++ b/vnext/todolist/ToDoItem.js
@@ -0,0 +1,49 @@
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ * @format
+ * @flow
+ */
+
+import React, {Component} from 'react';
+import {StackPanel, TextBlock} from 'react-native-windows';
+import ToggleSwitch from './Controls/ToggleSwitch';
+
+export default class ToDoItem extends Component {
+ state = {
+ name: this.props.task.name,
+ };
+ /*
+ onSetCompleted(value) {
+ this.props.item.isCompleted = value;
+ this.props.updatePerson();
+ }
+ */
+
+ render() {
+ return (
+
+
+
+
+ );
+ }
+
+ onToggleSwitchChanged = value => {
+ this.props.task.isCompleted = value;
+ this.props.updateTaskList();
+ };
+
+ onPointerEntered = () => {
+ this.setState({showHover: true});
+ };
+ onPointerExited = () => {
+ this.setState({showHover: false});
+ };
+}
diff --git a/vnext/todolist/ToDoItemList.js b/vnext/todolist/ToDoItemList.js
new file mode 100644
index 00000000000..8d822ee6694
--- /dev/null
+++ b/vnext/todolist/ToDoItemList.js
@@ -0,0 +1,89 @@
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ * @format
+ * @flow
+ */
+
+import React, {Component} from 'react';
+import {StackPanel, Grid, TextBlock} from 'react-native-windows';
+import ToDoItem from './ToDoItem';
+import TaskList from './data/TaskList';
+
+export default class ToDoItemList extends Component {
+ state = {
+ name: this.props.taskList.name,
+ completionRate: this.props.taskList.completionRate,
+ pointerPressed: false,
+ expanded: true,
+ };
+
+ toPercentage(value) {
+ return (100 * value).toFixed(0).toString() + '%';
+ }
+
+ updateTaskList = () => {
+ this.setState({
+ completionRate: this.props.taskList.completionRate,
+ });
+ };
+
+ onPointerPressed = () => {
+ this.setState({
+ pointerPressed: true,
+ });
+ };
+
+ onPointerReleased = () => {
+ if (this.state.pointerPressed) {
+ this.setState({
+ expanded: !this.state.expanded,
+ });
+ }
+ };
+
+ render() {
+ return (
+
+
+
+
+
+ {this.state.expanded && this.renderItems()}
+
+ );
+ }
+
+ renderItems() {
+ const items = [];
+ var tasks = this.props.taskList.tasks;
+ for (var i = 0; i < tasks.length; i++) {
+ items.push(
+ ,
+ );
+ }
+ return items;
+ }
+}
diff --git a/vnext/todolist/ToDoList.js b/vnext/todolist/ToDoList.js
new file mode 100644
index 00000000000..3ae7df34a2b
--- /dev/null
+++ b/vnext/todolist/ToDoList.js
@@ -0,0 +1,31 @@
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ * @format
+ * @flow
+ */
+
+import React, {Component} from 'react';
+import {StackPanel} from 'react-native-windows';
+import ToDoItemList from './ToDoItemList';
+
+export default class ToDoList extends Component {
+ state = {
+ tasks: this.props.tasks,
+ };
+
+ render() {
+ return (
+ {this.renderToDoList()}
+ );
+ }
+
+ renderToDoList() {
+ const items = [];
+ var tasks = this.state.tasks;
+ for (var i = 0; i < tasks.length; i++) {
+ items.push();
+ }
+ return items;
+ }
+}
diff --git a/vnext/todolist/data/SampleData.js b/vnext/todolist/data/SampleData.js
new file mode 100644
index 00000000000..02de4fed79a
--- /dev/null
+++ b/vnext/todolist/data/SampleData.js
@@ -0,0 +1,36 @@
+// © Microsoft Corporation. All rights reserved.
+
+import TaskList from './TaskList';
+
+const tolkien = new TaskList('J.R.R. Tolkien');
+tolkien.addTask('Finish work on Recipes of Middle Earth');
+tolkien.addTask('Continue Orc experiments');
+tolkien.addTask('Replenish pipe tabacco supplies');
+
+const columbus = new TaskList('Christopher Columbus');
+columbus.addTask('Investor meeting to secure funding');
+columbus.addTask('Practice sea navigation techniques');
+columbus.addTask('Test whether dining table is round or flat');
+columbus.addTask('Attend geography class');
+
+const caesar = new TaskList('Julius Caesar');
+caesar.addTask('Work on Senate speech (due Mar 15)');
+caesar.addTask('Experiment with various salad dressings');
+caesar.addTask('Pose for sculpture');
+caesar.addTask('Coffee with Brutus');
+
+const vader = new TaskList('Darth Vader');
+vader.addTask('Meet with color consultant for Death Star decor');
+vader.addTask('Attend anger management class');
+vader.addTask('Lead troops in deep breathing exercises');
+
+const tasks = [
+ tolkien,
+ columbus,
+ caesar,
+ vader,
+];
+
+module.exports = {
+ getTasks: () => tasks.concat(),
+};
diff --git a/vnext/todolist/data/Task.js b/vnext/todolist/data/Task.js
new file mode 100644
index 00000000000..ee2cec7dd6f
--- /dev/null
+++ b/vnext/todolist/data/Task.js
@@ -0,0 +1,12 @@
+// © Microsoft Corporation. All rights reserved.
+
+export default class Task {
+ constructor(name) {
+ this.name = name;
+ this.isCompleted = false;
+ }
+
+ toggleCompleted() {
+ this.isCompleted = !this.isCompleted;
+ }
+}
diff --git a/vnext/todolist/data/TaskList.js b/vnext/todolist/data/TaskList.js
new file mode 100644
index 00000000000..a32d47e5e73
--- /dev/null
+++ b/vnext/todolist/data/TaskList.js
@@ -0,0 +1,24 @@
+// © Microsoft Corporation. All rights reserved.
+
+import Task from './Task';
+
+export default class TaskList {
+ constructor(name) {
+ this.name = name;
+ this.tasks = [];
+ }
+
+ get completionRate() {
+ if (this.tasks.length == 0) {
+ return 1.0;
+ }
+
+ return this.tasks.filter((t) => t.isCompleted).length / this.tasks.length;
+ }
+
+ addTask(name) {
+ let task = new Task(name);
+
+ this.tasks.push(task);
+ }
+}
diff --git a/vnext/todolist/index.uwp.js b/vnext/todolist/index.uwp.js
new file mode 100644
index 00000000000..fe8613d07a0
--- /dev/null
+++ b/vnext/todolist/index.uwp.js
@@ -0,0 +1,37 @@
+/**
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ * @format
+ * @flow
+ */
+
+import React, {Component} from 'react';
+import {AppRegistry} from 'react-native';
+import {StackPanel} from 'react-native-windows';
+import ToDoList from './ToDoList';
+import SampleData from './data/SampleData';
+
+const initialState = {
+ tasks: SampleData.getTasks(),
+};
+
+export default class ToDoListApp extends Component {
+ constructor() {
+ super();
+ this.state = initialState;
+ }
+
+ render() {
+ return (
+
+
+
+ );
+ }
+
+ toggleSwitchChanged(toggleState) {
+ this.setState({dude: toggleState});
+ }
+}
+
+AppRegistry.registerComponent('ToDoListApp', () => ToDoListApp);