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