=0;a--){var n=r[a];if(t(this._tokens[n],n))return n}return-1},t.findMatching=function(e,t,r){void 0===r&&(r=0);var a=this._nodesToTokenIndexes.get(e);if(a){var n=0,s=r;if(s>1){var o=this._nodesOccurrencesCountCache.get(e);o&&o.test===t&&o.count0&&this._nodesOccurrencesCountCache.set(e,{test:t,count:s,i:n}),i;r--}}}return null},t.matchesOriginal=function(e,t){return e.end-e.start===t.length&&(null!=e.value?e.value===t:this._source.startsWith(t,e.start))},t.startMatches=function(e,t){var r=this._nodesToTokenIndexes.get(e);if(!r)return!1;var a=this._tokens[r[0]];return a.start===e.start&&this.matchesOriginal(a,t)},t.endMatches=function(e,t){var r=this._nodesToTokenIndexes.get(e);if(!r)return!1;var a=this._tokens[r[r.length-1]];return a.end===e.end&&this.matchesOriginal(a,t)},t._getTokensIndexesOfNode=function(e){if(null==e.start||null==e.end)return[];var t=this._findTokensOfNode(e,0,this._tokens.length-1),r=t.first,a=t.last,n=r,s=WT(e);"ExportNamedDeclaration"!==e.type&&"ExportDefaultDeclaration"!==e.type||!e.declaration||"ClassDeclaration"!==e.declaration.type||s.next();for(var o,d=[],c=i(s);!(o=c()).done;){var l=o.value;if(null!=l&&(null!=l.start&&null!=l.end)){for(var u=this._findTokensOfNode(l,n,a),p=u.first,f=n;f>1;if(ethis._tokens[a].start))return a;t=a+1}}return t},t._findLastTokenOfNode=function(e,t,r){for(;t<=r;){var a=r+t>>1;if(ethis._tokens[a].end))return a;t=a+1}}return r},o(e)}();function WT(e){var t,r,a,n,s,o;return p().wrap((function(d){for(;;)switch(d.prev=d.next){case 0:if("TemplateLiteral"!==e.type){d.next=13;break}return d.next=3,e.quasis[0];case 3:t=1;case 4:if(!(t2?wP(p):"\\x"+("00"+p).slice(-2)})),"`"==d&&(i=i.replace(/\$\{/g,"\\${")),t.isScriptContext&&(i=i.replace(/<\/(script|style)/gi,"<\\/$1").replace(/ previous live fiber
- // --sibling--> deleted fiber
- //
- // We can't disconnect `alternate` on nodes that haven't been deleted
- // yet, but we can disconnect the `sibling` and `child` pointers.
- var previousFiber = fiber.alternate;
-
- if (previousFiber !== null) {
- var detachedChild = previousFiber.child;
-
- if (detachedChild !== null) {
- previousFiber.child = null;
-
- do {
- var detachedSibling = detachedChild.sibling;
- detachedChild.sibling = null;
- detachedChild = detachedSibling;
- } while (detachedChild !== null);
- }
- }
- }
-
- nextEffect = fiber;
- }
- }
-
- if ((fiber.subtreeFlags & PassiveMask) !== NoFlags && child !== null) {
- child.return = fiber;
- nextEffect = child;
- } else {
- commitPassiveUnmountEffects_complete();
- }
- }
- }
-
- function commitPassiveUnmountEffects_complete() {
- while (nextEffect !== null) {
- var fiber = nextEffect;
-
- if ((fiber.flags & Passive) !== NoFlags) {
- setCurrentFiber(fiber);
- commitPassiveUnmountOnFiber(fiber);
- resetCurrentFiber();
- }
-
- var sibling = fiber.sibling;
-
- if (sibling !== null) {
- sibling.return = fiber.return;
- nextEffect = sibling;
- return;
- }
-
- nextEffect = fiber.return;
- }
- }
-
- function commitPassiveUnmountOnFiber(finishedWork) {
- switch (finishedWork.tag) {
- case FunctionComponent:
- case ForwardRef:
- case SimpleMemoComponent:
- {
- if ( finishedWork.mode & ProfileMode) {
- startPassiveEffectTimer();
- commitHookEffectListUnmount(Passive$1 | HasEffect, finishedWork, finishedWork.return);
- recordPassiveEffectDuration(finishedWork);
- } else {
- commitHookEffectListUnmount(Passive$1 | HasEffect, finishedWork, finishedWork.return);
- }
-
- break;
- }
- }
- }
-
- function commitPassiveUnmountEffectsInsideOfDeletedTree_begin(deletedSubtreeRoot, nearestMountedAncestor) {
- while (nextEffect !== null) {
- var fiber = nextEffect; // Deletion effects fire in parent -> child order
- // TODO: Check if fiber has a PassiveStatic flag
-
- setCurrentFiber(fiber);
- commitPassiveUnmountInsideDeletedTreeOnFiber(fiber, nearestMountedAncestor);
- resetCurrentFiber();
- var child = fiber.child; // TODO: Only traverse subtree if it has a PassiveStatic flag. (But, if we
- // do this, still need to handle `deletedTreeCleanUpLevel` correctly.)
-
- if (child !== null) {
- child.return = fiber;
- nextEffect = child;
- } else {
- commitPassiveUnmountEffectsInsideOfDeletedTree_complete(deletedSubtreeRoot);
- }
- }
- }
-
- function commitPassiveUnmountEffectsInsideOfDeletedTree_complete(deletedSubtreeRoot) {
- while (nextEffect !== null) {
- var fiber = nextEffect;
- var sibling = fiber.sibling;
- var returnFiber = fiber.return;
-
- {
- // Recursively traverse the entire deleted tree and clean up fiber fields.
- // This is more aggressive than ideal, and the long term goal is to only
- // have to detach the deleted tree at the root.
- detachFiberAfterEffects(fiber);
-
- if (fiber === deletedSubtreeRoot) {
- nextEffect = null;
- return;
- }
- }
-
- if (sibling !== null) {
- sibling.return = returnFiber;
- nextEffect = sibling;
- return;
- }
-
- nextEffect = returnFiber;
- }
- }
-
- function commitPassiveUnmountInsideDeletedTreeOnFiber(current, nearestMountedAncestor) {
- switch (current.tag) {
- case FunctionComponent:
- case ForwardRef:
- case SimpleMemoComponent:
- {
- if ( current.mode & ProfileMode) {
- startPassiveEffectTimer();
- commitHookEffectListUnmount(Passive$1, current, nearestMountedAncestor);
- recordPassiveEffectDuration(current);
- } else {
- commitHookEffectListUnmount(Passive$1, current, nearestMountedAncestor);
- }
-
- break;
- }
- }
- } // TODO: Reuse reappearLayoutEffects traversal here?
-
-
- function invokeLayoutEffectMountInDEV(fiber) {
- {
- // We don't need to re-check StrictEffectsMode here.
- // This function is only called if that check has already passed.
- switch (fiber.tag) {
- case FunctionComponent:
- case ForwardRef:
- case SimpleMemoComponent:
- {
- try {
- commitHookEffectListMount(Layout | HasEffect, fiber);
- } catch (error) {
- captureCommitPhaseError(fiber, fiber.return, error);
- }
-
- break;
- }
-
- case ClassComponent:
- {
- var instance = fiber.stateNode;
-
- try {
- instance.componentDidMount();
- } catch (error) {
- captureCommitPhaseError(fiber, fiber.return, error);
- }
-
- break;
- }
- }
- }
- }
-
- function invokePassiveEffectMountInDEV(fiber) {
- {
- // We don't need to re-check StrictEffectsMode here.
- // This function is only called if that check has already passed.
- switch (fiber.tag) {
- case FunctionComponent:
- case ForwardRef:
- case SimpleMemoComponent:
- {
- try {
- commitHookEffectListMount(Passive$1 | HasEffect, fiber);
- } catch (error) {
- captureCommitPhaseError(fiber, fiber.return, error);
- }
-
- break;
- }
- }
- }
- }
-
- function invokeLayoutEffectUnmountInDEV(fiber) {
- {
- // We don't need to re-check StrictEffectsMode here.
- // This function is only called if that check has already passed.
- switch (fiber.tag) {
- case FunctionComponent:
- case ForwardRef:
- case SimpleMemoComponent:
- {
- try {
- commitHookEffectListUnmount(Layout | HasEffect, fiber, fiber.return);
- } catch (error) {
- captureCommitPhaseError(fiber, fiber.return, error);
- }
-
- break;
- }
-
- case ClassComponent:
- {
- var instance = fiber.stateNode;
-
- if (typeof instance.componentWillUnmount === 'function') {
- safelyCallComponentWillUnmount(fiber, fiber.return, instance);
- }
-
- break;
- }
- }
- }
- }
-
- function invokePassiveEffectUnmountInDEV(fiber) {
- {
- // We don't need to re-check StrictEffectsMode here.
- // This function is only called if that check has already passed.
- switch (fiber.tag) {
- case FunctionComponent:
- case ForwardRef:
- case SimpleMemoComponent:
- {
- try {
- commitHookEffectListUnmount(Passive$1 | HasEffect, fiber, fiber.return);
- } catch (error) {
- captureCommitPhaseError(fiber, fiber.return, error);
- }
- }
- }
- }
- }
-
- var COMPONENT_TYPE = 0;
- var HAS_PSEUDO_CLASS_TYPE = 1;
- var ROLE_TYPE = 2;
- var TEST_NAME_TYPE = 3;
- var TEXT_TYPE = 4;
-
- if (typeof Symbol === 'function' && Symbol.for) {
- var symbolFor = Symbol.for;
- COMPONENT_TYPE = symbolFor('selector.component');
- HAS_PSEUDO_CLASS_TYPE = symbolFor('selector.has_pseudo_class');
- ROLE_TYPE = symbolFor('selector.role');
- TEST_NAME_TYPE = symbolFor('selector.test_id');
- TEXT_TYPE = symbolFor('selector.text');
- }
- var commitHooks = [];
- function onCommitRoot$1() {
- {
- commitHooks.forEach(function (commitHook) {
- return commitHook();
- });
- }
- }
-
- var ReactCurrentActQueue = ReactSharedInternals.ReactCurrentActQueue;
- function isLegacyActEnvironment(fiber) {
- {
- // Legacy mode. We preserve the behavior of React 17's act. It assumes an
- // act environment whenever `jest` is defined, but you can still turn off
- // spurious warnings by setting IS_REACT_ACT_ENVIRONMENT explicitly
- // to false.
- var isReactActEnvironmentGlobal = // $FlowExpectedError – Flow doesn't know about IS_REACT_ACT_ENVIRONMENT global
- typeof IS_REACT_ACT_ENVIRONMENT !== 'undefined' ? IS_REACT_ACT_ENVIRONMENT : undefined; // $FlowExpectedError - Flow doesn't know about jest
-
- var jestIsDefined = typeof jest !== 'undefined';
- return jestIsDefined && isReactActEnvironmentGlobal !== false;
- }
- }
- function isConcurrentActEnvironment() {
- {
- var isReactActEnvironmentGlobal = // $FlowExpectedError – Flow doesn't know about IS_REACT_ACT_ENVIRONMENT global
- typeof IS_REACT_ACT_ENVIRONMENT !== 'undefined' ? IS_REACT_ACT_ENVIRONMENT : undefined;
-
- if (!isReactActEnvironmentGlobal && ReactCurrentActQueue.current !== null) {
- // TODO: Include link to relevant documentation page.
- error('The current testing environment is not configured to support ' + 'act(...)');
- }
-
- return isReactActEnvironmentGlobal;
- }
- }
-
- var ceil = Math.ceil;
- var ReactCurrentDispatcher$2 = ReactSharedInternals.ReactCurrentDispatcher,
- ReactCurrentOwner$2 = ReactSharedInternals.ReactCurrentOwner,
- ReactCurrentBatchConfig$3 = ReactSharedInternals.ReactCurrentBatchConfig,
- ReactCurrentActQueue$1 = ReactSharedInternals.ReactCurrentActQueue;
- var NoContext =
- /* */
- 0;
- var BatchedContext =
- /* */
- 1;
- var RenderContext =
- /* */
- 2;
- var CommitContext =
- /* */
- 4;
- var RootInProgress = 0;
- var RootFatalErrored = 1;
- var RootErrored = 2;
- var RootSuspended = 3;
- var RootSuspendedWithDelay = 4;
- var RootCompleted = 5;
- var RootDidNotComplete = 6; // Describes where we are in the React execution stack
-
- var executionContext = NoContext; // The root we're working on
-
- var workInProgressRoot = null; // The fiber we're working on
-
- var workInProgress = null; // The lanes we're rendering
-
- var workInProgressRootRenderLanes = NoLanes; // Stack that allows components to change the render lanes for its subtree
- // This is a superset of the lanes we started working on at the root. The only
- // case where it's Different from `workInProgressRootRenderLanes` is when we
- // enter a subtree that is hidden and needs to be unhidden: Suspense and
- // Offscreen component.
- //
- // Most things in the work loop should deal with workInProgressRootRenderLanes.
- // Most things in begin/complete phases should deal with subtreeRenderLanes.
-
- var subtreeRenderLanes = NoLanes;
- var subtreeRenderLanesCursor = createCursor(NoLanes); // Whether to root completed, errored, suspended, etc.
-
- var workInProgressRootExitStatus = RootInProgress; // A fatal error, if one is thrown
-
- var workInProgressRootFatalError = null; // "Included" lanes refer to lanes that were worked on during this render. It's
- // slightly Different than `renderLanes` because `renderLanes` can change as you
- // enter and exit an Offscreen tree. This value is the combination of all render
- // lanes for the entire render phase.
-
- var workInProgressRootIncludedLanes = NoLanes; // The work left over by components that were visited during this render. Only
- // includes unprocessed updates, not work in bailed out children.
-
- var workInProgressRootSkippedLanes = NoLanes; // Lanes that were updated (in an interleaved event) during this render.
-
- var workInProgressRootInterleavedUpdatedLanes = NoLanes; // Lanes that were updated during the render phase (*not* an interleaved event).
-
- var workInProgressRootPingedLanes = NoLanes; // Errors that are thrown during the render phase.
-
- var workInProgressRootConcurrentErrors = null; // These are errors that we recovered from without surfacing them to the UI.
- // We will log them once the tree commits.
-
- var workInProgressRootRecoverableErrors = null; // The most recent time we committed a fallback. This lets us ensure a train
- // model where we don't commit new loading states in too quick succession.
-
- var globalMostRecentFallbackTime = 0;
- var FALLBACK_THROTTLE_MS = 500; // The absolute time for when we should start giving up on rendering
- // more and prefer CPU suspense heuristics instead.
-
- var workInProgressRootRenderTargetTime = Infinity; // How long a render is supposed to take before we start following CPU
- // suspense heuristics and opt out of rendering more content.
-
- var RENDER_TIMEOUT_MS = 500;
- var workInProgressTransitions = null;
-
- function resetRenderTimer() {
- workInProgressRootRenderTargetTime = now() + RENDER_TIMEOUT_MS;
- }
-
- function getRenderTargetTime() {
- return workInProgressRootRenderTargetTime;
- }
- var hasUncaughtError = false;
- var firstUncaughtError = null;
- var legacyErrorBoundariesThatAlreadyFailed = null; // Only used when enableProfilerNestedUpdateScheduledHook is true;
- var rootDoesHavePassiveEffects = false;
- var rootWithPendingPassiveEffects = null;
- var pendingPassiveEffectsLanes = NoLanes;
- var pendingPassiveProfilerEffects = [];
- var pendingPassiveTransitions = null; // Use these to prevent an infinite loop of nested updates
-
- var NESTED_UPDATE_LIMIT = 50;
- var nestedUpdateCount = 0;
- var rootWithNestedUpdates = null;
- var isFlushingPassiveEffects = false;
- var didScheduleUpdateDuringPassiveEffects = false;
- var NESTED_PASSIVE_UPDATE_LIMIT = 50;
- var nestedPassiveUpdateCount = 0;
- var rootWithPassiveNestedUpdates = null; // If two updates are scheduled within the same event, we should treat their
- // event times as simultaneous, even if the actual clock time has advanced
- // between the first and second call.
-
- var currentEventTime = NoTimestamp;
- var currentEventTransitionLane = NoLanes;
- var isRunningInsertionEffect = false;
- function getWorkInProgressRoot() {
- return workInProgressRoot;
- }
- function requestEventTime() {
- if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
- // We're inside React, so it's fine to read the actual time.
- return now();
- } // We're not inside React, so we may be in the middle of a browser event.
-
-
- if (currentEventTime !== NoTimestamp) {
- // Use the same start time for all updates until we enter React again.
- return currentEventTime;
- } // This is the first update since React yielded. Compute a new start time.
-
-
- currentEventTime = now();
- return currentEventTime;
- }
- function requestUpdateLane(fiber) {
- // Special cases
- var mode = fiber.mode;
-
- if ((mode & ConcurrentMode) === NoMode) {
- return SyncLane;
- } else if ( (executionContext & RenderContext) !== NoContext && workInProgressRootRenderLanes !== NoLanes) {
- // This is a render phase update. These are not officially supported. The
- // old behavior is to give this the same "thread" (lanes) as
- // whatever is currently rendering. So if you call `setState` on a component
- // that happens later in the same render, it will flush. Ideally, we want to
- // remove the special case and treat them as if they came from an
- // interleaved event. Regardless, this pattern is not officially supported.
- // This behavior is only a fallback. The flag only exists until we can roll
- // out the setState warning, since existing code might accidentally rely on
- // the current behavior.
- return pickArbitraryLane(workInProgressRootRenderLanes);
- }
-
- var isTransition = requestCurrentTransition() !== NoTransition;
-
- if (isTransition) {
- if ( ReactCurrentBatchConfig$3.transition !== null) {
- var transition = ReactCurrentBatchConfig$3.transition;
-
- if (!transition._updatedFibers) {
- transition._updatedFibers = new Set();
- }
-
- transition._updatedFibers.add(fiber);
- } // The algorithm for assigning an update to a lane should be stable for all
- // updates at the same priority within the same event. To do this, the
- // inputs to the algorithm must be the same.
- //
- // The trick we use is to cache the first of each of these inputs within an
- // event. Then reset the cached values once we can be sure the event is
- // over. Our heuristic for that is whenever we enter a concurrent work loop.
-
-
- if (currentEventTransitionLane === NoLane) {
- // All transitions within the same event are assigned the same lane.
- currentEventTransitionLane = claimNextTransitionLane();
- }
-
- return currentEventTransitionLane;
- } // Updates originating inside certain React methods, like flushSync, have
- // their priority set by tracking it with a context variable.
- //
- // The opaque type returned by the host config is internally a lane, so we can
- // use that directly.
- // TODO: Move this type conversion to the event priority module.
-
-
- var updateLane = getCurrentUpdatePriority();
-
- if (updateLane !== NoLane) {
- return updateLane;
- } // This update originated outside React. Ask the host environment for an
- // appropriate priority, based on the type of event.
- //
- // The opaque type returned by the host config is internally a lane, so we can
- // use that directly.
- // TODO: Move this type conversion to the event priority module.
-
-
- var eventLane = getCurrentEventPriority();
- return eventLane;
- }
-
- function requestRetryLane(fiber) {
- // This is a fork of `requestUpdateLane` designed specifically for Suspense
- // "retries" — a special update that attempts to flip a Suspense boundary
- // from its placeholder state to its primary/resolved state.
- // Special cases
- var mode = fiber.mode;
-
- if ((mode & ConcurrentMode) === NoMode) {
- return SyncLane;
- }
-
- return claimNextRetryLane();
- }
-
- function scheduleUpdateOnFiber(root, fiber, lane, eventTime) {
- checkForNestedUpdates();
-
- {
- if (isRunningInsertionEffect) {
- error('useInsertionEffect must not schedule updates.');
- }
- }
-
- {
- if (isFlushingPassiveEffects) {
- didScheduleUpdateDuringPassiveEffects = true;
- }
- } // Mark that the root has a pending update.
-
-
- markRootUpdated(root, lane, eventTime);
-
- if ((executionContext & RenderContext) !== NoLanes && root === workInProgressRoot) {
- // This update was dispatched during the render phase. This is a mistake
- // if the update originates from user space (with the exception of local
- // hook updates, which are handled differently and don't reach this
- // function), but there are some internal React features that use this as
- // an implementation detail, like selective hydration.
- warnAboutRenderPhaseUpdatesInDEV(fiber); // Track lanes that were updated during the render phase
- } else {
- // This is a normal update, scheduled from outside the render phase. For
- // example, during an input event.
- {
- if (isDevToolsPresent) {
- addFiberToLanesMap(root, fiber, lane);
- }
- }
-
- warnIfUpdatesNotWrappedWithActDEV(fiber);
-
- if (root === workInProgressRoot) {
- // Received an update to a tree that's in the middle of rendering. Mark
- // that there was an interleaved update work on this root. Unless the
- // `deferRenderPhaseUpdateToNextBatch` flag is off and this is a render
- // phase update. In that case, we don't treat render phase updates as if
- // they were interleaved, for backwards compat reasons.
- if ( (executionContext & RenderContext) === NoContext) {
- workInProgressRootInterleavedUpdatedLanes = mergeLanes(workInProgressRootInterleavedUpdatedLanes, lane);
- }
-
- if (workInProgressRootExitStatus === RootSuspendedWithDelay) {
- // The root already suspended with a delay, which means this render
- // definitely won't finish. Since we have a new update, let's mark it as
- // suspended now, right before marking the incoming update. This has the
- // effect of interrupting the current render and switching to the update.
- // TODO: Make sure this doesn't override pings that happen while we've
- // already started rendering.
- markRootSuspended$1(root, workInProgressRootRenderLanes);
- }
- }
-
- ensureRootIsScheduled(root, eventTime);
-
- if (lane === SyncLane && executionContext === NoContext && (fiber.mode & ConcurrentMode) === NoMode && // Treat `act` as if it's inside `batchedUpdates`, even in legacy mode.
- !( ReactCurrentActQueue$1.isBatchingLegacy)) {
- // Flush the synchronous work now, unless we're already working or inside
- // a batch. This is intentionally inside scheduleUpdateOnFiber instead of
- // scheduleCallbackForFiber to preserve the ability to schedule a callback
- // without immediately flushing it. We only do this for user-initiated
- // updates, to preserve historical behavior of legacy mode.
- resetRenderTimer();
- flushSyncCallbacksOnlyInLegacyMode();
- }
- }
- }
- function scheduleInitialHydrationOnRoot(root, lane, eventTime) {
- // This is a special fork of scheduleUpdateOnFiber that is only used to
- // schedule the initial hydration of a root that has just been created. Most
- // of the stuff in scheduleUpdateOnFiber can be skipped.
- //
- // The main reason for this separate path, though, is to distinguish the
- // initial children from subsequent updates. In fully client-rendered roots
- // (createRoot instead of hydrateRoot), all top-level renders are modeled as
- // updates, but hydration roots are special because the initial render must
- // match what was rendered on the server.
- var current = root.current;
- current.lanes = lane;
- markRootUpdated(root, lane, eventTime);
- ensureRootIsScheduled(root, eventTime);
- }
- function isUnsafeClassRenderPhaseUpdate(fiber) {
- // Check if this is a render phase update. Only called by class components,
- // which special (deprecated) behavior for UNSAFE_componentWillReceive props.
- return (// TODO: Remove outdated deferRenderPhaseUpdateToNextBatch experiment. We
- // decided not to enable it.
- (executionContext & RenderContext) !== NoContext
- );
- } // Use this function to schedule a task for a root. There's only one task per
- // root; if a task was already scheduled, we'll check to make sure the priority
- // of the existing task is the same as the priority of the next level that the
- // root has work on. This function is called on every update, and right before
- // exiting a task.
-
- function ensureRootIsScheduled(root, currentTime) {
- var existingCallbackNode = root.callbackNode; // Check if any lanes are being starved by other work. If so, mark them as
- // expired so we know to work on those next.
-
- markStarvedLanesAsExpired(root, currentTime); // Determine the next lanes to work on, and their priority.
-
- var nextLanes = getNextLanes(root, root === workInProgressRoot ? workInProgressRootRenderLanes : NoLanes);
-
- if (nextLanes === NoLanes) {
- // Special case: There's nothing to work on.
- if (existingCallbackNode !== null) {
- cancelCallback$1(existingCallbackNode);
- }
-
- root.callbackNode = null;
- root.callbackPriority = NoLane;
- return;
- } // We use the highest priority lane to represent the priority of the callback.
-
-
- var newCallbackPriority = getHighestPriorityLane(nextLanes); // Check if there's an existing task. We may be able to reuse it.
-
- var existingCallbackPriority = root.callbackPriority;
-
- if (existingCallbackPriority === newCallbackPriority && // Special case related to `act`. If the currently scheduled task is a
- // Scheduler task, rather than an `act` task, cancel it and re-scheduled
- // on the `act` queue.
- !( ReactCurrentActQueue$1.current !== null && existingCallbackNode !== fakeActCallbackNode)) {
- {
- // If we're going to re-use an existing task, it needs to exist.
- // Assume that discrete update microtasks are non-cancellable and null.
- // TODO: Temporary until we confirm this warning is not fired.
- if (existingCallbackNode == null && existingCallbackPriority !== SyncLane) {
- error('Expected scheduled callback to exist. This error is likely caused by a bug in React. Please file an issue.');
- }
- } // The priority hasn't changed. We can reuse the existing task. Exit.
-
-
- return;
- }
-
- if (existingCallbackNode != null) {
- // Cancel the existing callback. We'll schedule a new one below.
- cancelCallback$1(existingCallbackNode);
- } // Schedule a new callback.
-
-
- var newCallbackNode;
-
- if (newCallbackPriority === SyncLane) {
- // Special case: Sync React callbacks are scheduled on a special
- // internal queue
- if (root.tag === LegacyRoot) {
- if ( ReactCurrentActQueue$1.isBatchingLegacy !== null) {
- ReactCurrentActQueue$1.didScheduleLegacyUpdate = true;
- }
-
- scheduleLegacySyncCallback(performSyncWorkOnRoot.bind(null, root));
- } else {
- scheduleSyncCallback(performSyncWorkOnRoot.bind(null, root));
- }
-
- {
- // Flush the queue in a microtask.
- if ( ReactCurrentActQueue$1.current !== null) {
- // Inside `act`, use our internal `act` queue so that these get flushed
- // at the end of the current scope even when using the sync version
- // of `act`.
- ReactCurrentActQueue$1.current.push(flushSyncCallbacks);
- } else {
- scheduleMicrotask(function () {
- // In Safari, appending an iframe forces microtasks to run.
- // https://github.com/facebook/react/issues/22459
- // We don't support running callbacks in the middle of render
- // or commit so we need to check against that.
- if ((executionContext & (RenderContext | CommitContext)) === NoContext) {
- // Note that this would still prematurely flush the callbacks
- // if this happens outside render or commit phase (e.g. in an event).
- flushSyncCallbacks();
- }
- });
- }
- }
-
- newCallbackNode = null;
- } else {
- var schedulerPriorityLevel;
-
- switch (lanesToEventPriority(nextLanes)) {
- case DiscreteEventPriority:
- schedulerPriorityLevel = ImmediatePriority;
- break;
-
- case ContinuousEventPriority:
- schedulerPriorityLevel = UserBlockingPriority;
- break;
-
- case DefaultEventPriority:
- schedulerPriorityLevel = NormalPriority;
- break;
-
- case IdleEventPriority:
- schedulerPriorityLevel = IdlePriority;
- break;
-
- default:
- schedulerPriorityLevel = NormalPriority;
- break;
- }
-
- newCallbackNode = scheduleCallback$1(schedulerPriorityLevel, performConcurrentWorkOnRoot.bind(null, root));
- }
-
- root.callbackPriority = newCallbackPriority;
- root.callbackNode = newCallbackNode;
- } // This is the entry point for every concurrent task, i.e. anything that
- // goes through Scheduler.
-
-
- function performConcurrentWorkOnRoot(root, didTimeout) {
- {
- resetNestedUpdateFlag();
- } // Since we know we're in a React event, we can clear the current
- // event time. The next update will compute a new event time.
-
-
- currentEventTime = NoTimestamp;
- currentEventTransitionLane = NoLanes;
-
- if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
- throw new Error('Should not already be working.');
- } // Flush any pending passive effects before deciding which lanes to work on,
- // in case they schedule additional work.
-
-
- var originalCallbackNode = root.callbackNode;
- var didFlushPassiveEffects = flushPassiveEffects();
-
- if (didFlushPassiveEffects) {
- // Something in the passive effect phase may have canceled the current task.
- // Check if the task node for this root was changed.
- if (root.callbackNode !== originalCallbackNode) {
- // The current task was canceled. Exit. We don't need to call
- // `ensureRootIsScheduled` because the check above implies either that
- // there's a new task, or that there's no remaining work on this root.
- return null;
- }
- } // Determine the next lanes to work on, using the fields stored
- // on the root.
-
-
- var lanes = getNextLanes(root, root === workInProgressRoot ? workInProgressRootRenderLanes : NoLanes);
-
- if (lanes === NoLanes) {
- // Defensive coding. This is never expected to happen.
- return null;
- } // We disable time-slicing in some cases: if the work has been CPU-bound
- // for too long ("expired" work, to prevent starvation), or we're in
- // sync-updates-by-default mode.
- // TODO: We only check `didTimeout` defensively, to account for a Scheduler
- // bug we're still investigating. Once the bug in Scheduler is fixed,
- // we can remove this, since we track expiration ourselves.
-
-
- var shouldTimeSlice = !includesBlockingLane(root, lanes) && !includesExpiredLane(root, lanes) && ( !didTimeout);
- var exitStatus = shouldTimeSlice ? renderRootConcurrent(root, lanes) : renderRootSync(root, lanes);
-
- if (exitStatus !== RootInProgress) {
- if (exitStatus === RootErrored) {
- // If something threw an error, try rendering one more time. We'll
- // render synchronously to block concurrent data mutations, and we'll
- // includes all pending updates are included. If it still fails after
- // the second attempt, we'll give up and commit the resulting tree.
- var errorRetryLanes = getLanesToRetrySynchronouslyOnError(root);
-
- if (errorRetryLanes !== NoLanes) {
- lanes = errorRetryLanes;
- exitStatus = recoverFromConcurrentError(root, errorRetryLanes);
- }
- }
-
- if (exitStatus === RootFatalErrored) {
- var fatalError = workInProgressRootFatalError;
- prepareFreshStack(root, NoLanes);
- markRootSuspended$1(root, lanes);
- ensureRootIsScheduled(root, now());
- throw fatalError;
- }
-
- if (exitStatus === RootDidNotComplete) {
- // The render unwound without completing the tree. This happens in special
- // cases where need to exit the current render without producing a
- // consistent tree or committing.
- //
- // This should only happen during a concurrent render, not a discrete or
- // synchronous update. We should have already checked for this when we
- // unwound the stack.
- markRootSuspended$1(root, lanes);
- } else {
- // The render completed.
- // Check if this render may have yielded to a concurrent event, and if so,
- // confirm that any newly rendered stores are consistent.
- // TODO: It's possible that even a concurrent render may never have yielded
- // to the main thread, if it was fast enough, or if it expired. We could
- // skip the consistency check in that case, too.
- var renderWasConcurrent = !includesBlockingLane(root, lanes);
- var finishedWork = root.current.alternate;
-
- if (renderWasConcurrent && !isRenderConsistentWithExternalStores(finishedWork)) {
- // A store was mutated in an interleaved event. Render again,
- // synchronously, to block further mutations.
- exitStatus = renderRootSync(root, lanes); // We need to check again if something threw
-
- if (exitStatus === RootErrored) {
- var _errorRetryLanes = getLanesToRetrySynchronouslyOnError(root);
-
- if (_errorRetryLanes !== NoLanes) {
- lanes = _errorRetryLanes;
- exitStatus = recoverFromConcurrentError(root, _errorRetryLanes); // We assume the tree is now consistent because we didn't yield to any
- // concurrent events.
- }
- }
-
- if (exitStatus === RootFatalErrored) {
- var _fatalError = workInProgressRootFatalError;
- prepareFreshStack(root, NoLanes);
- markRootSuspended$1(root, lanes);
- ensureRootIsScheduled(root, now());
- throw _fatalError;
- }
- } // We now have a consistent tree. The next step is either to commit it,
- // or, if something suspended, wait to commit it after a timeout.
-
-
- root.finishedWork = finishedWork;
- root.finishedLanes = lanes;
- finishConcurrentRender(root, exitStatus, lanes);
- }
- }
-
- ensureRootIsScheduled(root, now());
-
- if (root.callbackNode === originalCallbackNode) {
- // The task node scheduled for this root is the same one that's
- // currently executed. Need to return a continuation.
- return performConcurrentWorkOnRoot.bind(null, root);
- }
-
- return null;
- }
-
- function recoverFromConcurrentError(root, errorRetryLanes) {
- // If an error occurred during hydration, discard server response and fall
- // back to client side render.
- // Before rendering again, save the errors from the previous attempt.
- var errorsFromFirstAttempt = workInProgressRootConcurrentErrors;
-
- if (isRootDehydrated(root)) {
- // The shell failed to hydrate. Set a flag to force a client rendering
- // during the next attempt. To do this, we call prepareFreshStack now
- // to create the root work-in-progress fiber. This is a bit weird in terms
- // of factoring, because it relies on renderRootSync not calling
- // prepareFreshStack again in the call below, which happens because the
- // root and lanes haven't changed.
- //
- // TODO: I think what we should do is set ForceClientRender inside
- // throwException, like we do for nested Suspense boundaries. The reason
- // it's here instead is so we can switch to the synchronous work loop, too.
- // Something to consider for a future refactor.
- var rootWorkInProgress = prepareFreshStack(root, errorRetryLanes);
- rootWorkInProgress.flags |= ForceClientRender;
-
- {
- errorHydratingContainer(root.containerInfo);
- }
- }
-
- var exitStatus = renderRootSync(root, errorRetryLanes);
-
- if (exitStatus !== RootErrored) {
- // Successfully finished rendering on retry
- // The errors from the failed first attempt have been recovered. Add
- // them to the collection of recoverable errors. We'll log them in the
- // commit phase.
- var errorsFromSecondAttempt = workInProgressRootRecoverableErrors;
- workInProgressRootRecoverableErrors = errorsFromFirstAttempt; // The errors from the second attempt should be queued after the errors
- // from the first attempt, to preserve the causal sequence.
-
- if (errorsFromSecondAttempt !== null) {
- queueRecoverableErrors(errorsFromSecondAttempt);
- }
- }
-
- return exitStatus;
- }
-
- function queueRecoverableErrors(errors) {
- if (workInProgressRootRecoverableErrors === null) {
- workInProgressRootRecoverableErrors = errors;
- } else {
- workInProgressRootRecoverableErrors.push.apply(workInProgressRootRecoverableErrors, errors);
- }
- }
-
- function finishConcurrentRender(root, exitStatus, lanes) {
- switch (exitStatus) {
- case RootInProgress:
- case RootFatalErrored:
- {
- throw new Error('Root did not complete. This is a bug in React.');
- }
- // Flow knows about invariant, so it complains if I add a break
- // statement, but eslint doesn't know about invariant, so it complains
- // if I do. eslint-disable-next-line no-fallthrough
-
- case RootErrored:
- {
- // We should have already attempted to retry this tree. If we reached
- // this point, it errored again. Commit it.
- commitRoot(root, workInProgressRootRecoverableErrors, workInProgressTransitions);
- break;
- }
-
- case RootSuspended:
- {
- markRootSuspended$1(root, lanes); // We have an acceptable loading state. We need to figure out if we
- // should immediately commit it or wait a bit.
-
- if (includesOnlyRetries(lanes) && // do not delay if we're inside an act() scope
- !shouldForceFlushFallbacksInDEV()) {
- // This render only included retries, no updates. Throttle committing
- // retries so that we don't show too many loading states too quickly.
- var msUntilTimeout = globalMostRecentFallbackTime + FALLBACK_THROTTLE_MS - now(); // Don't bother with a very short suspense time.
-
- if (msUntilTimeout > 10) {
- var nextLanes = getNextLanes(root, NoLanes);
-
- if (nextLanes !== NoLanes) {
- // There's additional work on this root.
- break;
- }
-
- var suspendedLanes = root.suspendedLanes;
-
- if (!isSubsetOfLanes(suspendedLanes, lanes)) {
- // We should prefer to render the fallback of at the last
- // suspended level. Ping the last suspended level to try
- // rendering it again.
- // FIXME: What if the suspended lanes are Idle? Should not restart.
- var eventTime = requestEventTime();
- markRootPinged(root, suspendedLanes);
- break;
- } // The render is suspended, it hasn't timed out, and there's no
- // lower priority work to do. Instead of committing the fallback
- // immediately, wait for more data to arrive.
-
-
- root.timeoutHandle = scheduleTimeout(commitRoot.bind(null, root, workInProgressRootRecoverableErrors, workInProgressTransitions), msUntilTimeout);
- break;
- }
- } // The work expired. Commit immediately.
-
-
- commitRoot(root, workInProgressRootRecoverableErrors, workInProgressTransitions);
- break;
- }
-
- case RootSuspendedWithDelay:
- {
- markRootSuspended$1(root, lanes);
-
- if (includesOnlyTransitions(lanes)) {
- // This is a transition, so we should exit without committing a
- // placeholder and without scheduling a timeout. Delay indefinitely
- // until we receive more data.
- break;
- }
-
- if (!shouldForceFlushFallbacksInDEV()) {
- // This is not a transition, but we did trigger an avoided state.
- // Schedule a placeholder to display after a short delay, using the Just
- // Noticeable Difference.
- // TODO: Is the JND optimization worth the added complexity? If this is
- // the only reason we track the event time, then probably not.
- // Consider removing.
- var mostRecentEventTime = getMostRecentEventTime(root, lanes);
- var eventTimeMs = mostRecentEventTime;
- var timeElapsedMs = now() - eventTimeMs;
-
- var _msUntilTimeout = jnd(timeElapsedMs) - timeElapsedMs; // Don't bother with a very short suspense time.
-
-
- if (_msUntilTimeout > 10) {
- // Instead of committing the fallback immediately, wait for more data
- // to arrive.
- root.timeoutHandle = scheduleTimeout(commitRoot.bind(null, root, workInProgressRootRecoverableErrors, workInProgressTransitions), _msUntilTimeout);
- break;
- }
- } // Commit the placeholder.
-
-
- commitRoot(root, workInProgressRootRecoverableErrors, workInProgressTransitions);
- break;
- }
-
- case RootCompleted:
- {
- // The work completed. Ready to commit.
- commitRoot(root, workInProgressRootRecoverableErrors, workInProgressTransitions);
- break;
- }
-
- default:
- {
- throw new Error('Unknown root exit status.');
- }
- }
- }
-
- function isRenderConsistentWithExternalStores(finishedWork) {
- // Search the rendered tree for external store reads, and check whether the
- // stores were mutated in a concurrent event. Intentionally using an iterative
- // loop instead of recursion so we can exit early.
- var node = finishedWork;
-
- while (true) {
- if (node.flags & StoreConsistency) {
- var updateQueue = node.updateQueue;
-
- if (updateQueue !== null) {
- var checks = updateQueue.stores;
-
- if (checks !== null) {
- for (var i = 0; i < checks.length; i++) {
- var check = checks[i];
- var getSnapshot = check.getSnapshot;
- var renderedValue = check.value;
-
- try {
- if (!objectIs(getSnapshot(), renderedValue)) {
- // Found an inconsistent store.
- return false;
- }
- } catch (error) {
- // If `getSnapshot` throws, return `false`. This will schedule
- // a re-render, and the error will be rethrown during render.
- return false;
- }
- }
- }
- }
- }
-
- var child = node.child;
-
- if (node.subtreeFlags & StoreConsistency && child !== null) {
- child.return = node;
- node = child;
- continue;
- }
-
- if (node === finishedWork) {
- return true;
- }
-
- while (node.sibling === null) {
- if (node.return === null || node.return === finishedWork) {
- return true;
- }
-
- node = node.return;
- }
-
- node.sibling.return = node.return;
- node = node.sibling;
- } // Flow doesn't know this is unreachable, but eslint does
- // eslint-disable-next-line no-unreachable
-
-
- return true;
- }
-
- function markRootSuspended$1(root, suspendedLanes) {
- // When suspending, we should always exclude lanes that were pinged or (more
- // rarely, since we try to avoid it) updated during the render phase.
- // TODO: Lol maybe there's a better way to factor this besides this
- // obnoxiously named function :)
- suspendedLanes = removeLanes(suspendedLanes, workInProgressRootPingedLanes);
- suspendedLanes = removeLanes(suspendedLanes, workInProgressRootInterleavedUpdatedLanes);
- markRootSuspended(root, suspendedLanes);
- } // This is the entry point for synchronous tasks that don't go
- // through Scheduler
-
-
- function performSyncWorkOnRoot(root) {
- {
- syncNestedUpdateFlag();
- }
-
- if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
- throw new Error('Should not already be working.');
- }
-
- flushPassiveEffects();
- var lanes = getNextLanes(root, NoLanes);
-
- if (!includesSomeLane(lanes, SyncLane)) {
- // There's no remaining sync work left.
- ensureRootIsScheduled(root, now());
- return null;
- }
-
- var exitStatus = renderRootSync(root, lanes);
-
- if (root.tag !== LegacyRoot && exitStatus === RootErrored) {
- // If something threw an error, try rendering one more time. We'll render
- // synchronously to block concurrent data mutations, and we'll includes
- // all pending updates are included. If it still fails after the second
- // attempt, we'll give up and commit the resulting tree.
- var errorRetryLanes = getLanesToRetrySynchronouslyOnError(root);
-
- if (errorRetryLanes !== NoLanes) {
- lanes = errorRetryLanes;
- exitStatus = recoverFromConcurrentError(root, errorRetryLanes);
- }
- }
-
- if (exitStatus === RootFatalErrored) {
- var fatalError = workInProgressRootFatalError;
- prepareFreshStack(root, NoLanes);
- markRootSuspended$1(root, lanes);
- ensureRootIsScheduled(root, now());
- throw fatalError;
- }
-
- if (exitStatus === RootDidNotComplete) {
- throw new Error('Root did not complete. This is a bug in React.');
- } // We now have a consistent tree. Because this is a sync render, we
- // will commit it even if something suspended.
-
-
- var finishedWork = root.current.alternate;
- root.finishedWork = finishedWork;
- root.finishedLanes = lanes;
- commitRoot(root, workInProgressRootRecoverableErrors, workInProgressTransitions); // Before exiting, make sure there's a callback scheduled for the next
- // pending level.
-
- ensureRootIsScheduled(root, now());
- return null;
- }
-
- function flushRoot(root, lanes) {
- if (lanes !== NoLanes) {
- markRootEntangled(root, mergeLanes(lanes, SyncLane));
- ensureRootIsScheduled(root, now());
-
- if ((executionContext & (RenderContext | CommitContext)) === NoContext) {
- resetRenderTimer();
- flushSyncCallbacks();
- }
- }
- }
- function batchedUpdates$1(fn, a) {
- var prevExecutionContext = executionContext;
- executionContext |= BatchedContext;
-
- try {
- return fn(a);
- } finally {
- executionContext = prevExecutionContext; // If there were legacy sync updates, flush them at the end of the outer
- // most batchedUpdates-like method.
-
- if (executionContext === NoContext && // Treat `act` as if it's inside `batchedUpdates`, even in legacy mode.
- !( ReactCurrentActQueue$1.isBatchingLegacy)) {
- resetRenderTimer();
- flushSyncCallbacksOnlyInLegacyMode();
- }
- }
- }
- function discreteUpdates(fn, a, b, c, d) {
- var previousPriority = getCurrentUpdatePriority();
- var prevTransition = ReactCurrentBatchConfig$3.transition;
-
- try {
- ReactCurrentBatchConfig$3.transition = null;
- setCurrentUpdatePriority(DiscreteEventPriority);
- return fn(a, b, c, d);
- } finally {
- setCurrentUpdatePriority(previousPriority);
- ReactCurrentBatchConfig$3.transition = prevTransition;
-
- if (executionContext === NoContext) {
- resetRenderTimer();
- }
- }
- } // Overload the definition to the two valid signatures.
- // Warning, this opts-out of checking the function body.
-
- // eslint-disable-next-line no-redeclare
- function flushSync(fn) {
- // In legacy mode, we flush pending passive effects at the beginning of the
- // next event, not at the end of the previous one.
- if (rootWithPendingPassiveEffects !== null && rootWithPendingPassiveEffects.tag === LegacyRoot && (executionContext & (RenderContext | CommitContext)) === NoContext) {
- flushPassiveEffects();
- }
-
- var prevExecutionContext = executionContext;
- executionContext |= BatchedContext;
- var prevTransition = ReactCurrentBatchConfig$3.transition;
- var previousPriority = getCurrentUpdatePriority();
-
- try {
- ReactCurrentBatchConfig$3.transition = null;
- setCurrentUpdatePriority(DiscreteEventPriority);
-
- if (fn) {
- return fn();
- } else {
- return undefined;
- }
- } finally {
- setCurrentUpdatePriority(previousPriority);
- ReactCurrentBatchConfig$3.transition = prevTransition;
- executionContext = prevExecutionContext; // Flush the immediate callbacks that were scheduled during this batch.
- // Note that this will happen even if batchedUpdates is higher up
- // the stack.
-
- if ((executionContext & (RenderContext | CommitContext)) === NoContext) {
- flushSyncCallbacks();
- }
- }
- }
- function isAlreadyRendering() {
- // Used by the renderer to print a warning if certain APIs are called from
- // the wrong context.
- return (executionContext & (RenderContext | CommitContext)) !== NoContext;
- }
- function pushRenderLanes(fiber, lanes) {
- push(subtreeRenderLanesCursor, subtreeRenderLanes, fiber);
- subtreeRenderLanes = mergeLanes(subtreeRenderLanes, lanes);
- workInProgressRootIncludedLanes = mergeLanes(workInProgressRootIncludedLanes, lanes);
- }
- function popRenderLanes(fiber) {
- subtreeRenderLanes = subtreeRenderLanesCursor.current;
- pop(subtreeRenderLanesCursor, fiber);
- }
-
- function prepareFreshStack(root, lanes) {
- root.finishedWork = null;
- root.finishedLanes = NoLanes;
- var timeoutHandle = root.timeoutHandle;
-
- if (timeoutHandle !== noTimeout) {
- // The root previous suspended and scheduled a timeout to commit a fallback
- // state. Now that we have additional work, cancel the timeout.
- root.timeoutHandle = noTimeout; // $FlowFixMe Complains noTimeout is not a TimeoutID, despite the check above
-
- cancelTimeout(timeoutHandle);
- }
-
- if (workInProgress !== null) {
- var interruptedWork = workInProgress.return;
-
- while (interruptedWork !== null) {
- var current = interruptedWork.alternate;
- unwindInterruptedWork(current, interruptedWork);
- interruptedWork = interruptedWork.return;
- }
- }
-
- workInProgressRoot = root;
- var rootWorkInProgress = createWorkInProgress(root.current, null);
- workInProgress = rootWorkInProgress;
- workInProgressRootRenderLanes = subtreeRenderLanes = workInProgressRootIncludedLanes = lanes;
- workInProgressRootExitStatus = RootInProgress;
- workInProgressRootFatalError = null;
- workInProgressRootSkippedLanes = NoLanes;
- workInProgressRootInterleavedUpdatedLanes = NoLanes;
- workInProgressRootPingedLanes = NoLanes;
- workInProgressRootConcurrentErrors = null;
- workInProgressRootRecoverableErrors = null;
- finishQueueingConcurrentUpdates();
-
- {
- ReactStrictModeWarnings.discardPendingWarnings();
- }
-
- return rootWorkInProgress;
- }
-
- function handleError(root, thrownValue) {
- do {
- var erroredWork = workInProgress;
-
- try {
- // Reset module-level state that was set during the render phase.
- resetContextDependencies();
- resetHooksAfterThrow();
- resetCurrentFiber(); // TODO: I found and added this missing line while investigating a
- // separate issue. Write a regression test using string refs.
-
- ReactCurrentOwner$2.current = null;
-
- if (erroredWork === null || erroredWork.return === null) {
- // Expected to be working on a non-root fiber. This is a fatal error
- // because there's no ancestor that can handle it; the root is
- // supposed to capture all errors that weren't caught by an error
- // boundary.
- workInProgressRootExitStatus = RootFatalErrored;
- workInProgressRootFatalError = thrownValue; // Set `workInProgress` to null. This represents advancing to the next
- // sibling, or the parent if there are no siblings. But since the root
- // has no siblings nor a parent, we set it to null. Usually this is
- // handled by `completeUnitOfWork` or `unwindWork`, but since we're
- // intentionally not calling those, we need set it here.
- // TODO: Consider calling `unwindWork` to pop the contexts.
-
- workInProgress = null;
- return;
- }
-
- if (enableProfilerTimer && erroredWork.mode & ProfileMode) {
- // Record the time spent rendering before an error was thrown. This
- // avoids inaccurate Profiler durations in the case of a
- // suspended render.
- stopProfilerTimerIfRunningAndRecordDelta(erroredWork, true);
- }
-
- if (enableSchedulingProfiler) {
- markComponentRenderStopped();
-
- if (thrownValue !== null && typeof thrownValue === 'object' && typeof thrownValue.then === 'function') {
- var wakeable = thrownValue;
- markComponentSuspended(erroredWork, wakeable, workInProgressRootRenderLanes);
- } else {
- markComponentErrored(erroredWork, thrownValue, workInProgressRootRenderLanes);
- }
- }
-
- throwException(root, erroredWork.return, erroredWork, thrownValue, workInProgressRootRenderLanes);
- completeUnitOfWork(erroredWork);
- } catch (yetAnotherThrownValue) {
- // Something in the return path also threw.
- thrownValue = yetAnotherThrownValue;
-
- if (workInProgress === erroredWork && erroredWork !== null) {
- // If this boundary has already errored, then we had trouble processing
- // the error. Bubble it to the next boundary.
- erroredWork = erroredWork.return;
- workInProgress = erroredWork;
- } else {
- erroredWork = workInProgress;
- }
-
- continue;
- } // Return to the normal work loop.
-
-
- return;
- } while (true);
- }
-
- function pushDispatcher() {
- var prevDispatcher = ReactCurrentDispatcher$2.current;
- ReactCurrentDispatcher$2.current = ContextOnlyDispatcher;
-
- if (prevDispatcher === null) {
- // The React isomorphic package does not include a default dispatcher.
- // Instead the first renderer will lazily attach one, in order to give
- // nicer error messages.
- return ContextOnlyDispatcher;
- } else {
- return prevDispatcher;
- }
- }
-
- function popDispatcher(prevDispatcher) {
- ReactCurrentDispatcher$2.current = prevDispatcher;
- }
-
- function markCommitTimeOfFallback() {
- globalMostRecentFallbackTime = now();
- }
- function markSkippedUpdateLanes(lane) {
- workInProgressRootSkippedLanes = mergeLanes(lane, workInProgressRootSkippedLanes);
- }
- function renderDidSuspend() {
- if (workInProgressRootExitStatus === RootInProgress) {
- workInProgressRootExitStatus = RootSuspended;
- }
- }
- function renderDidSuspendDelayIfPossible() {
- if (workInProgressRootExitStatus === RootInProgress || workInProgressRootExitStatus === RootSuspended || workInProgressRootExitStatus === RootErrored) {
- workInProgressRootExitStatus = RootSuspendedWithDelay;
- } // Check if there are updates that we skipped tree that might have unblocked
- // this render.
-
-
- if (workInProgressRoot !== null && (includesNonIdleWork(workInProgressRootSkippedLanes) || includesNonIdleWork(workInProgressRootInterleavedUpdatedLanes))) {
- // Mark the current render as suspended so that we switch to working on
- // the updates that were skipped. Usually we only suspend at the end of
- // the render phase.
- // TODO: We should probably always mark the root as suspended immediately
- // (inside this function), since by suspending at the end of the render
- // phase introduces a potential mistake where we suspend lanes that were
- // pinged or updated while we were rendering.
- markRootSuspended$1(workInProgressRoot, workInProgressRootRenderLanes);
- }
- }
- function renderDidError(error) {
- if (workInProgressRootExitStatus !== RootSuspendedWithDelay) {
- workInProgressRootExitStatus = RootErrored;
- }
-
- if (workInProgressRootConcurrentErrors === null) {
- workInProgressRootConcurrentErrors = [error];
- } else {
- workInProgressRootConcurrentErrors.push(error);
- }
- } // Called during render to determine if anything has suspended.
- // Returns false if we're not sure.
-
- function renderHasNotSuspendedYet() {
- // If something errored or completed, we can't really be sure,
- // so those are false.
- return workInProgressRootExitStatus === RootInProgress;
- }
-
- function renderRootSync(root, lanes) {
- var prevExecutionContext = executionContext;
- executionContext |= RenderContext;
- var prevDispatcher = pushDispatcher(); // If the root or lanes have changed, throw out the existing stack
- // and prepare a fresh one. Otherwise we'll continue where we left off.
-
- if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes) {
- {
- if (isDevToolsPresent) {
- var memoizedUpdaters = root.memoizedUpdaters;
-
- if (memoizedUpdaters.size > 0) {
- restorePendingUpdaters(root, workInProgressRootRenderLanes);
- memoizedUpdaters.clear();
- } // At this point, move Fibers that scheduled the upcoming work from the Map to the Set.
- // If we bailout on this work, we'll move them back (like above).
- // It's important to move them now in case the work spawns more work at the same priority with Different updaters.
- // That way we can keep the current update and future updates separate.
-
-
- movePendingFibersToMemoized(root, lanes);
- }
- }
-
- workInProgressTransitions = getTransitionsForLanes();
- prepareFreshStack(root, lanes);
- }
-
- {
- markRenderStarted(lanes);
- }
-
- do {
- try {
- workLoopSync();
- break;
- } catch (thrownValue) {
- handleError(root, thrownValue);
- }
- } while (true);
-
- resetContextDependencies();
- executionContext = prevExecutionContext;
- popDispatcher(prevDispatcher);
-
- if (workInProgress !== null) {
- // This is a sync render, so we should have finished the whole tree.
- throw new Error('Cannot commit an incomplete root. This error is likely caused by a ' + 'bug in React. Please file an issue.');
- }
-
- {
- markRenderStopped();
- } // Set this to null to indicate there's no in-progress render.
-
-
- workInProgressRoot = null;
- workInProgressRootRenderLanes = NoLanes;
- return workInProgressRootExitStatus;
- } // The work loop is an extremely hot path. Tell Closure not to inline it.
-
- /** @noinline */
-
-
- function workLoopSync() {
- // Already timed out, so perform work without checking if we need to yield.
- while (workInProgress !== null) {
- performUnitOfWork(workInProgress);
- }
- }
-
- function renderRootConcurrent(root, lanes) {
- var prevExecutionContext = executionContext;
- executionContext |= RenderContext;
- var prevDispatcher = pushDispatcher(); // If the root or lanes have changed, throw out the existing stack
- // and prepare a fresh one. Otherwise we'll continue where we left off.
-
- if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes) {
- {
- if (isDevToolsPresent) {
- var memoizedUpdaters = root.memoizedUpdaters;
-
- if (memoizedUpdaters.size > 0) {
- restorePendingUpdaters(root, workInProgressRootRenderLanes);
- memoizedUpdaters.clear();
- } // At this point, move Fibers that scheduled the upcoming work from the Map to the Set.
- // If we bailout on this work, we'll move them back (like above).
- // It's important to move them now in case the work spawns more work at the same priority with Different updaters.
- // That way we can keep the current update and future updates separate.
-
-
- movePendingFibersToMemoized(root, lanes);
- }
- }
-
- workInProgressTransitions = getTransitionsForLanes();
- resetRenderTimer();
- prepareFreshStack(root, lanes);
- }
-
- {
- markRenderStarted(lanes);
- }
-
- do {
- try {
- workLoopConcurrent();
- break;
- } catch (thrownValue) {
- handleError(root, thrownValue);
- }
- } while (true);
-
- resetContextDependencies();
- popDispatcher(prevDispatcher);
- executionContext = prevExecutionContext;
-
-
- if (workInProgress !== null) {
- // Still work remaining.
- {
- markRenderYielded();
- }
-
- return RootInProgress;
- } else {
- // Completed the tree.
- {
- markRenderStopped();
- } // Set this to null to indicate there's no in-progress render.
-
-
- workInProgressRoot = null;
- workInProgressRootRenderLanes = NoLanes; // Return the final exit status.
-
- return workInProgressRootExitStatus;
- }
- }
- /** @noinline */
-
-
- function workLoopConcurrent() {
- // Perform work until Scheduler asks us to yield
- while (workInProgress !== null && !shouldYield()) {
- performUnitOfWork(workInProgress);
- }
- }
-
- function performUnitOfWork(unitOfWork) {
- // The current, flushed, state of this fiber is the alternate. Ideally
- // nothing should rely on this, but relying on it here means that we don't
- // need an additional field on the work in progress.
- var current = unitOfWork.alternate;
- setCurrentFiber(unitOfWork);
- var next;
-
- if ( (unitOfWork.mode & ProfileMode) !== NoMode) {
- startProfilerTimer(unitOfWork);
- next = beginWork$1(current, unitOfWork, subtreeRenderLanes);
- stopProfilerTimerIfRunningAndRecordDelta(unitOfWork, true);
- } else {
- next = beginWork$1(current, unitOfWork, subtreeRenderLanes);
- }
-
- resetCurrentFiber();
- unitOfWork.memoizedProps = unitOfWork.pendingProps;
-
- if (next === null) {
- // If this doesn't spawn new work, complete the current work.
- completeUnitOfWork(unitOfWork);
- } else {
- workInProgress = next;
- }
-
- ReactCurrentOwner$2.current = null;
- }
-
- function completeUnitOfWork(unitOfWork) {
- // Attempt to complete the current unit of work, then move to the next
- // sibling. If there are no more siblings, return to the parent fiber.
- var completedWork = unitOfWork;
-
- do {
- // The current, flushed, state of this fiber is the alternate. Ideally
- // nothing should rely on this, but relying on it here means that we don't
- // need an additional field on the work in progress.
- var current = completedWork.alternate;
- var returnFiber = completedWork.return; // Check if the work completed or if something threw.
-
- if ((completedWork.flags & Incomplete) === NoFlags) {
- setCurrentFiber(completedWork);
- var next = void 0;
-
- if ( (completedWork.mode & ProfileMode) === NoMode) {
- next = completeWork(current, completedWork, subtreeRenderLanes);
- } else {
- startProfilerTimer(completedWork);
- next = completeWork(current, completedWork, subtreeRenderLanes); // Update render duration assuming we didn't error.
-
- stopProfilerTimerIfRunningAndRecordDelta(completedWork, false);
- }
-
- resetCurrentFiber();
-
- if (next !== null) {
- // Completing this fiber spawned new work. Work on that next.
- workInProgress = next;
- return;
- }
- } else {
- // This fiber did not complete because something threw. Pop values off
- // the stack without entering the complete phase. If this is a boundary,
- // capture values if possible.
- var _next = unwindWork(current, completedWork); // Because this fiber did not complete, don't reset its lanes.
-
-
- if (_next !== null) {
- // If completing this work spawned new work, do that next. We'll come
- // back here again.
- // Since we're restarting, remove anything that is not a host effect
- // from the effect tag.
- _next.flags &= HostEffectMask;
- workInProgress = _next;
- return;
- }
-
- if ( (completedWork.mode & ProfileMode) !== NoMode) {
- // Record the render duration for the fiber that errored.
- stopProfilerTimerIfRunningAndRecordDelta(completedWork, false); // Include the time spent working on failed children before continuing.
-
- var actualDuration = completedWork.actualDuration;
- var child = completedWork.child;
-
- while (child !== null) {
- actualDuration += child.actualDuration;
- child = child.sibling;
- }
-
- completedWork.actualDuration = actualDuration;
- }
-
- if (returnFiber !== null) {
- // Mark the parent fiber as incomplete and clear its subtree flags.
- returnFiber.flags |= Incomplete;
- returnFiber.subtreeFlags = NoFlags;
- returnFiber.deletions = null;
- } else {
- // We've unwound all the way to the root.
- workInProgressRootExitStatus = RootDidNotComplete;
- workInProgress = null;
- return;
- }
- }
-
- var siblingFiber = completedWork.sibling;
-
- if (siblingFiber !== null) {
- // If there is more work to do in this returnFiber, do that next.
- workInProgress = siblingFiber;
- return;
- } // Otherwise, return to the parent
-
-
- completedWork = returnFiber; // Update the next thing we're working on in case something throws.
-
- workInProgress = completedWork;
- } while (completedWork !== null); // We've reached the root.
-
-
- if (workInProgressRootExitStatus === RootInProgress) {
- workInProgressRootExitStatus = RootCompleted;
- }
- }
-
- function commitRoot(root, recoverableErrors, transitions) {
- // TODO: This no longer makes any sense. We already wrap the mutation and
- // layout phases. Should be able to remove.
- var previousUpdateLanePriority = getCurrentUpdatePriority();
- var prevTransition = ReactCurrentBatchConfig$3.transition;
-
- try {
- ReactCurrentBatchConfig$3.transition = null;
- setCurrentUpdatePriority(DiscreteEventPriority);
- commitRootImpl(root, recoverableErrors, transitions, previousUpdateLanePriority);
- } finally {
- ReactCurrentBatchConfig$3.transition = prevTransition;
- setCurrentUpdatePriority(previousUpdateLanePriority);
- }
-
- return null;
- }
-
- function commitRootImpl(root, recoverableErrors, transitions, renderPriorityLevel) {
- do {
- // `flushPassiveEffects` will call `flushSyncUpdateQueue` at the end, which
- // means `flushPassiveEffects` will sometimes result in additional
- // passive effects. So we need to keep flushing in a loop until there are
- // no more pending effects.
- // TODO: Might be better if `flushPassiveEffects` did not automatically
- // flush synchronous work at the end, to avoid factoring hazards like this.
- flushPassiveEffects();
- } while (rootWithPendingPassiveEffects !== null);
-
- flushRenderPhaseStrictModeWarningsInDEV();
-
- if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
- throw new Error('Should not already be working.');
- }
-
- var finishedWork = root.finishedWork;
- var lanes = root.finishedLanes;
-
- {
- markCommitStarted(lanes);
- }
-
- if (finishedWork === null) {
-
- {
- markCommitStopped();
- }
-
- return null;
- } else {
- {
- if (lanes === NoLanes) {
- error('root.finishedLanes should not be empty during a commit. This is a ' + 'bug in React.');
- }
- }
- }
-
- root.finishedWork = null;
- root.finishedLanes = NoLanes;
-
- if (finishedWork === root.current) {
- throw new Error('Cannot commit the same tree as before. This error is likely caused by ' + 'a bug in React. Please file an issue.');
- } // commitRoot never returns a continuation; it always finishes synchronously.
- // So we can clear these now to allow a new callback to be scheduled.
-
-
- root.callbackNode = null;
- root.callbackPriority = NoLane; // Update the first and last pending times on this root. The new first
- // pending time is whatever is left on the root fiber.
-
- var remainingLanes = mergeLanes(finishedWork.lanes, finishedWork.childLanes);
- markRootFinished(root, remainingLanes);
-
- if (root === workInProgressRoot) {
- // We can reset these now that they are finished.
- workInProgressRoot = null;
- workInProgress = null;
- workInProgressRootRenderLanes = NoLanes;
- } // If there are pending passive effects, schedule a callback to process them.
- // Do this as early as possible, so it is queued before anything else that
- // might get scheduled in the commit phase. (See #16714.)
- // TODO: Delete all other places that schedule the passive effect callback
- // They're redundant.
-
-
- if ((finishedWork.subtreeFlags & PassiveMask) !== NoFlags || (finishedWork.flags & PassiveMask) !== NoFlags) {
- if (!rootDoesHavePassiveEffects) {
- rootDoesHavePassiveEffects = true;
- // to store it in pendingPassiveTransitions until they get processed
- // We need to pass this through as an argument to commitRoot
- // because workInProgressTransitions might have changed between
- // the previous render and commit if we throttle the commit
- // with setTimeout
-
- pendingPassiveTransitions = transitions;
- scheduleCallback$1(NormalPriority, function () {
- flushPassiveEffects(); // This render triggered passive effects: release the root cache pool
- // *after* passive effects fire to avoid freeing a cache pool that may
- // be referenced by a node in the tree (HostRoot, Cache boundary etc)
-
- return null;
- });
- }
- } // Check if there are any effects in the whole tree.
- // TODO: This is left over from the effect list implementation, where we had
- // to check for the existence of `firstEffect` to satisfy Flow. I think the
- // only other reason this optimization exists is because it affects profiling.
- // Reconsider whether this is necessary.
-
-
- var subtreeHasEffects = (finishedWork.subtreeFlags & (BeforeMutationMask | MutationMask | LayoutMask | PassiveMask)) !== NoFlags;
- var rootHasEffect = (finishedWork.flags & (BeforeMutationMask | MutationMask | LayoutMask | PassiveMask)) !== NoFlags;
-
- if (subtreeHasEffects || rootHasEffect) {
- var prevTransition = ReactCurrentBatchConfig$3.transition;
- ReactCurrentBatchConfig$3.transition = null;
- var previousPriority = getCurrentUpdatePriority();
- setCurrentUpdatePriority(DiscreteEventPriority);
- var prevExecutionContext = executionContext;
- executionContext |= CommitContext; // Reset this to null before calling lifecycles
-
- ReactCurrentOwner$2.current = null; // The commit phase is broken into several sub-phases. We do a separate pass
- // of the effect list for each phase: all mutation effects come before all
- // layout effects, and so on.
- // The first phase a "before mutation" phase. We use this phase to read the
- // state of the host tree right before we mutate it. This is where
- // getSnapshotBeforeUpdate is called.
-
- var shouldFireAfterActiveInstanceBlur = commitBeforeMutationEffects(root, finishedWork);
-
- {
- // Mark the current commit time to be shared by all Profilers in this
- // batch. This enables them to be grouped later.
- recordCommitTime();
- }
-
-
- commitMutationEffects(root, finishedWork, lanes);
-
- resetAfterCommit(root.containerInfo); // The work-in-progress tree is now the current tree. This must come after
- // the mutation phase, so that the previous tree is still current during
- // componentWillUnmount, but before the layout phase, so that the finished
- // work is current during componentDidMount/Update.
-
- root.current = finishedWork; // The next phase is the layout phase, where we call effects that read
-
- {
- markLayoutEffectsStarted(lanes);
- }
-
- commitLayoutEffects(finishedWork, root, lanes);
-
- {
- markLayoutEffectsStopped();
- }
- // opportunity to paint.
-
-
- requestPaint();
- executionContext = prevExecutionContext; // Reset the priority to the previous non-sync value.
-
- setCurrentUpdatePriority(previousPriority);
- ReactCurrentBatchConfig$3.transition = prevTransition;
- } else {
- // No effects.
- root.current = finishedWork; // Measure these anyway so the flamegraph explicitly shows that there were
- // no effects.
- // TODO: Maybe there's a better way to report this.
-
- {
- recordCommitTime();
- }
- }
-
- var rootDidHavePassiveEffects = rootDoesHavePassiveEffects;
-
- if (rootDoesHavePassiveEffects) {
- // This commit has passive effects. Stash a reference to them. But don't
- // schedule a callback until after flushing layout work.
- rootDoesHavePassiveEffects = false;
- rootWithPendingPassiveEffects = root;
- pendingPassiveEffectsLanes = lanes;
- } else {
-
- {
- nestedPassiveUpdateCount = 0;
- rootWithPassiveNestedUpdates = null;
- }
- } // Read this again, since an effect might have updated it
-
-
- remainingLanes = root.pendingLanes; // Check if there's remaining work on this root
- // TODO: This is part of the `componentDidCatch` implementation. Its purpose
- // is to detect whether something might have called setState inside
- // `componentDidCatch`. The mechanism is known to be flawed because `setState`
- // inside `componentDidCatch` is itself flawed — that's why we recommend
- // `getDerivedStateFromError` instead. However, it could be improved by
- // checking if remainingLanes includes Sync work, instead of whether there's
- // any work remaining at all (which would also include stuff like Suspense
- // retries or transitions). It's been like this for a while, though, so fixing
- // it probably isn't that urgent.
-
- if (remainingLanes === NoLanes) {
- // If there's no remaining work, we can clear the set of already failed
- // error boundaries.
- legacyErrorBoundariesThatAlreadyFailed = null;
- }
-
- {
- if (!rootDidHavePassiveEffects) {
- commitDoubleInvokeEffectsInDEV(root.current, false);
- }
- }
-
- onCommitRoot(finishedWork.stateNode, renderPriorityLevel);
-
- {
- if (isDevToolsPresent) {
- root.memoizedUpdaters.clear();
- }
- }
-
- {
- onCommitRoot$1();
- } // Always call this before exiting `commitRoot`, to ensure that any
- // additional work on this root is scheduled.
-
-
- ensureRootIsScheduled(root, now());
-
- if (recoverableErrors !== null) {
- // There were errors during this render, but recovered from them without
- // needing to surface it to the UI. We log them here.
- var onRecoverableError = root.onRecoverableError;
-
- for (var i = 0; i < recoverableErrors.length; i++) {
- var recoverableError = recoverableErrors[i];
- var componentStack = recoverableError.stack;
- var digest = recoverableError.digest;
- onRecoverableError(recoverableError.value, {
- componentStack: componentStack,
- digest: digest
- });
- }
- }
-
- if (hasUncaughtError) {
- hasUncaughtError = false;
- var error$1 = firstUncaughtError;
- firstUncaughtError = null;
- throw error$1;
- } // If the passive effects are the result of a discrete render, flush them
- // synchronously at the end of the current task so that the result is
- // immediately observable. Otherwise, we assume that they are not
- // order-dependent and do not need to be observed by external systems, so we
- // can wait until after paint.
- // TODO: We can optimize this by not scheduling the callback earlier. Since we
- // currently schedule the callback in multiple places, will wait until those
- // are consolidated.
-
-
- if (includesSomeLane(pendingPassiveEffectsLanes, SyncLane) && root.tag !== LegacyRoot) {
- flushPassiveEffects();
- } // Read this again, since a passive effect might have updated it
-
-
- remainingLanes = root.pendingLanes;
-
- if (includesSomeLane(remainingLanes, SyncLane)) {
- {
- markNestedUpdateScheduled();
- } // Count the number of times the root synchronously re-renders without
- // finishing. If there are too many, it indicates an infinite update loop.
-
-
- if (root === rootWithNestedUpdates) {
- nestedUpdateCount++;
- } else {
- nestedUpdateCount = 0;
- rootWithNestedUpdates = root;
- }
- } else {
- nestedUpdateCount = 0;
- } // If layout work was scheduled, flush it now.
-
-
- flushSyncCallbacks();
-
- {
- markCommitStopped();
- }
-
- return null;
- }
-
- function flushPassiveEffects() {
- // Returns whether passive effects were flushed.
- // TODO: Combine this check with the one in flushPassiveEFfectsImpl. We should
- // probably just combine the two functions. I believe they were only separate
- // in the first place because we used to wrap it with
- // `Scheduler.runWithPriority`, which accepts a function. But now we track the
- // priority within React itself, so we can mutate the variable directly.
- if (rootWithPendingPassiveEffects !== null) {
- var renderPriority = lanesToEventPriority(pendingPassiveEffectsLanes);
- var priority = lowerEventPriority(DefaultEventPriority, renderPriority);
- var prevTransition = ReactCurrentBatchConfig$3.transition;
- var previousPriority = getCurrentUpdatePriority();
-
- try {
- ReactCurrentBatchConfig$3.transition = null;
- setCurrentUpdatePriority(priority);
- return flushPassiveEffectsImpl();
- } finally {
- setCurrentUpdatePriority(previousPriority);
- ReactCurrentBatchConfig$3.transition = prevTransition; // Once passive effects have run for the tree - giving components a
- }
- }
-
- return false;
- }
- function enqueuePendingPassiveProfilerEffect(fiber) {
- {
- pendingPassiveProfilerEffects.push(fiber);
-
- if (!rootDoesHavePassiveEffects) {
- rootDoesHavePassiveEffects = true;
- scheduleCallback$1(NormalPriority, function () {
- flushPassiveEffects();
- return null;
- });
- }
- }
- }
-
- function flushPassiveEffectsImpl() {
- if (rootWithPendingPassiveEffects === null) {
- return false;
- } // Cache and clear the transitions flag
-
-
- var transitions = pendingPassiveTransitions;
- pendingPassiveTransitions = null;
- var root = rootWithPendingPassiveEffects;
- var lanes = pendingPassiveEffectsLanes;
- rootWithPendingPassiveEffects = null; // TODO: This is sometimes out of sync with rootWithPendingPassiveEffects.
- // Figure out why and fix it. It's not causing any known issues (probably
- // because it's only used for profiling), but it's a refactor hazard.
-
- pendingPassiveEffectsLanes = NoLanes;
-
- if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
- throw new Error('Cannot flush passive effects while already rendering.');
- }
-
- {
- isFlushingPassiveEffects = true;
- didScheduleUpdateDuringPassiveEffects = false;
- }
-
- {
- markPassiveEffectsStarted(lanes);
- }
-
- var prevExecutionContext = executionContext;
- executionContext |= CommitContext;
- commitPassiveUnmountEffects(root.current);
- commitPassiveMountEffects(root, root.current, lanes, transitions); // TODO: Move to commitPassiveMountEffects
-
- {
- var profilerEffects = pendingPassiveProfilerEffects;
- pendingPassiveProfilerEffects = [];
-
- for (var i = 0; i < profilerEffects.length; i++) {
- var _fiber = profilerEffects[i];
- commitPassiveEffectDurations(root, _fiber);
- }
- }
-
- {
- markPassiveEffectsStopped();
- }
-
- {
- commitDoubleInvokeEffectsInDEV(root.current, true);
- }
-
- executionContext = prevExecutionContext;
- flushSyncCallbacks();
-
- {
- // If additional passive effects were scheduled, increment a counter. If this
- // exceeds the limit, we'll fire a warning.
- if (didScheduleUpdateDuringPassiveEffects) {
- if (root === rootWithPassiveNestedUpdates) {
- nestedPassiveUpdateCount++;
- } else {
- nestedPassiveUpdateCount = 0;
- rootWithPassiveNestedUpdates = root;
- }
- } else {
- nestedPassiveUpdateCount = 0;
- }
-
- isFlushingPassiveEffects = false;
- didScheduleUpdateDuringPassiveEffects = false;
- } // TODO: Move to commitPassiveMountEffects
-
-
- onPostCommitRoot(root);
-
- {
- var stateNode = root.current.stateNode;
- stateNode.effectDuration = 0;
- stateNode.passiveEffectDuration = 0;
- }
-
- return true;
- }
-
- function isAlreadyFailedLegacyErrorBoundary(instance) {
- return legacyErrorBoundariesThatAlreadyFailed !== null && legacyErrorBoundariesThatAlreadyFailed.has(instance);
- }
- function markLegacyErrorBoundaryAsFailed(instance) {
- if (legacyErrorBoundariesThatAlreadyFailed === null) {
- legacyErrorBoundariesThatAlreadyFailed = new Set([instance]);
- } else {
- legacyErrorBoundariesThatAlreadyFailed.add(instance);
- }
- }
-
- function prepareToThrowUncaughtError(error) {
- if (!hasUncaughtError) {
- hasUncaughtError = true;
- firstUncaughtError = error;
- }
- }
-
- var onUncaughtError = prepareToThrowUncaughtError;
-
- function captureCommitPhaseErrorOnRoot(rootFiber, sourceFiber, error) {
- var errorInfo = createCapturedValueAtFiber(error, sourceFiber);
- var update = createRootErrorUpdate(rootFiber, errorInfo, SyncLane);
- var root = enqueueUpdate(rootFiber, update, SyncLane);
- var eventTime = requestEventTime();
-
- if (root !== null) {
- markRootUpdated(root, SyncLane, eventTime);
- ensureRootIsScheduled(root, eventTime);
- }
- }
-
- function captureCommitPhaseError(sourceFiber, nearestMountedAncestor, error$1) {
- {
- reportUncaughtErrorInDEV(error$1);
- setIsRunningInsertionEffect(false);
- }
-
- if (sourceFiber.tag === HostRoot) {
- // Error was thrown at the root. There is no parent, so the root
- // itself should capture it.
- captureCommitPhaseErrorOnRoot(sourceFiber, sourceFiber, error$1);
- return;
- }
-
- var fiber = null;
-
- {
- fiber = nearestMountedAncestor;
- }
-
- while (fiber !== null) {
- if (fiber.tag === HostRoot) {
- captureCommitPhaseErrorOnRoot(fiber, sourceFiber, error$1);
- return;
- } else if (fiber.tag === ClassComponent) {
- var ctor = fiber.type;
- var instance = fiber.stateNode;
-
- if (typeof ctor.getDerivedStateFromError === 'function' || typeof instance.componentDidCatch === 'function' && !isAlreadyFailedLegacyErrorBoundary(instance)) {
- var errorInfo = createCapturedValueAtFiber(error$1, sourceFiber);
- var update = createClassErrorUpdate(fiber, errorInfo, SyncLane);
- var root = enqueueUpdate(fiber, update, SyncLane);
- var eventTime = requestEventTime();
-
- if (root !== null) {
- markRootUpdated(root, SyncLane, eventTime);
- ensureRootIsScheduled(root, eventTime);
- }
-
- return;
- }
- }
-
- fiber = fiber.return;
- }
-
- {
- // TODO: Until we re-land skipUnmountedBoundaries (see #20147), this warning
- // will fire for errors that are thrown by destroy functions inside deleted
- // trees. What it should instead do is propagate the error to the parent of
- // the deleted tree. In the meantime, do not add this warning to the
- // allowlist; this is only for our internal use.
- error('Internal React error: Attempted to capture a commit phase error ' + 'inside a detached tree. This indicates a bug in React. Likely ' + 'causes include deleting the same fiber more than once, committing an ' + 'already-finished tree, or an inconsistent return pointer.\n\n' + 'Error message:\n\n%s', error$1);
- }
- }
- function pingSuspendedRoot(root, wakeable, pingedLanes) {
- var pingCache = root.pingCache;
-
- if (pingCache !== null) {
- // The wakeable resolved, so we no longer need to memoize, because it will
- // never be thrown again.
- pingCache.delete(wakeable);
- }
-
- var eventTime = requestEventTime();
- markRootPinged(root, pingedLanes);
- warnIfSuspenseResolutionNotWrappedWithActDEV(root);
-
- if (workInProgressRoot === root && isSubsetOfLanes(workInProgressRootRenderLanes, pingedLanes)) {
- // Received a ping at the same priority level at which we're currently
- // rendering. We might want to restart this render. This should mirror
- // the logic of whether or not a root suspends once it completes.
- // TODO: If we're rendering sync either due to Sync, Batched or expired,
- // we should probably never restart.
- // If we're suspended with delay, or if it's a retry, we'll always suspend
- // so we can always restart.
- if (workInProgressRootExitStatus === RootSuspendedWithDelay || workInProgressRootExitStatus === RootSuspended && includesOnlyRetries(workInProgressRootRenderLanes) && now() - globalMostRecentFallbackTime < FALLBACK_THROTTLE_MS) {
- // Restart from the root.
- prepareFreshStack(root, NoLanes);
- } else {
- // Even though we can't restart right now, we might get an
- // opportunity later. So we mark this render as having a ping.
- workInProgressRootPingedLanes = mergeLanes(workInProgressRootPingedLanes, pingedLanes);
- }
- }
-
- ensureRootIsScheduled(root, eventTime);
- }
-
- function retryTimedOutBoundary(boundaryFiber, retryLane) {
- // The boundary fiber (a Suspense component or SuspenseList component)
- // previously was rendered in its fallback state. One of the promises that
- // suspended it has resolved, which means at least part of the tree was
- // likely unblocked. Try rendering again, at a new lanes.
- if (retryLane === NoLane) {
- // TODO: Assign this to `suspenseState.retryLane`? to avoid
- // unnecessary entanglement?
- retryLane = requestRetryLane(boundaryFiber);
- } // TODO: Special case idle priority?
-
-
- var eventTime = requestEventTime();
- var root = enqueueConcurrentRenderForLane(boundaryFiber, retryLane);
-
- if (root !== null) {
- markRootUpdated(root, retryLane, eventTime);
- ensureRootIsScheduled(root, eventTime);
- }
- }
-
- function retryDehydratedSuspenseBoundary(boundaryFiber) {
- var suspenseState = boundaryFiber.memoizedState;
- var retryLane = NoLane;
-
- if (suspenseState !== null) {
- retryLane = suspenseState.retryLane;
- }
-
- retryTimedOutBoundary(boundaryFiber, retryLane);
- }
- function resolveRetryWakeable(boundaryFiber, wakeable) {
- var retryLane = NoLane; // Default
-
- var retryCache;
-
- switch (boundaryFiber.tag) {
- case SuspenseComponent:
- retryCache = boundaryFiber.stateNode;
- var suspenseState = boundaryFiber.memoizedState;
-
- if (suspenseState !== null) {
- retryLane = suspenseState.retryLane;
- }
-
- break;
-
- case SuspenseListComponent:
- retryCache = boundaryFiber.stateNode;
- break;
-
- default:
- throw new Error('Pinged unknown suspense boundary type. ' + 'This is probably a bug in React.');
- }
-
- if (retryCache !== null) {
- // The wakeable resolved, so we no longer need to memoize, because it will
- // never be thrown again.
- retryCache.delete(wakeable);
- }
-
- retryTimedOutBoundary(boundaryFiber, retryLane);
- } // Computes the next Just Noticeable Difference (JND) boundary.
- // The theory is that a person can't tell the difference between small differences in time.
- // Therefore, if we wait a bit longer than necessary that won't translate to a noticeable
- // difference in the experience. However, waiting for longer might mean that we can avoid
- // showing an intermediate loading state. The longer we have already waited, the harder it
- // is to tell small differences in time. Therefore, the longer we've already waited,
- // the longer we can wait additionally. At some point we have to give up though.
- // We pick a train model where the next boundary commits at a consistent schedule.
- // These particular numbers are vague estimates. We expect to adjust them based on research.
-
- function jnd(timeElapsed) {
- return timeElapsed < 120 ? 120 : timeElapsed < 480 ? 480 : timeElapsed < 1080 ? 1080 : timeElapsed < 1920 ? 1920 : timeElapsed < 3000 ? 3000 : timeElapsed < 4320 ? 4320 : ceil(timeElapsed / 1960) * 1960;
- }
-
- function checkForNestedUpdates() {
- if (nestedUpdateCount > NESTED_UPDATE_LIMIT) {
- nestedUpdateCount = 0;
- rootWithNestedUpdates = null;
- throw new Error('Maximum update depth exceeded. This can happen when a component ' + 'repeatedly calls setState inside componentWillUpdate or ' + 'componentDidUpdate. React limits the number of nested updates to ' + 'prevent infinite loops.');
- }
-
- {
- if (nestedPassiveUpdateCount > NESTED_PASSIVE_UPDATE_LIMIT) {
- nestedPassiveUpdateCount = 0;
- rootWithPassiveNestedUpdates = null;
-
- error('Maximum update depth exceeded. This can happen when a component ' + "calls setState inside useEffect, but useEffect either doesn't " + 'have a dependency array, or one of the dependencies changes on ' + 'every render.');
- }
- }
- }
-
- function flushRenderPhaseStrictModeWarningsInDEV() {
- {
- ReactStrictModeWarnings.flushLegacyContextWarning();
-
- {
- ReactStrictModeWarnings.flushPendingUnsafeLifecycleWarnings();
- }
- }
- }
-
- function commitDoubleInvokeEffectsInDEV(fiber, hasPassiveEffects) {
- {
- // TODO (StrictEffects) Should we set a marker on the root if it contains strict effects
- // so we don't traverse unnecessarily? similar to subtreeFlags but just at the root level.
- // Maybe not a big deal since this is DEV only behavior.
- setCurrentFiber(fiber);
- invokeEffectsInDev(fiber, MountLayoutDev, invokeLayoutEffectUnmountInDEV);
-
- if (hasPassiveEffects) {
- invokeEffectsInDev(fiber, MountPassiveDev, invokePassiveEffectUnmountInDEV);
- }
-
- invokeEffectsInDev(fiber, MountLayoutDev, invokeLayoutEffectMountInDEV);
-
- if (hasPassiveEffects) {
- invokeEffectsInDev(fiber, MountPassiveDev, invokePassiveEffectMountInDEV);
- }
-
- resetCurrentFiber();
- }
- }
-
- function invokeEffectsInDev(firstChild, fiberFlags, invokeEffectFn) {
- {
- // We don't need to re-check StrictEffectsMode here.
- // This function is only called if that check has already passed.
- var current = firstChild;
- var subtreeRoot = null;
-
- while (current !== null) {
- var primarySubtreeFlag = current.subtreeFlags & fiberFlags;
-
- if (current !== subtreeRoot && current.child !== null && primarySubtreeFlag !== NoFlags) {
- current = current.child;
- } else {
- if ((current.flags & fiberFlags) !== NoFlags) {
- invokeEffectFn(current);
- }
-
- if (current.sibling !== null) {
- current = current.sibling;
- } else {
- current = subtreeRoot = current.return;
- }
- }
- }
- }
- }
-
- var didWarnStateUpdateForNotYetMountedComponent = null;
- function warnAboutUpdateOnNotYetMountedFiberInDEV(fiber) {
- {
- if ((executionContext & RenderContext) !== NoContext) {
- // We let the other warning about render phase updates deal with this one.
- return;
- }
-
- if (!(fiber.mode & ConcurrentMode)) {
- return;
- }
-
- var tag = fiber.tag;
-
- if (tag !== IndeterminateComponent && tag !== HostRoot && tag !== ClassComponent && tag !== FunctionComponent && tag !== ForwardRef && tag !== MemoComponent && tag !== SimpleMemoComponent) {
- // Only warn for user-defined components, not internal ones like Suspense.
- return;
- } // We show the whole stack but dedupe on the top component's name because
- // the problematic code almost always lies inside that component.
-
-
- var componentName = getComponentNameFromFiber(fiber) || 'ReactComponent';
-
- if (didWarnStateUpdateForNotYetMountedComponent !== null) {
- if (didWarnStateUpdateForNotYetMountedComponent.has(componentName)) {
- return;
- }
-
- didWarnStateUpdateForNotYetMountedComponent.add(componentName);
- } else {
- didWarnStateUpdateForNotYetMountedComponent = new Set([componentName]);
- }
-
- var previousFiber = current;
-
- try {
- setCurrentFiber(fiber);
-
- error("Can't perform a React state update on a component that hasn't mounted yet. " + 'This indicates that you have a side-effect in your render function that ' + 'asynchronously later calls tries to update the component. Move this work to ' + 'useEffect instead.');
- } finally {
- if (previousFiber) {
- setCurrentFiber(fiber);
- } else {
- resetCurrentFiber();
- }
- }
- }
- }
- var beginWork$1;
-
- {
- var dummyFiber = null;
-
- beginWork$1 = function (current, unitOfWork, lanes) {
- // If a component throws an error, we replay it again in a synchronously
- // dispatched event, so that the debugger will treat it as an uncaught
- // error See ReactErrorUtils for more information.
- // Before entering the begin phase, copy the work-in-progress onto a dummy
- // fiber. If beginWork throws, we'll use this to reset the state.
- var originalWorkInProgressCopy = assignFiberPropertiesInDEV(dummyFiber, unitOfWork);
-
- try {
- return beginWork(current, unitOfWork, lanes);
- } catch (originalError) {
- if (didSuspendOrErrorWhileHydratingDEV() || originalError !== null && typeof originalError === 'object' && typeof originalError.then === 'function') {
- // Don't replay promises.
- // Don't replay errors if we are hydrating and have already suspended or handled an error
- throw originalError;
- } // Keep this code in sync with handleError; any changes here must have
- // corresponding changes there.
-
-
- resetContextDependencies();
- resetHooksAfterThrow(); // Don't reset current debug fiber, since we're about to work on the
- // same fiber again.
- // Unwind the failed stack frame
-
- unwindInterruptedWork(current, unitOfWork); // Restore the original properties of the fiber.
-
- assignFiberPropertiesInDEV(unitOfWork, originalWorkInProgressCopy);
-
- if ( unitOfWork.mode & ProfileMode) {
- // Reset the profiler timer.
- startProfilerTimer(unitOfWork);
- } // Run beginWork again.
-
-
- invokeGuardedCallback(null, beginWork, null, current, unitOfWork, lanes);
-
- if (hasCaughtError()) {
- var replayError = clearCaughtError();
-
- if (typeof replayError === 'object' && replayError !== null && replayError._suppressLogging && typeof originalError === 'object' && originalError !== null && !originalError._suppressLogging) {
- // If suppressed, let the flag carry over to the original error which is the one we'll rethrow.
- originalError._suppressLogging = true;
- }
- } // We always throw the original error in case the second render pass is not idempotent.
- // This can happen if a memoized function or CommonJS module doesn't throw after first invocation.
-
-
- throw originalError;
- }
- };
- }
-
- var didWarnAboutUpdateInRender = false;
- var didWarnAboutUpdateInRenderForAnotherComponent;
-
- {
- didWarnAboutUpdateInRenderForAnotherComponent = new Set();
- }
-
- function warnAboutRenderPhaseUpdatesInDEV(fiber) {
- {
- if (isRendering && !getIsUpdatingOpaqueValueInRenderPhaseInDEV()) {
- switch (fiber.tag) {
- case FunctionComponent:
- case ForwardRef:
- case SimpleMemoComponent:
- {
- var renderingComponentName = workInProgress && getComponentNameFromFiber(workInProgress) || 'Unknown'; // Dedupe by the rendering component because it's the one that needs to be fixed.
-
- var dedupeKey = renderingComponentName;
-
- if (!didWarnAboutUpdateInRenderForAnotherComponent.has(dedupeKey)) {
- didWarnAboutUpdateInRenderForAnotherComponent.add(dedupeKey);
- var setStateComponentName = getComponentNameFromFiber(fiber) || 'Unknown';
-
- error('Cannot update a component (`%s`) while rendering a ' + 'Different component (`%s`). To locate the bad setState() call inside `%s`, ' + 'follow the stack trace as described in https://reactjs.org/link/setstate-in-render', setStateComponentName, renderingComponentName, renderingComponentName);
- }
-
- break;
- }
-
- case ClassComponent:
- {
- if (!didWarnAboutUpdateInRender) {
- error('Cannot update during an existing state transition (such as ' + 'within `render`). Render methods should be a pure ' + 'function of props and state.');
-
- didWarnAboutUpdateInRender = true;
- }
-
- break;
- }
- }
- }
- }
- }
-
- function restorePendingUpdaters(root, lanes) {
- {
- if (isDevToolsPresent) {
- var memoizedUpdaters = root.memoizedUpdaters;
- memoizedUpdaters.forEach(function (schedulingFiber) {
- addFiberToLanesMap(root, schedulingFiber, lanes);
- }); // This function intentionally does not clear memoized updaters.
- // Those may still be relevant to the current commit
- // and a future one (e.g. Suspense).
- }
- }
- }
- var fakeActCallbackNode = {};
-
- function scheduleCallback$1(priorityLevel, callback) {
- {
- // If we're currently inside an `act` scope, bypass Scheduler and push to
- // the `act` queue instead.
- var actQueue = ReactCurrentActQueue$1.current;
-
- if (actQueue !== null) {
- actQueue.push(callback);
- return fakeActCallbackNode;
- } else {
- return scheduleCallback(priorityLevel, callback);
- }
- }
- }
-
- function cancelCallback$1(callbackNode) {
- if ( callbackNode === fakeActCallbackNode) {
- return;
- } // In production, always call Scheduler. This function will be stripped out.
-
-
- return cancelCallback(callbackNode);
- }
-
- function shouldForceFlushFallbacksInDEV() {
- // Never force flush in production. This function should get stripped out.
- return ReactCurrentActQueue$1.current !== null;
- }
-
- function warnIfUpdatesNotWrappedWithActDEV(fiber) {
- {
- if (fiber.mode & ConcurrentMode) {
- if (!isConcurrentActEnvironment()) {
- // Not in an act environment. No need to warn.
- return;
- }
- } else {
- // Legacy mode has additional cases where we suppress a warning.
- if (!isLegacyActEnvironment()) {
- // Not in an act environment. No need to warn.
- return;
- }
-
- if (executionContext !== NoContext) {
- // Legacy mode doesn't warn if the update is batched, i.e.
- // batchedUpdates or flushSync.
- return;
- }
-
- if (fiber.tag !== FunctionComponent && fiber.tag !== ForwardRef && fiber.tag !== SimpleMemoComponent) {
- // For backwards compatibility with pre-hooks code, legacy mode only
- // warns for updates that originate from a hook.
- return;
- }
- }
-
- if (ReactCurrentActQueue$1.current === null) {
- var previousFiber = current;
-
- try {
- setCurrentFiber(fiber);
-
- error('An update to %s inside a test was not wrapped in act(...).\n\n' + 'When testing, code that causes React state updates should be ' + 'wrapped into act(...):\n\n' + 'act(() => {\n' + ' /* fire events that update state */\n' + '});\n' + '/* assert on the output */\n\n' + "This ensures that you're testing the behavior the user would see " + 'in the browser.' + ' Learn more at https://reactjs.org/link/wrap-tests-with-act', getComponentNameFromFiber(fiber));
- } finally {
- if (previousFiber) {
- setCurrentFiber(fiber);
- } else {
- resetCurrentFiber();
- }
- }
- }
- }
- }
-
- function warnIfSuspenseResolutionNotWrappedWithActDEV(root) {
- {
- if (root.tag !== LegacyRoot && isConcurrentActEnvironment() && ReactCurrentActQueue$1.current === null) {
- error('A suspended resource finished loading inside a test, but the event ' + 'was not wrapped in act(...).\n\n' + 'When testing, code that resolves suspended data should be wrapped ' + 'into act(...):\n\n' + 'act(() => {\n' + ' /* finish loading suspended data */\n' + '});\n' + '/* assert on the output */\n\n' + "This ensures that you're testing the behavior the user would see " + 'in the browser.' + ' Learn more at https://reactjs.org/link/wrap-tests-with-act');
- }
- }
- }
-
- function setIsRunningInsertionEffect(isRunning) {
- {
- isRunningInsertionEffect = isRunning;
- }
- }
-
- /* eslint-disable react-internal/prod-error-codes */
- var resolveFamily = null; // $FlowFixMe Flow gets confused by a WeakSet feature check below.
-
- var failedBoundaries = null;
- var setRefreshHandler = function (handler) {
- {
- resolveFamily = handler;
- }
- };
- function resolveFunctionForHotReloading(type) {
- {
- if (resolveFamily === null) {
- // Hot reloading is disabled.
- return type;
- }
-
- var family = resolveFamily(type);
-
- if (family === undefined) {
- return type;
- } // Use the latest known implementation.
-
-
- return family.current;
- }
- }
- function resolveClassForHotReloading(type) {
- // No implementation differences.
- return resolveFunctionForHotReloading(type);
- }
- function resolveForwardRefForHotReloading(type) {
- {
- if (resolveFamily === null) {
- // Hot reloading is disabled.
- return type;
- }
-
- var family = resolveFamily(type);
-
- if (family === undefined) {
- // Check if we're dealing with a real forwardRef. Don't want to crash early.
- if (type !== null && type !== undefined && typeof type.render === 'function') {
- // ForwardRef is special because its resolved .type is an object,
- // but it's possible that we only have its inner render function in the map.
- // If that inner render function is Different, we'll build a new forwardRef type.
- var currentRender = resolveFunctionForHotReloading(type.render);
-
- if (type.render !== currentRender) {
- var syntheticType = {
- $$typeof: REACT_FORWARD_REF_TYPE,
- render: currentRender
- };
-
- if (type.displayName !== undefined) {
- syntheticType.displayName = type.displayName;
- }
-
- return syntheticType;
- }
- }
-
- return type;
- } // Use the latest known implementation.
-
-
- return family.current;
- }
- }
- function isCompatibleFamilyForHotReloading(fiber, element) {
- {
- if (resolveFamily === null) {
- // Hot reloading is disabled.
- return false;
- }
-
- var prevType = fiber.elementType;
- var nextType = element.type; // If we got here, we know types aren't === equal.
-
- var needsCompareFamilies = false;
- var $$typeofNextType = typeof nextType === 'object' && nextType !== null ? nextType.$$typeof : null;
-
- switch (fiber.tag) {
- case ClassComponent:
- {
- if (typeof nextType === 'function') {
- needsCompareFamilies = true;
- }
-
- break;
- }
-
- case FunctionComponent:
- {
- if (typeof nextType === 'function') {
- needsCompareFamilies = true;
- } else if ($$typeofNextType === REACT_LAZY_TYPE) {
- // We don't know the inner type yet.
- // We're going to assume that the lazy inner type is stable,
- // and so it is sufficient to avoid reconciling it away.
- // We're not going to unwrap or actually use the new lazy type.
- needsCompareFamilies = true;
- }
-
- break;
- }
-
- case ForwardRef:
- {
- if ($$typeofNextType === REACT_FORWARD_REF_TYPE) {
- needsCompareFamilies = true;
- } else if ($$typeofNextType === REACT_LAZY_TYPE) {
- needsCompareFamilies = true;
- }
-
- break;
- }
-
- case MemoComponent:
- case SimpleMemoComponent:
- {
- if ($$typeofNextType === REACT_MEMO_TYPE) {
- // TODO: if it was but can no longer be simple,
- // we shouldn't set this.
- needsCompareFamilies = true;
- } else if ($$typeofNextType === REACT_LAZY_TYPE) {
- needsCompareFamilies = true;
- }
-
- break;
- }
-
- default:
- return false;
- } // Check if both types have a family and it's the same one.
-
-
- if (needsCompareFamilies) {
- // Note: memo() and forwardRef() we'll compare outer rather than inner type.
- // This means both of them need to be registered to preserve state.
- // If we unwrapped and compared the inner types for wrappers instead,
- // then we would risk falsely saying two separate memo(Foo)
- // calls are equivalent because they wrap the same Foo function.
- var prevFamily = resolveFamily(prevType);
-
- if (prevFamily !== undefined && prevFamily === resolveFamily(nextType)) {
- return true;
- }
- }
-
- return false;
- }
- }
- function markFailedErrorBoundaryForHotReloading(fiber) {
- {
- if (resolveFamily === null) {
- // Hot reloading is disabled.
- return;
- }
-
- if (typeof WeakSet !== 'function') {
- return;
- }
-
- if (failedBoundaries === null) {
- failedBoundaries = new WeakSet();
- }
-
- failedBoundaries.add(fiber);
- }
- }
- var scheduleRefresh = function (root, update) {
- {
- if (resolveFamily === null) {
- // Hot reloading is disabled.
- return;
- }
-
- var staleFamilies = update.staleFamilies,
- updatedFamilies = update.updatedFamilies;
- flushPassiveEffects();
- flushSync(function () {
- scheduleFibersWithFamiliesRecursively(root.current, updatedFamilies, staleFamilies);
- });
- }
- };
- var scheduleRoot = function (root, element) {
- {
- if (root.context !== emptyContextObject) {
- // Super edge case: root has a legacy _renderSubtree context
- // but we don't know the parentComponent so we can't pass it.
- // Just ignore. We'll delete this with _renderSubtree code path later.
- return;
- }
-
- flushPassiveEffects();
- flushSync(function () {
- updateContainer(element, root, null, null);
- });
- }
- };
-
- function scheduleFibersWithFamiliesRecursively(fiber, updatedFamilies, staleFamilies) {
- {
- var alternate = fiber.alternate,
- child = fiber.child,
- sibling = fiber.sibling,
- tag = fiber.tag,
- type = fiber.type;
- var candidateType = null;
-
- switch (tag) {
- case FunctionComponent:
- case SimpleMemoComponent:
- case ClassComponent:
- candidateType = type;
- break;
-
- case ForwardRef:
- candidateType = type.render;
- break;
- }
-
- if (resolveFamily === null) {
- throw new Error('Expected resolveFamily to be set during hot reload.');
- }
-
- var needsRender = false;
- var needsRemount = false;
-
- if (candidateType !== null) {
- var family = resolveFamily(candidateType);
-
- if (family !== undefined) {
- if (staleFamilies.has(family)) {
- needsRemount = true;
- } else if (updatedFamilies.has(family)) {
- if (tag === ClassComponent) {
- needsRemount = true;
- } else {
- needsRender = true;
- }
- }
- }
- }
-
- if (failedBoundaries !== null) {
- if (failedBoundaries.has(fiber) || alternate !== null && failedBoundaries.has(alternate)) {
- needsRemount = true;
- }
- }
-
- if (needsRemount) {
- fiber._debugNeedsRemount = true;
- }
-
- if (needsRemount || needsRender) {
- var _root = enqueueConcurrentRenderForLane(fiber, SyncLane);
-
- if (_root !== null) {
- scheduleUpdateOnFiber(_root, fiber, SyncLane, NoTimestamp);
- }
- }
-
- if (child !== null && !needsRemount) {
- scheduleFibersWithFamiliesRecursively(child, updatedFamilies, staleFamilies);
- }
-
- if (sibling !== null) {
- scheduleFibersWithFamiliesRecursively(sibling, updatedFamilies, staleFamilies);
- }
- }
- }
-
- var findHostInstancesForRefresh = function (root, families) {
- {
- var hostInstances = new Set();
- var types = new Set(families.map(function (family) {
- return family.current;
- }));
- findHostInstancesForMatchingFibersRecursively(root.current, types, hostInstances);
- return hostInstances;
- }
- };
-
- function findHostInstancesForMatchingFibersRecursively(fiber, types, hostInstances) {
- {
- var child = fiber.child,
- sibling = fiber.sibling,
- tag = fiber.tag,
- type = fiber.type;
- var candidateType = null;
-
- switch (tag) {
- case FunctionComponent:
- case SimpleMemoComponent:
- case ClassComponent:
- candidateType = type;
- break;
-
- case ForwardRef:
- candidateType = type.render;
- break;
- }
-
- var didMatch = false;
-
- if (candidateType !== null) {
- if (types.has(candidateType)) {
- didMatch = true;
- }
- }
-
- if (didMatch) {
- // We have a match. This only drills down to the closest host components.
- // There's no need to search deeper because for the purpose of giving
- // visual feedback, "flashing" outermost parent rectangles is sufficient.
- findHostInstancesForFiberShallowly(fiber, hostInstances);
- } else {
- // If there's no match, maybe there will be one further down in the child tree.
- if (child !== null) {
- findHostInstancesForMatchingFibersRecursively(child, types, hostInstances);
- }
- }
-
- if (sibling !== null) {
- findHostInstancesForMatchingFibersRecursively(sibling, types, hostInstances);
- }
- }
- }
-
- function findHostInstancesForFiberShallowly(fiber, hostInstances) {
- {
- var foundHostInstances = findChildHostInstancesForFiberShallowly(fiber, hostInstances);
-
- if (foundHostInstances) {
- return;
- } // If we didn't find any host children, fallback to closest host parent.
-
-
- var node = fiber;
-
- while (true) {
- switch (node.tag) {
- case HostComponent:
- hostInstances.add(node.stateNode);
- return;
-
- case HostPortal:
- hostInstances.add(node.stateNode.containerInfo);
- return;
-
- case HostRoot:
- hostInstances.add(node.stateNode.containerInfo);
- return;
- }
-
- if (node.return === null) {
- throw new Error('Expected to reach root first.');
- }
-
- node = node.return;
- }
- }
- }
-
- function findChildHostInstancesForFiberShallowly(fiber, hostInstances) {
- {
- var node = fiber;
- var foundHostInstances = false;
-
- while (true) {
- if (node.tag === HostComponent) {
- // We got a match.
- foundHostInstances = true;
- hostInstances.add(node.stateNode); // There may still be more, so keep searching.
- } else if (node.child !== null) {
- node.child.return = node;
- node = node.child;
- continue;
- }
-
- if (node === fiber) {
- return foundHostInstances;
- }
-
- while (node.sibling === null) {
- if (node.return === null || node.return === fiber) {
- return foundHostInstances;
- }
-
- node = node.return;
- }
-
- node.sibling.return = node.return;
- node = node.sibling;
- }
- }
-
- return false;
- }
-
- var hasBadMapPolyfill;
-
- {
- hasBadMapPolyfill = false;
-
- try {
- var nonExtensibleObject = Object.preventExtensions({});
- /* eslint-disable no-new */
-
- new Map([[nonExtensibleObject, null]]);
- new Set([nonExtensibleObject]);
- /* eslint-enable no-new */
- } catch (e) {
- // TODO: Consider warning about bad polyfills
- hasBadMapPolyfill = true;
- }
- }
-
- function FiberNode(tag, pendingProps, key, mode) {
- // Instance
- this.tag = tag;
- this.key = key;
- this.elementType = null;
- this.type = null;
- this.stateNode = null; // Fiber
-
- this.return = null;
- this.child = null;
- this.sibling = null;
- this.index = 0;
- this.ref = null;
- this.pendingProps = pendingProps;
- this.memoizedProps = null;
- this.updateQueue = null;
- this.memoizedState = null;
- this.dependencies = null;
- this.mode = mode; // Effects
-
- this.flags = NoFlags;
- this.subtreeFlags = NoFlags;
- this.deletions = null;
- this.lanes = NoLanes;
- this.childLanes = NoLanes;
- this.alternate = null;
-
- {
- // Note: The following is done to avoid a v8 performance cliff.
- //
- // Initializing the fields below to smis and later updating them with
- // double values will cause Fibers to end up having separate shapes.
- // This behavior/bug has something to do with Object.preventExtension().
- // Fortunately this only impacts DEV builds.
- // Unfortunately it makes React unusably slow for some applications.
- // To work around this, initialize the fields below with doubles.
- //
- // Learn more about this here:
- // https://github.com/facebook/react/issues/14365
- // https://bugs.chromium.org/p/v8/issues/detail?id=8538
- this.actualDuration = Number.NaN;
- this.actualStartTime = Number.NaN;
- this.selfBaseDuration = Number.NaN;
- this.treeBaseDuration = Number.NaN; // It's okay to replace the initial doubles with smis after initialization.
- // This won't trigger the performance cliff mentioned above,
- // and it simplifies other profiler code (including DevTools).
-
- this.actualDuration = 0;
- this.actualStartTime = -1;
- this.selfBaseDuration = 0;
- this.treeBaseDuration = 0;
- }
-
- {
- // This isn't directly used but is handy for debugging internals:
- this._debugSource = null;
- this._debugOwner = null;
- this._debugNeedsRemount = false;
- this._debugHookTypes = null;
-
- if (!hasBadMapPolyfill && typeof Object.preventExtensions === 'function') {
- Object.preventExtensions(this);
- }
- }
- } // This is a constructor function, rather than a POJO constructor, still
- // please ensure we do the following:
- // 1) Nobody should add any instance methods on this. Instance methods can be
- // more difficult to predict when they get optimized and they are almost
- // never inlined properly in static compilers.
- // 2) Nobody should rely on `instanceof Fiber` for type testing. We should
- // always know when it is a fiber.
- // 3) We might want to experiment with using numeric keys since they are easier
- // to optimize in a non-JIT environment.
- // 4) We can easily go from a constructor to a createFiber object literal if that
- // is faster.
- // 5) It should be easy to port this to a C struct and keep a C implementation
- // compatible.
-
-
- var createFiber = function (tag, pendingProps, key, mode) {
- // $FlowFixMe: the shapes are exact here but Flow doesn't like constructors
- return new FiberNode(tag, pendingProps, key, mode);
- };
-
- function shouldConstruct$1(Component) {
- var prototype = Component.prototype;
- return !!(prototype && prototype.isReactComponent);
- }
-
- function isSimpleFunctionComponent(type) {
- return typeof type === 'function' && !shouldConstruct$1(type) && type.defaultProps === undefined;
- }
- function resolveLazyComponentTag(Component) {
- if (typeof Component === 'function') {
- return shouldConstruct$1(Component) ? ClassComponent : FunctionComponent;
- } else if (Component !== undefined && Component !== null) {
- var $$typeof = Component.$$typeof;
-
- if ($$typeof === REACT_FORWARD_REF_TYPE) {
- return ForwardRef;
- }
-
- if ($$typeof === REACT_MEMO_TYPE) {
- return MemoComponent;
- }
- }
-
- return IndeterminateComponent;
- } // This is used to create an alternate fiber to do work on.
-
- function createWorkInProgress(current, pendingProps) {
- var workInProgress = current.alternate;
-
- if (workInProgress === null) {
- // We use a double buffering pooling technique because we know that we'll
- // only ever need at most two versions of a tree. We pool the "other" unused
- // node that we're free to reuse. This is lazily created to avoid allocating
- // extra objects for things that are never updated. It also allow us to
- // reclaim the extra memory if needed.
- workInProgress = createFiber(current.tag, pendingProps, current.key, current.mode);
- workInProgress.elementType = current.elementType;
- workInProgress.type = current.type;
- workInProgress.stateNode = current.stateNode;
-
- {
- // DEV-only fields
- workInProgress._debugSource = current._debugSource;
- workInProgress._debugOwner = current._debugOwner;
- workInProgress._debugHookTypes = current._debugHookTypes;
- }
-
- workInProgress.alternate = current;
- current.alternate = workInProgress;
- } else {
- workInProgress.pendingProps = pendingProps; // Needed because Blocks store data on type.
-
- workInProgress.type = current.type; // We already have an alternate.
- // Reset the effect tag.
-
- workInProgress.flags = NoFlags; // The effects are no longer valid.
-
- workInProgress.subtreeFlags = NoFlags;
- workInProgress.deletions = null;
-
- {
- // We intentionally reset, rather than copy, actualDuration & actualStartTime.
- // This prevents time from endlessly accumulating in new commits.
- // This has the downside of resetting values for Different priority renders,
- // But works for yielding (the common case) and should support resuming.
- workInProgress.actualDuration = 0;
- workInProgress.actualStartTime = -1;
- }
- } // Reset all effects except static ones.
- // Static effects are not specific to a render.
-
-
- workInProgress.flags = current.flags & StaticMask;
- workInProgress.childLanes = current.childLanes;
- workInProgress.lanes = current.lanes;
- workInProgress.child = current.child;
- workInProgress.memoizedProps = current.memoizedProps;
- workInProgress.memoizedState = current.memoizedState;
- workInProgress.updateQueue = current.updateQueue; // Clone the dependencies object. This is mutated during the render phase, so
- // it cannot be shared with the current fiber.
-
- var currentDependencies = current.dependencies;
- workInProgress.dependencies = currentDependencies === null ? null : {
- lanes: currentDependencies.lanes,
- firstContext: currentDependencies.firstContext
- }; // These will be overridden during the parent's reconciliation
-
- workInProgress.sibling = current.sibling;
- workInProgress.index = current.index;
- workInProgress.ref = current.ref;
-
- {
- workInProgress.selfBaseDuration = current.selfBaseDuration;
- workInProgress.treeBaseDuration = current.treeBaseDuration;
- }
-
- {
- workInProgress._debugNeedsRemount = current._debugNeedsRemount;
-
- switch (workInProgress.tag) {
- case IndeterminateComponent:
- case FunctionComponent:
- case SimpleMemoComponent:
- workInProgress.type = resolveFunctionForHotReloading(current.type);
- break;
-
- case ClassComponent:
- workInProgress.type = resolveClassForHotReloading(current.type);
- break;
-
- case ForwardRef:
- workInProgress.type = resolveForwardRefForHotReloading(current.type);
- break;
- }
- }
-
- return workInProgress;
- } // Used to reuse a Fiber for a second pass.
-
- function resetWorkInProgress(workInProgress, renderLanes) {
- // This resets the Fiber to what createFiber or createWorkInProgress would
- // have set the values to before during the first pass. Ideally this wouldn't
- // be necessary but unfortunately many code paths reads from the workInProgress
- // when they should be reading from current and writing to workInProgress.
- // We assume pendingProps, index, key, ref, return are still untouched to
- // avoid doing another reconciliation.
- // Reset the effect flags but keep any Placement tags, since that's something
- // that child fiber is setting, not the reconciliation.
- workInProgress.flags &= StaticMask | Placement; // The effects are no longer valid.
-
- var current = workInProgress.alternate;
-
- if (current === null) {
- // Reset to createFiber's initial values.
- workInProgress.childLanes = NoLanes;
- workInProgress.lanes = renderLanes;
- workInProgress.child = null;
- workInProgress.subtreeFlags = NoFlags;
- workInProgress.memoizedProps = null;
- workInProgress.memoizedState = null;
- workInProgress.updateQueue = null;
- workInProgress.dependencies = null;
- workInProgress.stateNode = null;
-
- {
- // Note: We don't reset the actualTime counts. It's useful to accumulate
- // actual time across multiple render passes.
- workInProgress.selfBaseDuration = 0;
- workInProgress.treeBaseDuration = 0;
- }
- } else {
- // Reset to the cloned values that createWorkInProgress would've.
- workInProgress.childLanes = current.childLanes;
- workInProgress.lanes = current.lanes;
- workInProgress.child = current.child;
- workInProgress.subtreeFlags = NoFlags;
- workInProgress.deletions = null;
- workInProgress.memoizedProps = current.memoizedProps;
- workInProgress.memoizedState = current.memoizedState;
- workInProgress.updateQueue = current.updateQueue; // Needed because Blocks store data on type.
-
- workInProgress.type = current.type; // Clone the dependencies object. This is mutated during the render phase, so
- // it cannot be shared with the current fiber.
-
- var currentDependencies = current.dependencies;
- workInProgress.dependencies = currentDependencies === null ? null : {
- lanes: currentDependencies.lanes,
- firstContext: currentDependencies.firstContext
- };
-
- {
- // Note: We don't reset the actualTime counts. It's useful to accumulate
- // actual time across multiple render passes.
- workInProgress.selfBaseDuration = current.selfBaseDuration;
- workInProgress.treeBaseDuration = current.treeBaseDuration;
- }
- }
-
- return workInProgress;
- }
- function createHostRootFiber(tag, isStrictMode, concurrentUpdatesByDefaultOverride) {
- var mode;
-
- if (tag === ConcurrentRoot) {
- mode = ConcurrentMode;
-
- if (isStrictMode === true) {
- mode |= StrictLegacyMode;
-
- {
- mode |= StrictEffectsMode;
- }
- }
- } else {
- mode = NoMode;
- }
-
- if ( isDevToolsPresent) {
- // Always collect profile timings when DevTools are present.
- // This enables DevTools to start capturing timing at any point–
- // Without some nodes in the tree having empty base times.
- mode |= ProfileMode;
- }
-
- return createFiber(HostRoot, null, null, mode);
- }
- function createFiberFromTypeAndProps(type, // React$ElementType
- key, pendingProps, owner, mode, lanes) {
- var fiberTag = IndeterminateComponent; // The resolved type is set if we know what the final type will be. I.e. it's not lazy.
-
- var resolvedType = type;
-
- if (typeof type === 'function') {
- if (shouldConstruct$1(type)) {
- fiberTag = ClassComponent;
-
- {
- resolvedType = resolveClassForHotReloading(resolvedType);
- }
- } else {
- {
- resolvedType = resolveFunctionForHotReloading(resolvedType);
- }
- }
- } else if (typeof type === 'string') {
- fiberTag = HostComponent;
- } else {
- getTag: switch (type) {
- case REACT_FRAGMENT_TYPE:
- return createFiberFromFragment(pendingProps.children, mode, lanes, key);
-
- case REACT_STRICT_MODE_TYPE:
- fiberTag = Mode;
- mode |= StrictLegacyMode;
-
- if ( (mode & ConcurrentMode) !== NoMode) {
- // Strict effects should never run on legacy roots
- mode |= StrictEffectsMode;
- }
-
- break;
-
- case REACT_PROFILER_TYPE:
- return createFiberFromProfiler(pendingProps, mode, lanes, key);
-
- case REACT_SUSPENSE_TYPE:
- return createFiberFromSuspense(pendingProps, mode, lanes, key);
-
- case REACT_SUSPENSE_LIST_TYPE:
- return createFiberFromSuspenseList(pendingProps, mode, lanes, key);
-
- case REACT_OFFSCREEN_TYPE:
- return createFiberFromOffscreen(pendingProps, mode, lanes, key);
-
- case REACT_LEGACY_HIDDEN_TYPE:
-
- // eslint-disable-next-line no-fallthrough
-
- case REACT_SCOPE_TYPE:
-
- // eslint-disable-next-line no-fallthrough
-
- case REACT_CACHE_TYPE:
-
- // eslint-disable-next-line no-fallthrough
-
- case REACT_TRACING_MARKER_TYPE:
-
- // eslint-disable-next-line no-fallthrough
-
- case REACT_DEBUG_TRACING_MODE_TYPE:
-
- // eslint-disable-next-line no-fallthrough
-
- default:
- {
- if (typeof type === 'object' && type !== null) {
- switch (type.$$typeof) {
- case REACT_PROVIDER_TYPE:
- fiberTag = ContextProvider;
- break getTag;
-
- case REACT_CONTEXT_TYPE:
- // This is a consumer
- fiberTag = ContextConsumer;
- break getTag;
-
- case REACT_FORWARD_REF_TYPE:
- fiberTag = ForwardRef;
-
- {
- resolvedType = resolveForwardRefForHotReloading(resolvedType);
- }
-
- break getTag;
-
- case REACT_MEMO_TYPE:
- fiberTag = MemoComponent;
- break getTag;
-
- case REACT_LAZY_TYPE:
- fiberTag = LazyComponent;
- resolvedType = null;
- break getTag;
- }
- }
-
- var info = '';
-
- {
- if (type === undefined || typeof type === 'object' && type !== null && Object.keys(type).length === 0) {
- info += ' You likely forgot to export your component from the file ' + "it's defined in, or you might have mixed up default and " + 'named imports.';
- }
-
- var ownerName = owner ? getComponentNameFromFiber(owner) : null;
-
- if (ownerName) {
- info += '\n\nCheck the render method of `' + ownerName + '`.';
- }
- }
-
- throw new Error('Element type is invalid: expected a string (for built-in ' + 'components) or a class/function (for composite components) ' + ("but got: " + (type == null ? type : typeof type) + "." + info));
- }
- }
- }
-
- var fiber = createFiber(fiberTag, pendingProps, key, mode);
- fiber.elementType = type;
- fiber.type = resolvedType;
- fiber.lanes = lanes;
-
- {
- fiber._debugOwner = owner;
- }
-
- return fiber;
- }
- function createFiberFromElement(element, mode, lanes) {
- var owner = null;
-
- {
- owner = element._owner;
- }
-
- var type = element.type;
- var key = element.key;
- var pendingProps = element.props;
- var fiber = createFiberFromTypeAndProps(type, key, pendingProps, owner, mode, lanes);
-
- {
- fiber._debugSource = element._source;
- fiber._debugOwner = element._owner;
- }
-
- return fiber;
- }
- function createFiberFromFragment(elements, mode, lanes, key) {
- var fiber = createFiber(Fragment, elements, key, mode);
- fiber.lanes = lanes;
- return fiber;
- }
-
- function createFiberFromProfiler(pendingProps, mode, lanes, key) {
- {
- if (typeof pendingProps.id !== 'string') {
- error('Profiler must specify an "id" of type `string` as a prop. Received the type `%s` instead.', typeof pendingProps.id);
- }
- }
-
- var fiber = createFiber(Profiler, pendingProps, key, mode | ProfileMode);
- fiber.elementType = REACT_PROFILER_TYPE;
- fiber.lanes = lanes;
-
- {
- fiber.stateNode = {
- effectDuration: 0,
- passiveEffectDuration: 0
- };
- }
-
- return fiber;
- }
-
- function createFiberFromSuspense(pendingProps, mode, lanes, key) {
- var fiber = createFiber(SuspenseComponent, pendingProps, key, mode);
- fiber.elementType = REACT_SUSPENSE_TYPE;
- fiber.lanes = lanes;
- return fiber;
- }
- function createFiberFromSuspenseList(pendingProps, mode, lanes, key) {
- var fiber = createFiber(SuspenseListComponent, pendingProps, key, mode);
- fiber.elementType = REACT_SUSPENSE_LIST_TYPE;
- fiber.lanes = lanes;
- return fiber;
- }
- function createFiberFromOffscreen(pendingProps, mode, lanes, key) {
- var fiber = createFiber(OffscreenComponent, pendingProps, key, mode);
- fiber.elementType = REACT_OFFSCREEN_TYPE;
- fiber.lanes = lanes;
- var primaryChildInstance = {
- isHidden: false
- };
- fiber.stateNode = primaryChildInstance;
- return fiber;
- }
- function createFiberFromText(content, mode, lanes) {
- var fiber = createFiber(HostText, content, null, mode);
- fiber.lanes = lanes;
- return fiber;
- }
- function createFiberFromHostInstanceForDeletion() {
- var fiber = createFiber(HostComponent, null, null, NoMode);
- fiber.elementType = 'DELETED';
- return fiber;
- }
- function createFiberFromDehydratedFragment(dehydratedNode) {
- var fiber = createFiber(DehydratedFragment, null, null, NoMode);
- fiber.stateNode = dehydratedNode;
- return fiber;
- }
- function createFiberFromPortal(portal, mode, lanes) {
- var pendingProps = portal.children !== null ? portal.children : [];
- var fiber = createFiber(HostPortal, pendingProps, portal.key, mode);
- fiber.lanes = lanes;
- fiber.stateNode = {
- containerInfo: portal.containerInfo,
- pendingChildren: null,
- // Used by persistent updates
- implementation: portal.implementation
- };
- return fiber;
- } // Used for stashing WIP properties to replay failed work in DEV.
-
- function assignFiberPropertiesInDEV(target, source) {
- if (target === null) {
- // This Fiber's initial properties will always be overwritten.
- // We only use a Fiber to ensure the same hidden class so DEV isn't slow.
- target = createFiber(IndeterminateComponent, null, null, NoMode);
- } // This is intentionally written as a list of all properties.
- // We tried to use Object.assign() instead but this is called in
- // the hottest path, and Object.assign() was too slow:
- // https://github.com/facebook/react/issues/12502
- // This code is DEV-only so size is not a concern.
-
-
- target.tag = source.tag;
- target.key = source.key;
- target.elementType = source.elementType;
- target.type = source.type;
- target.stateNode = source.stateNode;
- target.return = source.return;
- target.child = source.child;
- target.sibling = source.sibling;
- target.index = source.index;
- target.ref = source.ref;
- target.pendingProps = source.pendingProps;
- target.memoizedProps = source.memoizedProps;
- target.updateQueue = source.updateQueue;
- target.memoizedState = source.memoizedState;
- target.dependencies = source.dependencies;
- target.mode = source.mode;
- target.flags = source.flags;
- target.subtreeFlags = source.subtreeFlags;
- target.deletions = source.deletions;
- target.lanes = source.lanes;
- target.childLanes = source.childLanes;
- target.alternate = source.alternate;
-
- {
- target.actualDuration = source.actualDuration;
- target.actualStartTime = source.actualStartTime;
- target.selfBaseDuration = source.selfBaseDuration;
- target.treeBaseDuration = source.treeBaseDuration;
- }
-
- target._debugSource = source._debugSource;
- target._debugOwner = source._debugOwner;
- target._debugNeedsRemount = source._debugNeedsRemount;
- target._debugHookTypes = source._debugHookTypes;
- return target;
- }
-
- function FiberRootNode(containerInfo, tag, hydrate, identifierPrefix, onRecoverableError) {
- this.tag = tag;
- this.containerInfo = containerInfo;
- this.pendingChildren = null;
- this.current = null;
- this.pingCache = null;
- this.finishedWork = null;
- this.timeoutHandle = noTimeout;
- this.context = null;
- this.pendingContext = null;
- this.callbackNode = null;
- this.callbackPriority = NoLane;
- this.eventTimes = createLaneMap(NoLanes);
- this.expirationTimes = createLaneMap(NoTimestamp);
- this.pendingLanes = NoLanes;
- this.suspendedLanes = NoLanes;
- this.pingedLanes = NoLanes;
- this.expiredLanes = NoLanes;
- this.mutableReadLanes = NoLanes;
- this.finishedLanes = NoLanes;
- this.entangledLanes = NoLanes;
- this.entanglements = createLaneMap(NoLanes);
- this.identifierPrefix = identifierPrefix;
- this.onRecoverableError = onRecoverableError;
-
- {
- this.mutableSourceEagerHydrationData = null;
- }
-
- {
- this.effectDuration = 0;
- this.passiveEffectDuration = 0;
- }
-
- {
- this.memoizedUpdaters = new Set();
- var pendingUpdatersLaneMap = this.pendingUpdatersLaneMap = [];
-
- for (var _i = 0; _i < TotalLanes; _i++) {
- pendingUpdatersLaneMap.push(new Set());
- }
- }
-
- {
- switch (tag) {
- case ConcurrentRoot:
- this._debugRootType = hydrate ? 'hydrateRoot()' : 'createRoot()';
- break;
-
- case LegacyRoot:
- this._debugRootType = hydrate ? 'hydrate()' : 'render()';
- break;
- }
- }
- }
-
- function createFiberRoot(containerInfo, tag, hydrate, initialChildren, hydrationCallbacks, isStrictMode, concurrentUpdatesByDefaultOverride, // TODO: We have several of these arguments that are conceptually part of the
- // host config, but because they are passed in at runtime, we have to thread
- // them through the root constructor. Perhaps we should put them all into a
- // single type, like a DynamicHostConfig that is defined by the renderer.
- identifierPrefix, onRecoverableError, transitionCallbacks) {
- var root = new FiberRootNode(containerInfo, tag, hydrate, identifierPrefix, onRecoverableError);
- // stateNode is any.
-
-
- var uninitializedFiber = createHostRootFiber(tag, isStrictMode);
- root.current = uninitializedFiber;
- uninitializedFiber.stateNode = root;
-
- {
- var _initialState = {
- element: initialChildren,
- isDehydrated: hydrate,
- cache: null,
- // not enabled yet
- transitions: null,
- pendingSuspenseBoundaries: null
- };
- uninitializedFiber.memoizedState = _initialState;
- }
-
- initializeUpdateQueue(uninitializedFiber);
- return root;
- }
-
- var ReactVersion = '18.3.1';
-
- function createPortal(children, containerInfo, // TODO: figure out the API for cross-renderer implementation.
- implementation) {
- var key = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
-
- {
- checkKeyStringCoercion(key);
- }
-
- return {
- // This tag allow us to uniquely identify this as a React Portal
- $$typeof: REACT_PORTAL_TYPE,
- key: key == null ? null : '' + key,
- children: children,
- containerInfo: containerInfo,
- implementation: implementation
- };
- }
-
- var didWarnAboutNestedUpdates;
- var didWarnAboutFindNodeInStrictMode;
-
- {
- didWarnAboutNestedUpdates = false;
- didWarnAboutFindNodeInStrictMode = {};
- }
-
- function getContextForSubtree(parentComponent) {
- if (!parentComponent) {
- return emptyContextObject;
- }
-
- var fiber = get(parentComponent);
- var parentContext = findCurrentUnmaskedContext(fiber);
-
- if (fiber.tag === ClassComponent) {
- var Component = fiber.type;
-
- if (isContextProvider(Component)) {
- return processChildContext(fiber, Component, parentContext);
- }
- }
-
- return parentContext;
- }
-
- function findHostInstanceWithWarning(component, methodName) {
- {
- var fiber = get(component);
-
- if (fiber === undefined) {
- if (typeof component.render === 'function') {
- throw new Error('Unable to find node on an unmounted component.');
- } else {
- var keys = Object.keys(component).join(',');
- throw new Error("Argument appears to not be a ReactComponent. Keys: " + keys);
- }
- }
-
- var hostFiber = findCurrentHostFiber(fiber);
-
- if (hostFiber === null) {
- return null;
- }
-
- if (hostFiber.mode & StrictLegacyMode) {
- var componentName = getComponentNameFromFiber(fiber) || 'Component';
-
- if (!didWarnAboutFindNodeInStrictMode[componentName]) {
- didWarnAboutFindNodeInStrictMode[componentName] = true;
- var previousFiber = current;
-
- try {
- setCurrentFiber(hostFiber);
-
- if (fiber.mode & StrictLegacyMode) {
- error('%s is deprecated in StrictMode. ' + '%s was passed an instance of %s which is inside StrictMode. ' + 'Instead, add a ref directly to the element you want to reference. ' + 'Learn more about using refs safely here: ' + 'https://reactjs.org/link/strict-mode-find-node', methodName, methodName, componentName);
- } else {
- error('%s is deprecated in StrictMode. ' + '%s was passed an instance of %s which renders StrictMode children. ' + 'Instead, add a ref directly to the element you want to reference. ' + 'Learn more about using refs safely here: ' + 'https://reactjs.org/link/strict-mode-find-node', methodName, methodName, componentName);
- }
- } finally {
- // Ideally this should reset to previous but this shouldn't be called in
- // render and there's another warning for that anyway.
- if (previousFiber) {
- setCurrentFiber(previousFiber);
- } else {
- resetCurrentFiber();
- }
- }
- }
- }
-
- return hostFiber.stateNode;
- }
- }
-
- function createContainer(containerInfo, tag, hydrationCallbacks, isStrictMode, concurrentUpdatesByDefaultOverride, identifierPrefix, onRecoverableError, transitionCallbacks) {
- var hydrate = false;
- var initialChildren = null;
- return createFiberRoot(containerInfo, tag, hydrate, initialChildren, hydrationCallbacks, isStrictMode, concurrentUpdatesByDefaultOverride, identifierPrefix, onRecoverableError);
- }
- function createHydrationContainer(initialChildren, // TODO: Remove `callback` when we delete legacy mode.
- callback, containerInfo, tag, hydrationCallbacks, isStrictMode, concurrentUpdatesByDefaultOverride, identifierPrefix, onRecoverableError, transitionCallbacks) {
- var hydrate = true;
- var root = createFiberRoot(containerInfo, tag, hydrate, initialChildren, hydrationCallbacks, isStrictMode, concurrentUpdatesByDefaultOverride, identifierPrefix, onRecoverableError); // TODO: Move this to FiberRoot constructor
-
- root.context = getContextForSubtree(null); // Schedule the initial render. In a hydration root, this is Different from
- // a regular update because the initial render must match was was rendered
- // on the server.
- // NOTE: This update intentionally doesn't have a payload. We're only using
- // the update to schedule work on the root fiber (and, for legacy roots, to
- // enqueue the callback if one is provided).
-
- var current = root.current;
- var eventTime = requestEventTime();
- var lane = requestUpdateLane(current);
- var update = createUpdate(eventTime, lane);
- update.callback = callback !== undefined && callback !== null ? callback : null;
- enqueueUpdate(current, update, lane);
- scheduleInitialHydrationOnRoot(root, lane, eventTime);
- return root;
- }
- function updateContainer(element, container, parentComponent, callback) {
- {
- onScheduleRoot(container, element);
- }
-
- var current$1 = container.current;
- var eventTime = requestEventTime();
- var lane = requestUpdateLane(current$1);
-
- {
- markRenderScheduled(lane);
- }
-
- var context = getContextForSubtree(parentComponent);
-
- if (container.context === null) {
- container.context = context;
- } else {
- container.pendingContext = context;
- }
-
- {
- if (isRendering && current !== null && !didWarnAboutNestedUpdates) {
- didWarnAboutNestedUpdates = true;
-
- error('Render methods should be a pure function of props and state; ' + 'triggering nested component updates from render is not allowed. ' + 'If necessary, trigger nested updates in componentDidUpdate.\n\n' + 'Check the render method of %s.', getComponentNameFromFiber(current) || 'Unknown');
- }
- }
-
- var update = createUpdate(eventTime, lane); // Caution: React DevTools currently depends on this property
- // being called "element".
-
- update.payload = {
- element: element
- };
- callback = callback === undefined ? null : callback;
-
- if (callback !== null) {
- {
- if (typeof callback !== 'function') {
- error('render(...): Expected the last optional `callback` argument to be a ' + 'function. Instead received: %s.', callback);
- }
- }
-
- update.callback = callback;
- }
-
- var root = enqueueUpdate(current$1, update, lane);
-
- if (root !== null) {
- scheduleUpdateOnFiber(root, current$1, lane, eventTime);
- entangleTransitions(root, current$1, lane);
- }
-
- return lane;
- }
- function getPublicRootInstance(container) {
- var containerFiber = container.current;
-
- if (!containerFiber.child) {
- return null;
- }
-
- switch (containerFiber.child.tag) {
- case HostComponent:
- return getPublicInstance(containerFiber.child.stateNode);
-
- default:
- return containerFiber.child.stateNode;
- }
- }
- function attemptSynchronousHydration$1(fiber) {
- switch (fiber.tag) {
- case HostRoot:
- {
- var root = fiber.stateNode;
-
- if (isRootDehydrated(root)) {
- // Flush the first scheduled "update".
- var lanes = getHighestPriorityPendingLanes(root);
- flushRoot(root, lanes);
- }
-
- break;
- }
-
- case SuspenseComponent:
- {
- flushSync(function () {
- var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
-
- if (root !== null) {
- var eventTime = requestEventTime();
- scheduleUpdateOnFiber(root, fiber, SyncLane, eventTime);
- }
- }); // If we're still blocked after this, we need to increase
- // the priority of any promises resolving within this
- // boundary so that they next attempt also has higher pri.
-
- var retryLane = SyncLane;
- markRetryLaneIfNotHydrated(fiber, retryLane);
- break;
- }
- }
- }
-
- function markRetryLaneImpl(fiber, retryLane) {
- var suspenseState = fiber.memoizedState;
-
- if (suspenseState !== null && suspenseState.dehydrated !== null) {
- suspenseState.retryLane = higherPriorityLane(suspenseState.retryLane, retryLane);
- }
- } // Increases the priority of thenables when they resolve within this boundary.
-
-
- function markRetryLaneIfNotHydrated(fiber, retryLane) {
- markRetryLaneImpl(fiber, retryLane);
- var alternate = fiber.alternate;
-
- if (alternate) {
- markRetryLaneImpl(alternate, retryLane);
- }
- }
- function attemptContinuousHydration$1(fiber) {
- if (fiber.tag !== SuspenseComponent) {
- // We ignore HostRoots here because we can't increase
- // their priority and they should not suspend on I/O,
- // since you have to wrap anything that might suspend in
- // Suspense.
- return;
- }
-
- var lane = SelectiveHydrationLane;
- var root = enqueueConcurrentRenderForLane(fiber, lane);
-
- if (root !== null) {
- var eventTime = requestEventTime();
- scheduleUpdateOnFiber(root, fiber, lane, eventTime);
- }
-
- markRetryLaneIfNotHydrated(fiber, lane);
- }
- function attemptHydrationAtCurrentPriority$1(fiber) {
- if (fiber.tag !== SuspenseComponent) {
- // We ignore HostRoots here because we can't increase
- // their priority other than synchronously flush it.
- return;
- }
-
- var lane = requestUpdateLane(fiber);
- var root = enqueueConcurrentRenderForLane(fiber, lane);
-
- if (root !== null) {
- var eventTime = requestEventTime();
- scheduleUpdateOnFiber(root, fiber, lane, eventTime);
- }
-
- markRetryLaneIfNotHydrated(fiber, lane);
- }
- function findHostInstanceWithNoPortals(fiber) {
- var hostFiber = findCurrentHostFiberWithNoPortals(fiber);
-
- if (hostFiber === null) {
- return null;
- }
-
- return hostFiber.stateNode;
- }
-
- var shouldErrorImpl = function (fiber) {
- return null;
- };
-
- function shouldError(fiber) {
- return shouldErrorImpl(fiber);
- }
-
- var shouldSuspendImpl = function (fiber) {
- return false;
- };
-
- function shouldSuspend(fiber) {
- return shouldSuspendImpl(fiber);
- }
- var overrideHookState = null;
- var overrideHookStateDeletePath = null;
- var overrideHookStateRenamePath = null;
- var overrideProps = null;
- var overridePropsDeletePath = null;
- var overridePropsRenamePath = null;
- var scheduleUpdate = null;
- var setErrorHandler = null;
- var setSuspenseHandler = null;
-
- {
- var copyWithDeleteImpl = function (obj, path, index) {
- var key = path[index];
- var updated = isArray(obj) ? obj.slice() : assign({}, obj);
-
- if (index + 1 === path.length) {
- if (isArray(updated)) {
- updated.splice(key, 1);
- } else {
- delete updated[key];
- }
-
- return updated;
- } // $FlowFixMe number or string is fine here
-
-
- updated[key] = copyWithDeleteImpl(obj[key], path, index + 1);
- return updated;
- };
-
- var copyWithDelete = function (obj, path) {
- return copyWithDeleteImpl(obj, path, 0);
- };
-
- var copyWithRenameImpl = function (obj, oldPath, newPath, index) {
- var oldKey = oldPath[index];
- var updated = isArray(obj) ? obj.slice() : assign({}, obj);
-
- if (index + 1 === oldPath.length) {
- var newKey = newPath[index]; // $FlowFixMe number or string is fine here
-
- updated[newKey] = updated[oldKey];
-
- if (isArray(updated)) {
- updated.splice(oldKey, 1);
- } else {
- delete updated[oldKey];
- }
- } else {
- // $FlowFixMe number or string is fine here
- updated[oldKey] = copyWithRenameImpl( // $FlowFixMe number or string is fine here
- obj[oldKey], oldPath, newPath, index + 1);
- }
-
- return updated;
- };
-
- var copyWithRename = function (obj, oldPath, newPath) {
- if (oldPath.length !== newPath.length) {
- warn('copyWithRename() expects paths of the same length');
-
- return;
- } else {
- for (var i = 0; i < newPath.length - 1; i++) {
- if (oldPath[i] !== newPath[i]) {
- warn('copyWithRename() expects paths to be the same except for the deepest key');
-
- return;
- }
- }
- }
-
- return copyWithRenameImpl(obj, oldPath, newPath, 0);
- };
-
- var copyWithSetImpl = function (obj, path, index, value) {
- if (index >= path.length) {
- return value;
- }
-
- var key = path[index];
- var updated = isArray(obj) ? obj.slice() : assign({}, obj); // $FlowFixMe number or string is fine here
-
- updated[key] = copyWithSetImpl(obj[key], path, index + 1, value);
- return updated;
- };
-
- var copyWithSet = function (obj, path, value) {
- return copyWithSetImpl(obj, path, 0, value);
- };
-
- var findHook = function (fiber, id) {
- // For now, the "id" of stateful hooks is just the stateful hook index.
- // This may change in the future with e.g. nested hooks.
- var currentHook = fiber.memoizedState;
-
- while (currentHook !== null && id > 0) {
- currentHook = currentHook.next;
- id--;
- }
-
- return currentHook;
- }; // Support DevTools editable values for useState and useReducer.
-
-
- overrideHookState = function (fiber, id, path, value) {
- var hook = findHook(fiber, id);
-
- if (hook !== null) {
- var newState = copyWithSet(hook.memoizedState, path, value);
- hook.memoizedState = newState;
- hook.baseState = newState; // We aren't actually adding an update to the queue,
- // because there is no update we can add for useReducer hooks that won't trigger an error.
- // (There's no appropriate action type for DevTools overrides.)
- // As a result though, React will see the scheduled update as a noop and bailout.
- // Shallow cloning props works as a workaround for now to bypass the bailout check.
-
- fiber.memoizedProps = assign({}, fiber.memoizedProps);
- var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
-
- if (root !== null) {
- scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
- }
- }
- };
-
- overrideHookStateDeletePath = function (fiber, id, path) {
- var hook = findHook(fiber, id);
-
- if (hook !== null) {
- var newState = copyWithDelete(hook.memoizedState, path);
- hook.memoizedState = newState;
- hook.baseState = newState; // We aren't actually adding an update to the queue,
- // because there is no update we can add for useReducer hooks that won't trigger an error.
- // (There's no appropriate action type for DevTools overrides.)
- // As a result though, React will see the scheduled update as a noop and bailout.
- // Shallow cloning props works as a workaround for now to bypass the bailout check.
-
- fiber.memoizedProps = assign({}, fiber.memoizedProps);
- var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
-
- if (root !== null) {
- scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
- }
- }
- };
-
- overrideHookStateRenamePath = function (fiber, id, oldPath, newPath) {
- var hook = findHook(fiber, id);
-
- if (hook !== null) {
- var newState = copyWithRename(hook.memoizedState, oldPath, newPath);
- hook.memoizedState = newState;
- hook.baseState = newState; // We aren't actually adding an update to the queue,
- // because there is no update we can add for useReducer hooks that won't trigger an error.
- // (There's no appropriate action type for DevTools overrides.)
- // As a result though, React will see the scheduled update as a noop and bailout.
- // Shallow cloning props works as a workaround for now to bypass the bailout check.
-
- fiber.memoizedProps = assign({}, fiber.memoizedProps);
- var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
-
- if (root !== null) {
- scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
- }
- }
- }; // Support DevTools props for function components, forwardRef, memo, host components, etc.
-
-
- overrideProps = function (fiber, path, value) {
- fiber.pendingProps = copyWithSet(fiber.memoizedProps, path, value);
-
- if (fiber.alternate) {
- fiber.alternate.pendingProps = fiber.pendingProps;
- }
-
- var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
-
- if (root !== null) {
- scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
- }
- };
-
- overridePropsDeletePath = function (fiber, path) {
- fiber.pendingProps = copyWithDelete(fiber.memoizedProps, path);
-
- if (fiber.alternate) {
- fiber.alternate.pendingProps = fiber.pendingProps;
- }
-
- var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
-
- if (root !== null) {
- scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
- }
- };
-
- overridePropsRenamePath = function (fiber, oldPath, newPath) {
- fiber.pendingProps = copyWithRename(fiber.memoizedProps, oldPath, newPath);
-
- if (fiber.alternate) {
- fiber.alternate.pendingProps = fiber.pendingProps;
- }
-
- var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
-
- if (root !== null) {
- scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
- }
- };
-
- scheduleUpdate = function (fiber) {
- var root = enqueueConcurrentRenderForLane(fiber, SyncLane);
-
- if (root !== null) {
- scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);
- }
- };
-
- setErrorHandler = function (newShouldErrorImpl) {
- shouldErrorImpl = newShouldErrorImpl;
- };
-
- setSuspenseHandler = function (newShouldSuspendImpl) {
- shouldSuspendImpl = newShouldSuspendImpl;
- };
- }
-
- function findHostInstanceByFiber(fiber) {
- var hostFiber = findCurrentHostFiber(fiber);
-
- if (hostFiber === null) {
- return null;
- }
-
- return hostFiber.stateNode;
- }
-
- function emptyFindFiberByHostInstance(instance) {
- return null;
- }
-
- function getCurrentFiberForDevTools() {
- return current;
- }
-
- function injectIntoDevTools(devToolsConfig) {
- var findFiberByHostInstance = devToolsConfig.findFiberByHostInstance;
- var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
- return injectInternals({
- bundleType: devToolsConfig.bundleType,
- version: devToolsConfig.version,
- rendererPackageName: devToolsConfig.rendererPackageName,
- rendererConfig: devToolsConfig.rendererConfig,
- overrideHookState: overrideHookState,
- overrideHookStateDeletePath: overrideHookStateDeletePath,
- overrideHookStateRenamePath: overrideHookStateRenamePath,
- overrideProps: overrideProps,
- overridePropsDeletePath: overridePropsDeletePath,
- overridePropsRenamePath: overridePropsRenamePath,
- setErrorHandler: setErrorHandler,
- setSuspenseHandler: setSuspenseHandler,
- scheduleUpdate: scheduleUpdate,
- currentDispatcherRef: ReactCurrentDispatcher,
- findHostInstanceByFiber: findHostInstanceByFiber,
- findFiberByHostInstance: findFiberByHostInstance || emptyFindFiberByHostInstance,
- // React Refresh
- findHostInstancesForRefresh: findHostInstancesForRefresh ,
- scheduleRefresh: scheduleRefresh ,
- scheduleRoot: scheduleRoot ,
- setRefreshHandler: setRefreshHandler ,
- // Enables DevTools to append owner stacks to error messages in DEV mode.
- getCurrentFiber: getCurrentFiberForDevTools ,
- // Enables DevTools to detect reconciler version rather than renderer version
- // which may not match for third party renderers.
- reconcilerVersion: ReactVersion
- });
- }
-
- /* global reportError */
-
- var defaultOnRecoverableError = typeof reportError === 'function' ? // In modern browsers, reportError will dispatch an error event,
- // emulating an uncaught JavaScript error.
- reportError : function (error) {
- // In older browsers and test environments, fallback to console.error.
- // eslint-disable-next-line react-internal/no-production-logging
- console['error'](error);
- };
-
- function ReactDOMRoot(internalRoot) {
- this._internalRoot = internalRoot;
- }
-
- ReactDOMHydrationRoot.prototype.render = ReactDOMRoot.prototype.render = function (children) {
- var root = this._internalRoot;
-
- if (root === null) {
- throw new Error('Cannot update an unmounted root.');
- }
-
- {
- if (typeof arguments[1] === 'function') {
- error('render(...): does not support the second callback argument. ' + 'To execute a side effect after rendering, declare it in a component body with useEffect().');
- } else if (isValidContainer(arguments[1])) {
- error('You passed a container to the second argument of root.render(...). ' + "You don't need to pass it again since you already passed it to create the root.");
- } else if (typeof arguments[1] !== 'undefined') {
- error('You passed a second argument to root.render(...) but it only accepts ' + 'one argument.');
- }
-
- var container = root.containerInfo;
-
- if (container.nodeType !== COMMENT_NODE) {
- var hostInstance = findHostInstanceWithNoPortals(root.current);
-
- if (hostInstance) {
- if (hostInstance.parentNode !== container) {
- error('render(...): It looks like the React-rendered content of the ' + 'root container was removed without using React. This is not ' + 'supported and will cause errors. Instead, call ' + "root.unmount() to empty a root's container.");
- }
- }
- }
- }
-
- updateContainer(children, root, null, null);
- };
-
- ReactDOMHydrationRoot.prototype.unmount = ReactDOMRoot.prototype.unmount = function () {
- {
- if (typeof arguments[0] === 'function') {
- error('unmount(...): does not support a callback argument. ' + 'To execute a side effect after rendering, declare it in a component body with useEffect().');
- }
- }
-
- var root = this._internalRoot;
-
- if (root !== null) {
- this._internalRoot = null;
- var container = root.containerInfo;
-
- {
- if (isAlreadyRendering()) {
- error('Attempted to synchronously unmount a root while React was already ' + 'rendering. React cannot finish unmounting the root until the ' + 'current render has completed, which may lead to a race condition.');
- }
- }
-
- flushSync(function () {
- updateContainer(null, root, null, null);
- });
- unmarkContainerAsRoot(container);
- }
- };
-
- function createRoot(container, options) {
- if (!isValidContainer(container)) {
- throw new Error('createRoot(...): Target container is not a DOM element.');
- }
-
- warnIfReactDOMContainerInDEV(container);
- var isStrictMode = false;
- var concurrentUpdatesByDefaultOverride = false;
- var identifierPrefix = '';
- var onRecoverableError = defaultOnRecoverableError;
- var transitionCallbacks = null;
-
- if (options !== null && options !== undefined) {
- {
- if (options.hydrate) {
- warn('hydrate through createRoot is deprecated. Use ReactDOMClient.hydrateRoot(container, ) instead.');
- } else {
- if (typeof options === 'object' && options !== null && options.$$typeof === REACT_ELEMENT_TYPE) {
- error('You passed a JSX element to createRoot. You probably meant to ' + 'call root.render instead. ' + 'Example usage:\n\n' + ' let root = createRoot(domContainer);\n' + ' root.render();');
- }
- }
- }
-
- if (options.unstable_strictMode === true) {
- isStrictMode = true;
- }
-
- if (options.identifierPrefix !== undefined) {
- identifierPrefix = options.identifierPrefix;
- }
-
- if (options.onRecoverableError !== undefined) {
- onRecoverableError = options.onRecoverableError;
- }
-
- if (options.transitionCallbacks !== undefined) {
- transitionCallbacks = options.transitionCallbacks;
- }
- }
-
- var root = createContainer(container, ConcurrentRoot, null, isStrictMode, concurrentUpdatesByDefaultOverride, identifierPrefix, onRecoverableError);
- markContainerAsRoot(root.current, container);
- var rootContainerElement = container.nodeType === COMMENT_NODE ? container.parentNode : container;
- listenToAllSupportedEvents(rootContainerElement);
- return new ReactDOMRoot(root);
- }
-
- function ReactDOMHydrationRoot(internalRoot) {
- this._internalRoot = internalRoot;
- }
-
- function scheduleHydration(target) {
- if (target) {
- queueExplicitHydrationTarget(target);
- }
- }
-
- ReactDOMHydrationRoot.prototype.unstable_scheduleHydration = scheduleHydration;
- function hydrateRoot(container, initialChildren, options) {
- if (!isValidContainer(container)) {
- throw new Error('hydrateRoot(...): Target container is not a DOM element.');
- }
-
- warnIfReactDOMContainerInDEV(container);
-
- {
- if (initialChildren === undefined) {
- error('Must provide initial children as second argument to hydrateRoot. ' + 'Example usage: hydrateRoot(domContainer, )');
- }
- } // For now we reuse the whole bag of options since they contain
- // the hydration callbacks.
-
-
- var hydrationCallbacks = options != null ? options : null; // TODO: Delete this option
-
- var mutableSources = options != null && options.hydratedSources || null;
- var isStrictMode = false;
- var concurrentUpdatesByDefaultOverride = false;
- var identifierPrefix = '';
- var onRecoverableError = defaultOnRecoverableError;
-
- if (options !== null && options !== undefined) {
- if (options.unstable_strictMode === true) {
- isStrictMode = true;
- }
-
- if (options.identifierPrefix !== undefined) {
- identifierPrefix = options.identifierPrefix;
- }
-
- if (options.onRecoverableError !== undefined) {
- onRecoverableError = options.onRecoverableError;
- }
- }
-
- var root = createHydrationContainer(initialChildren, null, container, ConcurrentRoot, hydrationCallbacks, isStrictMode, concurrentUpdatesByDefaultOverride, identifierPrefix, onRecoverableError);
- markContainerAsRoot(root.current, container); // This can't be a comment node since hydration doesn't work on comment nodes anyway.
-
- listenToAllSupportedEvents(container);
-
- if (mutableSources) {
- for (var i = 0; i < mutableSources.length; i++) {
- var mutableSource = mutableSources[i];
- registerMutableSourceForHydration(root, mutableSource);
- }
- }
-
- return new ReactDOMHydrationRoot(root);
- }
- function isValidContainer(node) {
- return !!(node && (node.nodeType === ELEMENT_NODE || node.nodeType === DOCUMENT_NODE || node.nodeType === DOCUMENT_FRAGMENT_NODE || !disableCommentsAsDOMContainers ));
- } // TODO: Remove this function which also includes comment nodes.
- // We only use it in places that are currently more relaxed.
-
- function isValidContainerLegacy(node) {
- return !!(node && (node.nodeType === ELEMENT_NODE || node.nodeType === DOCUMENT_NODE || node.nodeType === DOCUMENT_FRAGMENT_NODE || node.nodeType === COMMENT_NODE && node.nodeValue === ' react-mount-point-unstable '));
- }
-
- function warnIfReactDOMContainerInDEV(container) {
- {
- if (container.nodeType === ELEMENT_NODE && container.tagName && container.tagName.toUpperCase() === 'BODY') {
- error('createRoot(): Creating roots directly with document.body is ' + 'discouraged, since its children are often manipulated by third-party ' + 'scripts and browser extensions. This may lead to subtle ' + 'reconciliation issues. Try using a container element created ' + 'for your app.');
- }
-
- if (isContainerMarkedAsRoot(container)) {
- if (container._reactRootContainer) {
- error('You are calling ReactDOMClient.createRoot() on a container that was previously ' + 'passed to ReactDOM.render(). This is not supported.');
- } else {
- error('You are calling ReactDOMClient.createRoot() on a container that ' + 'has already been passed to createRoot() before. Instead, call ' + 'root.render() on the existing root instead if you want to update it.');
- }
- }
- }
- }
-
- var ReactCurrentOwner$3 = ReactSharedInternals.ReactCurrentOwner;
- var topLevelUpdateWarnings;
-
- {
- topLevelUpdateWarnings = function (container) {
- if (container._reactRootContainer && container.nodeType !== COMMENT_NODE) {
- var hostInstance = findHostInstanceWithNoPortals(container._reactRootContainer.current);
-
- if (hostInstance) {
- if (hostInstance.parentNode !== container) {
- error('render(...): It looks like the React-rendered content of this ' + 'container was removed without using React. This is not ' + 'supported and will cause errors. Instead, call ' + 'ReactDOM.unmountComponentAtNode to empty a container.');
- }
- }
- }
-
- var isRootRenderedBySomeReact = !!container._reactRootContainer;
- var rootEl = getReactRootElementInContainer(container);
- var hasNonRootReactChild = !!(rootEl && getInstanceFromNode(rootEl));
-
- if (hasNonRootReactChild && !isRootRenderedBySomeReact) {
- error('render(...): Replacing React-rendered children with a new root ' + 'component. If you intended to update the children of this node, ' + 'you should instead have the existing children update their state ' + 'and render the new components instead of calling ReactDOM.render.');
- }
-
- if (container.nodeType === ELEMENT_NODE && container.tagName && container.tagName.toUpperCase() === 'BODY') {
- error('render(): Rendering components directly into document.body is ' + 'discouraged, since its children are often manipulated by third-party ' + 'scripts and browser extensions. This may lead to subtle ' + 'reconciliation issues. Try rendering into a container element created ' + 'for your app.');
- }
- };
- }
-
- function getReactRootElementInContainer(container) {
- if (!container) {
- return null;
- }
-
- if (container.nodeType === DOCUMENT_NODE) {
- return container.documentElement;
- } else {
- return container.firstChild;
- }
- }
-
- function noopOnRecoverableError() {// This isn't reachable because onRecoverableError isn't called in the
- // legacy API.
- }
-
- function legacyCreateRootFromDOMContainer(container, initialChildren, parentComponent, callback, isHydrationContainer) {
- if (isHydrationContainer) {
- if (typeof callback === 'function') {
- var originalCallback = callback;
-
- callback = function () {
- var instance = getPublicRootInstance(root);
- originalCallback.call(instance);
- };
- }
-
- var root = createHydrationContainer(initialChildren, callback, container, LegacyRoot, null, // hydrationCallbacks
- false, // isStrictMode
- false, // concurrentUpdatesByDefaultOverride,
- '', // identifierPrefix
- noopOnRecoverableError);
- container._reactRootContainer = root;
- markContainerAsRoot(root.current, container);
- var rootContainerElement = container.nodeType === COMMENT_NODE ? container.parentNode : container;
- listenToAllSupportedEvents(rootContainerElement);
- flushSync();
- return root;
- } else {
- // First clear any existing content.
- var rootSibling;
-
- while (rootSibling = container.lastChild) {
- container.removeChild(rootSibling);
- }
-
- if (typeof callback === 'function') {
- var _originalCallback = callback;
-
- callback = function () {
- var instance = getPublicRootInstance(_root);
-
- _originalCallback.call(instance);
- };
- }
-
- var _root = createContainer(container, LegacyRoot, null, // hydrationCallbacks
- false, // isStrictMode
- false, // concurrentUpdatesByDefaultOverride,
- '', // identifierPrefix
- noopOnRecoverableError);
-
- container._reactRootContainer = _root;
- markContainerAsRoot(_root.current, container);
-
- var _rootContainerElement = container.nodeType === COMMENT_NODE ? container.parentNode : container;
-
- listenToAllSupportedEvents(_rootContainerElement); // Initial mount should not be batched.
-
- flushSync(function () {
- updateContainer(initialChildren, _root, parentComponent, callback);
- });
- return _root;
- }
- }
-
- function warnOnInvalidCallback$1(callback, callerName) {
- {
- if (callback !== null && typeof callback !== 'function') {
- error('%s(...): Expected the last optional `callback` argument to be a ' + 'function. Instead received: %s.', callerName, callback);
- }
- }
- }
-
- function legacyRenderSubtreeIntoContainer(parentComponent, children, container, forceHydrate, callback) {
- {
- topLevelUpdateWarnings(container);
- warnOnInvalidCallback$1(callback === undefined ? null : callback, 'render');
- }
-
- var maybeRoot = container._reactRootContainer;
- var root;
-
- if (!maybeRoot) {
- // Initial mount
- root = legacyCreateRootFromDOMContainer(container, children, parentComponent, callback, forceHydrate);
- } else {
- root = maybeRoot;
-
- if (typeof callback === 'function') {
- var originalCallback = callback;
-
- callback = function () {
- var instance = getPublicRootInstance(root);
- originalCallback.call(instance);
- };
- } // Update
-
-
- updateContainer(children, root, parentComponent, callback);
- }
-
- return getPublicRootInstance(root);
- }
-
- var didWarnAboutFindDOMNode = false;
- function findDOMNode(componentOrElement) {
- {
- if (!didWarnAboutFindDOMNode) {
- didWarnAboutFindDOMNode = true;
-
- error('findDOMNode is deprecated and will be removed in the next major ' + 'release. Instead, add a ref directly to the element you want ' + 'to reference. Learn more about using refs safely here: ' + 'https://reactjs.org/link/strict-mode-find-node');
- }
-
- var owner = ReactCurrentOwner$3.current;
-
- if (owner !== null && owner.stateNode !== null) {
- var warnedAboutRefsInRender = owner.stateNode._warnedAboutRefsInRender;
-
- if (!warnedAboutRefsInRender) {
- error('%s is accessing findDOMNode inside its render(). ' + 'render() should be a pure function of props and state. It should ' + 'never access something that requires stale data from the previous ' + 'render, such as refs. Move this logic to componentDidMount and ' + 'componentDidUpdate instead.', getComponentNameFromType(owner.type) || 'A component');
- }
-
- owner.stateNode._warnedAboutRefsInRender = true;
- }
- }
-
- if (componentOrElement == null) {
- return null;
- }
-
- if (componentOrElement.nodeType === ELEMENT_NODE) {
- return componentOrElement;
- }
-
- {
- return findHostInstanceWithWarning(componentOrElement, 'findDOMNode');
- }
- }
- function hydrate(element, container, callback) {
- {
- error('ReactDOM.hydrate is no longer supported in React 18. Use hydrateRoot ' + 'instead. Until you switch to the new API, your app will behave as ' + "if it's running React 17. Learn " + 'more: https://reactjs.org/link/switch-to-createroot');
- }
-
- if (!isValidContainerLegacy(container)) {
- throw new Error('Target container is not a DOM element.');
- }
-
- {
- var isModernRoot = isContainerMarkedAsRoot(container) && container._reactRootContainer === undefined;
-
- if (isModernRoot) {
- error('You are calling ReactDOM.hydrate() on a container that was previously ' + 'passed to ReactDOMClient.createRoot(). This is not supported. ' + 'Did you mean to call hydrateRoot(container, element)?');
- }
- } // TODO: throw or warn if we couldn't hydrate?
-
-
- return legacyRenderSubtreeIntoContainer(null, element, container, true, callback);
- }
- function render(element, container, callback) {
- {
- error('ReactDOM.render is no longer supported in React 18. Use createRoot ' + 'instead. Until you switch to the new API, your app will behave as ' + "if it's running React 17. Learn " + 'more: https://reactjs.org/link/switch-to-createroot');
- }
-
- if (!isValidContainerLegacy(container)) {
- throw new Error('Target container is not a DOM element.');
- }
-
- {
- var isModernRoot = isContainerMarkedAsRoot(container) && container._reactRootContainer === undefined;
-
- if (isModernRoot) {
- error('You are calling ReactDOM.render() on a container that was previously ' + 'passed to ReactDOMClient.createRoot(). This is not supported. ' + 'Did you mean to call root.render(element)?');
- }
- }
-
- return legacyRenderSubtreeIntoContainer(null, element, container, false, callback);
- }
- function unstable_renderSubtreeIntoContainer(parentComponent, element, containerNode, callback) {
- {
- error('ReactDOM.unstable_renderSubtreeIntoContainer() is no longer supported ' + 'in React 18. Consider using a portal instead. Until you switch to ' + "the createRoot API, your app will behave as if it's running React " + '17. Learn more: https://reactjs.org/link/switch-to-createroot');
- }
-
- if (!isValidContainerLegacy(containerNode)) {
- throw new Error('Target container is not a DOM element.');
- }
-
- if (parentComponent == null || !has(parentComponent)) {
- throw new Error('parentComponent must be a valid React Component');
- }
-
- return legacyRenderSubtreeIntoContainer(parentComponent, element, containerNode, false, callback);
- }
- var didWarnAboutUnmountComponentAtNode = false;
- function unmountComponentAtNode(container) {
- {
- if (!didWarnAboutUnmountComponentAtNode) {
- didWarnAboutUnmountComponentAtNode = true;
-
- error('unmountComponentAtNode is deprecated and will be removed in the ' + 'next major release. Switch to the createRoot API. Learn ' + 'more: https://reactjs.org/link/switch-to-createroot');
- }
- }
-
- if (!isValidContainerLegacy(container)) {
- throw new Error('unmountComponentAtNode(...): Target container is not a DOM element.');
- }
-
- {
- var isModernRoot = isContainerMarkedAsRoot(container) && container._reactRootContainer === undefined;
-
- if (isModernRoot) {
- error('You are calling ReactDOM.unmountComponentAtNode() on a container that was previously ' + 'passed to ReactDOMClient.createRoot(). This is not supported. Did you mean to call root.unmount()?');
- }
- }
-
- if (container._reactRootContainer) {
- {
- var rootEl = getReactRootElementInContainer(container);
- var renderedByDifferentReact = rootEl && !getInstanceFromNode(rootEl);
-
- if (renderedByDifferentReact) {
- error("unmountComponentAtNode(): The node you're attempting to unmount " + 'was rendered by another copy of React.');
- }
- } // Unmount should not be batched.
-
-
- flushSync(function () {
- legacyRenderSubtreeIntoContainer(null, null, container, false, function () {
- // $FlowFixMe This should probably use `delete container._reactRootContainer`
- container._reactRootContainer = null;
- unmarkContainerAsRoot(container);
- });
- }); // If you call unmountComponentAtNode twice in quick succession, you'll
- // get `true` twice. That's probably fine?
-
- return true;
- } else {
- {
- var _rootEl = getReactRootElementInContainer(container);
-
- var hasNonRootReactChild = !!(_rootEl && getInstanceFromNode(_rootEl)); // Check if the container itself is a React root node.
-
- var isContainerReactRoot = container.nodeType === ELEMENT_NODE && isValidContainerLegacy(container.parentNode) && !!container.parentNode._reactRootContainer;
-
- if (hasNonRootReactChild) {
- error("unmountComponentAtNode(): The node you're attempting to unmount " + 'was rendered by React and is not a top-level container. %s', isContainerReactRoot ? 'You may have accidentally passed in a React root node instead ' + 'of its container.' : 'Instead, have the parent component update its state and ' + 'rerender in order to remove this component.');
- }
- }
-
- return false;
- }
- }
-
- setAttemptSynchronousHydration(attemptSynchronousHydration$1);
- setAttemptContinuousHydration(attemptContinuousHydration$1);
- setAttemptHydrationAtCurrentPriority(attemptHydrationAtCurrentPriority$1);
- setGetCurrentUpdatePriority(getCurrentUpdatePriority);
- setAttemptHydrationAtPriority(runWithPriority);
-
- {
- if (typeof Map !== 'function' || // $FlowIssue Flow incorrectly thinks Map has no prototype
- Map.prototype == null || typeof Map.prototype.forEach !== 'function' || typeof Set !== 'function' || // $FlowIssue Flow incorrectly thinks Set has no prototype
- Set.prototype == null || typeof Set.prototype.clear !== 'function' || typeof Set.prototype.forEach !== 'function') {
- error('React depends on Map and Set built-in types. Make sure that you load a ' + 'polyfill in older browsers. https://reactjs.org/link/react-polyfills');
- }
- }
-
- setRestoreImplementation(restoreControlledState$3);
- setBatchingImplementation(batchedUpdates$1, discreteUpdates, flushSync);
-
- function createPortal$1(children, container) {
- var key = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
-
- if (!isValidContainer(container)) {
- throw new Error('Target container is not a DOM element.');
- } // TODO: pass ReactDOM portal implementation as third argument
- // $FlowFixMe The Flow type is opaque but there's no way to actually create it.
-
-
- return createPortal(children, container, null, key);
- }
-
- function renderSubtreeIntoContainer(parentComponent, element, containerNode, callback) {
- return unstable_renderSubtreeIntoContainer(parentComponent, element, containerNode, callback);
- }
-
- var Internals = {
- usingClientEntryPoint: false,
- // Keep in sync with ReactTestUtils.js.
- // This is an array for better minification.
- Events: [getInstanceFromNode, getNodeFromInstance, getFiberCurrentPropsFromNode, enqueueStateRestore, restoreStateIfNeeded, batchedUpdates$1]
- };
-
- function createRoot$1(container, options) {
- {
- if (!Internals.usingClientEntryPoint && !true) {
- error('You are importing createRoot from "react-dom" which is not supported. ' + 'You should instead import it from "react-dom/client".');
- }
- }
-
- return createRoot(container, options);
- }
-
- function hydrateRoot$1(container, initialChildren, options) {
- {
- if (!Internals.usingClientEntryPoint && !true) {
- error('You are importing hydrateRoot from "react-dom" which is not supported. ' + 'You should instead import it from "react-dom/client".');
- }
- }
-
- return hydrateRoot(container, initialChildren, options);
- } // Overload the definition to the two valid signatures.
- // Warning, this opts-out of checking the function body.
-
-
- // eslint-disable-next-line no-redeclare
- function flushSync$1(fn) {
- {
- if (isAlreadyRendering()) {
- error('flushSync was called from inside a lifecycle method. React cannot ' + 'flush when React is already rendering. Consider moving this call to ' + 'a scheduler task or micro task.');
- }
- }
-
- return flushSync(fn);
- }
- var foundDevTools = injectIntoDevTools({
- findFiberByHostInstance: getClosestInstanceFromNode,
- bundleType: 1 ,
- version: ReactVersion,
- rendererPackageName: 'react-dom'
- });
-
- {
- if (!foundDevTools && canUseDOM && window.top === window.self) {
- // If we're in Chrome or Firefox, provide a download link if not installed.
- if (navigator.userAgent.indexOf('Chrome') > -1 && navigator.userAgent.indexOf('Edge') === -1 || navigator.userAgent.indexOf('Firefox') > -1) {
- var protocol = window.location.protocol; // Don't warn in exotic cases like chrome-extension://.
-
- if (/^(https?|file):$/.test(protocol)) {
- // eslint-disable-next-line react-internal/no-production-logging
- console.info('%cDownload the React DevTools ' + 'for a better development experience: ' + 'https://reactjs.org/link/react-devtools' + (protocol === 'file:' ? '\nYou might need to use a local HTTP server (instead of file://): ' + 'https://reactjs.org/link/react-devtools-faq' : ''), 'font-weight:bold');
- }
- }
- }
- }
-
- exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = Internals;
- exports.createPortal = createPortal$1;
- exports.createRoot = createRoot$1;
- exports.findDOMNode = findDOMNode;
- exports.flushSync = flushSync$1;
- exports.hydrate = hydrate;
- exports.hydrateRoot = hydrateRoot$1;
- exports.render = render;
- exports.unmountComponentAtNode = unmountComponentAtNode;
- exports.unstable_batchedUpdates = batchedUpdates$1;
- exports.unstable_renderSubtreeIntoContainer = renderSubtreeIntoContainer;
- exports.version = ReactVersion;
-
-})));
diff --git a/public/react/react.development.js b/public/react/react.development.js
deleted file mode 100644
index dfb2710..0000000
--- a/public/react/react.development.js
+++ /dev/null
@@ -1,3343 +0,0 @@
-/**
- * @license React
- * react.development.js
- *
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-(function (global, factory) {
- typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
- typeof define === 'function' && define.amd ? define(['exports'], factory) :
- (global = global || self, factory(global.React = {}));
-}(this, (function (exports) { 'use strict';
-
- var ReactVersion = '18.3.1';
-
- // ATTENTION
- // When adding new symbols to this file,
- // Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
- // The Symbol used to tag the ReactElement-like types.
- var REACT_ELEMENT_TYPE = Symbol.for('react.element');
- var REACT_PORTAL_TYPE = Symbol.for('react.portal');
- var REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');
- var REACT_STRICT_MODE_TYPE = Symbol.for('react.strict_mode');
- var REACT_PROFILER_TYPE = Symbol.for('react.profiler');
- var REACT_PROVIDER_TYPE = Symbol.for('react.provider');
- var REACT_CONTEXT_TYPE = Symbol.for('react.context');
- var REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');
- var REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');
- var REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');
- var REACT_MEMO_TYPE = Symbol.for('react.memo');
- var REACT_LAZY_TYPE = Symbol.for('react.lazy');
- var REACT_OFFSCREEN_TYPE = Symbol.for('react.offscreen');
- var MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
- var FAUX_ITERATOR_SYMBOL = '@@iterator';
- function getIteratorFn(maybeIterable) {
- if (maybeIterable === null || typeof maybeIterable !== 'object') {
- return null;
- }
-
- var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
-
- if (typeof maybeIterator === 'function') {
- return maybeIterator;
- }
-
- return null;
- }
-
- /**
- * Keeps track of the current dispatcher.
- */
- var ReactCurrentDispatcher = {
- /**
- * @internal
- * @type {ReactComponent}
- */
- current: null
- };
-
- /**
- * Keeps track of the current batch's configuration such as how long an update
- * should suspend for if it needs to.
- */
- var ReactCurrentBatchConfig = {
- transition: null
- };
-
- var ReactCurrentActQueue = {
- current: null,
- // Used to reproduce behavior of `batchedUpdates` in legacy mode.
- isBatchingLegacy: false,
- didScheduleLegacyUpdate: false
- };
-
- /**
- * Keeps track of the current owner.
- *
- * The current owner is the component who should own any components that are
- * currently being constructed.
- */
- var ReactCurrentOwner = {
- /**
- * @internal
- * @type {ReactComponent}
- */
- current: null
- };
-
- var ReactDebugCurrentFrame = {};
- var currentExtraStackFrame = null;
- function setExtraStackFrame(stack) {
- {
- currentExtraStackFrame = stack;
- }
- }
-
- {
- ReactDebugCurrentFrame.setExtraStackFrame = function (stack) {
- {
- currentExtraStackFrame = stack;
- }
- }; // Stack implementation injected by the current renderer.
-
-
- ReactDebugCurrentFrame.getCurrentStack = null;
-
- ReactDebugCurrentFrame.getStackAddendum = function () {
- var stack = ''; // Add an extra top frame while an element is being validated
-
- if (currentExtraStackFrame) {
- stack += currentExtraStackFrame;
- } // Delegate to the injected renderer-specific implementation
-
-
- var impl = ReactDebugCurrentFrame.getCurrentStack;
-
- if (impl) {
- stack += impl() || '';
- }
-
- return stack;
- };
- }
-
- // -----------------------------------------------------------------------------
-
- var enableScopeAPI = false; // Experimental Create Event Handle API.
- var enableCacheElement = false;
- var enableTransitionTracing = false; // No known bugs, but needs performance testing
-
- var enableLegacyHidden = false; // Enables unstable_avoidThisFallback feature in Fiber
- // stuff. Intended to enable React core members to more easily debug scheduling
- // issues in DEV builds.
-
- var enableDebugTracing = false; // Track which Fiber(s) schedule render work.
-
- var ReactSharedInternals = {
- ReactCurrentDispatcher: ReactCurrentDispatcher,
- ReactCurrentBatchConfig: ReactCurrentBatchConfig,
- ReactCurrentOwner: ReactCurrentOwner
- };
-
- {
- ReactSharedInternals.ReactDebugCurrentFrame = ReactDebugCurrentFrame;
- ReactSharedInternals.ReactCurrentActQueue = ReactCurrentActQueue;
- }
-
- // by calls to these methods by a Babel plugin.
- //
- // In PROD (or in packages without access to React internals),
- // they are left as they are instead.
-
- function warn(format) {
- {
- {
- for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
- args[_key - 1] = arguments[_key];
- }
-
- printWarning('warn', format, args);
- }
- }
- }
- function error(format) {
- {
- {
- for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
- args[_key2 - 1] = arguments[_key2];
- }
-
- printWarning('error', format, args);
- }
- }
- }
-
- function printWarning(level, format, args) {
- // When changing this logic, you might want to also
- // update consoleWithStackDev.www.js as well.
- {
- var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
- var stack = ReactDebugCurrentFrame.getStackAddendum();
-
- if (stack !== '') {
- format += '%s';
- args = args.concat([stack]);
- } // eslint-disable-next-line react-internal/safe-string-coercion
-
-
- var argsWithFormat = args.map(function (item) {
- return String(item);
- }); // Careful: RN currently depends on this prefix
-
- argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it
- // breaks IE9: https://github.com/facebook/react/issues/13610
- // eslint-disable-next-line react-internal/no-production-logging
-
- Function.prototype.apply.call(console[level], console, argsWithFormat);
- }
- }
-
- var didWarnStateUpdateForUnmountedComponent = {};
-
- function warnNoop(publicInstance, callerName) {
- {
- var _constructor = publicInstance.constructor;
- var componentName = _constructor && (_constructor.displayName || _constructor.name) || 'ReactClass';
- var warningKey = componentName + "." + callerName;
-
- if (didWarnStateUpdateForUnmountedComponent[warningKey]) {
- return;
- }
-
- 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);
-
- didWarnStateUpdateForUnmountedComponent[warningKey] = true;
- }
- }
- /**
- * This is the abstract API for an update queue.
- */
-
-
- var ReactNoopUpdateQueue = {
- /**
- * Checks whether or not this composite component is mounted.
- * @param {ReactClass} publicInstance The instance we want to test.
- * @return {boolean} True if mounted, false otherwise.
- * @protected
- * @final
- */
- isMounted: function (publicInstance) {
- return false;
- },
-
- /**
- * Forces an update. This should only be invoked when it is known with
- * certainty that we are **not** in a DOM transaction.
- *
- * You may want to call this when you know that some deeper aspect of the
- * component's state has changed but `setState` was not called.
- *
- * This will not invoke `shouldComponentUpdate`, but it will invoke
- * `componentWillUpdate` and `componentDidUpdate`.
- *
- * @param {ReactClass} publicInstance The instance that should rerender.
- * @param {?function} callback Called after component is updated.
- * @param {?string} callerName name of the calling function in the public API.
- * @internal
- */
- enqueueForceUpdate: function (publicInstance, callback, callerName) {
- warnNoop(publicInstance, 'forceUpdate');
- },
-
- /**
- * Replaces all of the state. Always use this or `setState` to mutate state.
- * You should treat `this.state` as immutable.
- *
- * There is no guarantee that `this.state` will be immediately updated, so
- * accessing `this.state` after calling this method may return the old value.
- *
- * @param {ReactClass} publicInstance The instance that should rerender.
- * @param {object} completeState Next state.
- * @param {?function} callback Called after component is updated.
- * @param {?string} callerName name of the calling function in the public API.
- * @internal
- */
- enqueueReplaceState: function (publicInstance, completeState, callback, callerName) {
- warnNoop(publicInstance, 'replaceState');
- },
-
- /**
- * Sets a subset of the state. This only exists because _pendingState is
- * internal. This provides a merging strategy that is not available to deep
- * properties which is confusing. TODO: Expose pendingState or don't use it
- * during the merge.
- *
- * @param {ReactClass} publicInstance The instance that should rerender.
- * @param {object} partialState Next partial state to be merged with state.
- * @param {?function} callback Called after component is updated.
- * @param {?string} Name of the calling function in the public API.
- * @internal
- */
- enqueueSetState: function (publicInstance, partialState, callback, callerName) {
- warnNoop(publicInstance, 'setState');
- }
- };
-
- var assign = Object.assign;
-
- var emptyObject = {};
-
- {
- Object.freeze(emptyObject);
- }
- /**
- * Base class helpers for the updating state of a component.
- */
-
-
- function Component(props, context, updater) {
- this.props = props;
- this.context = context; // If a component has string refs, we will assign a Different object later.
-
- this.refs = emptyObject; // We initialize the default updater but the real one gets injected by the
- // renderer.
-
- this.updater = updater || ReactNoopUpdateQueue;
- }
-
- Component.prototype.isReactComponent = {};
- /**
- * Sets a subset of the state. Always use this to mutate
- * state. You should treat `this.state` as immutable.
- *
- * There is no guarantee that `this.state` will be immediately updated, so
- * accessing `this.state` after calling this method may return the old value.
- *
- * There is no guarantee that calls to `setState` will run synchronously,
- * as they may eventually be batched together. You can provide an optional
- * callback that will be executed when the call to setState is actually
- * completed.
- *
- * When a function is provided to setState, it will be called at some point in
- * the future (not synchronously). It will be called with the up to date
- * component arguments (state, props, context). These values can be Different
- * from this.* because your function may be called after receiveProps but before
- * shouldComponentUpdate, and this new state, props, and context will not yet be
- * assigned to this.
- *
- * @param {object|function} partialState Next partial state or function to
- * produce next partial state to be merged with current state.
- * @param {?function} callback Called after state is updated.
- * @final
- * @protected
- */
-
- Component.prototype.setState = function (partialState, callback) {
- if (typeof partialState !== 'object' && typeof partialState !== 'function' && partialState != null) {
- throw new Error('setState(...): takes an object of state variables to update or a ' + 'function which returns an object of state variables.');
- }
-
- this.updater.enqueueSetState(this, partialState, callback, 'setState');
- };
- /**
- * Forces an update. This should only be invoked when it is known with
- * certainty that we are **not** in a DOM transaction.
- *
- * You may want to call this when you know that some deeper aspect of the
- * component's state has changed but `setState` was not called.
- *
- * This will not invoke `shouldComponentUpdate`, but it will invoke
- * `componentWillUpdate` and `componentDidUpdate`.
- *
- * @param {?function} callback Called after update is complete.
- * @final
- * @protected
- */
-
-
- Component.prototype.forceUpdate = function (callback) {
- this.updater.enqueueForceUpdate(this, callback, 'forceUpdate');
- };
- /**
- * Deprecated APIs. These APIs used to exist on classic React classes but since
- * we would like to deprecate them, we're not going to move them over to this
- * modern base class. Instead, we define a getter that warns if it's accessed.
- */
-
-
- {
- var deprecatedAPIs = {
- isMounted: ['isMounted', 'Instead, make sure to clean up subscriptions and pending requests in ' + 'componentWillUnmount to prevent memory leaks.'],
- replaceState: ['replaceState', 'Refactor your code to use setState instead (see ' + 'https://github.com/facebook/react/issues/3236).']
- };
-
- var defineDeprecationWarning = function (methodName, info) {
- Object.defineProperty(Component.prototype, methodName, {
- get: function () {
- warn('%s(...) is deprecated in plain JavaScript React classes. %s', info[0], info[1]);
-
- return undefined;
- }
- });
- };
-
- for (var fnName in deprecatedAPIs) {
- if (deprecatedAPIs.hasOwnProperty(fnName)) {
- defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);
- }
- }
- }
-
- function ComponentDummy() {}
-
- ComponentDummy.prototype = Component.prototype;
- /**
- * Convenience component with default shallow equality check for sCU.
- */
-
- function PureComponent(props, context, updater) {
- this.props = props;
- this.context = context; // If a component has string refs, we will assign a Different object later.
-
- this.refs = emptyObject;
- this.updater = updater || ReactNoopUpdateQueue;
- }
-
- var pureComponentPrototype = PureComponent.prototype = new ComponentDummy();
- pureComponentPrototype.constructor = PureComponent; // Avoid an extra prototype jump for these methods.
-
- assign(pureComponentPrototype, Component.prototype);
- pureComponentPrototype.isPureReactComponent = true;
-
- // an immutable object with a single mutable value
- function createRef() {
- var refObject = {
- current: null
- };
-
- {
- Object.seal(refObject);
- }
-
- return refObject;
- }
-
- var isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
-
- function isArray(a) {
- return isArrayImpl(a);
- }
-
- /*
- * The `'' + value` pattern (used in in perf-sensitive code) throws for Symbol
- * and Temporal.* types. See https://github.com/facebook/react/pull/22064.
- *
- * The functions in this module will throw an easier-to-understand,
- * easier-to-debug exception with a clear errors message message explaining the
- * problem. (Instead of a confusing exception thrown inside the implementation
- * of the `value` object).
- */
- // $FlowFixMe only called in DEV, so void return is not possible.
- function typeName(value) {
- {
- // toStringTag is needed for namespaced types like Temporal.Instant
- var hasToStringTag = typeof Symbol === 'function' && Symbol.toStringTag;
- var type = hasToStringTag && value[Symbol.toStringTag] || value.constructor.name || 'Object';
- return type;
- }
- } // $FlowFixMe only called in DEV, so void return is not possible.
-
-
- function willCoercionThrow(value) {
- {
- try {
- testStringCoercion(value);
- return false;
- } catch (e) {
- return true;
- }
- }
- }
-
- function testStringCoercion(value) {
- // If you ended up here by following an exception call stack, here's what's
- // happened: you supplied an object or symbol value to React (as a prop, key,
- // DOM attribute, CSS property, string ref, etc.) and when React tried to
- // coerce it to a string using `'' + value`, an exception was thrown.
- //
- // The most common types that will cause this exception are `Symbol` instances
- // and Temporal objects like `Temporal.Instant`. But any object that has a
- // `valueOf` or `[Symbol.toPrimitive]` method that throws will also cause this
- // exception. (Library authors do this to prevent Users from using built-in
- // numeric operators like `+` or comparison operators like `>=` because custom
- // methods are needed to perform accurate arithmetic or comparison.)
- //
- // To fix the problem, coerce this object or symbol value to a string before
- // passing it to React. The most reliable way is usually `String(value)`.
- //
- // To find which value is throwing, check the browser or debugger console.
- // Before this exception was thrown, there should be `console.error` output
- // that shows the type (Symbol, Temporal.PlainDate, etc.) that caused the
- // problem and how that type was used: key, atrribute, input value prop, etc.
- // In most cases, this console output also shows the component and its
- // ancestor components where the exception happened.
- //
- // eslint-disable-next-line react-internal/safe-string-coercion
- return '' + value;
- }
- function checkKeyStringCoercion(value) {
- {
- if (willCoercionThrow(value)) {
- error('The provided key is an unsupported type %s.' + ' This value must be coerced to a string before before using it here.', typeName(value));
-
- return testStringCoercion(value); // throw (to help callers find troubleshooting comments)
- }
- }
- }
-
- function getWrappedName(outerType, innerType, wrapperName) {
- var displayName = outerType.displayName;
-
- if (displayName) {
- return displayName;
- }
-
- var functionName = innerType.displayName || innerType.name || '';
- return functionName !== '' ? wrapperName + "(" + functionName + ")" : wrapperName;
- } // Keep in sync with react-reconciler/getComponentNameFromFiber
-
-
- function getContextName(type) {
- return type.displayName || 'Context';
- } // Note that the reconciler package should generally prefer to use getComponentNameFromFiber() instead.
-
-
- function getComponentNameFromType(type) {
- if (type == null) {
- // Host root, text node or just invalid type.
- return null;
- }
-
- {
- if (typeof type.tag === 'number') {
- error('Received an unexpected object in getComponentNameFromType(). ' + 'This is likely a bug in React. Please file an issue.');
- }
- }
-
- if (typeof type === 'function') {
- return type.displayName || type.name || null;
- }
-
- if (typeof type === 'string') {
- return type;
- }
-
- switch (type) {
- case REACT_FRAGMENT_TYPE:
- return 'Fragment';
-
- case REACT_PORTAL_TYPE:
- return 'Portal';
-
- case REACT_PROFILER_TYPE:
- return 'Profiler';
-
- case REACT_STRICT_MODE_TYPE:
- return 'StrictMode';
-
- case REACT_SUSPENSE_TYPE:
- return 'Suspense';
-
- case REACT_SUSPENSE_LIST_TYPE:
- return 'SuspenseList';
-
- }
-
- if (typeof type === 'object') {
- switch (type.$$typeof) {
- case REACT_CONTEXT_TYPE:
- var context = type;
- return getContextName(context) + '.Consumer';
-
- case REACT_PROVIDER_TYPE:
- var provider = type;
- return getContextName(provider._context) + '.Provider';
-
- case REACT_FORWARD_REF_TYPE:
- return getWrappedName(type, type.render, 'ForwardRef');
-
- case REACT_MEMO_TYPE:
- var outerName = type.displayName || null;
-
- if (outerName !== null) {
- return outerName;
- }
-
- return getComponentNameFromType(type.type) || 'Memo';
-
- case REACT_LAZY_TYPE:
- {
- var lazyComponent = type;
- var payload = lazyComponent._payload;
- var init = lazyComponent._init;
-
- try {
- return getComponentNameFromType(init(payload));
- } catch (x) {
- return null;
- }
- }
-
- // eslint-disable-next-line no-fallthrough
- }
- }
-
- return null;
- }
-
- var hasOwnProperty = Object.prototype.hasOwnProperty;
-
- var RESERVED_PROPS = {
- key: true,
- ref: true,
- __self: true,
- __source: true
- };
- var specialPropKeyWarningShown, specialPropRefWarningShown, didWarnAboutStringRefs;
-
- {
- didWarnAboutStringRefs = {};
- }
-
- function hasValidRef(config) {
- {
- if (hasOwnProperty.call(config, 'ref')) {
- var getter = Object.getOwnPropertyDescriptor(config, 'ref').get;
-
- if (getter && getter.isReactWarning) {
- return false;
- }
- }
- }
-
- return config.ref !== undefined;
- }
-
- function hasValidKey(config) {
- {
- if (hasOwnProperty.call(config, 'key')) {
- var getter = Object.getOwnPropertyDescriptor(config, 'key').get;
-
- if (getter && getter.isReactWarning) {
- return false;
- }
- }
- }
-
- return config.key !== undefined;
- }
-
- function defineKeyPropWarningGetter(props, displayName) {
- var warnAboutAccessingKey = function () {
- {
- if (!specialPropKeyWarningShown) {
- specialPropKeyWarningShown = true;
-
- 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);
- }
- }
- };
-
- warnAboutAccessingKey.isReactWarning = true;
- Object.defineProperty(props, 'key', {
- get: warnAboutAccessingKey,
- configurable: true
- });
- }
-
- function defineRefPropWarningGetter(props, displayName) {
- var warnAboutAccessingRef = function () {
- {
- if (!specialPropRefWarningShown) {
- specialPropRefWarningShown = true;
-
- 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);
- }
- }
- };
-
- warnAboutAccessingRef.isReactWarning = true;
- Object.defineProperty(props, 'ref', {
- get: warnAboutAccessingRef,
- configurable: true
- });
- }
-
- function warnIfStringRefCannotBeAutoConverted(config) {
- {
- if (typeof config.ref === 'string' && ReactCurrentOwner.current && config.__self && ReactCurrentOwner.current.stateNode !== config.__self) {
- var componentName = getComponentNameFromType(ReactCurrentOwner.current.type);
-
- if (!didWarnAboutStringRefs[componentName]) {
- 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);
-
- didWarnAboutStringRefs[componentName] = true;
- }
- }
- }
- }
- /**
- * Factory method to create a new React element. This no longer adheres to
- * the class pattern, so do not use new to call it. Also, instanceof check
- * will not work. Instead test $$typeof field against Symbol.for('react.element') to check
- * if something is a React Element.
- *
- * @param {*} type
- * @param {*} props
- * @param {*} key
- * @param {string|object} ref
- * @param {*} owner
- * @param {*} self A *temporary* helper to detect places where `this` is
- * Different from the `owner` when React.createElement is called, so that we
- * can warn. We want to get rid of owner and replace string `ref`s with arrow
- * functions, and as long as `this` and owner are the same, there will be no
- * change in behavior.
- * @param {*} source An annotation object (added by a transpiler or otherwise)
- * indicating filename, line number, and/or other information.
- * @internal
- */
-
-
- var ReactElement = function (type, key, ref, self, source, owner, props) {
- var element = {
- // This tag allows us to uniquely identify this as a React Element
- $$typeof: REACT_ELEMENT_TYPE,
- // Built-in properties that belong on the element
- type: type,
- key: key,
- ref: ref,
- props: props,
- // Record the component responsible for creating this element.
- _owner: owner
- };
-
- {
- // The validation flag is currently mutative. We put it on
- // an external backing store so that we can freeze the whole object.
- // This can be replaced with a WeakMap once they are implemented in
- // commonly used development environments.
- element._store = {}; // To make comparing ReactElements easier for testing purposes, we make
- // the validation flag non-enumerable (where possible, which should
- // include every environment we run tests in), so the test framework
- // ignores it.
-
- Object.defineProperty(element._store, 'validated', {
- configurable: false,
- enumerable: false,
- writable: true,
- value: false
- }); // self and source are DEV only properties.
-
- Object.defineProperty(element, '_self', {
- configurable: false,
- enumerable: false,
- writable: false,
- value: self
- }); // Two elements created in two Different places should be considered
- // equal for testing purposes and therefore we hide it from enumeration.
-
- Object.defineProperty(element, '_source', {
- configurable: false,
- enumerable: false,
- writable: false,
- value: source
- });
-
- if (Object.freeze) {
- Object.freeze(element.props);
- Object.freeze(element);
- }
- }
-
- return element;
- };
- /**
- * Create and return a new ReactElement of the given type.
- * See https://reactjs.org/docs/react-api.html#createelement
- */
-
- function createElement(type, config, children) {
- var propName; // Reserved names are extracted
-
- var props = {};
- var key = null;
- var ref = null;
- var self = null;
- var source = null;
-
- if (config != null) {
- if (hasValidRef(config)) {
- ref = config.ref;
-
- {
- warnIfStringRefCannotBeAutoConverted(config);
- }
- }
-
- if (hasValidKey(config)) {
- {
- checkKeyStringCoercion(config.key);
- }
-
- key = '' + config.key;
- }
-
- self = config.__self === undefined ? null : config.__self;
- source = config.__source === undefined ? null : config.__source; // Remaining properties are added to a new props object
-
- for (propName in config) {
- if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
- props[propName] = config[propName];
- }
- }
- } // Children can be more than one argument, and those are transferred onto
- // the newly allocated props object.
-
-
- var childrenLength = arguments.length - 2;
-
- if (childrenLength === 1) {
- props.children = children;
- } else if (childrenLength > 1) {
- var childArray = Array(childrenLength);
-
- for (var i = 0; i < childrenLength; i++) {
- childArray[i] = arguments[i + 2];
- }
-
- {
- if (Object.freeze) {
- Object.freeze(childArray);
- }
- }
-
- props.children = childArray;
- } // Resolve default props
-
-
- if (type && type.defaultProps) {
- var defaultProps = type.defaultProps;
-
- for (propName in defaultProps) {
- if (props[propName] === undefined) {
- props[propName] = defaultProps[propName];
- }
- }
- }
-
- {
- if (key || ref) {
- var displayName = typeof type === 'function' ? type.displayName || type.name || 'Unknown' : type;
-
- if (key) {
- defineKeyPropWarningGetter(props, displayName);
- }
-
- if (ref) {
- defineRefPropWarningGetter(props, displayName);
- }
- }
- }
-
- return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);
- }
- function cloneAndReplaceKey(oldElement, newKey) {
- var newElement = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props);
- return newElement;
- }
- /**
- * Clone and return a new ReactElement using element as the starting point.
- * See https://reactjs.org/docs/react-api.html#cloneelement
- */
-
- function cloneElement(element, config, children) {
- if (element === null || element === undefined) {
- throw new Error("React.cloneElement(...): The argument must be a React element, but you passed " + element + ".");
- }
-
- var propName; // Original props are copied
-
- var props = assign({}, element.props); // Reserved names are extracted
-
- var key = element.key;
- var ref = element.ref; // Self is preserved since the owner is preserved.
-
- var self = element._self; // Source is preserved since cloneElement is unlikely to be targeted by a
- // transpiler, and the original source is probably a better indicator of the
- // true owner.
-
- var source = element._source; // Owner will be preserved, unless ref is overridden
-
- var owner = element._owner;
-
- if (config != null) {
- if (hasValidRef(config)) {
- // Silently steal the ref from the parent.
- ref = config.ref;
- owner = ReactCurrentOwner.current;
- }
-
- if (hasValidKey(config)) {
- {
- checkKeyStringCoercion(config.key);
- }
-
- key = '' + config.key;
- } // Remaining properties override existing props
-
-
- var defaultProps;
-
- if (element.type && element.type.defaultProps) {
- defaultProps = element.type.defaultProps;
- }
-
- for (propName in config) {
- if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
- if (config[propName] === undefined && defaultProps !== undefined) {
- // Resolve default props
- props[propName] = defaultProps[propName];
- } else {
- props[propName] = config[propName];
- }
- }
- }
- } // Children can be more than one argument, and those are transferred onto
- // the newly allocated props object.
-
-
- var childrenLength = arguments.length - 2;
-
- if (childrenLength === 1) {
- props.children = children;
- } else if (childrenLength > 1) {
- var childArray = Array(childrenLength);
-
- for (var i = 0; i < childrenLength; i++) {
- childArray[i] = arguments[i + 2];
- }
-
- props.children = childArray;
- }
-
- return ReactElement(element.type, key, ref, self, source, owner, props);
- }
- /**
- * Verifies the object is a ReactElement.
- * See https://reactjs.org/docs/react-api.html#isvalidelement
- * @param {?object} object
- * @return {boolean} True if `object` is a ReactElement.
- * @final
- */
-
- function isValidElement(object) {
- return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
- }
-
- var SEPARATOR = '.';
- var SUBSEPARATOR = ':';
- /**
- * Escape and wrap key so it is safe to use as a reactid
- *
- * @param {string} key to be escaped.
- * @return {string} the escaped key.
- */
-
- function escape(key) {
- var escapeRegex = /[=:]/g;
- var escaperLookup = {
- '=': '=0',
- ':': '=2'
- };
- var escapedString = key.replace(escapeRegex, function (match) {
- return escaperLookup[match];
- });
- return '$' + escapedString;
- }
- /**
- * TODO: Test that a single child and an array with one item have the same key
- * pattern.
- */
-
-
- var didWarnAboutMaps = false;
- var userProvidedKeyEscapeRegex = /\/+/g;
-
- function escapeUserProvidedKey(text) {
- return text.replace(userProvidedKeyEscapeRegex, '$&/');
- }
- /**
- * Generate a key string that identifies a element within a set.
- *
- * @param {*} element A element that could contain a manual key.
- * @param {number} index Index that is used if a manual key is not provided.
- * @return {string}
- */
-
-
- function getElementKey(element, index) {
- // Do some typechecking here since we call this blindly. We want to ensure
- // that we don't block potential future ES APIs.
- if (typeof element === 'object' && element !== null && element.key != null) {
- // Explicit key
- {
- checkKeyStringCoercion(element.key);
- }
-
- return escape('' + element.key);
- } // Implicit key determined by the index in the set
-
-
- return index.toString(36);
- }
-
- function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {
- var type = typeof children;
-
- if (type === 'undefined' || type === 'boolean') {
- // All of the above are perceived as null.
- children = null;
- }
-
- var invokeCallback = false;
-
- if (children === null) {
- invokeCallback = true;
- } else {
- switch (type) {
- case 'string':
- case 'number':
- invokeCallback = true;
- break;
-
- case 'object':
- switch (children.$$typeof) {
- case REACT_ELEMENT_TYPE:
- case REACT_PORTAL_TYPE:
- invokeCallback = true;
- }
-
- }
- }
-
- if (invokeCallback) {
- var _child = children;
- var mappedChild = callback(_child); // If it's the only child, treat the name as if it was wrapped in an array
- // so that it's consistent if the number of children grows:
-
- var childKey = nameSoFar === '' ? SEPARATOR + getElementKey(_child, 0) : nameSoFar;
-
- if (isArray(mappedChild)) {
- var escapedChildKey = '';
-
- if (childKey != null) {
- escapedChildKey = escapeUserProvidedKey(childKey) + '/';
- }
-
- mapIntoArray(mappedChild, array, escapedChildKey, '', function (c) {
- return c;
- });
- } else if (mappedChild != null) {
- if (isValidElement(mappedChild)) {
- {
- // The `if` statement here prevents auto-disabling of the safe
- // coercion ESLint rule, so we must manually disable it below.
- // $FlowFixMe Flow incorrectly thinks React.Portal doesn't have a key
- if (mappedChild.key && (!_child || _child.key !== mappedChild.key)) {
- checkKeyStringCoercion(mappedChild.key);
- }
- }
-
- mappedChild = cloneAndReplaceKey(mappedChild, // Keep both the (mapped) and old keys if they differ, just as
- // traverseAllChildren used to do for objects as children
- escapedPrefix + ( // $FlowFixMe Flow incorrectly thinks React.Portal doesn't have a key
- mappedChild.key && (!_child || _child.key !== mappedChild.key) ? // $FlowFixMe Flow incorrectly thinks existing element's key can be a number
- // eslint-disable-next-line react-internal/safe-string-coercion
- escapeUserProvidedKey('' + mappedChild.key) + '/' : '') + childKey);
- }
-
- array.push(mappedChild);
- }
-
- return 1;
- }
-
- var child;
- var nextName;
- var subtreeCount = 0; // Count of children found in the current subtree.
-
- var nextNamePrefix = nameSoFar === '' ? SEPARATOR : nameSoFar + SUBSEPARATOR;
-
- if (isArray(children)) {
- for (var i = 0; i < children.length; i++) {
- child = children[i];
- nextName = nextNamePrefix + getElementKey(child, i);
- subtreeCount += mapIntoArray(child, array, escapedPrefix, nextName, callback);
- }
- } else {
- var iteratorFn = getIteratorFn(children);
-
- if (typeof iteratorFn === 'function') {
- var iterableChildren = children;
-
- {
- // Warn about using Maps as children
- if (iteratorFn === iterableChildren.entries) {
- if (!didWarnAboutMaps) {
- warn('Using Maps as children is not supported. ' + 'Use an array of keyed ReactElements instead.');
- }
-
- didWarnAboutMaps = true;
- }
- }
-
- var iterator = iteratorFn.call(iterableChildren);
- var step;
- var ii = 0;
-
- while (!(step = iterator.next()).done) {
- child = step.value;
- nextName = nextNamePrefix + getElementKey(child, ii++);
- subtreeCount += mapIntoArray(child, array, escapedPrefix, nextName, callback);
- }
- } else if (type === 'object') {
- // eslint-disable-next-line react-internal/safe-string-coercion
- var childrenString = String(children);
- 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.');
- }
- }
-
- return subtreeCount;
- }
-
- /**
- * Maps children that are typically specified as `props.children`.
- *
- * See https://reactjs.org/docs/react-api.html#reactchildrenmap
- *
- * The provided mapFunction(child, index) will be called for each
- * leaf child.
- *
- * @param {?*} children Children tree container.
- * @param {function(*, int)} func The map function.
- * @param {*} context Context for mapFunction.
- * @return {object} Object containing the ordered map of results.
- */
- function mapChildren(children, func, context) {
- if (children == null) {
- return children;
- }
-
- var result = [];
- var count = 0;
- mapIntoArray(children, result, '', '', function (child) {
- return func.call(context, child, count++);
- });
- return result;
- }
- /**
- * Count the number of children that are typically specified as
- * `props.children`.
- *
- * See https://reactjs.org/docs/react-api.html#reactchildrencount
- *
- * @param {?*} children Children tree container.
- * @return {number} The number of children.
- */
-
-
- function countChildren(children) {
- var n = 0;
- mapChildren(children, function () {
- n++; // Don't return anything
- });
- return n;
- }
-
- /**
- * Iterates through children that are typically specified as `props.children`.
- *
- * See https://reactjs.org/docs/react-api.html#reactchildrenforeach
- *
- * The provided forEachFunc(child, index) will be called for each
- * leaf child.
- *
- * @param {?*} children Children tree container.
- * @param {function(*, int)} forEachFunc
- * @param {*} forEachContext Context for forEachContext.
- */
- function forEachChildren(children, forEachFunc, forEachContext) {
- mapChildren(children, function () {
- forEachFunc.apply(this, arguments); // Don't return anything.
- }, forEachContext);
- }
- /**
- * Flatten a children object (typically specified as `props.children`) and
- * return an array with appropriately re-keyed children.
- *
- * See https://reactjs.org/docs/react-api.html#reactchildrentoarray
- */
-
-
- function toArray(children) {
- return mapChildren(children, function (child) {
- return child;
- }) || [];
- }
- /**
- * Returns the first child in a collection of children and verifies that there
- * is only one child in the collection.
- *
- * See https://reactjs.org/docs/react-api.html#reactchildrenonly
- *
- * The current implementation of this function assumes that a single child gets
- * passed without a wrapper, but the purpose of this helper function is to
- * abstract away the particular structure of children.
- *
- * @param {?object} children Child collection structure.
- * @return {ReactElement} The first and only `ReactElement` contained in the
- * structure.
- */
-
-
- function onlyChild(children) {
- if (!isValidElement(children)) {
- throw new Error('React.Children.only expected to receive a single React element child.');
- }
-
- return children;
- }
-
- function createContext(defaultValue) {
- // TODO: Second argument used to be an optional `calculateChangedBits`
- // function. Warn to reserve for future use?
- var context = {
- $$typeof: REACT_CONTEXT_TYPE,
- // As a workaround to support multiple concurrent renderers, we categorize
- // some renderers as primary and others as secondary. We only expect
- // there to be two concurrent renderers at most: React Native (primary) and
- // Fabric (secondary); React DOM (primary) and React ART (secondary).
- // Secondary renderers store their context values on separate fields.
- _currentValue: defaultValue,
- _currentValue2: defaultValue,
- // Used to track how many concurrent renderers this context currently
- // supports within in a single renderer. Such as parallel server rendering.
- _threadCount: 0,
- // These are circular
- Provider: null,
- Consumer: null,
- // Add these to use same hidden class in VM as ServerContext
- _defaultValue: null,
- _globalName: null
- };
- context.Provider = {
- $$typeof: REACT_PROVIDER_TYPE,
- _context: context
- };
- var hasWarnedAboutUsingNestedContextConsumers = false;
- var hasWarnedAboutUsingConsumerProvider = false;
- var hasWarnedAboutDisplayNameOnConsumer = false;
-
- {
- // A separate object, but proxies back to the original context object for
- // backwards compatibility. It has a Different $$typeof, so we can properly
- // warn for the incorrect usage of Context as a Consumer.
- var Consumer = {
- $$typeof: REACT_CONTEXT_TYPE,
- _context: context
- }; // $FlowFixMe: Flow complains about not setting a value, which is intentional here
-
- Object.defineProperties(Consumer, {
- Provider: {
- get: function () {
- if (!hasWarnedAboutUsingConsumerProvider) {
- hasWarnedAboutUsingConsumerProvider = true;
-
- error('Rendering is not supported and will be removed in ' + 'a future major release. Did you mean to render instead?');
- }
-
- return context.Provider;
- },
- set: function (_Provider) {
- context.Provider = _Provider;
- }
- },
- _currentValue: {
- get: function () {
- return context._currentValue;
- },
- set: function (_currentValue) {
- context._currentValue = _currentValue;
- }
- },
- _currentValue2: {
- get: function () {
- return context._currentValue2;
- },
- set: function (_currentValue2) {
- context._currentValue2 = _currentValue2;
- }
- },
- _threadCount: {
- get: function () {
- return context._threadCount;
- },
- set: function (_threadCount) {
- context._threadCount = _threadCount;
- }
- },
- Consumer: {
- get: function () {
- if (!hasWarnedAboutUsingNestedContextConsumers) {
- hasWarnedAboutUsingNestedContextConsumers = true;
-
- error('Rendering is not supported and will be removed in ' + 'a future major release. Did you mean to render instead?');
- }
-
- return context.Consumer;
- }
- },
- displayName: {
- get: function () {
- return context.displayName;
- },
- set: function (displayName) {
- if (!hasWarnedAboutDisplayNameOnConsumer) {
- warn('Setting `displayName` on Context.Consumer has no effect. ' + "You should set it directly on the context with Context.displayName = '%s'.", displayName);
-
- hasWarnedAboutDisplayNameOnConsumer = true;
- }
- }
- }
- }); // $FlowFixMe: Flow complains about missing properties because it doesn't understand defineProperty
-
- context.Consumer = Consumer;
- }
-
- {
- context._currentRenderer = null;
- context._currentRenderer2 = null;
- }
-
- return context;
- }
-
- var Uninitialized = -1;
- var Pending = 0;
- var Resolved = 1;
- var Rejected = 2;
-
- function lazyInitializer(payload) {
- if (payload._status === Uninitialized) {
- var ctor = payload._result;
- var thenable = ctor(); // Transition to the next state.
- // This might throw either because it's missing or throws. If so, we treat it
- // as still uninitialized and try again next time. Which is the same as what
- // happens if the ctor or any wrappers processing the ctor throws. This might
- // end up fixing it if the resolution was a concurrency bug.
-
- thenable.then(function (moduleObject) {
- if (payload._status === Pending || payload._status === Uninitialized) {
- // Transition to the next state.
- var resolved = payload;
- resolved._status = Resolved;
- resolved._result = moduleObject;
- }
- }, function (error) {
- if (payload._status === Pending || payload._status === Uninitialized) {
- // Transition to the next state.
- var rejected = payload;
- rejected._status = Rejected;
- rejected._result = error;
- }
- });
-
- if (payload._status === Uninitialized) {
- // In case, we're still uninitialized, then we're waiting for the thenable
- // to resolve. Set it as pending in the meantime.
- var pending = payload;
- pending._status = Pending;
- pending._result = thenable;
- }
- }
-
- if (payload._status === Resolved) {
- var moduleObject = payload._result;
-
- {
- if (moduleObject === undefined) {
- 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.
- 'const MyComponent = lazy(() => imp' + "ort('./MyComponent'))\n\n" + 'Did you accidentally put curly braces around the import?', moduleObject);
- }
- }
-
- {
- if (!('default' in moduleObject)) {
- 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.
- 'const MyComponent = lazy(() => imp' + "ort('./MyComponent'))", moduleObject);
- }
- }
-
- return moduleObject.default;
- } else {
- throw payload._result;
- }
- }
-
- function lazy(ctor) {
- var payload = {
- // We use these fields to store the result.
- _status: Uninitialized,
- _result: ctor
- };
- var lazyType = {
- $$typeof: REACT_LAZY_TYPE,
- _payload: payload,
- _init: lazyInitializer
- };
-
- {
- // In production, this would just set it on the object.
- var defaultProps;
- var propTypes; // $FlowFixMe
-
- Object.defineProperties(lazyType, {
- defaultProps: {
- configurable: true,
- get: function () {
- return defaultProps;
- },
- set: function (newDefaultProps) {
- 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.');
-
- defaultProps = newDefaultProps; // Match production behavior more closely:
- // $FlowFixMe
-
- Object.defineProperty(lazyType, 'defaultProps', {
- enumerable: true
- });
- }
- },
- propTypes: {
- configurable: true,
- get: function () {
- return propTypes;
- },
- set: function (newPropTypes) {
- 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.');
-
- propTypes = newPropTypes; // Match production behavior more closely:
- // $FlowFixMe
-
- Object.defineProperty(lazyType, 'propTypes', {
- enumerable: true
- });
- }
- }
- });
- }
-
- return lazyType;
- }
-
- function forwardRef(render) {
- {
- if (render != null && render.$$typeof === REACT_MEMO_TYPE) {
- error('forwardRef requires a render function but received a `memo` ' + 'component. Instead of forwardRef(memo(...)), use ' + 'memo(forwardRef(...)).');
- } else if (typeof render !== 'function') {
- error('forwardRef requires a render function but was given %s.', render === null ? 'null' : typeof render);
- } else {
- if (render.length !== 0 && render.length !== 2) {
- 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.');
- }
- }
-
- if (render != null) {
- if (render.defaultProps != null || render.propTypes != null) {
- error('forwardRef render functions do not support propTypes or defaultProps. ' + 'Did you accidentally pass a React component?');
- }
- }
- }
-
- var elementType = {
- $$typeof: REACT_FORWARD_REF_TYPE,
- render: render
- };
-
- {
- var ownName;
- Object.defineProperty(elementType, 'displayName', {
- enumerable: false,
- configurable: true,
- get: function () {
- return ownName;
- },
- set: function (name) {
- ownName = name; // The inner component shouldn't inherit this display name in most cases,
- // because the component may be used elsewhere.
- // But it's nice for anonymous functions to inherit the name,
- // so that our component-stack generation logic will display their frames.
- // An anonymous function generally suggests a pattern like:
- // React.forwardRef((props, ref) => {...});
- // This kind of inner function is not used elsewhere so the side effect is okay.
-
- if (!render.name && !render.displayName) {
- render.displayName = name;
- }
- }
- });
- }
-
- return elementType;
- }
-
- var REACT_MODULE_REFERENCE;
-
- {
- REACT_MODULE_REFERENCE = Symbol.for('react.module.reference');
- }
-
- function isValidElementType(type) {
- if (typeof type === 'string' || typeof type === 'function') {
- return true;
- } // Note: typeof might be other than 'symbol' or 'number' (e.g. if it's a polyfill).
-
-
- 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 ) {
- return true;
- }
-
- if (typeof type === 'object' && type !== null) {
- 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
- // types supported by any Flight configuration anywhere since
- // we don't know which Flight build this will end up being used
- // with.
- type.$$typeof === REACT_MODULE_REFERENCE || type.getModuleId !== undefined) {
- return true;
- }
- }
-
- return false;
- }
-
- function memo(type, compare) {
- {
- if (!isValidElementType(type)) {
- error('memo: The first argument must be a component. Instead ' + 'received: %s', type === null ? 'null' : typeof type);
- }
- }
-
- var elementType = {
- $$typeof: REACT_MEMO_TYPE,
- type: type,
- compare: compare === undefined ? null : compare
- };
-
- {
- var ownName;
- Object.defineProperty(elementType, 'displayName', {
- enumerable: false,
- configurable: true,
- get: function () {
- return ownName;
- },
- set: function (name) {
- ownName = name; // The inner component shouldn't inherit this display name in most cases,
- // because the component may be used elsewhere.
- // But it's nice for anonymous functions to inherit the name,
- // so that our component-stack generation logic will display their frames.
- // An anonymous function generally suggests a pattern like:
- // React.memo((props) => {...});
- // This kind of inner function is not used elsewhere so the side effect is okay.
-
- if (!type.name && !type.displayName) {
- type.displayName = name;
- }
- }
- });
- }
-
- return elementType;
- }
-
- function resolveDispatcher() {
- var dispatcher = ReactCurrentDispatcher.current;
-
- {
- if (dispatcher === null) {
- 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.');
- }
- } // Will result in a null access error if accessed outside render phase. We
- // intentionally don't throw our own error because this is in a hot path.
- // Also helps ensure this is inlined.
-
-
- return dispatcher;
- }
- function useContext(Context) {
- var dispatcher = resolveDispatcher();
-
- {
- // TODO: add a more generic warning for invalid values.
- if (Context._context !== undefined) {
- var realContext = Context._context; // Don't deduplicate because this legitimately causes bugs
- // and nobody should be using this in existing code.
-
- if (realContext.Consumer === Context) {
- 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?');
- } else if (realContext.Provider === Context) {
- error('Calling useContext(Context.Provider) is not supported. ' + 'Did you mean to call useContext(Context) instead?');
- }
- }
- }
-
- return dispatcher.useContext(Context);
- }
- function useState(initialState) {
- var dispatcher = resolveDispatcher();
- return dispatcher.useState(initialState);
- }
- function useReducer(reducer, initialArg, init) {
- var dispatcher = resolveDispatcher();
- return dispatcher.useReducer(reducer, initialArg, init);
- }
- function useRef(initialValue) {
- var dispatcher = resolveDispatcher();
- return dispatcher.useRef(initialValue);
- }
- function useEffect(create, deps) {
- var dispatcher = resolveDispatcher();
- return dispatcher.useEffect(create, deps);
- }
- function useInsertionEffect(create, deps) {
- var dispatcher = resolveDispatcher();
- return dispatcher.useInsertionEffect(create, deps);
- }
- function useLayoutEffect(create, deps) {
- var dispatcher = resolveDispatcher();
- return dispatcher.useLayoutEffect(create, deps);
- }
- function useCallback(callback, deps) {
- var dispatcher = resolveDispatcher();
- return dispatcher.useCallback(callback, deps);
- }
- function useMemo(create, deps) {
- var dispatcher = resolveDispatcher();
- return dispatcher.useMemo(create, deps);
- }
- function useImperativeHandle(ref, create, deps) {
- var dispatcher = resolveDispatcher();
- return dispatcher.useImperativeHandle(ref, create, deps);
- }
- function useDebugValue(value, formatterFn) {
- {
- var dispatcher = resolveDispatcher();
- return dispatcher.useDebugValue(value, formatterFn);
- }
- }
- function useTransition() {
- var dispatcher = resolveDispatcher();
- return dispatcher.useTransition();
- }
- function useDeferredValue(value) {
- var dispatcher = resolveDispatcher();
- return dispatcher.useDeferredValue(value);
- }
- function useId() {
- var dispatcher = resolveDispatcher();
- return dispatcher.useId();
- }
- function useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
- var dispatcher = resolveDispatcher();
- return dispatcher.useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
- }
-
- // Helpers to patch console.logs to avoid logging during side-effect free
- // replaying on render function. This currently only patches the object
- // lazily which won't cover if the log function was extracted eagerly.
- // We could also eagerly patch the method.
- var disabledDepth = 0;
- var prevLog;
- var prevInfo;
- var prevWarn;
- var prevError;
- var prevGroup;
- var prevGroupCollapsed;
- var prevGroupEnd;
-
- function disabledLog() {}
-
- disabledLog.__reactDisabledLog = true;
- function disableLogs() {
- {
- if (disabledDepth === 0) {
- /* eslint-disable react-internal/no-production-logging */
- prevLog = console.log;
- prevInfo = console.info;
- prevWarn = console.warn;
- prevError = console.error;
- prevGroup = console.group;
- prevGroupCollapsed = console.groupCollapsed;
- prevGroupEnd = console.groupEnd; // https://github.com/facebook/react/issues/19099
-
- var props = {
- configurable: true,
- enumerable: true,
- value: disabledLog,
- writable: true
- }; // $FlowFixMe Flow thinks console is immutable.
-
- Object.defineProperties(console, {
- info: props,
- log: props,
- warn: props,
- error: props,
- group: props,
- groupCollapsed: props,
- groupEnd: props
- });
- /* eslint-enable react-internal/no-production-logging */
- }
-
- disabledDepth++;
- }
- }
- function reenableLogs() {
- {
- disabledDepth--;
-
- if (disabledDepth === 0) {
- /* eslint-disable react-internal/no-production-logging */
- var props = {
- configurable: true,
- enumerable: true,
- writable: true
- }; // $FlowFixMe Flow thinks console is immutable.
-
- Object.defineProperties(console, {
- log: assign({}, props, {
- value: prevLog
- }),
- info: assign({}, props, {
- value: prevInfo
- }),
- warn: assign({}, props, {
- value: prevWarn
- }),
- error: assign({}, props, {
- value: prevError
- }),
- group: assign({}, props, {
- value: prevGroup
- }),
- groupCollapsed: assign({}, props, {
- value: prevGroupCollapsed
- }),
- groupEnd: assign({}, props, {
- value: prevGroupEnd
- })
- });
- /* eslint-enable react-internal/no-production-logging */
- }
-
- if (disabledDepth < 0) {
- error('disabledDepth fell below zero. ' + 'This is a bug in React. Please file an issue.');
- }
- }
- }
-
- var ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher;
- var prefix;
- function describeBuiltInComponentFrame(name, source, ownerFn) {
- {
- if (prefix === undefined) {
- // Extract the VM specific prefix used by each line.
- try {
- throw Error();
- } catch (x) {
- var match = x.stack.trim().match(/\n( *(at )?)/);
- prefix = match && match[1] || '';
- }
- } // We use the prefix to ensure our stacks line up with native stack frames.
-
-
- return '\n' + prefix + name;
- }
- }
- var reentry = false;
- var componentFrameCache;
-
- {
- var PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map;
- componentFrameCache = new PossiblyWeakMap();
- }
-
- function describeNativeComponentFrame(fn, construct) {
- // If something asked for a stack inside a fake render, it should get ignored.
- if ( !fn || reentry) {
- return '';
- }
-
- {
- var frame = componentFrameCache.get(fn);
-
- if (frame !== undefined) {
- return frame;
- }
- }
-
- var control;
- reentry = true;
- var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe It does accept undefined.
-
- Error.prepareStackTrace = undefined;
- var previousDispatcher;
-
- {
- previousDispatcher = ReactCurrentDispatcher$1.current; // Set the dispatcher in DEV because this might be call in the render function
- // for warnings.
-
- ReactCurrentDispatcher$1.current = null;
- disableLogs();
- }
-
- try {
- // This should throw.
- if (construct) {
- // Something should be setting the props in the constructor.
- var Fake = function () {
- throw Error();
- }; // $FlowFixMe
-
-
- Object.defineProperty(Fake.prototype, 'props', {
- set: function () {
- // We use a throwing setter instead of frozen or non-writable props
- // because that won't throw in a non-strict mode function.
- throw Error();
- }
- });
-
- if (typeof Reflect === 'object' && Reflect.construct) {
- // We construct a Different control for this case to include any extra
- // frames added by the construct call.
- try {
- Reflect.construct(Fake, []);
- } catch (x) {
- control = x;
- }
-
- Reflect.construct(fn, [], Fake);
- } else {
- try {
- Fake.call();
- } catch (x) {
- control = x;
- }
-
- fn.call(Fake.prototype);
- }
- } else {
- try {
- throw Error();
- } catch (x) {
- control = x;
- }
-
- fn();
- }
- } catch (sample) {
- // This is inlined manually because closure doesn't do it for us.
- if (sample && control && typeof sample.stack === 'string') {
- // This extracts the first frame from the sample that isn't also in the control.
- // Skipping one frame that we assume is the frame that calls the two.
- var sampleLines = sample.stack.split('\n');
- var controlLines = control.stack.split('\n');
- var s = sampleLines.length - 1;
- var c = controlLines.length - 1;
-
- while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
- // We expect at least one stack frame to be shared.
- // Typically this will be the root most one. However, stack frames may be
- // cut off due to maximum stack limits. In this case, one maybe cut off
- // earlier than the other. We assume that the sample is longer or the same
- // and there for cut off earlier. So we should find the root most frame in
- // the sample somewhere in the control.
- c--;
- }
-
- for (; s >= 1 && c >= 0; s--, c--) {
- // Next we find the first one that isn't the same which should be the
- // frame that called our sample function and the control.
- if (sampleLines[s] !== controlLines[c]) {
- // In V8, the first line is describing the message but other VMs don't.
- // If we're about to return the first line, and the control is also on the same
- // line, that's a pretty good indicator that our sample threw at same line as
- // the control. I.e. before we entered the sample frame. So we ignore this result.
- // This can happen if you passed a class to function component, or non-function.
- if (s !== 1 || c !== 1) {
- do {
- s--;
- c--; // We may still have similar intermediate frames from the construct call.
- // The next one that isn't the same should be our match though.
-
- if (c < 0 || sampleLines[s] !== controlLines[c]) {
- // V8 adds a "new" prefix for native classes. Let's remove it to make it prettier.
- var _frame = '\n' + sampleLines[s].replace(' at new ', ' at '); // If our component frame is labeled ""
- // but we have a user-provided "displayName"
- // splice it in to make the stack more readable.
-
-
- if (fn.displayName && _frame.includes('')) {
- _frame = _frame.replace('', fn.displayName);
- }
-
- {
- if (typeof fn === 'function') {
- componentFrameCache.set(fn, _frame);
- }
- } // Return the line we found.
-
-
- return _frame;
- }
- } while (s >= 1 && c >= 0);
- }
-
- break;
- }
- }
- }
- } finally {
- reentry = false;
-
- {
- ReactCurrentDispatcher$1.current = previousDispatcher;
- reenableLogs();
- }
-
- Error.prepareStackTrace = previousPrepareStackTrace;
- } // Fallback to just using the name if we couldn't make it throw.
-
-
- var name = fn ? fn.displayName || fn.name : '';
- var syntheticFrame = name ? describeBuiltInComponentFrame(name) : '';
-
- {
- if (typeof fn === 'function') {
- componentFrameCache.set(fn, syntheticFrame);
- }
- }
-
- return syntheticFrame;
- }
- function describeFunctionComponentFrame(fn, source, ownerFn) {
- {
- return describeNativeComponentFrame(fn, false);
- }
- }
-
- function shouldConstruct(Component) {
- var prototype = Component.prototype;
- return !!(prototype && prototype.isReactComponent);
- }
-
- function describeUnknownElementTypeFrameInDEV(type, source, ownerFn) {
-
- if (type == null) {
- return '';
- }
-
- if (typeof type === 'function') {
- {
- return describeNativeComponentFrame(type, shouldConstruct(type));
- }
- }
-
- if (typeof type === 'string') {
- return describeBuiltInComponentFrame(type);
- }
-
- switch (type) {
- case REACT_SUSPENSE_TYPE:
- return describeBuiltInComponentFrame('Suspense');
-
- case REACT_SUSPENSE_LIST_TYPE:
- return describeBuiltInComponentFrame('SuspenseList');
- }
-
- if (typeof type === 'object') {
- switch (type.$$typeof) {
- case REACT_FORWARD_REF_TYPE:
- return describeFunctionComponentFrame(type.render);
-
- case REACT_MEMO_TYPE:
- // Memo may contain any component type so we recursively resolve it.
- return describeUnknownElementTypeFrameInDEV(type.type, source, ownerFn);
-
- case REACT_LAZY_TYPE:
- {
- var lazyComponent = type;
- var payload = lazyComponent._payload;
- var init = lazyComponent._init;
-
- try {
- // Lazy may contain any component type so we recursively resolve it.
- return describeUnknownElementTypeFrameInDEV(init(payload), source, ownerFn);
- } catch (x) {}
- }
- }
- }
-
- return '';
- }
-
- var loggedTypeFailures = {};
- var ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame;
-
- function setCurrentlyValidatingElement(element) {
- {
- if (element) {
- var owner = element._owner;
- var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
- ReactDebugCurrentFrame$1.setExtraStackFrame(stack);
- } else {
- ReactDebugCurrentFrame$1.setExtraStackFrame(null);
- }
- }
- }
-
- function checkPropTypes(typeSpecs, values, location, componentName, element) {
- {
- // $FlowFixMe This is okay but Flow doesn't know it.
- var has = Function.call.bind(hasOwnProperty);
-
- for (var typeSpecName in typeSpecs) {
- if (has(typeSpecs, typeSpecName)) {
- var error$1 = void 0; // Prop type validation may throw. In case they do, we don't want to
- // fail the render phase where it didn't fail before. So we log it.
- // After these have been cleaned up, we'll let them throw.
-
- try {
- // This is intentionally an invariant that gets caught. It's the same
- // behavior as without this statement except with a better message.
- if (typeof typeSpecs[typeSpecName] !== 'function') {
- // eslint-disable-next-line react-internal/prod-error-codes
- var err = Error((componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' + 'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.' + 'This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.');
- err.name = 'Invariant Violation';
- throw err;
- }
-
- error$1 = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED');
- } catch (ex) {
- error$1 = ex;
- }
-
- if (error$1 && !(error$1 instanceof Error)) {
- setCurrentlyValidatingElement(element);
-
- 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);
-
- setCurrentlyValidatingElement(null);
- }
-
- if (error$1 instanceof Error && !(error$1.message in loggedTypeFailures)) {
- // Only monitor this failure once because there tends to be a lot of the
- // same error.
- loggedTypeFailures[error$1.message] = true;
- setCurrentlyValidatingElement(element);
-
- error('Failed %s type: %s', location, error$1.message);
-
- setCurrentlyValidatingElement(null);
- }
- }
- }
- }
- }
-
- function setCurrentlyValidatingElement$1(element) {
- {
- if (element) {
- var owner = element._owner;
- var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
- setExtraStackFrame(stack);
- } else {
- setExtraStackFrame(null);
- }
- }
- }
-
- var propTypesMisspellWarningShown;
-
- {
- propTypesMisspellWarningShown = false;
- }
-
- function getDeclarationErrorAddendum() {
- if (ReactCurrentOwner.current) {
- var name = getComponentNameFromType(ReactCurrentOwner.current.type);
-
- if (name) {
- return '\n\nCheck the render method of `' + name + '`.';
- }
- }
-
- return '';
- }
-
- function getSourceInfoErrorAddendum(source) {
- if (source !== undefined) {
- var fileName = source.fileName.replace(/^.*[\\\/]/, '');
- var lineNumber = source.lineNumber;
- return '\n\nCheck your code at ' + fileName + ':' + lineNumber + '.';
- }
-
- return '';
- }
-
- function getSourceInfoErrorAddendumForProps(elementProps) {
- if (elementProps !== null && elementProps !== undefined) {
- return getSourceInfoErrorAddendum(elementProps.__source);
- }
-
- return '';
- }
- /**
- * Warn if there's no key explicitly set on dynamic arrays of children or
- * object keys are not valid. This allows us to keep track of children between
- * updates.
- */
-
-
- var ownerHasKeyUseWarning = {};
-
- function getCurrentComponentErrorInfo(parentType) {
- var info = getDeclarationErrorAddendum();
-
- if (!info) {
- var parentName = typeof parentType === 'string' ? parentType : parentType.displayName || parentType.name;
-
- if (parentName) {
- info = "\n\nCheck the top-level render call using <" + parentName + ">.";
- }
- }
-
- return info;
- }
- /**
- * Warn if the element doesn't have an explicit key assigned to it.
- * This element is in an array. The array could grow and shrink or be
- * reordered. All children that haven't already been validated are required to
- * have a "key" property assigned to it. Error statuses are cached so a warning
- * will only be shown once.
- *
- * @internal
- * @param {ReactElement} element Element that requires a key.
- * @param {*} parentType element's parent's type.
- */
-
-
- function validateExplicitKey(element, parentType) {
- if (!element._store || element._store.validated || element.key != null) {
- return;
- }
-
- element._store.validated = true;
- var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType);
-
- if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {
- return;
- }
-
- ownerHasKeyUseWarning[currentComponentErrorInfo] = true; // Usually the current owner is the offender, but if it accepts children as a
- // property, it may be the creator of the child that's responsible for
- // assigning it a key.
-
- var childOwner = '';
-
- if (element && element._owner && element._owner !== ReactCurrentOwner.current) {
- // Give the component that originally created this child.
- childOwner = " It was passed a child from " + getComponentNameFromType(element._owner.type) + ".";
- }
-
- {
- setCurrentlyValidatingElement$1(element);
-
- 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);
-
- setCurrentlyValidatingElement$1(null);
- }
- }
- /**
- * Ensure that every element either is passed in a static location, in an
- * array with an explicit keys property defined, or in an object literal
- * with valid key property.
- *
- * @internal
- * @param {ReactNode} node Statically passed child of any type.
- * @param {*} parentType node's parent's type.
- */
-
-
- function validateChildKeys(node, parentType) {
- if (typeof node !== 'object') {
- return;
- }
-
- if (isArray(node)) {
- for (var i = 0; i < node.length; i++) {
- var child = node[i];
-
- if (isValidElement(child)) {
- validateExplicitKey(child, parentType);
- }
- }
- } else if (isValidElement(node)) {
- // This element was passed in a valid location.
- if (node._store) {
- node._store.validated = true;
- }
- } else if (node) {
- var iteratorFn = getIteratorFn(node);
-
- if (typeof iteratorFn === 'function') {
- // Entry iterators used to provide implicit keys,
- // but now we print a separate warning for them later.
- if (iteratorFn !== node.entries) {
- var iterator = iteratorFn.call(node);
- var step;
-
- while (!(step = iterator.next()).done) {
- if (isValidElement(step.value)) {
- validateExplicitKey(step.value, parentType);
- }
- }
- }
- }
- }
- }
- /**
- * Given an element, validate that its props follow the propTypes definition,
- * provided by the type.
- *
- * @param {ReactElement} element
- */
-
-
- function validatePropTypes(element) {
- {
- var type = element.type;
-
- if (type === null || type === undefined || typeof type === 'string') {
- return;
- }
-
- var propTypes;
-
- if (typeof type === 'function') {
- propTypes = type.propTypes;
- } else if (typeof type === 'object' && (type.$$typeof === REACT_FORWARD_REF_TYPE || // Note: Memo only checks outer props here.
- // Inner props are checked in the reconciler.
- type.$$typeof === REACT_MEMO_TYPE)) {
- propTypes = type.propTypes;
- } else {
- return;
- }
-
- if (propTypes) {
- // Intentionally inside to avoid triggering lazy initializers:
- var name = getComponentNameFromType(type);
- checkPropTypes(propTypes, element.props, 'prop', name, element);
- } else if (type.PropTypes !== undefined && !propTypesMisspellWarningShown) {
- propTypesMisspellWarningShown = true; // Intentionally inside to avoid triggering lazy initializers:
-
- var _name = getComponentNameFromType(type);
-
- error('Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?', _name || 'Unknown');
- }
-
- if (typeof type.getDefaultProps === 'function' && !type.getDefaultProps.isReactClassApproved) {
- error('getDefaultProps is only used on classic React.createClass ' + 'definitions. Use a static property named `defaultProps` instead.');
- }
- }
- }
- /**
- * Given a fragment, validate that it can only be provided with fragment props
- * @param {ReactElement} fragment
- */
-
-
- function validateFragmentProps(fragment) {
- {
- var keys = Object.keys(fragment.props);
-
- for (var i = 0; i < keys.length; i++) {
- var key = keys[i];
-
- if (key !== 'children' && key !== 'key') {
- setCurrentlyValidatingElement$1(fragment);
-
- error('Invalid prop `%s` supplied to `React.Fragment`. ' + 'React.Fragment can only have `key` and `children` props.', key);
-
- setCurrentlyValidatingElement$1(null);
- break;
- }
- }
-
- if (fragment.ref !== null) {
- setCurrentlyValidatingElement$1(fragment);
-
- error('Invalid attribute `ref` supplied to `React.Fragment`.');
-
- setCurrentlyValidatingElement$1(null);
- }
- }
- }
- function createElementWithValidation(type, props, children) {
- var validType = isValidElementType(type); // We warn in this case but don't throw. We expect the element creation to
- // succeed and there will likely be errors in render.
-
- if (!validType) {
- var info = '';
-
- if (type === undefined || typeof type === 'object' && type !== null && Object.keys(type).length === 0) {
- info += ' You likely forgot to export your component from the file ' + "it's defined in, or you might have mixed up default and named imports.";
- }
-
- var sourceInfo = getSourceInfoErrorAddendumForProps(props);
-
- if (sourceInfo) {
- info += sourceInfo;
- } else {
- info += getDeclarationErrorAddendum();
- }
-
- var typeString;
-
- if (type === null) {
- typeString = 'null';
- } else if (isArray(type)) {
- typeString = 'array';
- } else if (type !== undefined && type.$$typeof === REACT_ELEMENT_TYPE) {
- typeString = "<" + (getComponentNameFromType(type.type) || 'Unknown') + " />";
- info = ' Did you accidentally export a JSX literal instead of a component?';
- } else {
- typeString = typeof type;
- }
-
- {
- 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);
- }
- }
-
- var element = createElement.apply(this, arguments); // The result can be nullish if a mock or a custom function is used.
- // TODO: Drop this when these are no longer allowed as the type argument.
-
- if (element == null) {
- return element;
- } // Skip key warning if the type isn't valid since our key validation logic
- // doesn't expect a non-string/function type and can throw confusing errors.
- // We don't want exception behavior to differ between dev.log and prod.
- // (Rendering will throw with a helpful message and as soon as the type is
- // fixed, the key warnings will appear.)
-
-
- if (validType) {
- for (var i = 2; i < arguments.length; i++) {
- validateChildKeys(arguments[i], type);
- }
- }
-
- if (type === REACT_FRAGMENT_TYPE) {
- validateFragmentProps(element);
- } else {
- validatePropTypes(element);
- }
-
- return element;
- }
- var didWarnAboutDeprecatedCreateFactory = false;
- function createFactoryWithValidation(type) {
- var validatedFactory = createElementWithValidation.bind(null, type);
- validatedFactory.type = type;
-
- {
- if (!didWarnAboutDeprecatedCreateFactory) {
- didWarnAboutDeprecatedCreateFactory = true;
-
- warn('React.createFactory() is deprecated and will be removed in ' + 'a future major release. Consider using JSX ' + 'or use React.createElement() directly instead.');
- } // Legacy hook: remove it
-
-
- Object.defineProperty(validatedFactory, 'type', {
- enumerable: false,
- get: function () {
- warn('Factory.type is deprecated. Access the class directly ' + 'before passing it to createFactory.');
-
- Object.defineProperty(this, 'type', {
- value: type
- });
- return type;
- }
- });
- }
-
- return validatedFactory;
- }
- function cloneElementWithValidation(element, props, children) {
- var newElement = cloneElement.apply(this, arguments);
-
- for (var i = 2; i < arguments.length; i++) {
- validateChildKeys(arguments[i], newElement.type);
- }
-
- validatePropTypes(newElement);
- return newElement;
- }
-
- var enableSchedulerDebugging = false;
- var enableProfiling = false;
- var frameYieldMs = 5;
-
- function push(heap, node) {
- var index = heap.length;
- heap.push(node);
- siftUp(heap, node, index);
- }
- function peek(heap) {
- return heap.length === 0 ? null : heap[0];
- }
- function pop(heap) {
- if (heap.length === 0) {
- return null;
- }
-
- var first = heap[0];
- var last = heap.pop();
-
- if (last !== first) {
- heap[0] = last;
- siftDown(heap, last, 0);
- }
-
- return first;
- }
-
- function siftUp(heap, node, i) {
- var index = i;
-
- while (index > 0) {
- var parentIndex = index - 1 >>> 1;
- var parent = heap[parentIndex];
-
- if (compare(parent, node) > 0) {
- // The parent is larger. Swap positions.
- heap[parentIndex] = node;
- heap[index] = parent;
- index = parentIndex;
- } else {
- // The parent is smaller. Exit.
- return;
- }
- }
- }
-
- function siftDown(heap, node, i) {
- var index = i;
- var length = heap.length;
- var halfLength = length >>> 1;
-
- while (index < halfLength) {
- var leftIndex = (index + 1) * 2 - 1;
- var left = heap[leftIndex];
- var rightIndex = leftIndex + 1;
- var right = heap[rightIndex]; // If the left or right node is smaller, swap with the smaller of those.
-
- if (compare(left, node) < 0) {
- if (rightIndex < length && compare(right, left) < 0) {
- heap[index] = right;
- heap[rightIndex] = node;
- index = rightIndex;
- } else {
- heap[index] = left;
- heap[leftIndex] = node;
- index = leftIndex;
- }
- } else if (rightIndex < length && compare(right, node) < 0) {
- heap[index] = right;
- heap[rightIndex] = node;
- index = rightIndex;
- } else {
- // Neither child is smaller. Exit.
- return;
- }
- }
- }
-
- function compare(a, b) {
- // Compare sort index first, then task id.
- var diff = a.sortIndex - b.sortIndex;
- return diff !== 0 ? diff : a.id - b.id;
- }
-
- // TODO: Use symbols?
- var ImmediatePriority = 1;
- var UserBlockingPriority = 2;
- var NormalPriority = 3;
- var LowPriority = 4;
- var IdlePriority = 5;
-
- function markTaskErrored(task, ms) {
- }
-
- /* eslint-disable no-var */
- var getCurrentTime;
- var hasPerformanceNow = typeof performance === 'object' && typeof performance.now === 'function';
-
- if (hasPerformanceNow) {
- var localPerformance = performance;
-
- getCurrentTime = function () {
- return localPerformance.now();
- };
- } else {
- var localDate = Date;
- var initialTime = localDate.now();
-
- getCurrentTime = function () {
- return localDate.now() - initialTime;
- };
- } // Max 31 bit integer. The max integer size in V8 for 32-bit systems.
- // Math.pow(2, 30) - 1
- // 0b111111111111111111111111111111
-
-
- var maxSigned31BitInt = 1073741823; // Times out immediately
-
- var IMMEDIATE_PRIORITY_TIMEOUT = -1; // Eventually times out
-
- var USER_BLOCKING_PRIORITY_TIMEOUT = 250;
- var NORMAL_PRIORITY_TIMEOUT = 5000;
- var LOW_PRIORITY_TIMEOUT = 10000; // Never times out
-
- var IDLE_PRIORITY_TIMEOUT = maxSigned31BitInt; // tasks are stored on a min heap
-
- var taskQueue = [];
- var timerQueue = []; // Incrementing id counter. Used to maintain insertion order.
-
- var taskIdCounter = 1; // Pausing the scheduler is useful for debugging.
- var currentTask = null;
- var currentPriorityLevel = NormalPriority; // This is set while performing work, to prevent re-entrance.
-
- var isPerformingWork = false;
- var isHostCallbackScheduled = false;
- var isHostTimeoutScheduled = false; // Capture local references to native APIs, in case a polyfill overrides them.
-
- var localSetTimeout = typeof setTimeout === 'function' ? setTimeout : null;
- var localClearTimeout = typeof clearTimeout === 'function' ? clearTimeout : null;
- var localSetImmediate = typeof setImmediate !== 'undefined' ? setImmediate : null; // IE and Node.js + jsdom
-
- var isInputPending = typeof navigator !== 'undefined' && navigator.scheduling !== undefined && navigator.scheduling.isInputPending !== undefined ? navigator.scheduling.isInputPending.bind(navigator.scheduling) : null;
-
- function advanceTimers(currentTime) {
- // Check for tasks that are no longer delayed and add them to the queue.
- var timer = peek(timerQueue);
-
- while (timer !== null) {
- if (timer.callback === null) {
- // Timer was cancelled.
- pop(timerQueue);
- } else if (timer.startTime <= currentTime) {
- // Timer fired. Transfer to the task queue.
- pop(timerQueue);
- timer.sortIndex = timer.expirationTime;
- push(taskQueue, timer);
- } else {
- // Remaining timers are pending.
- return;
- }
-
- timer = peek(timerQueue);
- }
- }
-
- function handleTimeout(currentTime) {
- isHostTimeoutScheduled = false;
- advanceTimers(currentTime);
-
- if (!isHostCallbackScheduled) {
- if (peek(taskQueue) !== null) {
- isHostCallbackScheduled = true;
- requestHostCallback(flushWork);
- } else {
- var firstTimer = peek(timerQueue);
-
- if (firstTimer !== null) {
- requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);
- }
- }
- }
- }
-
- function flushWork(hasTimeRemaining, initialTime) {
-
-
- isHostCallbackScheduled = false;
-
- if (isHostTimeoutScheduled) {
- // We scheduled a timeout but it's no longer needed. Cancel it.
- isHostTimeoutScheduled = false;
- cancelHostTimeout();
- }
-
- isPerformingWork = true;
- var previousPriorityLevel = currentPriorityLevel;
-
- try {
- if (enableProfiling) {
- try {
- return workLoop(hasTimeRemaining, initialTime);
- } catch (error) {
- if (currentTask !== null) {
- var currentTime = getCurrentTime();
- markTaskErrored(currentTask, currentTime);
- currentTask.isQueued = false;
- }
-
- throw error;
- }
- } else {
- // No catch in prod code path.
- return workLoop(hasTimeRemaining, initialTime);
- }
- } finally {
- currentTask = null;
- currentPriorityLevel = previousPriorityLevel;
- isPerformingWork = false;
- }
- }
-
- function workLoop(hasTimeRemaining, initialTime) {
- var currentTime = initialTime;
- advanceTimers(currentTime);
- currentTask = peek(taskQueue);
-
- while (currentTask !== null && !(enableSchedulerDebugging )) {
- if (currentTask.expirationTime > currentTime && (!hasTimeRemaining || shouldYieldToHost())) {
- // This currentTask hasn't expired, and we've reached the deadline.
- break;
- }
-
- var callback = currentTask.callback;
-
- if (typeof callback === 'function') {
- currentTask.callback = null;
- currentPriorityLevel = currentTask.priorityLevel;
- var didUserCallbackTimeout = currentTask.expirationTime <= currentTime;
-
- var continuationCallback = callback(didUserCallbackTimeout);
- currentTime = getCurrentTime();
-
- if (typeof continuationCallback === 'function') {
- currentTask.callback = continuationCallback;
- } else {
-
- if (currentTask === peek(taskQueue)) {
- pop(taskQueue);
- }
- }
-
- advanceTimers(currentTime);
- } else {
- pop(taskQueue);
- }
-
- currentTask = peek(taskQueue);
- } // Return whether there's additional work
-
-
- if (currentTask !== null) {
- return true;
- } else {
- var firstTimer = peek(timerQueue);
-
- if (firstTimer !== null) {
- requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);
- }
-
- return false;
- }
- }
-
- function unstable_runWithPriority(priorityLevel, eventHandler) {
- switch (priorityLevel) {
- case ImmediatePriority:
- case UserBlockingPriority:
- case NormalPriority:
- case LowPriority:
- case IdlePriority:
- break;
-
- default:
- priorityLevel = NormalPriority;
- }
-
- var previousPriorityLevel = currentPriorityLevel;
- currentPriorityLevel = priorityLevel;
-
- try {
- return eventHandler();
- } finally {
- currentPriorityLevel = previousPriorityLevel;
- }
- }
-
- function unstable_next(eventHandler) {
- var priorityLevel;
-
- switch (currentPriorityLevel) {
- case ImmediatePriority:
- case UserBlockingPriority:
- case NormalPriority:
- // Shift down to normal priority
- priorityLevel = NormalPriority;
- break;
-
- default:
- // Anything lower than normal priority should remain at the current level.
- priorityLevel = currentPriorityLevel;
- break;
- }
-
- var previousPriorityLevel = currentPriorityLevel;
- currentPriorityLevel = priorityLevel;
-
- try {
- return eventHandler();
- } finally {
- currentPriorityLevel = previousPriorityLevel;
- }
- }
-
- function unstable_wrapCallback(callback) {
- var parentPriorityLevel = currentPriorityLevel;
- return function () {
- // This is a fork of runWithPriority, inlined for performance.
- var previousPriorityLevel = currentPriorityLevel;
- currentPriorityLevel = parentPriorityLevel;
-
- try {
- return callback.apply(this, arguments);
- } finally {
- currentPriorityLevel = previousPriorityLevel;
- }
- };
- }
-
- function unstable_scheduleCallback(priorityLevel, callback, options) {
- var currentTime = getCurrentTime();
- var startTime;
-
- if (typeof options === 'object' && options !== null) {
- var delay = options.delay;
-
- if (typeof delay === 'number' && delay > 0) {
- startTime = currentTime + delay;
- } else {
- startTime = currentTime;
- }
- } else {
- startTime = currentTime;
- }
-
- var timeout;
-
- switch (priorityLevel) {
- case ImmediatePriority:
- timeout = IMMEDIATE_PRIORITY_TIMEOUT;
- break;
-
- case UserBlockingPriority:
- timeout = USER_BLOCKING_PRIORITY_TIMEOUT;
- break;
-
- case IdlePriority:
- timeout = IDLE_PRIORITY_TIMEOUT;
- break;
-
- case LowPriority:
- timeout = LOW_PRIORITY_TIMEOUT;
- break;
-
- case NormalPriority:
- default:
- timeout = NORMAL_PRIORITY_TIMEOUT;
- break;
- }
-
- var expirationTime = startTime + timeout;
- var newTask = {
- id: taskIdCounter++,
- callback: callback,
- priorityLevel: priorityLevel,
- startTime: startTime,
- expirationTime: expirationTime,
- sortIndex: -1
- };
-
- if (startTime > currentTime) {
- // This is a delayed task.
- newTask.sortIndex = startTime;
- push(timerQueue, newTask);
-
- if (peek(taskQueue) === null && newTask === peek(timerQueue)) {
- // All tasks are delayed, and this is the task with the earliest delay.
- if (isHostTimeoutScheduled) {
- // Cancel an existing timeout.
- cancelHostTimeout();
- } else {
- isHostTimeoutScheduled = true;
- } // Schedule a timeout.
-
-
- requestHostTimeout(handleTimeout, startTime - currentTime);
- }
- } else {
- newTask.sortIndex = expirationTime;
- push(taskQueue, newTask);
- // wait until the next time we yield.
-
-
- if (!isHostCallbackScheduled && !isPerformingWork) {
- isHostCallbackScheduled = true;
- requestHostCallback(flushWork);
- }
- }
-
- return newTask;
- }
-
- function unstable_pauseExecution() {
- }
-
- function unstable_continueExecution() {
-
- if (!isHostCallbackScheduled && !isPerformingWork) {
- isHostCallbackScheduled = true;
- requestHostCallback(flushWork);
- }
- }
-
- function unstable_getFirstCallbackNode() {
- return peek(taskQueue);
- }
-
- function unstable_cancelCallback(task) {
- // remove from the queue because you can't remove arbitrary nodes from an
- // array based heap, only the first one.)
-
-
- task.callback = null;
- }
-
- function unstable_getCurrentPriorityLevel() {
- return currentPriorityLevel;
- }
-
- var isMessageLoopRunning = false;
- var scheduledHostCallback = null;
- var taskTimeoutID = -1; // Scheduler periodically yields in case there is other work on the main
- // thread, like user events. By default, it yields multiple times per frame.
- // It does not attempt to align with frame boundaries, since most tasks don't
- // need to be frame aligned; for those that do, use requestAnimationFrame.
-
- var frameInterval = frameYieldMs;
- var startTime = -1;
-
- function shouldYieldToHost() {
- var timeElapsed = getCurrentTime() - startTime;
-
- if (timeElapsed < frameInterval) {
- // The main thread has only been blocked for a really short amount of time;
- // smaller than a single frame. Don't yield yet.
- return false;
- } // The main thread has been blocked for a non-negligible amount of time. We
-
-
- return true;
- }
-
- function requestPaint() {
-
- }
-
- function forceFrameRate(fps) {
- if (fps < 0 || fps > 125) {
- // Using console['error'] to evade Babel and ESLint
- console['error']('forceFrameRate takes a positive int between 0 and 125, ' + 'forcing frame rates higher than 125 fps is not supported');
- return;
- }
-
- if (fps > 0) {
- frameInterval = Math.floor(1000 / fps);
- } else {
- // reset the framerate
- frameInterval = frameYieldMs;
- }
- }
-
- var performWorkUntilDeadline = function () {
- if (scheduledHostCallback !== null) {
- var currentTime = getCurrentTime(); // Keep track of the start time so we can measure how long the main thread
- // has been blocked.
-
- startTime = currentTime;
- var hasTimeRemaining = true; // If a scheduler task throws, exit the current browser task so the
- // error can be observed.
- //
- // Intentionally not using a try-catch, since that makes some debugging
- // techniques harder. Instead, if `scheduledHostCallback` errors, then
- // `hasMoreWork` will remain true, and we'll continue the work loop.
-
- var hasMoreWork = true;
-
- try {
- hasMoreWork = scheduledHostCallback(hasTimeRemaining, currentTime);
- } finally {
- if (hasMoreWork) {
- // If there's more work, schedule the next message event at the end
- // of the preceding one.
- schedulePerformWorkUntilDeadline();
- } else {
- isMessageLoopRunning = false;
- scheduledHostCallback = null;
- }
- }
- } else {
- isMessageLoopRunning = false;
- } // Yielding to the browser will give it a chance to paint, so we can
- };
-
- var schedulePerformWorkUntilDeadline;
-
- if (typeof localSetImmediate === 'function') {
- // Node.js and old IE.
- // There's a few reasons for why we prefer setImmediate.
- //
- // Unlike MessageChannel, it doesn't prevent a Node.js process from exiting.
- // (Even though this is a DOM fork of the Scheduler, you could get here
- // with a mix of Node.js 15+, which has a MessageChannel, and jsdom.)
- // https://github.com/facebook/react/issues/20756
- //
- // But also, it runs earlier which is the semantic we want.
- // If other browsers ever implement it, it's better to use it.
- // Although both of these would be inferior to native scheduling.
- schedulePerformWorkUntilDeadline = function () {
- localSetImmediate(performWorkUntilDeadline);
- };
- } else if (typeof MessageChannel !== 'undefined') {
- // DOM and Worker environments.
- // We prefer MessageChannel because of the 4ms setTimeout clamping.
- var channel = new MessageChannel();
- var port = channel.port2;
- channel.port1.onmessage = performWorkUntilDeadline;
-
- schedulePerformWorkUntilDeadline = function () {
- port.postMessage(null);
- };
- } else {
- // We should only fallback here in non-browser environments.
- schedulePerformWorkUntilDeadline = function () {
- localSetTimeout(performWorkUntilDeadline, 0);
- };
- }
-
- function requestHostCallback(callback) {
- scheduledHostCallback = callback;
-
- if (!isMessageLoopRunning) {
- isMessageLoopRunning = true;
- schedulePerformWorkUntilDeadline();
- }
- }
-
- function requestHostTimeout(callback, ms) {
- taskTimeoutID = localSetTimeout(function () {
- callback(getCurrentTime());
- }, ms);
- }
-
- function cancelHostTimeout() {
- localClearTimeout(taskTimeoutID);
- taskTimeoutID = -1;
- }
-
- var unstable_requestPaint = requestPaint;
- var unstable_Profiling = null;
-
-
-
- var Scheduler = /*#__PURE__*/Object.freeze({
- __proto__: null,
- unstable_ImmediatePriority: ImmediatePriority,
- unstable_UserBlockingPriority: UserBlockingPriority,
- unstable_NormalPriority: NormalPriority,
- unstable_IdlePriority: IdlePriority,
- unstable_LowPriority: LowPriority,
- unstable_runWithPriority: unstable_runWithPriority,
- unstable_next: unstable_next,
- unstable_scheduleCallback: unstable_scheduleCallback,
- unstable_cancelCallback: unstable_cancelCallback,
- unstable_wrapCallback: unstable_wrapCallback,
- unstable_getCurrentPriorityLevel: unstable_getCurrentPriorityLevel,
- unstable_shouldYield: shouldYieldToHost,
- unstable_requestPaint: unstable_requestPaint,
- unstable_continueExecution: unstable_continueExecution,
- unstable_pauseExecution: unstable_pauseExecution,
- unstable_getFirstCallbackNode: unstable_getFirstCallbackNode,
- get unstable_now () { return getCurrentTime; },
- unstable_forceFrameRate: forceFrameRate,
- unstable_Profiling: unstable_Profiling
- });
-
- var ReactSharedInternals$1 = {
- ReactCurrentDispatcher: ReactCurrentDispatcher,
- ReactCurrentOwner: ReactCurrentOwner,
- ReactCurrentBatchConfig: ReactCurrentBatchConfig,
- // Re-export the schedule API(s) for UMD bundles.
- // This avoids introducing a dependency on a new UMD global in a minor update,
- // Since that would be a breaking change (e.g. for all existing CodeSandboxes).
- // This re-export is only required for UMD bundles;
- // CJS bundles use the shared NPM package.
- Scheduler: Scheduler
- };
-
- {
- ReactSharedInternals$1.ReactCurrentActQueue = ReactCurrentActQueue;
- ReactSharedInternals$1.ReactDebugCurrentFrame = ReactDebugCurrentFrame;
- }
-
- function startTransition(scope, options) {
- var prevTransition = ReactCurrentBatchConfig.transition;
- ReactCurrentBatchConfig.transition = {};
- var currentTransition = ReactCurrentBatchConfig.transition;
-
- {
- ReactCurrentBatchConfig.transition._updatedFibers = new Set();
- }
-
- try {
- scope();
- } finally {
- ReactCurrentBatchConfig.transition = prevTransition;
-
- {
- if (prevTransition === null && currentTransition._updatedFibers) {
- var updatedFibersCount = currentTransition._updatedFibers.size;
-
- if (updatedFibersCount > 10) {
- 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.');
- }
-
- currentTransition._updatedFibers.clear();
- }
- }
- }
- }
-
- var didWarnAboutMessageChannel = false;
- var enqueueTaskImpl = null;
- function enqueueTask(task) {
- if (enqueueTaskImpl === null) {
- try {
- // read require off the module object to get around the bundlers.
- // we don't want them to detect a require and bundle a Node polyfill.
- var requireString = ('require' + Math.random()).slice(0, 7);
- var nodeRequire = module && module[requireString]; // assuming we're in node, let's try to get node's
- // version of setImmediate, bypassing fake timers if any.
-
- enqueueTaskImpl = nodeRequire.call(module, 'timers').setImmediate;
- } catch (_err) {
- // we're in a browser
- // we can't use regular timers because they may still be faked
- // so we try MessageChannel+postMessage instead
- enqueueTaskImpl = function (callback) {
- {
- if (didWarnAboutMessageChannel === false) {
- didWarnAboutMessageChannel = true;
-
- if (typeof MessageChannel === 'undefined') {
- 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.');
- }
- }
- }
-
- var channel = new MessageChannel();
- channel.port1.onmessage = callback;
- channel.port2.postMessage(undefined);
- };
- }
- }
-
- return enqueueTaskImpl(task);
- }
-
- var actScopeDepth = 0;
- var didWarnNoAwaitAct = false;
- function act(callback) {
- {
- // `act` calls can be nested, so we track the depth. This represents the
- // number of `act` scopes on the stack.
- var prevActScopeDepth = actScopeDepth;
- actScopeDepth++;
-
- if (ReactCurrentActQueue.current === null) {
- // This is the outermost `act` scope. Initialize the queue. The reconciler
- // will detect the queue and use it instead of Scheduler.
- ReactCurrentActQueue.current = [];
- }
-
- var prevIsBatchingLegacy = ReactCurrentActQueue.isBatchingLegacy;
- var result;
-
- try {
- // Used to reproduce behavior of `batchedUpdates` in legacy mode. Only
- // set to `true` while the given callback is executed, not for updates
- // triggered during an async event, because this is how the legacy
- // implementation of `act` behaved.
- ReactCurrentActQueue.isBatchingLegacy = true;
- result = callback(); // Replicate behavior of original `act` implementation in legacy mode,
- // which flushed updates immediately after the scope function exits, even
- // if it's an async function.
-
- if (!prevIsBatchingLegacy && ReactCurrentActQueue.didScheduleLegacyUpdate) {
- var queue = ReactCurrentActQueue.current;
-
- if (queue !== null) {
- ReactCurrentActQueue.didScheduleLegacyUpdate = false;
- flushActQueue(queue);
- }
- }
- } catch (error) {
- popActScope(prevActScopeDepth);
- throw error;
- } finally {
- ReactCurrentActQueue.isBatchingLegacy = prevIsBatchingLegacy;
- }
-
- if (result !== null && typeof result === 'object' && typeof result.then === 'function') {
- var thenableResult = result; // The callback is an async function (i.e. returned a promise). Wait
- // for it to resolve before exiting the current scope.
-
- var wasAwaited = false;
- var thenable = {
- then: function (resolve, reject) {
- wasAwaited = true;
- thenableResult.then(function (returnValue) {
- popActScope(prevActScopeDepth);
-
- if (actScopeDepth === 0) {
- // We've exited the outermost act scope. Recursively flush the
- // queue until there's no remaining work.
- recursivelyFlushAsyncActWork(returnValue, resolve, reject);
- } else {
- resolve(returnValue);
- }
- }, function (error) {
- // The callback threw an error.
- popActScope(prevActScopeDepth);
- reject(error);
- });
- }
- };
-
- {
- if (!didWarnNoAwaitAct && typeof Promise !== 'undefined') {
- // eslint-disable-next-line no-undef
- Promise.resolve().then(function () {}).then(function () {
- if (!wasAwaited) {
- didWarnNoAwaitAct = true;
-
- error('You called act(async () => ...) without await. ' + 'This could lead to unexpected testing behaviour, ' + 'interleaving multiple act calls and mixing their ' + 'scopes. ' + 'You should - await act(async () => ...);');
- }
- });
- }
- }
-
- return thenable;
- } else {
- var returnValue = result; // The callback is not an async function. Exit the current scope
- // immediately, without awaiting.
-
- popActScope(prevActScopeDepth);
-
- if (actScopeDepth === 0) {
- // Exiting the outermost act scope. Flush the queue.
- var _queue = ReactCurrentActQueue.current;
-
- if (_queue !== null) {
- flushActQueue(_queue);
- ReactCurrentActQueue.current = null;
- } // Return a thenable. If the user awaits it, we'll flush again in
- // case additional work was scheduled by a microtask.
-
-
- var _thenable = {
- then: function (resolve, reject) {
- // Confirm we haven't re-entered another `act` scope, in case
- // the user does something weird like await the thenable
- // multiple times.
- if (ReactCurrentActQueue.current === null) {
- // Recursively flush the queue until there's no remaining work.
- ReactCurrentActQueue.current = [];
- recursivelyFlushAsyncActWork(returnValue, resolve, reject);
- } else {
- resolve(returnValue);
- }
- }
- };
- return _thenable;
- } else {
- // Since we're inside a nested `act` scope, the returned thenable
- // immediately resolves. The outer scope will flush the queue.
- var _thenable2 = {
- then: function (resolve, reject) {
- resolve(returnValue);
- }
- };
- return _thenable2;
- }
- }
- }
- }
-
- function popActScope(prevActScopeDepth) {
- {
- if (prevActScopeDepth !== actScopeDepth - 1) {
- error('You seem to have overlapping act() calls, this is not supported. ' + 'Be sure to await previous act() calls before making a new one. ');
- }
-
- actScopeDepth = prevActScopeDepth;
- }
- }
-
- function recursivelyFlushAsyncActWork(returnValue, resolve, reject) {
- {
- var queue = ReactCurrentActQueue.current;
-
- if (queue !== null) {
- try {
- flushActQueue(queue);
- enqueueTask(function () {
- if (queue.length === 0) {
- // No additional work was scheduled. Finish.
- ReactCurrentActQueue.current = null;
- resolve(returnValue);
- } else {
- // Keep flushing work until there's none left.
- recursivelyFlushAsyncActWork(returnValue, resolve, reject);
- }
- });
- } catch (error) {
- reject(error);
- }
- } else {
- resolve(returnValue);
- }
- }
- }
-
- var isFlushing = false;
-
- function flushActQueue(queue) {
- {
- if (!isFlushing) {
- // Prevent re-entrance.
- isFlushing = true;
- var i = 0;
-
- try {
- for (; i < queue.length; i++) {
- var callback = queue[i];
-
- do {
- callback = callback(true);
- } while (callback !== null);
- }
-
- queue.length = 0;
- } catch (error) {
- // If something throws, leave the remaining callbacks on the queue.
- queue = queue.slice(i + 1);
- throw error;
- } finally {
- isFlushing = false;
- }
- }
- }
- }
-
- var createElement$1 = createElementWithValidation ;
- var cloneElement$1 = cloneElementWithValidation ;
- var createFactory = createFactoryWithValidation ;
- var Children = {
- map: mapChildren,
- forEach: forEachChildren,
- count: countChildren,
- toArray: toArray,
- only: onlyChild
- };
-
- exports.Children = Children;
- exports.Component = Component;
- exports.Fragment = REACT_FRAGMENT_TYPE;
- exports.Profiler = REACT_PROFILER_TYPE;
- exports.PureComponent = PureComponent;
- exports.StrictMode = REACT_STRICT_MODE_TYPE;
- exports.Suspense = REACT_SUSPENSE_TYPE;
- exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = ReactSharedInternals$1;
- exports.act = act;
- exports.cloneElement = cloneElement$1;
- exports.createContext = createContext;
- exports.createElement = createElement$1;
- exports.createFactory = createFactory;
- exports.createRef = createRef;
- exports.forwardRef = forwardRef;
- exports.isValidElement = isValidElement;
- exports.lazy = lazy;
- exports.memo = memo;
- exports.startTransition = startTransition;
- exports.unstable_act = act;
- exports.useCallback = useCallback;
- exports.useContext = useContext;
- exports.useDebugValue = useDebugValue;
- exports.useDeferredValue = useDeferredValue;
- exports.useEffect = useEffect;
- exports.useId = useId;
- exports.useImperativeHandle = useImperativeHandle;
- exports.useInsertionEffect = useInsertionEffect;
- exports.useLayoutEffect = useLayoutEffect;
- exports.useMemo = useMemo;
- exports.useReducer = useReducer;
- exports.useRef = useRef;
- exports.useState = useState;
- exports.useSyncExternalStore = useSyncExternalStore;
- exports.useTransition = useTransition;
- exports.version = ReactVersion;
-
-})));