react.development.js (87574B)
1/** 2 * @license React 3 * react.development.js 4 * 5 * Copyright (c) Facebook, Inc. and its affiliates. 6 * 7 * This source code is licensed under the MIT license found in the 8 * LICENSE file in the root directory of this source tree. 9 */ 10 11'use strict'; 12 13if (process.env.NODE_ENV !== "production") { 14 (function() { 15 16 'use strict'; 17 18/* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */ 19if ( 20 typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' && 21 typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart === 22 'function' 23) { 24 __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error()); 25} 26 var ReactVersion = '18.2.0'; 27 28// ATTENTION 29// When adding new symbols to this file, 30// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols' 31// The Symbol used to tag the ReactElement-like types. 32var REACT_ELEMENT_TYPE = Symbol.for('react.element'); 33var REACT_PORTAL_TYPE = Symbol.for('react.portal'); 34var REACT_FRAGMENT_TYPE = Symbol.for('react.fragment'); 35var REACT_STRICT_MODE_TYPE = Symbol.for('react.strict_mode'); 36var REACT_PROFILER_TYPE = Symbol.for('react.profiler'); 37var REACT_PROVIDER_TYPE = Symbol.for('react.provider'); 38var REACT_CONTEXT_TYPE = Symbol.for('react.context'); 39var REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref'); 40var REACT_SUSPENSE_TYPE = Symbol.for('react.suspense'); 41var REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list'); 42var REACT_MEMO_TYPE = Symbol.for('react.memo'); 43var REACT_LAZY_TYPE = Symbol.for('react.lazy'); 44var REACT_OFFSCREEN_TYPE = Symbol.for('react.offscreen'); 45var MAYBE_ITERATOR_SYMBOL = Symbol.iterator; 46var FAUX_ITERATOR_SYMBOL = '@@iterator'; 47function getIteratorFn(maybeIterable) { 48 if (maybeIterable === null || typeof maybeIterable !== 'object') { 49 return null; 50 } 51 52 var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]; 53 54 if (typeof maybeIterator === 'function') { 55 return maybeIterator; 56 } 57 58 return null; 59} 60 61/** 62 * Keeps track of the current dispatcher. 63 */ 64var ReactCurrentDispatcher = { 65 /** 66 * @internal 67 * @type {ReactComponent} 68 */ 69 current: null 70}; 71 72/** 73 * Keeps track of the current batch's configuration such as how long an update 74 * should suspend for if it needs to. 75 */ 76var ReactCurrentBatchConfig = { 77 transition: null 78}; 79 80var ReactCurrentActQueue = { 81 current: null, 82 // Used to reproduce behavior of `batchedUpdates` in legacy mode. 83 isBatchingLegacy: false, 84 didScheduleLegacyUpdate: false 85}; 86 87/** 88 * Keeps track of the current owner. 89 * 90 * The current owner is the component who should own any components that are 91 * currently being constructed. 92 */ 93var ReactCurrentOwner = { 94 /** 95 * @internal 96 * @type {ReactComponent} 97 */ 98 current: null 99}; 100 101var ReactDebugCurrentFrame = {}; 102var currentExtraStackFrame = null; 103function setExtraStackFrame(stack) { 104 { 105 currentExtraStackFrame = stack; 106 } 107} 108 109{ 110 ReactDebugCurrentFrame.setExtraStackFrame = function (stack) { 111 { 112 currentExtraStackFrame = stack; 113 } 114 }; // Stack implementation injected by the current renderer. 115 116 117 ReactDebugCurrentFrame.getCurrentStack = null; 118 119 ReactDebugCurrentFrame.getStackAddendum = function () { 120 var stack = ''; // Add an extra top frame while an element is being validated 121 122 if (currentExtraStackFrame) { 123 stack += currentExtraStackFrame; 124 } // Delegate to the injected renderer-specific implementation 125 126 127 var impl = ReactDebugCurrentFrame.getCurrentStack; 128 129 if (impl) { 130 stack += impl() || ''; 131 } 132 133 return stack; 134 }; 135} 136 137// ----------------------------------------------------------------------------- 138 139var enableScopeAPI = false; // Experimental Create Event Handle API. 140var enableCacheElement = false; 141var enableTransitionTracing = false; // No known bugs, but needs performance testing 142 143var enableLegacyHidden = false; // Enables unstable_avoidThisFallback feature in Fiber 144// stuff. Intended to enable React core members to more easily debug scheduling 145// issues in DEV builds. 146 147var enableDebugTracing = false; // Track which Fiber(s) schedule render work. 148 149var ReactSharedInternals = { 150 ReactCurrentDispatcher: ReactCurrentDispatcher, 151 ReactCurrentBatchConfig: ReactCurrentBatchConfig, 152 ReactCurrentOwner: ReactCurrentOwner 153}; 154 155{ 156 ReactSharedInternals.ReactDebugCurrentFrame = ReactDebugCurrentFrame; 157 ReactSharedInternals.ReactCurrentActQueue = ReactCurrentActQueue; 158} 159 160// by calls to these methods by a Babel plugin. 161// 162// In PROD (or in packages without access to React internals), 163// they are left as they are instead. 164 165function warn(format) { 166 { 167 { 168 for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { 169 args[_key - 1] = arguments[_key]; 170 } 171 172 printWarning('warn', format, args); 173 } 174 } 175} 176function error(format) { 177 { 178 { 179 for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) { 180 args[_key2 - 1] = arguments[_key2]; 181 } 182 183 printWarning('error', format, args); 184 } 185 } 186} 187 188function printWarning(level, format, args) { 189 // When changing this logic, you might want to also 190 // update consoleWithStackDev.www.js as well. 191 { 192 var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame; 193 var stack = ReactDebugCurrentFrame.getStackAddendum(); 194 195 if (stack !== '') { 196 format += '%s'; 197 args = args.concat([stack]); 198 } // eslint-disable-next-line react-internal/safe-string-coercion 199 200 201 var argsWithFormat = args.map(function (item) { 202 return String(item); 203 }); // Careful: RN currently depends on this prefix 204 205 argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it 206 // breaks IE9: https://github.com/facebook/react/issues/13610 207 // eslint-disable-next-line react-internal/no-production-logging 208 209 Function.prototype.apply.call(console[level], console, argsWithFormat); 210 } 211} 212 213var didWarnStateUpdateForUnmountedComponent = {}; 214 215function warnNoop(publicInstance, callerName) { 216 { 217 var _constructor = publicInstance.constructor; 218 var componentName = _constructor && (_constructor.displayName || _constructor.name) || 'ReactClass'; 219 var warningKey = componentName + "." + callerName; 220 221 if (didWarnStateUpdateForUnmountedComponent[warningKey]) { 222 return; 223 } 224 225 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); 226 227 didWarnStateUpdateForUnmountedComponent[warningKey] = true; 228 } 229} 230/** 231 * This is the abstract API for an update queue. 232 */ 233 234 235var ReactNoopUpdateQueue = { 236 /** 237 * Checks whether or not this composite component is mounted. 238 * @param {ReactClass} publicInstance The instance we want to test. 239 * @return {boolean} True if mounted, false otherwise. 240 * @protected 241 * @final 242 */ 243 isMounted: function (publicInstance) { 244 return false; 245 }, 246 247 /** 248 * Forces an update. This should only be invoked when it is known with 249 * certainty that we are **not** in a DOM transaction. 250 * 251 * You may want to call this when you know that some deeper aspect of the 252 * component's state has changed but `setState` was not called. 253 * 254 * This will not invoke `shouldComponentUpdate`, but it will invoke 255 * `componentWillUpdate` and `componentDidUpdate`. 256 * 257 * @param {ReactClass} publicInstance The instance that should rerender. 258 * @param {?function} callback Called after component is updated. 259 * @param {?string} callerName name of the calling function in the public API. 260 * @internal 261 */ 262 enqueueForceUpdate: function (publicInstance, callback, callerName) { 263 warnNoop(publicInstance, 'forceUpdate'); 264 }, 265 266 /** 267 * Replaces all of the state. Always use this or `setState` to mutate state. 268 * You should treat `this.state` as immutable. 269 * 270 * There is no guarantee that `this.state` will be immediately updated, so 271 * accessing `this.state` after calling this method may return the old value. 272 * 273 * @param {ReactClass} publicInstance The instance that should rerender. 274 * @param {object} completeState Next state. 275 * @param {?function} callback Called after component is updated. 276 * @param {?string} callerName name of the calling function in the public API. 277 * @internal 278 */ 279 enqueueReplaceState: function (publicInstance, completeState, callback, callerName) { 280 warnNoop(publicInstance, 'replaceState'); 281 }, 282 283 /** 284 * Sets a subset of the state. This only exists because _pendingState is 285 * internal. This provides a merging strategy that is not available to deep 286 * properties which is confusing. TODO: Expose pendingState or don't use it 287 * during the merge. 288 * 289 * @param {ReactClass} publicInstance The instance that should rerender. 290 * @param {object} partialState Next partial state to be merged with state. 291 * @param {?function} callback Called after component is updated. 292 * @param {?string} Name of the calling function in the public API. 293 * @internal 294 */ 295 enqueueSetState: function (publicInstance, partialState, callback, callerName) { 296 warnNoop(publicInstance, 'setState'); 297 } 298}; 299 300var assign = Object.assign; 301 302var emptyObject = {}; 303 304{ 305 Object.freeze(emptyObject); 306} 307/** 308 * Base class helpers for the updating state of a component. 309 */ 310 311 312function Component(props, context, updater) { 313 this.props = props; 314 this.context = context; // If a component has string refs, we will assign a different object later. 315 316 this.refs = emptyObject; // We initialize the default updater but the real one gets injected by the 317 // renderer. 318 319 this.updater = updater || ReactNoopUpdateQueue; 320} 321 322Component.prototype.isReactComponent = {}; 323/** 324 * Sets a subset of the state. Always use this to mutate 325 * state. You should treat `this.state` as immutable. 326 * 327 * There is no guarantee that `this.state` will be immediately updated, so 328 * accessing `this.state` after calling this method may return the old value. 329 * 330 * There is no guarantee that calls to `setState` will run synchronously, 331 * as they may eventually be batched together. You can provide an optional 332 * callback that will be executed when the call to setState is actually 333 * completed. 334 * 335 * When a function is provided to setState, it will be called at some point in 336 * the future (not synchronously). It will be called with the up to date 337 * component arguments (state, props, context). These values can be different 338 * from this.* because your function may be called after receiveProps but before 339 * shouldComponentUpdate, and this new state, props, and context will not yet be 340 * assigned to this. 341 * 342 * @param {object|function} partialState Next partial state or function to 343 * produce next partial state to be merged with current state. 344 * @param {?function} callback Called after state is updated. 345 * @final 346 * @protected 347 */ 348 349Component.prototype.setState = function (partialState, callback) { 350 if (typeof partialState !== 'object' && typeof partialState !== 'function' && partialState != null) { 351 throw new Error('setState(...): takes an object of state variables to update or a ' + 'function which returns an object of state variables.'); 352 } 353 354 this.updater.enqueueSetState(this, partialState, callback, 'setState'); 355}; 356/** 357 * Forces an update. This should only be invoked when it is known with 358 * certainty that we are **not** in a DOM transaction. 359 * 360 * You may want to call this when you know that some deeper aspect of the 361 * component's state has changed but `setState` was not called. 362 * 363 * This will not invoke `shouldComponentUpdate`, but it will invoke 364 * `componentWillUpdate` and `componentDidUpdate`. 365 * 366 * @param {?function} callback Called after update is complete. 367 * @final 368 * @protected 369 */ 370 371 372Component.prototype.forceUpdate = function (callback) { 373 this.updater.enqueueForceUpdate(this, callback, 'forceUpdate'); 374}; 375/** 376 * Deprecated APIs. These APIs used to exist on classic React classes but since 377 * we would like to deprecate them, we're not going to move them over to this 378 * modern base class. Instead, we define a getter that warns if it's accessed. 379 */ 380 381 382{ 383 var deprecatedAPIs = { 384 isMounted: ['isMounted', 'Instead, make sure to clean up subscriptions and pending requests in ' + 'componentWillUnmount to prevent memory leaks.'], 385 replaceState: ['replaceState', 'Refactor your code to use setState instead (see ' + 'https://github.com/facebook/react/issues/3236).'] 386 }; 387 388 var defineDeprecationWarning = function (methodName, info) { 389 Object.defineProperty(Component.prototype, methodName, { 390 get: function () { 391 warn('%s(...) is deprecated in plain JavaScript React classes. %s', info[0], info[1]); 392 393 return undefined; 394 } 395 }); 396 }; 397 398 for (var fnName in deprecatedAPIs) { 399 if (deprecatedAPIs.hasOwnProperty(fnName)) { 400 defineDeprecationWarning(fnName, deprecatedAPIs[fnName]); 401 } 402 } 403} 404 405function ComponentDummy() {} 406 407ComponentDummy.prototype = Component.prototype; 408/** 409 * Convenience component with default shallow equality check for sCU. 410 */ 411 412function PureComponent(props, context, updater) { 413 this.props = props; 414 this.context = context; // If a component has string refs, we will assign a different object later. 415 416 this.refs = emptyObject; 417 this.updater = updater || ReactNoopUpdateQueue; 418} 419 420var pureComponentPrototype = PureComponent.prototype = new ComponentDummy(); 421pureComponentPrototype.constructor = PureComponent; // Avoid an extra prototype jump for these methods. 422 423assign(pureComponentPrototype, Component.prototype); 424pureComponentPrototype.isPureReactComponent = true; 425 426// an immutable object with a single mutable value 427function createRef() { 428 var refObject = { 429 current: null 430 }; 431 432 { 433 Object.seal(refObject); 434 } 435 436 return refObject; 437} 438 439var isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare 440 441function isArray(a) { 442 return isArrayImpl(a); 443} 444 445/* 446 * The `'' + value` pattern (used in in perf-sensitive code) throws for Symbol 447 * and Temporal.* types. See https://github.com/facebook/react/pull/22064. 448 * 449 * The functions in this module will throw an easier-to-understand, 450 * easier-to-debug exception with a clear errors message message explaining the 451 * problem. (Instead of a confusing exception thrown inside the implementation 452 * of the `value` object). 453 */ 454// $FlowFixMe only called in DEV, so void return is not possible. 455function typeName(value) { 456 { 457 // toStringTag is needed for namespaced types like Temporal.Instant 458 var hasToStringTag = typeof Symbol === 'function' && Symbol.toStringTag; 459 var type = hasToStringTag && value[Symbol.toStringTag] || value.constructor.name || 'Object'; 460 return type; 461 } 462} // $FlowFixMe only called in DEV, so void return is not possible. 463 464 465function willCoercionThrow(value) { 466 { 467 try { 468 testStringCoercion(value); 469 return false; 470 } catch (e) { 471 return true; 472 } 473 } 474} 475 476function testStringCoercion(value) { 477 // If you ended up here by following an exception call stack, here's what's 478 // happened: you supplied an object or symbol value to React (as a prop, key, 479 // DOM attribute, CSS property, string ref, etc.) and when React tried to 480 // coerce it to a string using `'' + value`, an exception was thrown. 481 // 482 // The most common types that will cause this exception are `Symbol` instances 483 // and Temporal objects like `Temporal.Instant`. But any object that has a 484 // `valueOf` or `[Symbol.toPrimitive]` method that throws will also cause this 485 // exception. (Library authors do this to prevent users from using built-in 486 // numeric operators like `+` or comparison operators like `>=` because custom 487 // methods are needed to perform accurate arithmetic or comparison.) 488 // 489 // To fix the problem, coerce this object or symbol value to a string before 490 // passing it to React. The most reliable way is usually `String(value)`. 491 // 492 // To find which value is throwing, check the browser or debugger console. 493 // Before this exception was thrown, there should be `console.error` output 494 // that shows the type (Symbol, Temporal.PlainDate, etc.) that caused the 495 // problem and how that type was used: key, atrribute, input value prop, etc. 496 // In most cases, this console output also shows the component and its 497 // ancestor components where the exception happened. 498 // 499 // eslint-disable-next-line react-internal/safe-string-coercion 500 return '' + value; 501} 502function checkKeyStringCoercion(value) { 503 { 504 if (willCoercionThrow(value)) { 505 error('The provided key is an unsupported type %s.' + ' This value must be coerced to a string before before using it here.', typeName(value)); 506 507 return testStringCoercion(value); // throw (to help callers find troubleshooting comments) 508 } 509 } 510} 511 512function getWrappedName(outerType, innerType, wrapperName) { 513 var displayName = outerType.displayName; 514 515 if (displayName) { 516 return displayName; 517 } 518 519 var functionName = innerType.displayName || innerType.name || ''; 520 return functionName !== '' ? wrapperName + "(" + functionName + ")" : wrapperName; 521} // Keep in sync with react-reconciler/getComponentNameFromFiber 522 523 524function getContextName(type) { 525 return type.displayName || 'Context'; 526} // Note that the reconciler package should generally prefer to use getComponentNameFromFiber() instead. 527 528 529function getComponentNameFromType(type) { 530 if (type == null) { 531 // Host root, text node or just invalid type. 532 return null; 533 } 534 535 { 536 if (typeof type.tag === 'number') { 537 error('Received an unexpected object in getComponentNameFromType(). ' + 'This is likely a bug in React. Please file an issue.'); 538 } 539 } 540 541 if (typeof type === 'function') { 542 return type.displayName || type.name || null; 543 } 544 545 if (typeof type === 'string') { 546 return type; 547 } 548 549 switch (type) { 550 case REACT_FRAGMENT_TYPE: 551 return 'Fragment'; 552 553 case REACT_PORTAL_TYPE: 554 return 'Portal'; 555 556 case REACT_PROFILER_TYPE: 557 return 'Profiler'; 558 559 case REACT_STRICT_MODE_TYPE: 560 return 'StrictMode'; 561 562 case REACT_SUSPENSE_TYPE: 563 return 'Suspense'; 564 565 case REACT_SUSPENSE_LIST_TYPE: 566 return 'SuspenseList'; 567 568 } 569 570 if (typeof type === 'object') { 571 switch (type.$$typeof) { 572 case REACT_CONTEXT_TYPE: 573 var context = type; 574 return getContextName(context) + '.Consumer'; 575 576 case REACT_PROVIDER_TYPE: 577 var provider = type; 578 return getContextName(provider._context) + '.Provider'; 579 580 case REACT_FORWARD_REF_TYPE: 581 return getWrappedName(type, type.render, 'ForwardRef'); 582 583 case REACT_MEMO_TYPE: 584 var outerName = type.displayName || null; 585 586 if (outerName !== null) { 587 return outerName; 588 } 589 590 return getComponentNameFromType(type.type) || 'Memo'; 591 592 case REACT_LAZY_TYPE: 593 { 594 var lazyComponent = type; 595 var payload = lazyComponent._payload; 596 var init = lazyComponent._init; 597 598 try { 599 return getComponentNameFromType(init(payload)); 600 } catch (x) { 601 return null; 602 } 603 } 604 605 // eslint-disable-next-line no-fallthrough 606 } 607 } 608 609 return null; 610} 611 612var hasOwnProperty = Object.prototype.hasOwnProperty; 613 614var RESERVED_PROPS = { 615 key: true, 616 ref: true, 617 __self: true, 618 __source: true 619}; 620var specialPropKeyWarningShown, specialPropRefWarningShown, didWarnAboutStringRefs; 621 622{ 623 didWarnAboutStringRefs = {}; 624} 625 626function hasValidRef(config) { 627 { 628 if (hasOwnProperty.call(config, 'ref')) { 629 var getter = Object.getOwnPropertyDescriptor(config, 'ref').get; 630 631 if (getter && getter.isReactWarning) { 632 return false; 633 } 634 } 635 } 636 637 return config.ref !== undefined; 638} 639 640function hasValidKey(config) { 641 { 642 if (hasOwnProperty.call(config, 'key')) { 643 var getter = Object.getOwnPropertyDescriptor(config, 'key').get; 644 645 if (getter && getter.isReactWarning) { 646 return false; 647 } 648 } 649 } 650 651 return config.key !== undefined; 652} 653 654function defineKeyPropWarningGetter(props, displayName) { 655 var warnAboutAccessingKey = function () { 656 { 657 if (!specialPropKeyWarningShown) { 658 specialPropKeyWarningShown = true; 659 660 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://reactjs.org/link/special-props)', displayName); 661 } 662 } 663 }; 664 665 warnAboutAccessingKey.isReactWarning = true; 666 Object.defineProperty(props, 'key', { 667 get: warnAboutAccessingKey, 668 configurable: true 669 }); 670} 671 672function defineRefPropWarningGetter(props, displayName) { 673 var warnAboutAccessingRef = function () { 674 { 675 if (!specialPropRefWarningShown) { 676 specialPropRefWarningShown = true; 677 678 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://reactjs.org/link/special-props)', displayName); 679 } 680 } 681 }; 682 683 warnAboutAccessingRef.isReactWarning = true; 684 Object.defineProperty(props, 'ref', { 685 get: warnAboutAccessingRef, 686 configurable: true 687 }); 688} 689 690function warnIfStringRefCannotBeAutoConverted(config) { 691 { 692 if (typeof config.ref === 'string' && ReactCurrentOwner.current && config.__self && ReactCurrentOwner.current.stateNode !== config.__self) { 693 var componentName = getComponentNameFromType(ReactCurrentOwner.current.type); 694 695 if (!didWarnAboutStringRefs[componentName]) { 696 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://reactjs.org/link/strict-mode-string-ref', componentName, config.ref); 697 698 didWarnAboutStringRefs[componentName] = true; 699 } 700 } 701 } 702} 703/** 704 * Factory method to create a new React element. This no longer adheres to 705 * the class pattern, so do not use new to call it. Also, instanceof check 706 * will not work. Instead test $$typeof field against Symbol.for('react.element') to check 707 * if something is a React Element. 708 * 709 * @param {*} type 710 * @param {*} props 711 * @param {*} key 712 * @param {string|object} ref 713 * @param {*} owner 714 * @param {*} self A *temporary* helper to detect places where `this` is 715 * different from the `owner` when React.createElement is called, so that we 716 * can warn. We want to get rid of owner and replace string `ref`s with arrow 717 * functions, and as long as `this` and owner are the same, there will be no 718 * change in behavior. 719 * @param {*} source An annotation object (added by a transpiler or otherwise) 720 * indicating filename, line number, and/or other information. 721 * @internal 722 */ 723 724 725var ReactElement = function (type, key, ref, self, source, owner, props) { 726 var element = { 727 // This tag allows us to uniquely identify this as a React Element 728 $$typeof: REACT_ELEMENT_TYPE, 729 // Built-in properties that belong on the element 730 type: type, 731 key: key, 732 ref: ref, 733 props: props, 734 // Record the component responsible for creating this element. 735 _owner: owner 736 }; 737 738 { 739 // The validation flag is currently mutative. We put it on 740 // an external backing store so that we can freeze the whole object. 741 // This can be replaced with a WeakMap once they are implemented in 742 // commonly used development environments. 743 element._store = {}; // To make comparing ReactElements easier for testing purposes, we make 744 // the validation flag non-enumerable (where possible, which should 745 // include every environment we run tests in), so the test framework 746 // ignores it. 747 748 Object.defineProperty(element._store, 'validated', { 749 configurable: false, 750 enumerable: false, 751 writable: true, 752 value: false 753 }); // self and source are DEV only properties. 754 755 Object.defineProperty(element, '_self', { 756 configurable: false, 757 enumerable: false, 758 writable: false, 759 value: self 760 }); // Two elements created in two different places should be considered 761 // equal for testing purposes and therefore we hide it from enumeration. 762 763 Object.defineProperty(element, '_source', { 764 configurable: false, 765 enumerable: false, 766 writable: false, 767 value: source 768 }); 769 770 if (Object.freeze) { 771 Object.freeze(element.props); 772 Object.freeze(element); 773 } 774 } 775 776 return element; 777}; 778/** 779 * Create and return a new ReactElement of the given type. 780 * See https://reactjs.org/docs/react-api.html#createelement 781 */ 782 783function createElement(type, config, children) { 784 var propName; // Reserved names are extracted 785 786 var props = {}; 787 var key = null; 788 var ref = null; 789 var self = null; 790 var source = null; 791 792 if (config != null) { 793 if (hasValidRef(config)) { 794 ref = config.ref; 795 796 { 797 warnIfStringRefCannotBeAutoConverted(config); 798 } 799 } 800 801 if (hasValidKey(config)) { 802 { 803 checkKeyStringCoercion(config.key); 804 } 805 806 key = '' + config.key; 807 } 808 809 self = config.__self === undefined ? null : config.__self; 810 source = config.__source === undefined ? null : config.__source; // Remaining properties are added to a new props object 811 812 for (propName in config) { 813 if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) { 814 props[propName] = config[propName]; 815 } 816 } 817 } // Children can be more than one argument, and those are transferred onto 818 // the newly allocated props object. 819 820 821 var childrenLength = arguments.length - 2; 822 823 if (childrenLength === 1) { 824 props.children = children; 825 } else if (childrenLength > 1) { 826 var childArray = Array(childrenLength); 827 828 for (var i = 0; i < childrenLength; i++) { 829 childArray[i] = arguments[i + 2]; 830 } 831 832 { 833 if (Object.freeze) { 834 Object.freeze(childArray); 835 } 836 } 837 838 props.children = childArray; 839 } // Resolve default props 840 841 842 if (type && type.defaultProps) { 843 var defaultProps = type.defaultProps; 844 845 for (propName in defaultProps) { 846 if (props[propName] === undefined) { 847 props[propName] = defaultProps[propName]; 848 } 849 } 850 } 851 852 { 853 if (key || ref) { 854 var displayName = typeof type === 'function' ? type.displayName || type.name || 'Unknown' : type; 855 856 if (key) { 857 defineKeyPropWarningGetter(props, displayName); 858 } 859 860 if (ref) { 861 defineRefPropWarningGetter(props, displayName); 862 } 863 } 864 } 865 866 return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props); 867} 868function cloneAndReplaceKey(oldElement, newKey) { 869 var newElement = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props); 870 return newElement; 871} 872/** 873 * Clone and return a new ReactElement using element as the starting point. 874 * See https://reactjs.org/docs/react-api.html#cloneelement 875 */ 876 877function cloneElement(element, config, children) { 878 if (element === null || element === undefined) { 879 throw new Error("React.cloneElement(...): The argument must be a React element, but you passed " + element + "."); 880 } 881 882 var propName; // Original props are copied 883 884 var props = assign({}, element.props); // Reserved names are extracted 885 886 var key = element.key; 887 var ref = element.ref; // Self is preserved since the owner is preserved. 888 889 var self = element._self; // Source is preserved since cloneElement is unlikely to be targeted by a 890 // transpiler, and the original source is probably a better indicator of the 891 // true owner. 892 893 var source = element._source; // Owner will be preserved, unless ref is overridden 894 895 var owner = element._owner; 896 897 if (config != null) { 898 if (hasValidRef(config)) { 899 // Silently steal the ref from the parent. 900 ref = config.ref; 901 owner = ReactCurrentOwner.current; 902 } 903 904 if (hasValidKey(config)) { 905 { 906 checkKeyStringCoercion(config.key); 907 } 908 909 key = '' + config.key; 910 } // Remaining properties override existing props 911 912 913 var defaultProps; 914 915 if (element.type && element.type.defaultProps) { 916 defaultProps = element.type.defaultProps; 917 } 918 919 for (propName in config) { 920 if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) { 921 if (config[propName] === undefined && defaultProps !== undefined) { 922 // Resolve default props 923 props[propName] = defaultProps[propName]; 924 } else { 925 props[propName] = config[propName]; 926 } 927 } 928 } 929 } // Children can be more than one argument, and those are transferred onto 930 // the newly allocated props object. 931 932 933 var childrenLength = arguments.length - 2; 934 935 if (childrenLength === 1) { 936 props.children = children; 937 } else if (childrenLength > 1) { 938 var childArray = Array(childrenLength); 939 940 for (var i = 0; i < childrenLength; i++) { 941 childArray[i] = arguments[i + 2]; 942 } 943 944 props.children = childArray; 945 } 946 947 return ReactElement(element.type, key, ref, self, source, owner, props); 948} 949/** 950 * Verifies the object is a ReactElement. 951 * See https://reactjs.org/docs/react-api.html#isvalidelement 952 * @param {?object} object 953 * @return {boolean} True if `object` is a ReactElement. 954 * @final 955 */ 956 957function isValidElement(object) { 958 return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE; 959} 960 961var SEPARATOR = '.'; 962var SUBSEPARATOR = ':'; 963/** 964 * Escape and wrap key so it is safe to use as a reactid 965 * 966 * @param {string} key to be escaped. 967 * @return {string} the escaped key. 968 */ 969 970function escape(key) { 971 var escapeRegex = /[=:]/g; 972 var escaperLookup = { 973 '=': '=0', 974 ':': '=2' 975 }; 976 var escapedString = key.replace(escapeRegex, function (match) { 977 return escaperLookup[match]; 978 }); 979 return '$' + escapedString; 980} 981/** 982 * TODO: Test that a single child and an array with one item have the same key 983 * pattern. 984 */ 985 986 987var didWarnAboutMaps = false; 988var userProvidedKeyEscapeRegex = /\/+/g; 989 990function escapeUserProvidedKey(text) { 991 return text.replace(userProvidedKeyEscapeRegex, '$&/'); 992} 993/** 994 * Generate a key string that identifies a element within a set. 995 * 996 * @param {*} element A element that could contain a manual key. 997 * @param {number} index Index that is used if a manual key is not provided. 998 * @return {string} 999 */ 1000 1001 1002function getElementKey(element, index) { 1003 // Do some typechecking here since we call this blindly. We want to ensure 1004 // that we don't block potential future ES APIs. 1005 if (typeof element === 'object' && element !== null && element.key != null) { 1006 // Explicit key 1007 { 1008 checkKeyStringCoercion(element.key); 1009 } 1010 1011 return escape('' + element.key); 1012 } // Implicit key determined by the index in the set 1013 1014 1015 return index.toString(36); 1016} 1017 1018function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) { 1019 var type = typeof children; 1020 1021 if (type === 'undefined' || type === 'boolean') { 1022 // All of the above are perceived as null. 1023 children = null; 1024 } 1025 1026 var invokeCallback = false; 1027 1028 if (children === null) { 1029 invokeCallback = true; 1030 } else { 1031 switch (type) { 1032 case 'string': 1033 case 'number': 1034 invokeCallback = true; 1035 break; 1036 1037 case 'object': 1038 switch (children.$$typeof) { 1039 case REACT_ELEMENT_TYPE: 1040 case REACT_PORTAL_TYPE: 1041 invokeCallback = true; 1042 } 1043 1044 } 1045 } 1046 1047 if (invokeCallback) { 1048 var _child = children; 1049 var mappedChild = callback(_child); // If it's the only child, treat the name as if it was wrapped in an array 1050 // so that it's consistent if the number of children grows: 1051 1052 var childKey = nameSoFar === '' ? SEPARATOR + getElementKey(_child, 0) : nameSoFar; 1053 1054 if (isArray(mappedChild)) { 1055 var escapedChildKey = ''; 1056 1057 if (childKey != null) { 1058 escapedChildKey = escapeUserProvidedKey(childKey) + '/'; 1059 } 1060 1061 mapIntoArray(mappedChild, array, escapedChildKey, '', function (c) { 1062 return c; 1063 }); 1064 } else if (mappedChild != null) { 1065 if (isValidElement(mappedChild)) { 1066 { 1067 // The `if` statement here prevents auto-disabling of the safe 1068 // coercion ESLint rule, so we must manually disable it below. 1069 // $FlowFixMe Flow incorrectly thinks React.Portal doesn't have a key 1070 if (mappedChild.key && (!_child || _child.key !== mappedChild.key)) { 1071 checkKeyStringCoercion(mappedChild.key); 1072 } 1073 } 1074 1075 mappedChild = cloneAndReplaceKey(mappedChild, // Keep both the (mapped) and old keys if they differ, just as 1076 // traverseAllChildren used to do for objects as children 1077 escapedPrefix + ( // $FlowFixMe Flow incorrectly thinks React.Portal doesn't have a key 1078 mappedChild.key && (!_child || _child.key !== mappedChild.key) ? // $FlowFixMe Flow incorrectly thinks existing element's key can be a number 1079 // eslint-disable-next-line react-internal/safe-string-coercion 1080 escapeUserProvidedKey('' + mappedChild.key) + '/' : '') + childKey); 1081 } 1082 1083 array.push(mappedChild); 1084 } 1085 1086 return 1; 1087 } 1088 1089 var child; 1090 var nextName; 1091 var subtreeCount = 0; // Count of children found in the current subtree. 1092 1093 var nextNamePrefix = nameSoFar === '' ? SEPARATOR : nameSoFar + SUBSEPARATOR; 1094 1095 if (isArray(children)) { 1096 for (var i = 0; i < children.length; i++) { 1097 child = children[i]; 1098 nextName = nextNamePrefix + getElementKey(child, i); 1099 subtreeCount += mapIntoArray(child, array, escapedPrefix, nextName, callback); 1100 } 1101 } else { 1102 var iteratorFn = getIteratorFn(children); 1103 1104 if (typeof iteratorFn === 'function') { 1105 var iterableChildren = children; 1106 1107 { 1108 // Warn about using Maps as children 1109 if (iteratorFn === iterableChildren.entries) { 1110 if (!didWarnAboutMaps) { 1111 warn('Using Maps as children is not supported. ' + 'Use an array of keyed ReactElements instead.'); 1112 } 1113 1114 didWarnAboutMaps = true; 1115 } 1116 } 1117 1118 var iterator = iteratorFn.call(iterableChildren); 1119 var step; 1120 var ii = 0; 1121 1122 while (!(step = iterator.next()).done) { 1123 child = step.value; 1124 nextName = nextNamePrefix + getElementKey(child, ii++); 1125 subtreeCount += mapIntoArray(child, array, escapedPrefix, nextName, callback); 1126 } 1127 } else if (type === 'object') { 1128 // eslint-disable-next-line react-internal/safe-string-coercion 1129 var childrenString = String(children); 1130 throw new Error("Objects are not valid as a React child (found: " + (childrenString === '[object Object]' ? 'object with keys {' + Object.keys(children).join(', ') + '}' : childrenString) + "). " + 'If you meant to render a collection of children, use an array ' + 'instead.'); 1131 } 1132 } 1133 1134 return subtreeCount; 1135} 1136 1137/** 1138 * Maps children that are typically specified as `props.children`. 1139 * 1140 * See https://reactjs.org/docs/react-api.html#reactchildrenmap 1141 * 1142 * The provided mapFunction(child, index) will be called for each 1143 * leaf child. 1144 * 1145 * @param {?*} children Children tree container. 1146 * @param {function(*, int)} func The map function. 1147 * @param {*} context Context for mapFunction. 1148 * @return {object} Object containing the ordered map of results. 1149 */ 1150function mapChildren(children, func, context) { 1151 if (children == null) { 1152 return children; 1153 } 1154 1155 var result = []; 1156 var count = 0; 1157 mapIntoArray(children, result, '', '', function (child) { 1158 return func.call(context, child, count++); 1159 }); 1160 return result; 1161} 1162/** 1163 * Count the number of children that are typically specified as 1164 * `props.children`. 1165 * 1166 * See https://reactjs.org/docs/react-api.html#reactchildrencount 1167 * 1168 * @param {?*} children Children tree container. 1169 * @return {number} The number of children. 1170 */ 1171 1172 1173function countChildren(children) { 1174 var n = 0; 1175 mapChildren(children, function () { 1176 n++; // Don't return anything 1177 }); 1178 return n; 1179} 1180 1181/** 1182 * Iterates through children that are typically specified as `props.children`. 1183 * 1184 * See https://reactjs.org/docs/react-api.html#reactchildrenforeach 1185 * 1186 * The provided forEachFunc(child, index) will be called for each 1187 * leaf child. 1188 * 1189 * @param {?*} children Children tree container. 1190 * @param {function(*, int)} forEachFunc 1191 * @param {*} forEachContext Context for forEachContext. 1192 */ 1193function forEachChildren(children, forEachFunc, forEachContext) { 1194 mapChildren(children, function () { 1195 forEachFunc.apply(this, arguments); // Don't return anything. 1196 }, forEachContext); 1197} 1198/** 1199 * Flatten a children object (typically specified as `props.children`) and 1200 * return an array with appropriately re-keyed children. 1201 * 1202 * See https://reactjs.org/docs/react-api.html#reactchildrentoarray 1203 */ 1204 1205 1206function toArray(children) { 1207 return mapChildren(children, function (child) { 1208 return child; 1209 }) || []; 1210} 1211/** 1212 * Returns the first child in a collection of children and verifies that there 1213 * is only one child in the collection. 1214 * 1215 * See https://reactjs.org/docs/react-api.html#reactchildrenonly 1216 * 1217 * The current implementation of this function assumes that a single child gets 1218 * passed without a wrapper, but the purpose of this helper function is to 1219 * abstract away the particular structure of children. 1220 * 1221 * @param {?object} children Child collection structure. 1222 * @return {ReactElement} The first and only `ReactElement` contained in the 1223 * structure. 1224 */ 1225 1226 1227function onlyChild(children) { 1228 if (!isValidElement(children)) { 1229 throw new Error('React.Children.only expected to receive a single React element child.'); 1230 } 1231 1232 return children; 1233} 1234 1235function createContext(defaultValue) { 1236 // TODO: Second argument used to be an optional `calculateChangedBits` 1237 // function. Warn to reserve for future use? 1238 var context = { 1239 $$typeof: REACT_CONTEXT_TYPE, 1240 // As a workaround to support multiple concurrent renderers, we categorize 1241 // some renderers as primary and others as secondary. We only expect 1242 // there to be two concurrent renderers at most: React Native (primary) and 1243 // Fabric (secondary); React DOM (primary) and React ART (secondary). 1244 // Secondary renderers store their context values on separate fields. 1245 _currentValue: defaultValue, 1246 _currentValue2: defaultValue, 1247 // Used to track how many concurrent renderers this context currently 1248 // supports within in a single renderer. Such as parallel server rendering. 1249 _threadCount: 0, 1250 // These are circular 1251 Provider: null, 1252 Consumer: null, 1253 // Add these to use same hidden class in VM as ServerContext 1254 _defaultValue: null, 1255 _globalName: null 1256 }; 1257 context.Provider = { 1258 $$typeof: REACT_PROVIDER_TYPE, 1259 _context: context 1260 }; 1261 var hasWarnedAboutUsingNestedContextConsumers = false; 1262 var hasWarnedAboutUsingConsumerProvider = false; 1263 var hasWarnedAboutDisplayNameOnConsumer = false; 1264 1265 { 1266 // A separate object, but proxies back to the original context object for 1267 // backwards compatibility. It has a different $$typeof, so we can properly 1268 // warn for the incorrect usage of Context as a Consumer. 1269 var Consumer = { 1270 $$typeof: REACT_CONTEXT_TYPE, 1271 _context: context 1272 }; // $FlowFixMe: Flow complains about not setting a value, which is intentional here 1273 1274 Object.defineProperties(Consumer, { 1275 Provider: { 1276 get: function () { 1277 if (!hasWarnedAboutUsingConsumerProvider) { 1278 hasWarnedAboutUsingConsumerProvider = true; 1279 1280 error('Rendering <Context.Consumer.Provider> is not supported and will be removed in ' + 'a future major release. Did you mean to render <Context.Provider> instead?'); 1281 } 1282 1283 return context.Provider; 1284 }, 1285 set: function (_Provider) { 1286 context.Provider = _Provider; 1287 } 1288 }, 1289 _currentValue: { 1290 get: function () { 1291 return context._currentValue; 1292 }, 1293 set: function (_currentValue) { 1294 context._currentValue = _currentValue; 1295 } 1296 }, 1297 _currentValue2: { 1298 get: function () { 1299 return context._currentValue2; 1300 }, 1301 set: function (_currentValue2) { 1302 context._currentValue2 = _currentValue2; 1303 } 1304 }, 1305 _threadCount: { 1306 get: function () { 1307 return context._threadCount; 1308 }, 1309 set: function (_threadCount) { 1310 context._threadCount = _threadCount; 1311 } 1312 }, 1313 Consumer: { 1314 get: function () { 1315 if (!hasWarnedAboutUsingNestedContextConsumers) { 1316 hasWarnedAboutUsingNestedContextConsumers = true; 1317 1318 error('Rendering <Context.Consumer.Consumer> is not supported and will be removed in ' + 'a future major release. Did you mean to render <Context.Consumer> instead?'); 1319 } 1320 1321 return context.Consumer; 1322 } 1323 }, 1324 displayName: { 1325 get: function () { 1326 return context.displayName; 1327 }, 1328 set: function (displayName) { 1329 if (!hasWarnedAboutDisplayNameOnConsumer) { 1330 warn('Setting `displayName` on Context.Consumer has no effect. ' + "You should set it directly on the context with Context.displayName = '%s'.", displayName); 1331 1332 hasWarnedAboutDisplayNameOnConsumer = true; 1333 } 1334 } 1335 } 1336 }); // $FlowFixMe: Flow complains about missing properties because it doesn't understand defineProperty 1337 1338 context.Consumer = Consumer; 1339 } 1340 1341 { 1342 context._currentRenderer = null; 1343 context._currentRenderer2 = null; 1344 } 1345 1346 return context; 1347} 1348 1349var Uninitialized = -1; 1350var Pending = 0; 1351var Resolved = 1; 1352var Rejected = 2; 1353 1354function lazyInitializer(payload) { 1355 if (payload._status === Uninitialized) { 1356 var ctor = payload._result; 1357 var thenable = ctor(); // Transition to the next state. 1358 // This might throw either because it's missing or throws. If so, we treat it 1359 // as still uninitialized and try again next time. Which is the same as what 1360 // happens if the ctor or any wrappers processing the ctor throws. This might 1361 // end up fixing it if the resolution was a concurrency bug. 1362 1363 thenable.then(function (moduleObject) { 1364 if (payload._status === Pending || payload._status === Uninitialized) { 1365 // Transition to the next state. 1366 var resolved = payload; 1367 resolved._status = Resolved; 1368 resolved._result = moduleObject; 1369 } 1370 }, function (error) { 1371 if (payload._status === Pending || payload._status === Uninitialized) { 1372 // Transition to the next state. 1373 var rejected = payload; 1374 rejected._status = Rejected; 1375 rejected._result = error; 1376 } 1377 }); 1378 1379 if (payload._status === Uninitialized) { 1380 // In case, we're still uninitialized, then we're waiting for the thenable 1381 // to resolve. Set it as pending in the meantime. 1382 var pending = payload; 1383 pending._status = Pending; 1384 pending._result = thenable; 1385 } 1386 } 1387 1388 if (payload._status === Resolved) { 1389 var moduleObject = payload._result; 1390 1391 { 1392 if (moduleObject === undefined) { 1393 error('lazy: Expected the result of a dynamic imp' + 'ort() call. ' + 'Instead received: %s\n\nYour code should look like: \n ' + // Break up imports to avoid accidentally parsing them as dependencies. 1394 'const MyComponent = lazy(() => imp' + "ort('./MyComponent'))\n\n" + 'Did you accidentally put curly braces around the import?', moduleObject); 1395 } 1396 } 1397 1398 { 1399 if (!('default' in moduleObject)) { 1400 error('lazy: Expected the result of a dynamic imp' + 'ort() call. ' + 'Instead received: %s\n\nYour code should look like: \n ' + // Break up imports to avoid accidentally parsing them as dependencies. 1401 'const MyComponent = lazy(() => imp' + "ort('./MyComponent'))", moduleObject); 1402 } 1403 } 1404 1405 return moduleObject.default; 1406 } else { 1407 throw payload._result; 1408 } 1409} 1410 1411function lazy(ctor) { 1412 var payload = { 1413 // We use these fields to store the result. 1414 _status: Uninitialized, 1415 _result: ctor 1416 }; 1417 var lazyType = { 1418 $$typeof: REACT_LAZY_TYPE, 1419 _payload: payload, 1420 _init: lazyInitializer 1421 }; 1422 1423 { 1424 // In production, this would just set it on the object. 1425 var defaultProps; 1426 var propTypes; // $FlowFixMe 1427 1428 Object.defineProperties(lazyType, { 1429 defaultProps: { 1430 configurable: true, 1431 get: function () { 1432 return defaultProps; 1433 }, 1434 set: function (newDefaultProps) { 1435 error('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.'); 1436 1437 defaultProps = newDefaultProps; // Match production behavior more closely: 1438 // $FlowFixMe 1439 1440 Object.defineProperty(lazyType, 'defaultProps', { 1441 enumerable: true 1442 }); 1443 } 1444 }, 1445 propTypes: { 1446 configurable: true, 1447 get: function () { 1448 return propTypes; 1449 }, 1450 set: function (newPropTypes) { 1451 error('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.'); 1452 1453 propTypes = newPropTypes; // Match production behavior more closely: 1454 // $FlowFixMe 1455 1456 Object.defineProperty(lazyType, 'propTypes', { 1457 enumerable: true 1458 }); 1459 } 1460 } 1461 }); 1462 } 1463 1464 return lazyType; 1465} 1466 1467function forwardRef(render) { 1468 { 1469 if (render != null && render.$$typeof === REACT_MEMO_TYPE) { 1470 error('forwardRef requires a render function but received a `memo` ' + 'component. Instead of forwardRef(memo(...)), use ' + 'memo(forwardRef(...)).'); 1471 } else if (typeof render !== 'function') { 1472 error('forwardRef requires a render function but was given %s.', render === null ? 'null' : typeof render); 1473 } else { 1474 if (render.length !== 0 && render.length !== 2) { 1475 error('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.'); 1476 } 1477 } 1478 1479 if (render != null) { 1480 if (render.defaultProps != null || render.propTypes != null) { 1481 error('forwardRef render functions do not support propTypes or defaultProps. ' + 'Did you accidentally pass a React component?'); 1482 } 1483 } 1484 } 1485 1486 var elementType = { 1487 $$typeof: REACT_FORWARD_REF_TYPE, 1488 render: render 1489 }; 1490 1491 { 1492 var ownName; 1493 Object.defineProperty(elementType, 'displayName', { 1494 enumerable: false, 1495 configurable: true, 1496 get: function () { 1497 return ownName; 1498 }, 1499 set: function (name) { 1500 ownName = name; // The inner component shouldn't inherit this display name in most cases, 1501 // because the component may be used elsewhere. 1502 // But it's nice for anonymous functions to inherit the name, 1503 // so that our component-stack generation logic will display their frames. 1504 // An anonymous function generally suggests a pattern like: 1505 // React.forwardRef((props, ref) => {...}); 1506 // This kind of inner function is not used elsewhere so the side effect is okay. 1507 1508 if (!render.name && !render.displayName) { 1509 render.displayName = name; 1510 } 1511 } 1512 }); 1513 } 1514 1515 return elementType; 1516} 1517 1518var REACT_MODULE_REFERENCE; 1519 1520{ 1521 REACT_MODULE_REFERENCE = Symbol.for('react.module.reference'); 1522} 1523 1524function isValidElementType(type) { 1525 if (typeof type === 'string' || typeof type === 'function') { 1526 return true; 1527 } // Note: typeof might be other than 'symbol' or 'number' (e.g. if it's a polyfill). 1528 1529 1530 if (type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || enableDebugTracing || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || enableLegacyHidden || type === REACT_OFFSCREEN_TYPE || enableScopeAPI || enableCacheElement || enableTransitionTracing ) { 1531 return true; 1532 } 1533 1534 if (typeof type === 'object' && type !== null) { 1535 if (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 || // This needs to include all possible module reference object 1536 // types supported by any Flight configuration anywhere since 1537 // we don't know which Flight build this will end up being used 1538 // with. 1539 type.$$typeof === REACT_MODULE_REFERENCE || type.getModuleId !== undefined) { 1540 return true; 1541 } 1542 } 1543 1544 return false; 1545} 1546 1547function memo(type, compare) { 1548 { 1549 if (!isValidElementType(type)) { 1550 error('memo: The first argument must be a component. Instead ' + 'received: %s', type === null ? 'null' : typeof type); 1551 } 1552 } 1553 1554 var elementType = { 1555 $$typeof: REACT_MEMO_TYPE, 1556 type: type, 1557 compare: compare === undefined ? null : compare 1558 }; 1559 1560 { 1561 var ownName; 1562 Object.defineProperty(elementType, 'displayName', { 1563 enumerable: false, 1564 configurable: true, 1565 get: function () { 1566 return ownName; 1567 }, 1568 set: function (name) { 1569 ownName = name; // The inner component shouldn't inherit this display name in most cases, 1570 // because the component may be used elsewhere. 1571 // But it's nice for anonymous functions to inherit the name, 1572 // so that our component-stack generation logic will display their frames. 1573 // An anonymous function generally suggests a pattern like: 1574 // React.memo((props) => {...}); 1575 // This kind of inner function is not used elsewhere so the side effect is okay. 1576 1577 if (!type.name && !type.displayName) { 1578 type.displayName = name; 1579 } 1580 } 1581 }); 1582 } 1583 1584 return elementType; 1585} 1586 1587function resolveDispatcher() { 1588 var dispatcher = ReactCurrentDispatcher.current; 1589 1590 { 1591 if (dispatcher === null) { 1592 error('Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for' + ' one of the following reasons:\n' + '1. You might have mismatching versions of React and the renderer (such as React DOM)\n' + '2. You might be breaking the Rules of Hooks\n' + '3. You might have more than one copy of React in the same app\n' + 'See https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem.'); 1593 } 1594 } // Will result in a null access error if accessed outside render phase. We 1595 // intentionally don't throw our own error because this is in a hot path. 1596 // Also helps ensure this is inlined. 1597 1598 1599 return dispatcher; 1600} 1601function useContext(Context) { 1602 var dispatcher = resolveDispatcher(); 1603 1604 { 1605 // TODO: add a more generic warning for invalid values. 1606 if (Context._context !== undefined) { 1607 var realContext = Context._context; // Don't deduplicate because this legitimately causes bugs 1608 // and nobody should be using this in existing code. 1609 1610 if (realContext.Consumer === Context) { 1611 error('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?'); 1612 } else if (realContext.Provider === Context) { 1613 error('Calling useContext(Context.Provider) is not supported. ' + 'Did you mean to call useContext(Context) instead?'); 1614 } 1615 } 1616 } 1617 1618 return dispatcher.useContext(Context); 1619} 1620function useState(initialState) { 1621 var dispatcher = resolveDispatcher(); 1622 return dispatcher.useState(initialState); 1623} 1624function useReducer(reducer, initialArg, init) { 1625 var dispatcher = resolveDispatcher(); 1626 return dispatcher.useReducer(reducer, initialArg, init); 1627} 1628function useRef(initialValue) { 1629 var dispatcher = resolveDispatcher(); 1630 return dispatcher.useRef(initialValue); 1631} 1632function useEffect(create, deps) { 1633 var dispatcher = resolveDispatcher(); 1634 return dispatcher.useEffect(create, deps); 1635} 1636function useInsertionEffect(create, deps) { 1637 var dispatcher = resolveDispatcher(); 1638 return dispatcher.useInsertionEffect(create, deps); 1639} 1640function useLayoutEffect(create, deps) { 1641 var dispatcher = resolveDispatcher(); 1642 return dispatcher.useLayoutEffect(create, deps); 1643} 1644function useCallback(callback, deps) { 1645 var dispatcher = resolveDispatcher(); 1646 return dispatcher.useCallback(callback, deps); 1647} 1648function useMemo(create, deps) { 1649 var dispatcher = resolveDispatcher(); 1650 return dispatcher.useMemo(create, deps); 1651} 1652function useImperativeHandle(ref, create, deps) { 1653 var dispatcher = resolveDispatcher(); 1654 return dispatcher.useImperativeHandle(ref, create, deps); 1655} 1656function useDebugValue(value, formatterFn) { 1657 { 1658 var dispatcher = resolveDispatcher(); 1659 return dispatcher.useDebugValue(value, formatterFn); 1660 } 1661} 1662function useTransition() { 1663 var dispatcher = resolveDispatcher(); 1664 return dispatcher.useTransition(); 1665} 1666function useDeferredValue(value) { 1667 var dispatcher = resolveDispatcher(); 1668 return dispatcher.useDeferredValue(value); 1669} 1670function useId() { 1671 var dispatcher = resolveDispatcher(); 1672 return dispatcher.useId(); 1673} 1674function useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) { 1675 var dispatcher = resolveDispatcher(); 1676 return dispatcher.useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot); 1677} 1678 1679// Helpers to patch console.logs to avoid logging during side-effect free 1680// replaying on render function. This currently only patches the object 1681// lazily which won't cover if the log function was extracted eagerly. 1682// We could also eagerly patch the method. 1683var disabledDepth = 0; 1684var prevLog; 1685var prevInfo; 1686var prevWarn; 1687var prevError; 1688var prevGroup; 1689var prevGroupCollapsed; 1690var prevGroupEnd; 1691 1692function disabledLog() {} 1693 1694disabledLog.__reactDisabledLog = true; 1695function disableLogs() { 1696 { 1697 if (disabledDepth === 0) { 1698 /* eslint-disable react-internal/no-production-logging */ 1699 prevLog = console.log; 1700 prevInfo = console.info; 1701 prevWarn = console.warn; 1702 prevError = console.error; 1703 prevGroup = console.group; 1704 prevGroupCollapsed = console.groupCollapsed; 1705 prevGroupEnd = console.groupEnd; // https://github.com/facebook/react/issues/19099 1706 1707 var props = { 1708 configurable: true, 1709 enumerable: true, 1710 value: disabledLog, 1711 writable: true 1712 }; // $FlowFixMe Flow thinks console is immutable. 1713 1714 Object.defineProperties(console, { 1715 info: props, 1716 log: props, 1717 warn: props, 1718 error: props, 1719 group: props, 1720 groupCollapsed: props, 1721 groupEnd: props 1722 }); 1723 /* eslint-enable react-internal/no-production-logging */ 1724 } 1725 1726 disabledDepth++; 1727 } 1728} 1729function reenableLogs() { 1730 { 1731 disabledDepth--; 1732 1733 if (disabledDepth === 0) { 1734 /* eslint-disable react-internal/no-production-logging */ 1735 var props = { 1736 configurable: true, 1737 enumerable: true, 1738 writable: true 1739 }; // $FlowFixMe Flow thinks console is immutable. 1740 1741 Object.defineProperties(console, { 1742 log: assign({}, props, { 1743 value: prevLog 1744 }), 1745 info: assign({}, props, { 1746 value: prevInfo 1747 }), 1748 warn: assign({}, props, { 1749 value: prevWarn 1750 }), 1751 error: assign({}, props, { 1752 value: prevError 1753 }), 1754 group: assign({}, props, { 1755 value: prevGroup 1756 }), 1757 groupCollapsed: assign({}, props, { 1758 value: prevGroupCollapsed 1759 }), 1760 groupEnd: assign({}, props, { 1761 value: prevGroupEnd 1762 }) 1763 }); 1764 /* eslint-enable react-internal/no-production-logging */ 1765 } 1766 1767 if (disabledDepth < 0) { 1768 error('disabledDepth fell below zero. ' + 'This is a bug in React. Please file an issue.'); 1769 } 1770 } 1771} 1772 1773var ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher; 1774var prefix; 1775function describeBuiltInComponentFrame(name, source, ownerFn) { 1776 { 1777 if (prefix === undefined) { 1778 // Extract the VM specific prefix used by each line. 1779 try { 1780 throw Error(); 1781 } catch (x) { 1782 var match = x.stack.trim().match(/\n( *(at )?)/); 1783 prefix = match && match[1] || ''; 1784 } 1785 } // We use the prefix to ensure our stacks line up with native stack frames. 1786 1787 1788 return '\n' + prefix + name; 1789 } 1790} 1791var reentry = false; 1792var componentFrameCache; 1793 1794{ 1795 var PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map; 1796 componentFrameCache = new PossiblyWeakMap(); 1797} 1798 1799function describeNativeComponentFrame(fn, construct) { 1800 // If something asked for a stack inside a fake render, it should get ignored. 1801 if ( !fn || reentry) { 1802 return ''; 1803 } 1804 1805 { 1806 var frame = componentFrameCache.get(fn); 1807 1808 if (frame !== undefined) { 1809 return frame; 1810 } 1811 } 1812 1813 var control; 1814 reentry = true; 1815 var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe It does accept undefined. 1816 1817 Error.prepareStackTrace = undefined; 1818 var previousDispatcher; 1819 1820 { 1821 previousDispatcher = ReactCurrentDispatcher$1.current; // Set the dispatcher in DEV because this might be call in the render function 1822 // for warnings. 1823 1824 ReactCurrentDispatcher$1.current = null; 1825 disableLogs(); 1826 } 1827 1828 try { 1829 // This should throw. 1830 if (construct) { 1831 // Something should be setting the props in the constructor. 1832 var Fake = function () { 1833 throw Error(); 1834 }; // $FlowFixMe 1835 1836 1837 Object.defineProperty(Fake.prototype, 'props', { 1838 set: function () { 1839 // We use a throwing setter instead of frozen or non-writable props 1840 // because that won't throw in a non-strict mode function. 1841 throw Error(); 1842 } 1843 }); 1844 1845 if (typeof Reflect === 'object' && Reflect.construct) { 1846 // We construct a different control for this case to include any extra 1847 // frames added by the construct call. 1848 try { 1849 Reflect.construct(Fake, []); 1850 } catch (x) { 1851 control = x; 1852 } 1853 1854 Reflect.construct(fn, [], Fake); 1855 } else { 1856 try { 1857 Fake.call(); 1858 } catch (x) { 1859 control = x; 1860 } 1861 1862 fn.call(Fake.prototype); 1863 } 1864 } else { 1865 try { 1866 throw Error(); 1867 } catch (x) { 1868 control = x; 1869 } 1870 1871 fn(); 1872 } 1873 } catch (sample) { 1874 // This is inlined manually because closure doesn't do it for us. 1875 if (sample && control && typeof sample.stack === 'string') { 1876 // This extracts the first frame from the sample that isn't also in the control. 1877 // Skipping one frame that we assume is the frame that calls the two. 1878 var sampleLines = sample.stack.split('\n'); 1879 var controlLines = control.stack.split('\n'); 1880 var s = sampleLines.length - 1; 1881 var c = controlLines.length - 1; 1882 1883 while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) { 1884 // We expect at least one stack frame to be shared. 1885 // Typically this will be the root most one. However, stack frames may be 1886 // cut off due to maximum stack limits. In this case, one maybe cut off 1887 // earlier than the other. We assume that the sample is longer or the same 1888 // and there for cut off earlier. So we should find the root most frame in 1889 // the sample somewhere in the control. 1890 c--; 1891 } 1892 1893 for (; s >= 1 && c >= 0; s--, c--) { 1894 // Next we find the first one that isn't the same which should be the 1895 // frame that called our sample function and the control. 1896 if (sampleLines[s] !== controlLines[c]) { 1897 // In V8, the first line is describing the message but other VMs don't. 1898 // If we're about to return the first line, and the control is also on the same 1899 // line, that's a pretty good indicator that our sample threw at same line as 1900 // the control. I.e. before we entered the sample frame. So we ignore this result. 1901 // This can happen if you passed a class to function component, or non-function. 1902 if (s !== 1 || c !== 1) { 1903 do { 1904 s--; 1905 c--; // We may still have similar intermediate frames from the construct call. 1906 // The next one that isn't the same should be our match though. 1907 1908 if (c < 0 || sampleLines[s] !== controlLines[c]) { 1909 // V8 adds a "new" prefix for native classes. Let's remove it to make it prettier. 1910 var _frame = '\n' + sampleLines[s].replace(' at new ', ' at '); // If our component frame is labeled "<anonymous>" 1911 // but we have a user-provided "displayName" 1912 // splice it in to make the stack more readable. 1913 1914 1915 if (fn.displayName && _frame.includes('<anonymous>')) { 1916 _frame = _frame.replace('<anonymous>', fn.displayName); 1917 } 1918 1919 { 1920 if (typeof fn === 'function') { 1921 componentFrameCache.set(fn, _frame); 1922 } 1923 } // Return the line we found. 1924 1925 1926 return _frame; 1927 } 1928 } while (s >= 1 && c >= 0); 1929 } 1930 1931 break; 1932 } 1933 } 1934 } 1935 } finally { 1936 reentry = false; 1937 1938 { 1939 ReactCurrentDispatcher$1.current = previousDispatcher; 1940 reenableLogs(); 1941 } 1942 1943 Error.prepareStackTrace = previousPrepareStackTrace; 1944 } // Fallback to just using the name if we couldn't make it throw. 1945 1946 1947 var name = fn ? fn.displayName || fn.name : ''; 1948 var syntheticFrame = name ? describeBuiltInComponentFrame(name) : ''; 1949 1950 { 1951 if (typeof fn === 'function') { 1952 componentFrameCache.set(fn, syntheticFrame); 1953 } 1954 } 1955 1956 return syntheticFrame; 1957} 1958function describeFunctionComponentFrame(fn, source, ownerFn) { 1959 { 1960 return describeNativeComponentFrame(fn, false); 1961 } 1962} 1963 1964function shouldConstruct(Component) { 1965 var prototype = Component.prototype; 1966 return !!(prototype && prototype.isReactComponent); 1967} 1968 1969function describeUnknownElementTypeFrameInDEV(type, source, ownerFn) { 1970 1971 if (type == null) { 1972 return ''; 1973 } 1974 1975 if (typeof type === 'function') { 1976 { 1977 return describeNativeComponentFrame(type, shouldConstruct(type)); 1978 } 1979 } 1980 1981 if (typeof type === 'string') { 1982 return describeBuiltInComponentFrame(type); 1983 } 1984 1985 switch (type) { 1986 case REACT_SUSPENSE_TYPE: 1987 return describeBuiltInComponentFrame('Suspense'); 1988 1989 case REACT_SUSPENSE_LIST_TYPE: 1990 return describeBuiltInComponentFrame('SuspenseList'); 1991 } 1992 1993 if (typeof type === 'object') { 1994 switch (type.$$typeof) { 1995 case REACT_FORWARD_REF_TYPE: 1996 return describeFunctionComponentFrame(type.render); 1997 1998 case REACT_MEMO_TYPE: 1999 // Memo may contain any component type so we recursively resolve it. 2000 return describeUnknownElementTypeFrameInDEV(type.type, source, ownerFn); 2001 2002 case REACT_LAZY_TYPE: 2003 { 2004 var lazyComponent = type; 2005 var payload = lazyComponent._payload; 2006 var init = lazyComponent._init; 2007 2008 try { 2009 // Lazy may contain any component type so we recursively resolve it. 2010 return describeUnknownElementTypeFrameInDEV(init(payload), source, ownerFn); 2011 } catch (x) {} 2012 } 2013 } 2014 } 2015 2016 return ''; 2017} 2018 2019var loggedTypeFailures = {}; 2020var ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame; 2021 2022function setCurrentlyValidatingElement(element) { 2023 { 2024 if (element) { 2025 var owner = element._owner; 2026 var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null); 2027 ReactDebugCurrentFrame$1.setExtraStackFrame(stack); 2028 } else { 2029 ReactDebugCurrentFrame$1.setExtraStackFrame(null); 2030 } 2031 } 2032} 2033 2034function checkPropTypes(typeSpecs, values, location, componentName, element) { 2035 { 2036 // $FlowFixMe This is okay but Flow doesn't know it. 2037 var has = Function.call.bind(hasOwnProperty); 2038 2039 for (var typeSpecName in typeSpecs) { 2040 if (has(typeSpecs, typeSpecName)) { 2041 var error$1 = void 0; // Prop type validation may throw. In case they do, we don't want to 2042 // fail the render phase where it didn't fail before. So we log it. 2043 // After these have been cleaned up, we'll let them throw. 2044 2045 try { 2046 // This is intentionally an invariant that gets caught. It's the same 2047 // behavior as without this statement except with a better message. 2048 if (typeof typeSpecs[typeSpecName] !== 'function') { 2049 // eslint-disable-next-line react-internal/prod-error-codes 2050 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] + '`.' + 'This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.'); 2051 err.name = 'Invariant Violation'; 2052 throw err; 2053 } 2054 2055 error$1 = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED'); 2056 } catch (ex) { 2057 error$1 = ex; 2058 } 2059 2060 if (error$1 && !(error$1 instanceof Error)) { 2061 setCurrentlyValidatingElement(element); 2062 2063 error('%s: type specification of %s' + ' `%s` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a %s. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).', componentName || 'React class', location, typeSpecName, typeof error$1); 2064 2065 setCurrentlyValidatingElement(null); 2066 } 2067 2068 if (error$1 instanceof Error && !(error$1.message in loggedTypeFailures)) { 2069 // Only monitor this failure once because there tends to be a lot of the 2070 // same error. 2071 loggedTypeFailures[error$1.message] = true; 2072 setCurrentlyValidatingElement(element); 2073 2074 error('Failed %s type: %s', location, error$1.message); 2075 2076 setCurrentlyValidatingElement(null); 2077 } 2078 } 2079 } 2080 } 2081} 2082 2083function setCurrentlyValidatingElement$1(element) { 2084 { 2085 if (element) { 2086 var owner = element._owner; 2087 var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null); 2088 setExtraStackFrame(stack); 2089 } else { 2090 setExtraStackFrame(null); 2091 } 2092 } 2093} 2094 2095var propTypesMisspellWarningShown; 2096 2097{ 2098 propTypesMisspellWarningShown = false; 2099} 2100 2101function getDeclarationErrorAddendum() { 2102 if (ReactCurrentOwner.current) { 2103 var name = getComponentNameFromType(ReactCurrentOwner.current.type); 2104 2105 if (name) { 2106 return '\n\nCheck the render method of `' + name + '`.'; 2107 } 2108 } 2109 2110 return ''; 2111} 2112 2113function getSourceInfoErrorAddendum(source) { 2114 if (source !== undefined) { 2115 var fileName = source.fileName.replace(/^.*[\\\/]/, ''); 2116 var lineNumber = source.lineNumber; 2117 return '\n\nCheck your code at ' + fileName + ':' + lineNumber + '.'; 2118 } 2119 2120 return ''; 2121} 2122 2123function getSourceInfoErrorAddendumForProps(elementProps) { 2124 if (elementProps !== null && elementProps !== undefined) { 2125 return getSourceInfoErrorAddendum(elementProps.__source); 2126 } 2127 2128 return ''; 2129} 2130/** 2131 * Warn if there's no key explicitly set on dynamic arrays of children or 2132 * object keys are not valid. This allows us to keep track of children between 2133 * updates. 2134 */ 2135 2136 2137var ownerHasKeyUseWarning = {}; 2138 2139function getCurrentComponentErrorInfo(parentType) { 2140 var info = getDeclarationErrorAddendum(); 2141 2142 if (!info) { 2143 var parentName = typeof parentType === 'string' ? parentType : parentType.displayName || parentType.name; 2144 2145 if (parentName) { 2146 info = "\n\nCheck the top-level render call using <" + parentName + ">."; 2147 } 2148 } 2149 2150 return info; 2151} 2152/** 2153 * Warn if the element doesn't have an explicit key assigned to it. 2154 * This element is in an array. The array could grow and shrink or be 2155 * reordered. All children that haven't already been validated are required to 2156 * have a "key" property assigned to it. Error statuses are cached so a warning 2157 * will only be shown once. 2158 * 2159 * @internal 2160 * @param {ReactElement} element Element that requires a key. 2161 * @param {*} parentType element's parent's type. 2162 */ 2163 2164 2165function validateExplicitKey(element, parentType) { 2166 if (!element._store || element._store.validated || element.key != null) { 2167 return; 2168 } 2169 2170 element._store.validated = true; 2171 var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType); 2172 2173 if (ownerHasKeyUseWarning[currentComponentErrorInfo]) { 2174 return; 2175 } 2176 2177 ownerHasKeyUseWarning[currentComponentErrorInfo] = true; // Usually the current owner is the offender, but if it accepts children as a 2178 // property, it may be the creator of the child that's responsible for 2179 // assigning it a key. 2180 2181 var childOwner = ''; 2182 2183 if (element && element._owner && element._owner !== ReactCurrentOwner.current) { 2184 // Give the component that originally created this child. 2185 childOwner = " It was passed a child from " + getComponentNameFromType(element._owner.type) + "."; 2186 } 2187 2188 { 2189 setCurrentlyValidatingElement$1(element); 2190 2191 error('Each child in a list should have a unique "key" prop.' + '%s%s See https://reactjs.org/link/warning-keys for more information.', currentComponentErrorInfo, childOwner); 2192 2193 setCurrentlyValidatingElement$1(null); 2194 } 2195} 2196/** 2197 * Ensure that every element either is passed in a static location, in an 2198 * array with an explicit keys property defined, or in an object literal 2199 * with valid key property. 2200 * 2201 * @internal 2202 * @param {ReactNode} node Statically passed child of any type. 2203 * @param {*} parentType node's parent's type. 2204 */ 2205 2206 2207function validateChildKeys(node, parentType) { 2208 if (typeof node !== 'object') { 2209 return; 2210 } 2211 2212 if (isArray(node)) { 2213 for (var i = 0; i < node.length; i++) { 2214 var child = node[i]; 2215 2216 if (isValidElement(child)) { 2217 validateExplicitKey(child, parentType); 2218 } 2219 } 2220 } else if (isValidElement(node)) { 2221 // This element was passed in a valid location. 2222 if (node._store) { 2223 node._store.validated = true; 2224 } 2225 } else if (node) { 2226 var iteratorFn = getIteratorFn(node); 2227 2228 if (typeof iteratorFn === 'function') { 2229 // Entry iterators used to provide implicit keys, 2230 // but now we print a separate warning for them later. 2231 if (iteratorFn !== node.entries) { 2232 var iterator = iteratorFn.call(node); 2233 var step; 2234 2235 while (!(step = iterator.next()).done) { 2236 if (isValidElement(step.value)) { 2237 validateExplicitKey(step.value, parentType); 2238 } 2239 } 2240 } 2241 } 2242 } 2243} 2244/** 2245 * Given an element, validate that its props follow the propTypes definition, 2246 * provided by the type. 2247 * 2248 * @param {ReactElement} element 2249 */ 2250 2251 2252function validatePropTypes(element) { 2253 { 2254 var type = element.type; 2255 2256 if (type === null || type === undefined || typeof type === 'string') { 2257 return; 2258 } 2259 2260 var propTypes; 2261 2262 if (typeof type === 'function') { 2263 propTypes = type.propTypes; 2264 } else if (typeof type === 'object' && (type.$$typeof === REACT_FORWARD_REF_TYPE || // Note: Memo only checks outer props here. 2265 // Inner props are checked in the reconciler. 2266 type.$$typeof === REACT_MEMO_TYPE)) { 2267 propTypes = type.propTypes; 2268 } else { 2269 return; 2270 } 2271 2272 if (propTypes) { 2273 // Intentionally inside to avoid triggering lazy initializers: 2274 var name = getComponentNameFromType(type); 2275 checkPropTypes(propTypes, element.props, 'prop', name, element); 2276 } else if (type.PropTypes !== undefined && !propTypesMisspellWarningShown) { 2277 propTypesMisspellWarningShown = true; // Intentionally inside to avoid triggering lazy initializers: 2278 2279 var _name = getComponentNameFromType(type); 2280 2281 error('Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?', _name || 'Unknown'); 2282 } 2283 2284 if (typeof type.getDefaultProps === 'function' && !type.getDefaultProps.isReactClassApproved) { 2285 error('getDefaultProps is only used on classic React.createClass ' + 'definitions. Use a static property named `defaultProps` instead.'); 2286 } 2287 } 2288} 2289/** 2290 * Given a fragment, validate that it can only be provided with fragment props 2291 * @param {ReactElement} fragment 2292 */ 2293 2294 2295function validateFragmentProps(fragment) { 2296 { 2297 var keys = Object.keys(fragment.props); 2298 2299 for (var i = 0; i < keys.length; i++) { 2300 var key = keys[i]; 2301 2302 if (key !== 'children' && key !== 'key') { 2303 setCurrentlyValidatingElement$1(fragment); 2304 2305 error('Invalid prop `%s` supplied to `React.Fragment`. ' + 'React.Fragment can only have `key` and `children` props.', key); 2306 2307 setCurrentlyValidatingElement$1(null); 2308 break; 2309 } 2310 } 2311 2312 if (fragment.ref !== null) { 2313 setCurrentlyValidatingElement$1(fragment); 2314 2315 error('Invalid attribute `ref` supplied to `React.Fragment`.'); 2316 2317 setCurrentlyValidatingElement$1(null); 2318 } 2319 } 2320} 2321function createElementWithValidation(type, props, children) { 2322 var validType = isValidElementType(type); // We warn in this case but don't throw. We expect the element creation to 2323 // succeed and there will likely be errors in render. 2324 2325 if (!validType) { 2326 var info = ''; 2327 2328 if (type === undefined || typeof type === 'object' && type !== null && Object.keys(type).length === 0) { 2329 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."; 2330 } 2331 2332 var sourceInfo = getSourceInfoErrorAddendumForProps(props); 2333 2334 if (sourceInfo) { 2335 info += sourceInfo; 2336 } else { 2337 info += getDeclarationErrorAddendum(); 2338 } 2339 2340 var typeString; 2341 2342 if (type === null) { 2343 typeString = 'null'; 2344 } else if (isArray(type)) { 2345 typeString = 'array'; 2346 } else if (type !== undefined && type.$$typeof === REACT_ELEMENT_TYPE) { 2347 typeString = "<" + (getComponentNameFromType(type.type) || 'Unknown') + " />"; 2348 info = ' Did you accidentally export a JSX literal instead of a component?'; 2349 } else { 2350 typeString = typeof type; 2351 } 2352 2353 { 2354 error('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); 2355 } 2356 } 2357 2358 var element = createElement.apply(this, arguments); // The result can be nullish if a mock or a custom function is used. 2359 // TODO: Drop this when these are no longer allowed as the type argument. 2360 2361 if (element == null) { 2362 return element; 2363 } // Skip key warning if the type isn't valid since our key validation logic 2364 // doesn't expect a non-string/function type and can throw confusing errors. 2365 // We don't want exception behavior to differ between dev and prod. 2366 // (Rendering will throw with a helpful message and as soon as the type is 2367 // fixed, the key warnings will appear.) 2368 2369 2370 if (validType) { 2371 for (var i = 2; i < arguments.length; i++) { 2372 validateChildKeys(arguments[i], type); 2373 } 2374 } 2375 2376 if (type === REACT_FRAGMENT_TYPE) { 2377 validateFragmentProps(element); 2378 } else { 2379 validatePropTypes(element); 2380 } 2381 2382 return element; 2383} 2384var didWarnAboutDeprecatedCreateFactory = false; 2385function createFactoryWithValidation(type) { 2386 var validatedFactory = createElementWithValidation.bind(null, type); 2387 validatedFactory.type = type; 2388 2389 { 2390 if (!didWarnAboutDeprecatedCreateFactory) { 2391 didWarnAboutDeprecatedCreateFactory = true; 2392 2393 warn('React.createFactory() is deprecated and will be removed in ' + 'a future major release. Consider using JSX ' + 'or use React.createElement() directly instead.'); 2394 } // Legacy hook: remove it 2395 2396 2397 Object.defineProperty(validatedFactory, 'type', { 2398 enumerable: false, 2399 get: function () { 2400 warn('Factory.type is deprecated. Access the class directly ' + 'before passing it to createFactory.'); 2401 2402 Object.defineProperty(this, 'type', { 2403 value: type 2404 }); 2405 return type; 2406 } 2407 }); 2408 } 2409 2410 return validatedFactory; 2411} 2412function cloneElementWithValidation(element, props, children) { 2413 var newElement = cloneElement.apply(this, arguments); 2414 2415 for (var i = 2; i < arguments.length; i++) { 2416 validateChildKeys(arguments[i], newElement.type); 2417 } 2418 2419 validatePropTypes(newElement); 2420 return newElement; 2421} 2422 2423function startTransition(scope, options) { 2424 var prevTransition = ReactCurrentBatchConfig.transition; 2425 ReactCurrentBatchConfig.transition = {}; 2426 var currentTransition = ReactCurrentBatchConfig.transition; 2427 2428 { 2429 ReactCurrentBatchConfig.transition._updatedFibers = new Set(); 2430 } 2431 2432 try { 2433 scope(); 2434 } finally { 2435 ReactCurrentBatchConfig.transition = prevTransition; 2436 2437 { 2438 if (prevTransition === null && currentTransition._updatedFibers) { 2439 var updatedFibersCount = currentTransition._updatedFibers.size; 2440 2441 if (updatedFibersCount > 10) { 2442 warn('Detected a large number of updates inside startTransition. ' + 'If this is due to a subscription please re-write it to use React provided hooks. ' + 'Otherwise concurrent mode guarantees are off the table.'); 2443 } 2444 2445 currentTransition._updatedFibers.clear(); 2446 } 2447 } 2448 } 2449} 2450 2451var didWarnAboutMessageChannel = false; 2452var enqueueTaskImpl = null; 2453function enqueueTask(task) { 2454 if (enqueueTaskImpl === null) { 2455 try { 2456 // read require off the module object to get around the bundlers. 2457 // we don't want them to detect a require and bundle a Node polyfill. 2458 var requireString = ('require' + Math.random()).slice(0, 7); 2459 var nodeRequire = module && module[requireString]; // assuming we're in node, let's try to get node's 2460 // version of setImmediate, bypassing fake timers if any. 2461 2462 enqueueTaskImpl = nodeRequire.call(module, 'timers').setImmediate; 2463 } catch (_err) { 2464 // we're in a browser 2465 // we can't use regular timers because they may still be faked 2466 // so we try MessageChannel+postMessage instead 2467 enqueueTaskImpl = function (callback) { 2468 { 2469 if (didWarnAboutMessageChannel === false) { 2470 didWarnAboutMessageChannel = true; 2471 2472 if (typeof MessageChannel === 'undefined') { 2473 error('This browser does not have a MessageChannel implementation, ' + 'so enqueuing tasks via await act(async () => ...) will fail. ' + 'Please file an issue at https://github.com/facebook/react/issues ' + 'if you encounter this warning.'); 2474 } 2475 } 2476 } 2477 2478 var channel = new MessageChannel(); 2479 channel.port1.onmessage = callback; 2480 channel.port2.postMessage(undefined); 2481 }; 2482 } 2483 } 2484 2485 return enqueueTaskImpl(task); 2486} 2487 2488var actScopeDepth = 0; 2489var didWarnNoAwaitAct = false; 2490function act(callback) { 2491 { 2492 // `act` calls can be nested, so we track the depth. This represents the 2493 // number of `act` scopes on the stack. 2494 var prevActScopeDepth = actScopeDepth; 2495 actScopeDepth++; 2496 2497 if (ReactCurrentActQueue.current === null) { 2498 // This is the outermost `act` scope. Initialize the queue. The reconciler 2499 // will detect the queue and use it instead of Scheduler. 2500 ReactCurrentActQueue.current = []; 2501 } 2502 2503 var prevIsBatchingLegacy = ReactCurrentActQueue.isBatchingLegacy; 2504 var result; 2505 2506 try { 2507 // Used to reproduce behavior of `batchedUpdates` in legacy mode. Only 2508 // set to `true` while the given callback is executed, not for updates 2509 // triggered during an async event, because this is how the legacy 2510 // implementation of `act` behaved. 2511 ReactCurrentActQueue.isBatchingLegacy = true; 2512 result = callback(); // Replicate behavior of original `act` implementation in legacy mode, 2513 // which flushed updates immediately after the scope function exits, even 2514 // if it's an async function. 2515 2516 if (!prevIsBatchingLegacy && ReactCurrentActQueue.didScheduleLegacyUpdate) { 2517 var queue = ReactCurrentActQueue.current; 2518 2519 if (queue !== null) { 2520 ReactCurrentActQueue.didScheduleLegacyUpdate = false; 2521 flushActQueue(queue); 2522 } 2523 } 2524 } catch (error) { 2525 popActScope(prevActScopeDepth); 2526 throw error; 2527 } finally { 2528 ReactCurrentActQueue.isBatchingLegacy = prevIsBatchingLegacy; 2529 } 2530 2531 if (result !== null && typeof result === 'object' && typeof result.then === 'function') { 2532 var thenableResult = result; // The callback is an async function (i.e. returned a promise). Wait 2533 // for it to resolve before exiting the current scope. 2534 2535 var wasAwaited = false; 2536 var thenable = { 2537 then: function (resolve, reject) { 2538 wasAwaited = true; 2539 thenableResult.then(function (returnValue) { 2540 popActScope(prevActScopeDepth); 2541 2542 if (actScopeDepth === 0) { 2543 // We've exited the outermost act scope. Recursively flush the 2544 // queue until there's no remaining work. 2545 recursivelyFlushAsyncActWork(returnValue, resolve, reject); 2546 } else { 2547 resolve(returnValue); 2548 } 2549 }, function (error) { 2550 // The callback threw an error. 2551 popActScope(prevActScopeDepth); 2552 reject(error); 2553 }); 2554 } 2555 }; 2556 2557 { 2558 if (!didWarnNoAwaitAct && typeof Promise !== 'undefined') { 2559 // eslint-disable-next-line no-undef 2560 Promise.resolve().then(function () {}).then(function () { 2561 if (!wasAwaited) { 2562 didWarnNoAwaitAct = true; 2563 2564 error('You called act(async () => ...) without await. ' + 'This could lead to unexpected testing behaviour, ' + 'interleaving multiple act calls and mixing their ' + 'scopes. ' + 'You should - await act(async () => ...);'); 2565 } 2566 }); 2567 } 2568 } 2569 2570 return thenable; 2571 } else { 2572 var returnValue = result; // The callback is not an async function. Exit the current scope 2573 // immediately, without awaiting. 2574 2575 popActScope(prevActScopeDepth); 2576 2577 if (actScopeDepth === 0) { 2578 // Exiting the outermost act scope. Flush the queue. 2579 var _queue = ReactCurrentActQueue.current; 2580 2581 if (_queue !== null) { 2582 flushActQueue(_queue); 2583 ReactCurrentActQueue.current = null; 2584 } // Return a thenable. If the user awaits it, we'll flush again in 2585 // case additional work was scheduled by a microtask. 2586 2587 2588 var _thenable = { 2589 then: function (resolve, reject) { 2590 // Confirm we haven't re-entered another `act` scope, in case 2591 // the user does something weird like await the thenable 2592 // multiple times. 2593 if (ReactCurrentActQueue.current === null) { 2594 // Recursively flush the queue until there's no remaining work. 2595 ReactCurrentActQueue.current = []; 2596 recursivelyFlushAsyncActWork(returnValue, resolve, reject); 2597 } else { 2598 resolve(returnValue); 2599 } 2600 } 2601 }; 2602 return _thenable; 2603 } else { 2604 // Since we're inside a nested `act` scope, the returned thenable 2605 // immediately resolves. The outer scope will flush the queue. 2606 var _thenable2 = { 2607 then: function (resolve, reject) { 2608 resolve(returnValue); 2609 } 2610 }; 2611 return _thenable2; 2612 } 2613 } 2614 } 2615} 2616 2617function popActScope(prevActScopeDepth) { 2618 { 2619 if (prevActScopeDepth !== actScopeDepth - 1) { 2620 error('You seem to have overlapping act() calls, this is not supported. ' + 'Be sure to await previous act() calls before making a new one. '); 2621 } 2622 2623 actScopeDepth = prevActScopeDepth; 2624 } 2625} 2626 2627function recursivelyFlushAsyncActWork(returnValue, resolve, reject) { 2628 { 2629 var queue = ReactCurrentActQueue.current; 2630 2631 if (queue !== null) { 2632 try { 2633 flushActQueue(queue); 2634 enqueueTask(function () { 2635 if (queue.length === 0) { 2636 // No additional work was scheduled. Finish. 2637 ReactCurrentActQueue.current = null; 2638 resolve(returnValue); 2639 } else { 2640 // Keep flushing work until there's none left. 2641 recursivelyFlushAsyncActWork(returnValue, resolve, reject); 2642 } 2643 }); 2644 } catch (error) { 2645 reject(error); 2646 } 2647 } else { 2648 resolve(returnValue); 2649 } 2650 } 2651} 2652 2653var isFlushing = false; 2654 2655function flushActQueue(queue) { 2656 { 2657 if (!isFlushing) { 2658 // Prevent re-entrance. 2659 isFlushing = true; 2660 var i = 0; 2661 2662 try { 2663 for (; i < queue.length; i++) { 2664 var callback = queue[i]; 2665 2666 do { 2667 callback = callback(true); 2668 } while (callback !== null); 2669 } 2670 2671 queue.length = 0; 2672 } catch (error) { 2673 // If something throws, leave the remaining callbacks on the queue. 2674 queue = queue.slice(i + 1); 2675 throw error; 2676 } finally { 2677 isFlushing = false; 2678 } 2679 } 2680 } 2681} 2682 2683var createElement$1 = createElementWithValidation ; 2684var cloneElement$1 = cloneElementWithValidation ; 2685var createFactory = createFactoryWithValidation ; 2686var Children = { 2687 map: mapChildren, 2688 forEach: forEachChildren, 2689 count: countChildren, 2690 toArray: toArray, 2691 only: onlyChild 2692}; 2693 2694exports.Children = Children; 2695exports.Component = Component; 2696exports.Fragment = REACT_FRAGMENT_TYPE; 2697exports.Profiler = REACT_PROFILER_TYPE; 2698exports.PureComponent = PureComponent; 2699exports.StrictMode = REACT_STRICT_MODE_TYPE; 2700exports.Suspense = REACT_SUSPENSE_TYPE; 2701exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = ReactSharedInternals; 2702exports.cloneElement = cloneElement$1; 2703exports.createContext = createContext; 2704exports.createElement = createElement$1; 2705exports.createFactory = createFactory; 2706exports.createRef = createRef; 2707exports.forwardRef = forwardRef; 2708exports.isValidElement = isValidElement; 2709exports.lazy = lazy; 2710exports.memo = memo; 2711exports.startTransition = startTransition; 2712exports.unstable_act = act; 2713exports.useCallback = useCallback; 2714exports.useContext = useContext; 2715exports.useDebugValue = useDebugValue; 2716exports.useDeferredValue = useDeferredValue; 2717exports.useEffect = useEffect; 2718exports.useId = useId; 2719exports.useImperativeHandle = useImperativeHandle; 2720exports.useInsertionEffect = useInsertionEffect; 2721exports.useLayoutEffect = useLayoutEffect; 2722exports.useMemo = useMemo; 2723exports.useReducer = useReducer; 2724exports.useRef = useRef; 2725exports.useState = useState; 2726exports.useSyncExternalStore = useSyncExternalStore; 2727exports.useTransition = useTransition; 2728exports.version = ReactVersion; 2729 /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */ 2730if ( 2731 typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' && 2732 typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop === 2733 'function' 2734) { 2735 __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error()); 2736} 2737 2738 })(); 2739}