1 /** @license React v16.9.0

     1 /** @license React v16.13.1

    13 	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :

    13   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :

    14 	typeof define === 'function' && define.amd ? define(factory) :

    14   typeof define === 'function' && define.amd ? define(['exports'], factory) :

    15 	(global.React = factory());

    15   (global = global || self, factory(global.React = {}));

    16 }(this, (function () { 'use strict';

    16 }(this, (function (exports) { 'use strict';

    17 

    17 

    18 // TODO: this is special because it gets imported during build.

    18   var ReactVersion = '16.13.1';

    19 

    19 

    20 var ReactVersion = '16.9.0';

    20   // The Symbol used to tag the ReactElement-like types. If there is no native Symbol

    21 

    21   // nor polyfill, then a plain number is used for performance.

    22 // The Symbol used to tag the ReactElement-like types. If there is no native Symbol

    22   var hasSymbol = typeof Symbol === 'function' && Symbol.for;

    23 // nor polyfill, then a plain number is used for performance.

    23   var REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for('react.element') : 0xeac7;

    24 var hasSymbol = typeof Symbol === 'function' && Symbol.for;

    24   var REACT_PORTAL_TYPE = hasSymbol ? Symbol.for('react.portal') : 0xeaca;

    25 

    25   var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for('react.fragment') : 0xeacb;

    26 var REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for('react.element') : 0xeac7;

    26   var REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for('react.strict_mode') : 0xeacc;

    27 var REACT_PORTAL_TYPE = hasSymbol ? Symbol.for('react.portal') : 0xeaca;

    27   var REACT_PROFILER_TYPE = hasSymbol ? Symbol.for('react.profiler') : 0xead2;

    28 var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for('react.fragment') : 0xeacb;

    28   var REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for('react.provider') : 0xeacd;

    29 var REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for('react.strict_mode') : 0xeacc;

    29   var REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for('react.context') : 0xeace; // TODO: We don't use AsyncMode or ConcurrentMode anymore. They were temporary

    30 var REACT_PROFILER_TYPE = hasSymbol ? Symbol.for('react.profiler') : 0xead2;

    30   var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for('react.concurrent_mode') : 0xeacf;

    31 var REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for('react.provider') : 0xeacd;

    31   var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for('react.forward_ref') : 0xead0;

    32 var REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for('react.context') : 0xeace;

    32   var REACT_SUSPENSE_TYPE = hasSymbol ? Symbol.for('react.suspense') : 0xead1;

    33 // TODO: We don't use AsyncMode or ConcurrentMode anymore. They were temporary

    33   var REACT_SUSPENSE_LIST_TYPE = hasSymbol ? Symbol.for('react.suspense_list') : 0xead8;

    34 // (unstable) APIs that have been removed. Can we remove the symbols?

    34   var REACT_MEMO_TYPE = hasSymbol ? Symbol.for('react.memo') : 0xead3;

    35 

    35   var REACT_LAZY_TYPE = hasSymbol ? Symbol.for('react.lazy') : 0xead4;

    36 var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for('react.concurrent_mode') : 0xeacf;

    36   var REACT_BLOCK_TYPE = hasSymbol ? Symbol.for('react.block') : 0xead9;

    37 var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for('react.forward_ref') : 0xead0;

    37   var REACT_FUNDAMENTAL_TYPE = hasSymbol ? Symbol.for('react.fundamental') : 0xead5;

    38 var REACT_SUSPENSE_TYPE = hasSymbol ? Symbol.for('react.suspense') : 0xead1;

    38   var REACT_RESPONDER_TYPE = hasSymbol ? Symbol.for('react.responder') : 0xead6;

    39 var REACT_SUSPENSE_LIST_TYPE = hasSymbol ? Symbol.for('react.suspense_list') : 0xead8;

    39   var REACT_SCOPE_TYPE = hasSymbol ? Symbol.for('react.scope') : 0xead7;

    40 var REACT_MEMO_TYPE = hasSymbol ? Symbol.for('react.memo') : 0xead3;

    40   var MAYBE_ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;

    41 var REACT_LAZY_TYPE = hasSymbol ? Symbol.for('react.lazy') : 0xead4;

    41   var FAUX_ITERATOR_SYMBOL = '@@iterator';

    42 var REACT_FUNDAMENTAL_TYPE = hasSymbol ? Symbol.for('react.fundamental') : 0xead5;

    42   function getIteratorFn(maybeIterable) {

    43 var REACT_RESPONDER_TYPE = hasSymbol ? Symbol.for('react.responder') : 0xead6;

    43     if (maybeIterable === null || typeof maybeIterable !== 'object') {

    44 

    44       return null;

    45 var MAYBE_ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;

    45     }

    46 var FAUX_ITERATOR_SYMBOL = '@@iterator';

    46 

    47 

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

    48 function getIteratorFn(maybeIterable) {

    48 

    49   if (maybeIterable === null || typeof maybeIterable !== 'object') {

    49     if (typeof maybeIterator === 'function') {

    50       return maybeIterator;

    51     }

    52 

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

    55 

    53   if (typeof maybeIterator === 'function') {

    56   /*

    54     return maybeIterator;

    57   object-assign

    55   }

    58   (c) Sindre Sorhus

    56   return null;

    59   @license MIT

    57 }

    60   */

    58 

    61   /* eslint-disable no-unused-vars */

    59 /*

    62   var getOwnPropertySymbols = Object.getOwnPropertySymbols;

    60 object-assign

    63   var hasOwnProperty = Object.prototype.hasOwnProperty;

    61 (c) Sindre Sorhus

    64   var propIsEnumerable = Object.prototype.propertyIsEnumerable;

    62 @license MIT

    65 

    63 */

    66   function toObject(val) {

    64 

    67   	if (val === null || val === undefined) {

    65 

    68   		throw new TypeError('Object.assign cannot be called with null or undefined');

    66 /* eslint-disable no-unused-vars */

    69   	}

    67 var getOwnPropertySymbols = Object.getOwnPropertySymbols;

    70 

    68 var hasOwnProperty = Object.prototype.hasOwnProperty;

    71   	return Object(val);

    69 var propIsEnumerable = Object.prototype.propertyIsEnumerable;

    72   }

    70 

    73 

    71 function toObject(val) {

    74   function shouldUseNative() {

    72 	if (val === null || val === undefined) {

    75   	try {

    73 		throw new TypeError('Object.assign cannot be called with null or undefined');

    76   		if (!Object.assign) {

    74 	}

    77   			return false;

    75 

    78   		}

    76 	return Object(val);

    79 

    77 }

    80   		// Detect buggy property enumeration order in older V8 versions.

    78 

    81 

    79 function shouldUseNative() {

    82   		// https://bugs.chromium.org/p/v8/issues/detail?id=4118

    80 	try {

    83   		var test1 = new String('abc');  // eslint-disable-line no-new-wrappers

    81 		if (!Object.assign) {

    84   		test1[5] = 'de';

    82 			return false;

    85   		if (Object.getOwnPropertyNames(test1)[0] === '5') {

    83 		}

    86   			return false;

    84 

    87   		}

    85 		// Detect buggy property enumeration order in older V8 versions.

    88 

    86 

    89   		// https://bugs.chromium.org/p/v8/issues/detail?id=3056

    87 		// https://bugs.chromium.org/p/v8/issues/detail?id=4118

    90   		var test2 = {};

    88 		var test1 = new String('abc');  // eslint-disable-line no-new-wrappers

    91   		for (var i = 0; i < 10; i++) {

    89 		test1[5] = 'de';

    92   			test2['_' + String.fromCharCode(i)] = i;

    90 		if (Object.getOwnPropertyNames(test1)[0] === '5') {

    93   		}

    91 			return false;

    94   		var order2 = Object.getOwnPropertyNames(test2).map(function (n) {

    92 		}

    95   			return test2[n];

    93 

    96   		});

    94 		// https://bugs.chromium.org/p/v8/issues/detail?id=3056

    97   		if (order2.join('') !== '0123456789') {

    95 		var test2 = {};

    98   			return false;

    96 		for (var i = 0; i < 10; i++) {

    99   		}

    97 			test2['_' + String.fromCharCode(i)] = i;

   100 

    98 		}

   101   		// https://bugs.chromium.org/p/v8/issues/detail?id=3056

    99 		var order2 = Object.getOwnPropertyNames(test2).map(function (n) {

   102   		var test3 = {};

   100 			return test2[n];

   103   		'abcdefghijklmnopqrst'.split('').forEach(function (letter) {

   101 		});

   104   			test3[letter] = letter;

   102 		if (order2.join('') !== '0123456789') {

   105   		});

   103 			return false;

   106   		if (Object.keys(Object.assign({}, test3)).join('') !==

   104 		}

   107   				'abcdefghijklmnopqrst') {

   105 

   108   			return false;

   106 		// https://bugs.chromium.org/p/v8/issues/detail?id=3056

   109   		}

   107 		var test3 = {};

   110 

   108 		'abcdefghijklmnopqrst'.split('').forEach(function (letter) {

   111   		return true;

   109 			test3[letter] = letter;

   112   	} catch (err) {

   110 		});

   113   		// We don't expect any of the above to throw, but better to be safe.

   111 		if (Object.keys(Object.assign({}, test3)).join('') !==

   114   		return false;

   112 				'abcdefghijklmnopqrst') {

   115   	}

   113 			return false;

   116   }

   114 		}

   117 

   115 

   118   var objectAssign = shouldUseNative() ? Object.assign : function (target, source) {

   116 		return true;

   119   	var from;

   117 	} catch (err) {

   120   	var to = toObject(target);

   118 		// We don't expect any of the above to throw, but better to be safe.

   121   	var symbols;

   119 		return false;

   122 

   120 	}

   123   	for (var s = 1; s < arguments.length; s++) {

   121 }

   124   		from = Object(arguments[s]);

   122 

   125 

   123 var objectAssign = shouldUseNative() ? Object.assign : function (target, source) {

   126   		for (var key in from) {

   124 	var from;

   127   			if (hasOwnProperty.call(from, key)) {

   125 	var to = toObject(target);

   128   				to[key] = from[key];

   126 	var symbols;

   129   			}

   127 

   130   		}

   128 	for (var s = 1; s < arguments.length; s++) {

   131 

   129 		from = Object(arguments[s]);

   132   		if (getOwnPropertySymbols) {

   130 

   133   			symbols = getOwnPropertySymbols(from);

   131 		for (var key in from) {

   134   			for (var i = 0; i < symbols.length; i++) {

   132 			if (hasOwnProperty.call(from, key)) {

   135   				if (propIsEnumerable.call(from, symbols[i])) {

   133 				to[key] = from[key];

   136   					to[symbols[i]] = from[symbols[i]];

   134 			}

   137   				}

   135 		}

   138   			}

   136 

   139   		}

   137 		if (getOwnPropertySymbols) {

   140   	}

   138 			symbols = getOwnPropertySymbols(from);

   141 

   139 			for (var i = 0; i < symbols.length; i++) {

   142   	return to;

   140 				if (propIsEnumerable.call(from, symbols[i])) {

   143   };

   141 					to[symbols[i]] = from[symbols[i]];

   144 

   142 				}

   145   /**

   143 			}

   146    * Keeps track of the current dispatcher.

   144 		}

   147    */

   145 	}

   148   var ReactCurrentDispatcher = {

   146 

   149     /**

   147 	return to;

   150      * @internal

   148 };

   151      * @type {ReactComponent}

   149 

   152      */

   150 // Do not require this module directly! Use normal `invariant` calls with

   153     current: null

   151 // template literal strings. The messages will be converted to ReactError during

   154   };

   152 // build, and in production they will be minified.

   155 

   153 

   156   /**

   154 // Do not require this module directly! Use normal `invariant` calls with

   157    * Keeps track of the current batch's configuration such as how long an update

   155 // template literal strings. The messages will be converted to ReactError during

   158    * should suspend for if it needs to.

   156 // build, and in production they will be minified.

   159    */

   157 

   160   var ReactCurrentBatchConfig = {

   158 function ReactError(error) {

   161     suspense: null

   159   error.name = 'Invariant Violation';

   162   };

   160   return error;

   163 

   161 }

   164   /**

   162 

   165    * Keeps track of the current owner.

   163 /**

   166    *

   164  * Use invariant() to assert state which your program assumes to be true.

   167    * The current owner is the component who should own any components that are

   165  *

   168    * currently being constructed.

   166  * Provide sprintf-style format (only %s is supported) and arguments

   169    */

   167  * to provide information about what broke and what you were

   170   var ReactCurrentOwner = {

   168  * expecting.

   171     /**

   169  *

   172      * @internal

   170  * The invariant message will be stripped in production, but the invariant

   173      * @type {ReactComponent}

   171  * will remain to ensure logic does not differ in production.

   174      */

   172  */

   175     current: null

   173 

   176   };

   174 /**

   177 

   175  * Forked from fbjs/warning:

   178   var BEFORE_SLASH_RE = /^(.*)[\\\/]/;

   176  * https://github.com/facebook/fbjs/blob/e66ba20ad5be433eb54423f2b097d829324d9de6/packages/fbjs/src/__forks__/warning.js

   179   function describeComponentFrame (name, source, ownerName) {

   177  *

   180     var sourceInfo = '';

   178  * Only change is we use console.warn instead of console.error,

   181 

   179  * and do nothing when 'console' is not supported.

   182     if (source) {

   180  * This really simplifies the code.

   183       var path = source.fileName;

   181  * ---

   184       var fileName = path.replace(BEFORE_SLASH_RE, '');

   182  * Similar to invariant but only logs a warning if the condition is not met.

   185 

   183  * This can be used to log issues in development environments in critical

   186       {

   184  * paths. Removing the logging code for production environments will keep the

   187         // In DEV, include code for a common special case:

   185  * same logic and follow the same code paths.

   188         // prefer "folder/index.js" instead of just "index.js".

   186  */

   189         if (/^index\./.test(fileName)) {

   187 

   190           var match = path.match(BEFORE_SLASH_RE);

   188 var lowPriorityWarning = function () {};

   191 

   189 

   192           if (match) {

   190 {

   193             var pathBeforeSlash = match[1];

   191   var printWarning = function (format) {

   194 

   192     for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {

   195             if (pathBeforeSlash) {

   193       args[_key - 1] = arguments[_key];

   196               var folderName = pathBeforeSlash.replace(BEFORE_SLASH_RE, '');

   194     }

   197               fileName = folderName + '/' + fileName;

   195 

   198             }

   196     var argIndex = 0;

   199           }

   197     var message = 'Warning: ' + format.replace(/%s/g, function () {

   200         }

   198       return args[argIndex++];

   201       }

   202 

   203       sourceInfo = ' (at ' + fileName + ':' + source.lineNumber + ')';

   204     } else if (ownerName) {

   205       sourceInfo = ' (created by ' + ownerName + ')';

   206     }

   207 

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

   209   }

   210 

   211   var Resolved = 1;

   212   function refineResolvedLazyComponent(lazyComponent) {

   213     return lazyComponent._status === Resolved ? lazyComponent._result : null;

   214   }

   215 

   216   function getWrappedName(outerType, innerType, wrapperName) {

   217     var functionName = innerType.displayName || innerType.name || '';

   218     return outerType.displayName || (functionName !== '' ? wrapperName + "(" + functionName + ")" : wrapperName);

   219   }

   220 

   221   function getComponentName(type) {

   222     if (type == null) {

   223       // Host root, text node or just invalid type.

   224       return null;

   225     }

   226 

   227     {

   228       if (typeof type.tag === 'number') {

   229         error('Received an unexpected object in getComponentName(). ' + 'This is likely a bug in React. Please file an issue.');

   230       }

   231     }

   232 

   233     if (typeof type === 'function') {

   234       return type.displayName || type.name || null;

   235     }

   236 

   237     if (typeof type === 'string') {

   238       return type;

   239     }

   240 

   241     switch (type) {

   242       case REACT_FRAGMENT_TYPE:

   243         return 'Fragment';

   244 

   245       case REACT_PORTAL_TYPE:

   246         return 'Portal';

   247 

   248       case REACT_PROFILER_TYPE:

   249         return "Profiler";

   250 

   251       case REACT_STRICT_MODE_TYPE:

   252         return 'StrictMode';

   253 

   254       case REACT_SUSPENSE_TYPE:

   255         return 'Suspense';

   256 

   257       case REACT_SUSPENSE_LIST_TYPE:

   258         return 'SuspenseList';

   259     }

   260 

   261     if (typeof type === 'object') {

   262       switch (type.$$typeof) {

   263         case REACT_CONTEXT_TYPE:

   264           return 'Context.Consumer';

   265 

   266         case REACT_PROVIDER_TYPE:

   267           return 'Context.Provider';

   268 

   269         case REACT_FORWARD_REF_TYPE:

   270           return getWrappedName(type, type.render, 'ForwardRef');

   271 

   272         case REACT_MEMO_TYPE:

   273           return getComponentName(type.type);

   274 

   275         case REACT_BLOCK_TYPE:

   276           return getComponentName(type.render);

   277 

   278         case REACT_LAZY_TYPE:

   279           {

   280             var thenable = type;

   281             var resolvedThenable = refineResolvedLazyComponent(thenable);

   282 

   283             if (resolvedThenable) {

   284               return getComponentName(resolvedThenable);

   285             }

   286 

   287             break;

   288           }

   289       }

   290     }

   291 

   292     return null;

   293   }

   294 

   295   var ReactDebugCurrentFrame = {};

   296   var currentlyValidatingElement = null;

   297   function setCurrentlyValidatingElement(element) {

   298     {

   299       currentlyValidatingElement = element;

   300     }

   301   }

   302 

   303   {

   304     // Stack implementation injected by the current renderer.

   305     ReactDebugCurrentFrame.getCurrentStack = null;

   306 

   307     ReactDebugCurrentFrame.getStackAddendum = function () {

   308       var stack = ''; // Add an extra top frame while an element is being validated

   309 

   310       if (currentlyValidatingElement) {

   311         var name = getComponentName(currentlyValidatingElement.type);

   312         var owner = currentlyValidatingElement._owner;

   313         stack += describeComponentFrame(name, currentlyValidatingElement._source, owner && getComponentName(owner.type));

   314       } // Delegate to the injected renderer-specific implementation

   315 

   316 

   317       var impl = ReactDebugCurrentFrame.getCurrentStack;

   318 

   319       if (impl) {

   320         stack += impl() || '';

   321       }

   322 

   323       return stack;

   324     };

   325   }

   326 

   327   /**

   328    * Used by act() to track whether you're inside an act() scope.

   329    */

   330   var IsSomeRendererActing = {

   331     current: false

   332   };

   333 

   334   var ReactSharedInternals = {

   335     ReactCurrentDispatcher: ReactCurrentDispatcher,

   336     ReactCurrentBatchConfig: ReactCurrentBatchConfig,

   337     ReactCurrentOwner: ReactCurrentOwner,

   338     IsSomeRendererActing: IsSomeRendererActing,

   339     // Used by renderers to avoid bundling object-assign twice in UMD bundles:

   340     assign: objectAssign

   341   };

   342 

   343   {

   344     objectAssign(ReactSharedInternals, {

   345       // These should not be included in production.

   346       ReactDebugCurrentFrame: ReactDebugCurrentFrame,

   347       // Shim for React DOM 16.0.0 which still destructured (but not used) this.

   348       // TODO: remove in React 17.0.

   349       ReactComponentTreeHook: {}

   200     if (typeof console !== 'undefined') {

   351   }

   201       console.warn(message);

   352 

   202     }

   353   // by calls to these methods by a Babel plugin.

   203     try {

   354   //

   204       // --- Welcome to debugging React ---

   355   // In PROD (or in packages without access to React internals),

   205       // This error was thrown as a convenience so that you can use this stack

   356   // they are left as they are instead.

   206       // to find the callsite that caused this warning to fire.

   357 

   207       throw new Error(message);

   358   function warn(format) {

   208     } catch (x) {}

   359     {

   209   };

   360       for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {

   210 

   361         args[_key - 1] = arguments[_key];

   211   lowPriorityWarning = function (condition, format) {

   362       }

   212     if (format === undefined) {

   363 

   213       throw new Error('`lowPriorityWarning(condition, format, ...args)` requires a warning ' + 'message argument');

   364       printWarning('warn', format, args);

   214     }

   365     }

   215     if (!condition) {

   366   }

   216       for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {

   367   function error(format) {

   217         args[_key2 - 2] = arguments[_key2];

   368     {

   218       }

   369       for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {

   219 

   370         args[_key2 - 1] = arguments[_key2];

   220       printWarning.apply(undefined, [format].concat(args));

   371       }

   221     }

   372 

   222   };

   373       printWarning('error', format, args);

   223 }

   374     }

   224 

   375   }

   225 var lowPriorityWarning$1 = lowPriorityWarning;

   376 

   226 

   377   function printWarning(level, format, args) {

   227 /**

   378     // When changing this logic, you might want to also

   228  * Similar to invariant but only logs a warning if the condition is not met.

   379     // update consoleWithStackDev.www.js as well.

   229  * This can be used to log issues in development environments in critical

   380     {

   230  * paths. Removing the logging code for production environments will keep the

   381       var hasExistingStack = args.length > 0 && typeof args[args.length - 1] === 'string' && args[args.length - 1].indexOf('\n    in') === 0;

   231  * same logic and follow the same code paths.

   382 

   232  */

   383       if (!hasExistingStack) {

   233 

   384         var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;

   234 var warningWithoutStack = function () {};

   385         var stack = ReactDebugCurrentFrame.getStackAddendum();

   235 

   386 

   236 {

   387         if (stack !== '') {

   237   warningWithoutStack = function (condition, format) {

   388           format += '%s';

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

   389           args = args.concat([stack]);

   239       args[_key - 2] = arguments[_key];

   390         }

   240     }

   391       }

   241 

   392 

   242     if (format === undefined) {

   243       throw new Error('`warningWithoutStack(condition, format, ...args)` requires a warning ' + 'message argument');

   244     }

   245     if (args.length > 8) {

   246       // Check before the condition to catch violations early.

   247       throw new Error('warningWithoutStack() currently supports at most 8 arguments.');

   248     }

   249     if (condition) {

   250       return;

   251     }

   252     if (typeof console !== 'undefined') {

   255       });

   395       }); // Careful: RN currently depends on this prefix

   256       argsWithFormat.unshift('Warning: ' + format);

   396 

   257 

   397       argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it

   258       // We intentionally don't use spread (or .apply) directly because it

   260       Function.prototype.apply.call(console.error, console, argsWithFormat);

   399       // eslint-disable-next-line react-internal/no-production-logging

   261     }

   400 

   262     try {

   401       Function.prototype.apply.call(console[level], console, argsWithFormat);

   263       // --- Welcome to debugging React ---

   402 

   264       // This error was thrown as a convenience so that you can use this stack

   403       try {

   265       // to find the callsite that caused this warning to fire.

   404         // --- Welcome to debugging React ---

   266       var argIndex = 0;

   405         // This error was thrown as a convenience so that you can use this stack

   267       var message = 'Warning: ' + format.replace(/%s/g, function () {

   406         // to find the callsite that caused this warning to fire.

   268         return args[argIndex++];

   407         var argIndex = 0;

   269       });

   408         var message = 'Warning: ' + format.replace(/%s/g, function () {

   270       throw new Error(message);

   409           return args[argIndex++];

   271     } catch (x) {}

   410         });

   411         throw new Error(message);

   412       } catch (x) {}

   413     }

   414   }

   415 

   416   var didWarnStateUpdateForUnmountedComponent = {};

   417 

   418   function warnNoop(publicInstance, callerName) {

   419     {

   420       var _constructor = publicInstance.constructor;

   421       var componentName = _constructor && (_constructor.displayName || _constructor.name) || 'ReactClass';

   422       var warningKey = componentName + "." + callerName;

   423 

   424       if (didWarnStateUpdateForUnmountedComponent[warningKey]) {

   425         return;

   426       }

   427 

   428       error("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);

   429 

   430       didWarnStateUpdateForUnmountedComponent[warningKey] = true;

   431     }

   432   }

   433   /**

   434    * This is the abstract API for an update queue.

   435    */

   436 

   437 

   438   var ReactNoopUpdateQueue = {

   439     /**

   440      * Checks whether or not this composite component is mounted.

   441      * @param {ReactClass} publicInstance The instance we want to test.

   442      * @return {boolean} True if mounted, false otherwise.

   443      * @protected

   444      * @final

   445      */

   446     isMounted: function (publicInstance) {

   447       return false;

   448     },

   449 

   450     /**

   451      * Forces an update. This should only be invoked when it is known with

   452      * certainty that we are **not** in a DOM transaction.

   453      *

   454      * You may want to call this when you know that some deeper aspect of the

   455      * component's state has changed but `setState` was not called.

   456      *

   457      * This will not invoke `shouldComponentUpdate`, but it will invoke

   458      * `componentWillUpdate` and `componentDidUpdate`.

   459      *

   460      * @param {ReactClass} publicInstance The instance that should rerender.

   461      * @param {?function} callback Called after component is updated.

   462      * @param {?string} callerName name of the calling function in the public API.

   463      * @internal

   464      */

   465     enqueueForceUpdate: function (publicInstance, callback, callerName) {

   466       warnNoop(publicInstance, 'forceUpdate');

   467     },

   468 

   469     /**

   470      * Replaces all of the state. Always use this or `setState` to mutate state.

   471      * You should treat `this.state` as immutable.

   472      *

   473      * There is no guarantee that `this.state` will be immediately updated, so

   474      * accessing `this.state` after calling this method may return the old value.

   475      *

   476      * @param {ReactClass} publicInstance The instance that should rerender.

   477      * @param {object} completeState Next state.

   478      * @param {?function} callback Called after component is updated.

   479      * @param {?string} callerName name of the calling function in the public API.

   480      * @internal

   481      */

   482     enqueueReplaceState: function (publicInstance, completeState, callback, callerName) {

   483       warnNoop(publicInstance, 'replaceState');

   484     },

   485 

   486     /**

   487      * Sets a subset of the state. This only exists because _pendingState is

   488      * internal. This provides a merging strategy that is not available to deep

   489      * properties which is confusing. TODO: Expose pendingState or don't use it

   490      * during the merge.

   491      *

   492      * @param {ReactClass} publicInstance The instance that should rerender.

   493      * @param {object} partialState Next partial state to be merged with state.

   494      * @param {?function} callback Called after component is updated.

   495      * @param {?string} Name of the calling function in the public API.

   496      * @internal

   497      */

   498     enqueueSetState: function (publicInstance, partialState, callback, callerName) {

   499       warnNoop(publicInstance, 'setState');

   500     }

   273 }

   502 

   274 

   503   var emptyObject = {};

   275 var warningWithoutStack$1 = warningWithoutStack;

   504 

   276 

   277 var didWarnStateUpdateForUnmountedComponent = {};

   278 

   279 function warnNoop(publicInstance, callerName) {

   281     var _constructor = publicInstance.constructor;

   506     Object.freeze(emptyObject);

   282     var componentName = _constructor && (_constructor.displayName || _constructor.name) || 'ReactClass';

   507   }

   283     var warningKey = componentName + '.' + callerName;

   284     if (didWarnStateUpdateForUnmountedComponent[warningKey]) {

   285       return;

   286     }

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

   288     didWarnStateUpdateForUnmountedComponent[warningKey] = true;

   289   }

   290 }

   291 

   292 /**

   293  * This is the abstract API for an update queue.

   294  */

   295 var ReactNoopUpdateQueue = {

   297    * Checks whether or not this composite component is mounted.

   509    * Base class helpers for the updating state of a component.

   298    * @param {ReactClass} publicInstance The instance we want to test.

   510    */

   299    * @return {boolean} True if mounted, false otherwise.

   511 

   512 

   513   function Component(props, context, updater) {

   514     this.props = props;

   515     this.context = context; // If a component has string refs, we will assign a different object later.

   516 

   517     this.refs = emptyObject; // We initialize the default updater but the real one gets injected by the

   518     // renderer.

   519 

   520     this.updater = updater || ReactNoopUpdateQueue;

   521   }

   522 

   523   Component.prototype.isReactComponent = {};

   524   /**

   525    * Sets a subset of the state. Always use this to mutate

   526    * state. You should treat `this.state` as immutable.

   527    *

   528    * There is no guarantee that `this.state` will be immediately updated, so

   529    * accessing `this.state` after calling this method may return the old value.

   530    *

   531    * There is no guarantee that calls to `setState` will run synchronously,

   532    * as they may eventually be batched together.  You can provide an optional

   533    * callback that will be executed when the call to setState is actually

   534    * completed.

   535    *

   536    * When a function is provided to setState, it will be called at some point in

   537    * the future (not synchronously). It will be called with the up to date

   538    * component arguments (state, props, context). These values can be different

   539    * from this.* because your function may be called after receiveProps but before

   540    * shouldComponentUpdate, and this new state, props, and context will not yet be

   541    * assigned to this.

   542    *

   543    * @param {object|function} partialState Next partial state or function to

   544    *        produce next partial state to be merged with current state.

   545    * @param {?function} callback Called after state is updated.

   546    * @final

   303   isMounted: function (publicInstance) {

   549 

   304     return false;

   550   Component.prototype.setState = function (partialState, callback) {

   305   },

   551     if (!(typeof partialState === 'object' || typeof partialState === 'function' || partialState == null)) {

   306 

   552       {

   553         throw Error( "setState(...): takes an object of state variables to update or a function which returns an object of state variables." );

   554       }

   555     }

   556 

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

   558   };

   317    * @param {ReactClass} publicInstance The instance that should rerender.

   569    * @param {?function} callback Called after update is complete.

   318    * @param {?function} callback Called after component is updated.

   570    * @final

   319    * @param {?string} callerName name of the calling function in the public API.

   571    * @protected

   572    */

   573 

   574 

   575   Component.prototype.forceUpdate = function (callback) {

   576     this.updater.enqueueForceUpdate(this, callback, 'forceUpdate');

   577   };

   578   /**

   579    * Deprecated APIs. These APIs used to exist on classic React classes but since

   580    * we would like to deprecate them, we're not going to move them over to this

   581    * modern base class. Instead, we define a getter that warns if it's accessed.

   582    */

   583 

   584 

   585   {

   586     var deprecatedAPIs = {

   587       isMounted: ['isMounted', 'Instead, make sure to clean up subscriptions and pending requests in ' + 'componentWillUnmount to prevent memory leaks.'],

   588       replaceState: ['replaceState', 'Refactor your code to use setState instead (see ' + 'https://github.com/facebook/react/issues/3236).']

   589     };

   590 

   591     var defineDeprecationWarning = function (methodName, info) {

   592       Object.defineProperty(Component.prototype, methodName, {

   593         get: function () {

   594           warn('%s(...) is deprecated in plain JavaScript React classes. %s', info[0], info[1]);

   595 

   596           return undefined;

   597         }

   598       });

   599     };

   600 

   601     for (var fnName in deprecatedAPIs) {

   602       if (deprecatedAPIs.hasOwnProperty(fnName)) {

   603         defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);

   604       }

   605     }

   606   }

   607 

   608   function ComponentDummy() {}

   609 

   610   ComponentDummy.prototype = Component.prototype;

   611   /**

   612    * Convenience component with default shallow equality check for sCU.

   613    */

   614 

   615   function PureComponent(props, context, updater) {

   616     this.props = props;

   617     this.context = context; // If a component has string refs, we will assign a different object later.

   618 

   619     this.refs = emptyObject;

   620     this.updater = updater || ReactNoopUpdateQueue;

   621   }

   622 

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

   624   pureComponentPrototype.constructor = PureComponent; // Avoid an extra prototype jump for these methods.

   625 

   626   objectAssign(pureComponentPrototype, Component.prototype);

   627 

   628   pureComponentPrototype.isPureReactComponent = true;

   629 

   630   // an immutable object with a single mutable value

   631   function createRef() {

   632     var refObject = {

   633       current: null

   634     };

   635 

   636     {

   637       Object.seal(refObject);

   638     }

   639 

   640     return refObject;

   641   }

   642 

   643   var hasOwnProperty$1 = Object.prototype.hasOwnProperty;

   644   var RESERVED_PROPS = {

   645     key: true,

   646     ref: true,

   647     __self: true,

   648     __source: true

   649   };

   650   var specialPropKeyWarningShown, specialPropRefWarningShown, didWarnAboutStringRefs;

   651 

   652   {

   653     didWarnAboutStringRefs = {};

   654   }

   655 

   656   function hasValidRef(config) {

   657     {

   658       if (hasOwnProperty$1.call(config, 'ref')) {

   659         var getter = Object.getOwnPropertyDescriptor(config, 'ref').get;

   660 

   661         if (getter && getter.isReactWarning) {

   662           return false;

   663         }

   664       }

   665     }

   666 

   667     return config.ref !== undefined;

   668   }

   669 

   670   function hasValidKey(config) {

   671     {

   672       if (hasOwnProperty$1.call(config, 'key')) {

   673         var getter = Object.getOwnPropertyDescriptor(config, 'key').get;

   674 

   675         if (getter && getter.isReactWarning) {

   676           return false;

   677         }

   678       }

   679     }

   680 

   681     return config.key !== undefined;

   682   }

   683 

   684   function defineKeyPropWarningGetter(props, displayName) {

   685     var warnAboutAccessingKey = function () {

   686       {

   687         if (!specialPropKeyWarningShown) {

   688           specialPropKeyWarningShown = true;

   689 

   690           error('%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);

   691         }

   692       }

   693     };

   694 

   695     warnAboutAccessingKey.isReactWarning = true;

   696     Object.defineProperty(props, 'key', {

   697       get: warnAboutAccessingKey,

   698       configurable: true

   699     });

   700   }

   701 

   702   function defineRefPropWarningGetter(props, displayName) {

   703     var warnAboutAccessingRef = function () {

   704       {

   705         if (!specialPropRefWarningShown) {

   706           specialPropRefWarningShown = true;

   707 

   708           error('%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);

   709         }

   710       }

   711     };

   712 

   713     warnAboutAccessingRef.isReactWarning = true;

   714     Object.defineProperty(props, 'ref', {

   715       get: warnAboutAccessingRef,

   716       configurable: true

   717     });

   718   }

   719 

   720   function warnIfStringRefCannotBeAutoConverted(config) {

   721     {

   722       if (typeof config.ref === 'string' && ReactCurrentOwner.current && config.__self && ReactCurrentOwner.current.stateNode !== config.__self) {

   723         var componentName = getComponentName(ReactCurrentOwner.current.type);

   724 

   725         if (!didWarnAboutStringRefs[componentName]) {

   726           error('Component "%s" contains the string ref "%s". ' + 'Support for string refs will be removed in a future major release. ' + 'This case cannot be automatically converted to an arrow function. ' + 'We ask you to manually fix this case by using useRef() or createRef() instead. ' + 'Learn more about using refs safely here: ' + 'https://fb.me/react-strict-mode-string-ref', getComponentName(ReactCurrentOwner.current.type), config.ref);

   727 

   728           didWarnAboutStringRefs[componentName] = true;

   729         }

   730       }

   731     }

   732   }

   733   /**

   734    * Factory method to create a new React element. This no longer adheres to

   735    * the class pattern, so do not use new to call it. Also, instanceof check

   736    * will not work. Instead test $$typeof field against Symbol.for('react.element') to check

   737    * if something is a React Element.

   738    *

   739    * @param {*} type

   740    * @param {*} props

   741    * @param {*} key

   742    * @param {string|object} ref

   743    * @param {*} owner

   744    * @param {*} self A *temporary* helper to detect places where `this` is

   745    * different from the `owner` when React.createElement is called, so that we

   746    * can warn. We want to get rid of owner and replace string `ref`s with arrow

   747    * functions, and as long as `this` and owner are the same, there will be no

   748    * change in behavior.

   749    * @param {*} source An annotation object (added by a transpiler or otherwise)

   750    * indicating filename, line number, and/or other information.

   322   enqueueForceUpdate: function (publicInstance, callback, callerName) {

   753 

   323     warnNoop(publicInstance, 'forceUpdate');

   754 

   324   },

   755   var ReactElement = function (type, key, ref, self, source, owner, props) {

   325 

   756     var element = {

   757       // This tag allows us to uniquely identify this as a React Element

   758       $$typeof: REACT_ELEMENT_TYPE,

   759       // Built-in properties that belong on the element

   760       type: type,

   761       key: key,

   762       ref: ref,

   763       props: props,

   764       // Record the component responsible for creating this element.

   765       _owner: owner

   766     };

   767 

   768     {

   769       // The validation flag is currently mutative. We put it on

   770       // an external backing store so that we can freeze the whole object.

   771       // This can be replaced with a WeakMap once they are implemented in

   772       // commonly used development environments.

   773       element._store = {}; // To make comparing ReactElements easier for testing purposes, we make

   774       // the validation flag non-enumerable (where possible, which should

   775       // include every environment we run tests in), so the test framework

   776       // ignores it.

   777 

   778       Object.defineProperty(element._store, 'validated', {

   779         configurable: false,

   780         enumerable: false,

   781         writable: true,

   782         value: false

   783       }); // self and source are DEV only properties.

   784 

   785       Object.defineProperty(element, '_self', {

   786         configurable: false,

   787         enumerable: false,

   788         writable: false,

   789         value: self

   790       }); // Two elements created in two different places should be considered

   791       // equal for testing purposes and therefore we hide it from enumeration.

   792 

   793       Object.defineProperty(element, '_source', {

   794         configurable: false,

   795         enumerable: false,

   796         writable: false,

   797         value: source

   798       });

   799 

   800       if (Object.freeze) {

   801         Object.freeze(element.props);

   802         Object.freeze(element);

   803       }

   804     }

   805 

   806     return element;

   807   };

   327    * Replaces all of the state. Always use this or `setState` to mutate state.

   809    * Create and return a new ReactElement of the given type.

   328    * You should treat `this.state` as immutable.

   810    * See https://reactjs.org/docs/react-api.html#createelement

   329    *

   330    * There is no guarantee that `this.state` will be immediately updated, so

   331    * accessing `this.state` after calling this method may return the old value.

   332    *

   333    * @param {ReactClass} publicInstance The instance that should rerender.

   334    * @param {object} completeState Next state.

   335    * @param {?function} callback Called after component is updated.

   336    * @param {?string} callerName name of the calling function in the public API.

   337    * @internal

   339   enqueueReplaceState: function (publicInstance, completeState, callback, callerName) {

   812 

   340     warnNoop(publicInstance, 'replaceState');

   813   function createElement(type, config, children) {

   341   },

   814     var propName; // Reserved names are extracted

   342 

   815 

   816     var props = {};

   817     var key = null;

   818     var ref = null;

   819     var self = null;

   820     var source = null;

   821 

   822     if (config != null) {

   823       if (hasValidRef(config)) {

   824         ref = config.ref;

   825 

   826         {

   827           warnIfStringRefCannotBeAutoConverted(config);

   828         }

   829       }

   830 

   831       if (hasValidKey(config)) {

   832         key = '' + config.key;

   833       }

   834 

   835       self = config.__self === undefined ? null : config.__self;

   836       source = config.__source === undefined ? null : config.__source; // Remaining properties are added to a new props object

   837 

   838       for (propName in config) {

   839         if (hasOwnProperty$1.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {

   840           props[propName] = config[propName];

   841         }

   842       }

   843     } // Children can be more than one argument, and those are transferred onto

   844     // the newly allocated props object.

   845 

   846 

   847     var childrenLength = arguments.length - 2;

   848 

   849     if (childrenLength === 1) {

   850       props.children = children;

   851     } else if (childrenLength > 1) {

   852       var childArray = Array(childrenLength);

   853 

   854       for (var i = 0; i < childrenLength; i++) {

   855         childArray[i] = arguments[i + 2];

   856       }

   857 

   858       {

   859         if (Object.freeze) {

   860           Object.freeze(childArray);

   861         }

   862       }

   863 

   864       props.children = childArray;

   865     } // Resolve default props

   866 

   867 

   868     if (type && type.defaultProps) {

   869       var defaultProps = type.defaultProps;

   870 

   871       for (propName in defaultProps) {

   872         if (props[propName] === undefined) {

   873           props[propName] = defaultProps[propName];

   874         }

   875       }

   876     }

   877 

   878     {

   879       if (key || ref) {

   880         var displayName = typeof type === 'function' ? type.displayName || type.name || 'Unknown' : type;

   881 

   882         if (key) {

   883           defineKeyPropWarningGetter(props, displayName);

   884         }

   885 

   886         if (ref) {

   887           defineRefPropWarningGetter(props, displayName);

   888         }

   889       }

   890     }

   891 

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

   893   }

   894   function cloneAndReplaceKey(oldElement, newKey) {

   895     var newElement = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props);

   896     return newElement;

   897   }

   344    * Sets a subset of the state. This only exists because _pendingState is

   899    * Clone and return a new ReactElement using element as the starting point.

   345    * internal. This provides a merging strategy that is not available to deep

   900    * See https://reactjs.org/docs/react-api.html#cloneelement

   346    * properties which is confusing. TODO: Expose pendingState or don't use it

   347    * during the merge.

   348    *

   349    * @param {ReactClass} publicInstance The instance that should rerender.

   350    * @param {object} partialState Next partial state to be merged with state.

   351    * @param {?function} callback Called after component is updated.

   352    * @param {?string} Name of the calling function in the public API.

   353    * @internal

   355   enqueueSetState: function (publicInstance, partialState, callback, callerName) {

   902 

   356     warnNoop(publicInstance, 'setState');

   903   function cloneElement(element, config, children) {

   357   }

   358 };

   359 

   360 var emptyObject = {};

   361 {

   362   Object.freeze(emptyObject);

   363 }

   364 

   365 /**

   366  * Base class helpers for the updating state of a component.

   367  */

   368 function Component(props, context, updater) {

   369   this.props = props;

   370   this.context = context;

   371   // If a component has string refs, we will assign a different object later.

   372   this.refs = emptyObject;

   373   // We initialize the default updater but the real one gets injected by the

   374   // renderer.

   375   this.updater = updater || ReactNoopUpdateQueue;

   376 }

   377 

   378 Component.prototype.isReactComponent = {};

   379 

   380 /**

   381  * Sets a subset of the state. Always use this to mutate

   382  * state. You should treat `this.state` as immutable.

   383  *

   384  * There is no guarantee that `this.state` will be immediately updated, so

   385  * accessing `this.state` after calling this method may return the old value.

   386  *

   387  * There is no guarantee that calls to `setState` will run synchronously,

   388  * as they may eventually be batched together.  You can provide an optional

   389  * callback that will be executed when the call to setState is actually

   390  * completed.

   391  *

   392  * When a function is provided to setState, it will be called at some point in

   393  * the future (not synchronously). It will be called with the up to date

   394  * component arguments (state, props, context). These values can be different

   395  * from this.* because your function may be called after receiveProps but before

   396  * shouldComponentUpdate, and this new state, props, and context will not yet be

   397  * assigned to this.

   398  *

   399  * @param {object|function} partialState Next partial state or function to

   400  *        produce next partial state to be merged with current state.

   401  * @param {?function} callback Called after state is updated.

   402  * @final

   403  * @protected

   404  */

   405 Component.prototype.setState = function (partialState, callback) {

   406   (function () {

   407     if (!(typeof partialState === 'object' || typeof partialState === 'function' || partialState == null)) {

   408       {

   409         throw ReactError(Error('setState(...): takes an object of state variables to update or a function which returns an object of state variables.'));

   410       }

   411     }

   412   })();

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

   414 };

   415 

   416 /**

   417  * Forces an update. This should only be invoked when it is known with

   418  * certainty that we are **not** in a DOM transaction.

   419  *

   420  * You may want to call this when you know that some deeper aspect of the

   421  * component's state has changed but `setState` was not called.

   422  *

   423  * This will not invoke `shouldComponentUpdate`, but it will invoke

   424  * `componentWillUpdate` and `componentDidUpdate`.

   425  *

   426  * @param {?function} callback Called after update is complete.

   427  * @final

   428  * @protected

   429  */

   430 Component.prototype.forceUpdate = function (callback) {

   431   this.updater.enqueueForceUpdate(this, callback, 'forceUpdate');

   432 };

   433 

   434 /**

   435  * Deprecated APIs. These APIs used to exist on classic React classes but since

   436  * we would like to deprecate them, we're not going to move them over to this

   437  * modern base class. Instead, we define a getter that warns if it's accessed.

   438  */

   439 {

   440   var deprecatedAPIs = {

   441     isMounted: ['isMounted', 'Instead, make sure to clean up subscriptions and pending requests in ' + 'componentWillUnmount to prevent memory leaks.'],

   442     replaceState: ['replaceState', 'Refactor your code to use setState instead (see ' + 'https://github.com/facebook/react/issues/3236).']

   443   };

   444   var defineDeprecationWarning = function (methodName, info) {

   445     Object.defineProperty(Component.prototype, methodName, {

   446       get: function () {

   447         lowPriorityWarning$1(false, '%s(...) is deprecated in plain JavaScript React classes. %s', info[0], info[1]);

   448         return undefined;

   449       }

   450     });

   451   };

   452   for (var fnName in deprecatedAPIs) {

   453     if (deprecatedAPIs.hasOwnProperty(fnName)) {

   454       defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);

   455     }

   456   }

   457 }

   458 

   459 function ComponentDummy() {}

   460 ComponentDummy.prototype = Component.prototype;

   461 

   462 /**

   463  * Convenience component with default shallow equality check for sCU.

   464  */

   465 function PureComponent(props, context, updater) {

   466   this.props = props;

   467   this.context = context;

   468   // If a component has string refs, we will assign a different object later.

   469   this.refs = emptyObject;

   470   this.updater = updater || ReactNoopUpdateQueue;

   471 }

   472 

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

   474 pureComponentPrototype.constructor = PureComponent;

   475 // Avoid an extra prototype jump for these methods.

   476 objectAssign(pureComponentPrototype, Component.prototype);

   477 pureComponentPrototype.isPureReactComponent = true;

   478 

   479 // an immutable object with a single mutable value

   480 function createRef() {

   481   var refObject = {

   482     current: null

   483   };

   484   {

   485     Object.seal(refObject);

   486   }

   487   return refObject;

   488 }

   489 

   490 /**

   491  * Keeps track of the current dispatcher.

   492  */

   493 var ReactCurrentDispatcher = {

   494   /**

   495    * @internal

   496    * @type {ReactComponent}

   497    */

   498   current: null

   499 };

   500 

   501 /**

   502  * Keeps track of the current batch's configuration such as how long an update

   503  * should suspend for if it needs to.

   504  */

   505 var ReactCurrentBatchConfig = {

   506   suspense: null

   507 };

   508 

   509 /**

   510  * Keeps track of the current owner.

   511  *

   512  * The current owner is the component who should own any components that are

   513  * currently being constructed.

   514  */

   515 var ReactCurrentOwner = {

   516   /**

   517    * @internal

   518    * @type {ReactComponent}

   519    */

   520   current: null

   521 };

   522 

   523 var BEFORE_SLASH_RE = /^(.*)[\\\/]/;

   524 

   525 var describeComponentFrame = function (name, source, ownerName) {

   526   var sourceInfo = '';

   527   if (source) {

   528     var path = source.fileName;

   529     var fileName = path.replace(BEFORE_SLASH_RE, '');

   530     {

   531       // In DEV, include code for a common special case:

   532       // prefer "folder/index.js" instead of just "index.js".

   533       if (/^index\./.test(fileName)) {

   534         var match = path.match(BEFORE_SLASH_RE);

   535         if (match) {

   536           var pathBeforeSlash = match[1];

   537           if (pathBeforeSlash) {

   538             var folderName = pathBeforeSlash.replace(BEFORE_SLASH_RE, '');

   539             fileName = folderName + '/' + fileName;

   540           }

   541         }

   542       }