{
  "version": 3,
  "file": "vendor-C0TsVpxF-chunk.js",
  "mappings": "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",
  "names": [
    "REACT_ELEMENT_TYPE",
    "Symbol",
    "for",
    "REACT_PORTAL_TYPE",
    "REACT_FRAGMENT_TYPE",
    "REACT_STRICT_MODE_TYPE",
    "REACT_PROFILER_TYPE",
    "REACT_PROVIDER_TYPE",
    "REACT_CONTEXT_TYPE",
    "REACT_FORWARD_REF_TYPE",
    "REACT_SUSPENSE_TYPE",
    "REACT_MEMO_TYPE",
    "REACT_LAZY_TYPE",
    "MAYBE_ITERATOR_SYMBOL",
    "iterator",
    "getIteratorFn",
    "maybeIterable",
    "maybeIterator",
    "FAUX_ITERATOR_SYMBOL",
    "ReactNoopUpdateQueue",
    "isMounted",
    "enqueueForceUpdate",
    "enqueueReplaceState",
    "enqueueSetState",
    "assign",
    "Object",
    "emptyObject",
    "Component",
    "props",
    "context",
    "updater",
    "refs",
    "prototype",
    "isReactComponent",
    "setState",
    "Component.prototype.setState",
    "partialState",
    "callback",
    "Error",
    "forceUpdate",
    "Component.prototype.forceUpdate",
    "ComponentDummy",
    "PureComponent",
    "pureComponentPrototype",
    "constructor",
    "isPureReactComponent",
    "isArrayImpl",
    "Array",
    "isArray",
    "hasOwnProperty",
    "ReactCurrentOwner",
    "current",
    "RESERVED_PROPS",
    "key",
    "ref",
    "__self",
    "__source",
    "createElement",
    "type",
    "config",
    "children",
    "propName",
    "undefined",
    "call",
    "childrenLength",
    "arguments",
    "length",
    "childArray",
    "i",
    "defaultProps",
    "element",
    "$$typeof",
    "_owner",
    "cloneAndReplaceKey",
    "oldElement",
    "newKey",
    "isValidElement",
    "object",
    "escape",
    "escaperLookup",
    "replace",
    "escapeRegex",
    "match",
    "escapedString",
    "userProvidedKeyEscapeRegex",
    "getElementKey",
    "index",
    "toString",
    "mapIntoArray",
    "array",
    "escapedPrefix",
    "nameSoFar",
    "invokeCallback",
    "child",
    "mappedChild",
    "childKey",
    "SEPARATOR",
    "escapedChildKey",
    "c",
    "push",
    "subtreeCount",
    "nextNamePrefix",
    "SUBSEPARATOR",
    "nextName",
    "iteratorFn",
    "ii",
    "step",
    "next",
    "done",
    "value",
    "childrenString",
    "String",
    "keys",
    "join",
    "mapChildren",
    "func",
    "result",
    "count",
    "lazyInitializer",
    "payload",
    "_status",
    "Uninitialized",
    "ctor",
    "_result",
    "thenable",
    "then",
    "moduleObject",
    "Pending",
    "Resolved",
    "error",
    "Rejected",
    "default",
    "ReactCurrentDispatcher",
    "ReactCurrentBatchConfig",
    "transition",
    "ReactSharedInternals",
    "exports",
    "Children",
    "map",
    "forEach",
    "forEachChildren",
    "forEachFunc",
    "forEachContext",
    "apply",
    "countChildren",
    "n",
    "toArray",
    "only",
    "onlyChild",
    "react_production_min",
    "cloneElement",
    "owner",
    "createContext",
    "defaultValue",
    "_currentValue",
    "_currentValue2",
    "_threadCount",
    "Provider",
    "Consumer",
    "_defaultValue",
    "_globalName",
    "_context",
    "createElement$1",
    "createFactory",
    "factory",
    "bind",
    "createRef",
    "refObject",
    "forwardRef",
    "render",
    "elementType",
    "lazy",
    "lazyType",
    "_payload",
    "_init",
    "memo",
    "compare",
    "startTransition",
    "scope",
    "prevTransition",
    "act",
    "useCallback",
    "deps",
    "useContext",
    "Context",
    "useDebugValue",
    "useDeferredValue",
    "useEffect",
    "create",
    "useId",
    "useImperativeHandle",
    "useInsertionEffect",
    "useLayoutEffect",
    "useMemo",
    "useReducer",
    "reducer",
    "initialArg",
    "init",
    "useRef",
    "initialValue",
    "useState",
    "initialState",
    "useSyncExternalStore",
    "subscribe",
    "getSnapshot",
    "getServerSnapshot",
    "useTransition",
    "ReactVersion",
    "reactModule",
    "require$$0",
    "f",
    "k",
    "l",
    "m",
    "p",
    "q",
    "a",
    "g",
    "b",
    "d",
    "e",
    "h",
    "reactJsxRuntime_production_min",
    "jsxRuntimeModule",
    "w",
    "C",
    "x",
    "r",
    "t",
    "u",
    "v",
    "y",
    "z",
    "A",
    "B",
    "D",
    "E",
    "F",
    "G",
    "H",
    "I",
    "J",
    "K",
    "L",
    "M",
    "N",
    "O",
    "P",
    "Q",
    "R",
    "S",
    "T",
    "schedulerModule",
    "React",
    "require",
    "Scheduler",
    "formatProdErrorMessage",
    "code",
    "url",
    "encodeURIComponent",
    "allNativeEvents",
    "Set",
    "registrationNameDependencies",
    "registerTwoPhaseEvent",
    "registrationName",
    "dependencies",
    "registerDirectEvent",
    "add",
    "canUseDOM",
    "window",
    "document",
    "VALID_ATTRIBUTE_NAME_REGEX",
    "illegalAttributeNameCache",
    "validatedAttributeNameCache",
    "isAttributeNameSafe",
    "attributeName",
    "test",
    "shouldRemoveAttributeWithWarning",
    "name",
    "propertyInfo",
    "isCustomComponentTag",
    "RESERVED",
    "acceptsBooleans",
    "prefix",
    "toLowerCase",
    "slice",
    "shouldRemoveAttribute",
    "BOOLEAN",
    "OVERLOADED_BOOLEAN",
    "NUMERIC",
    "isNaN",
    "POSITIVE_NUMERIC",
    "PropertyInfoRecord",
    "mustUseProperty",
    "attributeNamespace",
    "sanitizeURL",
    "removeEmptyString",
    "BOOLEANISH_STRING",
    "propertyName",
    "properties",
    "reservedProps",
    "_ref",
    "STRING",
    "CAMELIZE",
    "capitalize",
    "sa",
    "token",
    "toUpperCase",
    "setValueForProperty",
    "node",
    "removeAttribute",
    "setAttribute",
    "attributeValue",
    "setAttributeNS",
    "__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED",
    "REACT_SUSPENSE_LIST_TYPE",
    "REACT_OFFSCREEN_TYPE",
    "describeBuiltInComponentFrame",
    "stack",
    "trim",
    "reentry",
    "describeNativeComponentFrame",
    "fn",
    "construct",
    "previousPrepareStackTrace",
    "prepareStackTrace",
    "Fake",
    "defineProperty",
    "set",
    "Reflect",
    "control",
    "sample",
    "sampleLines",
    "split",
    "controlLines",
    "s",
    "frame",
    "displayName",
    "includes",
    "describeFiber",
    "fiber",
    "tag",
    "HostComponent",
    "LazyComponent",
    "SuspenseComponent",
    "SuspenseListComponent",
    "FunctionComponent",
    "IndeterminateComponent",
    "SimpleMemoComponent",
    "ForwardRef",
    "ClassComponent",
    "getComponentNameFromType",
    "functionName",
    "innerType",
    "wrapperName",
    "outerName",
    "getComponentNameFromFiber",
    "CacheComponent",
    "ContextConsumer",
    "ContextProvider",
    "DehydratedFragment",
    "Fragment",
    "HostPortal",
    "HostRoot",
    "HostText",
    "Mode",
    "OffscreenComponent",
    "Profiler",
    "ScopeComponent",
    "TracingMarkerComponent",
    "IncompleteClassComponent",
    "MemoComponent",
    "getToStringValue",
    "isCheckable",
    "elem",
    "nodeName",
    "trackValueOnNode",
    "valueField",
    "descriptor",
    "getOwnPropertyDescriptor",
    "currentValue",
    "get",
    "configurable",
    "enumerable",
    "tracker",
    "getValue",
    "setValue",
    "stopTracking",
    "_valueTracker",
    "track",
    "updateValueIfChanged",
    "lastValue",
    "checked",
    "nextValue",
    "getActiveElement",
    "doc",
    "activeElement",
    "body",
    "getHostProps",
    "defaultChecked",
    "_wrapperState",
    "initialChecked",
    "hostProps",
    "initWrapperState",
    "controlled",
    "updateChecked",
    "updateWrapper",
    "setDefaultValue",
    "postMountWrapper",
    "isHydrating",
    "ownerDocument",
    "updateOptions",
    "multiple",
    "propValue",
    "setDefaultSelected",
    "options",
    "selectedValue",
    "selected",
    "defaultSelected",
    "disabled",
    "getHostProps$2",
    "dangerouslySetInnerHTML",
    "initWrapperState$2",
    "updateWrapper$1",
    "newValue",
    "postMountWrapper$3",
    "textContent",
    "getIntrinsicNamespace",
    "SVG_NAMESPACE",
    "MATH_NAMESPACE",
    "HTML_NAMESPACE",
    "getChildNamespace",
    "parentNamespace",
    "reusableSVGContainer",
    "setInnerHTML",
    "createMicrosoftUnsafeLocalFunction",
    "MSApp",
    "execUnsafeLocalFunction",
    "arg0",
    "arg1",
    "arg2",
    "arg3",
    "html",
    "namespaceURI",
    "innerHTML",
    "valueOf",
    "svgNode",
    "firstChild",
    "removeChild",
    "appendChild",
    "ob",
    "text",
    "lastChild",
    "nodeType",
    "TEXT_NODE",
    "nodeValue",
    "isUnitlessNumber",
    "animationIterationCount",
    "aspectRatio",
    "borderImageOutset",
    "borderImageSlice",
    "borderImageWidth",
    "boxFlex",
    "boxFlexGroup",
    "boxOrdinalGroup",
    "columnCount",
    "columns",
    "flex",
    "flexGrow",
    "flexPositive",
    "flexShrink",
    "flexNegative",
    "flexOrder",
    "gridArea",
    "gridRow",
    "gridRowEnd",
    "gridRowSpan",
    "gridRowStart",
    "gridColumn",
    "gridColumnEnd",
    "gridColumnSpan",
    "gridColumnStart",
    "fontWeight",
    "lineClamp",
    "lineHeight",
    "opacity",
    "order",
    "orphans",
    "tabSize",
    "widows",
    "zIndex",
    "zoom",
    "fillOpacity",
    "floodOpacity",
    "stopOpacity",
    "strokeDasharray",
    "strokeDashoffset",
    "strokeMiterlimit",
    "strokeOpacity",
    "strokeWidth",
    "prefixes",
    "prop",
    "charAt",
    "substring",
    "dangerousStyleValue",
    "isCustomProperty",
    "setValueForStyles",
    "styles",
    "style",
    "styleName",
    "indexOf",
    "styleValue",
    "setProperty",
    "voidElementTags",
    "menuitem",
    "omittedCloseTags",
    "area",
    "base",
    "br",
    "col",
    "embed",
    "hr",
    "img",
    "input",
    "keygen",
    "link",
    "meta",
    "param",
    "source",
    "wbr",
    "assertValidProps",
    "HTML",
    "isCustomComponent",
    "tagName",
    "is",
    "currentReplayingEvent",
    "getEventTarget",
    "nativeEvent",
    "target",
    "srcElement",
    "correspondingUseElement",
    "parentNode",
    "restoreImpl",
    "restoreTarget",
    "restoreQueue",
    "restoreStateOfTarget",
    "internalInstance",
    "getInstanceFromNode",
    "stateNode",
    "getFiberCurrentPropsFromNode",
    "enqueueStateRestore",
    "restoreStateIfNeeded",
    "queuedTargets",
    "batchedUpdatesImpl",
    "Gb",
    "bookkeeping",
    "flushSyncImpl",
    "Hb",
    "isInsideEventHandler",
    "batchedUpdates",
    "getListener",
    "inst",
    "listener",
    "passiveBrowserEventsSupported",
    "addEventListener",
    "removeEventListener",
    "invokeGuardedCallbackProd",
    "funcArgs",
    "onError",
    "hasError",
    "caughtError",
    "hasRethrowError",
    "rethrowError",
    "reporter",
    "invokeGuardedCallback",
    "invokeGuardedCallbackImpl",
    "invokeGuardedCallbackAndCatchFirstError",
    "getNearestMountedFiber",
    "nearestMounted",
    "alternate",
    "return",
    "nextNode",
    "flags",
    "getSuspenseInstanceFromFiber",
    "suspenseState",
    "memoizedState",
    "dehydrated",
    "assertIsMounted",
    "findCurrentFiberUsingSlowPath",
    "parentA",
    "parentB",
    "nextParent",
    "sibling",
    "didFindChild",
    "findCurrentHostFiber",
    "parent",
    "currentParent",
    "findCurrentHostFiberImpl",
    "scheduleCallback",
    "unstable_scheduleCallback",
    "cancelCallback",
    "unstable_cancelCallback",
    "shouldYield",
    "unstable_shouldYield",
    "requestPaint",
    "unstable_requestPaint",
    "now",
    "unstable_now",
    "getCurrentPriorityLevel",
    "unstable_getCurrentPriorityLevel",
    "ImmediatePriority",
    "unstable_ImmediatePriority",
    "UserBlockingPriority",
    "unstable_UserBlockingPriority",
    "NormalPriority",
    "unstable_NormalPriority",
    "LowPriority",
    "unstable_LowPriority",
    "IdlePriority",
    "unstable_IdlePriority",
    "rendererID",
    "injectedHook",
    "onCommitRoot",
    "root",
    "onCommitFiberRoot",
    "DidCapture",
    "clz32",
    "Math",
    "clz32Fallback",
    "log",
    "LN2",
    "asUint",
    "nextTransitionLane",
    "TransitionLane1",
    "nextRetryLane",
    "RetryLane1",
    "getHighestPriorityLanes",
    "lanes",
    "SyncLane",
    "InputContinuousHydrationLane",
    "InputContinuousLane",
    "DefaultHydrationLane",
    "DefaultLane",
    "TransitionHydrationLane",
    "TransitionLane2",
    "TransitionLane3",
    "TransitionLane4",
    "TransitionLane5",
    "TransitionLane6",
    "TransitionLane7",
    "TransitionLane8",
    "TransitionLane9",
    "TransitionLane10",
    "TransitionLane11",
    "TransitionLane12",
    "TransitionLane13",
    "TransitionLane14",
    "TransitionLane15",
    "TransitionLane16",
    "TransitionLanes",
    "RetryLane2",
    "RetryLane3",
    "RetryLane4",
    "RetryLane5",
    "RetryLanes",
    "SelectiveHydrationLane",
    "IdleHydrationLane",
    "IdleLane",
    "OffscreenLane",
    "getNextLanes",
    "wipLanes",
    "pendingLanes",
    "NoLanes",
    "nextLanes",
    "suspendedLanes",
    "pingedLanes",
    "nonIdlePendingLanes",
    "NonIdleLanes",
    "nonIdleUnblockedLanes",
    "nonIdlePingedLanes",
    "unblockedLanes",
    "nextLane",
    "wipLane",
    "entangledLanes",
    "entanglements",
    "lane",
    "computeExpirationTime",
    "currentTime",
    "NoTimestamp",
    "markStarvedLanesAsExpired",
    "expirationTimes",
    "expirationTime",
    "expiredLanes",
    "getLanesToRetrySynchronouslyOnError",
    "everythingButOffscreen",
    "claimNextTransitionLane",
    "createLaneMap",
    "initial",
    "laneMap",
    "TotalLanes",
    "markRootUpdated",
    "updateLane",
    "eventTime",
    "eventTimes",
    "markRootFinished",
    "remainingLanes",
    "noLongerPendingLanes",
    "mutableReadLanes",
    "markRootEntangled",
    "rootEntangledLanes",
    "currentUpdatePriority",
    "NoLane",
    "lanesToEventPriority",
    "DiscreteEventPriority",
    "ContinuousEventPriority",
    "DefaultEventPriority",
    "IdleEventPriority",
    "_attemptSynchronousHydration",
    "attemptContinuousHydration",
    "attemptHydrationAtCurrentPriority",
    "getCurrentUpdatePriority$1",
    "attemptHydrationAtPriority",
    "hasScheduledReplayAttempt",
    "queuedDiscreteEvents",
    "queuedFocus",
    "queuedDrag",
    "queuedMouse",
    "queuedPointers",
    "Map",
    "queuedPointerCaptures",
    "queuedExplicitHydrationTargets",
    "discreteReplayableEvents",
    "clearIfContinuousEvent",
    "domEventName",
    "delete",
    "pointerId",
    "accumulateOrCreateContinuousQueuedReplayableEvent",
    "existingQueuedEvent",
    "blockedOn",
    "eventSystemFlags",
    "targetContainer",
    "queuedEvent",
    "targetContainers",
    "queueIfContinuousEvent",
    "attemptExplicitHydrationTarget",
    "queuedTarget",
    "targetInst",
    "getClosestInstanceFromNode",
    "instance",
    "priority",
    "isDehydrated",
    "containerInfo",
    "attemptReplayContinuousQueuedEvent",
    "nextBlockedOn",
    "findInstanceBlockingEvent",
    "nativeEventClone",
    "dispatchEvent",
    "shift",
    "attemptReplayContinuousQueuedEventInMap",
    "replayUnblockedEvents",
    "scheduleCallbackIfUnblocked",
    "unblocked",
    "retryIfBlockedOn",
    "unblock",
    "nextExplicitTarget",
    "_enabled",
    "dispatchDiscreteEvent",
    "container",
    "previousPriority",
    "dispatchContinuousEvent",
    "dispatchEventForPluginEventSystem",
    "return_targetInst",
    "stopPropagation",
    "IS_CAPTURE_PHASE",
    "nativeEventTarget",
    "getEventPriority",
    "startText",
    "fallbackText",
    "getData",
    "start",
    "startValue",
    "startLength",
    "end",
    "endValue",
    "endLength",
    "minEnd",
    "getEventCharCode",
    "keyCode",
    "charCode",
    "functionThatReturnsTrue",
    "functionThatReturnsFalse",
    "createSyntheticEvent",
    "Interface",
    "SyntheticBaseEvent",
    "reactName",
    "reactEventType",
    "_reactName",
    "_targetInst",
    "currentTarget",
    "normalize",
    "isDefaultPrevented",
    "defaultPrevented",
    "returnValue",
    "isPropagationStopped",
    "preventDefault",
    "event",
    "cancelBubble",
    "persist",
    "isPersistent",
    "EventInterface",
    "eventPhase",
    "bubbles",
    "cancelable",
    "timeStamp",
    "Date",
    "isTrusted",
    "SyntheticEvent",
    "UIEventInterface",
    "view",
    "detail",
    "SyntheticUIEvent",
    "lastMovementX",
    "lastMovementY",
    "lastMouseEvent",
    "MouseEventInterface",
    "screenX",
    "screenY",
    "clientX",
    "clientY",
    "pageX",
    "pageY",
    "ctrlKey",
    "shiftKey",
    "altKey",
    "metaKey",
    "getModifierState",
    "getEventModifierState",
    "button",
    "buttons",
    "relatedTarget",
    "fromElement",
    "toElement",
    "movementX",
    "movementY",
    "SyntheticMouseEvent",
    "DragEventInterface",
    "dataTransfer",
    "SyntheticDragEvent",
    "FocusEventInterface",
    "SyntheticFocusEvent",
    "AnimationEventInterface",
    "animationName",
    "elapsedTime",
    "pseudoElement",
    "SyntheticAnimationEvent",
    "ClipboardEventInterface",
    "clipboardData",
    "SyntheticClipboardEvent",
    "CompositionEventInterface",
    "data",
    "SyntheticCompositionEvent",
    "normalizeKey",
    "Esc",
    "Spacebar",
    "Left",
    "Up",
    "Right",
    "Down",
    "Del",
    "Win",
    "Menu",
    "Apps",
    "Scroll",
    "MozPrintableKey",
    "translateToKey",
    "modifierKeyToProp",
    "Alt",
    "Control",
    "Meta",
    "Shift",
    "modifierStateGetter",
    "keyArg",
    "syntheticEvent",
    "keyProp",
    "KeyboardEventInterface",
    "getEventKey",
    "fromCharCode",
    "location",
    "repeat",
    "locale",
    "which",
    "SyntheticKeyboardEvent",
    "PointerEventInterface",
    "width",
    "height",
    "pressure",
    "tangentialPressure",
    "tiltX",
    "tiltY",
    "twist",
    "pointerType",
    "isPrimary",
    "SyntheticPointerEvent",
    "TouchEventInterface",
    "touches",
    "targetTouches",
    "changedTouches",
    "SyntheticTouchEvent",
    "TransitionEventInterface",
    "SyntheticTransitionEvent",
    "WheelEventInterface",
    "deltaX",
    "wheelDeltaX",
    "deltaY",
    "wheelDeltaY",
    "wheelDelta",
    "deltaZ",
    "deltaMode",
    "SyntheticWheelEvent",
    "END_KEYCODES",
    "canUseCompositionEvent",
    "documentMode",
    "canUseTextInputEvent",
    "useFallbackCompositionData",
    "SPACEBAR_CHAR",
    "hasSpaceKeypress",
    "isFallbackCompositionEnd",
    "START_KEYCODE",
    "getDataFromCustomEvent",
    "isComposing",
    "getNativeBeforeInputChars",
    "SPACEBAR_CODE",
    "chars",
    "getFallbackBeforeInputChars",
    "char",
    "supportedInputTypes",
    "color",
    "date",
    "datetime",
    "email",
    "month",
    "number",
    "password",
    "range",
    "search",
    "tel",
    "time",
    "week",
    "isTextInputElement",
    "createAndAccumulateChangeEvent",
    "dispatchQueue",
    "listeners",
    "accumulateTwoPhaseListeners",
    "activeElementInst",
    "runEventInBatch",
    "processDispatchQueue",
    "getInstIfValueChanged",
    "targetNode",
    "getNodeFromInstance",
    "getTargetInstForChangeEvent",
    "isInputEventSupported",
    "xe",
    "isSupported",
    "eventName",
    "stopWatchingForValueChange",
    "detachEvent",
    "handlePropertyChange",
    "handleEventsForInputEventPolyfill",
    "attachEvent",
    "getTargetInstForInputEventPolyfill",
    "getTargetInstForClickEvent",
    "getTargetInstForInputOrChangeEvent",
    "objectIs",
    "shallowEqual",
    "objA",
    "objB",
    "keysA",
    "keysB",
    "currentKey",
    "getLeafNode",
    "getNodeForCharacterOffset",
    "offset",
    "nodeStart",
    "nodeEnd",
    "nextSibling",
    "containsNode",
    "outerNode",
    "innerNode",
    "contains",
    "compareDocumentPosition",
    "getActiveElementDeep",
    "win",
    "HTMLIFrameElement",
    "contentWindow",
    "href",
    "hasSelectionCapabilities",
    "contentEditable",
    "restoreSelection",
    "priorSelectionInformation",
    "curFocusedElem",
    "priorFocusedElem",
    "focusedElem",
    "priorSelectionRange",
    "selectionRange",
    "documentElement",
    "selectionStart",
    "selectionEnd",
    "min",
    "defaultView",
    "getSelection",
    "selection",
    "extend",
    "temp",
    "startMarker",
    "endMarker",
    "rangeCount",
    "anchorNode",
    "anchorOffset",
    "focusNode",
    "focusOffset",
    "createRange",
    "setStart",
    "removeAllRanges",
    "addRange",
    "setEnd",
    "ancestors",
    "ancestor",
    "ELEMENT_NODE",
    "left",
    "scrollLeft",
    "top",
    "scrollTop",
    "focus",
    "info",
    "skipSelectionChangeEvent",
    "activeElement$1",
    "activeElementInst$1",
    "lastSelection",
    "mouseDown",
    "constructSelectEvent",
    "DOCUMENT_NODE",
    "currentSelection",
    "makePrefixMap",
    "styleProp",
    "vendorPrefixes",
    "animationend",
    "animationiteration",
    "animationstart",
    "transitionend",
    "prefixedEventNames",
    "animation",
    "getVendorPrefixedEventName",
    "prefixMap",
    "ANIMATION_END",
    "ANIMATION_ITERATION",
    "ANIMATION_START",
    "TRANSITION_END",
    "topLevelEventsToReactNames",
    "simpleEventPluginEvents",
    "registerSimpleEvent",
    "capitalizedEvent",
    "mediaEventTypes",
    "nonDelegatedEvents",
    "concat",
    "executeDispatch",
    "inCapturePhase",
    "_dispatchQueue$i",
    "previousInstance",
    "_dispatchListeners$i",
    "_dispatchListeners$i2",
    "listenToNonDelegatedEvent",
    "targetElement",
    "elementListenerSet",
    "internalEventHandlersKey",
    "listenerSetKey",
    "listenerSet",
    "has",
    "addTrappedEventListener",
    "IS_NON_DELEGATED",
    "isCapturePhaseListener",
    "listenToNativeEvent",
    "listeningMarker",
    "random",
    "listenToAllSupportedEvents",
    "rootContainerElement",
    "eventPriority",
    "listenerWrapper",
    "isPassiveListener",
    "capture",
    "passive",
    "ancestorInst",
    "IS_EVENT_HANDLE_NON_MANAGED_NODE",
    "nodeTag",
    "COMMENT_NODE",
    "grandNode",
    "grandTag",
    "grandContainer",
    "parentTag",
    "SyntheticEventCtor",
    "accumulateTargetOnly",
    "reactEventName",
    "lastHostComponent",
    "_instance",
    "createDispatchListener",
    "SHOULD_NOT_PROCESS_POLYFILL_EVENT_PLUGINS",
    "isOverEvent",
    "isOutEvent",
    "related",
    "internalContainerInstanceKey",
    "parentWindow",
    "from",
    "to",
    "leaveEventType",
    "enterEventType",
    "eventTypePrefix",
    "fromNode",
    "toNode",
    "leave",
    "enter",
    "nativeTargetInst",
    "enterEvent",
    "nodeA",
    "instA",
    "nodeB",
    "instB",
    "depthA",
    "tempA",
    "getParent",
    "depthB",
    "tempB",
    "depth",
    "accumulateEnterLeaveListenersForEvent",
    "common",
    "getTargetInstFunc",
    "handleEventFunc",
    "state",
    "fallbackData",
    "ba",
    "eventType",
    "ie",
    "customData",
    "SyntheticInputEvent",
    "targetFiber",
    "captureName",
    "_instance2",
    "captureListener",
    "unshift",
    "bubbleListener",
    "_instance3",
    "NORMALIZE_NEWLINES_REGEX",
    "NORMALIZE_NULL_AND_REPLACEMENT_REGEX",
    "normalizeMarkupForTextOrAttribute",
    "markup",
    "checkForUnmatchedText",
    "serverText",
    "clientText",
    "isConcurrentMode",
    "normalizedClientText",
    "normalizedServerText",
    "noop",
    "eventsEnabled",
    "selectionInformation",
    "shouldSetTextContent",
    "__html",
    "scheduleTimeout",
    "setTimeout",
    "cancelTimeout",
    "clearTimeout",
    "localPromise",
    "Promise",
    "scheduleMicrotask",
    "queueMicrotask",
    "resolve",
    "catch",
    "handleErrorInNextTick",
    "clearSuspenseBoundary",
    "parentInstance",
    "suspenseInstance",
    "SUSPENSE_END_DATA",
    "SUSPENSE_START_DATA",
    "SUSPENSE_PENDING_START_DATA",
    "SUSPENSE_FALLBACK_START_DATA",
    "getNextHydratable",
    "nodeData",
    "getParentSuspenseInstance",
    "targetInstance",
    "previousSibling",
    "randomKey",
    "internalInstanceKey",
    "internalPropsKey",
    "internalEventHandlerListenersKey",
    "internalEventHandlesSetKey",
    "targetSuspenseInst",
    "valueStack",
    "createCursor",
    "pop",
    "cursor",
    "emptyContextObject",
    "contextStackCursor",
    "didPerformWorkStackCursor",
    "previousContext",
    "getMaskedContext",
    "workInProgress",
    "unmaskedContext",
    "contextTypes",
    "__reactInternalMemoizedUnmaskedChildContext",
    "__reactInternalMemoizedMaskedChildContext",
    "isContextProvider",
    "childContextTypes",
    "popContext",
    "pushTopLevelContextObject",
    "didChange",
    "processChildContext",
    "parentContext",
    "getChildContext",
    "childContext",
    "contextKey",
    "pushContextProvider",
    "memoizedMergedChildContext",
    "__reactInternalMemoizedMergedChildContext",
    "invalidateContextProvider",
    "mergedContext",
    "syncQueue",
    "includesLegacySyncCallbacks",
    "isFlushingSyncQueue",
    "scheduleSyncCallback",
    "scheduleLegacySyncCallback",
    "flushSyncCallbacks",
    "previousUpdatePriority",
    "queue",
    "isSync",
    "forkStack",
    "forkStackIndex",
    "treeForkProvider",
    "treeForkCount",
    "idStack",
    "idStackIndex",
    "treeContextProvider",
    "treeContextId",
    "treeContextOverflow",
    "pushTreeFork",
    "totalChildren",
    "pushTreeId",
    "baseIdWithLeadingBit",
    "baseOverflow",
    "baseLength",
    "numberOfOverflowBits",
    "newOverflow",
    "baseId",
    "restOfBaseLength",
    "slot",
    "restOfBaseId",
    "pushMaterializedTreeId",
    "numberOfForks",
    "slotIndex",
    "popTreeContext",
    "hydrationParentFiber",
    "nextHydratableInstance",
    "hydrationErrors",
    "deleteHydratableInstance",
    "returnFiber",
    "createFiber",
    "NoMode",
    "deletions",
    "ChildDeletion",
    "tryHydrate",
    "nextInstance",
    "pendingProps",
    "textInstance",
    "id",
    "overflow",
    "treeContext",
    "retryLane",
    "shouldClientRenderOnMismatch",
    "mode",
    "ConcurrentMode",
    "NoFlags",
    "tryToClaimNextHydratableInstance",
    "firstAttemptedInstance",
    "prevHydrationParentFiber",
    "Placement",
    "popToNextHostParent",
    "popHydrationState",
    "parentType",
    "Ef",
    "warnIfUnhydratedTailNodes",
    "yg",
    "resetHydrationState",
    "queueHydrationError",
    "ReactCurrentBatchConfig$1",
    "resolveDefaultProps",
    "baseProps",
    "valueCursor",
    "currentlyRenderingFiber",
    "lastContextDependency",
    "lastFullyObservedContext",
    "resetContextDependencies",
    "popProvider",
    "scheduleContextWorkOnParentPath",
    "renderLanes",
    "propagationRoot",
    "childLanes",
    "prepareToReadContext",
    "firstContext",
    "didReceiveUpdate",
    "readContext",
    "contextItem",
    "memoizedValue",
    "concurrentQueues",
    "pushConcurrentUpdateQueue",
    "enqueueConcurrentHookUpdate",
    "update",
    "interleaved",
    "markUpdateLaneFromFiberToRoot",
    "sourceFiber",
    "hasForceUpdate",
    "initializeUpdateQueue",
    "updateQueue",
    "baseState",
    "firstBaseUpdate",
    "lastBaseUpdate",
    "shared",
    "pending",
    "effects",
    "cloneUpdateQueue",
    "currentQueue",
    "clone",
    "createUpdate",
    "UpdateState",
    "enqueueUpdate",
    "sharedQueue",
    "executionContext",
    "RenderContext",
    "unsafe_markUpdateLaneFromFiberToRoot",
    "entangleTransitions",
    "queueLanes",
    "newQueueLanes",
    "enqueueCapturedUpdate",
    "capturedUpdate",
    "newFirst",
    "newLast",
    "processUpdateQueue",
    "pendingQueue",
    "lastPendingUpdate",
    "firstPendingUpdate",
    "currentLastBaseUpdate",
    "newState",
    "newLanes",
    "newLastBaseUpdate",
    "newFirstBaseUpdate",
    "newBaseState",
    "updateEventTime",
    "ReplaceState",
    "prevState",
    "nextProps",
    "nextState",
    "CaptureUpdate",
    "ForceUpdate",
    "Callback",
    "lastInterleaved",
    "workInProgressRootSkippedLanes",
    "commitUpdateQueue",
    "finishedWork",
    "finishedQueue",
    "effect",
    "emptyRefsObject",
    "applyDerivedStateFromProps",
    "getDerivedStateFromProps",
    "classComponentUpdater",
    "component",
    "_reactInternals",
    "requestEventTime",
    "requestUpdateLane",
    "scheduleUpdateOnFiber",
    "checkShouldComponentUpdate",
    "oldProps",
    "newProps",
    "oldState",
    "nextContext",
    "shouldComponentUpdate",
    "shouldUpdate",
    "constructClassInstance",
    "isLegacyContextConsumer",
    "contextType",
    "callComponentWillReceiveProps",
    "componentWillReceiveProps",
    "UNSAFE_componentWillReceiveProps",
    "mountClassInstance",
    "getSnapshotBeforeUpdate",
    "UNSAFE_componentWillMount",
    "componentWillMount",
    "componentDidMount",
    "fiberFlags",
    "coerceRef",
    "mixedRef",
    "resolvedInst",
    "stringRef",
    "_stringRef",
    "throwOnInvalidObjectType",
    "newChild",
    "childString",
    "resolveLazy",
    "ChildReconciler",
    "shouldTrackSideEffects",
    "deleteChild",
    "childToDelete",
    "deleteRemainingChildren",
    "currentFirstChild",
    "mapRemainingChildren",
    "existingChildren",
    "existingChild",
    "useFiber",
    "createWorkInProgress",
    "placeChild",
    "newFiber",
    "lastPlacedIndex",
    "newIndex",
    "oldIndex",
    "Forked",
    "placeSingleChild",
    "updateTextNode",
    "created",
    "createFiberFromText",
    "existing",
    "updateElement",
    "updateFragment",
    "createFiberFromTypeAndProps",
    "updatePortal",
    "portal",
    "implementation",
    "createFiberFromPortal",
    "fragment",
    "createFiberFromFragment",
    "createChild",
    "updateSlot",
    "oldFiber",
    "updateFromMap",
    "newIdx",
    "matchedFiber",
    "reconcileChildrenArray",
    "newChildren",
    "resultingFirstChild",
    "previousNewFiber",
    "nextOldFiber",
    "reconcileChildrenIterator",
    "newChildrenIterable",
    "reconcileChildFibers",
    "mountChildFibers",
    "NO_CONTEXT",
    "contextStackCursor$1",
    "contextFiberStackCursor",
    "rootInstanceStackCursor",
    "requiredContext",
    "pushHostContainer",
    "nextRootInstance",
    "DOCUMENT_FRAGMENT_NODE",
    "namespace",
    "ownNamespace",
    "nextRootContext",
    "popHostContainer",
    "pushHostContext",
    "popHostContext",
    "suspenseStackCursor",
    "DefaultSuspenseContext",
    "findFirstSuspended",
    "row",
    "memoizedProps",
    "revealOrder",
    "workInProgressSources",
    "resetWorkInProgressVersions",
    "mutableSource",
    "_workInProgressVersionPrimary",
    "ReactCurrentDispatcher$1",
    "ReactCurrentBatchConfig$2",
    "currentlyRenderingFiber$1",
    "currentHook",
    "workInProgressHook",
    "didScheduleRenderPhaseUpdate",
    "didScheduleRenderPhaseUpdateDuringThisPass",
    "localIdCounter",
    "globalClientIdCounter",
    "throwInvalidHookError",
    "areHookInputsEqual",
    "nextDeps",
    "prevDeps",
    "renderWithHooks",
    "secondArg",
    "nextRenderLanes",
    "HooksDispatcherOnMount",
    "HooksDispatcherOnUpdate",
    "numberOfReRenders",
    "RE_RENDER_LIMIT",
    "HooksDispatcherOnRerender",
    "ContextOnlyDispatcher",
    "didRenderTooFewHooks",
    "checkDidRenderIdHook",
    "didRenderIdHook",
    "mountWorkInProgressHook",
    "hook",
    "baseQueue",
    "updateWorkInProgressHook",
    "nextCurrentHook",
    "nextWorkInProgressHook",
    "newHook",
    "basicStateReducer",
    "action",
    "updateReducer",
    "lastRenderedReducer",
    "baseFirst",
    "first",
    "newBaseQueueFirst",
    "newBaseQueueLast",
    "hasEagerState",
    "eagerState",
    "lastRenderedState",
    "interleavedLane",
    "dispatch",
    "rerenderReducer",
    "lastRenderPhaseUpdate",
    "firstRenderPhaseUpdate",
    "updateMutableSource",
    "updateSyncExternalStore",
    "nextSnapshot",
    "snapshotChanged",
    "updateEffect",
    "subscribeToStore",
    "HasEffect",
    "Passive",
    "pushEffect",
    "updateStoreInstance",
    "workInProgressRoot",
    "SyncDefaultLanes",
    "pushStoreConsistencyCheck",
    "renderedSnapshot",
    "StoreConsistency",
    "check",
    "componentUpdateQueue",
    "lastEffect",
    "stores",
    "checkIfSnapshotChanged",
    "forceStoreRerender",
    "handleStoreChange",
    "latestGetSnapshot",
    "prevValue",
    "mountState",
    "dispatchSetState",
    "destroy",
    "firstEffect",
    "updateRef",
    "mountEffectImpl",
    "hookFlags",
    "updateEffectImpl",
    "prevEffect",
    "mountEffect",
    "Passive$1",
    "updateInsertionEffect",
    "Update",
    "Insertion",
    "updateLayoutEffect",
    "Layout",
    "imperativeHandleEffect",
    "updateImperativeHandle",
    "effectDeps",
    "mountDebugValue",
    "updateCallback",
    "updateMemo",
    "nextCreate",
    "updateDeferredValueImpl",
    "UrgentLanes",
    "deferredLane",
    "setPending",
    "updateId",
    "dispatchReducerAction",
    "isRenderPhaseUpdate",
    "enqueueRenderPhaseUpdate",
    "entangleTransitionUpdate",
    "currentState",
    "useMutableSource",
    "unstable_isNewReconciler",
    "enableNewReconciler",
    "mountCallback",
    "mountImperativeHandle",
    "mountLayoutEffect",
    "mountInsertionEffect",
    "mountMemo",
    "mountReducer",
    "mountRef",
    "mountDeferredValue",
    "mountTransition",
    "_mountState",
    "isPending",
    "mountMutableSource",
    "mountSyncExternalStore",
    "mountId",
    "identifierPrefix",
    "idWithLeadingBit",
    "treeId",
    "localId",
    "globalClientId",
    "updateState",
    "updateDebugValue",
    "updateDeferredValue",
    "updateTransition",
    "_updateState",
    "rerenderState",
    "rerenderDeferredValue",
    "rerenderTransition",
    "_rerenderState",
    "createCapturedValueAtFiber",
    "message",
    "digest",
    "createCapturedValue",
    "logCapturedError",
    "boundary",
    "errorInfo",
    "console",
    "PossiblyWeakMap",
    "WeakMap",
    "createRootErrorUpdate",
    "update.callback",
    "hasUncaughtError",
    "firstUncaughtError",
    "createClassErrorUpdate",
    "getDerivedStateFromError",
    "update.payload",
    "componentDidCatch",
    "legacyErrorBoundariesThatAlreadyFailed",
    "componentStack",
    "attachPingListener",
    "wakeable",
    "pingCache",
    "threadIDs",
    "ping",
    "pingSuspendedRoot",
    "getNearestSuspenseBoundaryToCapture",
    "markSuspenseBoundaryShouldCapture",
    "suspenseBoundary",
    "rootRenderLanes",
    "ShouldCapture",
    "ForceUpdateForLegacySuspense",
    "ReactCurrentOwner$1",
    "reconcileChildren",
    "nextChildren",
    "updateForwardRef",
    "hasId",
    "bailoutOnAlreadyFinishedWork",
    "PerformedWork",
    "updateMemoComponent",
    "shouldConstruct",
    "updateSimpleMemoComponent",
    "currentChild",
    "prevProps",
    "updateFunctionComponent",
    "updateOffscreenComponent",
    "baseLanes",
    "cachePool",
    "transitions",
    "subtreeRenderLanesCursor",
    "subtreeRenderLanes",
    "nextBaseLanes",
    "spawnedCachePool",
    "markRef",
    "Ref",
    "RefStatic",
    "updateClassComponent",
    "hasContext",
    "resetSuspendedCurrentOnMountInLegacyMode",
    "oldContext",
    "nextLegacyUnmaskedContext",
    "hasNewLifecycles",
    "unresolvedOldProps",
    "unresolvedNewProps",
    "nextUnmaskedContext",
    "enableLazyContextPropagation",
    "UNSAFE_componentWillUpdate",
    "componentWillUpdate",
    "componentDidUpdate",
    "Snapshot",
    "finishClassComponent",
    "nextUnitOfWork",
    "didCaptureError",
    "pushHostRootContext",
    "pendingContext",
    "mountHostRootWithoutHydrating",
    "recoverableError",
    "ForceClientRender",
    "SUSPENDED_MARKER",
    "mountSuspenseOffscreenState",
    "updateSuspenseComponent",
    "suspenseContext",
    "showFallback",
    "didSuspend",
    "ForceSuspenseFallback",
    "InvisibleParentSuspenseContext",
    "SubtreeSuspenseContextMask",
    "nextPrimaryChildren",
    "nextFallbackChildren",
    "fallback",
    "progressedPrimaryFragment",
    "primaryChildProps",
    "primaryChildFragment",
    "createFiberFromOffscreen",
    "fallbackChildFragment",
    "mountSuspensePrimaryChildren",
    "updateDehydratedSuspenseComponent",
    "currentPrimaryChildFragment",
    "currentFallbackChildFragment",
    "subtreeFlags",
    "StaticMask",
    "prevOffscreenState",
    "oj",
    "offscreenProps",
    "primaryChildren",
    "retrySuspenseComponentWithoutHydrating",
    "capturedValue",
    "fiberMode",
    "dataset",
    "dgst",
    "hasContextChanged",
    "attemptHydrationAtLane",
    "renderDidSuspendDelayIfPossible",
    "retry",
    "retryDehydratedSuspenseBoundary",
    "_reactRetry",
    "Hydrating",
    "scheduleSuspenseWorkOnFiber",
    "initSuspenseListRenderState",
    "isBackwards",
    "tail",
    "lastContentRow",
    "tailMode",
    "renderState",
    "rendering",
    "renderingStartTime",
    "last",
    "updateSuspenseListComponent",
    "currentRow",
    "nextRow",
    "attemptEarlyBailoutIfNoScheduledUpdate",
    "hasChildWork",
    "LegacyHiddenComponent",
    "appendAllChildren",
    "updateHostContainer",
    "updateHostComponent$1",
    "updateHostText$1",
    "updatePayload",
    "lastProps",
    "onClick",
    "onclick",
    "styleUpdates",
    "propKey",
    "STYLE",
    "lastStyle",
    "DANGEROUSLY_SET_INNER_HTML",
    "CHILDREN",
    "SUPPRESS_CONTENT_EDITABLE_WARNING",
    "SUPPRESS_HYDRATION_WARNING",
    "AUTOFOCUS",
    "nextProp",
    "lastProp",
    "nextHtml",
    "lastHtml",
    "oldText",
    "newText",
    "cutOffTailIfNeeded",
    "hasRenderedATailFallback",
    "tailNode",
    "lastTailNode",
    "bubbleProperties",
    "completedWork",
    "didBailout",
    "newChildLanes",
    "completeWork",
    "fiberRoot",
    "wasHydrated",
    "queueRecoverableErrors",
    "rootContainerInstance",
    "rootInstance",
    "currentHostContext",
    "wasMultiple",
    "div",
    "domElement",
    "size",
    "createElementNS",
    "setTextContent",
    "autoFocus",
    "textNode",
    "createTextNode",
    "fallthroughToNormalSuspensePath",
    "nextDidTimeout",
    "Visibility",
    "workInProgressRootExitStatus",
    "RootInProgress",
    "RootSuspended",
    "didSuspendAlready",
    "renderedTail",
    "suspended",
    "newThenables",
    "currentDependencies",
    "workInProgressRootRenderTargetTime",
    "SomeRetryLane",
    "popRenderLanes",
    "nextIsHidden",
    "unwindWork",
    "offscreenSubtreeIsHidden",
    "offscreenSubtreeWasHidden",
    "PossiblyWeakSet",
    "WeakSet",
    "nextEffect",
    "safelyDetachRef",
    "nearestMountedAncestor",
    "captureCommitPhaseError",
    "safelyCallDestroy",
    "shouldFireAfterActiveInstanceBlur",
    "commitBeforeMutationEffects",
    "indexWithinAnchor",
    "indexWithinFocus",
    "Df",
    "BeforeMutationMask",
    "snapshot",
    "__reactInternalSnapshotBeforeUpdate",
    "shouldFire",
    "commitHookEffectListUnmount",
    "commitHookEffectListMount",
    "commitAttachRef",
    "instanceToUse",
    "detachFiberAfterEffects",
    "hostInstance",
    "isHostParent",
    "getHostSibling",
    "insertOrAppendPlacementNodeIntoContainer",
    "before",
    "insertBefore",
    "reactRootContainer",
    "_reactRootContainer",
    "insertOrAppendPlacementNode",
    "hostParent",
    "hostParentIsContainer",
    "recursivelyTraverseDeletionEffects",
    "finishedRoot",
    "commitDeletionEffectsOnFiber",
    "deletedFiber",
    "onCommitFiberUnmount",
    "prevHostParent",
    "prevHostParentIsContainer",
    "_effect",
    "componentWillUnmount",
    "prevOffscreenSubtreeWasHidden",
    "attachSuspenseRetryListeners",
    "wakeables",
    "retryCache",
    "resolveRetryWakeable",
    "recursivelyTraverseMutationEffects",
    "parentFiber",
    "MutationMask",
    "commitMutationEffectsOnFiber",
    "commitReconciliationEffects",
    "ContentReset",
    "offscreenFiber",
    "isHidden",
    "globalMostRecentFallbackTime",
    "wasHidden",
    "offscreenChild",
    "disappearLayoutEffects_complete",
    "subtreeRoot",
    "hostSubtreeRoot",
    "display",
    "commitLayoutEffects",
    "committedLanes",
    "commitLayoutEffects_begin",
    "isModernRoot",
    "newOffscreenSubtreeIsHidden",
    "newOffscreenSubtreeWasHidden",
    "prevOffscreenSubtreeIsHidden",
    "reappearLayoutEffects_complete",
    "commitLayoutMountEffects_complete",
    "LayoutMask",
    "src",
    "ceil",
    "ReactCurrentDispatcher$2",
    "ReactCurrentOwner$2",
    "ReactCurrentBatchConfig$3",
    "NoContext",
    "workInProgressRootRenderLanes",
    "workInProgressRootFatalError",
    "workInProgressRootInterleavedUpdatedLanes",
    "workInProgressRootPingedLanes",
    "workInProgressRootConcurrentErrors",
    "workInProgressRootRecoverableErrors",
    "Infinity",
    "workInProgressTransitions",
    "rootDoesHavePassiveEffects",
    "rootWithPendingPassiveEffects",
    "pendingPassiveEffectsLanes",
    "nestedUpdateCount",
    "rootWithNestedUpdates",
    "currentEventTime",
    "currentEventTransitionLane",
    "NoTransition",
    "currentEvent",
    "eventLane",
    "NESTED_UPDATE_LIMIT",
    "RootSuspendedWithDelay",
    "markRootSuspended$1",
    "ensureRootIsScheduled",
    "RENDER_TIMEOUT_MS",
    "existingCallbackNode",
    "callbackNode",
    "callbackPriority",
    "newCallbackPriority",
    "LegacyRoot",
    "performSyncWorkOnRoot",
    "newCallbackNode",
    "schedulerPriorityLevel",
    "scheduleCallback$1",
    "performConcurrentWorkOnRoot",
    "didTimeout",
    "originalCallbackNode",
    "flushPassiveEffects",
    "didFlushPassiveEffects",
    "Jk",
    "prevExecutionContext",
    "prevDispatcher",
    "pushDispatcher",
    "prepareFreshStack",
    "workLoopConcurrent",
    "thrownValue",
    "handleError",
    "exitStatus",
    "RootErrored",
    "errorRetryLanes",
    "recoverFromConcurrentError",
    "RootFatalErrored",
    "fatalError",
    "RootDidNotComplete",
    "isRenderConsistentWithExternalStores",
    "renderRootSync",
    "finishedLanes",
    "commitRoot",
    "msUntilTimeout",
    "FALLBACK_THROTTLE_MS",
    "timeoutHandle",
    "mostRecentEventTime",
    "timeElapsedMs",
    "RootCompleted",
    "errorsFromFirstAttempt",
    "rootWorkInProgress",
    "errorsFromSecondAttempt",
    "errors",
    "checks",
    "renderedValue",
    "batchedUpdates$1",
    "BatchedContext",
    "flushSync",
    "noTimeout",
    "interruptedWork",
    "lastInterleavedUpdate",
    "firstInterleavedUpdate",
    "erroredWork",
    "Incomplete",
    "currentSource",
    "uncaughtSuspenseError",
    "completeUnitOfWork",
    "yetAnotherThrownValue",
    "workLoopSync",
    "performUnitOfWork",
    "unitOfWork",
    "beginWork$1",
    "HostEffectMask",
    "siblingFiber",
    "recoverableErrors",
    "previousUpdateLanePriority",
    "commitRootImpl",
    "renderPriorityLevel",
    "PassiveMask",
    "rootHasEffect",
    "CommitContext",
    "onRecoverableError",
    "renderPriority",
    "fiberToDelete",
    "previousFiber",
    "detachedChild",
    "detachedSibling",
    "onPostCommitFiberRoot",
    "captureCommitPhaseErrorOnRoot",
    "rootFiber",
    "retryTimedOutBoundary",
    "boundaryFiber",
    "beginWork",
    "resolvedTag",
    "resolveLazyComponentTag",
    "resolvedProps",
    "hint",
    "unresolvedProps",
    "prevChildren",
    "overrideState",
    "cache",
    "pendingSuspenseBoundaries",
    "isDirectTextChild",
    "list",
    "nextFiber",
    "dependency",
    "parentSuspense",
    "priorityLevel",
    "FiberNode",
    "Bg",
    "fiberTag",
    "resolvedType",
    "StrictLegacyMode",
    "ProfileMode",
    "elements",
    "primaryChildInstance",
    "content",
    "pendingChildren",
    "FiberRootNode",
    "hydrate",
    "mutableSourceEagerHydrationData",
    "createFiberRoot",
    "initialChildren",
    "hydrationCallbacks",
    "isStrictMode",
    "concurrentUpdatesByDefaultOverride",
    "ConcurrentRoot",
    "uninitializedFiber",
    "createPortal",
    "getContextForSubtree",
    "parentComponent",
    "createHydrationContainer",
    "updateContainer",
    "getPublicRootInstance",
    "containerFiber",
    "markRetryLaneImpl",
    "markRetryLaneIfNotHydrated",
    "emptyFindFiberByHostInstance",
    "defaultOnRecoverableError",
    "reportError",
    "ReactDOMRoot",
    "internalRoot",
    "_internalRoot",
    "ReactDOMHydrationRoot",
    "ReactDOMRoot.prototype.render",
    "unmount",
    "ReactDOMRoot.prototype.unmount",
    "unstable_scheduleHydration",
    "scheduleHydration",
    "updatePriority",
    "splice",
    "isValidContainer",
    "isValidContainerLegacy",
    "noopOnRecoverableError",
    "legacyCreateRootFromDOMContainer",
    "isHydrationContainer",
    "originalCallback",
    "rootSibling",
    "legacyRenderSubtreeIntoContainer",
    "forceHydrate",
    "maybeRoot",
    "attemptSynchronousHydration$1",
    "attemptContinuousHydration$1",
    "attemptHydrationAtCurrentPriority$1",
    "getCurrentUpdatePriority",
    "runWithPriority",
    "restoreControlledState$3",
    "queryRoot",
    "group",
    "querySelectorAll",
    "JSON",
    "stringify",
    "otherNode",
    "form",
    "otherProps",
    "Internals",
    "usingClientEntryPoint",
    "Events",
    "ul",
    "findFiberByHostInstance",
    "bundleType",
    "version",
    "rendererPackageName",
    "vl",
    "devToolsConfig",
    "rendererConfig",
    "overrideHookState",
    "overrideHookStateDeletePath",
    "overrideHookStateRenamePath",
    "overrideProps",
    "overridePropsDeletePath",
    "overridePropsRenamePath",
    "setErrorHandler",
    "setSuspenseHandler",
    "scheduleUpdate",
    "currentDispatcherRef",
    "findHostInstanceByFiber",
    "hostFiber",
    "findHostInstancesForRefresh",
    "scheduleRefresh",
    "scheduleRoot",
    "setRefreshHandler",
    "getCurrentFiber",
    "reconcilerVersion",
    "__REACT_DEVTOOLS_GLOBAL_HOOK__",
    "isDisabled",
    "supportsFiber",
    "inject",
    "internals",
    "reactDom_production_min",
    "createPortal$1",
    "createRoot$1",
    "unstable_strictMode",
    "findDOMNode",
    "componentOrElement",
    "flushSync$1",
    "hydrateRoot$1",
    "mutableSources",
    "hydratedSources",
    "getVersion",
    "_getVersion",
    "_source",
    "unmountComponentAtNode",
    "renderSubtreeIntoContainer",
    "containerNode",
    "actualVersion",
    "checkDCE",
    "err",
    "reactDomModule",
    "createRoot",
    "hydrateRoot",
    "useSyncExternalStoreWithSelector_production_min",
    "withSelectorModule",
    "ReactOriginal",
    "ReactOriginal[\"default\"]",
    "ContextKey",
    "gT",
    "getContext",
    "contextMap",
    "realContext",
    "ReactReduxContext",
    "notInitialized",
    "createReduxContextHook",
    "useReduxContext",
    "useSyncExternalStoreWithSelector",
    "initializeUseSelector",
    "refEquality",
    "createSelectorHook",
    "useReduxContext2",
    "useSelector2",
    "selector",
    "equalityFnOrOptions",
    "equalityFn",
    "devModeChecks",
    "store",
    "subscription",
    "getServerState",
    "stabilityCheck",
    "identityFunctionCheck",
    "wrappedSelector",
    "selectedState",
    "useSelector",
    "defaultNoopBatch",
    "createListenerCollection",
    "isSubscribed",
    "nullListeners",
    "createSubscription",
    "parentSub",
    "unsubscribe",
    "subscriptionsAmount",
    "selfSubscribed",
    "addNestedSub",
    "trySubscribe",
    "cleanupListener",
    "removed",
    "tryUnsubscribe",
    "notifyNestedSubs",
    "handleChangeWrapper",
    "trySubscribeSelf",
    "tryUnsubscribeSelf",
    "isReactNative",
    "useIsomorphicLayoutEffect",
    "serverState",
    "contextValue",
    "previousState",
    "Provider_default",
    "createStoreHook",
    "useStore2",
    "useStore",
    "createDispatchHook",
    "useDispatch2",
    "useDispatch",
    "batch",
    "useSyncExternalStoreWithSelector2",
    "$$observable",
    "symbol_observable_default",
    "randomString",
    "ActionTypes",
    "actionTypes_default",
    "isPlainObject",
    "obj",
    "proto",
    "createStore",
    "preloadedState",
    "enhancer",
    "currentReducer",
    "currentListeners",
    "nextListeners",
    "listenerIdCounter",
    "isDispatching",
    "ensureCanMutateNextListeners",
    "getState",
    "listenerId",
    "replaceReducer",
    "nextReducer",
    "observable",
    "outerSubscribe",
    "observer",
    "observeState",
    "observerAsObserver",
    "assertReducerShape",
    "reducers",
    "combineReducers",
    "reducerKeys",
    "finalReducers",
    "finalReducerKeys",
    "shapeAssertionError",
    "hasChanged",
    "previousStateForKey",
    "nextStateForKey",
    "compose",
    "funcs",
    "arg",
    "args",
    "applyMiddleware",
    "middlewares",
    "createStore2",
    "middlewareAPI",
    "chain",
    "middleware",
    "isAction",
    "NOTHING",
    "DRAFTABLE",
    "DRAFT_STATE",
    "die",
    "getPrototypeOf",
    "isDraft",
    "isDraftable",
    "_a",
    "isMap",
    "isSet",
    "objectCtorString",
    "Ctor",
    "original",
    "each",
    "iter",
    "getArchtype",
    "entry",
    "thing",
    "propOrOldValue",
    "latest",
    "shallowCopy",
    "strict",
    "descriptors",
    "desc",
    "freeze",
    "deep",
    "isFrozen",
    "dontMutateFrozenCollections",
    "_key",
    "plugins",
    "getPlugin",
    "pluginKey",
    "plugin",
    "loadPlugin",
    "currentScope",
    "getCurrentScope",
    "createScope",
    "parent_",
    "immer_",
    "usePatchesInScope",
    "patchListener",
    "revokeScope",
    "leaveScope",
    "revokeDraft",
    "enterScope",
    "immer2",
    "draft",
    "processResult",
    "baseDraft",
    "finalize",
    "maybeFreeze",
    "rootScope",
    "path",
    "childValue",
    "finalizeProperty",
    "resultEach",
    "isSet2",
    "parentState",
    "targetObject",
    "rootPath",
    "targetIsSet",
    "res",
    "createProxyProxy",
    "traps",
    "objectTraps",
    "arrayTraps",
    "revoke",
    "proxy",
    "readPropFromProto",
    "peek",
    "prepareCopy",
    "createProxy",
    "getDescriptorFromProto",
    "current2",
    "markChanged",
    "Immer2",
    "recipe",
    "defaultBase",
    "self",
    "base2",
    "ip",
    "patches",
    "inversePatches",
    "patch",
    "applyPatchesImpl",
    "currentImpl",
    "copy",
    "enablePatches",
    "REPLACE",
    "ADD",
    "REMOVE",
    "generatePatches_",
    "basePath",
    "generatePatchesFromAssigned",
    "generateArrayPatches",
    "generateSetPatches",
    "base_",
    "assigned_",
    "copy_",
    "clonePatchValueIfNeeded",
    "assignedValue",
    "origValue",
    "op",
    "generateReplacementPatches_",
    "baseValue",
    "replacement",
    "applyPatches_",
    "deepClonePatchValue",
    "cloned",
    "immer",
    "produce",
    "produceWithPatches",
    "applyPatches",
    "assertIsFunction",
    "errorMessage",
    "assertIsArrayOfFunctions",
    "item",
    "itemTypes",
    "ensureIsArray",
    "getDependencies",
    "createSelectorArgs",
    "collectInputSelectorResults",
    "inputSelectorArgs",
    "inputSelectorResults",
    "StrongRef",
    "UNTERMINATED",
    "TERMINATED",
    "createCacheNode",
    "weakMapMemoize",
    "fnNode",
    "resultEqualityCheck",
    "lastResult",
    "resultsCount",
    "memoized",
    "cacheNode",
    "objectCache",
    "objectNode",
    "primitiveCache",
    "primitiveNode",
    "terminatedNode",
    "lastResultValue",
    "createSelectorCreator",
    "memoizeOrOptions",
    "memoizeOptionsFromArgs",
    "createSelectorCreatorOptions",
    "recomputations",
    "dependencyRecomputations",
    "directlyPassedOptions",
    "resultFunc",
    "combinedOptions",
    "memoize",
    "memoizeOptions",
    "argsMemoize",
    "argsMemoizeOptions",
    "finalMemoizeOptions",
    "finalArgsMemoizeOptions",
    "memoizedResultFunc",
    "createSelector",
    "createThunkMiddleware",
    "extraArgument",
    "thunk",
    "withExtraArgument",
    "createDraftSafeSelectorCreator",
    "createSelector2",
    "createDraftSafeSelector2",
    "args2",
    "rest",
    "composeWithDevTools",
    "hasMatchFunction",
    "createAction",
    "prepareAction",
    "actionCreator",
    "prepared",
    "Tuple",
    "_Tuple",
    "items",
    "arr",
    "freezeDraftable",
    "val",
    "createNextState",
    "emplace",
    "handler",
    "inserted",
    "isBoolean",
    "buildGetDefaultMiddleware",
    "immutableCheck",
    "serializableCheck",
    "actionCreatorCheck",
    "middlewareArray",
    "thunkMiddleware",
    "SHOULD_AUTOBATCH",
    "prepareAutoBatched",
    "createQueueWithTimer",
    "timeout",
    "notify",
    "rAF",
    "autoBatchEnhancer",
    "notifying",
    "shouldNotifyAtEndOfTick",
    "notificationQueued",
    "queueCallback",
    "notifyListeners",
    "listener2",
    "wrappedListener",
    "buildGetDefaultEnhancers",
    "middlewareEnhancer",
    "autoBatch",
    "enhancerArray",
    "IS_PRODUCTION",
    "configureStore",
    "getDefaultMiddleware",
    "devTools",
    "enhancers",
    "rootReducer",
    "isPlainObject2",
    "finalMiddleware",
    "finalCompose",
    "compose2",
    "getDefaultEnhancers",
    "storeEnhancers",
    "composedEnhancer",
    "executeReducerBuilderCallback",
    "builderCallback",
    "actionsMap",
    "actionMatchers",
    "defaultCaseReducer",
    "builder",
    "typeOrActionCreator",
    "matcher",
    "isStateFunction",
    "createReducer",
    "mapOrBuilderCallback",
    "finalActionMatchers",
    "finalDefaultCaseReducer",
    "getInitialState",
    "frozenInitialState",
    "caseReducers",
    "reducer2",
    "cr",
    "caseReducer",
    "isDraft2",
    "isDraftable2",
    "createNextState2",
    "urlAlphabet",
    "nanoid",
    "matches",
    "isAnyOf",
    "matchers",
    "isAllOf",
    "hasExpectedRequestMetadata",
    "validStatus",
    "hasValidRequestId",
    "hasValidRequestStatus",
    "isAsyncThunkArray",
    "asyncThunks",
    "asyncThunk",
    "isRejected",
    "isRejectedWithValue",
    "hasFlag",
    "isFulfilled",
    "isAsyncThunkAction",
    "commonProperties",
    "RejectWithValue",
    "__publicField",
    "FulfillWithMeta",
    "miniSerializeError",
    "simpleError",
    "property",
    "createAsyncThunk",
    "createAsyncThunk2",
    "typePrefix",
    "payloadCreator",
    "fulfilled",
    "requestId",
    "rejected",
    "extra",
    "abortController",
    "abortHandler",
    "abortReason",
    "abort",
    "reason",
    "promise",
    "finalAction",
    "conditionResult",
    "isThenable",
    "abortedPromise",
    "_",
    "reject",
    "_b",
    "unwrapResult",
    "asyncThunkSymbol",
    "getType",
    "actionKey",
    "buildCreateSlice",
    "creators",
    "cAT",
    "reducerPath",
    "buildReducerCreators",
    "reducerNames",
    "contextMethods",
    "name2",
    "reducerName",
    "reducerDefinition",
    "reducerDetails",
    "isAsyncThunkSliceReducerDefinition",
    "handleThunkCaseReducerDefinition",
    "handleNormalReducerDefinition",
    "buildReducer",
    "extraReducers",
    "finalCaseReducers",
    "sM",
    "selectSelf",
    "injectedSelectorCache",
    "_reducer",
    "makeSelectorProps",
    "reducerPath2",
    "injected",
    "selectSlice",
    "sliceState",
    "getSelectors",
    "selectState",
    "selectorCache",
    "wrapSelector",
    "injectable",
    "pathOpt",
    "newReducerPath",
    "wrapper",
    "rootState",
    "createSlice",
    "prepare",
    "createNotation",
    "maybeReducerWithPrepare",
    "prepareCallback",
    "isCaseReducerWithPrepareDefinition",
    "settled",
    "assertFunction",
    "expected",
    "alm",
    "getListenerEntryPropsFrom",
    "predicate",
    "createListenerEntry",
    "addListener",
    "removeListener",
    "QueryStatus",
    "QueryStatus2",
    "getRequestStatusFlags",
    "status",
    "isAbsoluteUrl",
    "withoutTrailingSlash",
    "withoutLeadingSlash",
    "joinUrls",
    "delimiter",
    "flatten",
    "isOnline",
    "isDocumentVisible",
    "copyWithStructuralSharing",
    "oldObj",
    "newObj",
    "newKeys",
    "oldKeys",
    "isSameObject",
    "mergeObj",
    "defaultFetchFn",
    "defaultValidateStatus",
    "response",
    "defaultIsJsonContentType",
    "headers",
    "stripUndefined",
    "fetchBaseQuery",
    "baseUrl",
    "prepareHeaders",
    "fetchFn",
    "paramsSerializer",
    "isJsonContentType",
    "jsonContentType",
    "jsonReplacer",
    "defaultTimeout",
    "globalResponseHandler",
    "globalValidateStatus",
    "baseFetchOptions",
    "api",
    "signal",
    "endpoint",
    "forced",
    "params",
    "responseHandler",
    "validateStatus",
    "isJsonifiable",
    "divider",
    "query",
    "request",
    "timedOut",
    "timeoutId",
    "responseClone",
    "resultData",
    "responseText",
    "handleResponseError",
    "handleResponse",
    "HandledError",
    "onFocus",
    "onFocusLost",
    "onOnline",
    "onOffline",
    "initialized",
    "setupListeners",
    "customHandler",
    "defaultHandler",
    "handleFocus",
    "handleFocusLost",
    "handleOnline",
    "handleOffline",
    "handleVisibilityChange",
    "isQueryDefinition",
    "isMutationDefinition",
    "calculateProvidedBy",
    "description",
    "queryArg",
    "assertTagTypes",
    "isFunction",
    "expandTagDescription",
    "isNotNullish",
    "countObjectKeys",
    "asSafePromise",
    "forceQueryFnSymbol",
    "isUpsertQuery",
    "buildInitiate",
    "serializeQueryArgs",
    "queryThunk",
    "mutationThunk",
    "runningQueries",
    "runningMutations",
    "unsubscribeQueryResult",
    "removeMutationResult",
    "updateSubscriptionOptions",
    "buildInitiateQuery",
    "buildInitiateMutation",
    "getRunningQueryThunk",
    "getRunningMutationThunk",
    "getRunningQueriesThunk",
    "getRunningMutationsThunk",
    "endpointName",
    "queryArgs",
    "endpointDefinition",
    "queryCacheKey",
    "_endpointName",
    "fixedCacheKeyOrRequestId",
    "queryAction",
    "forceRefetch",
    "subscriptionOptions",
    "forceQueryFn",
    "thunkResult",
    "stateAfter",
    "skippedSynchronously",
    "runningQuery",
    "selectFromState",
    "statePromise",
    "running",
    "fixedCacheKey",
    "unwrap",
    "returnValuePromise",
    "reset",
    "ret",
    "defaultTransformResponse",
    "baseQueryReturnValue",
    "buildThunks",
    "baseQuery",
    "endpointDefinitions",
    "assertTagType",
    "patchQueryData",
    "updateProvided",
    "providedTags",
    "updateQueryData",
    "updateRecipe",
    "upsertQueryData",
    "executeEndpoint",
    "rejectWithValue",
    "fulfillWithValue",
    "transformResponse",
    "baseQueryApi",
    "isForcedQuery",
    "catchedError",
    "transformErrorResponse",
    "requestState",
    "baseFetchOnMountOrArgChange",
    "_c",
    "fulfilledVal",
    "refetchVal",
    "queryThunkArgs",
    "currentArg",
    "previousArg",
    "hasTheForce",
    "hasMaxAge",
    "prefetch",
    "force",
    "maxAge",
    "force2",
    "options2",
    "latestStateValue",
    "lastFulfilledTs",
    "matchesEndpoint",
    "buildMatchThunkActions",
    "calculateProvidedByThunk",
    "updateQuerySubstateIfExists",
    "substate",
    "getMutationCacheKey",
    "updateMutationSubstateIfExists",
    "buildSlice",
    "definitions",
    "apiUid",
    "extractRehydrationInfo",
    "hasRehydrationInfo",
    "resetApiState",
    "querySlice",
    "upserting",
    "merge",
    "fulfilledTimeStamp",
    "baseQueryMeta",
    "newData",
    "draftSubstateData",
    "condition",
    "queries",
    "mutationSlice",
    "cacheKey",
    "startedTimeStamp",
    "mutations",
    "invalidationSlice",
    "tagTypeSubscriptions",
    "idSubscriptions",
    "foundAt",
    "subscribedQueries",
    "provided",
    "incomingTags",
    "cacheKeys",
    "subscriptionSlice",
    "internalSubscriptionsSlice",
    "configSlice",
    "combinedReducer",
    "actions",
    "skipToken",
    "initialSubState",
    "defaultQuerySubState",
    "defaultMutationSubState",
    "buildSelectors",
    "selectSkippedQuery",
    "selectSkippedMutation",
    "buildQuerySelector",
    "buildMutationSelector",
    "selectInvalidatedBy",
    "selectCachedArgsForQuery",
    "withRequestFlags",
    "selectInternalState",
    "serializedArgs",
    "mutationId",
    "tags",
    "apiState",
    "toInvalidate",
    "invalidateSubscriptions",
    "invalidate",
    "querySubState",
    "queryName",
    "defaultSerializeQueryArgs",
    "serialized",
    "cached",
    "stringified",
    "acc",
    "key2",
    "buildCreateApi",
    "modules",
    "optionsWithDefaults",
    "queryArgsApi",
    "finalSerializeQueryArgs",
    "endpointSQA",
    "queryArgsApi2",
    "initialResult",
    "injectEndpoints",
    "addTagTypes",
    "endpoints",
    "eT",
    "partialDefinition",
    "initializedModules",
    "evaluatedEndpoints",
    "definition",
    "_formatProdErrorMessage2",
    "isObjectEmpty",
    "THIRTY_TWO_BIT_MAX_TIMER_SECONDS",
    "buildCacheCollectionHandler",
    "internalState",
    "removeQueryResult",
    "canTriggerUnsubscribe",
    "isAnyOf2",
    "anySubscriptionsRemainingForKey",
    "subscriptions",
    "currentRemovalTimeouts",
    "mwApi",
    "internalState2",
    "handleUnsubscribe",
    "queryState",
    "api2",
    "keepUnusedDataFor",
    "finalKeepUnusedDataFor",
    "currentTimeout",
    "buildInvalidationByTagsHandler",
    "refetchQuery",
    "isThunkActionWithTags",
    "isQueryEnd",
    "pendingTagInvalidations",
    "invalidateTags",
    "hasPendingRequests",
    "newTags",
    "valuesArray",
    "subscriptionSubState",
    "buildPollingHandler",
    "currentPolls",
    "updatePollingInterval",
    "startNextPoll",
    "clearPolls",
    "lowestPollingInterval",
    "skipPollingIfUnfocused",
    "findLowestPollingInterval",
    "currentPoll",
    "nextPollTimestamp",
    "cleanupPollForKey",
    "existingPoll",
    "subscribers",
    "buildWindowEventHandler",
    "refetchValidQueries",
    "sub",
    "neverResolvedError",
    "buildCacheLifecycleHandler",
    "isQueryThunk",
    "isMutationThunk",
    "isFulfilledThunk",
    "lifecycleMap",
    "stateBefore",
    "getCacheKey",
    "handleNewKey",
    "lifecycle",
    "cacheKey2",
    "originalArgs",
    "onCacheEntryAdded",
    "cacheEntryRemoved",
    "cacheDataLoaded",
    "__",
    "extra2",
    "lifecycleApi",
    "runningHandler",
    "buildQueryLifecycleHandler",
    "isPendingThunk",
    "isRejectedThunk",
    "isFullfilledThunk",
    "onQueryStarted",
    "queryFulfilled",
    "rejectedWithValue",
    "buildDevCheckHandler",
    "buildBatchedActionsHandler",
    "subscriptionsPrefix",
    "previousSubscriptions",
    "updateSyncTimer",
    "actuallyMutateSubscriptions",
    "mutableState",
    "mutated",
    "getSubscriptions",
    "subscriptionSelectors",
    "subscriptionsForQueryArg",
    "didMutate",
    "actionShouldContinue",
    "newSubscriptions",
    "produceWithPatches2",
    "isSubscriptionSliceAction",
    "isAdditionalSubscriptionAction",
    "buildMiddleware",
    "isThisApiSliceAction",
    "handlerBuilders",
    "initialized2",
    "builderArgs",
    "handlers",
    "build",
    "batchedActionsHandler",
    "windowEventsHandler",
    "mwApiWithNext",
    "internalProbeResult",
    "override",
    "safeAssign",
    "coreModuleName",
    "coreModule",
    "tagTypes",
    "refetchOnMountOrArgChange",
    "refetchOnFocus",
    "refetchOnReconnect",
    "invalidationBehavior",
    "sliceActions",
    "middlewareActions",
    "anyApi",
    "str",
    "UNINITIALIZED_VALUE",
    "useStableQueryArgs",
    "serialize",
    "incoming",
    "cache2",
    "useShallowStableValue",
    "useRef2",
    "useEffect2",
    "useEffect3",
    "noPendingQueryStateSelector",
    "buildHooks",
    "unstable__sideEffectsInRender",
    "usePossiblyImmediateEffect",
    "cb",
    "buildQueryHooks",
    "buildMutationHook",
    "usePrefetch",
    "queryStatePreSelector",
    "hasData",
    "isFetching",
    "isLoading",
    "isSuccess",
    "defaultOptions",
    "stableDefaultOptions",
    "useQuerySubscription",
    "skip",
    "pollingInterval",
    "initiate",
    "subscriptionSelectorsRef",
    "useRef3",
    "returnedValue",
    "stableArg",
    "stableSubscriptionOptions",
    "lastRenderHadSubscription",
    "promiseRef",
    "currentRenderHasSubscription",
    "subscriptionRemoved",
    "lastPromise",
    "lastSubscriptionOptions",
    "useMemo2",
    "useLazyQuerySubscription",
    "setArg",
    "subscriptionOptionsRef",
    "trigger",
    "preferCacheValue",
    "useQueryState",
    "selectFromResult",
    "select",
    "selectDefaultResult",
    "shallowEqual2",
    "querySelector",
    "newLastValue",
    "queryStateResults",
    "querySubscriptionResults",
    "isError",
    "setPromise",
    "triggerMutation",
    "promise2",
    "mutationSelector",
    "finalState",
    "reactHooksModuleName",
    "reactHooksModule",
    "rrBatch",
    "hooks",
    "rrUseDispatch",
    "rrUseSelector",
    "rrUseStore",
    "_createSelector",
    "useQuery",
    "useLazyQuery",
    "useMutation",
    "createApi"
  ],
  "sources": [
    "../../../node_modules/react/cjs/react.production.js",
    "../../../node_modules/react/index.js",
    "../../../node_modules/react/cjs/react-jsx-runtime.production.min.js",
    "../../../node_modules/react/jsx-runtime.js",
    "../../../node_modules/scheduler/cjs/scheduler.production.min.js",
    "../../../node_modules/scheduler/index.js",
    "../../../node_modules/react-dom/cjs/react-dom.production.js",
    "../../../node_modules/react-dom/index.js",
    "../../../node_modules/react-dom/client.js",
    "../../../node_modules/use-sync-external-store/cjs/use-sync-external-store-with-selector.production.min.js",
    "../../../node_modules/use-sync-external-store/with-selector.js",
    "../../../node_modules/react-redux/dist/react-redux.mjs",
    "../../../node_modules/redux/dist/redux.mjs",
    "../../../node_modules/immer/dist/immer.mjs",
    "../../../node_modules/reselect/dist/reselect.mjs",
    "../../../node_modules/redux-thunk/dist/redux-thunk.mjs",
    "../../../node_modules/@reduxjs/toolkit/dist/redux-toolkit.modern.mjs",
    "../../../node_modules/@reduxjs/toolkit/dist/query/rtk-query.modern.mjs",
    "../../../node_modules/@reduxjs/toolkit/dist/query/react/rtk-query-react.modern.mjs"
  ],
  "sourcesContent": [
    "'use strict';\n\nvar ReactVersion = '18.2.0';\n\n// ATTENTION\n// When adding new symbols to this file,\n// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'\n// The Symbol used to tag the ReactElement-like types.\nconst REACT_ELEMENT_TYPE = Symbol.for('react.element');\nconst REACT_PORTAL_TYPE = Symbol.for('react.portal');\nconst REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');\nconst REACT_STRICT_MODE_TYPE = Symbol.for('react.strict_mode');\nconst REACT_PROFILER_TYPE = Symbol.for('react.profiler');\nconst REACT_PROVIDER_TYPE = Symbol.for('react.provider');\nconst REACT_CONTEXT_TYPE = Symbol.for('react.context');\nconst REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');\nconst REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');\nconst REACT_MEMO_TYPE = Symbol.for('react.memo');\nconst REACT_LAZY_TYPE = Symbol.for('react.lazy');\nconst MAYBE_ITERATOR_SYMBOL = Symbol.iterator;\nconst FAUX_ITERATOR_SYMBOL = '@@iterator';\nfunction getIteratorFn(maybeIterable) {\n  if (maybeIterable === null || typeof maybeIterable !== 'object') {\n    return null;\n  }\n\n  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];\n\n  if (typeof maybeIterator === 'function') {\n    return maybeIterator;\n  }\n\n  return null;\n}\n\n/**\n * This is the abstract API for an update queue.\n */\n\n\nconst ReactNoopUpdateQueue = {\n  /**\n   * Checks whether or not this composite component is mounted.\n   * @param {ReactClass} publicInstance The instance we want to test.\n   * @return {boolean} True if mounted, false otherwise.\n   * @protected\n   * @final\n   */\n  isMounted: function (publicInstance) {\n    return false;\n  },\n\n  /**\n   * Forces an update. This should only be invoked when it is known with\n   * certainty that we are **not** in a DOM transaction.\n   *\n   * You may want to call this when you know that some deeper aspect of the\n   * component's state has changed but `setState` was not called.\n   *\n   * This will not invoke `shouldComponentUpdate`, but it will invoke\n   * `componentWillUpdate` and `componentDidUpdate`.\n   *\n   * @param {ReactClass} publicInstance The instance that should rerender.\n   * @param {?function} callback Called after component is updated.\n   * @param {?string} callerName name of the calling function in the public API.\n   * @internal\n   */\n  enqueueForceUpdate: function (publicInstance, callback, callerName) {\n  },\n\n  /**\n   * Replaces all of the state. Always use this or `setState` to mutate state.\n   * You should treat `this.state` as immutable.\n   *\n   * There is no guarantee that `this.state` will be immediately updated, so\n   * accessing `this.state` after calling this method may return the old value.\n   *\n   * @param {ReactClass} publicInstance The instance that should rerender.\n   * @param {object} completeState Next state.\n   * @param {?function} callback Called after component is updated.\n   * @param {?string} callerName name of the calling function in the public API.\n   * @internal\n   */\n  enqueueReplaceState: function (publicInstance, completeState, callback, callerName) {\n  },\n\n  /**\n   * Sets a subset of the state. This only exists because _pendingState is\n   * internal. This provides a merging strategy that is not available to deep\n   * properties which is confusing. TODO: Expose pendingState or don't use it\n   * during the merge.\n   *\n   * @param {ReactClass} publicInstance The instance that should rerender.\n   * @param {object} partialState Next partial state to be merged with state.\n   * @param {?function} callback Called after component is updated.\n   * @param {?string} Name of the calling function in the public API.\n   * @internal\n   */\n  enqueueSetState: function (publicInstance, partialState, callback, callerName) {\n  }\n};\n\nconst assign = Object.assign;\n\nconst emptyObject = {};\n/**\n * Base class helpers for the updating state of a component.\n */\n\n\nfunction Component(props, context, updater) {\n  this.props = props;\n  this.context = context; // If a component has string refs, we will assign a different object later.\n\n  this.refs = emptyObject; // We initialize the default updater but the real one gets injected by the\n  // renderer.\n\n  this.updater = updater || ReactNoopUpdateQueue;\n}\n\nComponent.prototype.isReactComponent = {};\n/**\n * Sets a subset of the state. Always use this to mutate\n * state. You should treat `this.state` as immutable.\n *\n * There is no guarantee that `this.state` will be immediately updated, so\n * accessing `this.state` after calling this method may return the old value.\n *\n * There is no guarantee that calls to `setState` will run synchronously,\n * as they may eventually be batched together.  You can provide an optional\n * callback that will be executed when the call to setState is actually\n * completed.\n *\n * When a function is provided to setState, it will be called at some point in\n * the future (not synchronously). It will be called with the up to date\n * component arguments (state, props, context). These values can be different\n * from this.* because your function may be called after receiveProps but before\n * shouldComponentUpdate, and this new state, props, and context will not yet be\n * assigned to this.\n *\n * @param {object|function} partialState Next partial state or function to\n *        produce next partial state to be merged with current state.\n * @param {?function} callback Called after state is updated.\n * @final\n * @protected\n */\n\nComponent.prototype.setState = function (partialState, callback) {\n  if (typeof partialState !== 'object' && typeof partialState !== 'function' && partialState != null) {\n    throw new Error('setState(...): takes an object of state variables to update or a ' + 'function which returns an object of state variables.');\n  }\n\n  this.updater.enqueueSetState(this, partialState, callback, 'setState');\n};\n/**\n * Forces an update. This should only be invoked when it is known with\n * certainty that we are **not** in a DOM transaction.\n *\n * You may want to call this when you know that some deeper aspect of the\n * component's state has changed but `setState` was not called.\n *\n * This will not invoke `shouldComponentUpdate`, but it will invoke\n * `componentWillUpdate` and `componentDidUpdate`.\n *\n * @param {?function} callback Called after update is complete.\n * @final\n * @protected\n */\n\n\nComponent.prototype.forceUpdate = function (callback) {\n  this.updater.enqueueForceUpdate(this, callback, 'forceUpdate');\n};\n\nfunction ComponentDummy() {}\n\nComponentDummy.prototype = Component.prototype;\n/**\n * Convenience component with default shallow equality check for sCU.\n */\n\nfunction PureComponent(props, context, updater) {\n  this.props = props;\n  this.context = context; // If a component has string refs, we will assign a different object later.\n\n  this.refs = emptyObject;\n  this.updater = updater || ReactNoopUpdateQueue;\n}\n\nconst pureComponentPrototype = PureComponent.prototype = new ComponentDummy();\npureComponentPrototype.constructor = PureComponent; // Avoid an extra prototype jump for these methods.\n\nassign(pureComponentPrototype, Component.prototype);\npureComponentPrototype.isPureReactComponent = true;\n\n// an immutable object with a single mutable value\nfunction createRef() {\n  const refObject = {\n    current: null\n  };\n\n  return refObject;\n}\n\nconst isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare\n\nfunction isArray(a) {\n  return isArrayImpl(a);\n}\n\nconst hasOwnProperty = Object.prototype.hasOwnProperty;\n\n/**\n * Keeps track of the current owner.\n *\n * The current owner is the component who should own any components that are\n * currently being constructed.\n */\nconst ReactCurrentOwner = {\n  /**\n   * @internal\n   * @type {ReactComponent}\n   */\n  current: null\n};\n\nconst RESERVED_PROPS = {\n  key: true,\n  ref: true,\n  __self: true,\n  __source: true\n};\n\nfunction hasValidRef(config) {\n\n  return config.ref !== undefined;\n}\n\nfunction hasValidKey(config) {\n\n  return config.key !== undefined;\n}\n/**\n * Factory method to create a new React element. This no longer adheres to\n * the class pattern, so do not use new to call it. Also, instanceof check\n * will not work. Instead test $$typeof field against Symbol.for('react.element') to check\n * if something is a React Element.\n *\n * @param {*} type\n * @param {*} props\n * @param {*} key\n * @param {string|object} ref\n * @param {*} owner\n * @param {*} self A *temporary* helper to detect places where `this` is\n * different from the `owner` when React.createElement is called, so that we\n * can warn. We want to get rid of owner and replace string `ref`s with arrow\n * functions, and as long as `this` and owner are the same, there will be no\n * change in behavior.\n * @param {*} source An annotation object (added by a transpiler or otherwise)\n * indicating filename, line number, and/or other information.\n * @internal\n */\n\n\nconst ReactElement = function (type, key, ref, self, source, owner, props) {\n  const element = {\n    // This tag allows us to uniquely identify this as a React Element\n    $$typeof: REACT_ELEMENT_TYPE,\n    // Built-in properties that belong on the element\n    type: type,\n    key: key,\n    ref: ref,\n    props: props,\n    // Record the component responsible for creating this element.\n    _owner: owner\n  };\n\n  return element;\n};\n/**\n * Create and return a new ReactElement of the given type.\n * See https://reactjs.org/docs/react-api.html#createelement\n */\n\nfunction createElement(type, config, children) {\n  let propName; // Reserved names are extracted\n\n  const props = {};\n  let key = null;\n  let ref = null;\n  let self = null;\n  let source = null;\n\n  if (config != null) {\n    if (hasValidRef(config)) {\n      ref = config.ref;\n    }\n\n    if (hasValidKey(config)) {\n\n      key = '' + config.key;\n    }\n\n    self = config.__self === undefined ? null : config.__self;\n    source = config.__source === undefined ? null : config.__source; // Remaining properties are added to a new props object\n\n    for (propName in config) {\n      if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {\n        props[propName] = config[propName];\n      }\n    }\n  } // Children can be more than one argument, and those are transferred onto\n  // the newly allocated props object.\n\n\n  const childrenLength = arguments.length - 2;\n\n  if (childrenLength === 1) {\n    props.children = children;\n  } else if (childrenLength > 1) {\n    const childArray = Array(childrenLength);\n\n    for (let i = 0; i < childrenLength; i++) {\n      childArray[i] = arguments[i + 2];\n    }\n\n    props.children = childArray;\n  } // Resolve default props\n\n\n  if (type && type.defaultProps) {\n    const defaultProps = type.defaultProps;\n\n    for (propName in defaultProps) {\n      if (props[propName] === undefined) {\n        props[propName] = defaultProps[propName];\n      }\n    }\n  }\n\n  return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);\n}\n/**\n * Return a function that produces ReactElements of a given type.\n * See https://reactjs.org/docs/react-api.html#createfactory\n */\n\nfunction createFactory(type) {\n  const factory = createElement.bind(null, type); // Expose the type on the factory and the prototype so that it can be\n  // easily accessed on elements. E.g. `<Foo />.type === Foo`.\n  // This should not be named `constructor` since this may not be the function\n  // that created the element, and it may not even be a constructor.\n  // Legacy hook: remove it\n\n  factory.type = type;\n  return factory;\n}\nfunction cloneAndReplaceKey(oldElement, newKey) {\n  const newElement = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props);\n  return newElement;\n}\n/**\n * Clone and return a new ReactElement using element as the starting point.\n * See https://reactjs.org/docs/react-api.html#cloneelement\n */\n\nfunction cloneElement(element, config, children) {\n  if (element === null || element === undefined) {\n    throw new Error(\"React.cloneElement(...): The argument must be a React element, but you passed \" + element + \".\");\n  }\n\n  let propName; // Original props are copied\n\n  const props = assign({}, element.props); // Reserved names are extracted\n\n  let key = element.key;\n  let ref = element.ref; // Self is preserved since the owner is preserved.\n\n  const self = element._self; // Source is preserved since cloneElement is unlikely to be targeted by a\n  // transpiler, and the original source is probably a better indicator of the\n  // true owner.\n\n  const source = element._source; // Owner will be preserved, unless ref is overridden\n\n  let owner = element._owner;\n\n  if (config != null) {\n    if (hasValidRef(config)) {\n      // Silently steal the ref from the parent.\n      ref = config.ref;\n      owner = ReactCurrentOwner.current;\n    }\n\n    if (hasValidKey(config)) {\n\n      key = '' + config.key;\n    } // Remaining properties override existing props\n\n\n    let defaultProps;\n\n    if (element.type && element.type.defaultProps) {\n      defaultProps = element.type.defaultProps;\n    }\n\n    for (propName in config) {\n      if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {\n        if (config[propName] === undefined && defaultProps !== undefined) {\n          // Resolve default props\n          props[propName] = defaultProps[propName];\n        } else {\n          props[propName] = config[propName];\n        }\n      }\n    }\n  } // Children can be more than one argument, and those are transferred onto\n  // the newly allocated props object.\n\n\n  const childrenLength = arguments.length - 2;\n\n  if (childrenLength === 1) {\n    props.children = children;\n  } else if (childrenLength > 1) {\n    const childArray = Array(childrenLength);\n\n    for (let i = 0; i < childrenLength; i++) {\n      childArray[i] = arguments[i + 2];\n    }\n\n    props.children = childArray;\n  }\n\n  return ReactElement(element.type, key, ref, self, source, owner, props);\n}\n/**\n * Verifies the object is a ReactElement.\n * See https://reactjs.org/docs/react-api.html#isvalidelement\n * @param {?object} object\n * @return {boolean} True if `object` is a ReactElement.\n * @final\n */\n\nfunction isValidElement(object) {\n  return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;\n}\n\nconst SEPARATOR = '.';\nconst SUBSEPARATOR = ':';\n/**\n * Escape and wrap key so it is safe to use as a reactid\n *\n * @param {string} key to be escaped.\n * @return {string} the escaped key.\n */\n\nfunction escape(key) {\n  const escapeRegex = /[=:]/g;\n  const escaperLookup = {\n    '=': '=0',\n    ':': '=2'\n  };\n  const escapedString = key.replace(escapeRegex, function (match) {\n    return escaperLookup[match];\n  });\n  return '$' + escapedString;\n}\nconst userProvidedKeyEscapeRegex = /\\/+/g;\n\nfunction escapeUserProvidedKey(text) {\n  return text.replace(userProvidedKeyEscapeRegex, '$&/');\n}\n/**\n * Generate a key string that identifies a element within a set.\n *\n * @param {*} element A element that could contain a manual key.\n * @param {number} index Index that is used if a manual key is not provided.\n * @return {string}\n */\n\n\nfunction getElementKey(element, index) {\n  // Do some typechecking here since we call this blindly. We want to ensure\n  // that we don't block potential future ES APIs.\n  if (typeof element === 'object' && element !== null && element.key != null) {\n\n    return escape('' + element.key);\n  } // Implicit key determined by the index in the set\n\n\n  return index.toString(36);\n}\n\nfunction mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {\n  const type = typeof children;\n\n  if (type === 'undefined' || type === 'boolean') {\n    // All of the above are perceived as null.\n    children = null;\n  }\n\n  let invokeCallback = false;\n\n  if (children === null) {\n    invokeCallback = true;\n  } else {\n    switch (type) {\n      case 'string':\n      case 'number':\n        invokeCallback = true;\n        break;\n\n      case 'object':\n        switch (children.$$typeof) {\n          case REACT_ELEMENT_TYPE:\n          case REACT_PORTAL_TYPE:\n            invokeCallback = true;\n        }\n\n    }\n  }\n\n  if (invokeCallback) {\n    const child = children;\n    let mappedChild = callback(child); // If it's the only child, treat the name as if it was wrapped in an array\n    // so that it's consistent if the number of children grows:\n\n    const childKey = nameSoFar === '' ? SEPARATOR + getElementKey(child, 0) : nameSoFar;\n\n    if (isArray(mappedChild)) {\n      let escapedChildKey = '';\n\n      if (childKey != null) {\n        escapedChildKey = escapeUserProvidedKey(childKey) + '/';\n      }\n\n      mapIntoArray(mappedChild, array, escapedChildKey, '', c => c);\n    } else if (mappedChild != null) {\n      if (isValidElement(mappedChild)) {\n\n        mappedChild = cloneAndReplaceKey(mappedChild, // Keep both the (mapped) and old keys if they differ, just as\n        // traverseAllChildren used to do for objects as children\n        escapedPrefix + ( // $FlowFixMe Flow incorrectly thinks React.Portal doesn't have a key\n        mappedChild.key && (!child || child.key !== mappedChild.key) ? // $FlowFixMe Flow incorrectly thinks existing element's key can be a number\n        // eslint-disable-next-line react-internal/safe-string-coercion\n        escapeUserProvidedKey('' + mappedChild.key) + '/' : '') + childKey);\n      }\n\n      array.push(mappedChild);\n    }\n\n    return 1;\n  }\n\n  let child;\n  let nextName;\n  let subtreeCount = 0; // Count of children found in the current subtree.\n\n  const nextNamePrefix = nameSoFar === '' ? SEPARATOR : nameSoFar + SUBSEPARATOR;\n\n  if (isArray(children)) {\n    for (let i = 0; i < children.length; i++) {\n      child = children[i];\n      nextName = nextNamePrefix + getElementKey(child, i);\n      subtreeCount += mapIntoArray(child, array, escapedPrefix, nextName, callback);\n    }\n  } else {\n    const iteratorFn = getIteratorFn(children);\n\n    if (typeof iteratorFn === 'function') {\n      const iterableChildren = children;\n\n      const iterator = iteratorFn.call(iterableChildren);\n      let step;\n      let ii = 0;\n\n      while (!(step = iterator.next()).done) {\n        child = step.value;\n        nextName = nextNamePrefix + getElementKey(child, ii++);\n        subtreeCount += mapIntoArray(child, array, escapedPrefix, nextName, callback);\n      }\n    } else if (type === 'object') {\n      // eslint-disable-next-line react-internal/safe-string-coercion\n      const childrenString = String(children);\n      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.');\n    }\n  }\n\n  return subtreeCount;\n}\n\n/**\n * Maps children that are typically specified as `props.children`.\n *\n * See https://reactjs.org/docs/react-api.html#reactchildrenmap\n *\n * The provided mapFunction(child, index) will be called for each\n * leaf child.\n *\n * @param {?*} children Children tree container.\n * @param {function(*, int)} func The map function.\n * @param {*} context Context for mapFunction.\n * @return {object} Object containing the ordered map of results.\n */\nfunction mapChildren(children, func, context) {\n  if (children == null) {\n    return children;\n  }\n\n  const result = [];\n  let count = 0;\n  mapIntoArray(children, result, '', '', function (child) {\n    return func.call(context, child, count++);\n  });\n  return result;\n}\n/**\n * Count the number of children that are typically specified as\n * `props.children`.\n *\n * See https://reactjs.org/docs/react-api.html#reactchildrencount\n *\n * @param {?*} children Children tree container.\n * @return {number} The number of children.\n */\n\n\nfunction countChildren(children) {\n  let n = 0;\n  mapChildren(children, () => {\n    n++; // Don't return anything\n  });\n  return n;\n}\n\n/**\n * Iterates through children that are typically specified as `props.children`.\n *\n * See https://reactjs.org/docs/react-api.html#reactchildrenforeach\n *\n * The provided forEachFunc(child, index) will be called for each\n * leaf child.\n *\n * @param {?*} children Children tree container.\n * @param {function(*, int)} forEachFunc\n * @param {*} forEachContext Context for forEachContext.\n */\nfunction forEachChildren(children, forEachFunc, forEachContext) {\n  mapChildren(children, function () {\n    forEachFunc.apply(this, arguments); // Don't return anything.\n  }, forEachContext);\n}\n/**\n * Flatten a children object (typically specified as `props.children`) and\n * return an array with appropriately re-keyed children.\n *\n * See https://reactjs.org/docs/react-api.html#reactchildrentoarray\n */\n\n\nfunction toArray(children) {\n  return mapChildren(children, child => child) || [];\n}\n/**\n * Returns the first child in a collection of children and verifies that there\n * is only one child in the collection.\n *\n * See https://reactjs.org/docs/react-api.html#reactchildrenonly\n *\n * The current implementation of this function assumes that a single child gets\n * passed without a wrapper, but the purpose of this helper function is to\n * abstract away the particular structure of children.\n *\n * @param {?object} children Child collection structure.\n * @return {ReactElement} The first and only `ReactElement` contained in the\n * structure.\n */\n\n\nfunction onlyChild(children) {\n  if (!isValidElement(children)) {\n    throw new Error('React.Children.only expected to receive a single React element child.');\n  }\n\n  return children;\n}\n\nfunction createContext(defaultValue) {\n  // TODO: Second argument used to be an optional `calculateChangedBits`\n  // function. Warn to reserve for future use?\n  const context = {\n    $$typeof: REACT_CONTEXT_TYPE,\n    // As a workaround to support multiple concurrent renderers, we categorize\n    // some renderers as primary and others as secondary. We only expect\n    // there to be two concurrent renderers at most: React Native (primary) and\n    // Fabric (secondary); React DOM (primary) and React ART (secondary).\n    // Secondary renderers store their context values on separate fields.\n    _currentValue: defaultValue,\n    _currentValue2: defaultValue,\n    // Used to track how many concurrent renderers this context currently\n    // supports within in a single renderer. Such as parallel server rendering.\n    _threadCount: 0,\n    // These are circular\n    Provider: null,\n    Consumer: null,\n    // Add these to use same hidden class in VM as ServerContext\n    _defaultValue: null,\n    _globalName: null\n  };\n  context.Provider = {\n    $$typeof: REACT_PROVIDER_TYPE,\n    _context: context\n  };\n\n  {\n    context.Consumer = context;\n  }\n\n  return context;\n}\n\nconst Uninitialized = -1;\nconst Pending = 0;\nconst Resolved = 1;\nconst Rejected = 2;\n\nfunction lazyInitializer(payload) {\n  if (payload._status === Uninitialized) {\n    const ctor = payload._result;\n    const thenable = ctor(); // Transition to the next state.\n    // This might throw either because it's missing or throws. If so, we treat it\n    // as still uninitialized and try again next time. Which is the same as what\n    // happens if the ctor or any wrappers processing the ctor throws. This might\n    // end up fixing it if the resolution was a concurrency bug.\n\n    thenable.then(moduleObject => {\n      if (payload._status === Pending || payload._status === Uninitialized) {\n        // Transition to the next state.\n        const resolved = payload;\n        resolved._status = Resolved;\n        resolved._result = moduleObject;\n      }\n    }, error => {\n      if (payload._status === Pending || payload._status === Uninitialized) {\n        // Transition to the next state.\n        const rejected = payload;\n        rejected._status = Rejected;\n        rejected._result = error;\n      }\n    });\n\n    if (payload._status === Uninitialized) {\n      // In case, we're still uninitialized, then we're waiting for the thenable\n      // to resolve. Set it as pending in the meantime.\n      const pending = payload;\n      pending._status = Pending;\n      pending._result = thenable;\n    }\n  }\n\n  if (payload._status === Resolved) {\n    const moduleObject = payload._result;\n\n    return moduleObject.default;\n  } else {\n    throw payload._result;\n  }\n}\n\nfunction lazy(ctor) {\n  const payload = {\n    // We use these fields to store the result.\n    _status: Uninitialized,\n    _result: ctor\n  };\n  const lazyType = {\n    $$typeof: REACT_LAZY_TYPE,\n    _payload: payload,\n    _init: lazyInitializer\n  };\n\n  return lazyType;\n}\n\nfunction forwardRef(render) {\n\n  const elementType = {\n    $$typeof: REACT_FORWARD_REF_TYPE,\n    render\n  };\n\n  return elementType;\n}\n\nfunction memo(type, compare) {\n\n  const elementType = {\n    $$typeof: REACT_MEMO_TYPE,\n    type,\n    compare: compare === undefined ? null : compare\n  };\n\n  return elementType;\n}\n\n/**\n * Keeps track of the current dispatcher.\n */\nconst ReactCurrentDispatcher = {\n  /**\n   * @internal\n   * @type {ReactComponent}\n   */\n  current: null\n};\n\nfunction resolveDispatcher() {\n  const dispatcher = ReactCurrentDispatcher.current;\n  // intentionally don't throw our own error because this is in a hot path.\n  // Also helps ensure this is inlined.\n\n\n  return dispatcher;\n}\nfunction useContext(Context) {\n  const dispatcher = resolveDispatcher();\n\n  return dispatcher.useContext(Context);\n}\nfunction useState(initialState) {\n  const dispatcher = resolveDispatcher();\n  return dispatcher.useState(initialState);\n}\nfunction useReducer(reducer, initialArg, init) {\n  const dispatcher = resolveDispatcher();\n  return dispatcher.useReducer(reducer, initialArg, init);\n}\nfunction useRef(initialValue) {\n  const dispatcher = resolveDispatcher();\n  return dispatcher.useRef(initialValue);\n}\nfunction useEffect(create, deps) {\n  const dispatcher = resolveDispatcher();\n  return dispatcher.useEffect(create, deps);\n}\nfunction useInsertionEffect(create, deps) {\n  const dispatcher = resolveDispatcher();\n  return dispatcher.useInsertionEffect(create, deps);\n}\nfunction useLayoutEffect(create, deps) {\n  const dispatcher = resolveDispatcher();\n  return dispatcher.useLayoutEffect(create, deps);\n}\nfunction useCallback(callback, deps) {\n  const dispatcher = resolveDispatcher();\n  return dispatcher.useCallback(callback, deps);\n}\nfunction useMemo(create, deps) {\n  const dispatcher = resolveDispatcher();\n  return dispatcher.useMemo(create, deps);\n}\nfunction useImperativeHandle(ref, create, deps) {\n  const dispatcher = resolveDispatcher();\n  return dispatcher.useImperativeHandle(ref, create, deps);\n}\nfunction useDebugValue(value, formatterFn) {\n}\nfunction useTransition() {\n  const dispatcher = resolveDispatcher();\n  return dispatcher.useTransition();\n}\nfunction useDeferredValue(value) {\n  const dispatcher = resolveDispatcher();\n  return dispatcher.useDeferredValue(value);\n}\nfunction useId() {\n  const dispatcher = resolveDispatcher();\n  return dispatcher.useId();\n}\nfunction useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {\n  const dispatcher = resolveDispatcher();\n  return dispatcher.useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);\n}\n\n/**\n * Keeps track of the current batch's configuration such as how long an update\n * should suspend for if it needs to.\n */\nconst ReactCurrentBatchConfig = {\n  transition: null\n};\n\nconst ReactSharedInternals = {\n  ReactCurrentDispatcher,\n  ReactCurrentBatchConfig,\n  ReactCurrentOwner\n};\n\nfunction startTransition(scope, options) {\n  const prevTransition = ReactCurrentBatchConfig.transition;\n  ReactCurrentBatchConfig.transition = {};\n\n  try {\n    scope();\n  } finally {\n    ReactCurrentBatchConfig.transition = prevTransition;\n  }\n}\n\nfunction act(callback) {\n  {\n    throw new Error('act(...) is not supported in production builds of React.');\n  }\n}\n\nconst createElement$1 =  createElement;\nconst cloneElement$1 =  cloneElement;\nconst createFactory$1 =  createFactory;\nconst Children = {\n  map: mapChildren,\n  forEach: forEachChildren,\n  count: countChildren,\n  toArray,\n  only: onlyChild\n};\n\nexports.Children = Children;\nexports.Component = Component;\nexports.Fragment = REACT_FRAGMENT_TYPE;\nexports.Profiler = REACT_PROFILER_TYPE;\nexports.PureComponent = PureComponent;\nexports.StrictMode = REACT_STRICT_MODE_TYPE;\nexports.Suspense = REACT_SUSPENSE_TYPE;\nexports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = ReactSharedInternals;\nexports.cloneElement = cloneElement$1;\nexports.createContext = createContext;\nexports.createElement = createElement$1;\nexports.createFactory = createFactory$1;\nexports.createRef = createRef;\nexports.forwardRef = forwardRef;\nexports.isValidElement = isValidElement;\nexports.lazy = lazy;\nexports.memo = memo;\nexports.startTransition = startTransition;\nexports.unstable_act = act;\nexports.useCallback = useCallback;\nexports.useContext = useContext;\nexports.useDebugValue = useDebugValue;\nexports.useDeferredValue = useDeferredValue;\nexports.useEffect = useEffect;\nexports.useId = useId;\nexports.useImperativeHandle = useImperativeHandle;\nexports.useInsertionEffect = useInsertionEffect;\nexports.useLayoutEffect = useLayoutEffect;\nexports.useMemo = useMemo;\nexports.useReducer = useReducer;\nexports.useRef = useRef;\nexports.useState = useState;\nexports.useSyncExternalStore = useSyncExternalStore;\nexports.useTransition = useTransition;\nexports.version = ReactVersion;",
    "'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/react.production.min.js');\n} else {\n  module.exports = require('./cjs/react.development.js');\n}\n",
    "/**\n * @license React\n * react-jsx-runtime.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n'use strict';var f=require(\"react\"),k=Symbol.for(\"react.element\"),l=Symbol.for(\"react.fragment\"),m=Object.prototype.hasOwnProperty,n=f.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner,p={key:!0,ref:!0,__self:!0,__source:!0};\nfunction q(c,a,g){var b,d={},e=null,h=null;void 0!==g&&(e=\"\"+g);void 0!==a.key&&(e=\"\"+a.key);void 0!==a.ref&&(h=a.ref);for(b in a)m.call(a,b)&&!p.hasOwnProperty(b)&&(d[b]=a[b]);if(c&&c.defaultProps)for(b in a=c.defaultProps,a)void 0===d[b]&&(d[b]=a[b]);return{$$typeof:k,type:c,key:e,ref:h,props:d,_owner:n.current}}exports.Fragment=l;exports.jsx=q;exports.jsxs=q;\n",
    "'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/react-jsx-runtime.production.min.js');\n} else {\n  module.exports = require('./cjs/react-jsx-runtime.development.js');\n}\n",
    "/**\n * @license React\n * scheduler.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n'use strict';function f(a,b){var c=a.length;a.push(b);a:for(;0<c;){var d=c-1>>>1,e=a[d];if(0<g(e,b))a[d]=b,a[c]=e,c=d;else break a}}function h(a){return 0===a.length?null:a[0]}function k(a){if(0===a.length)return null;var b=a[0],c=a.pop();if(c!==b){a[0]=c;a:for(var d=0,e=a.length,w=e>>>1;d<w;){var m=2*(d+1)-1,C=a[m],n=m+1,x=a[n];if(0>g(C,c))n<e&&0>g(x,C)?(a[d]=x,a[n]=c,d=n):(a[d]=C,a[m]=c,d=m);else if(n<e&&0>g(x,c))a[d]=x,a[n]=c,d=n;else break a}}return b}\nfunction g(a,b){var c=a.sortIndex-b.sortIndex;return 0!==c?c:a.id-b.id}if(\"object\"===typeof performance&&\"function\"===typeof performance.now){var l=performance;exports.unstable_now=function(){return l.now()}}else{var p=Date,q=p.now();exports.unstable_now=function(){return p.now()-q}}var r=[],t=[],u=1,v=null,y=3,z=!1,A=!1,B=!1,D=\"function\"===typeof setTimeout?setTimeout:null,E=\"function\"===typeof clearTimeout?clearTimeout:null,F=\"undefined\"!==typeof setImmediate?setImmediate:null;\n\"undefined\"!==typeof navigator&&void 0!==navigator.scheduling&&void 0!==navigator.scheduling.isInputPending&&navigator.scheduling.isInputPending.bind(navigator.scheduling);function G(a){for(var b=h(t);null!==b;){if(null===b.callback)k(t);else if(b.startTime<=a)k(t),b.sortIndex=b.expirationTime,f(r,b);else break;b=h(t)}}function H(a){B=!1;G(a);if(!A)if(null!==h(r))A=!0,I(J);else{var b=h(t);null!==b&&K(H,b.startTime-a)}}\nfunction J(a,b){A=!1;B&&(B=!1,E(L),L=-1);z=!0;var c=y;try{G(b);for(v=h(r);null!==v&&(!(v.expirationTime>b)||a&&!M());){var d=v.callback;if(\"function\"===typeof d){v.callback=null;y=v.priorityLevel;var e=d(v.expirationTime<=b);b=exports.unstable_now();\"function\"===typeof e?v.callback=e:v===h(r)&&k(r);G(b)}else k(r);v=h(r)}if(null!==v)var w=!0;else{var m=h(t);null!==m&&K(H,m.startTime-b);w=!1}return w}finally{v=null,y=c,z=!1}}var N=!1,O=null,L=-1,P=5,Q=-1;\nfunction M(){return exports.unstable_now()-Q<P?!1:!0}function R(){if(null!==O){var a=exports.unstable_now();Q=a;var b=!0;try{b=O(!0,a)}finally{b?S():(N=!1,O=null)}}else N=!1}var S;if(\"function\"===typeof F)S=function(){F(R)};else if(\"undefined\"!==typeof MessageChannel){var T=new MessageChannel,U=T.port2;T.port1.onmessage=R;S=function(){U.postMessage(null)}}else S=function(){D(R,0)};function I(a){O=a;N||(N=!0,S())}function K(a,b){L=D(function(){a(exports.unstable_now())},b)}\nexports.unstable_IdlePriority=5;exports.unstable_ImmediatePriority=1;exports.unstable_LowPriority=4;exports.unstable_NormalPriority=3;exports.unstable_Profiling=null;exports.unstable_UserBlockingPriority=2;exports.unstable_cancelCallback=function(a){a.callback=null};exports.unstable_continueExecution=function(){A||z||(A=!0,I(J))};\nexports.unstable_forceFrameRate=function(a){0>a||125<a?console.error(\"forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported\"):P=0<a?Math.floor(1E3/a):5};exports.unstable_getCurrentPriorityLevel=function(){return y};exports.unstable_getFirstCallbackNode=function(){return h(r)};exports.unstable_next=function(a){switch(y){case 1:case 2:case 3:var b=3;break;default:b=y}var c=y;y=b;try{return a()}finally{y=c}};exports.unstable_pauseExecution=function(){};\nexports.unstable_requestPaint=function(){};exports.unstable_runWithPriority=function(a,b){switch(a){case 1:case 2:case 3:case 4:case 5:break;default:a=3}var c=y;y=a;try{return b()}finally{y=c}};\nexports.unstable_scheduleCallback=function(a,b,c){var d=exports.unstable_now();\"object\"===typeof c&&null!==c?(c=c.delay,c=\"number\"===typeof c&&0<c?d+c:d):c=d;switch(a){case 1:var e=-1;break;case 2:e=250;break;case 5:e=1073741823;break;case 4:e=1E4;break;default:e=5E3}e=c+e;a={id:u++,callback:b,priorityLevel:a,startTime:c,expirationTime:e,sortIndex:-1};c>d?(a.sortIndex=c,f(t,a),null===h(r)&&a===h(t)&&(B?(E(L),L=-1):B=!0,K(H,c-d))):(a.sortIndex=e,f(r,a),A||z||(A=!0,I(J)));return a};\nexports.unstable_shouldYield=M;exports.unstable_wrapCallback=function(a){var b=y;return function(){var c=y;y=b;try{return a.apply(this,arguments)}finally{y=c}}};\n",
    "'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/scheduler.production.min.js');\n} else {\n  module.exports = require('./cjs/scheduler.development.js');\n}\n",
    "'use strict';\n\nvar React = require('react');\nvar Scheduler = require('scheduler');\n\n// Do not require this module directly! Use normal `invariant` calls with\n// template literal strings. The messages will be replaced with error codes\n// during build.\nfunction formatProdErrorMessage(code) {\n  let url = 'https://reactjs.org/docs/error-decoder.html?invariant=' + code;\n\n  for (let i = 1; i < arguments.length; i++) {\n    url += '&args[]=' + encodeURIComponent(arguments[i]);\n  }\n\n  return \"Minified React error #\" + code + \"; visit \" + url + \" for the full message or \" + 'use the non-minified dev environment for full errors and additional ' + 'helpful warnings.';\n}\n\nconst FunctionComponent = 0;\nconst ClassComponent = 1;\nconst IndeterminateComponent = 2; // Before we know whether it is function or class\n\nconst HostRoot = 3; // Root of a host tree. Could be nested inside another node.\n\nconst HostPortal = 4; // A subtree. Could be an entry point to a different renderer.\n\nconst HostComponent = 5;\nconst HostText = 6;\nconst Fragment = 7;\nconst Mode = 8;\nconst ContextConsumer = 9;\nconst ContextProvider = 10;\nconst ForwardRef = 11;\nconst Profiler = 12;\nconst SuspenseComponent = 13;\nconst MemoComponent = 14;\nconst SimpleMemoComponent = 15;\nconst LazyComponent = 16;\nconst IncompleteClassComponent = 17;\nconst DehydratedFragment = 18;\nconst SuspenseListComponent = 19;\nconst ScopeComponent = 21;\nconst OffscreenComponent = 22;\nconst LegacyHiddenComponent = 23;\nconst CacheComponent = 24;\nconst TracingMarkerComponent = 25;\n\n// -----------------------------------------------------------------------------\n\nconst enableClientRenderFallbackOnTextMismatch = true; // TODO: Need to review this code one more time before landing\n// the react-reconciler package.\n\nconst enableNewReconciler = false; // Support legacy Primer support on internal FB www\n\nconst enableLazyContextPropagation = false; // FB-only usage. The new API has different semantics.\n\nconst enableLegacyHidden = false; // Enables unstable_avoidThisFallback feature in Fiber\n\nconst enableSuspenseAvoidThisFallback = false; // Enables unstable_avoidThisFallback feature in Fizz\n// React DOM Chopping Block\n//\n// Similar to main Chopping Block but only flags related to React DOM. These are\n// grouped because we will likely batch all of them into a single major release.\n// -----------------------------------------------------------------------------\n// Disable support for comment nodes as React DOM containers. Already disabled\n// in open source, but www codebase still relies on it. Need to remove.\n\nconst disableCommentsAsDOMContainers = true; // Disable javascript: URL strings in href for XSS protection.\n// Debugging and DevTools\n// -----------------------------------------------------------------------------\n// Adds user timing marks for e.g. state updates, suspense, and work loop stuff,\n// for an experimental timeline tool.\n\nconst enableSchedulingProfiler = false; // Helps identify side effects in render-phase lifecycle hooks and setState\n\nconst enableProfilerTimer = false; // Record durations for commit and passive effects phases.\n\nconst enableProfilerCommitHooks = false; // Phase param passed to onRender callback differentiates between an \"update\" and a \"cascading-update\".\n\nconst allNativeEvents = new Set();\n/**\n * Mapping from registration name to event name\n */\n\n\nconst registrationNameDependencies = {};\n\nfunction registerTwoPhaseEvent(registrationName, dependencies) {\n  registerDirectEvent(registrationName, dependencies);\n  registerDirectEvent(registrationName + 'Capture', dependencies);\n}\nfunction registerDirectEvent(registrationName, dependencies) {\n\n  registrationNameDependencies[registrationName] = dependencies;\n\n  for (let i = 0; i < dependencies.length; i++) {\n    allNativeEvents.add(dependencies[i]);\n  }\n}\n\nconst canUseDOM = !!(typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined');\n\nconst hasOwnProperty = Object.prototype.hasOwnProperty;\n\n// A reserved attribute.\n// It is handled by React separately and shouldn't be written to the DOM.\nconst RESERVED = 0; // A simple string attribute.\n// Attributes that aren't in the filter are presumed to have this type.\n\nconst STRING = 1; // A string attribute that accepts booleans in React. In HTML, these are called\n// \"enumerated\" attributes with \"true\" and \"false\" as possible values.\n// When true, it should be set to a \"true\" string.\n// When false, it should be set to a \"false\" string.\n\nconst BOOLEANISH_STRING = 2; // A real boolean attribute.\n// When true, it should be present (set either to an empty string or its name).\n// When false, it should be omitted.\n\nconst BOOLEAN = 3; // An attribute that can be used as a flag as well as with a value.\n// When true, it should be present (set either to an empty string or its name).\n// When false, it should be omitted.\n// For any other value, should be present with that value.\n\nconst OVERLOADED_BOOLEAN = 4; // An attribute that must be numeric or parse as a numeric.\n// When falsy, it should be removed.\n\nconst NUMERIC = 5; // An attribute that must be positive numeric or parse as a positive numeric.\n// When falsy, it should be removed.\n\nconst POSITIVE_NUMERIC = 6;\n\n/* eslint-disable max-len */\nconst ATTRIBUTE_NAME_START_CHAR = ':A-Z_a-z\\\\u00C0-\\\\u00D6\\\\u00D8-\\\\u00F6\\\\u00F8-\\\\u02FF\\\\u0370-\\\\u037D\\\\u037F-\\\\u1FFF\\\\u200C-\\\\u200D\\\\u2070-\\\\u218F\\\\u2C00-\\\\u2FEF\\\\u3001-\\\\uD7FF\\\\uF900-\\\\uFDCF\\\\uFDF0-\\\\uFFFD';\n/* eslint-enable max-len */\n\nconst ATTRIBUTE_NAME_CHAR = ATTRIBUTE_NAME_START_CHAR + '\\\\-.0-9\\\\u00B7\\\\u0300-\\\\u036F\\\\u203F-\\\\u2040';\nconst VALID_ATTRIBUTE_NAME_REGEX = new RegExp('^[' + ATTRIBUTE_NAME_START_CHAR + '][' + ATTRIBUTE_NAME_CHAR + ']*$');\nconst illegalAttributeNameCache = {};\nconst validatedAttributeNameCache = {};\nfunction isAttributeNameSafe(attributeName) {\n  if (hasOwnProperty.call(validatedAttributeNameCache, attributeName)) {\n    return true;\n  }\n\n  if (hasOwnProperty.call(illegalAttributeNameCache, attributeName)) {\n    return false;\n  }\n\n  if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName)) {\n    validatedAttributeNameCache[attributeName] = true;\n    return true;\n  }\n\n  illegalAttributeNameCache[attributeName] = true;\n\n  return false;\n}\nfunction shouldIgnoreAttribute(name, propertyInfo, isCustomComponentTag) {\n  if (propertyInfo !== null) {\n    return propertyInfo.type === RESERVED;\n  }\n\n  if (isCustomComponentTag) {\n    return false;\n  }\n\n  if (name.length > 2 && (name[0] === 'o' || name[0] === 'O') && (name[1] === 'n' || name[1] === 'N')) {\n    return true;\n  }\n\n  return false;\n}\nfunction shouldRemoveAttributeWithWarning(name, value, propertyInfo, isCustomComponentTag) {\n  if (propertyInfo !== null && propertyInfo.type === RESERVED) {\n    return false;\n  }\n\n  switch (typeof value) {\n    case 'function': // $FlowIssue symbol is perfectly valid here\n\n    case 'symbol':\n      // eslint-disable-line\n      return true;\n\n    case 'boolean':\n      {\n        if (isCustomComponentTag) {\n          return false;\n        }\n\n        if (propertyInfo !== null) {\n          return !propertyInfo.acceptsBooleans;\n        } else {\n          const prefix = name.toLowerCase().slice(0, 5);\n          return prefix !== 'data-' && prefix !== 'aria-';\n        }\n      }\n\n    default:\n      return false;\n  }\n}\nfunction shouldRemoveAttribute(name, value, propertyInfo, isCustomComponentTag) {\n  if (value === null || typeof value === 'undefined') {\n    return true;\n  }\n\n  if (shouldRemoveAttributeWithWarning(name, value, propertyInfo, isCustomComponentTag)) {\n    return true;\n  }\n\n  if (isCustomComponentTag) {\n\n    return false;\n  }\n\n  if (propertyInfo !== null) {\n\n    switch (propertyInfo.type) {\n      case BOOLEAN:\n        return !value;\n\n      case OVERLOADED_BOOLEAN:\n        return value === false;\n\n      case NUMERIC:\n        return isNaN(value);\n\n      case POSITIVE_NUMERIC:\n        return isNaN(value) || value < 1;\n    }\n  }\n\n  return false;\n}\nfunction getPropertyInfo(name) {\n  return properties.hasOwnProperty(name) ? properties[name] : null;\n}\n\nfunction PropertyInfoRecord(name, type, mustUseProperty, attributeName, attributeNamespace, sanitizeURL, removeEmptyString) {\n  this.acceptsBooleans = type === BOOLEANISH_STRING || type === BOOLEAN || type === OVERLOADED_BOOLEAN;\n  this.attributeName = attributeName;\n  this.attributeNamespace = attributeNamespace;\n  this.mustUseProperty = mustUseProperty;\n  this.propertyName = name;\n  this.type = type;\n  this.sanitizeURL = sanitizeURL;\n  this.removeEmptyString = removeEmptyString;\n} // When adding attributes to this list, be sure to also add them to\n// the `possibleStandardNames` module to ensure casing and incorrect\n// name warnings.\n\n\nconst properties = {}; // These props are reserved by React. They shouldn't be written to the DOM.\n\nconst reservedProps = ['children', 'dangerouslySetInnerHTML', // TODO: This prevents the assignment of defaultValue to regular\n// elements (not just inputs). Now that ReactDOMInput assigns to the\n// defaultValue property -- do we need this?\n'defaultValue', 'defaultChecked', 'innerHTML', 'suppressContentEditableWarning', 'suppressHydrationWarning', 'style'];\n\nreservedProps.forEach(name => {\n  properties[name] = new PropertyInfoRecord(name, RESERVED, false, // mustUseProperty\n  name, // attributeName\n  null, // attributeNamespace\n  false, // sanitizeURL\n  false);\n}); // A few React string attributes have a different name.\n// This is a mapping from React prop names to the attribute names.\n\n[['acceptCharset', 'accept-charset'], ['className', 'class'], ['htmlFor', 'for'], ['httpEquiv', 'http-equiv']].forEach((_ref) => {\n  let name = _ref[0],\n      attributeName = _ref[1];\n  properties[name] = new PropertyInfoRecord(name, STRING, false, // mustUseProperty\n  attributeName, // attributeName\n  null, // attributeNamespace\n  false, // sanitizeURL\n  false);\n}); // These are \"enumerated\" HTML attributes that accept \"true\" and \"false\".\n// In React, we let users pass `true` and `false` even though technically\n// these aren't boolean attributes (they are coerced to strings).\n\n['contentEditable', 'draggable', 'spellCheck', 'value'].forEach(name => {\n  properties[name] = new PropertyInfoRecord(name, BOOLEANISH_STRING, false, // mustUseProperty\n  name.toLowerCase(), // attributeName\n  null, // attributeNamespace\n  false, // sanitizeURL\n  false);\n}); // These are \"enumerated\" SVG attributes that accept \"true\" and \"false\".\n// In React, we let users pass `true` and `false` even though technically\n// these aren't boolean attributes (they are coerced to strings).\n// Since these are SVG attributes, their attribute names are case-sensitive.\n\n['autoReverse', 'externalResourcesRequired', 'focusable', 'preserveAlpha'].forEach(name => {\n  properties[name] = new PropertyInfoRecord(name, BOOLEANISH_STRING, false, // mustUseProperty\n  name, // attributeName\n  null, // attributeNamespace\n  false, // sanitizeURL\n  false);\n}); // These are HTML boolean attributes.\n\n['allowFullScreen', 'async', // Note: there is a special case that prevents it from being written to the DOM\n// on the client side because the browsers are inconsistent. Instead we call focus().\n'autoFocus', 'autoPlay', 'controls', 'default', 'defer', 'disabled', 'disablePictureInPicture', 'disableRemotePlayback', 'formNoValidate', 'hidden', 'loop', 'noModule', 'noValidate', 'open', 'playsInline', 'readOnly', 'required', 'reversed', 'scoped', 'seamless', // Microdata\n'itemScope'].forEach(name => {\n  properties[name] = new PropertyInfoRecord(name, BOOLEAN, false, // mustUseProperty\n  name.toLowerCase(), // attributeName\n  null, // attributeNamespace\n  false, // sanitizeURL\n  false);\n}); // These are the few React props that we set as DOM properties\n// rather than attributes. These are all booleans.\n\n['checked', // Note: `option.selected` is not updated if `select.multiple` is\n// disabled with `removeAttribute`. We have special logic for handling this.\n'multiple', 'muted', 'selected' // NOTE: if you add a camelCased prop to this list,\n// you'll need to set attributeName to name.toLowerCase()\n// instead in the assignment below.\n].forEach(name => {\n  properties[name] = new PropertyInfoRecord(name, BOOLEAN, true, // mustUseProperty\n  name, // attributeName\n  null, // attributeNamespace\n  false, // sanitizeURL\n  false);\n}); // These are HTML attributes that are \"overloaded booleans\": they behave like\n// booleans, but can also accept a string value.\n\n['capture', 'download' // NOTE: if you add a camelCased prop to this list,\n// you'll need to set attributeName to name.toLowerCase()\n// instead in the assignment below.\n].forEach(name => {\n  properties[name] = new PropertyInfoRecord(name, OVERLOADED_BOOLEAN, false, // mustUseProperty\n  name, // attributeName\n  null, // attributeNamespace\n  false, // sanitizeURL\n  false);\n}); // These are HTML attributes that must be positive numbers.\n\n['cols', 'rows', 'size', 'span' // NOTE: if you add a camelCased prop to this list,\n// you'll need to set attributeName to name.toLowerCase()\n// instead in the assignment below.\n].forEach(name => {\n  properties[name] = new PropertyInfoRecord(name, POSITIVE_NUMERIC, false, // mustUseProperty\n  name, // attributeName\n  null, // attributeNamespace\n  false, // sanitizeURL\n  false);\n}); // These are HTML attributes that must be numbers.\n\n['rowSpan', 'start'].forEach(name => {\n  properties[name] = new PropertyInfoRecord(name, NUMERIC, false, // mustUseProperty\n  name.toLowerCase(), // attributeName\n  null, // attributeNamespace\n  false, // sanitizeURL\n  false);\n});\nconst CAMELIZE = /[\\-\\:]([a-z])/g;\n\nconst capitalize = token => token[1].toUpperCase(); // This is a list of all SVG attributes that need special casing, namespacing,\n// or boolean value assignment. Regular attributes that just accept strings\n// and have the same names are omitted, just like in the HTML attribute filter.\n// Some of these attributes can be hard to find. This list was created by\n// scraping the MDN documentation.\n\n\n['accent-height', 'alignment-baseline', 'arabic-form', 'baseline-shift', 'cap-height', 'clip-path', 'clip-rule', 'color-interpolation', 'color-interpolation-filters', 'color-profile', 'color-rendering', 'dominant-baseline', 'enable-background', 'fill-opacity', 'fill-rule', 'flood-color', 'flood-opacity', 'font-family', 'font-size', 'font-size-adjust', 'font-stretch', 'font-style', 'font-variant', 'font-weight', 'glyph-name', 'glyph-orientation-horizontal', 'glyph-orientation-vertical', 'horiz-adv-x', 'horiz-origin-x', 'image-rendering', 'letter-spacing', 'lighting-color', 'marker-end', 'marker-mid', 'marker-start', 'overline-position', 'overline-thickness', 'paint-order', 'panose-1', 'pointer-events', 'rendering-intent', 'shape-rendering', 'stop-color', 'stop-opacity', 'strikethrough-position', 'strikethrough-thickness', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke-width', 'text-anchor', 'text-decoration', 'text-rendering', 'underline-position', 'underline-thickness', 'unicode-bidi', 'unicode-range', 'units-per-em', 'v-alphabetic', 'v-hanging', 'v-ideographic', 'v-mathematical', 'vector-effect', 'vert-adv-y', 'vert-origin-x', 'vert-origin-y', 'word-spacing', 'writing-mode', 'xmlns:xlink', 'x-height' // NOTE: if you add a camelCased prop to this list,\n// you'll need to set attributeName to name.toLowerCase()\n// instead in the assignment below.\n].forEach(attributeName => {\n  const name = attributeName.replace(CAMELIZE, capitalize);\n  properties[name] = new PropertyInfoRecord(name, STRING, false, // mustUseProperty\n  attributeName, null, // attributeNamespace\n  false, // sanitizeURL\n  false);\n}); // String SVG attributes with the xlink namespace.\n\n['xlink:actuate', 'xlink:arcrole', 'xlink:role', 'xlink:show', 'xlink:title', 'xlink:type' // NOTE: if you add a camelCased prop to this list,\n// you'll need to set attributeName to name.toLowerCase()\n// instead in the assignment below.\n].forEach(attributeName => {\n  const name = attributeName.replace(CAMELIZE, capitalize);\n  properties[name] = new PropertyInfoRecord(name, STRING, false, // mustUseProperty\n  attributeName, 'http://www.w3.org/1999/xlink', false, // sanitizeURL\n  false);\n}); // String SVG attributes with the xml namespace.\n\n['xml:base', 'xml:lang', 'xml:space' // NOTE: if you add a camelCased prop to this list,\n// you'll need to set attributeName to name.toLowerCase()\n// instead in the assignment below.\n].forEach(attributeName => {\n  const name = attributeName.replace(CAMELIZE, capitalize);\n  properties[name] = new PropertyInfoRecord(name, STRING, false, // mustUseProperty\n  attributeName, 'http://www.w3.org/XML/1998/namespace', false, // sanitizeURL\n  false);\n}); // These attribute exists both in HTML and SVG.\n// The attribute name is case-sensitive in SVG so we can't just use\n// the React name like we do for attributes that exist only in HTML.\n\n['tabIndex', 'crossOrigin'].forEach(attributeName => {\n  properties[attributeName] = new PropertyInfoRecord(attributeName, STRING, false, // mustUseProperty\n  attributeName.toLowerCase(), // attributeName\n  null, // attributeNamespace\n  false, // sanitizeURL\n  false);\n}); // These attributes accept URLs. These must not allow javascript: URLS.\n// These will also need to accept Trusted Types object in the future.\n\nconst xlinkHref = 'xlinkHref';\nproperties[xlinkHref] = new PropertyInfoRecord('xlinkHref', STRING, false, // mustUseProperty\n'xlink:href', 'http://www.w3.org/1999/xlink', true, // sanitizeURL\nfalse);\n['src', 'href', 'action', 'formAction'].forEach(attributeName => {\n  properties[attributeName] = new PropertyInfoRecord(attributeName, STRING, false, // mustUseProperty\n  attributeName.toLowerCase(), // attributeName\n  null, // attributeNamespace\n  true, // sanitizeURL\n  true);\n});\n\nfunction sanitizeURL(url) {\n}\n\n/**\n * Get the value for a property on a node. Only used in DEV for SSR validation.\n * The \"expected\" argument is used as a hint of what the expected value is.\n * Some properties have multiple equivalent values.\n */\nfunction getValueForProperty(node, name, expected, propertyInfo) {\n}\n/**\n * Get the value for a attribute on a node. Only used in DEV for SSR validation.\n * The third argument is used as a hint of what the expected value is. Some\n * attributes have multiple equivalent values.\n */\n\nfunction getValueForAttribute(node, name, expected, isCustomComponentTag) {\n}\n/**\n * Sets the value for a property on a node.\n *\n * @param {DOMElement} node\n * @param {string} name\n * @param {*} value\n */\n\nfunction setValueForProperty(node, name, value, isCustomComponentTag) {\n  const propertyInfo = getPropertyInfo(name);\n\n  if (shouldIgnoreAttribute(name, propertyInfo, isCustomComponentTag)) {\n    return;\n  }\n\n  if (shouldRemoveAttribute(name, value, propertyInfo, isCustomComponentTag)) {\n    value = null;\n  }\n\n\n  if (isCustomComponentTag || propertyInfo === null) {\n    if (isAttributeNameSafe(name)) {\n      const attributeName = name;\n\n      if (value === null) {\n        node.removeAttribute(attributeName);\n      } else {\n\n        node.setAttribute(attributeName,  '' + value);\n      }\n    }\n\n    return;\n  }\n\n  const mustUseProperty = propertyInfo.mustUseProperty;\n\n  if (mustUseProperty) {\n    const propertyName = propertyInfo.propertyName;\n\n    if (value === null) {\n      const type = propertyInfo.type;\n      node[propertyName] = type === BOOLEAN ? false : '';\n    } else {\n      // Contrary to `setAttribute`, object properties are properly\n      // `toString`ed by IE8/9.\n      node[propertyName] = value;\n    }\n\n    return;\n  } // The rest are treated as attributes with special cases.\n\n\n  const attributeName = propertyInfo.attributeName,\n        attributeNamespace = propertyInfo.attributeNamespace;\n\n  if (value === null) {\n    node.removeAttribute(attributeName);\n  } else {\n    const type = propertyInfo.type;\n    let attributeValue;\n\n    if (type === BOOLEAN || type === OVERLOADED_BOOLEAN && value === true) {\n      // If attribute type is boolean, we know for sure it won't be an execution sink\n      // and we won't require Trusted Type here.\n      attributeValue = '';\n    } else {\n      // `setAttribute` with objects becomes only `[object]` in IE8/9,\n      // ('' + value) makes it output the correct toString()-value.\n      {\n\n        attributeValue = '' + value;\n      }\n\n      if (propertyInfo.sanitizeURL) {\n        sanitizeURL(attributeValue.toString());\n      }\n    }\n\n    if (attributeNamespace) {\n      node.setAttributeNS(attributeNamespace, attributeName, attributeValue);\n    } else {\n      node.setAttribute(attributeName, attributeValue);\n    }\n  }\n}\n\nconst ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;\n\n// ATTENTION\n// When adding new symbols to this file,\n// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'\n// The Symbol used to tag the ReactElement-like types.\nconst REACT_ELEMENT_TYPE = Symbol.for('react.element');\nconst REACT_PORTAL_TYPE = Symbol.for('react.portal');\nconst REACT_FRAGMENT_TYPE = Symbol.for('react.fragment');\nconst REACT_STRICT_MODE_TYPE = Symbol.for('react.strict_mode');\nconst REACT_PROFILER_TYPE = Symbol.for('react.profiler');\nconst REACT_PROVIDER_TYPE = Symbol.for('react.provider');\nconst REACT_CONTEXT_TYPE = Symbol.for('react.context');\nconst REACT_FORWARD_REF_TYPE = Symbol.for('react.forward_ref');\nconst REACT_SUSPENSE_TYPE = Symbol.for('react.suspense');\nconst REACT_SUSPENSE_LIST_TYPE = Symbol.for('react.suspense_list');\nconst REACT_MEMO_TYPE = Symbol.for('react.memo');\nconst REACT_LAZY_TYPE = Symbol.for('react.lazy');\nconst REACT_SCOPE_TYPE = Symbol.for('react.scope');\nconst REACT_DEBUG_TRACING_MODE_TYPE = Symbol.for('react.debug_trace_mode');\nconst REACT_OFFSCREEN_TYPE = Symbol.for('react.offscreen');\nconst REACT_LEGACY_HIDDEN_TYPE = Symbol.for('react.legacy_hidden');\nconst REACT_CACHE_TYPE = Symbol.for('react.cache');\nconst REACT_TRACING_MARKER_TYPE = Symbol.for('react.tracing_marker');\nconst MAYBE_ITERATOR_SYMBOL = Symbol.iterator;\nconst FAUX_ITERATOR_SYMBOL = '@@iterator';\nfunction getIteratorFn(maybeIterable) {\n  if (maybeIterable === null || typeof maybeIterable !== 'object') {\n    return null;\n  }\n\n  const maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];\n\n  if (typeof maybeIterator === 'function') {\n    return maybeIterator;\n  }\n\n  return null;\n}\n\nconst assign = Object.assign;\n\nconst ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;\nlet prefix;\nfunction describeBuiltInComponentFrame(name, source, ownerFn) {\n  {\n    if (prefix === undefined) {\n      // Extract the VM specific prefix used by each line.\n      try {\n        throw Error();\n      } catch (x) {\n        const match = x.stack.trim().match(/\\n( *(at )?)/);\n        prefix = match && match[1] || '';\n      }\n    } // We use the prefix to ensure our stacks line up with native stack frames.\n\n\n    return '\\n' + prefix + name;\n  }\n}\nlet reentry = false;\n\nfunction describeNativeComponentFrame(fn, construct) {\n  // If something asked for a stack inside a fake render, it should get ignored.\n  if ( !fn || reentry) {\n    return '';\n  }\n\n  let control;\n  reentry = true;\n  const previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe It does accept undefined.\n\n  Error.prepareStackTrace = undefined;\n\n  try {\n    // This should throw.\n    if (construct) {\n      // Something should be setting the props in the constructor.\n      const Fake = function () {\n        throw Error();\n      }; // $FlowFixMe\n\n\n      Object.defineProperty(Fake.prototype, 'props', {\n        set: function () {\n          // We use a throwing setter instead of frozen or non-writable props\n          // because that won't throw in a non-strict mode function.\n          throw Error();\n        }\n      });\n\n      if (typeof Reflect === 'object' && Reflect.construct) {\n        // We construct a different control for this case to include any extra\n        // frames added by the construct call.\n        try {\n          Reflect.construct(Fake, []);\n        } catch (x) {\n          control = x;\n        }\n\n        Reflect.construct(fn, [], Fake);\n      } else {\n        try {\n          Fake.call();\n        } catch (x) {\n          control = x;\n        }\n\n        fn.call(Fake.prototype);\n      }\n    } else {\n      try {\n        throw Error();\n      } catch (x) {\n        control = x;\n      }\n\n      fn();\n    }\n  } catch (sample) {\n    // This is inlined manually because closure doesn't do it for us.\n    if (sample && control && typeof sample.stack === 'string') {\n      // This extracts the first frame from the sample that isn't also in the control.\n      // Skipping one frame that we assume is the frame that calls the two.\n      const sampleLines = sample.stack.split('\\n');\n      const controlLines = control.stack.split('\\n');\n      let s = sampleLines.length - 1;\n      let c = controlLines.length - 1;\n\n      while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {\n        // We expect at least one stack frame to be shared.\n        // Typically this will be the root most one. However, stack frames may be\n        // cut off due to maximum stack limits. In this case, one maybe cut off\n        // earlier than the other. We assume that the sample is longer or the same\n        // and there for cut off earlier. So we should find the root most frame in\n        // the sample somewhere in the control.\n        c--;\n      }\n\n      for (; s >= 1 && c >= 0; s--, c--) {\n        // Next we find the first one that isn't the same which should be the\n        // frame that called our sample function and the control.\n        if (sampleLines[s] !== controlLines[c]) {\n          // In V8, the first line is describing the message but other VMs don't.\n          // If we're about to return the first line, and the control is also on the same\n          // line, that's a pretty good indicator that our sample threw at same line as\n          // the control. I.e. before we entered the sample frame. So we ignore this result.\n          // This can happen if you passed a class to function component, or non-function.\n          if (s !== 1 || c !== 1) {\n            do {\n              s--;\n              c--; // We may still have similar intermediate frames from the construct call.\n              // The next one that isn't the same should be our match though.\n\n              if (c < 0 || sampleLines[s] !== controlLines[c]) {\n                // V8 adds a \"new\" prefix for native classes. Let's remove it to make it prettier.\n                let frame = '\\n' + sampleLines[s].replace(' at new ', ' at '); // If our component frame is labeled \"<anonymous>\"\n                // but we have a user-provided \"displayName\"\n                // splice it in to make the stack more readable.\n\n                if (fn.displayName && frame.includes('<anonymous>')) {\n                  frame = frame.replace('<anonymous>', fn.displayName);\n                }\n\n\n                return frame;\n              }\n            } while (s >= 1 && c >= 0);\n          }\n\n          break;\n        }\n      }\n    }\n  } finally {\n    reentry = false;\n\n    Error.prepareStackTrace = previousPrepareStackTrace;\n  } // Fallback to just using the name if we couldn't make it throw.\n\n\n  const name = fn ? fn.displayName || fn.name : '';\n  const syntheticFrame = name ? describeBuiltInComponentFrame(name) : '';\n\n  return syntheticFrame;\n}\n\nfunction describeClassComponentFrame(ctor, source, ownerFn) {\n  {\n    return describeNativeComponentFrame(ctor, true);\n  }\n}\nfunction describeFunctionComponentFrame(fn, source, ownerFn) {\n  {\n    return describeNativeComponentFrame(fn, false);\n  }\n}\n\nfunction describeFiber(fiber) {\n\n  switch (fiber.tag) {\n    case HostComponent:\n      return describeBuiltInComponentFrame(fiber.type);\n\n    case LazyComponent:\n      return describeBuiltInComponentFrame('Lazy');\n\n    case SuspenseComponent:\n      return describeBuiltInComponentFrame('Suspense');\n\n    case SuspenseListComponent:\n      return describeBuiltInComponentFrame('SuspenseList');\n\n    case FunctionComponent:\n    case IndeterminateComponent:\n    case SimpleMemoComponent:\n      return describeFunctionComponentFrame(fiber.type);\n\n    case ForwardRef:\n      return describeFunctionComponentFrame(fiber.type.render);\n\n    case ClassComponent:\n      return describeClassComponentFrame(fiber.type);\n\n    default:\n      return '';\n  }\n}\n\nfunction getStackByFiberInDevAndProd(workInProgress) {\n  try {\n    let info = '';\n    let node = workInProgress;\n\n    do {\n      info += describeFiber(node);\n      node = node.return;\n    } while (node);\n\n    return info;\n  } catch (x) {\n    return '\\nError generating stack: ' + x.message + '\\n' + x.stack;\n  }\n}\n\nfunction getWrappedName(outerType, innerType, wrapperName) {\n  const displayName = outerType.displayName;\n\n  if (displayName) {\n    return displayName;\n  }\n\n  const functionName = innerType.displayName || innerType.name || '';\n  return functionName !== '' ? wrapperName + \"(\" + functionName + \")\" : wrapperName;\n} // Keep in sync with react-reconciler/getComponentNameFromFiber\n\n\nfunction getContextName(type) {\n  return type.displayName || 'Context';\n} // Note that the reconciler package should generally prefer to use getComponentNameFromFiber() instead.\n\n\nfunction getComponentNameFromType(type) {\n  if (type == null) {\n    // Host root, text node or just invalid type.\n    return null;\n  }\n\n  if (typeof type === 'function') {\n    return type.displayName || type.name || null;\n  }\n\n  if (typeof type === 'string') {\n    return type;\n  }\n\n  switch (type) {\n    case REACT_FRAGMENT_TYPE:\n      return 'Fragment';\n\n    case REACT_PORTAL_TYPE:\n      return 'Portal';\n\n    case REACT_PROFILER_TYPE:\n      return 'Profiler';\n\n    case REACT_STRICT_MODE_TYPE:\n      return 'StrictMode';\n\n    case REACT_SUSPENSE_TYPE:\n      return 'Suspense';\n\n    case REACT_SUSPENSE_LIST_TYPE:\n      return 'SuspenseList';\n\n  }\n\n  if (typeof type === 'object') {\n    switch (type.$$typeof) {\n      case REACT_CONTEXT_TYPE:\n        const context = type;\n        return getContextName(context) + '.Consumer';\n\n      case REACT_PROVIDER_TYPE:\n        const provider = type;\n        return getContextName(provider._context) + '.Provider';\n\n      case REACT_FORWARD_REF_TYPE:\n        return getWrappedName(type, type.render, 'ForwardRef');\n\n      case REACT_MEMO_TYPE:\n        const outerName = type.displayName || null;\n\n        if (outerName !== null) {\n          return outerName;\n        }\n\n        return getComponentNameFromType(type.type) || 'Memo';\n\n      case REACT_LAZY_TYPE:\n        {\n          const lazyComponent = type;\n          const payload = lazyComponent._payload;\n          const init = lazyComponent._init;\n\n          try {\n            return getComponentNameFromType(init(payload));\n          } catch (x) {\n            return null;\n          }\n        }\n\n      // eslint-disable-next-line no-fallthrough\n    }\n  }\n\n  return null;\n}\n\nfunction getWrappedName$1(outerType, innerType, wrapperName) {\n  const functionName = innerType.displayName || innerType.name || '';\n  return outerType.displayName || (functionName !== '' ? wrapperName + \"(\" + functionName + \")\" : wrapperName);\n} // Keep in sync with shared/getComponentNameFromType\n\n\nfunction getContextName$1(type) {\n  return type.displayName || 'Context';\n}\n\nfunction getComponentNameFromFiber(fiber) {\n  const tag = fiber.tag,\n        type = fiber.type;\n\n  switch (tag) {\n    case CacheComponent:\n      return 'Cache';\n\n    case ContextConsumer:\n      const context = type;\n      return getContextName$1(context) + '.Consumer';\n\n    case ContextProvider:\n      const provider = type;\n      return getContextName$1(provider._context) + '.Provider';\n\n    case DehydratedFragment:\n      return 'DehydratedFragment';\n\n    case ForwardRef:\n      return getWrappedName$1(type, type.render, 'ForwardRef');\n\n    case Fragment:\n      return 'Fragment';\n\n    case HostComponent:\n      // Host component type is the display name (e.g. \"div\", \"View\")\n      return type;\n\n    case HostPortal:\n      return 'Portal';\n\n    case HostRoot:\n      return 'Root';\n\n    case HostText:\n      return 'Text';\n\n    case LazyComponent:\n      // Name comes from the type in this case; we don't have a tag.\n      return getComponentNameFromType(type);\n\n    case Mode:\n      if (type === REACT_STRICT_MODE_TYPE) {\n        // Don't be less specific than shared/getComponentNameFromType\n        return 'StrictMode';\n      }\n\n      return 'Mode';\n\n    case OffscreenComponent:\n      return 'Offscreen';\n\n    case Profiler:\n      return 'Profiler';\n\n    case ScopeComponent:\n      return 'Scope';\n\n    case SuspenseComponent:\n      return 'Suspense';\n\n    case SuspenseListComponent:\n      return 'SuspenseList';\n\n    case TracingMarkerComponent:\n      return 'TracingMarker';\n    // The display name for this tags come from the user-provided type:\n\n    case ClassComponent:\n    case FunctionComponent:\n    case IncompleteClassComponent:\n    case IndeterminateComponent:\n    case MemoComponent:\n    case SimpleMemoComponent:\n      if (typeof type === 'function') {\n        return type.displayName || type.name || null;\n      }\n\n      if (typeof type === 'string') {\n        return type;\n      }\n\n      break;\n\n  }\n\n  return null;\n}\n\nconst ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;\n\nfunction resetCurrentFiber() {\n}\n\n// Flow does not allow string concatenation of most non-string types. To work\n// around this limitation, we use an opaque type that can only be obtained by\n// passing the value through getToStringValue first.\nfunction toString(value) {\n  // The coercion safety check is performed in getToStringValue().\n  // eslint-disable-next-line react-internal/safe-string-coercion\n  return '' + value;\n}\nfunction getToStringValue(value) {\n  switch (typeof value) {\n    case 'boolean':\n    case 'number':\n    case 'string':\n    case 'undefined':\n      return value;\n\n    case 'object':\n\n      return value;\n\n    default:\n      // function, symbol are assigned as empty strings\n      return '';\n  }\n}\n\nfunction isCheckable(elem) {\n  const type = elem.type;\n  const nodeName = elem.nodeName;\n  return nodeName && nodeName.toLowerCase() === 'input' && (type === 'checkbox' || type === 'radio');\n}\n\nfunction getTracker(node) {\n  return node._valueTracker;\n}\n\nfunction detachTracker(node) {\n  node._valueTracker = null;\n}\n\nfunction getValueFromNode(node) {\n  let value = '';\n\n  if (!node) {\n    return value;\n  }\n\n  if (isCheckable(node)) {\n    value = node.checked ? 'true' : 'false';\n  } else {\n    value = node.value;\n  }\n\n  return value;\n}\n\nfunction trackValueOnNode(node) {\n  const valueField = isCheckable(node) ? 'checked' : 'value';\n  const descriptor = Object.getOwnPropertyDescriptor(node.constructor.prototype, valueField);\n\n  let currentValue = '' + node[valueField]; // if someone has already defined a value or Safari, then bail\n  // and don't track value will cause over reporting of changes,\n  // but it's better then a hard failure\n  // (needed for certain tests that spyOn input values and Safari)\n\n  if (node.hasOwnProperty(valueField) || typeof descriptor === 'undefined' || typeof descriptor.get !== 'function' || typeof descriptor.set !== 'function') {\n    return;\n  }\n\n  const get = descriptor.get,\n        set = descriptor.set;\n  Object.defineProperty(node, valueField, {\n    configurable: true,\n    get: function () {\n      return get.call(this);\n    },\n    set: function (value) {\n\n      currentValue = '' + value;\n      set.call(this, value);\n    }\n  }); // We could've passed this the first time\n  // but it triggers a bug in IE11 and Edge 14/15.\n  // Calling defineProperty() again should be equivalent.\n  // https://github.com/facebook/react/issues/11768\n\n  Object.defineProperty(node, valueField, {\n    enumerable: descriptor.enumerable\n  });\n  const tracker = {\n    getValue() {\n      return currentValue;\n    },\n\n    setValue(value) {\n\n      currentValue = '' + value;\n    },\n\n    stopTracking() {\n      detachTracker(node);\n      delete node[valueField];\n    }\n\n  };\n  return tracker;\n}\n\nfunction track(node) {\n  if (getTracker(node)) {\n    return;\n  } // TODO: Once it's just Fiber we can move this to node._wrapperState\n\n\n  node._valueTracker = trackValueOnNode(node);\n}\nfunction updateValueIfChanged(node) {\n  if (!node) {\n    return false;\n  }\n\n  const tracker = getTracker(node); // if there is no tracker at this point it's unlikely\n  // that trying again will succeed\n\n  if (!tracker) {\n    return true;\n  }\n\n  const lastValue = tracker.getValue();\n  const nextValue = getValueFromNode(node);\n\n  if (nextValue !== lastValue) {\n    tracker.setValue(nextValue);\n    return true;\n  }\n\n  return false;\n}\n\nfunction getActiveElement(doc) {\n  doc = doc || (typeof document !== 'undefined' ? document : undefined);\n\n  if (typeof doc === 'undefined') {\n    return null;\n  }\n\n  try {\n    return doc.activeElement || doc.body;\n  } catch (e) {\n    return doc.body;\n  }\n}\n\nfunction isControlled(props) {\n  const usesChecked = props.type === 'checkbox' || props.type === 'radio';\n  return usesChecked ? props.checked != null : props.value != null;\n}\n/**\n * Implements an <input> host component that allows setting these optional\n * props: `checked`, `value`, `defaultChecked`, and `defaultValue`.\n *\n * If `checked` or `value` are not supplied (or null/undefined), user actions\n * that affect the checked state or value will trigger updates to the element.\n *\n * If they are supplied (and not null/undefined), the rendered element will not\n * trigger updates to the element. Instead, the props must change in order for\n * the rendered element to be updated.\n *\n * The rendered element will be initialized as unchecked (or `defaultChecked`)\n * with an empty value (or `defaultValue`).\n *\n * See http://www.w3.org/TR/2012/WD-html5-20121025/the-input-element.html\n */\n\n\nfunction getHostProps(element, props) {\n  const node = element;\n  const checked = props.checked;\n  const hostProps = assign({}, props, {\n    defaultChecked: undefined,\n    defaultValue: undefined,\n    value: undefined,\n    checked: checked != null ? checked : node._wrapperState.initialChecked\n  });\n  return hostProps;\n}\nfunction initWrapperState(element, props) {\n\n  const node = element;\n  const defaultValue = props.defaultValue == null ? '' : props.defaultValue;\n  node._wrapperState = {\n    initialChecked: props.checked != null ? props.checked : props.defaultChecked,\n    initialValue: getToStringValue(props.value != null ? props.value : defaultValue),\n    controlled: isControlled(props)\n  };\n}\nfunction updateChecked(element, props) {\n  const node = element;\n  const checked = props.checked;\n\n  if (checked != null) {\n    setValueForProperty(node, 'checked', checked, false);\n  }\n}\nfunction updateWrapper(element, props) {\n  const node = element;\n\n  updateChecked(element, props);\n  const value = getToStringValue(props.value);\n  const type = props.type;\n\n  if (value != null) {\n    if (type === 'number') {\n      if (value === 0 && node.value === '' || // We explicitly want to coerce to number here if possible.\n      // eslint-disable-next-line\n      node.value != value) {\n        node.value = toString(value);\n      }\n    } else if (node.value !== toString(value)) {\n      node.value = toString(value);\n    }\n  } else if (type === 'submit' || type === 'reset') {\n    // Submit/reset inputs need the attribute removed completely to avoid\n    // blank-text buttons.\n    node.removeAttribute('value');\n    return;\n  }\n\n  {\n    // When syncing the value attribute, the value comes from a cascade of\n    // properties:\n    //  1. The value React property\n    //  2. The defaultValue React property\n    //  3. Otherwise there should be no change\n    if (props.hasOwnProperty('value')) {\n      setDefaultValue(node, props.type, value);\n    } else if (props.hasOwnProperty('defaultValue')) {\n      setDefaultValue(node, props.type, getToStringValue(props.defaultValue));\n    }\n  }\n\n  {\n    // When syncing the checked attribute, it only changes when it needs\n    // to be removed, such as transitioning from a checkbox into a text input\n    if (props.checked == null && props.defaultChecked != null) {\n      node.defaultChecked = !!props.defaultChecked;\n    }\n  }\n}\nfunction postMountWrapper(element, props, isHydrating) {\n  const node = element; // Do not assign value if it is already set. This prevents user text input\n  // from being lost during SSR hydration.\n\n  if (props.hasOwnProperty('value') || props.hasOwnProperty('defaultValue')) {\n    const type = props.type;\n    const isButton = type === 'submit' || type === 'reset'; // Avoid setting value attribute on submit/reset inputs as it overrides the\n    // default value provided by the browser. See: #12872\n\n    if (isButton && (props.value === undefined || props.value === null)) {\n      return;\n    }\n\n    const initialValue = toString(node._wrapperState.initialValue); // Do not assign value if it is already set. This prevents user text input\n    // from being lost during SSR hydration.\n\n    if (!isHydrating) {\n      {\n        // When syncing the value attribute, the value property should use\n        // the wrapperState._initialValue property. This uses:\n        //\n        //   1. The value React property when present\n        //   2. The defaultValue React property when present\n        //   3. An empty string\n        if (initialValue !== node.value) {\n          node.value = initialValue;\n        }\n      }\n    }\n\n    {\n      // Otherwise, the value attribute is synchronized to the property,\n      // so we assign defaultValue to the same thing as the value property\n      // assignment step above.\n      node.defaultValue = initialValue;\n    }\n  } // Normally, we'd just do `node.checked = node.checked` upon initial mount, less this bug\n  // this is needed to work around a chrome bug where setting defaultChecked\n  // will sometimes influence the value of checked (even after detachment).\n  // Reference: https://bugs.chromium.org/p/chromium/issues/detail?id=608416\n  // We need to temporarily unset name to avoid disrupting radio button groups.\n\n\n  const name = node.name;\n\n  if (name !== '') {\n    node.name = '';\n  }\n\n  {\n    // When syncing the checked attribute, both the checked property and\n    // attribute are assigned at the same time using defaultChecked. This uses:\n    //\n    //   1. The checked React property when present\n    //   2. The defaultChecked React property when present\n    //   3. Otherwise, false\n    node.defaultChecked = !node.defaultChecked;\n    node.defaultChecked = !!node._wrapperState.initialChecked;\n  }\n\n  if (name !== '') {\n    node.name = name;\n  }\n}\nfunction restoreControlledState(element, props) {\n  const node = element;\n  updateWrapper(node, props);\n  updateNamedCousins(node, props);\n}\n\nfunction updateNamedCousins(rootNode, props) {\n  const name = props.name;\n\n  if (props.type === 'radio' && name != null) {\n    let queryRoot = rootNode;\n\n    while (queryRoot.parentNode) {\n      queryRoot = queryRoot.parentNode;\n    } // If `rootNode.form` was non-null, then we could try `form.elements`,\n\n    const group = queryRoot.querySelectorAll('input[name=' + JSON.stringify('' + name) + '][type=\"radio\"]');\n\n    for (let i = 0; i < group.length; i++) {\n      const otherNode = group[i];\n\n      if (otherNode === rootNode || otherNode.form !== rootNode.form) {\n        continue;\n      } // This will throw if radio buttons rendered by different copies of React\n      // and the same name are rendered into the same form (same as #1939).\n      // That's probably okay; we don't support it just as we don't support\n      // mixing React radio buttons with non-React ones.\n\n\n      const otherProps = getFiberCurrentPropsFromNode(otherNode);\n\n      if (!otherProps) {\n        throw Error(formatProdErrorMessage(90));\n      } // We need update the tracked value on the named cousin since the value\n      // was changed but the input saw no event or value set\n\n\n      updateValueIfChanged(otherNode); // If this is a controlled radio button group, forcing the input that\n      // was previously checked to update will cause it to be come re-checked\n      // as appropriate.\n\n      updateWrapper(otherNode, otherProps);\n    }\n  }\n} // In Chrome, assigning defaultValue to certain input types triggers input validation.\n// For number inputs, the display value loses trailing decimal points. For email inputs,\n// Chrome raises \"The specified value <x> is not a valid email address\".\n//\n// Here we check to see if the defaultValue has actually changed, avoiding these problems\n// when the user is inputting text\n//\n// https://github.com/facebook/react/issues/7253\n\n\nfunction setDefaultValue(node, type, value) {\n  if ( // Focused number inputs synchronize on blur. See ChangeEventPlugin.js\n  type !== 'number' || getActiveElement(node.ownerDocument) !== node) {\n    if (value == null) {\n      node.defaultValue = toString(node._wrapperState.initialValue);\n    } else if (node.defaultValue !== toString(value)) {\n      node.defaultValue = toString(value);\n    }\n  }\n}\n\nfunction postMountWrapper$1(element, props) {\n  // value=\"\" should make a value attribute (#6219)\n  if (props.value != null) {\n    element.setAttribute('value', toString(getToStringValue(props.value)));\n  }\n}\n\nconst isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare\n\nfunction isArray(a) {\n  return isArrayImpl(a);\n}\n\n// TODO: direct imports like some-package/src/* are bad. Fix me.\n\nfunction updateOptions(node, multiple, propValue, setDefaultSelected) {\n  const options = node.options;\n\n  if (multiple) {\n    const selectedValues = propValue;\n    const selectedValue = {};\n\n    for (let i = 0; i < selectedValues.length; i++) {\n      // Prefix to avoid chaos with special keys.\n      selectedValue['$' + selectedValues[i]] = true;\n    }\n\n    for (let i = 0; i < options.length; i++) {\n      const selected = selectedValue.hasOwnProperty('$' + options[i].value);\n\n      if (options[i].selected !== selected) {\n        options[i].selected = selected;\n      }\n\n      if (selected && setDefaultSelected) {\n        options[i].defaultSelected = true;\n      }\n    }\n  } else {\n    // Do not set `select.value` as exact behavior isn't consistent across all\n    // browsers for all cases.\n    const selectedValue = toString(getToStringValue(propValue));\n    let defaultSelected = null;\n\n    for (let i = 0; i < options.length; i++) {\n      if (options[i].value === selectedValue) {\n        options[i].selected = true;\n\n        if (setDefaultSelected) {\n          options[i].defaultSelected = true;\n        }\n\n        return;\n      }\n\n      if (defaultSelected === null && !options[i].disabled) {\n        defaultSelected = options[i];\n      }\n    }\n\n    if (defaultSelected !== null) {\n      defaultSelected.selected = true;\n    }\n  }\n}\n/**\n * Implements a <select> host component that allows optionally setting the\n * props `value` and `defaultValue`. If `multiple` is false, the prop must be a\n * stringable. If `multiple` is true, the prop must be an array of stringables.\n *\n * If `value` is not supplied (or null/undefined), user actions that change the\n * selected option will trigger updates to the rendered options.\n *\n * If it is supplied (and not null/undefined), the rendered options will not\n * update in response to user actions. Instead, the `value` prop must change in\n * order for the rendered options to update.\n *\n * If `defaultValue` is provided, any options with the supplied values will be\n * selected.\n */\n\n\nfunction getHostProps$1(element, props) {\n  return assign({}, props, {\n    value: undefined\n  });\n}\nfunction initWrapperState$1(element, props) {\n  const node = element;\n\n  node._wrapperState = {\n    wasMultiple: !!props.multiple\n  };\n}\nfunction postMountWrapper$2(element, props) {\n  const node = element;\n  node.multiple = !!props.multiple;\n  const value = props.value;\n\n  if (value != null) {\n    updateOptions(node, !!props.multiple, value, false);\n  } else if (props.defaultValue != null) {\n    updateOptions(node, !!props.multiple, props.defaultValue, true);\n  }\n}\nfunction postUpdateWrapper(element, props) {\n  const node = element;\n  const wasMultiple = node._wrapperState.wasMultiple;\n  node._wrapperState.wasMultiple = !!props.multiple;\n  const value = props.value;\n\n  if (value != null) {\n    updateOptions(node, !!props.multiple, value, false);\n  } else if (wasMultiple !== !!props.multiple) {\n    // For simplicity, reapply `defaultValue` if `multiple` is toggled.\n    if (props.defaultValue != null) {\n      updateOptions(node, !!props.multiple, props.defaultValue, true);\n    } else {\n      // Revert the select back to its default unselected state.\n      updateOptions(node, !!props.multiple, props.multiple ? [] : '', false);\n    }\n  }\n}\nfunction restoreControlledState$1(element, props) {\n  const node = element;\n  const value = props.value;\n\n  if (value != null) {\n    updateOptions(node, !!props.multiple, value, false);\n  }\n}\n\n/**\n * Implements a <textarea> host component that allows setting `value`, and\n * `defaultValue`. This differs from the traditional DOM API because value is\n * usually set as PCDATA children.\n *\n * If `value` is not supplied (or null/undefined), user actions that affect the\n * value will trigger updates to the element.\n *\n * If `value` is supplied (and not null/undefined), the rendered element will\n * not trigger updates to the element. Instead, the `value` prop must change in\n * order for the rendered element to be updated.\n *\n * The rendered element will be initialized with an empty value, the prop\n * `defaultValue` if specified, or the children content (deprecated).\n */\nfunction getHostProps$2(element, props) {\n  const node = element;\n\n  if (props.dangerouslySetInnerHTML != null) {\n    throw Error(formatProdErrorMessage(91));\n  } // Always set children to the same thing. In IE9, the selection range will\n  // get reset if `textContent` is mutated.  We could add a check in setTextContent\n  // to only set the value if/when the value differs from the node value (which would\n  // completely solve this IE9 bug), but Sebastian+Sophie seemed to like this\n  // solution. The value can be a boolean or object so that's why it's forced\n  // to be a string.\n\n\n  const hostProps = assign({}, props, {\n    value: undefined,\n    defaultValue: undefined,\n    children: toString(node._wrapperState.initialValue)\n  });\n\n  return hostProps;\n}\nfunction initWrapperState$2(element, props) {\n  const node = element;\n\n  let initialValue = props.value; // Only bother fetching default value if we're going to use it\n\n  if (initialValue == null) {\n    let children = props.children,\n        defaultValue = props.defaultValue;\n\n    if (children != null) {\n\n      {\n        if (defaultValue != null) {\n          throw Error(formatProdErrorMessage(92));\n        }\n\n        if (isArray(children)) {\n          if (children.length > 1) {\n            throw Error(formatProdErrorMessage(93));\n          }\n\n          children = children[0];\n        }\n\n        defaultValue = children;\n      }\n    }\n\n    if (defaultValue == null) {\n      defaultValue = '';\n    }\n\n    initialValue = defaultValue;\n  }\n\n  node._wrapperState = {\n    initialValue: getToStringValue(initialValue)\n  };\n}\nfunction updateWrapper$1(element, props) {\n  const node = element;\n  const value = getToStringValue(props.value);\n  const defaultValue = getToStringValue(props.defaultValue);\n\n  if (value != null) {\n    // Cast `value` to a string to ensure the value is set correctly. While\n    // browsers typically do this as necessary, jsdom doesn't.\n    const newValue = toString(value); // To avoid side effects (such as losing text selection), only set value if changed\n\n    if (newValue !== node.value) {\n      node.value = newValue;\n    }\n\n    if (props.defaultValue == null && node.defaultValue !== newValue) {\n      node.defaultValue = newValue;\n    }\n  }\n\n  if (defaultValue != null) {\n    node.defaultValue = toString(defaultValue);\n  }\n}\nfunction postMountWrapper$3(element, props) {\n  const node = element; // This is in postMount because we need access to the DOM node, which is not\n  // available until after the component has mounted.\n\n  const textContent = node.textContent; // Only set node.value if textContent is equal to the expected\n  // initial value. In IE10/IE11 there is a bug where the placeholder attribute\n  // will populate textContent as well.\n  // https://developer.microsoft.com/microsoft-edge/platform/issues/101525/\n\n  if (textContent === node._wrapperState.initialValue) {\n    if (textContent !== '' && textContent !== null) {\n      node.value = textContent;\n    }\n  }\n}\nfunction restoreControlledState$2(element, props) {\n  // DOM component is still mounted; update\n  updateWrapper$1(element, props);\n}\n\nconst HTML_NAMESPACE = 'http://www.w3.org/1999/xhtml';\nconst MATH_NAMESPACE = 'http://www.w3.org/1998/Math/MathML';\nconst SVG_NAMESPACE = 'http://www.w3.org/2000/svg'; // Assumes there is no parent namespace.\n\nfunction getIntrinsicNamespace(type) {\n  switch (type) {\n    case 'svg':\n      return SVG_NAMESPACE;\n\n    case 'math':\n      return MATH_NAMESPACE;\n\n    default:\n      return HTML_NAMESPACE;\n  }\n}\nfunction getChildNamespace(parentNamespace, type) {\n  if (parentNamespace == null || parentNamespace === HTML_NAMESPACE) {\n    // No (or default) parent namespace: potential entry point.\n    return getIntrinsicNamespace(type);\n  }\n\n  if (parentNamespace === SVG_NAMESPACE && type === 'foreignObject') {\n    // We're leaving SVG.\n    return HTML_NAMESPACE;\n  } // By default, pass namespace below.\n\n\n  return parentNamespace;\n}\n\n/* globals MSApp */\n\n/**\n * Create a function which has 'unsafe' privileges (required by windows8 apps)\n */\nconst createMicrosoftUnsafeLocalFunction = function (func) {\n  if (typeof MSApp !== 'undefined' && MSApp.execUnsafeLocalFunction) {\n    return function (arg0, arg1, arg2, arg3) {\n      MSApp.execUnsafeLocalFunction(function () {\n        return func(arg0, arg1, arg2, arg3);\n      });\n    };\n  } else {\n    return func;\n  }\n};\n\nlet reusableSVGContainer;\n/**\n * Set the innerHTML property of a node\n *\n * @param {DOMElement} node\n * @param {string} html\n * @internal\n */\n\nconst setInnerHTML = createMicrosoftUnsafeLocalFunction(function (node, html) {\n  if (node.namespaceURI === SVG_NAMESPACE) {\n\n    if (!('innerHTML' in node)) {\n      // IE does not have innerHTML for SVG nodes, so instead we inject the\n      // new markup in a temp node and then move the child nodes across into\n      // the target node\n      reusableSVGContainer = reusableSVGContainer || document.createElement('div');\n      reusableSVGContainer.innerHTML = '<svg>' + html.valueOf().toString() + '</svg>';\n      const svgNode = reusableSVGContainer.firstChild;\n\n      while (node.firstChild) {\n        node.removeChild(node.firstChild);\n      }\n\n      while (svgNode.firstChild) {\n        node.appendChild(svgNode.firstChild);\n      }\n\n      return;\n    }\n  }\n\n  node.innerHTML = html;\n});\n\n/**\n * HTML nodeType values that represent the type of the node\n */\nconst ELEMENT_NODE = 1;\nconst TEXT_NODE = 3;\nconst COMMENT_NODE = 8;\nconst DOCUMENT_NODE = 9;\nconst DOCUMENT_FRAGMENT_NODE = 11;\n\n/**\n * Set the textContent property of a node. For text updates, it's faster\n * to set the `nodeValue` of the Text node directly instead of using\n * `.textContent` which will remove the existing node and create a new one.\n *\n * @param {DOMElement} node\n * @param {string} text\n * @internal\n */\n\nconst setTextContent = function (node, text) {\n  if (text) {\n    const firstChild = node.firstChild;\n\n    if (firstChild && firstChild === node.lastChild && firstChild.nodeType === TEXT_NODE) {\n      firstChild.nodeValue = text;\n      return;\n    }\n  }\n\n  node.textContent = text;\n};\n\n/**\n * CSS properties which accept numbers but are not in units of \"px\".\n */\nconst isUnitlessNumber = {\n  animationIterationCount: true,\n  aspectRatio: true,\n  borderImageOutset: true,\n  borderImageSlice: true,\n  borderImageWidth: true,\n  boxFlex: true,\n  boxFlexGroup: true,\n  boxOrdinalGroup: true,\n  columnCount: true,\n  columns: true,\n  flex: true,\n  flexGrow: true,\n  flexPositive: true,\n  flexShrink: true,\n  flexNegative: true,\n  flexOrder: true,\n  gridArea: true,\n  gridRow: true,\n  gridRowEnd: true,\n  gridRowSpan: true,\n  gridRowStart: true,\n  gridColumn: true,\n  gridColumnEnd: true,\n  gridColumnSpan: true,\n  gridColumnStart: true,\n  fontWeight: true,\n  lineClamp: true,\n  lineHeight: true,\n  opacity: true,\n  order: true,\n  orphans: true,\n  tabSize: true,\n  widows: true,\n  zIndex: true,\n  zoom: true,\n  // SVG-related properties\n  fillOpacity: true,\n  floodOpacity: true,\n  stopOpacity: true,\n  strokeDasharray: true,\n  strokeDashoffset: true,\n  strokeMiterlimit: true,\n  strokeOpacity: true,\n  strokeWidth: true\n};\n/**\n * @param {string} prefix vendor-specific prefix, eg: Webkit\n * @param {string} key style name, eg: transitionDuration\n * @return {string} style name prefixed with `prefix`, properly camelCased, eg:\n * WebkitTransitionDuration\n */\n\nfunction prefixKey(prefix, key) {\n  return prefix + key.charAt(0).toUpperCase() + key.substring(1);\n}\n/**\n * Support style names that may come passed in prefixed by adding permutations\n * of vendor prefixes.\n */\n\n\nconst prefixes = ['Webkit', 'ms', 'Moz', 'O']; // Using Object.keys here, or else the vanilla for-in loop makes IE8 go into an\n// infinite loop, because it iterates over the newly added props too.\n\nObject.keys(isUnitlessNumber).forEach(function (prop) {\n  prefixes.forEach(function (prefix) {\n    isUnitlessNumber[prefixKey(prefix, prop)] = isUnitlessNumber[prop];\n  });\n});\n\n/**\n * Convert a value into the proper css writable value. The style name `name`\n * should be logical (no hyphens), as specified\n * in `CSSProperty.isUnitlessNumber`.\n *\n * @param {string} name CSS property name such as `topMargin`.\n * @param {*} value CSS property value such as `10px`.\n * @return {string} Normalized style value with dimensions applied.\n */\n\nfunction dangerousStyleValue(name, value, isCustomProperty) {\n  // Note that we've removed escapeTextForBrowser() calls here since the\n  // whole string will be escaped when the attribute is injected into\n  // the markup. If you provide unsafe user data here they can inject\n  // arbitrary CSS which may be problematic (I couldn't repro this):\n  // https://www.owasp.org/index.php/XSS_Filter_Evasion_Cheat_Sheet\n  // http://www.thespanner.co.uk/2007/11/26/ultimate-xss-css-injection/\n  // This is not an XSS hole but instead a potential CSS injection issue\n  // which has lead to a greater discussion about how we're going to\n  // trust URLs moving forward. See #2115901\n  const isEmpty = value == null || typeof value === 'boolean' || value === '';\n\n  if (isEmpty) {\n    return '';\n  }\n\n  if (!isCustomProperty && typeof value === 'number' && value !== 0 && !(isUnitlessNumber.hasOwnProperty(name) && isUnitlessNumber[name])) {\n    return value + 'px'; // Presumes implicit 'px' suffix for unitless numbers\n  }\n\n  return ('' + value).trim();\n}\n\n/**\n * Sets the value for multiple styles on a node.  If a value is specified as\n * '' (empty string), the corresponding style property will be unset.\n *\n * @param {DOMElement} node\n * @param {object} styles\n */\n\nfunction setValueForStyles(node, styles) {\n  const style = node.style;\n\n  for (let styleName in styles) {\n    if (!styles.hasOwnProperty(styleName)) {\n      continue;\n    }\n\n    const isCustomProperty = styleName.indexOf('--') === 0;\n\n    const styleValue = dangerousStyleValue(styleName, styles[styleName], isCustomProperty);\n\n    if (styleName === 'float') {\n      styleName = 'cssFloat';\n    }\n\n    if (isCustomProperty) {\n      style.setProperty(styleName, styleValue);\n    } else {\n      style[styleName] = styleValue;\n    }\n  }\n}\n\n// For HTML, certain tags should omit their close tag. We keep a list for\n// those special-case tags.\nconst omittedCloseTags = {\n  area: true,\n  base: true,\n  br: true,\n  col: true,\n  embed: true,\n  hr: true,\n  img: true,\n  input: true,\n  keygen: true,\n  link: true,\n  meta: true,\n  param: true,\n  source: true,\n  track: true,\n  wbr: true // NOTE: menuitem's close tag should be omitted, but that causes problems.\n\n};\n\n// `omittedCloseTags` except that `menuitem` should still have its closing tag.\n\nconst voidElementTags = assign({\n  menuitem: true\n}, omittedCloseTags);\n\nconst HTML = '__html';\n\nfunction assertValidProps(tag, props) {\n  if (!props) {\n    return;\n  } // Note the use of `==` which checks for null or undefined.\n\n\n  if (voidElementTags[tag]) {\n    if (props.children != null || props.dangerouslySetInnerHTML != null) {\n      throw Error(formatProdErrorMessage(137, tag));\n    }\n  }\n\n  if (props.dangerouslySetInnerHTML != null) {\n    if (props.children != null) {\n      throw Error(formatProdErrorMessage(60));\n    }\n\n    if (typeof props.dangerouslySetInnerHTML !== 'object' || !(HTML in props.dangerouslySetInnerHTML)) {\n      throw Error(formatProdErrorMessage(61));\n    }\n  }\n\n  if (props.style != null && typeof props.style !== 'object') {\n    throw Error(formatProdErrorMessage(62));\n  }\n}\n\nfunction isCustomComponent(tagName, props) {\n  if (tagName.indexOf('-') === -1) {\n    return typeof props.is === 'string';\n  }\n\n  switch (tagName) {\n    // These are reserved SVG and MathML elements.\n    // We don't mind this list too much because we expect it to never grow.\n    // The alternative is to track the namespace in a few places which is convoluted.\n    // https://w3c.github.io/webcomponents/spec/custom/#custom-elements-core-concepts\n    case 'annotation-xml':\n    case 'color-profile':\n    case 'font-face':\n    case 'font-face-src':\n    case 'font-face-uri':\n    case 'font-face-format':\n    case 'font-face-name':\n    case 'missing-glyph':\n      return false;\n\n    default:\n      return true;\n  }\n}\n\nconst IS_EVENT_HANDLE_NON_MANAGED_NODE = 1;\nconst IS_NON_DELEGATED = 1 << 1;\nconst IS_CAPTURE_PHASE = 1 << 2;\n// set to LEGACY_FB_SUPPORT. LEGACY_FB_SUPPORT only gets set when\n// we call willDeferLaterForLegacyFBSupport, thus not bailing out\n// will result in endless cycles like an infinite loop.\n// We also don't want to defer during event replaying.\n\nconst SHOULD_NOT_PROCESS_POLYFILL_EVENT_PLUGINS = IS_EVENT_HANDLE_NON_MANAGED_NODE | IS_NON_DELEGATED | IS_CAPTURE_PHASE;\n\n// This exists to avoid circular dependency between ReactDOMEventReplaying\n// and DOMPluginEventSystem.\nlet currentReplayingEvent = null;\nfunction setReplayingEvent(event) {\n\n  currentReplayingEvent = event;\n}\nfunction resetReplayingEvent() {\n\n  currentReplayingEvent = null;\n}\nfunction isReplayingEvent(event) {\n  return event === currentReplayingEvent;\n}\n\n/**\n * Gets the target node from a native browser event by accounting for\n * inconsistencies in browser DOM APIs.\n *\n * @param {object} nativeEvent Native browser event.\n * @return {DOMEventTarget} Target node.\n */\n\nfunction getEventTarget(nativeEvent) {\n  // Fallback to nativeEvent.srcElement for IE9\n  // https://github.com/facebook/react/issues/12506\n  let target = nativeEvent.target || nativeEvent.srcElement || window; // Normalize SVG <use> element events #4963\n\n  if (target.correspondingUseElement) {\n    target = target.correspondingUseElement;\n  } // Safari may fire events on text nodes (Node.TEXT_NODE is 3).\n  // @see http://www.quirksmode.org/js/events_properties.html\n\n\n  return target.nodeType === TEXT_NODE ? target.parentNode : target;\n}\n\nlet restoreImpl = null;\nlet restoreTarget = null;\nlet restoreQueue = null;\n\nfunction restoreStateOfTarget(target) {\n  // We perform this translation at the end of the event loop so that we\n  // always receive the correct fiber here\n  const internalInstance = getInstanceFromNode(target);\n\n  if (!internalInstance) {\n    // Unmounted\n    return;\n  }\n\n  if (typeof restoreImpl !== 'function') {\n    throw Error(formatProdErrorMessage(280));\n  }\n\n  const stateNode = internalInstance.stateNode; // Guard against Fiber being unmounted.\n\n  if (stateNode) {\n    const props = getFiberCurrentPropsFromNode(stateNode);\n    restoreImpl(internalInstance.stateNode, internalInstance.type, props);\n  }\n}\n\nfunction setRestoreImplementation(impl) {\n  restoreImpl = impl;\n}\nfunction enqueueStateRestore(target) {\n  if (restoreTarget) {\n    if (restoreQueue) {\n      restoreQueue.push(target);\n    } else {\n      restoreQueue = [target];\n    }\n  } else {\n    restoreTarget = target;\n  }\n}\nfunction needsStateRestore() {\n  return restoreTarget !== null || restoreQueue !== null;\n}\nfunction restoreStateIfNeeded() {\n  if (!restoreTarget) {\n    return;\n  }\n\n  const target = restoreTarget;\n  const queuedTargets = restoreQueue;\n  restoreTarget = null;\n  restoreQueue = null;\n  restoreStateOfTarget(target);\n\n  if (queuedTargets) {\n    for (let i = 0; i < queuedTargets.length; i++) {\n      restoreStateOfTarget(queuedTargets[i]);\n    }\n  }\n}\n\n// the renderer. Such as when we're dispatching events or if third party\n// libraries need to call batchedUpdates. Eventually, this API will go away when\n// everything is batched by default. We'll then have a similar API to opt-out of\n// scheduled work and instead do synchronous work.\n// Defaults\n\nlet batchedUpdatesImpl = function (fn, bookkeeping) {\n  return fn(bookkeeping);\n};\n\nlet flushSyncImpl = function () {};\n\nlet isInsideEventHandler = false;\n\nfunction finishEventHandler() {\n  // Here we wait until all updates have propagated, which is important\n  // when using controlled components within layers:\n  // https://github.com/facebook/react/issues/1698\n  // Then we restore state of any controlled component.\n  const controlledComponentsHavePendingUpdates = needsStateRestore();\n\n  if (controlledComponentsHavePendingUpdates) {\n    // If a controlled event was fired, we may need to restore the state of\n    // the DOM node back to the controlled value. This is necessary when React\n    // bails out of the update without touching the DOM.\n    // TODO: Restore state in the microtask, after the discrete updates flush,\n    // instead of early flushing them here.\n    flushSyncImpl();\n    restoreStateIfNeeded();\n  }\n}\n\nfunction batchedUpdates(fn, a, b) {\n  if (isInsideEventHandler) {\n    // If we are currently inside another batch, we need to wait until it\n    // fully completes before restoring state.\n    return fn(a, b);\n  }\n\n  isInsideEventHandler = true;\n\n  try {\n    return batchedUpdatesImpl(fn, a, b);\n  } finally {\n    isInsideEventHandler = false;\n    finishEventHandler();\n  }\n} // TODO: Replace with flushSync\nfunction setBatchingImplementation(_batchedUpdatesImpl, _discreteUpdatesImpl, _flushSyncImpl) {\n  batchedUpdatesImpl = _batchedUpdatesImpl;\n  flushSyncImpl = _flushSyncImpl;\n}\n\nfunction isInteractive(tag) {\n  return tag === 'button' || tag === 'input' || tag === 'select' || tag === 'textarea';\n}\n\nfunction shouldPreventMouseEvent(name, type, props) {\n  switch (name) {\n    case 'onClick':\n    case 'onClickCapture':\n    case 'onDoubleClick':\n    case 'onDoubleClickCapture':\n    case 'onMouseDown':\n    case 'onMouseDownCapture':\n    case 'onMouseMove':\n    case 'onMouseMoveCapture':\n    case 'onMouseUp':\n    case 'onMouseUpCapture':\n    case 'onMouseEnter':\n      return !!(props.disabled && isInteractive(type));\n\n    default:\n      return false;\n  }\n}\n/**\n * @param {object} inst The instance, which is the source of events.\n * @param {string} registrationName Name of listener (e.g. `onClick`).\n * @return {?function} The stored callback.\n */\n\n\nfunction getListener(inst, registrationName) {\n  const stateNode = inst.stateNode;\n\n  if (stateNode === null) {\n    // Work in progress (ex: onload events in incremental mode).\n    return null;\n  }\n\n  const props = getFiberCurrentPropsFromNode(stateNode);\n\n  if (props === null) {\n    // Work in progress.\n    return null;\n  }\n\n  const listener = props[registrationName];\n\n  if (shouldPreventMouseEvent(registrationName, inst.type, props)) {\n    return null;\n  }\n\n  if (listener && typeof listener !== 'function') {\n    throw Error(formatProdErrorMessage(231, registrationName, typeof listener));\n  }\n\n  return listener;\n}\n\nlet passiveBrowserEventsSupported = false; // Check if browser support events with passive listeners\n// https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#Safely_detecting_option_support\n\nif (canUseDOM) {\n  try {\n    const options = {}; // $FlowFixMe: Ignore Flow complaining about needing a value\n\n    Object.defineProperty(options, 'passive', {\n      get: function () {\n        passiveBrowserEventsSupported = true;\n      }\n    });\n    window.addEventListener('test', options, options);\n    window.removeEventListener('test', options, options);\n  } catch (e) {\n    passiveBrowserEventsSupported = false;\n  }\n}\n\nfunction invokeGuardedCallbackProd(name, func, context, a, b, c, d, e, f) {\n  const funcArgs = Array.prototype.slice.call(arguments, 3);\n\n  try {\n    func.apply(context, funcArgs);\n  } catch (error) {\n    this.onError(error);\n  }\n}\n\nlet invokeGuardedCallbackImpl = invokeGuardedCallbackProd;\n\nlet hasError = false;\nlet caughtError = null; // Used by event system to capture/rethrow the first error.\n\nlet hasRethrowError = false;\nlet rethrowError = null;\nconst reporter = {\n  onError(error) {\n    hasError = true;\n    caughtError = error;\n  }\n\n};\n/**\n * Call a function while guarding against errors that happens within it.\n * Returns an error if it throws, otherwise null.\n *\n * In production, this is implemented using a try-catch. The reason we don't\n * use a try-catch directly is so that we can swap out a different\n * implementation in DEV mode.\n *\n * @param {String} name of the guard to use for logging or debugging\n * @param {Function} func The function to invoke\n * @param {*} context The context to use when calling the function\n * @param {...*} args Arguments for function\n */\n\nfunction invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {\n  hasError = false;\n  caughtError = null;\n  invokeGuardedCallbackImpl.apply(reporter, arguments);\n}\n/**\n * Same as invokeGuardedCallback, but instead of returning an error, it stores\n * it in a global so it can be rethrown by `rethrowCaughtError` later.\n * TODO: See if caughtError and rethrowError can be unified.\n *\n * @param {String} name of the guard to use for logging or debugging\n * @param {Function} func The function to invoke\n * @param {*} context The context to use when calling the function\n * @param {...*} args Arguments for function\n */\n\nfunction invokeGuardedCallbackAndCatchFirstError(name, func, context, a, b, c, d, e, f) {\n  invokeGuardedCallback.apply(this, arguments);\n\n  if (hasError) {\n    const error = clearCaughtError();\n\n    if (!hasRethrowError) {\n      hasRethrowError = true;\n      rethrowError = error;\n    }\n  }\n}\n/**\n * During execution of guarded functions we will capture the first error which\n * we will rethrow to be handled by the top level error handler.\n */\n\nfunction rethrowCaughtError() {\n  if (hasRethrowError) {\n    const error = rethrowError;\n    hasRethrowError = false;\n    rethrowError = null;\n    throw error;\n  }\n}\nfunction clearCaughtError() {\n  if (hasError) {\n    const error = caughtError;\n    hasError = false;\n    caughtError = null;\n    return error;\n  } else {\n    throw Error(formatProdErrorMessage(198));\n  }\n}\n\n/**\n * `ReactInstanceMap` maintains a mapping from a public facing stateful\n * instance (key) and the internal representation (value). This allows public\n * methods to accept the user facing instance as an argument and map them back\n * to internal methods.\n *\n * Note that this module is currently shared and assumed to be stateless.\n * If this becomes an actual Map, that will break.\n */\nfunction get(key) {\n  return key._reactInternals;\n}\nfunction has(key) {\n  return key._reactInternals !== undefined;\n}\nfunction set(key, value) {\n  key._reactInternals = value;\n}\n\n// Don't change these two values. They're used by React Dev Tools.\nconst NoFlags =\n/*                      */\n0b00000000000000000000000000;\nconst PerformedWork =\n/*                */\n0b00000000000000000000000001; // You can change the rest (and add more).\n\nconst Placement =\n/*                    */\n0b00000000000000000000000010;\nconst Update =\n/*                       */\n0b00000000000000000000000100;\nconst ChildDeletion =\n/*                */\n0b00000000000000000000010000;\nconst ContentReset =\n/*                 */\n0b00000000000000000000100000;\nconst Callback =\n/*                     */\n0b00000000000000000001000000;\nconst DidCapture =\n/*                   */\n0b00000000000000000010000000;\nconst ForceClientRender =\n/*            */\n0b00000000000000000100000000;\nconst Ref =\n/*                          */\n0b00000000000000001000000000;\nconst Snapshot =\n/*                     */\n0b00000000000000010000000000;\nconst Passive =\n/*                      */\n0b00000000000000100000000000;\nconst Hydrating =\n/*                    */\n0b00000000000001000000000000;\nconst Visibility =\n/*                   */\n0b00000000000010000000000000;\nconst StoreConsistency =\n/*             */\n0b00000000000100000000000000;\nconst LifecycleEffectMask = Passive | Update | Callback | Ref | Snapshot | StoreConsistency; // Union of all commit flags (flags with the lifetime of a particular commit)\n\nconst HostEffectMask =\n/*               */\n0b00000000000111111111111111; // These are not really side effects, but we still reuse this field.\n\nconst Incomplete =\n/*                   */\n0b00000000001000000000000000;\nconst ShouldCapture =\n/*                */\n0b00000000010000000000000000;\nconst ForceUpdateForLegacySuspense =\n/* */\n0b00000000100000000000000000;\nconst Forked =\n/*                       */\n0b00000100000000000000000000; // Static tags describe aspects of a fiber that are not specific to a render,\n// e.g. a fiber uses a passive effect (even if there are no updates on this particular render).\n// This enables us to defer more work in the unmount case,\n// since we can defer traversing the tree during layout to look for Passive effects,\n// and instead rely on the static flag as a signal that there may be cleanup work.\n\nconst RefStatic =\n/*                    */\n0b00001000000000000000000000;\nconst LayoutStatic =\n/*                 */\n0b00010000000000000000000000;\nconst PassiveStatic =\n/*                */\n0b00100000000000000000000000; // These flags allow us to traverse to fibers that have effects on mount\n// don't contain effects, by checking subtreeFlags.\n\nconst BeforeMutationMask = // TODO: Remove Update flag from before mutation phase by re-landing Visibility\n// flag logic (see #20043)\nUpdate | Snapshot | ( 0);\nconst MutationMask = Placement | Update | ChildDeletion | ContentReset | Ref | Hydrating | Visibility;\nconst LayoutMask = Update | Callback | Ref | Visibility; // TODO: Split into PassiveMountMask and PassiveUnmountMask\n\nconst PassiveMask = Passive | ChildDeletion; // Union of tags that don't get reset on clones.\n// This allows certain concepts to persist without recalculating them,\n// e.g. whether a subtree contains passive effects or portals.\n\nconst StaticMask = LayoutStatic | PassiveStatic | RefStatic;\n\nconst ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner;\nfunction getNearestMountedFiber(fiber) {\n  let node = fiber;\n  let nearestMounted = fiber;\n\n  if (!fiber.alternate) {\n    // If there is no alternate, this might be a new tree that isn't inserted\n    // yet. If it is, then it will have a pending insertion effect on it.\n    let nextNode = node;\n\n    do {\n      node = nextNode;\n\n      if ((node.flags & (Placement | Hydrating)) !== NoFlags) {\n        // This is an insertion or in-progress hydration. The nearest possible\n        // mounted fiber is the parent but we need to continue to figure out\n        // if that one is still mounted.\n        nearestMounted = node.return;\n      }\n\n      nextNode = node.return;\n    } while (nextNode);\n  } else {\n    while (node.return) {\n      node = node.return;\n    }\n  }\n\n  if (node.tag === HostRoot) {\n    // TODO: Check if this was a nested HostRoot when used with\n    // renderContainerIntoSubtree.\n    return nearestMounted;\n  } // If we didn't hit the root, that means that we're in an disconnected tree\n  // that has been unmounted.\n\n\n  return null;\n}\nfunction getSuspenseInstanceFromFiber(fiber) {\n  if (fiber.tag === SuspenseComponent) {\n    let suspenseState = fiber.memoizedState;\n\n    if (suspenseState === null) {\n      const current = fiber.alternate;\n\n      if (current !== null) {\n        suspenseState = current.memoizedState;\n      }\n    }\n\n    if (suspenseState !== null) {\n      return suspenseState.dehydrated;\n    }\n  }\n\n  return null;\n}\nfunction getContainerFromFiber(fiber) {\n  return fiber.tag === HostRoot ? fiber.stateNode.containerInfo : null;\n}\nfunction isFiberMounted(fiber) {\n  return getNearestMountedFiber(fiber) === fiber;\n}\nfunction isMounted(component) {\n\n  const fiber = get(component);\n\n  if (!fiber) {\n    return false;\n  }\n\n  return getNearestMountedFiber(fiber) === fiber;\n}\n\nfunction assertIsMounted(fiber) {\n  if (getNearestMountedFiber(fiber) !== fiber) {\n    throw Error(formatProdErrorMessage(188));\n  }\n}\n\nfunction findCurrentFiberUsingSlowPath(fiber) {\n  const alternate = fiber.alternate;\n\n  if (!alternate) {\n    // If there is no alternate, then we only need to check if it is mounted.\n    const nearestMounted = getNearestMountedFiber(fiber);\n\n    if (nearestMounted === null) {\n      throw Error(formatProdErrorMessage(188));\n    }\n\n    if (nearestMounted !== fiber) {\n      return null;\n    }\n\n    return fiber;\n  } // If we have two possible branches, we'll walk backwards up to the root\n  // to see what path the root points to. On the way we may hit one of the\n  // special cases and we'll deal with them.\n\n\n  let a = fiber;\n  let b = alternate;\n\n  while (true) {\n    const parentA = a.return;\n\n    if (parentA === null) {\n      // We're at the root.\n      break;\n    }\n\n    const parentB = parentA.alternate;\n\n    if (parentB === null) {\n      // There is no alternate. This is an unusual case. Currently, it only\n      // happens when a Suspense component is hidden. An extra fragment fiber\n      // is inserted in between the Suspense fiber and its children. Skip\n      // over this extra fragment fiber and proceed to the next parent.\n      const nextParent = parentA.return;\n\n      if (nextParent !== null) {\n        a = b = nextParent;\n        continue;\n      } // If there's no parent, we're at the root.\n\n\n      break;\n    } // If both copies of the parent fiber point to the same child, we can\n    // assume that the child is current. This happens when we bailout on low\n    // priority: the bailed out fiber's child reuses the current child.\n\n\n    if (parentA.child === parentB.child) {\n      let child = parentA.child;\n\n      while (child) {\n        if (child === a) {\n          // We've determined that A is the current branch.\n          assertIsMounted(parentA);\n          return fiber;\n        }\n\n        if (child === b) {\n          // We've determined that B is the current branch.\n          assertIsMounted(parentA);\n          return alternate;\n        }\n\n        child = child.sibling;\n      } // We should never have an alternate for any mounting node. So the only\n      // way this could possibly happen is if this was unmounted, if at all.\n\n\n      throw Error(formatProdErrorMessage(188));\n    }\n\n    if (a.return !== b.return) {\n      // The return pointer of A and the return pointer of B point to different\n      // fibers. We assume that return pointers never criss-cross, so A must\n      // belong to the child set of A.return, and B must belong to the child\n      // set of B.return.\n      a = parentA;\n      b = parentB;\n    } else {\n      // The return pointers point to the same fiber. We'll have to use the\n      // default, slow path: scan the child sets of each parent alternate to see\n      // which child belongs to which set.\n      //\n      // Search parent A's child set\n      let didFindChild = false;\n      let child = parentA.child;\n\n      while (child) {\n        if (child === a) {\n          didFindChild = true;\n          a = parentA;\n          b = parentB;\n          break;\n        }\n\n        if (child === b) {\n          didFindChild = true;\n          b = parentA;\n          a = parentB;\n          break;\n        }\n\n        child = child.sibling;\n      }\n\n      if (!didFindChild) {\n        // Search parent B's child set\n        child = parentB.child;\n\n        while (child) {\n          if (child === a) {\n            didFindChild = true;\n            a = parentB;\n            b = parentA;\n            break;\n          }\n\n          if (child === b) {\n            didFindChild = true;\n            b = parentB;\n            a = parentA;\n            break;\n          }\n\n          child = child.sibling;\n        }\n\n        if (!didFindChild) {\n          throw Error(formatProdErrorMessage(189));\n        }\n      }\n    }\n\n    if (a.alternate !== b) {\n      throw Error(formatProdErrorMessage(190));\n    }\n  } // If the root is not a host container, we're in a disconnected tree. I.e.\n  // unmounted.\n\n\n  if (a.tag !== HostRoot) {\n    throw Error(formatProdErrorMessage(188));\n  }\n\n  if (a.stateNode.current === a) {\n    // We've determined that A is the current branch.\n    return fiber;\n  } // Otherwise B has to be current branch.\n\n\n  return alternate;\n}\nfunction findCurrentHostFiber(parent) {\n  const currentParent = findCurrentFiberUsingSlowPath(parent);\n  return currentParent !== null ? findCurrentHostFiberImpl(currentParent) : null;\n}\n\nfunction findCurrentHostFiberImpl(node) {\n  // Next we'll drill down this component to find the first HostComponent/Text.\n  if (node.tag === HostComponent || node.tag === HostText) {\n    return node;\n  }\n\n  let child = node.child;\n\n  while (child !== null) {\n    const match = findCurrentHostFiberImpl(child);\n\n    if (match !== null) {\n      return match;\n    }\n\n    child = child.sibling;\n  }\n\n  return null;\n}\n\n// This module only exists as an ESM wrapper around the external CommonJS\nconst scheduleCallback = Scheduler.unstable_scheduleCallback;\nconst cancelCallback = Scheduler.unstable_cancelCallback;\nconst shouldYield = Scheduler.unstable_shouldYield;\nconst requestPaint = Scheduler.unstable_requestPaint;\nconst now = Scheduler.unstable_now;\nconst getCurrentPriorityLevel = Scheduler.unstable_getCurrentPriorityLevel;\nconst ImmediatePriority = Scheduler.unstable_ImmediatePriority;\nconst UserBlockingPriority = Scheduler.unstable_UserBlockingPriority;\nconst NormalPriority = Scheduler.unstable_NormalPriority;\nconst LowPriority = Scheduler.unstable_LowPriority;\nconst IdlePriority = Scheduler.unstable_IdlePriority;\n\nlet rendererID = null;\nlet injectedHook = null;\nfunction injectInternals(internals) {\n  if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === 'undefined') {\n    // No DevTools\n    return false;\n  }\n\n  const hook = __REACT_DEVTOOLS_GLOBAL_HOOK__;\n\n  if (hook.isDisabled) {\n    // This isn't a real property on the hook, but it can be set to opt out\n    // of DevTools integration and associated warnings and logs.\n    // https://github.com/facebook/react/issues/3877\n    return true;\n  }\n\n  if (!hook.supportsFiber) {\n\n\n    return true;\n  }\n\n  try {\n    if (enableSchedulingProfiler) {\n      // Conditionally inject these hooks only if Timeline profiler is supported by this build.\n      // This gives DevTools a way to feature detect that isn't tied to version number\n      // (since profiling and timeline are controlled by different feature flags).\n      internals = assign({}, internals, {\n        getLaneLabelMap,\n        injectProfilingHooks\n      });\n    }\n\n    rendererID = hook.inject(internals); // We have successfully injected, so now it is safe to set up hooks.\n\n    injectedHook = hook;\n  } catch (err) {\n  }\n\n  if (hook.checkDCE) {\n    // This is the real DevTools.\n    return true;\n  } else {\n    // This is likely a hook installed by Fast Refresh runtime.\n    return false;\n  }\n}\nfunction onCommitRoot(root, eventPriority) {\n  if (injectedHook && typeof injectedHook.onCommitFiberRoot === 'function') {\n    try {\n      const didError = (root.current.flags & DidCapture) === DidCapture;\n\n      if (enableProfilerTimer) {\n        let schedulerPriority;\n\n        switch (eventPriority) {\n          case DiscreteEventPriority:\n            schedulerPriority = ImmediatePriority;\n            break;\n\n          case ContinuousEventPriority:\n            schedulerPriority = UserBlockingPriority;\n            break;\n\n          case DefaultEventPriority:\n            schedulerPriority = NormalPriority;\n            break;\n\n          case IdleEventPriority:\n            schedulerPriority = IdlePriority;\n            break;\n\n          default:\n            schedulerPriority = NormalPriority;\n            break;\n        }\n\n        injectedHook.onCommitFiberRoot(rendererID, root, schedulerPriority, didError);\n      } else {\n        injectedHook.onCommitFiberRoot(rendererID, root, undefined, didError);\n      }\n    } catch (err) {\n    }\n  }\n}\nfunction onPostCommitRoot(root) {\n  if (injectedHook && typeof injectedHook.onPostCommitFiberRoot === 'function') {\n    try {\n      injectedHook.onPostCommitFiberRoot(rendererID, root);\n    } catch (err) {\n    }\n  }\n}\nfunction onCommitUnmount(fiber) {\n  if (injectedHook && typeof injectedHook.onCommitFiberUnmount === 'function') {\n    try {\n      injectedHook.onCommitFiberUnmount(rendererID, fiber);\n    } catch (err) {\n    }\n  }\n}\n\nfunction injectProfilingHooks(profilingHooks) {\n}\n\nfunction getLaneLabelMap() {\n  {\n    return null;\n  }\n}\nfunction markComponentRenderStopped() {\n}\nfunction markComponentErrored(fiber, thrownValue, lanes) {\n}\nfunction markComponentSuspended(fiber, wakeable, lanes) {\n}\n\nconst NoMode =\n/*                         */\n0b000000; // TODO: Remove ConcurrentMode by reading from the root tag instead\n\nconst ConcurrentMode =\n/*                 */\n0b000001;\nconst ProfileMode =\n/*                    */\n0b000010;\nconst StrictLegacyMode =\n/*               */\n0b001000;\n\n// TODO: This is pretty well supported by browsers. Maybe we can drop it.\nconst clz32 = Math.clz32 ? Math.clz32 : clz32Fallback; // Count leading zeros.\n// Based on:\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/clz32\n\nconst log = Math.log;\nconst LN2 = Math.LN2;\n\nfunction clz32Fallback(x) {\n  const asUint = x >>> 0;\n\n  if (asUint === 0) {\n    return 32;\n  }\n\n  return 31 - (log(asUint) / LN2 | 0) | 0;\n}\n\n// TODO: Ideally these types would be opaque but that doesn't work well with\n// If those values are changed that package should be rebuilt and redeployed.\n\nconst TotalLanes = 31;\nconst NoLanes =\n/*                        */\n0b0000000000000000000000000000000;\nconst NoLane =\n/*                          */\n0b0000000000000000000000000000000;\nconst SyncLane =\n/*                        */\n0b0000000000000000000000000000001;\nconst InputContinuousHydrationLane =\n/*    */\n0b0000000000000000000000000000010;\nconst InputContinuousLane =\n/*             */\n0b0000000000000000000000000000100;\nconst DefaultHydrationLane =\n/*            */\n0b0000000000000000000000000001000;\nconst DefaultLane =\n/*                     */\n0b0000000000000000000000000010000;\nconst TransitionHydrationLane =\n/*                */\n0b0000000000000000000000000100000;\nconst TransitionLanes =\n/*                       */\n0b0000000001111111111111111000000;\nconst TransitionLane1 =\n/*                        */\n0b0000000000000000000000001000000;\nconst TransitionLane2 =\n/*                        */\n0b0000000000000000000000010000000;\nconst TransitionLane3 =\n/*                        */\n0b0000000000000000000000100000000;\nconst TransitionLane4 =\n/*                        */\n0b0000000000000000000001000000000;\nconst TransitionLane5 =\n/*                        */\n0b0000000000000000000010000000000;\nconst TransitionLane6 =\n/*                        */\n0b0000000000000000000100000000000;\nconst TransitionLane7 =\n/*                        */\n0b0000000000000000001000000000000;\nconst TransitionLane8 =\n/*                        */\n0b0000000000000000010000000000000;\nconst TransitionLane9 =\n/*                        */\n0b0000000000000000100000000000000;\nconst TransitionLane10 =\n/*                       */\n0b0000000000000001000000000000000;\nconst TransitionLane11 =\n/*                       */\n0b0000000000000010000000000000000;\nconst TransitionLane12 =\n/*                       */\n0b0000000000000100000000000000000;\nconst TransitionLane13 =\n/*                       */\n0b0000000000001000000000000000000;\nconst TransitionLane14 =\n/*                       */\n0b0000000000010000000000000000000;\nconst TransitionLane15 =\n/*                       */\n0b0000000000100000000000000000000;\nconst TransitionLane16 =\n/*                       */\n0b0000000001000000000000000000000;\nconst RetryLanes =\n/*                            */\n0b0000111110000000000000000000000;\nconst RetryLane1 =\n/*                             */\n0b0000000010000000000000000000000;\nconst RetryLane2 =\n/*                             */\n0b0000000100000000000000000000000;\nconst RetryLane3 =\n/*                             */\n0b0000001000000000000000000000000;\nconst RetryLane4 =\n/*                             */\n0b0000010000000000000000000000000;\nconst RetryLane5 =\n/*                             */\n0b0000100000000000000000000000000;\nconst SomeRetryLane = RetryLane1;\nconst SelectiveHydrationLane =\n/*          */\n0b0001000000000000000000000000000;\nconst NonIdleLanes =\n/*                          */\n0b0001111111111111111111111111111;\nconst IdleHydrationLane =\n/*               */\n0b0010000000000000000000000000000;\nconst IdleLane =\n/*                        */\n0b0100000000000000000000000000000;\nconst OffscreenLane =\n/*                   */\n0b1000000000000000000000000000000; // This function is used for the experimental timeline (react-devtools-timeline)\nconst NoTimestamp = -1;\nlet nextTransitionLane = TransitionLane1;\nlet nextRetryLane = RetryLane1;\n\nfunction getHighestPriorityLanes(lanes) {\n  switch (getHighestPriorityLane(lanes)) {\n    case SyncLane:\n      return SyncLane;\n\n    case InputContinuousHydrationLane:\n      return InputContinuousHydrationLane;\n\n    case InputContinuousLane:\n      return InputContinuousLane;\n\n    case DefaultHydrationLane:\n      return DefaultHydrationLane;\n\n    case DefaultLane:\n      return DefaultLane;\n\n    case TransitionHydrationLane:\n      return TransitionHydrationLane;\n\n    case TransitionLane1:\n    case TransitionLane2:\n    case TransitionLane3:\n    case TransitionLane4:\n    case TransitionLane5:\n    case TransitionLane6:\n    case TransitionLane7:\n    case TransitionLane8:\n    case TransitionLane9:\n    case TransitionLane10:\n    case TransitionLane11:\n    case TransitionLane12:\n    case TransitionLane13:\n    case TransitionLane14:\n    case TransitionLane15:\n    case TransitionLane16:\n      return lanes & TransitionLanes;\n\n    case RetryLane1:\n    case RetryLane2:\n    case RetryLane3:\n    case RetryLane4:\n    case RetryLane5:\n      return lanes & RetryLanes;\n\n    case SelectiveHydrationLane:\n      return SelectiveHydrationLane;\n\n    case IdleHydrationLane:\n      return IdleHydrationLane;\n\n    case IdleLane:\n      return IdleLane;\n\n    case OffscreenLane:\n      return OffscreenLane;\n\n    default:\n\n\n      return lanes;\n  }\n}\n\nfunction getNextLanes(root, wipLanes) {\n  // Early bailout if there's no pending work left.\n  const pendingLanes = root.pendingLanes;\n\n  if (pendingLanes === NoLanes) {\n    return NoLanes;\n  }\n\n  let nextLanes = NoLanes;\n  const suspendedLanes = root.suspendedLanes;\n  const pingedLanes = root.pingedLanes; // Do not work on any idle work until all the non-idle work has finished,\n  // even if the work is suspended.\n\n  const nonIdlePendingLanes = pendingLanes & NonIdleLanes;\n\n  if (nonIdlePendingLanes !== NoLanes) {\n    const nonIdleUnblockedLanes = nonIdlePendingLanes & ~suspendedLanes;\n\n    if (nonIdleUnblockedLanes !== NoLanes) {\n      nextLanes = getHighestPriorityLanes(nonIdleUnblockedLanes);\n    } else {\n      const nonIdlePingedLanes = nonIdlePendingLanes & pingedLanes;\n\n      if (nonIdlePingedLanes !== NoLanes) {\n        nextLanes = getHighestPriorityLanes(nonIdlePingedLanes);\n      }\n    }\n  } else {\n    // The only remaining work is Idle.\n    const unblockedLanes = pendingLanes & ~suspendedLanes;\n\n    if (unblockedLanes !== NoLanes) {\n      nextLanes = getHighestPriorityLanes(unblockedLanes);\n    } else {\n      if (pingedLanes !== NoLanes) {\n        nextLanes = getHighestPriorityLanes(pingedLanes);\n      }\n    }\n  }\n\n  if (nextLanes === NoLanes) {\n    // This should only be reachable if we're suspended\n    // TODO: Consider warning in this path if a fallback timer is not scheduled.\n    return NoLanes;\n  } // If we're already in the middle of a render, switching lanes will interrupt\n  // it and we'll lose our progress. We should only do this if the new lanes are\n  // higher priority.\n\n\n  if (wipLanes !== NoLanes && wipLanes !== nextLanes && // If we already suspended with a delay, then interrupting is fine. Don't\n  // bother waiting until the root is complete.\n  (wipLanes & suspendedLanes) === NoLanes) {\n    const nextLane = getHighestPriorityLane(nextLanes);\n    const wipLane = getHighestPriorityLane(wipLanes);\n\n    if ( // Tests whether the next lane is equal or lower priority than the wip\n    // one. This works because the bits decrease in priority as you go left.\n    nextLane >= wipLane || // Default priority updates should not interrupt transition updates. The\n    // only difference between default updates and transition updates is that\n    // default updates do not support refresh transitions.\n    nextLane === DefaultLane && (wipLane & TransitionLanes) !== NoLanes) {\n      // Keep working on the existing in-progress tree. Do not interrupt.\n      return wipLanes;\n    }\n  }\n\n  if ((nextLanes & InputContinuousLane) !== NoLanes) {\n    // When updates are sync by default, we entangle continuous priority updates\n    // and default updates, so they render in the same batch. The only reason\n    // they use separate lanes is because continuous updates should interrupt\n    // transitions, but default updates should not.\n    nextLanes |= pendingLanes & DefaultLane;\n  } // Check for entangled lanes and add them to the batch.\n  //\n  // A lane is said to be entangled with another when it's not allowed to render\n  // in a batch that does not also include the other lane. Typically we do this\n  // when multiple updates have the same source, and we only want to respond to\n  // the most recent event from that source.\n  //\n  // Note that we apply entanglements *after* checking for partial work above.\n  // This means that if a lane is entangled during an interleaved event while\n  // it's already rendering, we won't interrupt it. This is intentional, since\n  // entanglement is usually \"best effort\": we'll try our best to render the\n  // lanes in the same batch, but it's not worth throwing out partially\n  // completed work in order to do it.\n  // TODO: Reconsider this. The counter-argument is that the partial work\n  // represents an intermediate state, which we don't want to show to the user.\n  // And by spending extra time finishing it, we're increasing the amount of\n  // time it takes to show the final state, which is what they are actually\n  // waiting for.\n  //\n  // For those exceptions where entanglement is semantically important, like\n  // useMutableSource, we should ensure that there is no partial work at the\n  // time we apply the entanglement.\n\n\n  const entangledLanes = root.entangledLanes;\n\n  if (entangledLanes !== NoLanes) {\n    const entanglements = root.entanglements;\n    let lanes = nextLanes & entangledLanes;\n\n    while (lanes > 0) {\n      const index = pickArbitraryLaneIndex(lanes);\n      const lane = 1 << index;\n      nextLanes |= entanglements[index];\n      lanes &= ~lane;\n    }\n  }\n\n  return nextLanes;\n}\nfunction getMostRecentEventTime(root, lanes) {\n  const eventTimes = root.eventTimes;\n  let mostRecentEventTime = NoTimestamp;\n\n  while (lanes > 0) {\n    const index = pickArbitraryLaneIndex(lanes);\n    const lane = 1 << index;\n    const eventTime = eventTimes[index];\n\n    if (eventTime > mostRecentEventTime) {\n      mostRecentEventTime = eventTime;\n    }\n\n    lanes &= ~lane;\n  }\n\n  return mostRecentEventTime;\n}\n\nfunction computeExpirationTime(lane, currentTime) {\n  switch (lane) {\n    case SyncLane:\n    case InputContinuousHydrationLane:\n    case InputContinuousLane:\n      // User interactions should expire slightly more quickly.\n      //\n      // NOTE: This is set to the corresponding constant as in Scheduler.js.\n      // When we made it larger, a product metric in www regressed, suggesting\n      // there's a user interaction that's being starved by a series of\n      // synchronous updates. If that theory is correct, the proper solution is\n      // to fix the starvation. However, this scenario supports the idea that\n      // expiration times are an important safeguard when starvation\n      // does happen.\n      return currentTime + 250;\n\n    case DefaultHydrationLane:\n    case DefaultLane:\n    case TransitionHydrationLane:\n    case TransitionLane1:\n    case TransitionLane2:\n    case TransitionLane3:\n    case TransitionLane4:\n    case TransitionLane5:\n    case TransitionLane6:\n    case TransitionLane7:\n    case TransitionLane8:\n    case TransitionLane9:\n    case TransitionLane10:\n    case TransitionLane11:\n    case TransitionLane12:\n    case TransitionLane13:\n    case TransitionLane14:\n    case TransitionLane15:\n    case TransitionLane16:\n      return currentTime + 5000;\n\n    case RetryLane1:\n    case RetryLane2:\n    case RetryLane3:\n    case RetryLane4:\n    case RetryLane5:\n      // TODO: Retries should be allowed to expire if they are CPU bound for\n      // too long, but when I made this change it caused a spike in browser\n      // crashes. There must be some other underlying bug; not super urgent but\n      // ideally should figure out why and fix it. Unfortunately we don't have\n      // a repro for the crashes, only detected via production metrics.\n      return NoTimestamp;\n\n    case SelectiveHydrationLane:\n    case IdleHydrationLane:\n    case IdleLane:\n    case OffscreenLane:\n      // Anything idle priority or lower should never expire.\n      return NoTimestamp;\n\n    default:\n\n      return NoTimestamp;\n  }\n}\n\nfunction markStarvedLanesAsExpired(root, currentTime) {\n  // TODO: This gets called every time we yield. We can optimize by storing\n  // the earliest expiration time on the root. Then use that to quickly bail out\n  // of this function.\n  const pendingLanes = root.pendingLanes;\n  const suspendedLanes = root.suspendedLanes;\n  const pingedLanes = root.pingedLanes;\n  const expirationTimes = root.expirationTimes; // Iterate through the pending lanes and check if we've reached their\n  // expiration time. If so, we'll assume the update is being starved and mark\n  // it as expired to force it to finish.\n\n  let lanes = pendingLanes;\n\n  while (lanes > 0) {\n    const index = pickArbitraryLaneIndex(lanes);\n    const lane = 1 << index;\n    const expirationTime = expirationTimes[index];\n\n    if (expirationTime === NoTimestamp) {\n      // Found a pending lane with no expiration time. If it's not suspended, or\n      // if it's pinged, assume it's CPU-bound. Compute a new expiration time\n      // using the current time.\n      if ((lane & suspendedLanes) === NoLanes || (lane & pingedLanes) !== NoLanes) {\n        // Assumes timestamps are monotonically increasing.\n        expirationTimes[index] = computeExpirationTime(lane, currentTime);\n      }\n    } else if (expirationTime <= currentTime) {\n      // This lane expired\n      root.expiredLanes |= lane;\n    }\n\n    lanes &= ~lane;\n  }\n} // This returns the highest priority pending lanes regardless of whether they\n// are suspended.\n\nfunction getHighestPriorityPendingLanes(root) {\n  return getHighestPriorityLanes(root.pendingLanes);\n}\nfunction getLanesToRetrySynchronouslyOnError(root) {\n  const everythingButOffscreen = root.pendingLanes & ~OffscreenLane;\n\n  if (everythingButOffscreen !== NoLanes) {\n    return everythingButOffscreen;\n  }\n\n  if (everythingButOffscreen & OffscreenLane) {\n    return OffscreenLane;\n  }\n\n  return NoLanes;\n}\nfunction includesSyncLane(lanes) {\n  return (lanes & SyncLane) !== NoLanes;\n}\nfunction includesNonIdleWork(lanes) {\n  return (lanes & NonIdleLanes) !== NoLanes;\n}\nfunction includesOnlyRetries(lanes) {\n  return (lanes & RetryLanes) === lanes;\n}\nfunction includesOnlyNonUrgentLanes(lanes) {\n  const UrgentLanes = SyncLane | InputContinuousLane | DefaultLane;\n  return (lanes & UrgentLanes) === NoLanes;\n}\nfunction includesOnlyTransitions(lanes) {\n  return (lanes & TransitionLanes) === lanes;\n}\nfunction includesBlockingLane(root, lanes) {\n\n  const SyncDefaultLanes = InputContinuousHydrationLane | InputContinuousLane | DefaultHydrationLane | DefaultLane;\n  return (lanes & SyncDefaultLanes) !== NoLanes;\n}\nfunction includesExpiredLane(root, lanes) {\n  // This is a separate check from includesBlockingLane because a lane can\n  // expire after a render has already started.\n  return (lanes & root.expiredLanes) !== NoLanes;\n}\nfunction isTransitionLane(lane) {\n  return (lane & TransitionLanes) !== NoLanes;\n}\nfunction claimNextTransitionLane() {\n  // Cycle through the lanes, assigning each new transition to the next lane.\n  // In most cases, this means every transition gets its own lane, until we\n  // run out of lanes and cycle back to the beginning.\n  const lane = nextTransitionLane;\n  nextTransitionLane <<= 1;\n\n  if ((nextTransitionLane & TransitionLanes) === NoLanes) {\n    nextTransitionLane = TransitionLane1;\n  }\n\n  return lane;\n}\nfunction claimNextRetryLane() {\n  const lane = nextRetryLane;\n  nextRetryLane <<= 1;\n\n  if ((nextRetryLane & RetryLanes) === NoLanes) {\n    nextRetryLane = RetryLane1;\n  }\n\n  return lane;\n}\nfunction getHighestPriorityLane(lanes) {\n  return lanes & -lanes;\n}\nfunction pickArbitraryLane(lanes) {\n  // This wrapper function gets inlined. Only exists so to communicate that it\n  // doesn't matter which bit is selected; you can pick any bit without\n  // affecting the algorithms where its used. Here I'm using\n  // getHighestPriorityLane because it requires the fewest operations.\n  return getHighestPriorityLane(lanes);\n}\n\nfunction pickArbitraryLaneIndex(lanes) {\n  return 31 - clz32(lanes);\n}\n\nfunction laneToIndex(lane) {\n  return pickArbitraryLaneIndex(lane);\n}\n\nfunction includesSomeLane(a, b) {\n  return (a & b) !== NoLanes;\n}\nfunction isSubsetOfLanes(set, subset) {\n  return (set & subset) === subset;\n}\nfunction mergeLanes(a, b) {\n  return a | b;\n}\nfunction removeLanes(set, subset) {\n  return set & ~subset;\n}\nfunction intersectLanes(a, b) {\n  return a & b;\n} // Seems redundant, but it changes the type from a single lane (used for\n// updates) to a group of lanes (used for flushing work).\n\nfunction laneToLanes(lane) {\n  return lane;\n}\nfunction higherPriorityLane(a, b) {\n  // This works because the bit ranges decrease in priority as you go left.\n  return a !== NoLane && a < b ? a : b;\n}\nfunction createLaneMap(initial) {\n  // Intentionally pushing one by one.\n  // https://v8.dev/blog/elements-kinds#avoid-creating-holes\n  const laneMap = [];\n\n  for (let i = 0; i < TotalLanes; i++) {\n    laneMap.push(initial);\n  }\n\n  return laneMap;\n}\nfunction markRootUpdated(root, updateLane, eventTime) {\n  root.pendingLanes |= updateLane; // If there are any suspended transitions, it's possible this new update\n  // could unblock them. Clear the suspended lanes so that we can try rendering\n  // them again.\n  //\n  // TODO: We really only need to unsuspend only lanes that are in the\n  // `subtreeLanes` of the updated fiber, or the update lanes of the return\n  // path. This would exclude suspended updates in an unrelated sibling tree,\n  // since there's no way for this update to unblock it.\n  //\n  // We don't do this if the incoming update is idle, because we never process\n  // idle updates until after all the regular updates have finished; there's no\n  // way it could unblock a transition.\n\n  if (updateLane !== IdleLane) {\n    root.suspendedLanes = NoLanes;\n    root.pingedLanes = NoLanes;\n  }\n\n  const eventTimes = root.eventTimes;\n  const index = laneToIndex(updateLane); // We can always overwrite an existing timestamp because we prefer the most\n  // recent event, and we assume time is monotonically increasing.\n\n  eventTimes[index] = eventTime;\n}\nfunction markRootSuspended(root, suspendedLanes) {\n  root.suspendedLanes |= suspendedLanes;\n  root.pingedLanes &= ~suspendedLanes; // The suspended lanes are no longer CPU-bound. Clear their expiration times.\n\n  const expirationTimes = root.expirationTimes;\n  let lanes = suspendedLanes;\n\n  while (lanes > 0) {\n    const index = pickArbitraryLaneIndex(lanes);\n    const lane = 1 << index;\n    expirationTimes[index] = NoTimestamp;\n    lanes &= ~lane;\n  }\n}\nfunction markRootPinged(root, pingedLanes, eventTime) {\n  root.pingedLanes |= root.suspendedLanes & pingedLanes;\n}\nfunction markRootFinished(root, remainingLanes) {\n  const noLongerPendingLanes = root.pendingLanes & ~remainingLanes;\n  root.pendingLanes = remainingLanes; // Let's try everything again\n\n  root.suspendedLanes = NoLanes;\n  root.pingedLanes = NoLanes;\n  root.expiredLanes &= remainingLanes;\n  root.mutableReadLanes &= remainingLanes;\n  root.entangledLanes &= remainingLanes;\n  const entanglements = root.entanglements;\n  const eventTimes = root.eventTimes;\n  const expirationTimes = root.expirationTimes; // Clear the lanes that no longer have pending work\n\n  let lanes = noLongerPendingLanes;\n\n  while (lanes > 0) {\n    const index = pickArbitraryLaneIndex(lanes);\n    const lane = 1 << index;\n    entanglements[index] = NoLanes;\n    eventTimes[index] = NoTimestamp;\n    expirationTimes[index] = NoTimestamp;\n    lanes &= ~lane;\n  }\n}\nfunction markRootEntangled(root, entangledLanes) {\n  // In addition to entangling each of the given lanes with each other, we also\n  // have to consider _transitive_ entanglements. For each lane that is already\n  // entangled with *any* of the given lanes, that lane is now transitively\n  // entangled with *all* the given lanes.\n  //\n  // Translated: If C is entangled with A, then entangling A with B also\n  // entangles C with B.\n  //\n  // If this is hard to grasp, it might help to intentionally break this\n  // function and look at the tests that fail in ReactTransition-test.js. Try\n  // commenting out one of the conditions below.\n  const rootEntangledLanes = root.entangledLanes |= entangledLanes;\n  const entanglements = root.entanglements;\n  let lanes = rootEntangledLanes;\n\n  while (lanes) {\n    const index = pickArbitraryLaneIndex(lanes);\n    const lane = 1 << index;\n\n    if ( // Is this one of the newly entangled lanes?\n    lane & entangledLanes | // Is this lane transitively entangled with the newly entangled lanes?\n    entanglements[index] & entangledLanes) {\n      entanglements[index] |= entangledLanes;\n    }\n\n    lanes &= ~lane;\n  }\n}\nfunction getBumpedLaneForHydration(root, renderLanes) {\n  const renderLane = getHighestPriorityLane(renderLanes);\n  let lane;\n\n  switch (renderLane) {\n    case InputContinuousLane:\n      lane = InputContinuousHydrationLane;\n      break;\n\n    case DefaultLane:\n      lane = DefaultHydrationLane;\n      break;\n\n    case TransitionLane1:\n    case TransitionLane2:\n    case TransitionLane3:\n    case TransitionLane4:\n    case TransitionLane5:\n    case TransitionLane6:\n    case TransitionLane7:\n    case TransitionLane8:\n    case TransitionLane9:\n    case TransitionLane10:\n    case TransitionLane11:\n    case TransitionLane12:\n    case TransitionLane13:\n    case TransitionLane14:\n    case TransitionLane15:\n    case TransitionLane16:\n    case RetryLane1:\n    case RetryLane2:\n    case RetryLane3:\n    case RetryLane4:\n    case RetryLane5:\n      lane = TransitionHydrationLane;\n      break;\n\n    case IdleLane:\n      lane = IdleHydrationLane;\n      break;\n\n    default:\n      // Everything else is already either a hydration lane, or shouldn't\n      // be retried at a hydration lane.\n      lane = NoLane;\n      break;\n  } // Check if the lane we chose is suspended. If so, that indicates that we\n  // already attempted and failed to hydrate at that level. Also check if we're\n  // already rendering that lane, which is rare but could happen.\n\n\n  if ((lane & (root.suspendedLanes | renderLanes)) !== NoLane) {\n    // Give up trying to hydrate and fall back to client render.\n    return NoLane;\n  }\n\n  return lane;\n}\nfunction getTransitionsForLanes(root, lanes) {\n  {\n    return null;\n  }\n}\n\nconst DiscreteEventPriority = SyncLane;\nconst ContinuousEventPriority = InputContinuousLane;\nconst DefaultEventPriority = DefaultLane;\nconst IdleEventPriority = IdleLane;\nlet currentUpdatePriority = NoLane;\nfunction getCurrentUpdatePriority() {\n  return currentUpdatePriority;\n}\nfunction setCurrentUpdatePriority(newPriority) {\n  currentUpdatePriority = newPriority;\n}\nfunction runWithPriority(priority, fn) {\n  const previousPriority = currentUpdatePriority;\n\n  try {\n    currentUpdatePriority = priority;\n    return fn();\n  } finally {\n    currentUpdatePriority = previousPriority;\n  }\n}\nfunction higherEventPriority(a, b) {\n  return a !== 0 && a < b ? a : b;\n}\nfunction lowerEventPriority(a, b) {\n  return a === 0 || a > b ? a : b;\n}\nfunction isHigherEventPriority(a, b) {\n  return a !== 0 && a < b;\n}\nfunction lanesToEventPriority(lanes) {\n  const lane = getHighestPriorityLane(lanes);\n\n  if (!isHigherEventPriority(DiscreteEventPriority, lane)) {\n    return DiscreteEventPriority;\n  }\n\n  if (!isHigherEventPriority(ContinuousEventPriority, lane)) {\n    return ContinuousEventPriority;\n  }\n\n  if (includesNonIdleWork(lane)) {\n    return DefaultEventPriority;\n  }\n\n  return IdleEventPriority;\n}\n\n// This is imported by the event replaying implementation in React DOM. It's\n// in a separate file to break a circular dependency between the renderer and\n// the reconciler.\nfunction isRootDehydrated(root) {\n  const currentState = root.current.memoizedState;\n  return currentState.isDehydrated;\n}\n\nlet _attemptSynchronousHydration;\n\nfunction setAttemptSynchronousHydration(fn) {\n  _attemptSynchronousHydration = fn;\n}\nfunction attemptSynchronousHydration(fiber) {\n  _attemptSynchronousHydration(fiber);\n}\nlet attemptContinuousHydration;\nfunction setAttemptContinuousHydration(fn) {\n  attemptContinuousHydration = fn;\n}\nlet attemptHydrationAtCurrentPriority;\nfunction setAttemptHydrationAtCurrentPriority(fn) {\n  attemptHydrationAtCurrentPriority = fn;\n}\nlet getCurrentUpdatePriority$1;\nfunction setGetCurrentUpdatePriority(fn) {\n  getCurrentUpdatePriority$1 = fn;\n}\nlet attemptHydrationAtPriority;\nfunction setAttemptHydrationAtPriority(fn) {\n  attemptHydrationAtPriority = fn;\n} // TODO: Upgrade this definition once we're on a newer version of Flow that\n// has this definition built-in.\n\nlet hasScheduledReplayAttempt = false; // The queue of discrete events to be replayed.\n\nconst queuedDiscreteEvents = []; // Indicates if any continuous event targets are non-null for early bailout.\n// if the last target was dehydrated.\n\nlet queuedFocus = null;\nlet queuedDrag = null;\nlet queuedMouse = null; // For pointer events there can be one latest event per pointerId.\n\nconst queuedPointers = new Map();\nconst queuedPointerCaptures = new Map(); // We could consider replaying selectionchange and touchmoves too.\n\nconst queuedExplicitHydrationTargets = [];\nconst discreteReplayableEvents = ['mousedown', 'mouseup', 'touchcancel', 'touchend', 'touchstart', 'auxclick', 'dblclick', 'pointercancel', 'pointerdown', 'pointerup', 'dragend', 'dragstart', 'drop', 'compositionend', 'compositionstart', 'keydown', 'keypress', 'keyup', 'input', 'textInput', // Intentionally camelCase\n'copy', 'cut', 'paste', 'click', 'change', 'contextmenu', 'reset', 'submit'];\nfunction isDiscreteEventThatRequiresHydration(eventType) {\n  return discreteReplayableEvents.indexOf(eventType) > -1;\n}\n\nfunction createQueuedReplayableEvent(blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent) {\n  return {\n    blockedOn,\n    domEventName,\n    eventSystemFlags,\n    nativeEvent,\n    targetContainers: [targetContainer]\n  };\n}\n\nfunction clearIfContinuousEvent(domEventName, nativeEvent) {\n  switch (domEventName) {\n    case 'focusin':\n    case 'focusout':\n      queuedFocus = null;\n      break;\n\n    case 'dragenter':\n    case 'dragleave':\n      queuedDrag = null;\n      break;\n\n    case 'mouseover':\n    case 'mouseout':\n      queuedMouse = null;\n      break;\n\n    case 'pointerover':\n    case 'pointerout':\n      {\n        const pointerId = nativeEvent.pointerId;\n        queuedPointers.delete(pointerId);\n        break;\n      }\n\n    case 'gotpointercapture':\n    case 'lostpointercapture':\n      {\n        const pointerId = nativeEvent.pointerId;\n        queuedPointerCaptures.delete(pointerId);\n        break;\n      }\n  }\n}\n\nfunction accumulateOrCreateContinuousQueuedReplayableEvent(existingQueuedEvent, blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent) {\n  if (existingQueuedEvent === null || existingQueuedEvent.nativeEvent !== nativeEvent) {\n    const queuedEvent = createQueuedReplayableEvent(blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent);\n\n    if (blockedOn !== null) {\n      const fiber = getInstanceFromNode(blockedOn);\n\n      if (fiber !== null) {\n        // Attempt to increase the priority of this target.\n        attemptContinuousHydration(fiber);\n      }\n    }\n\n    return queuedEvent;\n  } // If we have already queued this exact event, then it's because\n  // the different event systems have different DOM event listeners.\n  // We can accumulate the flags, and the targetContainers, and\n  // store a single event to be replayed.\n\n\n  existingQueuedEvent.eventSystemFlags |= eventSystemFlags;\n  const targetContainers = existingQueuedEvent.targetContainers;\n\n  if (targetContainer !== null && targetContainers.indexOf(targetContainer) === -1) {\n    targetContainers.push(targetContainer);\n  }\n\n  return existingQueuedEvent;\n}\n\nfunction queueIfContinuousEvent(blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent) {\n  // These set relatedTarget to null because the replayed event will be treated as if we\n  // moved from outside the window (no target) onto the target once it hydrates.\n  // Instead of mutating we could clone the event.\n  switch (domEventName) {\n    case 'focusin':\n      {\n        const focusEvent = nativeEvent;\n        queuedFocus = accumulateOrCreateContinuousQueuedReplayableEvent(queuedFocus, blockedOn, domEventName, eventSystemFlags, targetContainer, focusEvent);\n        return true;\n      }\n\n    case 'dragenter':\n      {\n        const dragEvent = nativeEvent;\n        queuedDrag = accumulateOrCreateContinuousQueuedReplayableEvent(queuedDrag, blockedOn, domEventName, eventSystemFlags, targetContainer, dragEvent);\n        return true;\n      }\n\n    case 'mouseover':\n      {\n        const mouseEvent = nativeEvent;\n        queuedMouse = accumulateOrCreateContinuousQueuedReplayableEvent(queuedMouse, blockedOn, domEventName, eventSystemFlags, targetContainer, mouseEvent);\n        return true;\n      }\n\n    case 'pointerover':\n      {\n        const pointerEvent = nativeEvent;\n        const pointerId = pointerEvent.pointerId;\n        queuedPointers.set(pointerId, accumulateOrCreateContinuousQueuedReplayableEvent(queuedPointers.get(pointerId) || null, blockedOn, domEventName, eventSystemFlags, targetContainer, pointerEvent));\n        return true;\n      }\n\n    case 'gotpointercapture':\n      {\n        const pointerEvent = nativeEvent;\n        const pointerId = pointerEvent.pointerId;\n        queuedPointerCaptures.set(pointerId, accumulateOrCreateContinuousQueuedReplayableEvent(queuedPointerCaptures.get(pointerId) || null, blockedOn, domEventName, eventSystemFlags, targetContainer, pointerEvent));\n        return true;\n      }\n  }\n\n  return false;\n} // Check if this target is unblocked. Returns true if it's unblocked.\n\nfunction attemptExplicitHydrationTarget(queuedTarget) {\n  // TODO: This function shares a lot of logic with findInstanceBlockingEvent.\n  // Try to unify them. It's a bit tricky since it would require two return\n  // values.\n  const targetInst = getClosestInstanceFromNode(queuedTarget.target);\n\n  if (targetInst !== null) {\n    const nearestMounted = getNearestMountedFiber(targetInst);\n\n    if (nearestMounted !== null) {\n      const tag = nearestMounted.tag;\n\n      if (tag === SuspenseComponent) {\n        const instance = getSuspenseInstanceFromFiber(nearestMounted);\n\n        if (instance !== null) {\n          // We're blocked on hydrating this boundary.\n          // Increase its priority.\n          queuedTarget.blockedOn = instance;\n          attemptHydrationAtPriority(queuedTarget.priority, () => {\n            attemptHydrationAtCurrentPriority(nearestMounted);\n          });\n          return;\n        }\n      } else if (tag === HostRoot) {\n        const root = nearestMounted.stateNode;\n\n        if (isRootDehydrated(root)) {\n          queuedTarget.blockedOn = getContainerFromFiber(nearestMounted); // We don't currently have a way to increase the priority of\n          // a root other than sync.\n\n          return;\n        }\n      }\n    }\n  }\n\n  queuedTarget.blockedOn = null;\n}\n\nfunction queueExplicitHydrationTarget(target) {\n  // TODO: This will read the priority if it's dispatched by the React\n  // event system but not native events. Should read window.event.type, like\n  // we do for updates (getCurrentEventPriority).\n  const updatePriority = getCurrentUpdatePriority$1();\n  const queuedTarget = {\n    blockedOn: null,\n    target: target,\n    priority: updatePriority\n  };\n  let i = 0;\n\n  for (; i < queuedExplicitHydrationTargets.length; i++) {\n    // Stop once we hit the first target with lower priority than\n    if (!isHigherEventPriority(updatePriority, queuedExplicitHydrationTargets[i].priority)) {\n      break;\n    }\n  }\n\n  queuedExplicitHydrationTargets.splice(i, 0, queuedTarget);\n\n  if (i === 0) {\n    attemptExplicitHydrationTarget(queuedTarget);\n  }\n}\n\nfunction attemptReplayContinuousQueuedEvent(queuedEvent) {\n  if (queuedEvent.blockedOn !== null) {\n    return false;\n  }\n\n  const targetContainers = queuedEvent.targetContainers;\n\n  while (targetContainers.length > 0) {\n    const targetContainer = targetContainers[0];\n    const nextBlockedOn = findInstanceBlockingEvent(queuedEvent.domEventName, queuedEvent.eventSystemFlags, targetContainer, queuedEvent.nativeEvent);\n\n    if (nextBlockedOn === null) {\n      {\n        const nativeEvent = queuedEvent.nativeEvent;\n        const nativeEventClone = new nativeEvent.constructor(nativeEvent.type, nativeEvent);\n        setReplayingEvent(nativeEventClone);\n        nativeEvent.target.dispatchEvent(nativeEventClone);\n        resetReplayingEvent();\n      }\n    } else {\n      // We're still blocked. Try again later.\n      const fiber = getInstanceFromNode(nextBlockedOn);\n\n      if (fiber !== null) {\n        attemptContinuousHydration(fiber);\n      }\n\n      queuedEvent.blockedOn = nextBlockedOn;\n      return false;\n    } // This target container was successfully dispatched. Try the next.\n\n\n    targetContainers.shift();\n  }\n\n  return true;\n}\n\nfunction attemptReplayContinuousQueuedEventInMap(queuedEvent, key, map) {\n  if (attemptReplayContinuousQueuedEvent(queuedEvent)) {\n    map.delete(key);\n  }\n}\n\nfunction replayUnblockedEvents() {\n  hasScheduledReplayAttempt = false;\n\n\n  if (queuedFocus !== null && attemptReplayContinuousQueuedEvent(queuedFocus)) {\n    queuedFocus = null;\n  }\n\n  if (queuedDrag !== null && attemptReplayContinuousQueuedEvent(queuedDrag)) {\n    queuedDrag = null;\n  }\n\n  if (queuedMouse !== null && attemptReplayContinuousQueuedEvent(queuedMouse)) {\n    queuedMouse = null;\n  }\n\n  queuedPointers.forEach(attemptReplayContinuousQueuedEventInMap);\n  queuedPointerCaptures.forEach(attemptReplayContinuousQueuedEventInMap);\n}\n\nfunction scheduleCallbackIfUnblocked(queuedEvent, unblocked) {\n  if (queuedEvent.blockedOn === unblocked) {\n    queuedEvent.blockedOn = null;\n\n    if (!hasScheduledReplayAttempt) {\n      hasScheduledReplayAttempt = true; // Schedule a callback to attempt replaying as many events as are\n      // now unblocked. This first might not actually be unblocked yet.\n      // We could check it early to avoid scheduling an unnecessary callback.\n\n      Scheduler.unstable_scheduleCallback(Scheduler.unstable_NormalPriority, replayUnblockedEvents);\n    }\n  }\n}\n\nfunction retryIfBlockedOn(unblocked) {\n  // Mark anything that was blocked on this as no longer blocked\n  // and eligible for a replay.\n  if (queuedDiscreteEvents.length > 0) {\n    scheduleCallbackIfUnblocked(queuedDiscreteEvents[0], unblocked); // This is a exponential search for each boundary that commits. I think it's\n    // worth it because we expect very few discrete events to queue up and once\n    // we are actually fully unblocked it will be fast to replay them.\n\n    for (let i = 1; i < queuedDiscreteEvents.length; i++) {\n      const queuedEvent = queuedDiscreteEvents[i];\n\n      if (queuedEvent.blockedOn === unblocked) {\n        queuedEvent.blockedOn = null;\n      }\n    }\n  }\n\n  if (queuedFocus !== null) {\n    scheduleCallbackIfUnblocked(queuedFocus, unblocked);\n  }\n\n  if (queuedDrag !== null) {\n    scheduleCallbackIfUnblocked(queuedDrag, unblocked);\n  }\n\n  if (queuedMouse !== null) {\n    scheduleCallbackIfUnblocked(queuedMouse, unblocked);\n  }\n\n  const unblock = queuedEvent => scheduleCallbackIfUnblocked(queuedEvent, unblocked);\n\n  queuedPointers.forEach(unblock);\n  queuedPointerCaptures.forEach(unblock);\n\n  for (let i = 0; i < queuedExplicitHydrationTargets.length; i++) {\n    const queuedTarget = queuedExplicitHydrationTargets[i];\n\n    if (queuedTarget.blockedOn === unblocked) {\n      queuedTarget.blockedOn = null;\n    }\n  }\n\n  while (queuedExplicitHydrationTargets.length > 0) {\n    const nextExplicitTarget = queuedExplicitHydrationTargets[0];\n\n    if (nextExplicitTarget.blockedOn !== null) {\n      // We're still blocked.\n      break;\n    } else {\n      attemptExplicitHydrationTarget(nextExplicitTarget);\n\n      if (nextExplicitTarget.blockedOn === null) {\n        // We're unblocked.\n        queuedExplicitHydrationTargets.shift();\n      }\n    }\n  }\n}\n\nconst ReactCurrentBatchConfig = ReactSharedInternals.ReactCurrentBatchConfig; // TODO: can we stop exporting these?\n\nlet _enabled = true; // This is exported in FB builds for use by legacy FB layer infra.\n// We'd like to remove this but it's not clear if this is safe.\n\nfunction setEnabled(enabled) {\n  _enabled = !!enabled;\n}\nfunction isEnabled() {\n  return _enabled;\n}\nfunction createEventListenerWrapperWithPriority(targetContainer, domEventName, eventSystemFlags) {\n  const eventPriority = getEventPriority(domEventName);\n  let listenerWrapper;\n\n  switch (eventPriority) {\n    case DiscreteEventPriority:\n      listenerWrapper = dispatchDiscreteEvent;\n      break;\n\n    case ContinuousEventPriority:\n      listenerWrapper = dispatchContinuousEvent;\n      break;\n\n    case DefaultEventPriority:\n    default:\n      listenerWrapper = dispatchEvent;\n      break;\n  }\n\n  return listenerWrapper.bind(null, domEventName, eventSystemFlags, targetContainer);\n}\n\nfunction dispatchDiscreteEvent(domEventName, eventSystemFlags, container, nativeEvent) {\n  const previousPriority = getCurrentUpdatePriority();\n  const prevTransition = ReactCurrentBatchConfig.transition;\n  ReactCurrentBatchConfig.transition = null;\n\n  try {\n    setCurrentUpdatePriority(DiscreteEventPriority);\n    dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);\n  } finally {\n    setCurrentUpdatePriority(previousPriority);\n    ReactCurrentBatchConfig.transition = prevTransition;\n  }\n}\n\nfunction dispatchContinuousEvent(domEventName, eventSystemFlags, container, nativeEvent) {\n  const previousPriority = getCurrentUpdatePriority();\n  const prevTransition = ReactCurrentBatchConfig.transition;\n  ReactCurrentBatchConfig.transition = null;\n\n  try {\n    setCurrentUpdatePriority(ContinuousEventPriority);\n    dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);\n  } finally {\n    setCurrentUpdatePriority(previousPriority);\n    ReactCurrentBatchConfig.transition = prevTransition;\n  }\n}\n\nfunction dispatchEvent(domEventName, eventSystemFlags, targetContainer, nativeEvent) {\n  if (!_enabled) {\n    return;\n  }\n\n  {\n    dispatchEventWithEnableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay(domEventName, eventSystemFlags, targetContainer, nativeEvent);\n  }\n}\n\nfunction dispatchEventWithEnableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay(domEventName, eventSystemFlags, targetContainer, nativeEvent) {\n  let blockedOn = findInstanceBlockingEvent(domEventName, eventSystemFlags, targetContainer, nativeEvent);\n\n  if (blockedOn === null) {\n    dispatchEventForPluginEventSystem(domEventName, eventSystemFlags, nativeEvent, return_targetInst, targetContainer);\n    clearIfContinuousEvent(domEventName, nativeEvent);\n    return;\n  }\n\n  if (queueIfContinuousEvent(blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent)) {\n    nativeEvent.stopPropagation();\n    return;\n  } // We need to clear only if we didn't queue because\n  // queueing is accumulative.\n\n\n  clearIfContinuousEvent(domEventName, nativeEvent);\n\n  if (eventSystemFlags & IS_CAPTURE_PHASE && isDiscreteEventThatRequiresHydration(domEventName)) {\n    while (blockedOn !== null) {\n      const fiber = getInstanceFromNode(blockedOn);\n\n      if (fiber !== null) {\n        attemptSynchronousHydration(fiber);\n      }\n\n      const nextBlockedOn = findInstanceBlockingEvent(domEventName, eventSystemFlags, targetContainer, nativeEvent);\n\n      if (nextBlockedOn === null) {\n        dispatchEventForPluginEventSystem(domEventName, eventSystemFlags, nativeEvent, return_targetInst, targetContainer);\n      }\n\n      if (nextBlockedOn === blockedOn) {\n        break;\n      }\n\n      blockedOn = nextBlockedOn;\n    }\n\n    if (blockedOn !== null) {\n      nativeEvent.stopPropagation();\n    }\n\n    return;\n  } // This is not replayable so we'll invoke it but without a target,\n  // in case the event system needs to trace it.\n\n\n  dispatchEventForPluginEventSystem(domEventName, eventSystemFlags, nativeEvent, null, targetContainer);\n}\n\nlet return_targetInst = null; // Returns a SuspenseInstance or Container if it's blocked.\n// The return_targetInst field above is conceptually part of the return value.\n\nfunction findInstanceBlockingEvent(domEventName, eventSystemFlags, targetContainer, nativeEvent) {\n  // TODO: Warn if _enabled is false.\n  return_targetInst = null;\n  const nativeEventTarget = getEventTarget(nativeEvent);\n  let targetInst = getClosestInstanceFromNode(nativeEventTarget);\n\n  if (targetInst !== null) {\n    const nearestMounted = getNearestMountedFiber(targetInst);\n\n    if (nearestMounted === null) {\n      // This tree has been unmounted already. Dispatch without a target.\n      targetInst = null;\n    } else {\n      const tag = nearestMounted.tag;\n\n      if (tag === SuspenseComponent) {\n        const instance = getSuspenseInstanceFromFiber(nearestMounted);\n\n        if (instance !== null) {\n          // Queue the event to be replayed later. Abort dispatching since we\n          // don't want this event dispatched twice through the event system.\n          // TODO: If this is the first discrete event in the queue. Schedule an increased\n          // priority for this boundary.\n          return instance;\n        } // This shouldn't happen, something went wrong but to avoid blocking\n        // the whole system, dispatch the event without a target.\n        // TODO: Warn.\n\n\n        targetInst = null;\n      } else if (tag === HostRoot) {\n        const root = nearestMounted.stateNode;\n\n        if (isRootDehydrated(root)) {\n          // If this happens during a replay something went wrong and it might block\n          // the whole system.\n          return getContainerFromFiber(nearestMounted);\n        }\n\n        targetInst = null;\n      } else if (nearestMounted !== targetInst) {\n        // If we get an event (ex: img onload) before committing that\n        // component's mount, ignore it for now (that is, treat it as if it was an\n        // event on a non-React tree). We might also consider queueing events and\n        // dispatching them after the mount.\n        targetInst = null;\n      }\n    }\n  }\n\n  return_targetInst = targetInst; // We're not blocked on anything.\n\n  return null;\n}\nfunction getEventPriority(domEventName) {\n  switch (domEventName) {\n    // Used by SimpleEventPlugin:\n    case 'cancel':\n    case 'click':\n    case 'close':\n    case 'contextmenu':\n    case 'copy':\n    case 'cut':\n    case 'auxclick':\n    case 'dblclick':\n    case 'dragend':\n    case 'dragstart':\n    case 'drop':\n    case 'focusin':\n    case 'focusout':\n    case 'input':\n    case 'invalid':\n    case 'keydown':\n    case 'keypress':\n    case 'keyup':\n    case 'mousedown':\n    case 'mouseup':\n    case 'paste':\n    case 'pause':\n    case 'play':\n    case 'pointercancel':\n    case 'pointerdown':\n    case 'pointerup':\n    case 'ratechange':\n    case 'reset':\n    case 'resize':\n    case 'seeked':\n    case 'submit':\n    case 'touchcancel':\n    case 'touchend':\n    case 'touchstart':\n    case 'volumechange': // Used by polyfills:\n    // eslint-disable-next-line no-fallthrough\n\n    case 'change':\n    case 'selectionchange':\n    case 'textInput':\n    case 'compositionstart':\n    case 'compositionend':\n    case 'compositionupdate': // Only enableCreateEventHandleAPI:\n    // eslint-disable-next-line no-fallthrough\n\n    case 'beforeblur':\n    case 'afterblur': // Not used by React but could be by user code:\n    // eslint-disable-next-line no-fallthrough\n\n    case 'beforeinput':\n    case 'blur':\n    case 'fullscreenchange':\n    case 'focus':\n    case 'hashchange':\n    case 'popstate':\n    case 'select':\n    case 'selectstart':\n      return DiscreteEventPriority;\n\n    case 'drag':\n    case 'dragenter':\n    case 'dragexit':\n    case 'dragleave':\n    case 'dragover':\n    case 'mousemove':\n    case 'mouseout':\n    case 'mouseover':\n    case 'pointermove':\n    case 'pointerout':\n    case 'pointerover':\n    case 'scroll':\n    case 'toggle':\n    case 'touchmove':\n    case 'wheel': // Not used by React but could be by user code:\n    // eslint-disable-next-line no-fallthrough\n\n    case 'mouseenter':\n    case 'mouseleave':\n    case 'pointerenter':\n    case 'pointerleave':\n      return ContinuousEventPriority;\n\n    case 'message':\n      {\n        // We might be in the Scheduler callback.\n        // Eventually this mechanism will be replaced by a check\n        // of the current priority on the native scheduler.\n        const schedulerPriority = getCurrentPriorityLevel();\n\n        switch (schedulerPriority) {\n          case ImmediatePriority:\n            return DiscreteEventPriority;\n\n          case UserBlockingPriority:\n            return ContinuousEventPriority;\n\n          case NormalPriority:\n          case LowPriority:\n            // TODO: Handle LowSchedulerPriority, somehow. Maybe the same lane as hydration.\n            return DefaultEventPriority;\n\n          case IdlePriority:\n            return IdleEventPriority;\n\n          default:\n            return DefaultEventPriority;\n        }\n      }\n\n    default:\n      return DefaultEventPriority;\n  }\n}\n\nfunction addEventBubbleListener(target, eventType, listener) {\n  target.addEventListener(eventType, listener, false);\n  return listener;\n}\nfunction addEventCaptureListener(target, eventType, listener) {\n  target.addEventListener(eventType, listener, true);\n  return listener;\n}\nfunction addEventCaptureListenerWithPassiveFlag(target, eventType, listener, passive) {\n  target.addEventListener(eventType, listener, {\n    capture: true,\n    passive\n  });\n  return listener;\n}\nfunction addEventBubbleListenerWithPassiveFlag(target, eventType, listener, passive) {\n  target.addEventListener(eventType, listener, {\n    passive\n  });\n  return listener;\n}\n\n/**\n * These variables store information about text content of a target node,\n * allowing comparison of content before and after a given event.\n *\n * Identify the node where selection currently begins, then observe\n * both its text content and its current position in the DOM. Since the\n * browser may natively replace the target node during composition, we can\n * use its position to find its replacement.\n *\n *\n */\nlet root = null;\nlet startText = null;\nlet fallbackText = null;\nfunction initialize(nativeEventTarget) {\n  root = nativeEventTarget;\n  startText = getText();\n  return true;\n}\nfunction reset() {\n  root = null;\n  startText = null;\n  fallbackText = null;\n}\nfunction getData() {\n  if (fallbackText) {\n    return fallbackText;\n  }\n\n  let start;\n  const startValue = startText;\n  const startLength = startValue.length;\n  let end;\n  const endValue = getText();\n  const endLength = endValue.length;\n\n  for (start = 0; start < startLength; start++) {\n    if (startValue[start] !== endValue[start]) {\n      break;\n    }\n  }\n\n  const minEnd = startLength - start;\n\n  for (end = 1; end <= minEnd; end++) {\n    if (startValue[startLength - end] !== endValue[endLength - end]) {\n      break;\n    }\n  }\n\n  const sliceTail = end > 1 ? 1 - end : undefined;\n  fallbackText = endValue.slice(start, sliceTail);\n  return fallbackText;\n}\nfunction getText() {\n  if ('value' in root) {\n    return root.value;\n  }\n\n  return root.textContent;\n}\n\n/**\n * `charCode` represents the actual \"character code\" and is safe to use with\n * `String.fromCharCode`. As such, only keys that correspond to printable\n * characters produce a valid `charCode`, the only exception to this is Enter.\n * The Tab-key is considered non-printable and does not have a `charCode`,\n * presumably because it does not produce a tab-character in browsers.\n *\n * @param {object} nativeEvent Native browser event.\n * @return {number} Normalized `charCode` property.\n */\nfunction getEventCharCode(nativeEvent) {\n  let charCode;\n  const keyCode = nativeEvent.keyCode;\n\n  if ('charCode' in nativeEvent) {\n    charCode = nativeEvent.charCode; // FF does not set `charCode` for the Enter-key, check against `keyCode`.\n\n    if (charCode === 0 && keyCode === 13) {\n      charCode = 13;\n    }\n  } else {\n    // IE8 does not implement `charCode`, but `keyCode` has the correct value.\n    charCode = keyCode;\n  } // IE and Edge (on Windows) and Chrome / Safari (on Windows and Linux)\n  // report Enter as charCode 10 when ctrl is pressed.\n\n\n  if (charCode === 10) {\n    charCode = 13;\n  } // Some non-printable keys are reported in `charCode`/`keyCode`, discard them.\n  // Must not discard the (non-)printable Enter-key.\n\n\n  if (charCode >= 32 || charCode === 13) {\n    return charCode;\n  }\n\n  return 0;\n}\n\nfunction functionThatReturnsTrue() {\n  return true;\n}\n\nfunction functionThatReturnsFalse() {\n  return false;\n} // This is intentionally a factory so that we have different returned constructors.\n// If we had a single constructor, it would be megamorphic and engines would deopt.\n\n\nfunction createSyntheticEvent(Interface) {\n  /**\n   * Synthetic events are dispatched by event plugins, typically in response to a\n   * top-level event delegation handler.\n   *\n   * These systems should generally use pooling to reduce the frequency of garbage\n   * collection. The system should check `isPersistent` to determine whether the\n   * event should be released into the pool after being dispatched. Users that\n   * need a persisted event should invoke `persist`.\n   *\n   * Synthetic events (and subclasses) implement the DOM Level 3 Events API by\n   * normalizing browser quirks. Subclasses do not necessarily have to implement a\n   * DOM interface; custom application-specific events can also subclass this.\n   */\n  function SyntheticBaseEvent(reactName, reactEventType, targetInst, nativeEvent, nativeEventTarget) {\n    this._reactName = reactName;\n    this._targetInst = targetInst;\n    this.type = reactEventType;\n    this.nativeEvent = nativeEvent;\n    this.target = nativeEventTarget;\n    this.currentTarget = null;\n\n    for (const propName in Interface) {\n      if (!Interface.hasOwnProperty(propName)) {\n        continue;\n      }\n\n      const normalize = Interface[propName];\n\n      if (normalize) {\n        this[propName] = normalize(nativeEvent);\n      } else {\n        this[propName] = nativeEvent[propName];\n      }\n    }\n\n    const defaultPrevented = nativeEvent.defaultPrevented != null ? nativeEvent.defaultPrevented : nativeEvent.returnValue === false;\n\n    if (defaultPrevented) {\n      this.isDefaultPrevented = functionThatReturnsTrue;\n    } else {\n      this.isDefaultPrevented = functionThatReturnsFalse;\n    }\n\n    this.isPropagationStopped = functionThatReturnsFalse;\n    return this;\n  }\n\n  assign(SyntheticBaseEvent.prototype, {\n    preventDefault: function () {\n      this.defaultPrevented = true;\n      const event = this.nativeEvent;\n\n      if (!event) {\n        return;\n      }\n\n      if (event.preventDefault) {\n        event.preventDefault(); // $FlowFixMe - flow is not aware of `unknown` in IE\n      } else if (typeof event.returnValue !== 'unknown') {\n        event.returnValue = false;\n      }\n\n      this.isDefaultPrevented = functionThatReturnsTrue;\n    },\n    stopPropagation: function () {\n      const event = this.nativeEvent;\n\n      if (!event) {\n        return;\n      }\n\n      if (event.stopPropagation) {\n        event.stopPropagation(); // $FlowFixMe - flow is not aware of `unknown` in IE\n      } else if (typeof event.cancelBubble !== 'unknown') {\n        // The ChangeEventPlugin registers a \"propertychange\" event for\n        // IE. This event does not support bubbling or cancelling, and\n        // any references to cancelBubble throw \"Member not found\".  A\n        // typeof check of \"unknown\" circumvents this issue (and is also\n        // IE specific).\n        event.cancelBubble = true;\n      }\n\n      this.isPropagationStopped = functionThatReturnsTrue;\n    },\n\n    /**\n     * We release all dispatched `SyntheticEvent`s after each event loop, adding\n     * them back into the pool. This allows a way to hold onto a reference that\n     * won't be added back into the pool.\n     */\n    persist: function () {// Modern event system doesn't use pooling.\n    },\n\n    /**\n     * Checks if this event should be released back into the pool.\n     *\n     * @return {boolean} True if this should not be released, false otherwise.\n     */\n    isPersistent: functionThatReturnsTrue\n  });\n  return SyntheticBaseEvent;\n}\n/**\n * @interface Event\n * @see http://www.w3.org/TR/DOM-Level-3-Events/\n */\n\n\nconst EventInterface = {\n  eventPhase: 0,\n  bubbles: 0,\n  cancelable: 0,\n  timeStamp: function (event) {\n    return event.timeStamp || Date.now();\n  },\n  defaultPrevented: 0,\n  isTrusted: 0\n};\nconst SyntheticEvent = createSyntheticEvent(EventInterface);\n\nconst UIEventInterface = assign({}, EventInterface, {\n  view: 0,\n  detail: 0\n});\n\nconst SyntheticUIEvent = createSyntheticEvent(UIEventInterface);\nlet lastMovementX;\nlet lastMovementY;\nlet lastMouseEvent;\n\nfunction updateMouseMovementPolyfillState(event) {\n  if (event !== lastMouseEvent) {\n    if (lastMouseEvent && event.type === 'mousemove') {\n      lastMovementX = event.screenX - lastMouseEvent.screenX;\n      lastMovementY = event.screenY - lastMouseEvent.screenY;\n    } else {\n      lastMovementX = 0;\n      lastMovementY = 0;\n    }\n\n    lastMouseEvent = event;\n  }\n}\n/**\n * @interface MouseEvent\n * @see http://www.w3.org/TR/DOM-Level-3-Events/\n */\n\n\nconst MouseEventInterface = assign({}, UIEventInterface, {\n  screenX: 0,\n  screenY: 0,\n  clientX: 0,\n  clientY: 0,\n  pageX: 0,\n  pageY: 0,\n  ctrlKey: 0,\n  shiftKey: 0,\n  altKey: 0,\n  metaKey: 0,\n  getModifierState: getEventModifierState,\n  button: 0,\n  buttons: 0,\n  relatedTarget: function (event) {\n    if (event.relatedTarget === undefined) return event.fromElement === event.srcElement ? event.toElement : event.fromElement;\n    return event.relatedTarget;\n  },\n  movementX: function (event) {\n    if ('movementX' in event) {\n      return event.movementX;\n    }\n\n    updateMouseMovementPolyfillState(event);\n    return lastMovementX;\n  },\n  movementY: function (event) {\n    if ('movementY' in event) {\n      return event.movementY;\n    } // Don't need to call updateMouseMovementPolyfillState() here\n    // because it's guaranteed to have already run when movementX\n    // was copied.\n\n\n    return lastMovementY;\n  }\n});\n\nconst SyntheticMouseEvent = createSyntheticEvent(MouseEventInterface);\n/**\n * @interface DragEvent\n * @see http://www.w3.org/TR/DOM-Level-3-Events/\n */\n\nconst DragEventInterface = assign({}, MouseEventInterface, {\n  dataTransfer: 0\n});\n\nconst SyntheticDragEvent = createSyntheticEvent(DragEventInterface);\n/**\n * @interface FocusEvent\n * @see http://www.w3.org/TR/DOM-Level-3-Events/\n */\n\nconst FocusEventInterface = assign({}, UIEventInterface, {\n  relatedTarget: 0\n});\n\nconst SyntheticFocusEvent = createSyntheticEvent(FocusEventInterface);\n/**\n * @interface Event\n * @see http://www.w3.org/TR/css3-animations/#AnimationEvent-interface\n * @see https://developer.mozilla.org/en-US/docs/Web/API/AnimationEvent\n */\n\nconst AnimationEventInterface = assign({}, EventInterface, {\n  animationName: 0,\n  elapsedTime: 0,\n  pseudoElement: 0\n});\n\nconst SyntheticAnimationEvent = createSyntheticEvent(AnimationEventInterface);\n/**\n * @interface Event\n * @see http://www.w3.org/TR/clipboard-apis/\n */\n\nconst ClipboardEventInterface = assign({}, EventInterface, {\n  clipboardData: function (event) {\n    return 'clipboardData' in event ? event.clipboardData : window.clipboardData;\n  }\n});\n\nconst SyntheticClipboardEvent = createSyntheticEvent(ClipboardEventInterface);\n/**\n * @interface Event\n * @see http://www.w3.org/TR/DOM-Level-3-Events/#events-compositionevents\n */\n\nconst CompositionEventInterface = assign({}, EventInterface, {\n  data: 0\n});\n\nconst SyntheticCompositionEvent = createSyntheticEvent(CompositionEventInterface);\n/**\n * @interface Event\n * @see http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105\n *      /#events-inputevents\n */\n// Happens to share the same list for now.\n\nconst SyntheticInputEvent = SyntheticCompositionEvent;\n/**\n * Normalization of deprecated HTML5 `key` values\n * @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names\n */\n\nconst normalizeKey = {\n  Esc: 'Escape',\n  Spacebar: ' ',\n  Left: 'ArrowLeft',\n  Up: 'ArrowUp',\n  Right: 'ArrowRight',\n  Down: 'ArrowDown',\n  Del: 'Delete',\n  Win: 'OS',\n  Menu: 'ContextMenu',\n  Apps: 'ContextMenu',\n  Scroll: 'ScrollLock',\n  MozPrintableKey: 'Unidentified'\n};\n/**\n * Translation from legacy `keyCode` to HTML5 `key`\n * Only special keys supported, all others depend on keyboard layout or browser\n * @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names\n */\n\nconst translateToKey = {\n  '8': 'Backspace',\n  '9': 'Tab',\n  '12': 'Clear',\n  '13': 'Enter',\n  '16': 'Shift',\n  '17': 'Control',\n  '18': 'Alt',\n  '19': 'Pause',\n  '20': 'CapsLock',\n  '27': 'Escape',\n  '32': ' ',\n  '33': 'PageUp',\n  '34': 'PageDown',\n  '35': 'End',\n  '36': 'Home',\n  '37': 'ArrowLeft',\n  '38': 'ArrowUp',\n  '39': 'ArrowRight',\n  '40': 'ArrowDown',\n  '45': 'Insert',\n  '46': 'Delete',\n  '112': 'F1',\n  '113': 'F2',\n  '114': 'F3',\n  '115': 'F4',\n  '116': 'F5',\n  '117': 'F6',\n  '118': 'F7',\n  '119': 'F8',\n  '120': 'F9',\n  '121': 'F10',\n  '122': 'F11',\n  '123': 'F12',\n  '144': 'NumLock',\n  '145': 'ScrollLock',\n  '224': 'Meta'\n};\n/**\n * @param {object} nativeEvent Native browser event.\n * @return {string} Normalized `key` property.\n */\n\nfunction getEventKey(nativeEvent) {\n  if (nativeEvent.key) {\n    // Normalize inconsistent values reported by browsers due to\n    // implementations of a working draft specification.\n    // FireFox implements `key` but returns `MozPrintableKey` for all\n    // printable characters (normalized to `Unidentified`), ignore it.\n    const key = normalizeKey[nativeEvent.key] || nativeEvent.key;\n\n    if (key !== 'Unidentified') {\n      return key;\n    }\n  } // Browser does not implement `key`, polyfill as much of it as we can.\n\n\n  if (nativeEvent.type === 'keypress') {\n    const charCode = getEventCharCode(nativeEvent); // The enter-key is technically both printable and non-printable and can\n    // thus be captured by `keypress`, no other non-printable key should.\n\n    return charCode === 13 ? 'Enter' : String.fromCharCode(charCode);\n  }\n\n  if (nativeEvent.type === 'keydown' || nativeEvent.type === 'keyup') {\n    // While user keyboard layout determines the actual meaning of each\n    // `keyCode` value, almost all function keys have a universal value.\n    return translateToKey[nativeEvent.keyCode] || 'Unidentified';\n  }\n\n  return '';\n}\n/**\n * Translation from modifier key to the associated property in the event.\n * @see http://www.w3.org/TR/DOM-Level-3-Events/#keys-Modifiers\n */\n\n\nconst modifierKeyToProp = {\n  Alt: 'altKey',\n  Control: 'ctrlKey',\n  Meta: 'metaKey',\n  Shift: 'shiftKey'\n}; // Older browsers (Safari <= 10, iOS Safari <= 10.2) do not support\n// getModifierState. If getModifierState is not supported, we map it to a set of\n// modifier keys exposed by the event. In this case, Lock-keys are not supported.\n\nfunction modifierStateGetter(keyArg) {\n  const syntheticEvent = this;\n  const nativeEvent = syntheticEvent.nativeEvent;\n\n  if (nativeEvent.getModifierState) {\n    return nativeEvent.getModifierState(keyArg);\n  }\n\n  const keyProp = modifierKeyToProp[keyArg];\n  return keyProp ? !!nativeEvent[keyProp] : false;\n}\n\nfunction getEventModifierState(nativeEvent) {\n  return modifierStateGetter;\n}\n/**\n * @interface KeyboardEvent\n * @see http://www.w3.org/TR/DOM-Level-3-Events/\n */\n\n\nconst KeyboardEventInterface = assign({}, UIEventInterface, {\n  key: getEventKey,\n  code: 0,\n  location: 0,\n  ctrlKey: 0,\n  shiftKey: 0,\n  altKey: 0,\n  metaKey: 0,\n  repeat: 0,\n  locale: 0,\n  getModifierState: getEventModifierState,\n  // Legacy Interface\n  charCode: function (event) {\n    // `charCode` is the result of a KeyPress event and represents the value of\n    // the actual printable character.\n    // KeyPress is deprecated, but its replacement is not yet final and not\n    // implemented in any major browser. Only KeyPress has charCode.\n    if (event.type === 'keypress') {\n      return getEventCharCode(event);\n    }\n\n    return 0;\n  },\n  keyCode: function (event) {\n    // `keyCode` is the result of a KeyDown/Up event and represents the value of\n    // physical keyboard key.\n    // The actual meaning of the value depends on the users' keyboard layout\n    // which cannot be detected. Assuming that it is a US keyboard layout\n    // provides a surprisingly accurate mapping for US and European users.\n    // Due to this, it is left to the user to implement at this time.\n    if (event.type === 'keydown' || event.type === 'keyup') {\n      return event.keyCode;\n    }\n\n    return 0;\n  },\n  which: function (event) {\n    // `which` is an alias for either `keyCode` or `charCode` depending on the\n    // type of the event.\n    if (event.type === 'keypress') {\n      return getEventCharCode(event);\n    }\n\n    if (event.type === 'keydown' || event.type === 'keyup') {\n      return event.keyCode;\n    }\n\n    return 0;\n  }\n});\n\nconst SyntheticKeyboardEvent = createSyntheticEvent(KeyboardEventInterface);\n/**\n * @interface PointerEvent\n * @see http://www.w3.org/TR/pointerevents/\n */\n\nconst PointerEventInterface = assign({}, MouseEventInterface, {\n  pointerId: 0,\n  width: 0,\n  height: 0,\n  pressure: 0,\n  tangentialPressure: 0,\n  tiltX: 0,\n  tiltY: 0,\n  twist: 0,\n  pointerType: 0,\n  isPrimary: 0\n});\n\nconst SyntheticPointerEvent = createSyntheticEvent(PointerEventInterface);\n/**\n * @interface TouchEvent\n * @see http://www.w3.org/TR/touch-events/\n */\n\nconst TouchEventInterface = assign({}, UIEventInterface, {\n  touches: 0,\n  targetTouches: 0,\n  changedTouches: 0,\n  altKey: 0,\n  metaKey: 0,\n  ctrlKey: 0,\n  shiftKey: 0,\n  getModifierState: getEventModifierState\n});\n\nconst SyntheticTouchEvent = createSyntheticEvent(TouchEventInterface);\n/**\n * @interface Event\n * @see http://www.w3.org/TR/2009/WD-css3-transitions-20090320/#transition-events-\n * @see https://developer.mozilla.org/en-US/docs/Web/API/TransitionEvent\n */\n\nconst TransitionEventInterface = assign({}, EventInterface, {\n  propertyName: 0,\n  elapsedTime: 0,\n  pseudoElement: 0\n});\n\nconst SyntheticTransitionEvent = createSyntheticEvent(TransitionEventInterface);\n/**\n * @interface WheelEvent\n * @see http://www.w3.org/TR/DOM-Level-3-Events/\n */\n\nconst WheelEventInterface = assign({}, MouseEventInterface, {\n  deltaX(event) {\n    return 'deltaX' in event ? event.deltaX : // Fallback to `wheelDeltaX` for Webkit and normalize (right is positive).\n    'wheelDeltaX' in event ? -event.wheelDeltaX : 0;\n  },\n\n  deltaY(event) {\n    return 'deltaY' in event ? event.deltaY : // Fallback to `wheelDeltaY` for Webkit and normalize (down is positive).\n    'wheelDeltaY' in event ? -event.wheelDeltaY : // Fallback to `wheelDelta` for IE<9 and normalize (down is positive).\n    'wheelDelta' in event ? -event.wheelDelta : 0;\n  },\n\n  deltaZ: 0,\n  // Browsers without \"deltaMode\" is reporting in raw wheel delta where one\n  // notch on the scroll is always +/- 120, roughly equivalent to pixels.\n  // A good approximation of DOM_DELTA_LINE (1) is 5% of viewport size or\n  // ~40 pixels, for DOM_DELTA_SCREEN (2) it is 87.5% of viewport size.\n  deltaMode: 0\n});\n\nconst SyntheticWheelEvent = createSyntheticEvent(WheelEventInterface);\n\nconst END_KEYCODES = [9, 13, 27, 32]; // Tab, Return, Esc, Space\n\nconst START_KEYCODE = 229;\nconst canUseCompositionEvent = canUseDOM && 'CompositionEvent' in window;\nlet documentMode = null;\n\nif (canUseDOM && 'documentMode' in document) {\n  documentMode = document.documentMode;\n} // Webkit offers a very useful `textInput` event that can be used to\n// directly represent `beforeInput`. The IE `textinput` event is not as\n// useful, so we don't use it.\n\n\nconst canUseTextInputEvent = canUseDOM && 'TextEvent' in window && !documentMode; // In IE9+, we have access to composition events, but the data supplied\n// by the native compositionend event may be incorrect. Japanese ideographic\n// spaces, for instance (\\u3000) are not recorded correctly.\n\nconst useFallbackCompositionData = canUseDOM && (!canUseCompositionEvent || documentMode && documentMode > 8 && documentMode <= 11);\nconst SPACEBAR_CODE = 32;\nconst SPACEBAR_CHAR = String.fromCharCode(SPACEBAR_CODE);\n\nfunction registerEvents() {\n  registerTwoPhaseEvent('onBeforeInput', ['compositionend', 'keypress', 'textInput', 'paste']);\n  registerTwoPhaseEvent('onCompositionEnd', ['compositionend', 'focusout', 'keydown', 'keypress', 'keyup', 'mousedown']);\n  registerTwoPhaseEvent('onCompositionStart', ['compositionstart', 'focusout', 'keydown', 'keypress', 'keyup', 'mousedown']);\n  registerTwoPhaseEvent('onCompositionUpdate', ['compositionupdate', 'focusout', 'keydown', 'keypress', 'keyup', 'mousedown']);\n} // Track whether we've ever handled a keypress on the space key.\n\n\nlet hasSpaceKeypress = false;\n/**\n * Return whether a native keypress event is assumed to be a command.\n * This is required because Firefox fires `keypress` events for key commands\n * (cut, copy, select-all, etc.) even though no character is inserted.\n */\n\nfunction isKeypressCommand(nativeEvent) {\n  return (nativeEvent.ctrlKey || nativeEvent.altKey || nativeEvent.metaKey) && // ctrlKey && altKey is equivalent to AltGr, and is not a command.\n  !(nativeEvent.ctrlKey && nativeEvent.altKey);\n}\n/**\n * Translate native top level events into event types.\n */\n\n\nfunction getCompositionEventType(domEventName) {\n  switch (domEventName) {\n    case 'compositionstart':\n      return 'onCompositionStart';\n\n    case 'compositionend':\n      return 'onCompositionEnd';\n\n    case 'compositionupdate':\n      return 'onCompositionUpdate';\n  }\n}\n/**\n * Does our fallback best-guess model think this event signifies that\n * composition has begun?\n */\n\n\nfunction isFallbackCompositionStart(domEventName, nativeEvent) {\n  return domEventName === 'keydown' && nativeEvent.keyCode === START_KEYCODE;\n}\n/**\n * Does our fallback mode think that this event is the end of composition?\n */\n\n\nfunction isFallbackCompositionEnd(domEventName, nativeEvent) {\n  switch (domEventName) {\n    case 'keyup':\n      // Command keys insert or clear IME input.\n      return END_KEYCODES.indexOf(nativeEvent.keyCode) !== -1;\n\n    case 'keydown':\n      // Expect IME keyCode on each keydown. If we get any other\n      // code we must have exited earlier.\n      return nativeEvent.keyCode !== START_KEYCODE;\n\n    case 'keypress':\n    case 'mousedown':\n    case 'focusout':\n      // Events are not possible without cancelling IME.\n      return true;\n\n    default:\n      return false;\n  }\n}\n/**\n * Google Input Tools provides composition data via a CustomEvent,\n * with the `data` property populated in the `detail` object. If this\n * is available on the event object, use it. If not, this is a plain\n * composition event and we have nothing special to extract.\n *\n * @param {object} nativeEvent\n * @return {?string}\n */\n\n\nfunction getDataFromCustomEvent(nativeEvent) {\n  const detail = nativeEvent.detail;\n\n  if (typeof detail === 'object' && 'data' in detail) {\n    return detail.data;\n  }\n\n  return null;\n}\n/**\n * Check if a composition event was triggered by Korean IME.\n * Our fallback mode does not work well with IE's Korean IME,\n * so just use native composition events when Korean IME is used.\n * Although CompositionEvent.locale property is deprecated,\n * it is available in IE, where our fallback mode is enabled.\n *\n * @param {object} nativeEvent\n * @return {boolean}\n */\n\n\nfunction isUsingKoreanIME(nativeEvent) {\n  return nativeEvent.locale === 'ko';\n} // Track the current IME composition status, if any.\n\n\nlet isComposing = false;\n/**\n * @return {?object} A SyntheticCompositionEvent.\n */\n\nfunction extractCompositionEvent(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget) {\n  let eventType;\n  let fallbackData;\n\n  if (canUseCompositionEvent) {\n    eventType = getCompositionEventType(domEventName);\n  } else if (!isComposing) {\n    if (isFallbackCompositionStart(domEventName, nativeEvent)) {\n      eventType = 'onCompositionStart';\n    }\n  } else if (isFallbackCompositionEnd(domEventName, nativeEvent)) {\n    eventType = 'onCompositionEnd';\n  }\n\n  if (!eventType) {\n    return null;\n  }\n\n  if (useFallbackCompositionData && !isUsingKoreanIME(nativeEvent)) {\n    // The current composition is stored statically and must not be\n    // overwritten while composition continues.\n    if (!isComposing && eventType === 'onCompositionStart') {\n      isComposing = initialize(nativeEventTarget);\n    } else if (eventType === 'onCompositionEnd') {\n      if (isComposing) {\n        fallbackData = getData();\n      }\n    }\n  }\n\n  const listeners = accumulateTwoPhaseListeners(targetInst, eventType);\n\n  if (listeners.length > 0) {\n    const event = new SyntheticCompositionEvent(eventType, domEventName, null, nativeEvent, nativeEventTarget);\n    dispatchQueue.push({\n      event,\n      listeners\n    });\n\n    if (fallbackData) {\n      // Inject data generated from fallback path into the synthetic event.\n      // This matches the property of native CompositionEventInterface.\n      event.data = fallbackData;\n    } else {\n      const customData = getDataFromCustomEvent(nativeEvent);\n\n      if (customData !== null) {\n        event.data = customData;\n      }\n    }\n  }\n}\n\nfunction getNativeBeforeInputChars(domEventName, nativeEvent) {\n  switch (domEventName) {\n    case 'compositionend':\n      return getDataFromCustomEvent(nativeEvent);\n\n    case 'keypress':\n      /**\n       * If native `textInput` events are available, our goal is to make\n       * use of them. However, there is a special case: the spacebar key.\n       * In Webkit, preventing default on a spacebar `textInput` event\n       * cancels character insertion, but it *also* causes the browser\n       * to fall back to its default spacebar behavior of scrolling the\n       * page.\n       *\n       * Tracking at:\n       * https://code.google.com/p/chromium/issues/detail?id=355103\n       *\n       * To avoid this issue, use the keypress event as if no `textInput`\n       * event is available.\n       */\n      const which = nativeEvent.which;\n\n      if (which !== SPACEBAR_CODE) {\n        return null;\n      }\n\n      hasSpaceKeypress = true;\n      return SPACEBAR_CHAR;\n\n    case 'textInput':\n      // Record the characters to be added to the DOM.\n      const chars = nativeEvent.data; // If it's a spacebar character, assume that we have already handled\n      // it at the keypress level and bail immediately. Android Chrome\n      // doesn't give us keycodes, so we need to ignore it.\n\n      if (chars === SPACEBAR_CHAR && hasSpaceKeypress) {\n        return null;\n      }\n\n      return chars;\n\n    default:\n      // For other native event types, do nothing.\n      return null;\n  }\n}\n/**\n * For browsers that do not provide the `textInput` event, extract the\n * appropriate string to use for SyntheticInputEvent.\n */\n\n\nfunction getFallbackBeforeInputChars(domEventName, nativeEvent) {\n  // If we are currently composing (IME) and using a fallback to do so,\n  // try to extract the composed characters from the fallback object.\n  // If composition event is available, we extract a string only at\n  // compositionevent, otherwise extract it at fallback events.\n  if (isComposing) {\n    if (domEventName === 'compositionend' || !canUseCompositionEvent && isFallbackCompositionEnd(domEventName, nativeEvent)) {\n      const chars = getData();\n      reset();\n      isComposing = false;\n      return chars;\n    }\n\n    return null;\n  }\n\n  switch (domEventName) {\n    case 'paste':\n      // If a paste event occurs after a keypress, throw out the input\n      // chars. Paste events should not lead to BeforeInput events.\n      return null;\n\n    case 'keypress':\n      /**\n       * As of v27, Firefox may fire keypress events even when no character\n       * will be inserted. A few possibilities:\n       *\n       * - `which` is `0`. Arrow keys, Esc key, etc.\n       *\n       * - `which` is the pressed key code, but no char is available.\n       *   Ex: 'AltGr + d` in Polish. There is no modified character for\n       *   this key combination and no character is inserted into the\n       *   document, but FF fires the keypress for char code `100` anyway.\n       *   No `input` event will occur.\n       *\n       * - `which` is the pressed key code, but a command combination is\n       *   being used. Ex: `Cmd+C`. No character is inserted, and no\n       *   `input` event will occur.\n       */\n      if (!isKeypressCommand(nativeEvent)) {\n        // IE fires the `keypress` event when a user types an emoji via\n        // Touch keyboard of Windows.  In such a case, the `char` property\n        // holds an emoji character like `\\uD83D\\uDE0A`.  Because its length\n        // is 2, the property `which` does not represent an emoji correctly.\n        // In such a case, we directly return the `char` property instead of\n        // using `which`.\n        if (nativeEvent.char && nativeEvent.char.length > 1) {\n          return nativeEvent.char;\n        } else if (nativeEvent.which) {\n          return String.fromCharCode(nativeEvent.which);\n        }\n      }\n\n      return null;\n\n    case 'compositionend':\n      return useFallbackCompositionData && !isUsingKoreanIME(nativeEvent) ? null : nativeEvent.data;\n\n    default:\n      return null;\n  }\n}\n/**\n * Extract a SyntheticInputEvent for `beforeInput`, based on either native\n * `textInput` or fallback behavior.\n *\n * @return {?object} A SyntheticInputEvent.\n */\n\n\nfunction extractBeforeInputEvent(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget) {\n  let chars;\n\n  if (canUseTextInputEvent) {\n    chars = getNativeBeforeInputChars(domEventName, nativeEvent);\n  } else {\n    chars = getFallbackBeforeInputChars(domEventName, nativeEvent);\n  } // If no characters are being inserted, no BeforeInput event should\n  // be fired.\n\n\n  if (!chars) {\n    return null;\n  }\n\n  const listeners = accumulateTwoPhaseListeners(targetInst, 'onBeforeInput');\n\n  if (listeners.length > 0) {\n    const event = new SyntheticInputEvent('onBeforeInput', 'beforeinput', null, nativeEvent, nativeEventTarget);\n    dispatchQueue.push({\n      event,\n      listeners\n    });\n    event.data = chars;\n  }\n}\n/**\n * Create an `onBeforeInput` event to match\n * http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105/#events-inputevents.\n *\n * This event plugin is based on the native `textInput` event\n * available in Chrome, Safari, Opera, and IE. This event fires after\n * `onKeyPress` and `onCompositionEnd`, but before `onInput`.\n *\n * `beforeInput` is spec'd but not implemented in any browsers, and\n * the `input` event does not provide any useful information about what has\n * actually been added, contrary to the spec. Thus, `textInput` is the best\n * available event to identify the characters that have actually been inserted\n * into the target node.\n *\n * This plugin is also responsible for emitting `composition` events, thus\n * allowing us to share composition fallback code for both `beforeInput` and\n * `composition` event types.\n */\n\n\nfunction extractEvents(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags, targetContainer) {\n  extractCompositionEvent(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget);\n  extractBeforeInputEvent(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget);\n}\n\n/**\n * @see http://www.whatwg.org/specs/web-apps/current-work/multipage/the-input-element.html#input-type-attr-summary\n */\nconst supportedInputTypes = {\n  color: true,\n  date: true,\n  datetime: true,\n  'datetime-local': true,\n  email: true,\n  month: true,\n  number: true,\n  password: true,\n  range: true,\n  search: true,\n  tel: true,\n  text: true,\n  time: true,\n  url: true,\n  week: true\n};\n\nfunction isTextInputElement(elem) {\n  const nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();\n\n  if (nodeName === 'input') {\n    return !!supportedInputTypes[elem.type];\n  }\n\n  if (nodeName === 'textarea') {\n    return true;\n  }\n\n  return false;\n}\n\n/**\n * Checks if an event is supported in the current execution environment.\n *\n * NOTE: This will not work correctly for non-generic events such as `change`,\n * `reset`, `load`, `error`, and `select`.\n *\n * Borrows from Modernizr.\n *\n * @param {string} eventNameSuffix Event name, e.g. \"click\".\n * @return {boolean} True if the event is supported.\n * @internal\n * @license Modernizr 3.0.0pre (Custom Build) | MIT\n */\n\nfunction isEventSupported(eventNameSuffix) {\n  if (!canUseDOM) {\n    return false;\n  }\n\n  const eventName = 'on' + eventNameSuffix;\n  let isSupported = (eventName in document);\n\n  if (!isSupported) {\n    const element = document.createElement('div');\n    element.setAttribute(eventName, 'return;');\n    isSupported = typeof element[eventName] === 'function';\n  }\n\n  return isSupported;\n}\n\nfunction registerEvents$1() {\n  registerTwoPhaseEvent('onChange', ['change', 'click', 'focusin', 'focusout', 'input', 'keydown', 'keyup', 'selectionchange']);\n}\n\nfunction createAndAccumulateChangeEvent(dispatchQueue, inst, nativeEvent, target) {\n  // Flag this event loop as needing state restore.\n  enqueueStateRestore(target);\n  const listeners = accumulateTwoPhaseListeners(inst, 'onChange');\n\n  if (listeners.length > 0) {\n    const event = new SyntheticEvent('onChange', 'change', null, nativeEvent, target);\n    dispatchQueue.push({\n      event,\n      listeners\n    });\n  }\n}\n/**\n * For IE shims\n */\n\n\nlet activeElement = null;\nlet activeElementInst = null;\n/**\n * SECTION: handle `change` event\n */\n\nfunction shouldUseChangeEvent(elem) {\n  const nodeName = elem.nodeName && elem.nodeName.toLowerCase();\n  return nodeName === 'select' || nodeName === 'input' && elem.type === 'file';\n}\n\nfunction manualDispatchChangeEvent(nativeEvent) {\n  const dispatchQueue = [];\n  createAndAccumulateChangeEvent(dispatchQueue, activeElementInst, nativeEvent, getEventTarget(nativeEvent)); // If change and propertychange bubbled, we'd just bind to it like all the\n  // other events and have it go through ReactBrowserEventEmitter. Since it\n  // doesn't, we manually listen for the events and so we have to enqueue and\n  // process the abstract event manually.\n  //\n  // Batching is necessary here in order to ensure that all event handlers run\n  // before the next rerender (including event handlers attached to ancestor\n  // elements instead of directly on the input). Without this, controlled\n  // components don't work properly in conjunction with event bubbling because\n  // the component is rerendered and the value reverted before all the event\n  // handlers can run. See https://github.com/facebook/react/issues/708.\n\n  batchedUpdates(runEventInBatch, dispatchQueue);\n}\n\nfunction runEventInBatch(dispatchQueue) {\n  processDispatchQueue(dispatchQueue, 0);\n}\n\nfunction getInstIfValueChanged(targetInst) {\n  const targetNode = getNodeFromInstance(targetInst);\n\n  if (updateValueIfChanged(targetNode)) {\n    return targetInst;\n  }\n}\n\nfunction getTargetInstForChangeEvent(domEventName, targetInst) {\n  if (domEventName === 'change') {\n    return targetInst;\n  }\n}\n/**\n * SECTION: handle `input` event\n */\n\n\nlet isInputEventSupported = false;\n\nif (canUseDOM) {\n  // IE9 claims to support the input event but fails to trigger it when\n  // deleting text, so we ignore its input events.\n  isInputEventSupported = isEventSupported('input') && (!document.documentMode || document.documentMode > 9);\n}\n/**\n * (For IE <=9) Starts tracking propertychange events on the passed-in element\n * and override the value property so that we can distinguish user events from\n * value changes in JS.\n */\n\n\nfunction startWatchingForValueChange(target, targetInst) {\n  activeElement = target;\n  activeElementInst = targetInst;\n  activeElement.attachEvent('onpropertychange', handlePropertyChange);\n}\n/**\n * (For IE <=9) Removes the event listeners from the currently-tracked element,\n * if any exists.\n */\n\n\nfunction stopWatchingForValueChange() {\n  if (!activeElement) {\n    return;\n  }\n\n  activeElement.detachEvent('onpropertychange', handlePropertyChange);\n  activeElement = null;\n  activeElementInst = null;\n}\n/**\n * (For IE <=9) Handles a propertychange event, sending a `change` event if\n * the value of the active element has changed.\n */\n\n\nfunction handlePropertyChange(nativeEvent) {\n  if (nativeEvent.propertyName !== 'value') {\n    return;\n  }\n\n  if (getInstIfValueChanged(activeElementInst)) {\n    manualDispatchChangeEvent(nativeEvent);\n  }\n}\n\nfunction handleEventsForInputEventPolyfill(domEventName, target, targetInst) {\n  if (domEventName === 'focusin') {\n    // In IE9, propertychange fires for most input events but is buggy and\n    // doesn't fire when text is deleted, but conveniently, selectionchange\n    // appears to fire in all of the remaining cases so we catch those and\n    // forward the event if the value has changed\n    // In either case, we don't want to call the event handler if the value\n    // is changed from JS so we redefine a setter for `.value` that updates\n    // our activeElementValue variable, allowing us to ignore those changes\n    //\n    // stopWatching() should be a noop here but we call it just in case we\n    // missed a blur event somehow.\n    stopWatchingForValueChange();\n    startWatchingForValueChange(target, targetInst);\n  } else if (domEventName === 'focusout') {\n    stopWatchingForValueChange();\n  }\n} // For IE8 and IE9.\n\n\nfunction getTargetInstForInputEventPolyfill(domEventName, targetInst) {\n  if (domEventName === 'selectionchange' || domEventName === 'keyup' || domEventName === 'keydown') {\n    // On the selectionchange event, the target is just document which isn't\n    // helpful for us so just check activeElement instead.\n    //\n    // 99% of the time, keydown and keyup aren't necessary. IE8 fails to fire\n    // propertychange on the first input event after setting `value` from a\n    // script and fires only keydown, keypress, keyup. Catching keyup usually\n    // gets it and catching keydown lets us fire an event for the first\n    // keystroke if user does a key repeat (it'll be a little delayed: right\n    // before the second keystroke). Other input methods (e.g., paste) seem to\n    // fire selectionchange normally.\n    return getInstIfValueChanged(activeElementInst);\n  }\n}\n/**\n * SECTION: handle `click` event\n */\n\n\nfunction shouldUseClickEvent(elem) {\n  // Use the `click` event to detect changes to checkbox and radio inputs.\n  // This approach works across all browsers, whereas `change` does not fire\n  // until `blur` in IE8.\n  const nodeName = elem.nodeName;\n  return nodeName && nodeName.toLowerCase() === 'input' && (elem.type === 'checkbox' || elem.type === 'radio');\n}\n\nfunction getTargetInstForClickEvent(domEventName, targetInst) {\n  if (domEventName === 'click') {\n    return getInstIfValueChanged(targetInst);\n  }\n}\n\nfunction getTargetInstForInputOrChangeEvent(domEventName, targetInst) {\n  if (domEventName === 'input' || domEventName === 'change') {\n    return getInstIfValueChanged(targetInst);\n  }\n}\n\nfunction handleControlledInputBlur(node) {\n  const state = node._wrapperState;\n\n  if (!state || !state.controlled || node.type !== 'number') {\n    return;\n  }\n\n  {\n    // If controlled, assign the value attribute to the current value on blur\n    setDefaultValue(node, 'number', node.value);\n  }\n}\n/**\n * This plugin creates an `onChange` event that normalizes change events\n * across form elements. This event fires at a time when it's possible to\n * change the element's value without seeing a flicker.\n *\n * Supported elements are:\n * - input (see `isTextInputElement`)\n * - textarea\n * - select\n */\n\n\nfunction extractEvents$1(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags, targetContainer) {\n  const targetNode = targetInst ? getNodeFromInstance(targetInst) : window;\n  let getTargetInstFunc, handleEventFunc;\n\n  if (shouldUseChangeEvent(targetNode)) {\n    getTargetInstFunc = getTargetInstForChangeEvent;\n  } else if (isTextInputElement(targetNode)) {\n    if (isInputEventSupported) {\n      getTargetInstFunc = getTargetInstForInputOrChangeEvent;\n    } else {\n      getTargetInstFunc = getTargetInstForInputEventPolyfill;\n      handleEventFunc = handleEventsForInputEventPolyfill;\n    }\n  } else if (shouldUseClickEvent(targetNode)) {\n    getTargetInstFunc = getTargetInstForClickEvent;\n  }\n\n  if (getTargetInstFunc) {\n    const inst = getTargetInstFunc(domEventName, targetInst);\n\n    if (inst) {\n      createAndAccumulateChangeEvent(dispatchQueue, inst, nativeEvent, nativeEventTarget);\n      return;\n    }\n  }\n\n  if (handleEventFunc) {\n    handleEventFunc(domEventName, targetNode, targetInst);\n  } // When blurring, set the value attribute for number inputs\n\n\n  if (domEventName === 'focusout') {\n    handleControlledInputBlur(targetNode);\n  }\n}\n\nfunction registerEvents$2() {\n  registerDirectEvent('onMouseEnter', ['mouseout', 'mouseover']);\n  registerDirectEvent('onMouseLeave', ['mouseout', 'mouseover']);\n  registerDirectEvent('onPointerEnter', ['pointerout', 'pointerover']);\n  registerDirectEvent('onPointerLeave', ['pointerout', 'pointerover']);\n}\n/**\n * For almost every interaction we care about, there will be both a top-level\n * `mouseover` and `mouseout` event that occurs. Only use `mouseout` so that\n * we do not extract duplicate events. However, moving the mouse into the\n * browser from outside will not fire a `mouseout` event. In this case, we use\n * the `mouseover` top-level event.\n */\n\n\nfunction extractEvents$2(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags, targetContainer) {\n  const isOverEvent = domEventName === 'mouseover' || domEventName === 'pointerover';\n  const isOutEvent = domEventName === 'mouseout' || domEventName === 'pointerout';\n\n  if (isOverEvent && !isReplayingEvent(nativeEvent)) {\n    // If this is an over event with a target, we might have already dispatched\n    // the event in the out event of the other target. If this is replayed,\n    // then it's because we couldn't dispatch against this target previously\n    // so we have to do it now instead.\n    const related = nativeEvent.relatedTarget || nativeEvent.fromElement;\n\n    if (related) {\n      // If the related node is managed by React, we can assume that we have\n      // already dispatched the corresponding events during its mouseout.\n      if (getClosestInstanceFromNode(related) || isContainerMarkedAsRoot(related)) {\n        return;\n      }\n    }\n  }\n\n  if (!isOutEvent && !isOverEvent) {\n    // Must not be a mouse or pointer in or out - ignoring.\n    return;\n  }\n\n  let win; // TODO: why is this nullable in the types but we read from it?\n\n  if (nativeEventTarget.window === nativeEventTarget) {\n    // `nativeEventTarget` is probably a window object.\n    win = nativeEventTarget;\n  } else {\n    // TODO: Figure out why `ownerDocument` is sometimes undefined in IE8.\n    const doc = nativeEventTarget.ownerDocument;\n\n    if (doc) {\n      win = doc.defaultView || doc.parentWindow;\n    } else {\n      win = window;\n    }\n  }\n\n  let from;\n  let to;\n\n  if (isOutEvent) {\n    const related = nativeEvent.relatedTarget || nativeEvent.toElement;\n    from = targetInst;\n    to = related ? getClosestInstanceFromNode(related) : null;\n\n    if (to !== null) {\n      const nearestMounted = getNearestMountedFiber(to);\n\n      if (to !== nearestMounted || to.tag !== HostComponent && to.tag !== HostText) {\n        to = null;\n      }\n    }\n  } else {\n    // Moving to a node from outside the window.\n    from = null;\n    to = targetInst;\n  }\n\n  if (from === to) {\n    // Nothing pertains to our managed components.\n    return;\n  }\n\n  let SyntheticEventCtor = SyntheticMouseEvent;\n  let leaveEventType = 'onMouseLeave';\n  let enterEventType = 'onMouseEnter';\n  let eventTypePrefix = 'mouse';\n\n  if (domEventName === 'pointerout' || domEventName === 'pointerover') {\n    SyntheticEventCtor = SyntheticPointerEvent;\n    leaveEventType = 'onPointerLeave';\n    enterEventType = 'onPointerEnter';\n    eventTypePrefix = 'pointer';\n  }\n\n  const fromNode = from == null ? win : getNodeFromInstance(from);\n  const toNode = to == null ? win : getNodeFromInstance(to);\n  const leave = new SyntheticEventCtor(leaveEventType, eventTypePrefix + 'leave', from, nativeEvent, nativeEventTarget);\n  leave.target = fromNode;\n  leave.relatedTarget = toNode;\n  let enter = null; // We should only process this nativeEvent if we are processing\n  // the first ancestor. Next time, we will ignore the event.\n\n  const nativeTargetInst = getClosestInstanceFromNode(nativeEventTarget);\n\n  if (nativeTargetInst === targetInst) {\n    const enterEvent = new SyntheticEventCtor(enterEventType, eventTypePrefix + 'enter', to, nativeEvent, nativeEventTarget);\n    enterEvent.target = toNode;\n    enterEvent.relatedTarget = fromNode;\n    enter = enterEvent;\n  }\n\n  accumulateEnterLeaveTwoPhaseListeners(dispatchQueue, leave, enter, from, to);\n}\n\n/**\n * inlined Object.is polyfill to avoid requiring consumers ship their own\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is\n */\nfunction is(x, y) {\n  return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y // eslint-disable-line no-self-compare\n  ;\n}\n\nconst objectIs = typeof Object.is === 'function' ? Object.is : is;\n\n/**\n * Performs equality by iterating through keys on an object and returning false\n * when any key has values which are not strictly equal between the arguments.\n * Returns true when the values of all keys are strictly equal.\n */\n\nfunction shallowEqual(objA, objB) {\n  if (objectIs(objA, objB)) {\n    return true;\n  }\n\n  if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null) {\n    return false;\n  }\n\n  const keysA = Object.keys(objA);\n  const keysB = Object.keys(objB);\n\n  if (keysA.length !== keysB.length) {\n    return false;\n  } // Test for A's keys different from B.\n\n\n  for (let i = 0; i < keysA.length; i++) {\n    const currentKey = keysA[i];\n\n    if (!hasOwnProperty.call(objB, currentKey) || !objectIs(objA[currentKey], objB[currentKey])) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\n/**\n * Given any node return the first leaf node without children.\n *\n * @param {DOMElement|DOMTextNode} node\n * @return {DOMElement|DOMTextNode}\n */\n\nfunction getLeafNode(node) {\n  while (node && node.firstChild) {\n    node = node.firstChild;\n  }\n\n  return node;\n}\n/**\n * Get the next sibling within a container. This will walk up the\n * DOM if a node's siblings have been exhausted.\n *\n * @param {DOMElement|DOMTextNode} node\n * @return {?DOMElement|DOMTextNode}\n */\n\n\nfunction getSiblingNode(node) {\n  while (node) {\n    if (node.nextSibling) {\n      return node.nextSibling;\n    }\n\n    node = node.parentNode;\n  }\n}\n/**\n * Get object describing the nodes which contain characters at offset.\n *\n * @param {DOMElement|DOMTextNode} root\n * @param {number} offset\n * @return {?object}\n */\n\n\nfunction getNodeForCharacterOffset(root, offset) {\n  let node = getLeafNode(root);\n  let nodeStart = 0;\n  let nodeEnd = 0;\n\n  while (node) {\n    if (node.nodeType === TEXT_NODE) {\n      nodeEnd = nodeStart + node.textContent.length;\n\n      if (nodeStart <= offset && nodeEnd >= offset) {\n        return {\n          node: node,\n          offset: offset - nodeStart\n        };\n      }\n\n      nodeStart = nodeEnd;\n    }\n\n    node = getLeafNode(getSiblingNode(node));\n  }\n}\n\n/**\n * @param {DOMElement} outerNode\n * @return {?object}\n */\n\nfunction getOffsets(outerNode) {\n  const ownerDocument = outerNode.ownerDocument;\n  const win = ownerDocument && ownerDocument.defaultView || window;\n  const selection = win.getSelection && win.getSelection();\n\n  if (!selection || selection.rangeCount === 0) {\n    return null;\n  }\n\n  const anchorNode = selection.anchorNode,\n        anchorOffset = selection.anchorOffset,\n        focusNode = selection.focusNode,\n        focusOffset = selection.focusOffset; // In Firefox, anchorNode and focusNode can be \"anonymous divs\", e.g. the\n  // up/down buttons on an <input type=\"number\">. Anonymous divs do not seem to\n  // expose properties, triggering a \"Permission denied error\" if any of its\n  // properties are accessed. The only seemingly possible way to avoid erroring\n  // is to access a property that typically works for non-anonymous divs and\n  // catch any error that may otherwise arise. See\n  // https://bugzilla.mozilla.org/show_bug.cgi?id=208427\n\n  try {\n    /* eslint-disable no-unused-expressions */\n    anchorNode.nodeType;\n    focusNode.nodeType;\n    /* eslint-enable no-unused-expressions */\n  } catch (e) {\n    return null;\n  }\n\n  return getModernOffsetsFromPoints(outerNode, anchorNode, anchorOffset, focusNode, focusOffset);\n}\n/**\n * Returns {start, end} where `start` is the character/codepoint index of\n * (anchorNode, anchorOffset) within the textContent of `outerNode`, and\n * `end` is the index of (focusNode, focusOffset).\n *\n * Returns null if you pass in garbage input but we should probably just crash.\n *\n * Exported only for testing.\n */\n\nfunction getModernOffsetsFromPoints(outerNode, anchorNode, anchorOffset, focusNode, focusOffset) {\n  let length = 0;\n  let start = -1;\n  let end = -1;\n  let indexWithinAnchor = 0;\n  let indexWithinFocus = 0;\n  let node = outerNode;\n  let parentNode = null;\n\n  outer: while (true) {\n    let next = null;\n\n    while (true) {\n      if (node === anchorNode && (anchorOffset === 0 || node.nodeType === TEXT_NODE)) {\n        start = length + anchorOffset;\n      }\n\n      if (node === focusNode && (focusOffset === 0 || node.nodeType === TEXT_NODE)) {\n        end = length + focusOffset;\n      }\n\n      if (node.nodeType === TEXT_NODE) {\n        length += node.nodeValue.length;\n      }\n\n      if ((next = node.firstChild) === null) {\n        break;\n      } // Moving from `node` to its first child `next`.\n\n\n      parentNode = node;\n      node = next;\n    }\n\n    while (true) {\n      if (node === outerNode) {\n        // If `outerNode` has children, this is always the second time visiting\n        // it. If it has no children, this is still the first loop, and the only\n        // valid selection is anchorNode and focusNode both equal to this node\n        // and both offsets 0, in which case we will have handled above.\n        break outer;\n      }\n\n      if (parentNode === anchorNode && ++indexWithinAnchor === anchorOffset) {\n        start = length;\n      }\n\n      if (parentNode === focusNode && ++indexWithinFocus === focusOffset) {\n        end = length;\n      }\n\n      if ((next = node.nextSibling) !== null) {\n        break;\n      }\n\n      node = parentNode;\n      parentNode = node.parentNode;\n    } // Moving from `node` to its next sibling `next`.\n\n\n    node = next;\n  }\n\n  if (start === -1 || end === -1) {\n    // This should never happen. (Would happen if the anchor/focus nodes aren't\n    // actually inside the passed-in node.)\n    return null;\n  }\n\n  return {\n    start: start,\n    end: end\n  };\n}\n/**\n * In modern non-IE browsers, we can support both forward and backward\n * selections.\n *\n * Note: IE10+ supports the Selection object, but it does not support\n * the `extend` method, which means that even in modern IE, it's not possible\n * to programmatically create a backward selection. Thus, for all IE\n * versions, we use the old IE API to create our selections.\n *\n * @param {DOMElement|DOMTextNode} node\n * @param {object} offsets\n */\n\nfunction setOffsets(node, offsets) {\n  const doc = node.ownerDocument || document;\n  const win = doc && doc.defaultView || window; // Edge fails with \"Object expected\" in some scenarios.\n  // (For instance: TinyMCE editor used in a list component that supports pasting to add more,\n  // fails when pasting 100+ items)\n\n  if (!win.getSelection) {\n    return;\n  }\n\n  const selection = win.getSelection();\n  const length = node.textContent.length;\n  let start = Math.min(offsets.start, length);\n  let end = offsets.end === undefined ? start : Math.min(offsets.end, length); // IE 11 uses modern selection, but doesn't support the extend method.\n  // Flip backward selections, so we can set with a single range.\n\n  if (!selection.extend && start > end) {\n    const temp = end;\n    end = start;\n    start = temp;\n  }\n\n  const startMarker = getNodeForCharacterOffset(node, start);\n  const endMarker = getNodeForCharacterOffset(node, end);\n\n  if (startMarker && endMarker) {\n    if (selection.rangeCount === 1 && selection.anchorNode === startMarker.node && selection.anchorOffset === startMarker.offset && selection.focusNode === endMarker.node && selection.focusOffset === endMarker.offset) {\n      return;\n    }\n\n    const range = doc.createRange();\n    range.setStart(startMarker.node, startMarker.offset);\n    selection.removeAllRanges();\n\n    if (start > end) {\n      selection.addRange(range);\n      selection.extend(endMarker.node, endMarker.offset);\n    } else {\n      range.setEnd(endMarker.node, endMarker.offset);\n      selection.addRange(range);\n    }\n  }\n}\n\nfunction isTextNode(node) {\n  return node && node.nodeType === TEXT_NODE;\n}\n\nfunction containsNode(outerNode, innerNode) {\n  if (!outerNode || !innerNode) {\n    return false;\n  } else if (outerNode === innerNode) {\n    return true;\n  } else if (isTextNode(outerNode)) {\n    return false;\n  } else if (isTextNode(innerNode)) {\n    return containsNode(outerNode, innerNode.parentNode);\n  } else if ('contains' in outerNode) {\n    return outerNode.contains(innerNode);\n  } else if (outerNode.compareDocumentPosition) {\n    return !!(outerNode.compareDocumentPosition(innerNode) & 16);\n  } else {\n    return false;\n  }\n}\n\nfunction isInDocument(node) {\n  return node && node.ownerDocument && containsNode(node.ownerDocument.documentElement, node);\n}\n\nfunction isSameOriginFrame(iframe) {\n  try {\n    // Accessing the contentDocument of a HTMLIframeElement can cause the browser\n    // to throw, e.g. if it has a cross-origin src attribute.\n    // Safari will show an error in the console when the access results in \"Blocked a frame with origin\". e.g:\n    // iframe.contentDocument.defaultView;\n    // A safety way is to access one of the cross origin properties: Window or Location\n    // Which might result in \"SecurityError\" DOM Exception and it is compatible to Safari.\n    // https://html.spec.whatwg.org/multipage/browsers.html#integration-with-idl\n    return typeof iframe.contentWindow.location.href === 'string';\n  } catch (err) {\n    return false;\n  }\n}\n\nfunction getActiveElementDeep() {\n  let win = window;\n  let element = getActiveElement();\n\n  while (element instanceof win.HTMLIFrameElement) {\n    if (isSameOriginFrame(element)) {\n      win = element.contentWindow;\n    } else {\n      return element;\n    }\n\n    element = getActiveElement(win.document);\n  }\n\n  return element;\n}\n/**\n * @ReactInputSelection: React input selection module. Based on Selection.js,\n * but modified to be suitable for react and has a couple of bug fixes (doesn't\n * assume buttons have range selections allowed).\n * Input selection module for React.\n */\n\n/**\n * @hasSelectionCapabilities: we get the element types that support selection\n * from https://html.spec.whatwg.org/#do-not-apply, looking at `selectionStart`\n * and `selectionEnd` rows.\n */\n\n\nfunction hasSelectionCapabilities(elem) {\n  const nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();\n  return nodeName && (nodeName === 'input' && (elem.type === 'text' || elem.type === 'search' || elem.type === 'tel' || elem.type === 'url' || elem.type === 'password') || nodeName === 'textarea' || elem.contentEditable === 'true');\n}\nfunction getSelectionInformation() {\n  const focusedElem = getActiveElementDeep();\n  return {\n    focusedElem: focusedElem,\n    selectionRange: hasSelectionCapabilities(focusedElem) ? getSelection(focusedElem) : null\n  };\n}\n/**\n * @restoreSelection: If any selection information was potentially lost,\n * restore it. This is useful when performing operations that could remove dom\n * nodes and place them back in, resulting in focus being lost.\n */\n\nfunction restoreSelection(priorSelectionInformation) {\n  const curFocusedElem = getActiveElementDeep();\n  const priorFocusedElem = priorSelectionInformation.focusedElem;\n  const priorSelectionRange = priorSelectionInformation.selectionRange;\n\n  if (curFocusedElem !== priorFocusedElem && isInDocument(priorFocusedElem)) {\n    if (priorSelectionRange !== null && hasSelectionCapabilities(priorFocusedElem)) {\n      setSelection(priorFocusedElem, priorSelectionRange);\n    } // Focusing a node can change the scroll position, which is undesirable\n\n\n    const ancestors = [];\n    let ancestor = priorFocusedElem;\n\n    while (ancestor = ancestor.parentNode) {\n      if (ancestor.nodeType === ELEMENT_NODE) {\n        ancestors.push({\n          element: ancestor,\n          left: ancestor.scrollLeft,\n          top: ancestor.scrollTop\n        });\n      }\n    }\n\n    if (typeof priorFocusedElem.focus === 'function') {\n      priorFocusedElem.focus();\n    }\n\n    for (let i = 0; i < ancestors.length; i++) {\n      const info = ancestors[i];\n      info.element.scrollLeft = info.left;\n      info.element.scrollTop = info.top;\n    }\n  }\n}\n/**\n * @getSelection: Gets the selection bounds of a focused textarea, input or\n * contentEditable node.\n * -@input: Look up selection bounds of this input\n * -@return {start: selectionStart, end: selectionEnd}\n */\n\nfunction getSelection(input) {\n  let selection;\n\n  if ('selectionStart' in input) {\n    // Modern browser with input or textarea.\n    selection = {\n      start: input.selectionStart,\n      end: input.selectionEnd\n    };\n  } else {\n    // Content editable or old IE textarea.\n    selection = getOffsets(input);\n  }\n\n  return selection || {\n    start: 0,\n    end: 0\n  };\n}\n/**\n * @setSelection: Sets the selection bounds of a textarea or input and focuses\n * the input.\n * -@input     Set selection bounds of this input or textarea\n * -@offsets   Object of same form that is returned from get*\n */\n\nfunction setSelection(input, offsets) {\n  const start = offsets.start;\n  let end = offsets.end;\n\n  if (end === undefined) {\n    end = start;\n  }\n\n  if ('selectionStart' in input) {\n    input.selectionStart = start;\n    input.selectionEnd = Math.min(end, input.value.length);\n  } else {\n    setOffsets(input, offsets);\n  }\n}\n\nconst skipSelectionChangeEvent = canUseDOM && 'documentMode' in document && document.documentMode <= 11;\n\nfunction registerEvents$3() {\n  registerTwoPhaseEvent('onSelect', ['focusout', 'contextmenu', 'dragend', 'focusin', 'keydown', 'keyup', 'mousedown', 'mouseup', 'selectionchange']);\n}\n\nlet activeElement$1 = null;\nlet activeElementInst$1 = null;\nlet lastSelection = null;\nlet mouseDown = false;\n/**\n * Get an object which is a unique representation of the current selection.\n *\n * The return value will not be consistent across nodes or browsers, but\n * two identical selections on the same node will return identical objects.\n */\n\nfunction getSelection$1(node) {\n  if ('selectionStart' in node && hasSelectionCapabilities(node)) {\n    return {\n      start: node.selectionStart,\n      end: node.selectionEnd\n    };\n  } else {\n    const win = node.ownerDocument && node.ownerDocument.defaultView || window;\n    const selection = win.getSelection();\n    return {\n      anchorNode: selection.anchorNode,\n      anchorOffset: selection.anchorOffset,\n      focusNode: selection.focusNode,\n      focusOffset: selection.focusOffset\n    };\n  }\n}\n/**\n * Get document associated with the event target.\n */\n\n\nfunction getEventTargetDocument(eventTarget) {\n  return eventTarget.window === eventTarget ? eventTarget.document : eventTarget.nodeType === DOCUMENT_NODE ? eventTarget : eventTarget.ownerDocument;\n}\n/**\n * Poll selection to see whether it's changed.\n *\n * @param {object} nativeEvent\n * @param {object} nativeEventTarget\n * @return {?SyntheticEvent}\n */\n\n\nfunction constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget) {\n  // Ensure we have the right element, and that the user is not dragging a\n  // selection (this matches native `select` event behavior). In HTML5, select\n  // fires only on input and textarea thus if there's no focused element we\n  // won't dispatch.\n  const doc = getEventTargetDocument(nativeEventTarget);\n\n  if (mouseDown || activeElement$1 == null || activeElement$1 !== getActiveElement(doc)) {\n    return;\n  } // Only fire when selection has actually changed.\n\n\n  const currentSelection = getSelection$1(activeElement$1);\n\n  if (!lastSelection || !shallowEqual(lastSelection, currentSelection)) {\n    lastSelection = currentSelection;\n    const listeners = accumulateTwoPhaseListeners(activeElementInst$1, 'onSelect');\n\n    if (listeners.length > 0) {\n      const event = new SyntheticEvent('onSelect', 'select', null, nativeEvent, nativeEventTarget);\n      dispatchQueue.push({\n        event,\n        listeners\n      });\n      event.target = activeElement$1;\n    }\n  }\n}\n/**\n * This plugin creates an `onSelect` event that normalizes select events\n * across form elements.\n *\n * Supported elements are:\n * - input (see `isTextInputElement`)\n * - textarea\n * - contentEditable\n *\n * This differs from native browser implementations in the following ways:\n * - Fires on contentEditable fields as well as inputs.\n * - Fires for collapsed selection.\n * - Fires after user input.\n */\n\n\nfunction extractEvents$3(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags, targetContainer) {\n  const targetNode = targetInst ? getNodeFromInstance(targetInst) : window;\n\n  switch (domEventName) {\n    // Track the input node that has focus.\n    case 'focusin':\n      if (isTextInputElement(targetNode) || targetNode.contentEditable === 'true') {\n        activeElement$1 = targetNode;\n        activeElementInst$1 = targetInst;\n        lastSelection = null;\n      }\n\n      break;\n\n    case 'focusout':\n      activeElement$1 = null;\n      activeElementInst$1 = null;\n      lastSelection = null;\n      break;\n    // Don't fire the event while the user is dragging. This matches the\n    // semantics of the native select event.\n\n    case 'mousedown':\n      mouseDown = true;\n      break;\n\n    case 'contextmenu':\n    case 'mouseup':\n    case 'dragend':\n      mouseDown = false;\n      constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);\n      break;\n    // Chrome and IE fire non-standard event when selection is changed (and\n    // sometimes when it hasn't). IE's event fires out of order with respect\n    // to key and input events on deletion, so we discard it.\n    //\n    // Firefox doesn't support selectionchange, so check selection status\n    // after each key entry. The selection changes after keydown and before\n    // keyup, but we check on keydown as well in the case of holding down a\n    // key, when multiple keydown events are fired but only one keyup is.\n    // This is also our approach for IE handling, for the reason above.\n\n    case 'selectionchange':\n      if (skipSelectionChangeEvent) {\n        break;\n      }\n\n    // falls through\n\n    case 'keydown':\n    case 'keyup':\n      constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);\n  }\n}\n\n/**\n * Generate a mapping of standard vendor prefixes using the defined style property and event name.\n *\n * @param {string} styleProp\n * @param {string} eventName\n * @returns {object}\n */\n\nfunction makePrefixMap(styleProp, eventName) {\n  const prefixes = {};\n  prefixes[styleProp.toLowerCase()] = eventName.toLowerCase();\n  prefixes['Webkit' + styleProp] = 'webkit' + eventName;\n  prefixes['Moz' + styleProp] = 'moz' + eventName;\n  return prefixes;\n}\n/**\n * A list of event names to a configurable list of vendor prefixes.\n */\n\n\nconst vendorPrefixes = {\n  animationend: makePrefixMap('Animation', 'AnimationEnd'),\n  animationiteration: makePrefixMap('Animation', 'AnimationIteration'),\n  animationstart: makePrefixMap('Animation', 'AnimationStart'),\n  transitionend: makePrefixMap('Transition', 'TransitionEnd')\n};\n/**\n * Event names that have already been detected and prefixed (if applicable).\n */\n\nconst prefixedEventNames = {};\n/**\n * Element to check for prefixes on.\n */\n\nlet style = {};\n/**\n * Bootstrap if a DOM exists.\n */\n\nif (canUseDOM) {\n  style = document.createElement('div').style; // On some platforms, in particular some releases of Android 4.x,\n  // the un-prefixed \"animation\" and \"transition\" properties are defined on the\n  // style object but the events that fire will still be prefixed, so we need\n  // to check if the un-prefixed events are usable, and if not remove them from the map.\n\n  if (!('AnimationEvent' in window)) {\n    delete vendorPrefixes.animationend.animation;\n    delete vendorPrefixes.animationiteration.animation;\n    delete vendorPrefixes.animationstart.animation;\n  } // Same as above\n\n\n  if (!('TransitionEvent' in window)) {\n    delete vendorPrefixes.transitionend.transition;\n  }\n}\n/**\n * Attempts to determine the correct vendor prefixed event name.\n *\n * @param {string} eventName\n * @returns {string}\n */\n\n\nfunction getVendorPrefixedEventName(eventName) {\n  if (prefixedEventNames[eventName]) {\n    return prefixedEventNames[eventName];\n  } else if (!vendorPrefixes[eventName]) {\n    return eventName;\n  }\n\n  const prefixMap = vendorPrefixes[eventName];\n\n  for (const styleProp in prefixMap) {\n    if (prefixMap.hasOwnProperty(styleProp) && styleProp in style) {\n      return prefixedEventNames[eventName] = prefixMap[styleProp];\n    }\n  }\n\n  return eventName;\n}\n\nconst ANIMATION_END = getVendorPrefixedEventName('animationend');\nconst ANIMATION_ITERATION = getVendorPrefixedEventName('animationiteration');\nconst ANIMATION_START = getVendorPrefixedEventName('animationstart');\nconst TRANSITION_END = getVendorPrefixedEventName('transitionend');\n\nconst topLevelEventsToReactNames = new Map(); // NOTE: Capitalization is important in this list!\n//\n// E.g. it needs \"pointerDown\", not \"pointerdown\".\n// This is because we derive both React name (\"onPointerDown\")\n// and DOM name (\"pointerdown\") from the same list.\n//\n// Exceptions that don't match this convention are listed separately.\n//\n// prettier-ignore\n\nconst simpleEventPluginEvents = ['abort', 'auxClick', 'cancel', 'canPlay', 'canPlayThrough', 'click', 'close', 'contextMenu', 'copy', 'cut', 'drag', 'dragEnd', 'dragEnter', 'dragExit', 'dragLeave', 'dragOver', 'dragStart', 'drop', 'durationChange', 'emptied', 'encrypted', 'ended', 'error', 'gotPointerCapture', 'input', 'invalid', 'keyDown', 'keyPress', 'keyUp', 'load', 'loadedData', 'loadedMetadata', 'loadStart', 'lostPointerCapture', 'mouseDown', 'mouseMove', 'mouseOut', 'mouseOver', 'mouseUp', 'paste', 'pause', 'play', 'playing', 'pointerCancel', 'pointerDown', 'pointerMove', 'pointerOut', 'pointerOver', 'pointerUp', 'progress', 'rateChange', 'reset', 'resize', 'seeked', 'seeking', 'stalled', 'submit', 'suspend', 'timeUpdate', 'touchCancel', 'touchEnd', 'touchStart', 'volumeChange', 'scroll', 'toggle', 'touchMove', 'waiting', 'wheel'];\n\nfunction registerSimpleEvent(domEventName, reactName) {\n  topLevelEventsToReactNames.set(domEventName, reactName);\n  registerTwoPhaseEvent(reactName, [domEventName]);\n}\n\nfunction registerSimpleEvents() {\n  for (let i = 0; i < simpleEventPluginEvents.length; i++) {\n    const eventName = simpleEventPluginEvents[i];\n    const domEventName = eventName.toLowerCase();\n    const capitalizedEvent = eventName[0].toUpperCase() + eventName.slice(1);\n    registerSimpleEvent(domEventName, 'on' + capitalizedEvent);\n  } // Special cases where event names don't match.\n\n\n  registerSimpleEvent(ANIMATION_END, 'onAnimationEnd');\n  registerSimpleEvent(ANIMATION_ITERATION, 'onAnimationIteration');\n  registerSimpleEvent(ANIMATION_START, 'onAnimationStart');\n  registerSimpleEvent('dblclick', 'onDoubleClick');\n  registerSimpleEvent('focusin', 'onFocus');\n  registerSimpleEvent('focusout', 'onBlur');\n  registerSimpleEvent(TRANSITION_END, 'onTransitionEnd');\n}\n\nfunction extractEvents$4(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags, targetContainer) {\n  const reactName = topLevelEventsToReactNames.get(domEventName);\n\n  if (reactName === undefined) {\n    return;\n  }\n\n  let SyntheticEventCtor = SyntheticEvent;\n  let reactEventType = domEventName;\n\n  switch (domEventName) {\n    case 'keypress':\n      // Firefox creates a keypress event for function keys too. This removes\n      // the unwanted keypress events. Enter is however both printable and\n      // non-printable. One would expect Tab to be as well (but it isn't).\n      if (getEventCharCode(nativeEvent) === 0) {\n        return;\n      }\n\n    /* falls through */\n\n    case 'keydown':\n    case 'keyup':\n      SyntheticEventCtor = SyntheticKeyboardEvent;\n      break;\n\n    case 'focusin':\n      reactEventType = 'focus';\n      SyntheticEventCtor = SyntheticFocusEvent;\n      break;\n\n    case 'focusout':\n      reactEventType = 'blur';\n      SyntheticEventCtor = SyntheticFocusEvent;\n      break;\n\n    case 'beforeblur':\n    case 'afterblur':\n      SyntheticEventCtor = SyntheticFocusEvent;\n      break;\n\n    case 'click':\n      // Firefox creates a click event on right mouse clicks. This removes the\n      // unwanted click events.\n      if (nativeEvent.button === 2) {\n        return;\n      }\n\n    /* falls through */\n\n    case 'auxclick':\n    case 'dblclick':\n    case 'mousedown':\n    case 'mousemove':\n    case 'mouseup': // TODO: Disabled elements should not respond to mouse events\n\n    /* falls through */\n\n    case 'mouseout':\n    case 'mouseover':\n    case 'contextmenu':\n      SyntheticEventCtor = SyntheticMouseEvent;\n      break;\n\n    case 'drag':\n    case 'dragend':\n    case 'dragenter':\n    case 'dragexit':\n    case 'dragleave':\n    case 'dragover':\n    case 'dragstart':\n    case 'drop':\n      SyntheticEventCtor = SyntheticDragEvent;\n      break;\n\n    case 'touchcancel':\n    case 'touchend':\n    case 'touchmove':\n    case 'touchstart':\n      SyntheticEventCtor = SyntheticTouchEvent;\n      break;\n\n    case ANIMATION_END:\n    case ANIMATION_ITERATION:\n    case ANIMATION_START:\n      SyntheticEventCtor = SyntheticAnimationEvent;\n      break;\n\n    case TRANSITION_END:\n      SyntheticEventCtor = SyntheticTransitionEvent;\n      break;\n\n    case 'scroll':\n      SyntheticEventCtor = SyntheticUIEvent;\n      break;\n\n    case 'wheel':\n      SyntheticEventCtor = SyntheticWheelEvent;\n      break;\n\n    case 'copy':\n    case 'cut':\n    case 'paste':\n      SyntheticEventCtor = SyntheticClipboardEvent;\n      break;\n\n    case 'gotpointercapture':\n    case 'lostpointercapture':\n    case 'pointercancel':\n    case 'pointerdown':\n    case 'pointermove':\n    case 'pointerout':\n    case 'pointerover':\n    case 'pointerup':\n      SyntheticEventCtor = SyntheticPointerEvent;\n      break;\n  }\n\n  const inCapturePhase = (eventSystemFlags & IS_CAPTURE_PHASE) !== 0;\n\n  {\n    // Some events don't bubble in the browser.\n    // In the past, React has always bubbled them, but this can be surprising.\n    // We're going to try aligning closer to the browser behavior by not bubbling\n    // them in React either. We'll start by not bubbling onScroll, and then expand.\n    const accumulateTargetOnly = !inCapturePhase && // TODO: ideally, we'd eventually add all events from\n    // nonDelegatedEvents list in DOMPluginEventSystem.\n    // Then we can remove this special list.\n    // This is a breaking change that can wait until React 18.\n    domEventName === 'scroll';\n    const listeners = accumulateSinglePhaseListeners(targetInst, reactName, nativeEvent.type, inCapturePhase, accumulateTargetOnly);\n\n    if (listeners.length > 0) {\n      // Intentionally create event lazily.\n      const event = new SyntheticEventCtor(reactName, reactEventType, null, nativeEvent, nativeEventTarget);\n      dispatchQueue.push({\n        event,\n        listeners\n      });\n    }\n  }\n}\n\n// TODO: remove top-level side effect.\nregisterSimpleEvents();\nregisterEvents$2();\nregisterEvents$1();\nregisterEvents$3();\nregisterEvents();\n\nfunction extractEvents$5(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags, targetContainer) {\n  // TODO: we should remove the concept of a \"SimpleEventPlugin\".\n  // This is the basic functionality of the event system. All\n  // the other plugins are essentially polyfills. So the plugin\n  // should probably be inlined somewhere and have its logic\n  // be core the to event system. This would potentially allow\n  // us to ship builds of React without the polyfilled plugins below.\n  extractEvents$4(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags);\n  const shouldProcessPolyfillPlugins = (eventSystemFlags & SHOULD_NOT_PROCESS_POLYFILL_EVENT_PLUGINS) === 0; // We don't process these events unless we are in the\n  // event's native \"bubble\" phase, which means that we're\n  // not in the capture phase. That's because we emulate\n  // the capture phase here still. This is a trade-off,\n  // because in an ideal world we would not emulate and use\n  // the phases properly, like we do with the SimpleEvent\n  // plugin. However, the plugins below either expect\n  // emulation (EnterLeave) or use state localized to that\n  // plugin (BeforeInput, Change, Select). The state in\n  // these modules complicates things, as you'll essentially\n  // get the case where the capture phase event might change\n  // state, only for the following bubble event to come in\n  // later and not trigger anything as the state now\n  // invalidates the heuristics of the event plugin. We\n  // could alter all these plugins to work in such ways, but\n  // that might cause other unknown side-effects that we\n  // can't foresee right now.\n\n  if (shouldProcessPolyfillPlugins) {\n    extractEvents$2(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget);\n    extractEvents$1(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget);\n    extractEvents$3(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget);\n    extractEvents(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget);\n  }\n} // List of events that need to be individually attached to media elements.\n\n\nconst mediaEventTypes = ['abort', 'canplay', 'canplaythrough', 'durationchange', 'emptied', 'encrypted', 'ended', 'error', 'loadeddata', 'loadedmetadata', 'loadstart', 'pause', 'play', 'playing', 'progress', 'ratechange', 'resize', 'seeked', 'seeking', 'stalled', 'suspend', 'timeupdate', 'volumechange', 'waiting']; // We should not delegate these events to the container, but rather\n// set them on the actual target element itself. This is primarily\n// because these events do not consistently bubble in the DOM.\n\nconst nonDelegatedEvents = new Set(['cancel', 'close', 'invalid', 'load', 'scroll', 'toggle'].concat(mediaEventTypes));\n\nfunction executeDispatch(event, listener, currentTarget) {\n  const type = event.type || 'unknown-event';\n  event.currentTarget = currentTarget;\n  invokeGuardedCallbackAndCatchFirstError(type, listener, undefined, event);\n  event.currentTarget = null;\n}\n\nfunction processDispatchQueueItemsInOrder(event, dispatchListeners, inCapturePhase) {\n  let previousInstance;\n\n  if (inCapturePhase) {\n    for (let i = dispatchListeners.length - 1; i >= 0; i--) {\n      const _dispatchListeners$i = dispatchListeners[i],\n            instance = _dispatchListeners$i.instance,\n            currentTarget = _dispatchListeners$i.currentTarget,\n            listener = _dispatchListeners$i.listener;\n\n      if (instance !== previousInstance && event.isPropagationStopped()) {\n        return;\n      }\n\n      executeDispatch(event, listener, currentTarget);\n      previousInstance = instance;\n    }\n  } else {\n    for (let i = 0; i < dispatchListeners.length; i++) {\n      const _dispatchListeners$i2 = dispatchListeners[i],\n            instance = _dispatchListeners$i2.instance,\n            currentTarget = _dispatchListeners$i2.currentTarget,\n            listener = _dispatchListeners$i2.listener;\n\n      if (instance !== previousInstance && event.isPropagationStopped()) {\n        return;\n      }\n\n      executeDispatch(event, listener, currentTarget);\n      previousInstance = instance;\n    }\n  }\n}\n\nfunction processDispatchQueue(dispatchQueue, eventSystemFlags) {\n  const inCapturePhase = (eventSystemFlags & IS_CAPTURE_PHASE) !== 0;\n\n  for (let i = 0; i < dispatchQueue.length; i++) {\n    const _dispatchQueue$i = dispatchQueue[i],\n          event = _dispatchQueue$i.event,\n          listeners = _dispatchQueue$i.listeners;\n    processDispatchQueueItemsInOrder(event, listeners, inCapturePhase); //  event system doesn't use pooling.\n  } // This would be a good time to rethrow if any of the event handlers threw.\n\n\n  rethrowCaughtError();\n}\n\nfunction dispatchEventsForPlugins(domEventName, eventSystemFlags, nativeEvent, targetInst, targetContainer) {\n  const nativeEventTarget = getEventTarget(nativeEvent);\n  const dispatchQueue = [];\n  extractEvents$5(dispatchQueue, domEventName, targetInst, nativeEvent, nativeEventTarget, eventSystemFlags);\n  processDispatchQueue(dispatchQueue, eventSystemFlags);\n}\n\nfunction listenToNonDelegatedEvent(domEventName, targetElement) {\n\n  const isCapturePhaseListener = false;\n  const listenerSet = getEventListenerSet(targetElement);\n  const listenerSetKey = getListenerSetKey(domEventName, isCapturePhaseListener);\n\n  if (!listenerSet.has(listenerSetKey)) {\n    addTrappedEventListener(targetElement, domEventName, IS_NON_DELEGATED, isCapturePhaseListener);\n    listenerSet.add(listenerSetKey);\n  }\n}\nfunction listenToNativeEvent(domEventName, isCapturePhaseListener, target) {\n\n  let eventSystemFlags = 0;\n\n  if (isCapturePhaseListener) {\n    eventSystemFlags |= IS_CAPTURE_PHASE;\n  }\n\n  addTrappedEventListener(target, domEventName, eventSystemFlags, isCapturePhaseListener);\n} // This is only used by createEventHandle when the\nconst listeningMarker = '_reactListening' + Math.random().toString(36).slice(2);\nfunction listenToAllSupportedEvents(rootContainerElement) {\n  if (!rootContainerElement[listeningMarker]) {\n    rootContainerElement[listeningMarker] = true;\n    allNativeEvents.forEach(domEventName => {\n      // We handle selectionchange separately because it\n      // doesn't bubble and needs to be on the document.\n      if (domEventName !== 'selectionchange') {\n        if (!nonDelegatedEvents.has(domEventName)) {\n          listenToNativeEvent(domEventName, false, rootContainerElement);\n        }\n\n        listenToNativeEvent(domEventName, true, rootContainerElement);\n      }\n    });\n    const ownerDocument = rootContainerElement.nodeType === DOCUMENT_NODE ? rootContainerElement : rootContainerElement.ownerDocument;\n\n    if (ownerDocument !== null) {\n      // The selectionchange event also needs deduplication\n      // but it is attached to the document.\n      if (!ownerDocument[listeningMarker]) {\n        ownerDocument[listeningMarker] = true;\n        listenToNativeEvent('selectionchange', false, ownerDocument);\n      }\n    }\n  }\n}\n\nfunction addTrappedEventListener(targetContainer, domEventName, eventSystemFlags, isCapturePhaseListener, isDeferredListenerForLegacyFBSupport) {\n  let listener = createEventListenerWrapperWithPriority(targetContainer, domEventName, eventSystemFlags); // If passive option is not supported, then the event will be\n  // active and not passive.\n\n  let isPassiveListener = undefined;\n\n  if (passiveBrowserEventsSupported) {\n    // Browsers introduced an intervention, making these events\n    // passive by default on document. React doesn't bind them\n    // to document anymore, but changing this now would undo\n    // the performance wins from the change. So we emulate\n    // the existing behavior manually on the roots now.\n    // https://github.com/facebook/react/issues/19651\n    if (domEventName === 'touchstart' || domEventName === 'touchmove' || domEventName === 'wheel') {\n      isPassiveListener = true;\n    }\n  }\n\n  targetContainer =  targetContainer;\n  let unsubscribeListener; // When legacyFBSupport is enabled, it's for when we\n\n\n  if (isCapturePhaseListener) {\n    if (isPassiveListener !== undefined) {\n      unsubscribeListener = addEventCaptureListenerWithPassiveFlag(targetContainer, domEventName, listener, isPassiveListener);\n    } else {\n      unsubscribeListener = addEventCaptureListener(targetContainer, domEventName, listener);\n    }\n  } else {\n    if (isPassiveListener !== undefined) {\n      unsubscribeListener = addEventBubbleListenerWithPassiveFlag(targetContainer, domEventName, listener, isPassiveListener);\n    } else {\n      unsubscribeListener = addEventBubbleListener(targetContainer, domEventName, listener);\n    }\n  }\n}\n\nfunction isMatchingRootContainer(grandContainer, targetContainer) {\n  return grandContainer === targetContainer || grandContainer.nodeType === COMMENT_NODE && grandContainer.parentNode === targetContainer;\n}\n\nfunction dispatchEventForPluginEventSystem(domEventName, eventSystemFlags, nativeEvent, targetInst, targetContainer) {\n  let ancestorInst = targetInst;\n\n  if ((eventSystemFlags & IS_EVENT_HANDLE_NON_MANAGED_NODE) === 0 && (eventSystemFlags & IS_NON_DELEGATED) === 0) {\n    const targetContainerNode = targetContainer; // If we are using the legacy FB support flag, we\n\n    if (targetInst !== null) {\n      // The below logic attempts to work out if we need to change\n      // the target fiber to a different ancestor. We had similar logic\n      // in the legacy event system, except the big difference between\n      // systems is that the modern event system now has an event listener\n      // attached to each React Root and React Portal Root. Together,\n      // the DOM nodes representing these roots are the \"rootContainer\".\n      // To figure out which ancestor instance we should use, we traverse\n      // up the fiber tree from the target instance and attempt to find\n      // root boundaries that match that of our current \"rootContainer\".\n      // If we find that \"rootContainer\", we find the parent fiber\n      // sub-tree for that root and make that our ancestor instance.\n      let node = targetInst;\n\n      mainLoop: while (true) {\n        if (node === null) {\n          return;\n        }\n\n        const nodeTag = node.tag;\n\n        if (nodeTag === HostRoot || nodeTag === HostPortal) {\n          let container = node.stateNode.containerInfo;\n\n          if (isMatchingRootContainer(container, targetContainerNode)) {\n            break;\n          }\n\n          if (nodeTag === HostPortal) {\n            // The target is a portal, but it's not the rootContainer we're looking for.\n            // Normally portals handle their own events all the way down to the root.\n            // So we should be able to stop now. However, we don't know if this portal\n            // was part of *our* root.\n            let grandNode = node.return;\n\n            while (grandNode !== null) {\n              const grandTag = grandNode.tag;\n\n              if (grandTag === HostRoot || grandTag === HostPortal) {\n                const grandContainer = grandNode.stateNode.containerInfo;\n\n                if (isMatchingRootContainer(grandContainer, targetContainerNode)) {\n                  // This is the rootContainer we're looking for and we found it as\n                  // a parent of the Portal. That means we can ignore it because the\n                  // Portal will bubble through to us.\n                  return;\n                }\n              }\n\n              grandNode = grandNode.return;\n            }\n          } // Now we need to find it's corresponding host fiber in the other\n          // tree. To do this we can use getClosestInstanceFromNode, but we\n          // need to validate that the fiber is a host instance, otherwise\n          // we need to traverse up through the DOM till we find the correct\n          // node that is from the other tree.\n\n\n          while (container !== null) {\n            const parentNode = getClosestInstanceFromNode(container);\n\n            if (parentNode === null) {\n              return;\n            }\n\n            const parentTag = parentNode.tag;\n\n            if (parentTag === HostComponent || parentTag === HostText) {\n              node = ancestorInst = parentNode;\n              continue mainLoop;\n            }\n\n            container = container.parentNode;\n          }\n        }\n\n        node = node.return;\n      }\n    }\n  }\n\n  batchedUpdates(() => dispatchEventsForPlugins(domEventName, eventSystemFlags, nativeEvent, ancestorInst));\n}\n\nfunction createDispatchListener(instance, listener, currentTarget) {\n  return {\n    instance,\n    listener,\n    currentTarget\n  };\n}\n\nfunction accumulateSinglePhaseListeners(targetFiber, reactName, nativeEventType, inCapturePhase, accumulateTargetOnly, nativeEvent) {\n  const captureName = reactName !== null ? reactName + 'Capture' : null;\n  const reactEventName = inCapturePhase ? captureName : reactName;\n  let listeners = [];\n  let instance = targetFiber;\n  let lastHostComponent = null; // Accumulate all instances and listeners via the target -> root path.\n\n  while (instance !== null) {\n    const _instance = instance,\n          stateNode = _instance.stateNode,\n          tag = _instance.tag; // Handle listeners that are on HostComponents (i.e. <div>)\n\n    if (tag === HostComponent && stateNode !== null) {\n      lastHostComponent = stateNode; // createEventHandle listeners\n\n\n      if (reactEventName !== null) {\n        const listener = getListener(instance, reactEventName);\n\n        if (listener != null) {\n          listeners.push(createDispatchListener(instance, listener, lastHostComponent));\n        }\n      }\n    } // If we are only accumulating events for the target, then we don't\n    // continue to propagate through the React fiber tree to find other\n    // listeners.\n\n\n    if (accumulateTargetOnly) {\n      break;\n    } // If we are processing the onBeforeBlur event, then we need to take\n\n    instance = instance.return;\n  }\n\n  return listeners;\n} // We should only use this function for:\n// - BeforeInputEventPlugin\n// - ChangeEventPlugin\n// - SelectEventPlugin\n// This is because we only process these plugins\n// in the bubble phase, so we need to accumulate two\n// phase event listeners (via emulation).\n\nfunction accumulateTwoPhaseListeners(targetFiber, reactName) {\n  const captureName = reactName + 'Capture';\n  const listeners = [];\n  let instance = targetFiber; // Accumulate all instances and listeners via the target -> root path.\n\n  while (instance !== null) {\n    const _instance2 = instance,\n          stateNode = _instance2.stateNode,\n          tag = _instance2.tag; // Handle listeners that are on HostComponents (i.e. <div>)\n\n    if (tag === HostComponent && stateNode !== null) {\n      const currentTarget = stateNode;\n      const captureListener = getListener(instance, captureName);\n\n      if (captureListener != null) {\n        listeners.unshift(createDispatchListener(instance, captureListener, currentTarget));\n      }\n\n      const bubbleListener = getListener(instance, reactName);\n\n      if (bubbleListener != null) {\n        listeners.push(createDispatchListener(instance, bubbleListener, currentTarget));\n      }\n    }\n\n    instance = instance.return;\n  }\n\n  return listeners;\n}\n\nfunction getParent(inst) {\n  if (inst === null) {\n    return null;\n  }\n\n  do {\n    inst = inst.return; // TODO: If this is a HostRoot we might want to bail out.\n    // That is depending on if we want nested subtrees (layers) to bubble\n    // events to their parent. We could also go through parentNode on the\n    // host node but that wouldn't work for React Native and doesn't let us\n    // do the portal feature.\n  } while (inst && inst.tag !== HostComponent);\n\n  if (inst) {\n    return inst;\n  }\n\n  return null;\n}\n/**\n * Return the lowest common ancestor of A and B, or null if they are in\n * different trees.\n */\n\n\nfunction getLowestCommonAncestor(instA, instB) {\n  let nodeA = instA;\n  let nodeB = instB;\n  let depthA = 0;\n\n  for (let tempA = nodeA; tempA; tempA = getParent(tempA)) {\n    depthA++;\n  }\n\n  let depthB = 0;\n\n  for (let tempB = nodeB; tempB; tempB = getParent(tempB)) {\n    depthB++;\n  } // If A is deeper, crawl up.\n\n\n  while (depthA - depthB > 0) {\n    nodeA = getParent(nodeA);\n    depthA--;\n  } // If B is deeper, crawl up.\n\n\n  while (depthB - depthA > 0) {\n    nodeB = getParent(nodeB);\n    depthB--;\n  } // Walk in lockstep until we find a match.\n\n\n  let depth = depthA;\n\n  while (depth--) {\n    if (nodeA === nodeB || nodeB !== null && nodeA === nodeB.alternate) {\n      return nodeA;\n    }\n\n    nodeA = getParent(nodeA);\n    nodeB = getParent(nodeB);\n  }\n\n  return null;\n}\n\nfunction accumulateEnterLeaveListenersForEvent(dispatchQueue, event, target, common, inCapturePhase) {\n  const registrationName = event._reactName;\n  const listeners = [];\n  let instance = target;\n\n  while (instance !== null) {\n    if (instance === common) {\n      break;\n    }\n\n    const _instance3 = instance,\n          alternate = _instance3.alternate,\n          stateNode = _instance3.stateNode,\n          tag = _instance3.tag;\n\n    if (alternate !== null && alternate === common) {\n      break;\n    }\n\n    if (tag === HostComponent && stateNode !== null) {\n      const currentTarget = stateNode;\n\n      if (inCapturePhase) {\n        const captureListener = getListener(instance, registrationName);\n\n        if (captureListener != null) {\n          listeners.unshift(createDispatchListener(instance, captureListener, currentTarget));\n        }\n      } else if (!inCapturePhase) {\n        const bubbleListener = getListener(instance, registrationName);\n\n        if (bubbleListener != null) {\n          listeners.push(createDispatchListener(instance, bubbleListener, currentTarget));\n        }\n      }\n    }\n\n    instance = instance.return;\n  }\n\n  if (listeners.length !== 0) {\n    dispatchQueue.push({\n      event,\n      listeners\n    });\n  }\n} // We should only use this function for:\n// - EnterLeaveEventPlugin\n// This is because we only process this plugin\n// in the bubble phase, so we need to accumulate two\n// phase event listeners.\n\n\nfunction accumulateEnterLeaveTwoPhaseListeners(dispatchQueue, leaveEvent, enterEvent, from, to) {\n  const common = from && to ? getLowestCommonAncestor(from, to) : null;\n\n  if (from !== null) {\n    accumulateEnterLeaveListenersForEvent(dispatchQueue, leaveEvent, from, common, false);\n  }\n\n  if (to !== null && enterEvent !== null) {\n    accumulateEnterLeaveListenersForEvent(dispatchQueue, enterEvent, to, common, true);\n  }\n}\nfunction getListenerSetKey(domEventName, capture) {\n  return domEventName + \"__\" + (capture ? 'capture' : 'bubble');\n}\n\nconst DANGEROUSLY_SET_INNER_HTML = 'dangerouslySetInnerHTML';\nconst SUPPRESS_CONTENT_EDITABLE_WARNING = 'suppressContentEditableWarning';\nconst SUPPRESS_HYDRATION_WARNING = 'suppressHydrationWarning';\nconst AUTOFOCUS = 'autoFocus';\nconst CHILDREN = 'children';\nconst STYLE = 'style';\nconst HTML$1 = '__html';\nlet warnForPropDifference;\nlet normalizeHTML;\n// It also can turn \\u0000 into \\uFFFD inside attributes.\n// https://www.w3.org/TR/html5/single-page.html#preprocessing-the-input-stream\n// If we have a mismatch, it might be caused by that.\n// We will still patch up in this case but not fire the warning.\n\n\nconst NORMALIZE_NEWLINES_REGEX = /\\r\\n?/g;\nconst NORMALIZE_NULL_AND_REPLACEMENT_REGEX = /\\u0000|\\uFFFD/g;\n\nfunction normalizeMarkupForTextOrAttribute(markup) {\n\n  const markupString = typeof markup === 'string' ? markup : '' + markup;\n  return markupString.replace(NORMALIZE_NEWLINES_REGEX, '\\n').replace(NORMALIZE_NULL_AND_REPLACEMENT_REGEX, '');\n}\n\nfunction checkForUnmatchedText(serverText, clientText, isConcurrentMode, shouldWarnDev) {\n  const normalizedClientText = normalizeMarkupForTextOrAttribute(clientText);\n  const normalizedServerText = normalizeMarkupForTextOrAttribute(serverText);\n\n  if (normalizedServerText === normalizedClientText) {\n    return;\n  }\n\n  if (isConcurrentMode && enableClientRenderFallbackOnTextMismatch) {\n    // In concurrent roots, we throw when there's a text mismatch and revert to\n    // client rendering, up to the nearest Suspense boundary.\n    throw Error(formatProdErrorMessage(425));\n  }\n}\n\nfunction getOwnerDocumentFromRootContainer(rootContainerElement) {\n  return rootContainerElement.nodeType === DOCUMENT_NODE ? rootContainerElement : rootContainerElement.ownerDocument;\n}\n\nfunction noop() {}\n\nfunction trapClickOnNonInteractiveElement(node) {\n  // Mobile Safari does not fire properly bubble click events on\n  // non-interactive elements, which means delegated click listeners do not\n  // fire. The workaround for this bug involves attaching an empty click\n  // listener on the target node.\n  // https://www.quirksmode.org/blog/archives/2010/09/click_event_del.html\n  // Just set it using the onclick property so that we don't have to manage any\n  // bookkeeping for it. Not sure if we need to clear it when the listener is\n  // removed.\n  // TODO: Only do this for the relevant Safaris maybe?\n  node.onclick = noop;\n}\n\nfunction setInitialDOMProperties(tag, domElement, rootContainerElement, nextProps, isCustomComponentTag) {\n  for (const propKey in nextProps) {\n    if (!nextProps.hasOwnProperty(propKey)) {\n      continue;\n    }\n\n    const nextProp = nextProps[propKey];\n\n    if (propKey === STYLE) {\n\n\n      setValueForStyles(domElement, nextProp);\n    } else if (propKey === DANGEROUSLY_SET_INNER_HTML) {\n      const nextHtml = nextProp ? nextProp[HTML$1] : undefined;\n\n      if (nextHtml != null) {\n        setInnerHTML(domElement, nextHtml);\n      }\n    } else if (propKey === CHILDREN) {\n      if (typeof nextProp === 'string') {\n        // Avoid setting initial textContent when the text is empty. In IE11 setting\n        // textContent on a <textarea> will cause the placeholder to not\n        // show within the <textarea> until it has been focused and blurred again.\n        // https://github.com/facebook/react/issues/6731#issuecomment-254874553\n        const canSetTextContent = tag !== 'textarea' || nextProp !== '';\n\n        if (canSetTextContent) {\n          setTextContent(domElement, nextProp);\n        }\n      } else if (typeof nextProp === 'number') {\n        setTextContent(domElement, '' + nextProp);\n      }\n    } else if (propKey === SUPPRESS_CONTENT_EDITABLE_WARNING || propKey === SUPPRESS_HYDRATION_WARNING) ; else if (propKey === AUTOFOCUS) ; else if (registrationNameDependencies.hasOwnProperty(propKey)) {\n      if (nextProp != null) {\n\n        if (propKey === 'onScroll') {\n          listenToNonDelegatedEvent('scroll', domElement);\n        }\n      }\n    } else if (nextProp != null) {\n      setValueForProperty(domElement, propKey, nextProp, isCustomComponentTag);\n    }\n  }\n}\n\nfunction updateDOMProperties(domElement, updatePayload, wasCustomComponentTag, isCustomComponentTag) {\n  // TODO: Handle wasCustomComponentTag\n  for (let i = 0; i < updatePayload.length; i += 2) {\n    const propKey = updatePayload[i];\n    const propValue = updatePayload[i + 1];\n\n    if (propKey === STYLE) {\n      setValueForStyles(domElement, propValue);\n    } else if (propKey === DANGEROUSLY_SET_INNER_HTML) {\n      setInnerHTML(domElement, propValue);\n    } else if (propKey === CHILDREN) {\n      setTextContent(domElement, propValue);\n    } else {\n      setValueForProperty(domElement, propKey, propValue, isCustomComponentTag);\n    }\n  }\n}\n\nfunction createElement(type, props, rootContainerElement, parentNamespace) {\n  // tags get no namespace.\n\n  const ownerDocument = getOwnerDocumentFromRootContainer(rootContainerElement);\n  let domElement;\n  let namespaceURI = parentNamespace;\n\n  if (namespaceURI === HTML_NAMESPACE) {\n    namespaceURI = getIntrinsicNamespace(type);\n  }\n\n  if (namespaceURI === HTML_NAMESPACE) {\n\n    if (type === 'script') {\n      // Create the script via .innerHTML so its \"parser-inserted\" flag is\n      // set to true and it does not execute\n      const div = ownerDocument.createElement('div');\n\n      div.innerHTML = '<script><' + '/script>'; // eslint-disable-line\n      // This is guaranteed to yield a script element.\n\n      const firstChild = div.firstChild;\n      domElement = div.removeChild(firstChild);\n    } else if (typeof props.is === 'string') {\n      // $FlowIssue `createElement` should be updated for Web Components\n      domElement = ownerDocument.createElement(type, {\n        is: props.is\n      });\n    } else {\n      // Separate else branch instead of using `props.is || undefined` above because of a Firefox bug.\n      // See discussion in https://github.com/facebook/react/pull/6896\n      // and discussion in https://bugzilla.mozilla.org/show_bug.cgi?id=1276240\n      domElement = ownerDocument.createElement(type); // Normally attributes are assigned in `setInitialDOMProperties`, however the `multiple` and `size`\n      // attributes on `select`s needs to be added before `option`s are inserted.\n      // This prevents:\n      // - a bug where the `select` does not scroll to the correct option because singular\n      //  `select` elements automatically pick the first item #13222\n      // - a bug where the `select` set the first item as selected despite the `size` attribute #14239\n      // See https://github.com/facebook/react/issues/13222\n      // and https://github.com/facebook/react/issues/14239\n\n      if (type === 'select') {\n        const node = domElement;\n\n        if (props.multiple) {\n          node.multiple = true;\n        } else if (props.size) {\n          // Setting a size greater than 1 causes a select to behave like `multiple=true`, where\n          // it is possible that no option is selected.\n          //\n          // This is only necessary when a select in \"single selection mode\".\n          node.size = props.size;\n        }\n      }\n    }\n  } else {\n    domElement = ownerDocument.createElementNS(namespaceURI, type);\n  }\n\n  return domElement;\n}\nfunction createTextNode(text, rootContainerElement) {\n  return getOwnerDocumentFromRootContainer(rootContainerElement).createTextNode(text);\n}\nfunction setInitialProperties(domElement, tag, rawProps, rootContainerElement) {\n  const isCustomComponentTag = isCustomComponent(tag, rawProps);\n\n\n  let props;\n\n  switch (tag) {\n    case 'dialog':\n      listenToNonDelegatedEvent('cancel', domElement);\n      listenToNonDelegatedEvent('close', domElement);\n      props = rawProps;\n      break;\n\n    case 'iframe':\n    case 'object':\n    case 'embed':\n      // We listen to this event in case to ensure emulated bubble\n      // listeners still fire for the load event.\n      listenToNonDelegatedEvent('load', domElement);\n      props = rawProps;\n      break;\n\n    case 'video':\n    case 'audio':\n      // We listen to these events in case to ensure emulated bubble\n      // listeners still fire for all the media events.\n      for (let i = 0; i < mediaEventTypes.length; i++) {\n        listenToNonDelegatedEvent(mediaEventTypes[i], domElement);\n      }\n\n      props = rawProps;\n      break;\n\n    case 'source':\n      // We listen to this event in case to ensure emulated bubble\n      // listeners still fire for the error event.\n      listenToNonDelegatedEvent('error', domElement);\n      props = rawProps;\n      break;\n\n    case 'img':\n    case 'image':\n    case 'link':\n      // We listen to these events in case to ensure emulated bubble\n      // listeners still fire for error and load events.\n      listenToNonDelegatedEvent('error', domElement);\n      listenToNonDelegatedEvent('load', domElement);\n      props = rawProps;\n      break;\n\n    case 'details':\n      // We listen to this event in case to ensure emulated bubble\n      // listeners still fire for the toggle event.\n      listenToNonDelegatedEvent('toggle', domElement);\n      props = rawProps;\n      break;\n\n    case 'input':\n      initWrapperState(domElement, rawProps);\n      props = getHostProps(domElement, rawProps); // We listen to this event in case to ensure emulated bubble\n      // listeners still fire for the invalid event.\n\n      listenToNonDelegatedEvent('invalid', domElement);\n      break;\n\n    case 'option':\n      props = rawProps;\n      break;\n\n    case 'select':\n      initWrapperState$1(domElement, rawProps);\n      props = getHostProps$1(domElement, rawProps); // We listen to this event in case to ensure emulated bubble\n      // listeners still fire for the invalid event.\n\n      listenToNonDelegatedEvent('invalid', domElement);\n      break;\n\n    case 'textarea':\n      initWrapperState$2(domElement, rawProps);\n      props = getHostProps$2(domElement, rawProps); // We listen to this event in case to ensure emulated bubble\n      // listeners still fire for the invalid event.\n\n      listenToNonDelegatedEvent('invalid', domElement);\n      break;\n\n    default:\n      props = rawProps;\n  }\n\n  assertValidProps(tag, props);\n  setInitialDOMProperties(tag, domElement, rootContainerElement, props, isCustomComponentTag);\n\n  switch (tag) {\n    case 'input':\n      // TODO: Make sure we check if this is still unmounted or do any clean\n      // up necessary since we never stop tracking anymore.\n      track(domElement);\n      postMountWrapper(domElement, rawProps, false);\n      break;\n\n    case 'textarea':\n      // TODO: Make sure we check if this is still unmounted or do any clean\n      // up necessary since we never stop tracking anymore.\n      track(domElement);\n      postMountWrapper$3(domElement);\n      break;\n\n    case 'option':\n      postMountWrapper$1(domElement, rawProps);\n      break;\n\n    case 'select':\n      postMountWrapper$2(domElement, rawProps);\n      break;\n\n    default:\n      if (typeof props.onClick === 'function') {\n        // TODO: This cast may not be sound for SVG, MathML or custom elements.\n        trapClickOnNonInteractiveElement(domElement);\n      }\n\n      break;\n  }\n} // Calculate the diff between the two objects.\n\nfunction diffProperties(domElement, tag, lastRawProps, nextRawProps, rootContainerElement) {\n\n  let updatePayload = null;\n  let lastProps;\n  let nextProps;\n\n  switch (tag) {\n    case 'input':\n      lastProps = getHostProps(domElement, lastRawProps);\n      nextProps = getHostProps(domElement, nextRawProps);\n      updatePayload = [];\n      break;\n\n    case 'select':\n      lastProps = getHostProps$1(domElement, lastRawProps);\n      nextProps = getHostProps$1(domElement, nextRawProps);\n      updatePayload = [];\n      break;\n\n    case 'textarea':\n      lastProps = getHostProps$2(domElement, lastRawProps);\n      nextProps = getHostProps$2(domElement, nextRawProps);\n      updatePayload = [];\n      break;\n\n    default:\n      lastProps = lastRawProps;\n      nextProps = nextRawProps;\n\n      if (typeof lastProps.onClick !== 'function' && typeof nextProps.onClick === 'function') {\n        // TODO: This cast may not be sound for SVG, MathML or custom elements.\n        trapClickOnNonInteractiveElement(domElement);\n      }\n\n      break;\n  }\n\n  assertValidProps(tag, nextProps);\n  let propKey;\n  let styleName;\n  let styleUpdates = null;\n\n  for (propKey in lastProps) {\n    if (nextProps.hasOwnProperty(propKey) || !lastProps.hasOwnProperty(propKey) || lastProps[propKey] == null) {\n      continue;\n    }\n\n    if (propKey === STYLE) {\n      const lastStyle = lastProps[propKey];\n\n      for (styleName in lastStyle) {\n        if (lastStyle.hasOwnProperty(styleName)) {\n          if (!styleUpdates) {\n            styleUpdates = {};\n          }\n\n          styleUpdates[styleName] = '';\n        }\n      }\n    } else if (propKey === DANGEROUSLY_SET_INNER_HTML || propKey === CHILDREN) ; else if (propKey === SUPPRESS_CONTENT_EDITABLE_WARNING || propKey === SUPPRESS_HYDRATION_WARNING) ; else if (propKey === AUTOFOCUS) ; else if (registrationNameDependencies.hasOwnProperty(propKey)) {\n      // This is a special case. If any listener updates we need to ensure\n      // that the \"current\" fiber pointer gets updated so we need a commit\n      // to update this element.\n      if (!updatePayload) {\n        updatePayload = [];\n      }\n    } else {\n      // For all other deleted properties we add it to the queue. We use\n      // the allowed property list in the commit phase instead.\n      (updatePayload = updatePayload || []).push(propKey, null);\n    }\n  }\n\n  for (propKey in nextProps) {\n    const nextProp = nextProps[propKey];\n    const lastProp = lastProps != null ? lastProps[propKey] : undefined;\n\n    if (!nextProps.hasOwnProperty(propKey) || nextProp === lastProp || nextProp == null && lastProp == null) {\n      continue;\n    }\n\n    if (propKey === STYLE) {\n\n      if (lastProp) {\n        // Unset styles on `lastProp` but not on `nextProp`.\n        for (styleName in lastProp) {\n          if (lastProp.hasOwnProperty(styleName) && (!nextProp || !nextProp.hasOwnProperty(styleName))) {\n            if (!styleUpdates) {\n              styleUpdates = {};\n            }\n\n            styleUpdates[styleName] = '';\n          }\n        } // Update styles that changed since `lastProp`.\n\n\n        for (styleName in nextProp) {\n          if (nextProp.hasOwnProperty(styleName) && lastProp[styleName] !== nextProp[styleName]) {\n            if (!styleUpdates) {\n              styleUpdates = {};\n            }\n\n            styleUpdates[styleName] = nextProp[styleName];\n          }\n        }\n      } else {\n        // Relies on `updateStylesByID` not mutating `styleUpdates`.\n        if (!styleUpdates) {\n          if (!updatePayload) {\n            updatePayload = [];\n          }\n\n          updatePayload.push(propKey, styleUpdates);\n        }\n\n        styleUpdates = nextProp;\n      }\n    } else if (propKey === DANGEROUSLY_SET_INNER_HTML) {\n      const nextHtml = nextProp ? nextProp[HTML$1] : undefined;\n      const lastHtml = lastProp ? lastProp[HTML$1] : undefined;\n\n      if (nextHtml != null) {\n        if (lastHtml !== nextHtml) {\n          (updatePayload = updatePayload || []).push(propKey, nextHtml);\n        }\n      }\n    } else if (propKey === CHILDREN) {\n      if (typeof nextProp === 'string' || typeof nextProp === 'number') {\n        (updatePayload = updatePayload || []).push(propKey, '' + nextProp);\n      }\n    } else if (propKey === SUPPRESS_CONTENT_EDITABLE_WARNING || propKey === SUPPRESS_HYDRATION_WARNING) ; else if (registrationNameDependencies.hasOwnProperty(propKey)) {\n      if (nextProp != null) {\n\n        if (propKey === 'onScroll') {\n          listenToNonDelegatedEvent('scroll', domElement);\n        }\n      }\n\n      if (!updatePayload && lastProp !== nextProp) {\n        // This is a special case. If any listener updates we need to ensure\n        // that the \"current\" props pointer gets updated so we need a commit\n        // to update this element.\n        updatePayload = [];\n      }\n    } else {\n      // For any other property we always add it to the queue and then we\n      // filter it out using the allowed property list during the commit.\n      (updatePayload = updatePayload || []).push(propKey, nextProp);\n    }\n  }\n\n  if (styleUpdates) {\n\n    (updatePayload = updatePayload || []).push(STYLE, styleUpdates);\n  }\n\n  return updatePayload;\n} // Apply the diff.\n\nfunction updateProperties(domElement, updatePayload, tag, lastRawProps, nextRawProps) {\n  // Update checked *before* name.\n  // In the middle of an update, it is possible to have multiple checked.\n  // When a checked radio tries to change name, browser makes another radio's checked false.\n  if (tag === 'input' && nextRawProps.type === 'radio' && nextRawProps.name != null) {\n    updateChecked(domElement, nextRawProps);\n  }\n\n  const wasCustomComponentTag = isCustomComponent(tag, lastRawProps);\n  const isCustomComponentTag = isCustomComponent(tag, nextRawProps); // Apply the diff.\n\n  updateDOMProperties(domElement, updatePayload, wasCustomComponentTag, isCustomComponentTag); // TODO: Ensure that an update gets scheduled if any of the special props\n  // changed.\n\n  switch (tag) {\n    case 'input':\n      // Update the wrapper around inputs *after* updating props. This has to\n      // happen after `updateDOMProperties`. Otherwise HTML5 input validations\n      // raise warnings and prevent the new value from being assigned.\n      updateWrapper(domElement, nextRawProps);\n      break;\n\n    case 'textarea':\n      updateWrapper$1(domElement, nextRawProps);\n      break;\n\n    case 'select':\n      // <select> value update needs to occur after <option> children\n      // reconciliation\n      postUpdateWrapper(domElement, nextRawProps);\n      break;\n  }\n}\n\nfunction getPossibleStandardName(propName) {\n\n  return null;\n}\n\nfunction diffHydratedProperties(domElement, tag, rawProps, parentNamespace, rootContainerElement, isConcurrentMode, shouldWarnDev) {\n  let isCustomComponentTag;\n  let extraAttributeNames;\n\n\n  switch (tag) {\n    case 'dialog':\n      listenToNonDelegatedEvent('cancel', domElement);\n      listenToNonDelegatedEvent('close', domElement);\n      break;\n\n    case 'iframe':\n    case 'object':\n    case 'embed':\n      // We listen to this event in case to ensure emulated bubble\n      // listeners still fire for the load event.\n      listenToNonDelegatedEvent('load', domElement);\n      break;\n\n    case 'video':\n    case 'audio':\n      // We listen to these events in case to ensure emulated bubble\n      // listeners still fire for all the media events.\n      for (let i = 0; i < mediaEventTypes.length; i++) {\n        listenToNonDelegatedEvent(mediaEventTypes[i], domElement);\n      }\n\n      break;\n\n    case 'source':\n      // We listen to this event in case to ensure emulated bubble\n      // listeners still fire for the error event.\n      listenToNonDelegatedEvent('error', domElement);\n      break;\n\n    case 'img':\n    case 'image':\n    case 'link':\n      // We listen to these events in case to ensure emulated bubble\n      // listeners still fire for error and load events.\n      listenToNonDelegatedEvent('error', domElement);\n      listenToNonDelegatedEvent('load', domElement);\n      break;\n\n    case 'details':\n      // We listen to this event in case to ensure emulated bubble\n      // listeners still fire for the toggle event.\n      listenToNonDelegatedEvent('toggle', domElement);\n      break;\n\n    case 'input':\n      initWrapperState(domElement, rawProps); // We listen to this event in case to ensure emulated bubble\n      // listeners still fire for the invalid event.\n\n      listenToNonDelegatedEvent('invalid', domElement);\n      break;\n\n    case 'option':\n      break;\n\n    case 'select':\n      initWrapperState$1(domElement, rawProps); // We listen to this event in case to ensure emulated bubble\n      // listeners still fire for the invalid event.\n\n      listenToNonDelegatedEvent('invalid', domElement);\n      break;\n\n    case 'textarea':\n      initWrapperState$2(domElement, rawProps); // We listen to this event in case to ensure emulated bubble\n      // listeners still fire for the invalid event.\n\n      listenToNonDelegatedEvent('invalid', domElement);\n      break;\n  }\n\n  assertValidProps(tag, rawProps);\n\n  let updatePayload = null;\n\n  for (const propKey in rawProps) {\n    if (!rawProps.hasOwnProperty(propKey)) {\n      continue;\n    }\n\n    const nextProp = rawProps[propKey];\n\n    if (propKey === CHILDREN) {\n      // For text content children we compare against textContent. This\n      // might match additional HTML that is hidden when we read it using\n      // textContent. E.g. \"foo\" will match \"f<span>oo</span>\" but that still\n      // satisfies our requirement. Our requirement is not to produce perfect\n      // HTML and attributes. Ideally we should preserve structure but it's\n      // ok not to if the visible content is still enough to indicate what\n      // even listeners these nodes might be wired up to.\n      // TODO: Warn if there is more than a single textNode as a child.\n      // TODO: Should we use domElement.firstChild.nodeValue to compare?\n      if (typeof nextProp === 'string') {\n        if (domElement.textContent !== nextProp) {\n          if (rawProps[SUPPRESS_HYDRATION_WARNING] !== true) {\n            checkForUnmatchedText(domElement.textContent, nextProp, isConcurrentMode);\n          }\n\n          updatePayload = [CHILDREN, nextProp];\n        }\n      } else if (typeof nextProp === 'number') {\n        if (domElement.textContent !== '' + nextProp) {\n          if (rawProps[SUPPRESS_HYDRATION_WARNING] !== true) {\n            checkForUnmatchedText(domElement.textContent, nextProp, isConcurrentMode);\n          }\n\n          updatePayload = [CHILDREN, '' + nextProp];\n        }\n      }\n    } else if (registrationNameDependencies.hasOwnProperty(propKey)) {\n      if (nextProp != null) {\n\n        if (propKey === 'onScroll') {\n          listenToNonDelegatedEvent('scroll', domElement);\n        }\n      }\n    } else if (shouldWarnDev && false && // Convince Flow we've calculated it (it's DEV-only in this method.)\n    typeof isCustomComponentTag === 'boolean') {\n      // Validate that the properties correspond to their expected values.\n      let serverValue;\n      const propertyInfo =  getPropertyInfo(propKey);\n\n      if (rawProps[SUPPRESS_HYDRATION_WARNING] === true) ; else if (propKey === SUPPRESS_CONTENT_EDITABLE_WARNING || propKey === SUPPRESS_HYDRATION_WARNING || // Controlled attributes are not validated\n      // TODO: Only ignore them on controlled tags.\n      propKey === 'value' || propKey === 'checked' || propKey === 'selected') ; else if (propKey === DANGEROUSLY_SET_INNER_HTML) {\n        const serverHTML = domElement.innerHTML;\n        const nextHtml = nextProp ? nextProp[HTML$1] : undefined;\n\n        if (nextHtml != null) {\n          const expectedHTML = normalizeHTML();\n\n          if (expectedHTML !== serverHTML) {\n            warnForPropDifference();\n          }\n        }\n      } else if (propKey === STYLE) {\n        // $FlowFixMe - Should be inferred as not undefined.\n        extraAttributeNames.delete(propKey);\n      } else if (!shouldIgnoreAttribute(propKey, propertyInfo, isCustomComponentTag) && !shouldRemoveAttribute(propKey, nextProp, propertyInfo, isCustomComponentTag)) {\n        let isMismatchDueToBadCasing = false;\n\n        if (propertyInfo !== null) {\n          // $FlowFixMe - Should be inferred as not undefined.\n          extraAttributeNames.delete(propertyInfo.attributeName);\n          serverValue = getValueForProperty();\n        } else {\n          let ownNamespace = parentNamespace;\n\n          if (ownNamespace === HTML_NAMESPACE) {\n            ownNamespace = getIntrinsicNamespace(tag);\n          }\n\n          if (ownNamespace === HTML_NAMESPACE) {\n            // $FlowFixMe - Should be inferred as not undefined.\n            extraAttributeNames.delete(propKey.toLowerCase());\n          } else {\n            const standardName = getPossibleStandardName();\n\n            if (standardName !== null && standardName !== propKey) {\n              // If an SVG prop is supplied with bad casing, it will\n              // be successfully parsed from HTML, but will produce a mismatch\n              // (and would be incorrectly rendered on the client).\n              // However, we already warn about bad casing elsewhere.\n              // So we'll skip the misleading extra mismatch warning in this case.\n              isMismatchDueToBadCasing = true; // $FlowFixMe - Should be inferred as not undefined.\n\n              extraAttributeNames.delete(standardName);\n            } // $FlowFixMe - Should be inferred as not undefined.\n\n\n            extraAttributeNames.delete(propKey);\n          }\n\n          serverValue = getValueForAttribute();\n        }\n\n        if ( nextProp !== serverValue && !isMismatchDueToBadCasing) {\n          warnForPropDifference();\n        }\n      }\n    }\n  }\n\n  switch (tag) {\n    case 'input':\n      // TODO: Make sure we check if this is still unmounted or do any clean\n      // up necessary since we never stop tracking anymore.\n      track(domElement);\n      postMountWrapper(domElement, rawProps, true);\n      break;\n\n    case 'textarea':\n      // TODO: Make sure we check if this is still unmounted or do any clean\n      // up necessary since we never stop tracking anymore.\n      track(domElement);\n      postMountWrapper$3(domElement);\n      break;\n\n    case 'select':\n    case 'option':\n      // For input and textarea we current always set the value property at\n      // post mount to force it to diverge from attributes. However, for\n      // option and select we don't quite do the same thing and select\n      // is not resilient to the DOM state changing so we don't do that here.\n      // TODO: Consider not doing this for input and textarea.\n      break;\n\n    default:\n      if (typeof rawProps.onClick === 'function') {\n        // TODO: This cast may not be sound for SVG, MathML or custom elements.\n        trapClickOnNonInteractiveElement(domElement);\n      }\n\n      break;\n  }\n\n  return updatePayload;\n}\nfunction diffHydratedText(textNode, text, isConcurrentMode) {\n  const isDifferent = textNode.nodeValue !== text;\n  return isDifferent;\n}\nfunction restoreControlledState$3(domElement, tag, props) {\n  switch (tag) {\n    case 'input':\n      restoreControlledState(domElement, props);\n      return;\n\n    case 'textarea':\n      restoreControlledState$2(domElement, props);\n      return;\n\n    case 'select':\n      restoreControlledState$1(domElement, props);\n      return;\n  }\n}\n\nconst SUPPRESS_HYDRATION_WARNING$1 = 'suppressHydrationWarning';\nconst SUSPENSE_START_DATA = '$';\nconst SUSPENSE_END_DATA = '/$';\nconst SUSPENSE_PENDING_START_DATA = '$?';\nconst SUSPENSE_FALLBACK_START_DATA = '$!';\nconst STYLE$1 = 'style';\nlet eventsEnabled = null;\nlet selectionInformation = null;\nfunction getRootHostContext(rootContainerInstance) {\n  let type;\n  let namespace;\n  const nodeType = rootContainerInstance.nodeType;\n\n  switch (nodeType) {\n    case DOCUMENT_NODE:\n    case DOCUMENT_FRAGMENT_NODE:\n      {\n        type = nodeType === DOCUMENT_NODE ? '#document' : '#fragment';\n        const root = rootContainerInstance.documentElement;\n        namespace = root ? root.namespaceURI : getChildNamespace(null, '');\n        break;\n      }\n\n    default:\n      {\n        const container = nodeType === COMMENT_NODE ? rootContainerInstance.parentNode : rootContainerInstance;\n        const ownNamespace = container.namespaceURI || null;\n        type = container.tagName;\n        namespace = getChildNamespace(ownNamespace, type);\n        break;\n      }\n  }\n\n  return namespace;\n}\nfunction getChildHostContext(parentHostContext, type, rootContainerInstance) {\n\n  const parentNamespace = parentHostContext;\n  return getChildNamespace(parentNamespace, type);\n}\nfunction getPublicInstance(instance) {\n  return instance;\n}\nfunction prepareForCommit(containerInfo) {\n  eventsEnabled = isEnabled();\n  selectionInformation = getSelectionInformation();\n  let activeInstance = null;\n\n  setEnabled(false);\n  return activeInstance;\n}\nfunction resetAfterCommit(containerInfo) {\n  restoreSelection(selectionInformation);\n  setEnabled(eventsEnabled);\n  eventsEnabled = null;\n  selectionInformation = null;\n}\nfunction createInstance(type, props, rootContainerInstance, hostContext, internalInstanceHandle) {\n  let parentNamespace;\n\n  {\n    parentNamespace = hostContext;\n  }\n\n  const domElement = createElement(type, props, rootContainerInstance, parentNamespace);\n  precacheFiberNode(internalInstanceHandle, domElement);\n  updateFiberProps(domElement, props);\n  return domElement;\n}\nfunction appendInitialChild(parentInstance, child) {\n  parentInstance.appendChild(child);\n}\nfunction finalizeInitialChildren(domElement, type, props, rootContainerInstance, hostContext) {\n  setInitialProperties(domElement, type, props, rootContainerInstance);\n\n  switch (type) {\n    case 'button':\n    case 'input':\n    case 'select':\n    case 'textarea':\n      return !!props.autoFocus;\n\n    case 'img':\n      return true;\n\n    default:\n      return false;\n  }\n}\nfunction prepareUpdate(domElement, type, oldProps, newProps, rootContainerInstance, hostContext) {\n\n  return diffProperties(domElement, type, oldProps, newProps);\n}\nfunction shouldSetTextContent(type, props) {\n  return type === 'textarea' || type === 'noscript' || typeof props.children === 'string' || typeof props.children === 'number' || typeof props.dangerouslySetInnerHTML === 'object' && props.dangerouslySetInnerHTML !== null && props.dangerouslySetInnerHTML.__html != null;\n}\nfunction createTextInstance(text, rootContainerInstance, hostContext, internalInstanceHandle) {\n\n  const textNode = createTextNode(text, rootContainerInstance);\n  precacheFiberNode(internalInstanceHandle, textNode);\n  return textNode;\n}\nfunction getCurrentEventPriority() {\n  const currentEvent = window.event;\n\n  if (currentEvent === undefined) {\n    return DefaultEventPriority;\n  }\n\n  return getEventPriority(currentEvent.type);\n}\n// if a component just imports ReactDOM (e.g. for findDOMNode).\n// Some environments might not have setTimeout or clearTimeout.\n\nconst scheduleTimeout = typeof setTimeout === 'function' ? setTimeout : undefined;\nconst cancelTimeout = typeof clearTimeout === 'function' ? clearTimeout : undefined;\nconst noTimeout = -1;\nconst localPromise = typeof Promise === 'function' ? Promise : undefined; // -------------------\nconst scheduleMicrotask = typeof queueMicrotask === 'function' ? queueMicrotask : typeof localPromise !== 'undefined' ? callback => localPromise.resolve(null).then(callback).catch(handleErrorInNextTick) : scheduleTimeout; // TODO: Determine the best fallback here.\n\nfunction handleErrorInNextTick(error) {\n  setTimeout(() => {\n    throw error;\n  });\n} // -------------------\nfunction commitMount(domElement, type, newProps, internalInstanceHandle) {\n  // Despite the naming that might imply otherwise, this method only\n  // fires if there is an `Update` effect scheduled during mounting.\n  // This happens if `finalizeInitialChildren` returns `true` (which it\n  // does to implement the `autoFocus` attribute on the client). But\n  // there are also other cases when this might happen (such as patching\n  // up text content during hydration mismatch). So we'll check this again.\n  switch (type) {\n    case 'button':\n    case 'input':\n    case 'select':\n    case 'textarea':\n      if (newProps.autoFocus) {\n        domElement.focus();\n      }\n\n      return;\n\n    case 'img':\n      {\n        if (newProps.src) {\n          domElement.src = newProps.src;\n        }\n\n        return;\n      }\n  }\n}\nfunction commitUpdate(domElement, updatePayload, type, oldProps, newProps, internalInstanceHandle) {\n  // Apply the diff to the DOM node.\n  updateProperties(domElement, updatePayload, type, oldProps, newProps); // Update the props handle so that we know which props are the ones with\n  // with current event handlers.\n\n  updateFiberProps(domElement, newProps);\n}\nfunction resetTextContent(domElement) {\n  setTextContent(domElement, '');\n}\nfunction commitTextUpdate(textInstance, oldText, newText) {\n  textInstance.nodeValue = newText;\n}\nfunction appendChild(parentInstance, child) {\n  parentInstance.appendChild(child);\n}\nfunction appendChildToContainer(container, child) {\n  let parentNode;\n\n  if (container.nodeType === COMMENT_NODE) {\n    parentNode = container.parentNode;\n    parentNode.insertBefore(child, container);\n  } else {\n    parentNode = container;\n    parentNode.appendChild(child);\n  } // This container might be used for a portal.\n  // If something inside a portal is clicked, that click should bubble\n  // through the React tree. However, on Mobile Safari the click would\n  // never bubble through the *DOM* tree unless an ancestor with onclick\n  // event exists. So we wouldn't see it and dispatch it.\n  // This is why we ensure that non React root containers have inline onclick\n  // defined.\n  // https://github.com/facebook/react/issues/11918\n\n\n  const reactRootContainer = container._reactRootContainer;\n\n  if ((reactRootContainer === null || reactRootContainer === undefined) && parentNode.onclick === null) {\n    // TODO: This cast may not be sound for SVG, MathML or custom elements.\n    trapClickOnNonInteractiveElement(parentNode);\n  }\n}\nfunction insertBefore(parentInstance, child, beforeChild) {\n  parentInstance.insertBefore(child, beforeChild);\n}\nfunction insertInContainerBefore(container, child, beforeChild) {\n  if (container.nodeType === COMMENT_NODE) {\n    container.parentNode.insertBefore(child, beforeChild);\n  } else {\n    container.insertBefore(child, beforeChild);\n  }\n}\n\nfunction removeChild(parentInstance, child) {\n  parentInstance.removeChild(child);\n}\nfunction removeChildFromContainer(container, child) {\n  if (container.nodeType === COMMENT_NODE) {\n    container.parentNode.removeChild(child);\n  } else {\n    container.removeChild(child);\n  }\n}\nfunction clearSuspenseBoundary(parentInstance, suspenseInstance) {\n  let node = suspenseInstance; // Delete all nodes within this suspense boundary.\n  // There might be nested nodes so we need to keep track of how\n  // deep we are and only break out when we're back on top.\n\n  let depth = 0;\n\n  do {\n    const nextNode = node.nextSibling;\n    parentInstance.removeChild(node);\n\n    if (nextNode && nextNode.nodeType === COMMENT_NODE) {\n      const data = nextNode.data;\n\n      if (data === SUSPENSE_END_DATA) {\n        if (depth === 0) {\n          parentInstance.removeChild(nextNode); // Retry if any event replaying was blocked on this.\n\n          retryIfBlockedOn(suspenseInstance);\n          return;\n        } else {\n          depth--;\n        }\n      } else if (data === SUSPENSE_START_DATA || data === SUSPENSE_PENDING_START_DATA || data === SUSPENSE_FALLBACK_START_DATA) {\n        depth++;\n      }\n    }\n\n    node = nextNode;\n  } while (node); // TODO: Warn, we didn't find the end comment boundary.\n  // Retry if any event replaying was blocked on this.\n\n\n  retryIfBlockedOn(suspenseInstance);\n}\nfunction clearSuspenseBoundaryFromContainer(container, suspenseInstance) {\n  if (container.nodeType === COMMENT_NODE) {\n    clearSuspenseBoundary(container.parentNode, suspenseInstance);\n  } else if (container.nodeType === ELEMENT_NODE) {\n    clearSuspenseBoundary(container, suspenseInstance);\n  } // Retry if any event replaying was blocked on this.\n\n\n  retryIfBlockedOn(container);\n}\nfunction hideInstance(instance) {\n  // TODO: Does this work for all element types? What about MathML? Should we\n  // pass host context to this method?\n  instance = instance;\n  const style = instance.style;\n\n  if (typeof style.setProperty === 'function') {\n    style.setProperty('display', 'none', 'important');\n  } else {\n    style.display = 'none';\n  }\n}\nfunction hideTextInstance(textInstance) {\n  textInstance.nodeValue = '';\n}\nfunction unhideInstance(instance, props) {\n  instance = instance;\n  const styleProp = props[STYLE$1];\n  const display = styleProp !== undefined && styleProp !== null && styleProp.hasOwnProperty('display') ? styleProp.display : null;\n  instance.style.display = dangerousStyleValue('display', display);\n}\nfunction unhideTextInstance(textInstance, text) {\n  textInstance.nodeValue = text;\n}\nfunction clearContainer(container) {\n  if (container.nodeType === ELEMENT_NODE) {\n    container.textContent = '';\n  } else if (container.nodeType === DOCUMENT_NODE) {\n    if (container.documentElement) {\n      container.removeChild(container.documentElement);\n    }\n  }\n} // -------------------\nfunction canHydrateInstance(instance, type, props) {\n  if (instance.nodeType !== ELEMENT_NODE || type.toLowerCase() !== instance.nodeName.toLowerCase()) {\n    return null;\n  } // This has now been refined to an element node.\n\n\n  return instance;\n}\nfunction canHydrateTextInstance(instance, text) {\n  if (text === '' || instance.nodeType !== TEXT_NODE) {\n    // Empty strings are not parsed by HTML so there won't be a correct match here.\n    return null;\n  } // This has now been refined to a text node.\n\n\n  return instance;\n}\nfunction canHydrateSuspenseInstance(instance) {\n  if (instance.nodeType !== COMMENT_NODE) {\n    // Empty strings are not parsed by HTML so there won't be a correct match here.\n    return null;\n  } // This has now been refined to a suspense node.\n\n\n  return instance;\n}\nfunction isSuspenseInstancePending(instance) {\n  return instance.data === SUSPENSE_PENDING_START_DATA;\n}\nfunction isSuspenseInstanceFallback(instance) {\n  return instance.data === SUSPENSE_FALLBACK_START_DATA;\n}\nfunction getSuspenseInstanceFallbackErrorDetails(instance) {\n  const dataset = instance.nextSibling && instance.nextSibling.dataset;\n  let digest;\n\n  if (dataset) {\n    digest = dataset.dgst;\n  }\n\n  {\n    // Object gets DCE'd if constructed in tail position and matches callsite destructuring\n    return {\n      digest\n    };\n  } // let value = {message: undefined, hash: undefined};\n  // const nextSibling = instance.nextSibling;\n  // if (nextSibling) {\n  //   const dataset = ((nextSibling: any): HTMLTemplateElement).dataset;\n  //   value.message = dataset.msg;\n  //   value.hash = dataset.hash;\n  //   if (false) {\n  //     value.stack = dataset.stack;\n  //   }\n  // }\n  // return value;\n\n}\nfunction registerSuspenseInstanceRetry(instance, callback) {\n  instance._reactRetry = callback;\n}\n\nfunction getNextHydratable(node) {\n  // Skip non-hydratable nodes.\n  for (; node != null; node = node.nextSibling) {\n    const nodeType = node.nodeType;\n\n    if (nodeType === ELEMENT_NODE || nodeType === TEXT_NODE) {\n      break;\n    }\n\n    if (nodeType === COMMENT_NODE) {\n      const nodeData = node.data;\n\n      if (nodeData === SUSPENSE_START_DATA || nodeData === SUSPENSE_FALLBACK_START_DATA || nodeData === SUSPENSE_PENDING_START_DATA) {\n        break;\n      }\n\n      if (nodeData === SUSPENSE_END_DATA) {\n        return null;\n      }\n    }\n  }\n\n  return node;\n}\n\nfunction getNextHydratableSibling(instance) {\n  return getNextHydratable(instance.nextSibling);\n}\nfunction getFirstHydratableChild(parentInstance) {\n  return getNextHydratable(parentInstance.firstChild);\n}\nfunction getFirstHydratableChildWithinContainer(parentContainer) {\n  return getNextHydratable(parentContainer.firstChild);\n}\nfunction getFirstHydratableChildWithinSuspenseInstance(parentInstance) {\n  return getNextHydratable(parentInstance.nextSibling);\n}\nfunction hydrateInstance(instance, type, props, rootContainerInstance, hostContext, internalInstanceHandle, shouldWarnDev) {\n  precacheFiberNode(internalInstanceHandle, instance); // TODO: Possibly defer this until the commit phase where all the events\n  // get attached.\n\n  updateFiberProps(instance, props);\n  let parentNamespace;\n\n  {\n    parentNamespace = hostContext;\n  } // TODO: Temporary hack to check if we're in a concurrent root. We can delete\n  // when the legacy root API is removed.\n\n\n  const isConcurrentMode = (internalInstanceHandle.mode & ConcurrentMode) !== NoMode;\n  return diffHydratedProperties(instance, type, props, parentNamespace, rootContainerInstance, isConcurrentMode, shouldWarnDev);\n}\nfunction hydrateTextInstance(textInstance, text, internalInstanceHandle, shouldWarnDev) {\n  precacheFiberNode(internalInstanceHandle, textInstance); // TODO: Temporary hack to check if we're in a concurrent root. We can delete\n  // when the legacy root API is removed.\n\n  const isConcurrentMode = (internalInstanceHandle.mode & ConcurrentMode) !== NoMode;\n  return diffHydratedText(textInstance, text);\n}\nfunction hydrateSuspenseInstance(suspenseInstance, internalInstanceHandle) {\n  precacheFiberNode(internalInstanceHandle, suspenseInstance);\n}\nfunction getNextHydratableInstanceAfterSuspenseInstance(suspenseInstance) {\n  let node = suspenseInstance.nextSibling; // Skip past all nodes within this suspense boundary.\n  // There might be nested nodes so we need to keep track of how\n  // deep we are and only break out when we're back on top.\n\n  let depth = 0;\n\n  while (node) {\n    if (node.nodeType === COMMENT_NODE) {\n      const data = node.data;\n\n      if (data === SUSPENSE_END_DATA) {\n        if (depth === 0) {\n          return getNextHydratableSibling(node);\n        } else {\n          depth--;\n        }\n      } else if (data === SUSPENSE_START_DATA || data === SUSPENSE_FALLBACK_START_DATA || data === SUSPENSE_PENDING_START_DATA) {\n        depth++;\n      }\n    }\n\n    node = node.nextSibling;\n  } // TODO: Warn, we didn't find the end comment boundary.\n\n\n  return null;\n} // Returns the SuspenseInstance if this node is a direct child of a\n// SuspenseInstance. I.e. if its previous sibling is a Comment with\n// SUSPENSE_x_START_DATA. Otherwise, null.\n\nfunction getParentSuspenseInstance(targetInstance) {\n  let node = targetInstance.previousSibling; // Skip past all nodes within this suspense boundary.\n  // There might be nested nodes so we need to keep track of how\n  // deep we are and only break out when we're back on top.\n\n  let depth = 0;\n\n  while (node) {\n    if (node.nodeType === COMMENT_NODE) {\n      const data = node.data;\n\n      if (data === SUSPENSE_START_DATA || data === SUSPENSE_FALLBACK_START_DATA || data === SUSPENSE_PENDING_START_DATA) {\n        if (depth === 0) {\n          return node;\n        } else {\n          depth--;\n        }\n      } else if (data === SUSPENSE_END_DATA) {\n        depth++;\n      }\n    }\n\n    node = node.previousSibling;\n  }\n\n  return null;\n}\nfunction commitHydratedContainer(container) {\n  // Retry if any event replaying was blocked on this.\n  retryIfBlockedOn(container);\n}\nfunction commitHydratedSuspenseInstance(suspenseInstance) {\n  // Retry if any event replaying was blocked on this.\n  retryIfBlockedOn(suspenseInstance);\n}\nfunction shouldDeleteUnhydratedTailInstances(parentType) {\n  return parentType !== 'head' && parentType !== 'body';\n}\nfunction didNotMatchHydratedContainerTextInstance(parentContainer, textInstance, text, isConcurrentMode) {\n  checkForUnmatchedText(textInstance.nodeValue, text, isConcurrentMode);\n}\nfunction didNotMatchHydratedTextInstance(parentType, parentProps, parentInstance, textInstance, text, isConcurrentMode) {\n  if (parentProps[SUPPRESS_HYDRATION_WARNING$1] !== true) {\n    checkForUnmatchedText(textInstance.nodeValue, text, isConcurrentMode);\n  }\n}\nfunction preparePortalMount(portalInstance) {\n  listenToAllSupportedEvents(portalInstance);\n}\n\nconst randomKey = Math.random().toString(36).slice(2);\nconst internalInstanceKey = '__reactFiber$' + randomKey;\nconst internalPropsKey = '__reactProps$' + randomKey;\nconst internalContainerInstanceKey = '__reactContainer$' + randomKey;\nconst internalEventHandlersKey = '__reactEvents$' + randomKey;\nconst internalEventHandlerListenersKey = '__reactListeners$' + randomKey;\nconst internalEventHandlesSetKey = '__reactHandles$' + randomKey;\nfunction detachDeletedInstance(node) {\n  // TODO: This function is only called on host components. I don't think all of\n  // these fields are relevant.\n  delete node[internalInstanceKey];\n  delete node[internalPropsKey];\n  delete node[internalEventHandlersKey];\n  delete node[internalEventHandlerListenersKey];\n  delete node[internalEventHandlesSetKey];\n}\nfunction precacheFiberNode(hostInst, node) {\n  node[internalInstanceKey] = hostInst;\n}\nfunction markContainerAsRoot(hostRoot, node) {\n  node[internalContainerInstanceKey] = hostRoot;\n}\nfunction unmarkContainerAsRoot(node) {\n  node[internalContainerInstanceKey] = null;\n}\nfunction isContainerMarkedAsRoot(node) {\n  return !!node[internalContainerInstanceKey];\n} // Given a DOM node, return the closest HostComponent or HostText fiber ancestor.\n// If the target node is part of a hydrated or not yet rendered subtree, then\n// this may also return a SuspenseComponent or HostRoot to indicate that.\n// Conceptually the HostRoot fiber is a child of the Container node. So if you\n// pass the Container node as the targetNode, you will not actually get the\n// HostRoot back. To get to the HostRoot, you need to pass a child of it.\n// The same thing applies to Suspense boundaries.\n\nfunction getClosestInstanceFromNode(targetNode) {\n  let targetInst = targetNode[internalInstanceKey];\n\n  if (targetInst) {\n    // Don't return HostRoot or SuspenseComponent here.\n    return targetInst;\n  } // If the direct event target isn't a React owned DOM node, we need to look\n  // to see if one of its parents is a React owned DOM node.\n\n\n  let parentNode = targetNode.parentNode;\n\n  while (parentNode) {\n    // We'll check if this is a container root that could include\n    // React nodes in the future. We need to check this first because\n    // if we're a child of a dehydrated container, we need to first\n    // find that inner container before moving on to finding the parent\n    // instance. Note that we don't check this field on  the targetNode\n    // itself because the fibers are conceptually between the container\n    // node and the first child. It isn't surrounding the container node.\n    // If it's not a container, we check if it's an instance.\n    targetInst = parentNode[internalContainerInstanceKey] || parentNode[internalInstanceKey];\n\n    if (targetInst) {\n      // Since this wasn't the direct target of the event, we might have\n      // stepped past dehydrated DOM nodes to get here. However they could\n      // also have been non-React nodes. We need to answer which one.\n      // If we the instance doesn't have any children, then there can't be\n      // a nested suspense boundary within it. So we can use this as a fast\n      // bailout. Most of the time, when people add non-React children to\n      // the tree, it is using a ref to a child-less DOM node.\n      // Normally we'd only need to check one of the fibers because if it\n      // has ever gone from having children to deleting them or vice versa\n      // it would have deleted the dehydrated boundary nested inside already.\n      // However, since the HostRoot starts out with an alternate it might\n      // have one on the alternate so we need to check in case this was a\n      // root.\n      const alternate = targetInst.alternate;\n\n      if (targetInst.child !== null || alternate !== null && alternate.child !== null) {\n        // Next we need to figure out if the node that skipped past is\n        // nested within a dehydrated boundary and if so, which one.\n        let suspenseInstance = getParentSuspenseInstance(targetNode);\n\n        while (suspenseInstance !== null) {\n          // We found a suspense instance. That means that we haven't\n          // hydrated it yet. Even though we leave the comments in the\n          // DOM after hydrating, and there are boundaries in the DOM\n          // that could already be hydrated, we wouldn't have found them\n          // through this pass since if the target is hydrated it would\n          // have had an internalInstanceKey on it.\n          // Let's get the fiber associated with the SuspenseComponent\n          // as the deepest instance.\n          const targetSuspenseInst = suspenseInstance[internalInstanceKey];\n\n          if (targetSuspenseInst) {\n            return targetSuspenseInst;\n          } // If we don't find a Fiber on the comment, it might be because\n          // we haven't gotten to hydrate it yet. There might still be a\n          // parent boundary that hasn't above this one so we need to find\n          // the outer most that is known.\n\n\n          suspenseInstance = getParentSuspenseInstance(suspenseInstance); // If we don't find one, then that should mean that the parent\n          // host component also hasn't hydrated yet. We can return it\n          // below since it will bail out on the isMounted check later.\n        }\n      }\n\n      return targetInst;\n    }\n\n    targetNode = parentNode;\n    parentNode = targetNode.parentNode;\n  }\n\n  return null;\n}\n/**\n * Given a DOM node, return the ReactDOMComponent or ReactDOMTextComponent\n * instance, or null if the node was not rendered by this React.\n */\n\nfunction getInstanceFromNode(node) {\n  const inst = node[internalInstanceKey] || node[internalContainerInstanceKey];\n\n  if (inst) {\n    if (inst.tag === HostComponent || inst.tag === HostText || inst.tag === SuspenseComponent || inst.tag === HostRoot) {\n      return inst;\n    } else {\n      return null;\n    }\n  }\n\n  return null;\n}\n/**\n * Given a ReactDOMComponent or ReactDOMTextComponent, return the corresponding\n * DOM node.\n */\n\nfunction getNodeFromInstance(inst) {\n  if (inst.tag === HostComponent || inst.tag === HostText) {\n    // In Fiber this, is just the state node right now. We assume it will be\n    // a host component or host text.\n    return inst.stateNode;\n  } // Without this first invariant, passing a non-DOM-component triggers the next\n  // invariant for a missing parent, which is super confusing.\n\n\n  throw Error(formatProdErrorMessage(33));\n}\nfunction getFiberCurrentPropsFromNode(node) {\n  return node[internalPropsKey] || null;\n}\nfunction updateFiberProps(node, props) {\n  node[internalPropsKey] = props;\n}\nfunction getEventListenerSet(node) {\n  let elementListenerSet = node[internalEventHandlersKey];\n\n  if (elementListenerSet === undefined) {\n    elementListenerSet = node[internalEventHandlersKey] = new Set();\n  }\n\n  return elementListenerSet;\n}\n\nconst ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame;\n\nconst valueStack = [];\n\nlet index = -1;\n\nfunction createCursor(defaultValue) {\n  return {\n    current: defaultValue\n  };\n}\n\nfunction pop(cursor, fiber) {\n  if (index < 0) {\n\n    return;\n  }\n\n  cursor.current = valueStack[index];\n  valueStack[index] = null;\n\n  index--;\n}\n\nfunction push(cursor, value, fiber) {\n  index++;\n  valueStack[index] = cursor.current;\n\n  cursor.current = value;\n}\n\nconst emptyContextObject = {};\n\n\nconst contextStackCursor = createCursor(emptyContextObject); // A cursor to a boolean indicating whether the context has changed.\n\nconst didPerformWorkStackCursor = createCursor(false); // Keep track of the previous context object that was on the stack.\n// We use this to get access to the parent context after we have already\n// pushed the next context provider, and now need to merge their contexts.\n\nlet previousContext = emptyContextObject;\n\nfunction getUnmaskedContext(workInProgress, Component, didPushOwnContextIfProvider) {\n  {\n    if (didPushOwnContextIfProvider && isContextProvider(Component)) {\n      // If the fiber is a context provider itself, when we read its context\n      // we may have already pushed its own child context on the stack. A context\n      // provider should not \"see\" its own child context. Therefore we read the\n      // previous (parent) context instead for a context provider.\n      return previousContext;\n    }\n\n    return contextStackCursor.current;\n  }\n}\n\nfunction cacheContext(workInProgress, unmaskedContext, maskedContext) {\n  {\n    const instance = workInProgress.stateNode;\n    instance.__reactInternalMemoizedUnmaskedChildContext = unmaskedContext;\n    instance.__reactInternalMemoizedMaskedChildContext = maskedContext;\n  }\n}\n\nfunction getMaskedContext(workInProgress, unmaskedContext) {\n  {\n    const type = workInProgress.type;\n    const contextTypes = type.contextTypes;\n\n    if (!contextTypes) {\n      return emptyContextObject;\n    } // Avoid recreating masked context unless unmasked context has changed.\n    // Failing to do this will result in unnecessary calls to componentWillReceiveProps.\n    // This may trigger infinite loops if componentWillReceiveProps calls setState.\n\n\n    const instance = workInProgress.stateNode;\n\n    if (instance && instance.__reactInternalMemoizedUnmaskedChildContext === unmaskedContext) {\n      return instance.__reactInternalMemoizedMaskedChildContext;\n    }\n\n    const context = {};\n\n    for (const key in contextTypes) {\n      context[key] = unmaskedContext[key];\n    }\n    // Context is created before the class component is instantiated so check for instance.\n\n\n    if (instance) {\n      cacheContext(workInProgress, unmaskedContext, context);\n    }\n\n    return context;\n  }\n}\n\nfunction hasContextChanged() {\n  {\n    return didPerformWorkStackCursor.current;\n  }\n}\n\nfunction isContextProvider(type) {\n  {\n    const childContextTypes = type.childContextTypes;\n    return childContextTypes !== null && childContextTypes !== undefined;\n  }\n}\n\nfunction popContext(fiber) {\n  {\n    pop(didPerformWorkStackCursor);\n    pop(contextStackCursor);\n  }\n}\n\nfunction popTopLevelContextObject(fiber) {\n  {\n    pop(didPerformWorkStackCursor);\n    pop(contextStackCursor);\n  }\n}\n\nfunction pushTopLevelContextObject(fiber, context, didChange) {\n  {\n    if (contextStackCursor.current !== emptyContextObject) {\n      throw Error(formatProdErrorMessage(168));\n    }\n\n    push(contextStackCursor, context);\n    push(didPerformWorkStackCursor, didChange);\n  }\n}\n\nfunction processChildContext(fiber, type, parentContext) {\n  {\n    const instance = fiber.stateNode;\n    const childContextTypes = type.childContextTypes; // TODO (bvaughn) Replace this behavior with an invariant() in the future.\n    // It has only been added in Fiber to match the (unintentional) behavior in Stack.\n\n    if (typeof instance.getChildContext !== 'function') {\n\n      return parentContext;\n    }\n\n    const childContext = instance.getChildContext();\n\n    for (const contextKey in childContext) {\n      if (!(contextKey in childContextTypes)) {\n        throw Error(formatProdErrorMessage(108, getComponentNameFromFiber(fiber) || 'Unknown', contextKey));\n      }\n    }\n\n    return assign({}, parentContext, childContext);\n  }\n}\n\nfunction pushContextProvider(workInProgress) {\n  {\n    const instance = workInProgress.stateNode; // We push the context as early as possible to ensure stack integrity.\n    // If the instance does not exist yet, we will push null at first,\n    // and replace it on the stack later when invalidating the context.\n\n    const memoizedMergedChildContext = instance && instance.__reactInternalMemoizedMergedChildContext || emptyContextObject; // Remember the parent context so we can merge with it later.\n    // Inherit the parent's did-perform-work value to avoid inadvertently blocking updates.\n\n    previousContext = contextStackCursor.current;\n    push(contextStackCursor, memoizedMergedChildContext);\n    push(didPerformWorkStackCursor, didPerformWorkStackCursor.current);\n    return true;\n  }\n}\n\nfunction invalidateContextProvider(workInProgress, type, didChange) {\n  {\n    const instance = workInProgress.stateNode;\n\n    if (!instance) {\n      throw Error(formatProdErrorMessage(169));\n    }\n\n    if (didChange) {\n      // Merge parent and own context.\n      // Skip this if we're not updating due to sCU.\n      // This avoids unnecessarily recomputing memoized values.\n      const mergedContext = processChildContext(workInProgress, type, previousContext);\n      instance.__reactInternalMemoizedMergedChildContext = mergedContext; // Replace the old (or empty) context with the new one.\n      // It is important to unwind the context in the reverse order.\n\n      pop(didPerformWorkStackCursor);\n      pop(contextStackCursor); // Now push the new context and mark that it has changed.\n\n      push(contextStackCursor, mergedContext);\n      push(didPerformWorkStackCursor, didChange);\n    } else {\n      pop(didPerformWorkStackCursor);\n      push(didPerformWorkStackCursor, didChange);\n    }\n  }\n}\n\nfunction findCurrentUnmaskedContext(fiber) {\n  {\n    // Currently this is only used with renderSubtreeIntoContainer; not sure if it\n    // makes sense elsewhere\n    if (!isFiberMounted(fiber) || fiber.tag !== ClassComponent) {\n      throw Error(formatProdErrorMessage(170));\n    }\n\n    let node = fiber;\n\n    do {\n      switch (node.tag) {\n        case HostRoot:\n          return node.stateNode.context;\n\n        case ClassComponent:\n          {\n            const Component = node.type;\n\n            if (isContextProvider(Component)) {\n              return node.stateNode.__reactInternalMemoizedMergedChildContext;\n            }\n\n            break;\n          }\n      }\n\n      node = node.return;\n    } while (node !== null);\n\n    throw Error(formatProdErrorMessage(171));\n  }\n}\n\nconst LegacyRoot = 0;\nconst ConcurrentRoot = 1;\n\nlet syncQueue = null;\nlet includesLegacySyncCallbacks = false;\nlet isFlushingSyncQueue = false;\nfunction scheduleSyncCallback(callback) {\n  // Push this callback into an internal queue. We'll flush these either in\n  // the next tick, or earlier if something calls `flushSyncCallbackQueue`.\n  if (syncQueue === null) {\n    syncQueue = [callback];\n  } else {\n    // Push onto existing queue. Don't need to schedule a callback because\n    // we already scheduled one when we created the queue.\n    syncQueue.push(callback);\n  }\n}\nfunction scheduleLegacySyncCallback(callback) {\n  includesLegacySyncCallbacks = true;\n  scheduleSyncCallback(callback);\n}\nfunction flushSyncCallbacksOnlyInLegacyMode() {\n  // Only flushes the queue if there's a legacy sync callback scheduled.\n  // TODO: There's only a single type of callback: performSyncOnWorkOnRoot. So\n  // it might make more sense for the queue to be a list of roots instead of a\n  // list of generic callbacks. Then we can have two: one for legacy roots, one\n  // for concurrent roots. And this method would only flush the legacy ones.\n  if (includesLegacySyncCallbacks) {\n    flushSyncCallbacks();\n  }\n}\nfunction flushSyncCallbacks() {\n  if (!isFlushingSyncQueue && syncQueue !== null) {\n    // Prevent re-entrance.\n    isFlushingSyncQueue = true;\n    let i = 0;\n    const previousUpdatePriority = getCurrentUpdatePriority();\n\n    try {\n      const isSync = true;\n      const queue = syncQueue; // TODO: Is this necessary anymore? The only user code that runs in this\n      // queue is in the render or commit phases.\n\n      setCurrentUpdatePriority(DiscreteEventPriority);\n\n      for (; i < queue.length; i++) {\n        let callback = queue[i];\n\n        do {\n          callback = callback(isSync);\n        } while (callback !== null);\n      }\n\n      syncQueue = null;\n      includesLegacySyncCallbacks = false;\n    } catch (error) {\n      // If something throws, leave the remaining callbacks on the queue.\n      if (syncQueue !== null) {\n        syncQueue = syncQueue.slice(i + 1);\n      } // Resume flushing in the next tick\n\n\n      scheduleCallback(ImmediatePriority, flushSyncCallbacks);\n      throw error;\n    } finally {\n      setCurrentUpdatePriority(previousUpdatePriority);\n      isFlushingSyncQueue = false;\n    }\n  }\n\n  return null;\n}\n\n// Ids are base 32 strings whose binary representation corresponds to the\n// TODO: Use the unified fiber stack module instead of this local one?\n// Intentionally not using it yet to derisk the initial implementation, because\n// the way we push/pop these values is a bit unusual. If there's a mistake, I'd\n// rather the ids be wrong than crash the whole reconciler.\nconst forkStack = [];\nlet forkStackIndex = 0;\nlet treeForkProvider = null;\nlet treeForkCount = 0;\nconst idStack = [];\nlet idStackIndex = 0;\nlet treeContextProvider = null;\nlet treeContextId = 1;\nlet treeContextOverflow = '';\nfunction isForkedChild(workInProgress) {\n  return (workInProgress.flags & Forked) !== NoFlags;\n}\nfunction getForksAtLevel(workInProgress) {\n  return treeForkCount;\n}\nfunction getTreeId() {\n  const overflow = treeContextOverflow;\n  const idWithLeadingBit = treeContextId;\n  const id = idWithLeadingBit & ~getLeadingBit(idWithLeadingBit);\n  return id.toString(32) + overflow;\n}\nfunction pushTreeFork(workInProgress, totalChildren) {\n  forkStack[forkStackIndex++] = treeForkCount;\n  forkStack[forkStackIndex++] = treeForkProvider;\n  treeForkProvider = workInProgress;\n  treeForkCount = totalChildren;\n}\nfunction pushTreeId(workInProgress, totalChildren, index) {\n  idStack[idStackIndex++] = treeContextId;\n  idStack[idStackIndex++] = treeContextOverflow;\n  idStack[idStackIndex++] = treeContextProvider;\n  treeContextProvider = workInProgress;\n  const baseIdWithLeadingBit = treeContextId;\n  const baseOverflow = treeContextOverflow; // The leftmost 1 marks the end of the sequence, non-inclusive. It's not part\n  // of the id; we use it to account for leading 0s.\n\n  const baseLength = getBitLength(baseIdWithLeadingBit) - 1;\n  const baseId = baseIdWithLeadingBit & ~(1 << baseLength);\n  const slot = index + 1;\n  const length = getBitLength(totalChildren) + baseLength; // 30 is the max length we can store without overflowing, taking into\n  // consideration the leading 1 we use to mark the end of the sequence.\n\n  if (length > 30) {\n    // We overflowed the bitwise-safe range. Fall back to slower algorithm.\n    // This branch assumes the length of the base id is greater than 5; it won't\n    // work for smaller ids, because you need 5 bits per character.\n    //\n    // We encode the id in multiple steps: first the base id, then the\n    // remaining digits.\n    //\n    // Each 5 bit sequence corresponds to a single base 32 character. So for\n    // example, if the current id is 23 bits long, we can convert 20 of those\n    // bits into a string of 4 characters, with 3 bits left over.\n    //\n    // First calculate how many bits in the base id represent a complete\n    // sequence of characters.\n    const numberOfOverflowBits = baseLength - baseLength % 5; // Then create a bitmask that selects only those bits.\n\n    const newOverflowBits = (1 << numberOfOverflowBits) - 1; // Select the bits, and convert them to a base 32 string.\n\n    const newOverflow = (baseId & newOverflowBits).toString(32); // Now we can remove those bits from the base id.\n\n    const restOfBaseId = baseId >> numberOfOverflowBits;\n    const restOfBaseLength = baseLength - numberOfOverflowBits; // Finally, encode the rest of the bits using the normal algorithm. Because\n    // we made more room, this time it won't overflow.\n\n    const restOfLength = getBitLength(totalChildren) + restOfBaseLength;\n    const restOfNewBits = slot << restOfBaseLength;\n    const id = restOfNewBits | restOfBaseId;\n    const overflow = newOverflow + baseOverflow;\n    treeContextId = 1 << restOfLength | id;\n    treeContextOverflow = overflow;\n  } else {\n    // Normal path\n    const newBits = slot << baseLength;\n    const id = newBits | baseId;\n    const overflow = baseOverflow;\n    treeContextId = 1 << length | id;\n    treeContextOverflow = overflow;\n  }\n}\nfunction pushMaterializedTreeId(workInProgress) {\n  // in its children.\n\n  const returnFiber = workInProgress.return;\n\n  if (returnFiber !== null) {\n    const numberOfForks = 1;\n    const slotIndex = 0;\n    pushTreeFork(workInProgress, numberOfForks);\n    pushTreeId(workInProgress, numberOfForks, slotIndex);\n  }\n}\n\nfunction getBitLength(number) {\n  return 32 - clz32(number);\n}\n\nfunction getLeadingBit(id) {\n  return 1 << getBitLength(id) - 1;\n}\n\nfunction popTreeContext(workInProgress) {\n  // Restore the previous values.\n  // This is a bit more complicated than other context-like modules in Fiber\n  // because the same Fiber may appear on the stack multiple times and for\n  // different reasons. We have to keep popping until the work-in-progress is\n  // no longer at the top of the stack.\n  while (workInProgress === treeForkProvider) {\n    treeForkProvider = forkStack[--forkStackIndex];\n    forkStack[forkStackIndex] = null;\n    treeForkCount = forkStack[--forkStackIndex];\n    forkStack[forkStackIndex] = null;\n  }\n\n  while (workInProgress === treeContextProvider) {\n    treeContextProvider = idStack[--idStackIndex];\n    idStack[idStackIndex] = null;\n    treeContextOverflow = idStack[--idStackIndex];\n    idStack[idStackIndex] = null;\n    treeContextId = idStack[--idStackIndex];\n    idStack[idStackIndex] = null;\n  }\n}\nfunction getSuspendedTreeContext() {\n\n  if (treeContextProvider !== null) {\n    return {\n      id: treeContextId,\n      overflow: treeContextOverflow\n    };\n  } else {\n    return null;\n  }\n}\nfunction restoreSuspendedTreeContext(workInProgress, suspendedContext) {\n  idStack[idStackIndex++] = treeContextId;\n  idStack[idStackIndex++] = treeContextOverflow;\n  idStack[idStackIndex++] = treeContextProvider;\n  treeContextId = suspendedContext.id;\n  treeContextOverflow = suspendedContext.overflow;\n  treeContextProvider = workInProgress;\n}\n\n// This may have been an insertion or a hydration.\n\nlet hydrationParentFiber = null;\nlet nextHydratableInstance = null;\nlet isHydrating = false; // This flag allows for warning supression when we expect there to be mismatches\n// due to earlier mismatches or a suspended fiber.\n\nlet didSuspendOrErrorDEV = false; // Hydration errors that were thrown inside this boundary\n\nlet hydrationErrors = null;\n\nfunction enterHydrationState(fiber) {\n\n  const parentInstance = fiber.stateNode.containerInfo;\n  nextHydratableInstance = getFirstHydratableChildWithinContainer(parentInstance);\n  hydrationParentFiber = fiber;\n  isHydrating = true;\n  hydrationErrors = null;\n  didSuspendOrErrorDEV = false;\n  return true;\n}\n\nfunction reenterHydrationStateFromDehydratedSuspenseInstance(fiber, suspenseInstance, treeContext) {\n\n  nextHydratableInstance = getFirstHydratableChildWithinSuspenseInstance(suspenseInstance);\n  hydrationParentFiber = fiber;\n  isHydrating = true;\n  hydrationErrors = null;\n  didSuspendOrErrorDEV = false;\n\n  if (treeContext !== null) {\n    restoreSuspendedTreeContext(fiber, treeContext);\n  }\n\n  return true;\n}\n\nfunction deleteHydratableInstance(returnFiber, instance) {\n  const childToDelete = createFiberFromHostInstanceForDeletion();\n  childToDelete.stateNode = instance;\n  childToDelete.return = returnFiber;\n  const deletions = returnFiber.deletions;\n\n  if (deletions === null) {\n    returnFiber.deletions = [childToDelete];\n    returnFiber.flags |= ChildDeletion;\n  } else {\n    deletions.push(childToDelete);\n  }\n}\n\nfunction insertNonHydratedInstance(returnFiber, fiber) {\n  fiber.flags = fiber.flags & ~Hydrating | Placement;\n}\n\nfunction tryHydrate(fiber, nextInstance) {\n  switch (fiber.tag) {\n    case HostComponent:\n      {\n        const type = fiber.type;\n        const props = fiber.pendingProps;\n        const instance = canHydrateInstance(nextInstance, type);\n\n        if (instance !== null) {\n          fiber.stateNode = instance;\n          hydrationParentFiber = fiber;\n          nextHydratableInstance = getFirstHydratableChild(instance);\n          return true;\n        }\n\n        return false;\n      }\n\n    case HostText:\n      {\n        const text = fiber.pendingProps;\n        const textInstance = canHydrateTextInstance(nextInstance, text);\n\n        if (textInstance !== null) {\n          fiber.stateNode = textInstance;\n          hydrationParentFiber = fiber; // Text Instances don't have children so there's nothing to hydrate.\n\n          nextHydratableInstance = null;\n          return true;\n        }\n\n        return false;\n      }\n\n    case SuspenseComponent:\n      {\n        const suspenseInstance = canHydrateSuspenseInstance(nextInstance);\n\n        if (suspenseInstance !== null) {\n          const suspenseState = {\n            dehydrated: suspenseInstance,\n            treeContext: getSuspendedTreeContext(),\n            retryLane: OffscreenLane\n          };\n          fiber.memoizedState = suspenseState; // Store the dehydrated fragment as a child fiber.\n          // This simplifies the code for getHostSibling and deleting nodes,\n          // since it doesn't have to consider all Suspense boundaries and\n          // check if they're dehydrated ones or not.\n\n          const dehydratedFragment = createFiberFromDehydratedFragment(suspenseInstance);\n          dehydratedFragment.return = fiber;\n          fiber.child = dehydratedFragment;\n          hydrationParentFiber = fiber; // While a Suspense Instance does have children, we won't step into\n          // it during the first pass. Instead, we'll reenter it later.\n\n          nextHydratableInstance = null;\n          return true;\n        }\n\n        return false;\n      }\n\n    default:\n      return false;\n  }\n}\n\nfunction shouldClientRenderOnMismatch(fiber) {\n  return (fiber.mode & ConcurrentMode) !== NoMode && (fiber.flags & DidCapture) === NoFlags;\n}\n\nfunction throwOnHydrationMismatch(fiber) {\n  throw Error(formatProdErrorMessage(418));\n}\n\nfunction tryToClaimNextHydratableInstance(fiber) {\n  if (!isHydrating) {\n    return;\n  }\n\n  let nextInstance = nextHydratableInstance;\n\n  if (!nextInstance) {\n    if (shouldClientRenderOnMismatch(fiber)) {\n      throwOnHydrationMismatch();\n    } // Nothing to hydrate. Make it an insertion.\n\n\n    insertNonHydratedInstance(hydrationParentFiber, fiber);\n    isHydrating = false;\n    hydrationParentFiber = fiber;\n    return;\n  }\n\n  const firstAttemptedInstance = nextInstance;\n\n  if (!tryHydrate(fiber, nextInstance)) {\n    if (shouldClientRenderOnMismatch(fiber)) {\n      throwOnHydrationMismatch();\n    } // If we can't hydrate this instance let's try the next one.\n    // We use this as a heuristic. It's based on intuition and not data so it\n    // might be flawed or unnecessary.\n\n\n    nextInstance = getNextHydratableSibling(firstAttemptedInstance);\n    const prevHydrationParentFiber = hydrationParentFiber;\n\n    if (!nextInstance || !tryHydrate(fiber, nextInstance)) {\n      // Nothing to hydrate. Make it an insertion.\n      insertNonHydratedInstance(hydrationParentFiber, fiber);\n      isHydrating = false;\n      hydrationParentFiber = fiber;\n      return;\n    } // We matched the next one, we'll now assume that the first one was\n    // superfluous and we'll delete it. Since we can't eagerly delete it\n    // we'll have to schedule a deletion. To do that, this node needs a dummy\n    // fiber associated with it.\n\n\n    deleteHydratableInstance(prevHydrationParentFiber, firstAttemptedInstance);\n  }\n}\n\nfunction prepareToHydrateHostInstance(fiber, rootContainerInstance, hostContext) {\n\n  const instance = fiber.stateNode;\n  const shouldWarnIfMismatchDev = !didSuspendOrErrorDEV;\n  const updatePayload = hydrateInstance(instance, fiber.type, fiber.memoizedProps, rootContainerInstance, hostContext, fiber, shouldWarnIfMismatchDev); // TODO: Type this specific to this type of component.\n\n  fiber.updateQueue = updatePayload; // If the update payload indicates that there is a change or if there\n  // is a new ref we mark this as an update.\n\n  if (updatePayload !== null) {\n    return true;\n  }\n\n  return false;\n}\n\nfunction prepareToHydrateHostTextInstance(fiber) {\n\n  const textInstance = fiber.stateNode;\n  const textContent = fiber.memoizedProps;\n  const shouldUpdate = hydrateTextInstance(textInstance, textContent, fiber);\n\n  if (shouldUpdate) {\n    // We assume that prepareToHydrateHostTextInstance is called in a context where the\n    // hydration parent is the parent host component of this host text.\n    const returnFiber = hydrationParentFiber;\n\n    if (returnFiber !== null) {\n      switch (returnFiber.tag) {\n        case HostRoot:\n          {\n            const parentContainer = returnFiber.stateNode.containerInfo;\n            const isConcurrentMode = (returnFiber.mode & ConcurrentMode) !== NoMode;\n            didNotMatchHydratedContainerTextInstance(parentContainer, textInstance, textContent, // TODO: Delete this argument when we remove the legacy root API.\n            isConcurrentMode);\n            break;\n          }\n\n        case HostComponent:\n          {\n            const parentType = returnFiber.type;\n            const parentProps = returnFiber.memoizedProps;\n            const parentInstance = returnFiber.stateNode;\n            const isConcurrentMode = (returnFiber.mode & ConcurrentMode) !== NoMode;\n            didNotMatchHydratedTextInstance(parentType, parentProps, parentInstance, textInstance, textContent, // TODO: Delete this argument when we remove the legacy root API.\n            isConcurrentMode);\n            break;\n          }\n      }\n    }\n  }\n\n  return shouldUpdate;\n}\n\nfunction prepareToHydrateHostSuspenseInstance(fiber) {\n\n  const suspenseState = fiber.memoizedState;\n  const suspenseInstance = suspenseState !== null ? suspenseState.dehydrated : null;\n\n  if (!suspenseInstance) {\n    throw Error(formatProdErrorMessage(317));\n  }\n\n  hydrateSuspenseInstance(suspenseInstance, fiber);\n}\n\nfunction skipPastDehydratedSuspenseInstance(fiber) {\n\n  const suspenseState = fiber.memoizedState;\n  const suspenseInstance = suspenseState !== null ? suspenseState.dehydrated : null;\n\n  if (!suspenseInstance) {\n    throw Error(formatProdErrorMessage(317));\n  }\n\n  return getNextHydratableInstanceAfterSuspenseInstance(suspenseInstance);\n}\n\nfunction popToNextHostParent(fiber) {\n  let parent = fiber.return;\n\n  while (parent !== null && parent.tag !== HostComponent && parent.tag !== HostRoot && parent.tag !== SuspenseComponent) {\n    parent = parent.return;\n  }\n\n  hydrationParentFiber = parent;\n}\n\nfunction popHydrationState(fiber) {\n\n  if (fiber !== hydrationParentFiber) {\n    // We're deeper than the current hydration context, inside an inserted\n    // tree.\n    return false;\n  }\n\n  if (!isHydrating) {\n    // If we're not currently hydrating but we're in a hydration context, then\n    // we were an insertion and now need to pop up reenter hydration of our\n    // siblings.\n    popToNextHostParent(fiber);\n    isHydrating = true;\n    return false;\n  } // If we have any remaining hydratable nodes, we need to delete them now.\n  // We only do this deeper than head and body since they tend to have random\n  // other nodes in them. We also ignore components with pure text content in\n  // side of them. We also don't delete anything inside the root container.\n\n\n  if (fiber.tag !== HostRoot && (fiber.tag !== HostComponent || shouldDeleteUnhydratedTailInstances(fiber.type) && !shouldSetTextContent(fiber.type, fiber.memoizedProps))) {\n    let nextInstance = nextHydratableInstance;\n\n    if (nextInstance) {\n      if (shouldClientRenderOnMismatch(fiber)) {\n        warnIfUnhydratedTailNodes();\n        throwOnHydrationMismatch();\n      } else {\n        while (nextInstance) {\n          deleteHydratableInstance(fiber, nextInstance);\n          nextInstance = getNextHydratableSibling(nextInstance);\n        }\n      }\n    }\n  }\n\n  popToNextHostParent(fiber);\n\n  if (fiber.tag === SuspenseComponent) {\n    nextHydratableInstance = skipPastDehydratedSuspenseInstance(fiber);\n  } else {\n    nextHydratableInstance = hydrationParentFiber ? getNextHydratableSibling(fiber.stateNode) : null;\n  }\n\n  return true;\n}\n\nfunction hasUnhydratedTailNodes() {\n  return isHydrating && nextHydratableInstance !== null;\n}\n\nfunction warnIfUnhydratedTailNodes(fiber) {\n  let nextInstance = nextHydratableInstance;\n\n  while (nextInstance) {\n    nextInstance = getNextHydratableSibling(nextInstance);\n  }\n}\n\nfunction resetHydrationState() {\n\n  hydrationParentFiber = null;\n  nextHydratableInstance = null;\n  isHydrating = false;\n  didSuspendOrErrorDEV = false;\n}\n\nfunction upgradeHydrationErrorsToRecoverable() {\n  if (hydrationErrors !== null) {\n    // Successfully completed a forced client render. The errors that occurred\n    // during the hydration attempt are now recovered. We will log them in\n    // commit phase, once the entire tree has finished.\n    queueRecoverableErrors(hydrationErrors);\n    hydrationErrors = null;\n  }\n}\n\nfunction getIsHydrating() {\n  return isHydrating;\n}\n\nfunction queueHydrationError(error) {\n  if (hydrationErrors === null) {\n    hydrationErrors = [error];\n  } else {\n    hydrationErrors.push(error);\n  }\n}\n\nconst ReactCurrentBatchConfig$1 = ReactSharedInternals.ReactCurrentBatchConfig;\nconst NoTransition = null;\nfunction requestCurrentTransition() {\n  return ReactCurrentBatchConfig$1.transition;\n}\n\nfunction resolveDefaultProps(Component, baseProps) {\n  if (Component && Component.defaultProps) {\n    // Resolve default props. Taken from ReactElement\n    const props = assign({}, baseProps);\n    const defaultProps = Component.defaultProps;\n\n    for (const propName in defaultProps) {\n      if (props[propName] === undefined) {\n        props[propName] = defaultProps[propName];\n      }\n    }\n\n    return props;\n  }\n\n  return baseProps;\n}\n\nconst valueCursor = createCursor(null);\n\nlet currentlyRenderingFiber = null;\nlet lastContextDependency = null;\nlet lastFullyObservedContext = null;\nfunction resetContextDependencies() {\n  // This is called right before React yields execution, to ensure `readContext`\n  // cannot be called outside the render phase.\n  currentlyRenderingFiber = null;\n  lastContextDependency = null;\n  lastFullyObservedContext = null;\n}\nfunction pushProvider(providerFiber, context, nextValue) {\n  {\n    push(valueCursor, context._currentValue);\n    context._currentValue = nextValue;\n  }\n}\nfunction popProvider(context, providerFiber) {\n  const currentValue = valueCursor.current;\n  pop(valueCursor);\n\n  {\n    {\n      context._currentValue = currentValue;\n    }\n  }\n}\nfunction scheduleContextWorkOnParentPath(parent, renderLanes, propagationRoot) {\n  // Update the child lanes of all the ancestors, including the alternates.\n  let node = parent;\n\n  while (node !== null) {\n    const alternate = node.alternate;\n\n    if (!isSubsetOfLanes(node.childLanes, renderLanes)) {\n      node.childLanes = mergeLanes(node.childLanes, renderLanes);\n\n      if (alternate !== null) {\n        alternate.childLanes = mergeLanes(alternate.childLanes, renderLanes);\n      }\n    } else if (alternate !== null && !isSubsetOfLanes(alternate.childLanes, renderLanes)) {\n      alternate.childLanes = mergeLanes(alternate.childLanes, renderLanes);\n    }\n\n    if (node === propagationRoot) {\n      break;\n    }\n\n    node = node.return;\n  }\n}\nfunction propagateContextChange(workInProgress, context, renderLanes) {\n  {\n    propagateContextChange_eager(workInProgress, context, renderLanes);\n  }\n}\n\nfunction propagateContextChange_eager(workInProgress, context, renderLanes) {\n\n  let fiber = workInProgress.child;\n\n  if (fiber !== null) {\n    // Set the return pointer of the child to the work-in-progress fiber.\n    fiber.return = workInProgress;\n  }\n\n  while (fiber !== null) {\n    let nextFiber; // Visit this fiber.\n\n    const list = fiber.dependencies;\n\n    if (list !== null) {\n      nextFiber = fiber.child;\n      let dependency = list.firstContext;\n\n      while (dependency !== null) {\n        // Check if the context matches.\n        if (dependency.context === context) {\n          // Match! Schedule an update on this fiber.\n          if (fiber.tag === ClassComponent) {\n            // Schedule a force update on the work-in-progress.\n            const lane = pickArbitraryLane(renderLanes);\n            const update = createUpdate(NoTimestamp, lane);\n            update.tag = ForceUpdate; // TODO: Because we don't have a work-in-progress, this will add the\n            // update to the current fiber, too, which means it will persist even if\n            // this render is thrown away. Since it's a race condition, not sure it's\n            // worth fixing.\n            // Inlined `enqueueUpdate` to remove interleaved update check\n\n            const updateQueue = fiber.updateQueue;\n\n            if (updateQueue === null) ; else {\n              const sharedQueue = updateQueue.shared;\n              const pending = sharedQueue.pending;\n\n              if (pending === null) {\n                // This is the first update. Create a circular list.\n                update.next = update;\n              } else {\n                update.next = pending.next;\n                pending.next = update;\n              }\n\n              sharedQueue.pending = update;\n            }\n          }\n\n          fiber.lanes = mergeLanes(fiber.lanes, renderLanes);\n          const alternate = fiber.alternate;\n\n          if (alternate !== null) {\n            alternate.lanes = mergeLanes(alternate.lanes, renderLanes);\n          }\n\n          scheduleContextWorkOnParentPath(fiber.return, renderLanes, workInProgress); // Mark the updated lanes on the list, too.\n\n          list.lanes = mergeLanes(list.lanes, renderLanes); // Since we already found a match, we can stop traversing the\n          // dependency list.\n\n          break;\n        }\n\n        dependency = dependency.next;\n      }\n    } else if (fiber.tag === ContextProvider) {\n      // Don't scan deeper if this is a matching provider\n      nextFiber = fiber.type === workInProgress.type ? null : fiber.child;\n    } else if (fiber.tag === DehydratedFragment) {\n      // If a dehydrated suspense boundary is in this subtree, we don't know\n      // if it will have any context consumers in it. The best we can do is\n      // mark it as having updates.\n      const parentSuspense = fiber.return;\n\n      if (parentSuspense === null) {\n        throw Error(formatProdErrorMessage(341));\n      }\n\n      parentSuspense.lanes = mergeLanes(parentSuspense.lanes, renderLanes);\n      const alternate = parentSuspense.alternate;\n\n      if (alternate !== null) {\n        alternate.lanes = mergeLanes(alternate.lanes, renderLanes);\n      } // This is intentionally passing this fiber as the parent\n      // because we want to schedule this fiber as having work\n      // on its children. We'll use the childLanes on\n      // this fiber to indicate that a context has changed.\n\n\n      scheduleContextWorkOnParentPath(parentSuspense, renderLanes, workInProgress);\n      nextFiber = fiber.sibling;\n    } else {\n      // Traverse down.\n      nextFiber = fiber.child;\n    }\n\n    if (nextFiber !== null) {\n      // Set the return pointer of the child to the work-in-progress fiber.\n      nextFiber.return = fiber;\n    } else {\n      // No child. Traverse to next sibling.\n      nextFiber = fiber;\n\n      while (nextFiber !== null) {\n        if (nextFiber === workInProgress) {\n          // We're back to the root of this subtree. Exit.\n          nextFiber = null;\n          break;\n        }\n\n        const sibling = nextFiber.sibling;\n\n        if (sibling !== null) {\n          // Set the return pointer of the sibling to the work-in-progress fiber.\n          sibling.return = nextFiber.return;\n          nextFiber = sibling;\n          break;\n        } // No more siblings. Traverse up.\n\n\n        nextFiber = nextFiber.return;\n      }\n    }\n\n    fiber = nextFiber;\n  }\n}\nfunction prepareToReadContext(workInProgress, renderLanes) {\n  currentlyRenderingFiber = workInProgress;\n  lastContextDependency = null;\n  lastFullyObservedContext = null;\n  const dependencies = workInProgress.dependencies;\n\n  if (dependencies !== null) {\n    {\n      const firstContext = dependencies.firstContext;\n\n      if (firstContext !== null) {\n        if (includesSomeLane(dependencies.lanes, renderLanes)) {\n          // Context list has a pending update. Mark that this fiber performed work.\n          markWorkInProgressReceivedUpdate();\n        } // Reset the work-in-progress list\n\n\n        dependencies.firstContext = null;\n      }\n    }\n  }\n}\nfunction readContext(context) {\n\n  const value =  context._currentValue ;\n\n  if (lastFullyObservedContext === context) ; else {\n    const contextItem = {\n      context: context,\n      memoizedValue: value,\n      next: null\n    };\n\n    if (lastContextDependency === null) {\n      if (currentlyRenderingFiber === null) {\n        throw Error(formatProdErrorMessage(308));\n      } // This is the first dependency for this component. Create a new list.\n\n\n      lastContextDependency = contextItem;\n      currentlyRenderingFiber.dependencies = {\n        lanes: NoLanes,\n        firstContext: contextItem\n      };\n    } else {\n      // Append a new context item.\n      lastContextDependency = lastContextDependency.next = contextItem;\n    }\n  }\n\n  return value;\n}\n\n// render. When this render exits, either because it finishes or because it is\n// interrupted, the interleaved updates will be transferred onto the main part\n// of the queue.\n\nlet concurrentQueues = null;\nfunction pushConcurrentUpdateQueue(queue) {\n  if (concurrentQueues === null) {\n    concurrentQueues = [queue];\n  } else {\n    concurrentQueues.push(queue);\n  }\n}\nfunction finishQueueingConcurrentUpdates() {\n  // Transfer the interleaved updates onto the main queue. Each queue has a\n  // `pending` field and an `interleaved` field. When they are not null, they\n  // point to the last node in a circular linked list. We need to append the\n  // interleaved list to the end of the pending list by joining them into a\n  // single, circular list.\n  if (concurrentQueues !== null) {\n    for (let i = 0; i < concurrentQueues.length; i++) {\n      const queue = concurrentQueues[i];\n      const lastInterleavedUpdate = queue.interleaved;\n\n      if (lastInterleavedUpdate !== null) {\n        queue.interleaved = null;\n        const firstInterleavedUpdate = lastInterleavedUpdate.next;\n        const lastPendingUpdate = queue.pending;\n\n        if (lastPendingUpdate !== null) {\n          const firstPendingUpdate = lastPendingUpdate.next;\n          lastPendingUpdate.next = firstInterleavedUpdate;\n          lastInterleavedUpdate.next = firstPendingUpdate;\n        }\n\n        queue.pending = lastInterleavedUpdate;\n      }\n    }\n\n    concurrentQueues = null;\n  }\n}\nfunction enqueueConcurrentHookUpdate(fiber, queue, update, lane) {\n  const interleaved = queue.interleaved;\n\n  if (interleaved === null) {\n    // This is the first update. Create a circular list.\n    update.next = update; // At the end of the current render, this queue's interleaved updates will\n    // be transferred to the pending queue.\n\n    pushConcurrentUpdateQueue(queue);\n  } else {\n    update.next = interleaved.next;\n    interleaved.next = update;\n  }\n\n  queue.interleaved = update;\n  return markUpdateLaneFromFiberToRoot(fiber, lane);\n}\nfunction enqueueConcurrentHookUpdateAndEagerlyBailout(fiber, queue, update, lane) {\n  const interleaved = queue.interleaved;\n\n  if (interleaved === null) {\n    // This is the first update. Create a circular list.\n    update.next = update; // At the end of the current render, this queue's interleaved updates will\n    // be transferred to the pending queue.\n\n    pushConcurrentUpdateQueue(queue);\n  } else {\n    update.next = interleaved.next;\n    interleaved.next = update;\n  }\n\n  queue.interleaved = update;\n}\nfunction enqueueConcurrentClassUpdate(fiber, queue, update, lane) {\n  const interleaved = queue.interleaved;\n\n  if (interleaved === null) {\n    // This is the first update. Create a circular list.\n    update.next = update; // At the end of the current render, this queue's interleaved updates will\n    // be transferred to the pending queue.\n\n    pushConcurrentUpdateQueue(queue);\n  } else {\n    update.next = interleaved.next;\n    interleaved.next = update;\n  }\n\n  queue.interleaved = update;\n  return markUpdateLaneFromFiberToRoot(fiber, lane);\n}\nfunction enqueueConcurrentRenderForLane(fiber, lane) {\n  return markUpdateLaneFromFiberToRoot(fiber, lane);\n} // Calling this function outside this module should only be done for backwards\n// compatibility and should always be accompanied by a warning.\n\nconst unsafe_markUpdateLaneFromFiberToRoot = markUpdateLaneFromFiberToRoot;\n\nfunction markUpdateLaneFromFiberToRoot(sourceFiber, lane) {\n  // Update the source fiber's lanes\n  sourceFiber.lanes = mergeLanes(sourceFiber.lanes, lane);\n  let alternate = sourceFiber.alternate;\n\n  if (alternate !== null) {\n    alternate.lanes = mergeLanes(alternate.lanes, lane);\n  }\n\n\n  let node = sourceFiber;\n  let parent = sourceFiber.return;\n\n  while (parent !== null) {\n    parent.childLanes = mergeLanes(parent.childLanes, lane);\n    alternate = parent.alternate;\n\n    if (alternate !== null) {\n      alternate.childLanes = mergeLanes(alternate.childLanes, lane);\n    }\n\n    node = parent;\n    parent = parent.return;\n  }\n\n  if (node.tag === HostRoot) {\n    const root = node.stateNode;\n    return root;\n  } else {\n    return null;\n  }\n}\n\nconst UpdateState = 0;\nconst ReplaceState = 1;\nconst ForceUpdate = 2;\nconst CaptureUpdate = 3; // Global state that is reset at the beginning of calling `processUpdateQueue`.\n// It should only be read right after calling `processUpdateQueue`, via\n// `checkHasForceUpdateAfterProcessing`.\n\nlet hasForceUpdate = false;\n\nfunction initializeUpdateQueue(fiber) {\n  const queue = {\n    baseState: fiber.memoizedState,\n    firstBaseUpdate: null,\n    lastBaseUpdate: null,\n    shared: {\n      pending: null,\n      interleaved: null,\n      lanes: NoLanes\n    },\n    effects: null\n  };\n  fiber.updateQueue = queue;\n}\nfunction cloneUpdateQueue(current, workInProgress) {\n  // Clone the update queue from current. Unless it's already a clone.\n  const queue = workInProgress.updateQueue;\n  const currentQueue = current.updateQueue;\n\n  if (queue === currentQueue) {\n    const clone = {\n      baseState: currentQueue.baseState,\n      firstBaseUpdate: currentQueue.firstBaseUpdate,\n      lastBaseUpdate: currentQueue.lastBaseUpdate,\n      shared: currentQueue.shared,\n      effects: currentQueue.effects\n    };\n    workInProgress.updateQueue = clone;\n  }\n}\nfunction createUpdate(eventTime, lane) {\n  const update = {\n    eventTime,\n    lane,\n    tag: UpdateState,\n    payload: null,\n    callback: null,\n    next: null\n  };\n  return update;\n}\nfunction enqueueUpdate(fiber, update, lane) {\n  const updateQueue = fiber.updateQueue;\n\n  if (updateQueue === null) {\n    // Only occurs if the fiber has been unmounted.\n    return null;\n  }\n\n  const sharedQueue = updateQueue.shared;\n\n  if (isUnsafeClassRenderPhaseUpdate()) {\n    // This is an unsafe render phase update. Add directly to the update\n    // queue so we can process it immediately during the current render.\n    const pending = sharedQueue.pending;\n\n    if (pending === null) {\n      // This is the first update. Create a circular list.\n      update.next = update;\n    } else {\n      update.next = pending.next;\n      pending.next = update;\n    }\n\n    sharedQueue.pending = update; // Update the childLanes even though we're most likely already rendering\n    // this fiber. This is for backwards compatibility in the case where you\n    // update a different component during render phase than the one that is\n    // currently renderings (a pattern that is accompanied by a warning).\n\n    return unsafe_markUpdateLaneFromFiberToRoot(fiber, lane);\n  } else {\n    return enqueueConcurrentClassUpdate(fiber, sharedQueue, update, lane);\n  }\n}\nfunction entangleTransitions(root, fiber, lane) {\n  const updateQueue = fiber.updateQueue;\n\n  if (updateQueue === null) {\n    // Only occurs if the fiber has been unmounted.\n    return;\n  }\n\n  const sharedQueue = updateQueue.shared;\n\n  if (isTransitionLane(lane)) {\n    let queueLanes = sharedQueue.lanes; // If any entangled lanes are no longer pending on the root, then they must\n    // have finished. We can remove them from the shared queue, which represents\n    // a superset of the actually pending lanes. In some cases we may entangle\n    // more than we need to, but that's OK. In fact it's worse if we *don't*\n    // entangle when we should.\n\n    queueLanes = intersectLanes(queueLanes, root.pendingLanes); // Entangle the new transition lane with the other transition lanes.\n\n    const newQueueLanes = mergeLanes(queueLanes, lane);\n    sharedQueue.lanes = newQueueLanes; // Even if queue.lanes already include lane, we don't know for certain if\n    // the lane finished since the last time we entangled it. So we need to\n    // entangle it again, just to be sure.\n\n    markRootEntangled(root, newQueueLanes);\n  }\n}\nfunction enqueueCapturedUpdate(workInProgress, capturedUpdate) {\n  // Captured updates are updates that are thrown by a child during the render\n  // phase. They should be discarded if the render is aborted. Therefore,\n  // we should only put them on the work-in-progress queue, not the current one.\n  let queue = workInProgress.updateQueue; // Check if the work-in-progress queue is a clone.\n\n  const current = workInProgress.alternate;\n\n  if (current !== null) {\n    const currentQueue = current.updateQueue;\n\n    if (queue === currentQueue) {\n      // The work-in-progress queue is the same as current. This happens when\n      // we bail out on a parent fiber that then captures an error thrown by\n      // a child. Since we want to append the update only to the work-in\n      // -progress queue, we need to clone the updates. We usually clone during\n      // processUpdateQueue, but that didn't happen in this case because we\n      // skipped over the parent when we bailed out.\n      let newFirst = null;\n      let newLast = null;\n      const firstBaseUpdate = queue.firstBaseUpdate;\n\n      if (firstBaseUpdate !== null) {\n        // Loop through the updates and clone them.\n        let update = firstBaseUpdate;\n\n        do {\n          const clone = {\n            eventTime: update.eventTime,\n            lane: update.lane,\n            tag: update.tag,\n            payload: update.payload,\n            callback: update.callback,\n            next: null\n          };\n\n          if (newLast === null) {\n            newFirst = newLast = clone;\n          } else {\n            newLast.next = clone;\n            newLast = clone;\n          }\n\n          update = update.next;\n        } while (update !== null); // Append the captured update the end of the cloned list.\n\n\n        if (newLast === null) {\n          newFirst = newLast = capturedUpdate;\n        } else {\n          newLast.next = capturedUpdate;\n          newLast = capturedUpdate;\n        }\n      } else {\n        // There are no base updates.\n        newFirst = newLast = capturedUpdate;\n      }\n\n      queue = {\n        baseState: currentQueue.baseState,\n        firstBaseUpdate: newFirst,\n        lastBaseUpdate: newLast,\n        shared: currentQueue.shared,\n        effects: currentQueue.effects\n      };\n      workInProgress.updateQueue = queue;\n      return;\n    }\n  } // Append the update to the end of the list.\n\n\n  const lastBaseUpdate = queue.lastBaseUpdate;\n\n  if (lastBaseUpdate === null) {\n    queue.firstBaseUpdate = capturedUpdate;\n  } else {\n    lastBaseUpdate.next = capturedUpdate;\n  }\n\n  queue.lastBaseUpdate = capturedUpdate;\n}\n\nfunction getStateFromUpdate(workInProgress, queue, update, prevState, nextProps, instance) {\n  switch (update.tag) {\n    case ReplaceState:\n      {\n        const payload = update.payload;\n\n        if (typeof payload === 'function') {\n\n          const nextState = payload.call(instance, prevState, nextProps);\n\n          return nextState;\n        } // State object\n\n\n        return payload;\n      }\n\n    case CaptureUpdate:\n      {\n        workInProgress.flags = workInProgress.flags & ~ShouldCapture | DidCapture;\n      }\n    // Intentional fallthrough\n\n    case UpdateState:\n      {\n        const payload = update.payload;\n        let partialState;\n\n        if (typeof payload === 'function') {\n\n          partialState = payload.call(instance, prevState, nextProps);\n        } else {\n          // Partial state object\n          partialState = payload;\n        }\n\n        if (partialState === null || partialState === undefined) {\n          // Null and undefined are treated as no-ops.\n          return prevState;\n        } // Merge the partial state and the previous state.\n\n\n        return assign({}, prevState, partialState);\n      }\n\n    case ForceUpdate:\n      {\n        hasForceUpdate = true;\n        return prevState;\n      }\n  }\n\n  return prevState;\n}\n\nfunction processUpdateQueue(workInProgress, props, instance, renderLanes) {\n  // This is always non-null on a ClassComponent or HostRoot\n  const queue = workInProgress.updateQueue;\n  hasForceUpdate = false;\n\n  let firstBaseUpdate = queue.firstBaseUpdate;\n  let lastBaseUpdate = queue.lastBaseUpdate; // Check if there are pending updates. If so, transfer them to the base queue.\n\n  let pendingQueue = queue.shared.pending;\n\n  if (pendingQueue !== null) {\n    queue.shared.pending = null; // The pending queue is circular. Disconnect the pointer between first\n    // and last so that it's non-circular.\n\n    const lastPendingUpdate = pendingQueue;\n    const firstPendingUpdate = lastPendingUpdate.next;\n    lastPendingUpdate.next = null; // Append pending updates to base queue\n\n    if (lastBaseUpdate === null) {\n      firstBaseUpdate = firstPendingUpdate;\n    } else {\n      lastBaseUpdate.next = firstPendingUpdate;\n    }\n\n    lastBaseUpdate = lastPendingUpdate; // If there's a current queue, and it's different from the base queue, then\n    // we need to transfer the updates to that queue, too. Because the base\n    // queue is a singly-linked list with no cycles, we can append to both\n    // lists and take advantage of structural sharing.\n    // TODO: Pass `current` as argument\n\n    const current = workInProgress.alternate;\n\n    if (current !== null) {\n      // This is always non-null on a ClassComponent or HostRoot\n      const currentQueue = current.updateQueue;\n      const currentLastBaseUpdate = currentQueue.lastBaseUpdate;\n\n      if (currentLastBaseUpdate !== lastBaseUpdate) {\n        if (currentLastBaseUpdate === null) {\n          currentQueue.firstBaseUpdate = firstPendingUpdate;\n        } else {\n          currentLastBaseUpdate.next = firstPendingUpdate;\n        }\n\n        currentQueue.lastBaseUpdate = lastPendingUpdate;\n      }\n    }\n  } // These values may change as we process the queue.\n\n\n  if (firstBaseUpdate !== null) {\n    // Iterate through the list of updates to compute the result.\n    let newState = queue.baseState; // TODO: Don't need to accumulate this. Instead, we can remove renderLanes\n    // from the original lanes.\n\n    let newLanes = NoLanes;\n    let newBaseState = null;\n    let newFirstBaseUpdate = null;\n    let newLastBaseUpdate = null;\n    let update = firstBaseUpdate;\n\n    do {\n      const updateLane = update.lane;\n      const updateEventTime = update.eventTime;\n\n      if (!isSubsetOfLanes(renderLanes, updateLane)) {\n        // Priority is insufficient. Skip this update. If this is the first\n        // skipped update, the previous update/state is the new base\n        // update/state.\n        const clone = {\n          eventTime: updateEventTime,\n          lane: updateLane,\n          tag: update.tag,\n          payload: update.payload,\n          callback: update.callback,\n          next: null\n        };\n\n        if (newLastBaseUpdate === null) {\n          newFirstBaseUpdate = newLastBaseUpdate = clone;\n          newBaseState = newState;\n        } else {\n          newLastBaseUpdate = newLastBaseUpdate.next = clone;\n        } // Update the remaining priority in the queue.\n\n\n        newLanes = mergeLanes(newLanes, updateLane);\n      } else {\n        // This update does have sufficient priority.\n        if (newLastBaseUpdate !== null) {\n          const clone = {\n            eventTime: updateEventTime,\n            // This update is going to be committed so we never want uncommit\n            // it. Using NoLane works because 0 is a subset of all bitmasks, so\n            // this will never be skipped by the check above.\n            lane: NoLane,\n            tag: update.tag,\n            payload: update.payload,\n            callback: update.callback,\n            next: null\n          };\n          newLastBaseUpdate = newLastBaseUpdate.next = clone;\n        } // Process this update.\n\n\n        newState = getStateFromUpdate(workInProgress, queue, update, newState, props, instance);\n        const callback = update.callback;\n\n        if (callback !== null && // If the update was already committed, we should not queue its\n        // callback again.\n        update.lane !== NoLane) {\n          workInProgress.flags |= Callback;\n          const effects = queue.effects;\n\n          if (effects === null) {\n            queue.effects = [update];\n          } else {\n            effects.push(update);\n          }\n        }\n      }\n\n      update = update.next;\n\n      if (update === null) {\n        pendingQueue = queue.shared.pending;\n\n        if (pendingQueue === null) {\n          break;\n        } else {\n          // An update was scheduled from inside a reducer. Add the new\n          // pending updates to the end of the list and keep processing.\n          const lastPendingUpdate = pendingQueue; // Intentionally unsound. Pending updates form a circular list, but we\n          // unravel them when transferring them to the base queue.\n\n          const firstPendingUpdate = lastPendingUpdate.next;\n          lastPendingUpdate.next = null;\n          update = firstPendingUpdate;\n          queue.lastBaseUpdate = lastPendingUpdate;\n          queue.shared.pending = null;\n        }\n      }\n    } while (true);\n\n    if (newLastBaseUpdate === null) {\n      newBaseState = newState;\n    }\n\n    queue.baseState = newBaseState;\n    queue.firstBaseUpdate = newFirstBaseUpdate;\n    queue.lastBaseUpdate = newLastBaseUpdate; // Interleaved updates are stored on a separate queue. We aren't going to\n    // process them during this render, but we do need to track which lanes\n    // are remaining.\n\n    const lastInterleaved = queue.shared.interleaved;\n\n    if (lastInterleaved !== null) {\n      let interleaved = lastInterleaved;\n\n      do {\n        newLanes = mergeLanes(newLanes, interleaved.lane);\n        interleaved = interleaved.next;\n      } while (interleaved !== lastInterleaved);\n    } else if (firstBaseUpdate === null) {\n      // `queue.lanes` is used for entangling transitions. We can set it back to\n      // zero once the queue is empty.\n      queue.shared.lanes = NoLanes;\n    } // Set the remaining expiration time to be whatever is remaining in the queue.\n    // This should be fine because the only two other things that contribute to\n    // expiration time are props and context. We're already in the middle of the\n    // begin phase by the time we start processing the queue, so we've already\n    // dealt with the props. Context in components that specify\n    // shouldComponentUpdate is tricky; but we'll have to account for\n    // that regardless.\n\n\n    markSkippedUpdateLanes(newLanes);\n    workInProgress.lanes = newLanes;\n    workInProgress.memoizedState = newState;\n  }\n}\n\nfunction callCallback(callback, context) {\n  if (typeof callback !== 'function') {\n    throw Error(formatProdErrorMessage(191, callback));\n  }\n\n  callback.call(context);\n}\n\nfunction resetHasForceUpdateBeforeProcessing() {\n  hasForceUpdate = false;\n}\nfunction checkHasForceUpdateAfterProcessing() {\n  return hasForceUpdate;\n}\nfunction commitUpdateQueue(finishedWork, finishedQueue, instance) {\n  // Commit the effects\n  const effects = finishedQueue.effects;\n  finishedQueue.effects = null;\n\n  if (effects !== null) {\n    for (let i = 0; i < effects.length; i++) {\n      const effect = effects[i];\n      const callback = effect.callback;\n\n      if (callback !== null) {\n        effect.callback = null;\n        callCallback(callback, instance);\n      }\n    }\n  }\n}\n\n// We'll use it to determine whether we need to initialize legacy refs.\n\nconst emptyRefsObject = new React.Component().refs;\n\nfunction applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, nextProps) {\n  const prevState = workInProgress.memoizedState;\n  let partialState = getDerivedStateFromProps(nextProps, prevState);\n\n\n  const memoizedState = partialState === null || partialState === undefined ? prevState : assign({}, prevState, partialState);\n  workInProgress.memoizedState = memoizedState; // Once the update queue is empty, persist the derived state onto the\n  // base state.\n\n  if (workInProgress.lanes === NoLanes) {\n    // Queue is always non-null for classes\n    const updateQueue = workInProgress.updateQueue;\n    updateQueue.baseState = memoizedState;\n  }\n}\n\nconst classComponentUpdater = {\n  isMounted,\n\n  enqueueSetState(inst, payload, callback) {\n    const fiber = get(inst);\n    const eventTime = requestEventTime();\n    const lane = requestUpdateLane(fiber);\n    const update = createUpdate(eventTime, lane);\n    update.payload = payload;\n\n    if (callback !== undefined && callback !== null) {\n\n      update.callback = callback;\n    }\n\n    const root = enqueueUpdate(fiber, update, lane);\n\n    if (root !== null) {\n      scheduleUpdateOnFiber(root, fiber, lane, eventTime);\n      entangleTransitions(root, fiber, lane);\n    }\n  },\n\n  enqueueReplaceState(inst, payload, callback) {\n    const fiber = get(inst);\n    const eventTime = requestEventTime();\n    const lane = requestUpdateLane(fiber);\n    const update = createUpdate(eventTime, lane);\n    update.tag = ReplaceState;\n    update.payload = payload;\n\n    if (callback !== undefined && callback !== null) {\n\n      update.callback = callback;\n    }\n\n    const root = enqueueUpdate(fiber, update, lane);\n\n    if (root !== null) {\n      scheduleUpdateOnFiber(root, fiber, lane, eventTime);\n      entangleTransitions(root, fiber, lane);\n    }\n  },\n\n  enqueueForceUpdate(inst, callback) {\n    const fiber = get(inst);\n    const eventTime = requestEventTime();\n    const lane = requestUpdateLane(fiber);\n    const update = createUpdate(eventTime, lane);\n    update.tag = ForceUpdate;\n\n    if (callback !== undefined && callback !== null) {\n\n      update.callback = callback;\n    }\n\n    const root = enqueueUpdate(fiber, update, lane);\n\n    if (root !== null) {\n      scheduleUpdateOnFiber(root, fiber, lane, eventTime);\n      entangleTransitions(root, fiber, lane);\n    }\n  }\n\n};\n\nfunction checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext) {\n  const instance = workInProgress.stateNode;\n\n  if (typeof instance.shouldComponentUpdate === 'function') {\n    let shouldUpdate = instance.shouldComponentUpdate(newProps, newState, nextContext);\n\n    return shouldUpdate;\n  }\n\n  if (ctor.prototype && ctor.prototype.isPureReactComponent) {\n    return !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState);\n  }\n\n  return true;\n}\n\nfunction adoptClassInstance(workInProgress, instance) {\n  instance.updater = classComponentUpdater;\n  workInProgress.stateNode = instance; // The instance needs access to the fiber so that it can schedule updates\n\n  set(instance, workInProgress);\n}\n\nfunction constructClassInstance(workInProgress, ctor, props) {\n  let isLegacyContextConsumer = false;\n  let unmaskedContext = emptyContextObject;\n  let context = emptyContextObject;\n  const contextType = ctor.contextType;\n\n  if (typeof contextType === 'object' && contextType !== null) {\n    context = readContext(contextType);\n  } else {\n    unmaskedContext = getUnmaskedContext(workInProgress, ctor, true);\n    const contextTypes = ctor.contextTypes;\n    isLegacyContextConsumer = contextTypes !== null && contextTypes !== undefined;\n    context = isLegacyContextConsumer ? getMaskedContext(workInProgress, unmaskedContext) : emptyContextObject;\n  }\n\n  let instance = new ctor(props, context); // Instantiate twice to help detect side-effects.\n\n  const state = workInProgress.memoizedState = instance.state !== null && instance.state !== undefined ? instance.state : null;\n  adoptClassInstance(workInProgress, instance);\n  // ReactFiberContext usually updates this cache but can't for newly-created instances.\n\n\n  if (isLegacyContextConsumer) {\n    cacheContext(workInProgress, unmaskedContext, context);\n  }\n\n  return instance;\n}\n\nfunction callComponentWillMount(workInProgress, instance) {\n  const oldState = instance.state;\n\n  if (typeof instance.componentWillMount === 'function') {\n    instance.componentWillMount();\n  }\n\n  if (typeof instance.UNSAFE_componentWillMount === 'function') {\n    instance.UNSAFE_componentWillMount();\n  }\n\n  if (oldState !== instance.state) {\n\n    classComponentUpdater.enqueueReplaceState(instance, instance.state, null);\n  }\n}\n\nfunction callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext) {\n  const oldState = instance.state;\n\n  if (typeof instance.componentWillReceiveProps === 'function') {\n    instance.componentWillReceiveProps(newProps, nextContext);\n  }\n\n  if (typeof instance.UNSAFE_componentWillReceiveProps === 'function') {\n    instance.UNSAFE_componentWillReceiveProps(newProps, nextContext);\n  }\n\n  if (instance.state !== oldState) {\n\n    classComponentUpdater.enqueueReplaceState(instance, instance.state, null);\n  }\n} // Invokes the mount life-cycles on a previously never rendered instance.\n\n\nfunction mountClassInstance(workInProgress, ctor, newProps, renderLanes) {\n\n  const instance = workInProgress.stateNode;\n  instance.props = newProps;\n  instance.state = workInProgress.memoizedState;\n  instance.refs = emptyRefsObject;\n  initializeUpdateQueue(workInProgress);\n  const contextType = ctor.contextType;\n\n  if (typeof contextType === 'object' && contextType !== null) {\n    instance.context = readContext(contextType);\n  } else {\n    const unmaskedContext = getUnmaskedContext(workInProgress, ctor, true);\n    instance.context = getMaskedContext(workInProgress, unmaskedContext);\n  }\n\n  instance.state = workInProgress.memoizedState;\n  const getDerivedStateFromProps = ctor.getDerivedStateFromProps;\n\n  if (typeof getDerivedStateFromProps === 'function') {\n    applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, newProps);\n    instance.state = workInProgress.memoizedState;\n  } // In order to support react-lifecycles-compat polyfilled components,\n  // Unsafe lifecycles should not be invoked for components using the new APIs.\n\n\n  if (typeof ctor.getDerivedStateFromProps !== 'function' && typeof instance.getSnapshotBeforeUpdate !== 'function' && (typeof instance.UNSAFE_componentWillMount === 'function' || typeof instance.componentWillMount === 'function')) {\n    callComponentWillMount(workInProgress, instance); // If we had additional state updates during this life-cycle, let's\n    // process them now.\n\n    processUpdateQueue(workInProgress, newProps, instance, renderLanes);\n    instance.state = workInProgress.memoizedState;\n  }\n\n  if (typeof instance.componentDidMount === 'function') {\n    let fiberFlags = Update;\n\n    {\n      fiberFlags |= LayoutStatic;\n    }\n\n    workInProgress.flags |= fiberFlags;\n  }\n}\n\nfunction resumeMountClassInstance(workInProgress, ctor, newProps, renderLanes) {\n  const instance = workInProgress.stateNode;\n  const oldProps = workInProgress.memoizedProps;\n  instance.props = oldProps;\n  const oldContext = instance.context;\n  const contextType = ctor.contextType;\n  let nextContext = emptyContextObject;\n\n  if (typeof contextType === 'object' && contextType !== null) {\n    nextContext = readContext(contextType);\n  } else {\n    const nextLegacyUnmaskedContext = getUnmaskedContext(workInProgress, ctor, true);\n    nextContext = getMaskedContext(workInProgress, nextLegacyUnmaskedContext);\n  }\n\n  const getDerivedStateFromProps = ctor.getDerivedStateFromProps;\n  const hasNewLifecycles = typeof getDerivedStateFromProps === 'function' || typeof instance.getSnapshotBeforeUpdate === 'function'; // Note: During these life-cycles, instance.props/instance.state are what\n  // ever the previously attempted to render - not the \"current\". However,\n  // during componentDidUpdate we pass the \"current\" props.\n  // In order to support react-lifecycles-compat polyfilled components,\n  // Unsafe lifecycles should not be invoked for components using the new APIs.\n\n  if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillReceiveProps === 'function' || typeof instance.componentWillReceiveProps === 'function')) {\n    if (oldProps !== newProps || oldContext !== nextContext) {\n      callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext);\n    }\n  }\n\n  resetHasForceUpdateBeforeProcessing();\n  const oldState = workInProgress.memoizedState;\n  let newState = instance.state = oldState;\n  processUpdateQueue(workInProgress, newProps, instance, renderLanes);\n  newState = workInProgress.memoizedState;\n\n  if (oldProps === newProps && oldState === newState && !hasContextChanged() && !checkHasForceUpdateAfterProcessing()) {\n    // If an update was already in progress, we should schedule an Update\n    // effect even though we're bailing out, so that cWU/cDU are called.\n    if (typeof instance.componentDidMount === 'function') {\n      let fiberFlags = Update;\n\n      {\n        fiberFlags |= LayoutStatic;\n      }\n\n      workInProgress.flags |= fiberFlags;\n    }\n\n    return false;\n  }\n\n  if (typeof getDerivedStateFromProps === 'function') {\n    applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, newProps);\n    newState = workInProgress.memoizedState;\n  }\n\n  const shouldUpdate = checkHasForceUpdateAfterProcessing() || checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext);\n\n  if (shouldUpdate) {\n    // In order to support react-lifecycles-compat polyfilled components,\n    // Unsafe lifecycles should not be invoked for components using the new APIs.\n    if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillMount === 'function' || typeof instance.componentWillMount === 'function')) {\n      if (typeof instance.componentWillMount === 'function') {\n        instance.componentWillMount();\n      }\n\n      if (typeof instance.UNSAFE_componentWillMount === 'function') {\n        instance.UNSAFE_componentWillMount();\n      }\n    }\n\n    if (typeof instance.componentDidMount === 'function') {\n      let fiberFlags = Update;\n\n      {\n        fiberFlags |= LayoutStatic;\n      }\n\n      workInProgress.flags |= fiberFlags;\n    }\n  } else {\n    // If an update was already in progress, we should schedule an Update\n    // effect even though we're bailing out, so that cWU/cDU are called.\n    if (typeof instance.componentDidMount === 'function') {\n      let fiberFlags = Update;\n\n      {\n        fiberFlags |= LayoutStatic;\n      }\n\n      workInProgress.flags |= fiberFlags;\n    } // If shouldComponentUpdate returned false, we should still update the\n    // memoized state to indicate that this work can be reused.\n\n\n    workInProgress.memoizedProps = newProps;\n    workInProgress.memoizedState = newState;\n  } // Update the existing instance's state, props, and context pointers even\n  // if shouldComponentUpdate returns false.\n\n\n  instance.props = newProps;\n  instance.state = newState;\n  instance.context = nextContext;\n  return shouldUpdate;\n} // Invokes the update life-cycles and returns false if it shouldn't rerender.\n\n\nfunction updateClassInstance(current, workInProgress, ctor, newProps, renderLanes) {\n  const instance = workInProgress.stateNode;\n  cloneUpdateQueue(current, workInProgress);\n  const unresolvedOldProps = workInProgress.memoizedProps;\n  const oldProps = workInProgress.type === workInProgress.elementType ? unresolvedOldProps : resolveDefaultProps(workInProgress.type, unresolvedOldProps);\n  instance.props = oldProps;\n  const unresolvedNewProps = workInProgress.pendingProps;\n  const oldContext = instance.context;\n  const contextType = ctor.contextType;\n  let nextContext = emptyContextObject;\n\n  if (typeof contextType === 'object' && contextType !== null) {\n    nextContext = readContext(contextType);\n  } else {\n    const nextUnmaskedContext = getUnmaskedContext(workInProgress, ctor, true);\n    nextContext = getMaskedContext(workInProgress, nextUnmaskedContext);\n  }\n\n  const getDerivedStateFromProps = ctor.getDerivedStateFromProps;\n  const hasNewLifecycles = typeof getDerivedStateFromProps === 'function' || typeof instance.getSnapshotBeforeUpdate === 'function'; // Note: During these life-cycles, instance.props/instance.state are what\n  // ever the previously attempted to render - not the \"current\". However,\n  // during componentDidUpdate we pass the \"current\" props.\n  // In order to support react-lifecycles-compat polyfilled components,\n  // Unsafe lifecycles should not be invoked for components using the new APIs.\n\n  if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillReceiveProps === 'function' || typeof instance.componentWillReceiveProps === 'function')) {\n    if (unresolvedOldProps !== unresolvedNewProps || oldContext !== nextContext) {\n      callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext);\n    }\n  }\n\n  resetHasForceUpdateBeforeProcessing();\n  const oldState = workInProgress.memoizedState;\n  let newState = instance.state = oldState;\n  processUpdateQueue(workInProgress, newProps, instance, renderLanes);\n  newState = workInProgress.memoizedState;\n\n  if (unresolvedOldProps === unresolvedNewProps && oldState === newState && !hasContextChanged() && !checkHasForceUpdateAfterProcessing() && !(enableLazyContextPropagation   )) {\n    // If an update was already in progress, we should schedule an Update\n    // effect even though we're bailing out, so that cWU/cDU are called.\n    if (typeof instance.componentDidUpdate === 'function') {\n      if (unresolvedOldProps !== current.memoizedProps || oldState !== current.memoizedState) {\n        workInProgress.flags |= Update;\n      }\n    }\n\n    if (typeof instance.getSnapshotBeforeUpdate === 'function') {\n      if (unresolvedOldProps !== current.memoizedProps || oldState !== current.memoizedState) {\n        workInProgress.flags |= Snapshot;\n      }\n    }\n\n    return false;\n  }\n\n  if (typeof getDerivedStateFromProps === 'function') {\n    applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, newProps);\n    newState = workInProgress.memoizedState;\n  }\n\n  const shouldUpdate = checkHasForceUpdateAfterProcessing() || checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext) || // TODO: In some cases, we'll end up checking if context has changed twice,\n  // both before and after `shouldComponentUpdate` has been called. Not ideal,\n  // but I'm loath to refactor this function. This only happens for memoized\n  // components so it's not that common.\n  enableLazyContextPropagation   ;\n\n  if (shouldUpdate) {\n    // In order to support react-lifecycles-compat polyfilled components,\n    // Unsafe lifecycles should not be invoked for components using the new APIs.\n    if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillUpdate === 'function' || typeof instance.componentWillUpdate === 'function')) {\n      if (typeof instance.componentWillUpdate === 'function') {\n        instance.componentWillUpdate(newProps, newState, nextContext);\n      }\n\n      if (typeof instance.UNSAFE_componentWillUpdate === 'function') {\n        instance.UNSAFE_componentWillUpdate(newProps, newState, nextContext);\n      }\n    }\n\n    if (typeof instance.componentDidUpdate === 'function') {\n      workInProgress.flags |= Update;\n    }\n\n    if (typeof instance.getSnapshotBeforeUpdate === 'function') {\n      workInProgress.flags |= Snapshot;\n    }\n  } else {\n    // If an update was already in progress, we should schedule an Update\n    // effect even though we're bailing out, so that cWU/cDU are called.\n    if (typeof instance.componentDidUpdate === 'function') {\n      if (unresolvedOldProps !== current.memoizedProps || oldState !== current.memoizedState) {\n        workInProgress.flags |= Update;\n      }\n    }\n\n    if (typeof instance.getSnapshotBeforeUpdate === 'function') {\n      if (unresolvedOldProps !== current.memoizedProps || oldState !== current.memoizedState) {\n        workInProgress.flags |= Snapshot;\n      }\n    } // If shouldComponentUpdate returned false, we should still update the\n    // memoized props/state to indicate that this work can be reused.\n\n\n    workInProgress.memoizedProps = newProps;\n    workInProgress.memoizedState = newState;\n  } // Update the existing instance's state, props, and context pointers even\n  // if shouldComponentUpdate returns false.\n\n\n  instance.props = newProps;\n  instance.state = newState;\n  instance.context = nextContext;\n  return shouldUpdate;\n}\n\nfunction coerceRef(returnFiber, current, element) {\n  const mixedRef = element.ref;\n\n  if (mixedRef !== null && typeof mixedRef !== 'function' && typeof mixedRef !== 'object') {\n\n    if (element._owner) {\n      const owner = element._owner;\n      let inst;\n\n      if (owner) {\n        const ownerFiber = owner;\n\n        if (ownerFiber.tag !== ClassComponent) {\n          throw Error(formatProdErrorMessage(309));\n        }\n\n        inst = ownerFiber.stateNode;\n      }\n\n      if (!inst) {\n        throw Error(formatProdErrorMessage(147, mixedRef));\n      } // Assigning this to a const so Flow knows it won't change in the closure\n\n\n      const resolvedInst = inst;\n\n      const stringRef = '' + mixedRef; // Check if previous string ref matches new string ref\n\n      if (current !== null && current.ref !== null && typeof current.ref === 'function' && current.ref._stringRef === stringRef) {\n        return current.ref;\n      }\n\n      const ref = function (value) {\n        let refs = resolvedInst.refs;\n\n        if (refs === emptyRefsObject) {\n          // This is a lazy pooled frozen object, so we need to initialize.\n          refs = resolvedInst.refs = {};\n        }\n\n        if (value === null) {\n          delete refs[stringRef];\n        } else {\n          refs[stringRef] = value;\n        }\n      };\n\n      ref._stringRef = stringRef;\n      return ref;\n    } else {\n      if (typeof mixedRef !== 'string') {\n        throw Error(formatProdErrorMessage(284));\n      }\n\n      if (!element._owner) {\n        throw Error(formatProdErrorMessage(290, mixedRef));\n      }\n    }\n  }\n\n  return mixedRef;\n}\n\nfunction throwOnInvalidObjectType(returnFiber, newChild) {\n  const childString = Object.prototype.toString.call(newChild);\n  throw Error(formatProdErrorMessage(31, childString === '[object Object]' ? 'object with keys {' + Object.keys(newChild).join(', ') + '}' : childString));\n}\n\nfunction resolveLazy(lazyType) {\n  const payload = lazyType._payload;\n  const init = lazyType._init;\n  return init(payload);\n} // This wrapper function exists because I expect to clone the code in each path\n// to be able to optimize each path individually by branching early. This needs\n// a compiler or we can do it manually. Helpers that don't need this branching\n// live outside of this function.\n\n\nfunction ChildReconciler(shouldTrackSideEffects) {\n  function deleteChild(returnFiber, childToDelete) {\n    if (!shouldTrackSideEffects) {\n      // Noop.\n      return;\n    }\n\n    const deletions = returnFiber.deletions;\n\n    if (deletions === null) {\n      returnFiber.deletions = [childToDelete];\n      returnFiber.flags |= ChildDeletion;\n    } else {\n      deletions.push(childToDelete);\n    }\n  }\n\n  function deleteRemainingChildren(returnFiber, currentFirstChild) {\n    if (!shouldTrackSideEffects) {\n      // Noop.\n      return null;\n    } // TODO: For the shouldClone case, this could be micro-optimized a bit by\n    // assuming that after the first child we've already added everything.\n\n\n    let childToDelete = currentFirstChild;\n\n    while (childToDelete !== null) {\n      deleteChild(returnFiber, childToDelete);\n      childToDelete = childToDelete.sibling;\n    }\n\n    return null;\n  }\n\n  function mapRemainingChildren(returnFiber, currentFirstChild) {\n    // Add the remaining children to a temporary map so that we can find them by\n    // keys quickly. Implicit (null) keys get added to this set with their index\n    // instead.\n    const existingChildren = new Map();\n    let existingChild = currentFirstChild;\n\n    while (existingChild !== null) {\n      if (existingChild.key !== null) {\n        existingChildren.set(existingChild.key, existingChild);\n      } else {\n        existingChildren.set(existingChild.index, existingChild);\n      }\n\n      existingChild = existingChild.sibling;\n    }\n\n    return existingChildren;\n  }\n\n  function useFiber(fiber, pendingProps) {\n    // We currently set sibling to null and index to 0 here because it is easy\n    // to forget to do before returning it. E.g. for the single child case.\n    const clone = createWorkInProgress(fiber, pendingProps);\n    clone.index = 0;\n    clone.sibling = null;\n    return clone;\n  }\n\n  function placeChild(newFiber, lastPlacedIndex, newIndex) {\n    newFiber.index = newIndex;\n\n    if (!shouldTrackSideEffects) {\n      // During hydration, the useId algorithm needs to know which fibers are\n      // part of a list of children (arrays, iterators).\n      newFiber.flags |= Forked;\n      return lastPlacedIndex;\n    }\n\n    const current = newFiber.alternate;\n\n    if (current !== null) {\n      const oldIndex = current.index;\n\n      if (oldIndex < lastPlacedIndex) {\n        // This is a move.\n        newFiber.flags |= Placement;\n        return lastPlacedIndex;\n      } else {\n        // This item can stay in place.\n        return oldIndex;\n      }\n    } else {\n      // This is an insertion.\n      newFiber.flags |= Placement;\n      return lastPlacedIndex;\n    }\n  }\n\n  function placeSingleChild(newFiber) {\n    // This is simpler for the single child case. We only need to do a\n    // placement for inserting new children.\n    if (shouldTrackSideEffects && newFiber.alternate === null) {\n      newFiber.flags |= Placement;\n    }\n\n    return newFiber;\n  }\n\n  function updateTextNode(returnFiber, current, textContent, lanes) {\n    if (current === null || current.tag !== HostText) {\n      // Insert\n      const created = createFiberFromText(textContent, returnFiber.mode, lanes);\n      created.return = returnFiber;\n      return created;\n    } else {\n      // Update\n      const existing = useFiber(current, textContent);\n      existing.return = returnFiber;\n      return existing;\n    }\n  }\n\n  function updateElement(returnFiber, current, element, lanes) {\n    const elementType = element.type;\n\n    if (elementType === REACT_FRAGMENT_TYPE) {\n      return updateFragment(returnFiber, current, element.props.children, lanes, element.key);\n    }\n\n    if (current !== null) {\n      if (current.elementType === elementType || ( // Keep this check inline so it only runs on the false path:\n       false) || // Lazy types should reconcile their resolved type.\n      // We need to do this after the Hot Reloading check above,\n      // because hot reloading has different semantics than prod because\n      // it doesn't resuspend. So we can't let the call below suspend.\n      typeof elementType === 'object' && elementType !== null && elementType.$$typeof === REACT_LAZY_TYPE && resolveLazy(elementType) === current.type) {\n        // Move based on index\n        const existing = useFiber(current, element.props);\n        existing.ref = coerceRef(returnFiber, current, element);\n        existing.return = returnFiber;\n\n        return existing;\n      }\n    } // Insert\n\n\n    const created = createFiberFromElement(element, returnFiber.mode, lanes);\n    created.ref = coerceRef(returnFiber, current, element);\n    created.return = returnFiber;\n    return created;\n  }\n\n  function updatePortal(returnFiber, current, portal, lanes) {\n    if (current === null || current.tag !== HostPortal || current.stateNode.containerInfo !== portal.containerInfo || current.stateNode.implementation !== portal.implementation) {\n      // Insert\n      const created = createFiberFromPortal(portal, returnFiber.mode, lanes);\n      created.return = returnFiber;\n      return created;\n    } else {\n      // Update\n      const existing = useFiber(current, portal.children || []);\n      existing.return = returnFiber;\n      return existing;\n    }\n  }\n\n  function updateFragment(returnFiber, current, fragment, lanes, key) {\n    if (current === null || current.tag !== Fragment) {\n      // Insert\n      const created = createFiberFromFragment(fragment, returnFiber.mode, lanes, key);\n      created.return = returnFiber;\n      return created;\n    } else {\n      // Update\n      const existing = useFiber(current, fragment);\n      existing.return = returnFiber;\n      return existing;\n    }\n  }\n\n  function createChild(returnFiber, newChild, lanes) {\n    if (typeof newChild === 'string' && newChild !== '' || typeof newChild === 'number') {\n      // Text nodes don't have keys. If the previous node is implicitly keyed\n      // we can continue to replace it without aborting even if it is not a text\n      // node.\n      const created = createFiberFromText('' + newChild, returnFiber.mode, lanes);\n      created.return = returnFiber;\n      return created;\n    }\n\n    if (typeof newChild === 'object' && newChild !== null) {\n      switch (newChild.$$typeof) {\n        case REACT_ELEMENT_TYPE:\n          {\n            const created = createFiberFromElement(newChild, returnFiber.mode, lanes);\n            created.ref = coerceRef(returnFiber, null, newChild);\n            created.return = returnFiber;\n            return created;\n          }\n\n        case REACT_PORTAL_TYPE:\n          {\n            const created = createFiberFromPortal(newChild, returnFiber.mode, lanes);\n            created.return = returnFiber;\n            return created;\n          }\n\n        case REACT_LAZY_TYPE:\n          {\n            const payload = newChild._payload;\n            const init = newChild._init;\n            return createChild(returnFiber, init(payload), lanes);\n          }\n      }\n\n      if (isArray(newChild) || getIteratorFn(newChild)) {\n        const created = createFiberFromFragment(newChild, returnFiber.mode, lanes, null);\n        created.return = returnFiber;\n        return created;\n      }\n\n      throwOnInvalidObjectType(returnFiber, newChild);\n    }\n\n    return null;\n  }\n\n  function updateSlot(returnFiber, oldFiber, newChild, lanes) {\n    // Update the fiber if the keys match, otherwise return null.\n    const key = oldFiber !== null ? oldFiber.key : null;\n\n    if (typeof newChild === 'string' && newChild !== '' || typeof newChild === 'number') {\n      // Text nodes don't have keys. If the previous node is implicitly keyed\n      // we can continue to replace it without aborting even if it is not a text\n      // node.\n      if (key !== null) {\n        return null;\n      }\n\n      return updateTextNode(returnFiber, oldFiber, '' + newChild, lanes);\n    }\n\n    if (typeof newChild === 'object' && newChild !== null) {\n      switch (newChild.$$typeof) {\n        case REACT_ELEMENT_TYPE:\n          {\n            if (newChild.key === key) {\n              return updateElement(returnFiber, oldFiber, newChild, lanes);\n            } else {\n              return null;\n            }\n          }\n\n        case REACT_PORTAL_TYPE:\n          {\n            if (newChild.key === key) {\n              return updatePortal(returnFiber, oldFiber, newChild, lanes);\n            } else {\n              return null;\n            }\n          }\n\n        case REACT_LAZY_TYPE:\n          {\n            const payload = newChild._payload;\n            const init = newChild._init;\n            return updateSlot(returnFiber, oldFiber, init(payload), lanes);\n          }\n      }\n\n      if (isArray(newChild) || getIteratorFn(newChild)) {\n        if (key !== null) {\n          return null;\n        }\n\n        return updateFragment(returnFiber, oldFiber, newChild, lanes, null);\n      }\n\n      throwOnInvalidObjectType(returnFiber, newChild);\n    }\n\n    return null;\n  }\n\n  function updateFromMap(existingChildren, returnFiber, newIdx, newChild, lanes) {\n    if (typeof newChild === 'string' && newChild !== '' || typeof newChild === 'number') {\n      // Text nodes don't have keys, so we neither have to check the old nor\n      // new node for the key. If both are text nodes, they match.\n      const matchedFiber = existingChildren.get(newIdx) || null;\n      return updateTextNode(returnFiber, matchedFiber, '' + newChild, lanes);\n    }\n\n    if (typeof newChild === 'object' && newChild !== null) {\n      switch (newChild.$$typeof) {\n        case REACT_ELEMENT_TYPE:\n          {\n            const matchedFiber = existingChildren.get(newChild.key === null ? newIdx : newChild.key) || null;\n            return updateElement(returnFiber, matchedFiber, newChild, lanes);\n          }\n\n        case REACT_PORTAL_TYPE:\n          {\n            const matchedFiber = existingChildren.get(newChild.key === null ? newIdx : newChild.key) || null;\n            return updatePortal(returnFiber, matchedFiber, newChild, lanes);\n          }\n\n        case REACT_LAZY_TYPE:\n          const payload = newChild._payload;\n          const init = newChild._init;\n          return updateFromMap(existingChildren, returnFiber, newIdx, init(payload), lanes);\n      }\n\n      if (isArray(newChild) || getIteratorFn(newChild)) {\n        const matchedFiber = existingChildren.get(newIdx) || null;\n        return updateFragment(returnFiber, matchedFiber, newChild, lanes, null);\n      }\n\n      throwOnInvalidObjectType(returnFiber, newChild);\n    }\n\n    return null;\n  }\n\n  function reconcileChildrenArray(returnFiber, currentFirstChild, newChildren, lanes) {\n\n    let resultingFirstChild = null;\n    let previousNewFiber = null;\n    let oldFiber = currentFirstChild;\n    let lastPlacedIndex = 0;\n    let newIdx = 0;\n    let nextOldFiber = null;\n\n    for (; oldFiber !== null && newIdx < newChildren.length; newIdx++) {\n      if (oldFiber.index > newIdx) {\n        nextOldFiber = oldFiber;\n        oldFiber = null;\n      } else {\n        nextOldFiber = oldFiber.sibling;\n      }\n\n      const newFiber = updateSlot(returnFiber, oldFiber, newChildren[newIdx], lanes);\n\n      if (newFiber === null) {\n        // TODO: This breaks on empty slots like null children. That's\n        // unfortunate because it triggers the slow path all the time. We need\n        // a better way to communicate whether this was a miss or null,\n        // boolean, undefined, etc.\n        if (oldFiber === null) {\n          oldFiber = nextOldFiber;\n        }\n\n        break;\n      }\n\n      if (shouldTrackSideEffects) {\n        if (oldFiber && newFiber.alternate === null) {\n          // We matched the slot, but we didn't reuse the existing fiber, so we\n          // need to delete the existing child.\n          deleteChild(returnFiber, oldFiber);\n        }\n      }\n\n      lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);\n\n      if (previousNewFiber === null) {\n        // TODO: Move out of the loop. This only happens for the first run.\n        resultingFirstChild = newFiber;\n      } else {\n        // TODO: Defer siblings if we're not at the right index for this slot.\n        // I.e. if we had null values before, then we want to defer this\n        // for each null value. However, we also don't want to call updateSlot\n        // with the previous one.\n        previousNewFiber.sibling = newFiber;\n      }\n\n      previousNewFiber = newFiber;\n      oldFiber = nextOldFiber;\n    }\n\n    if (newIdx === newChildren.length) {\n      // We've reached the end of the new children. We can delete the rest.\n      deleteRemainingChildren(returnFiber, oldFiber);\n\n      if (getIsHydrating()) {\n        const numberOfForks = newIdx;\n        pushTreeFork(returnFiber, numberOfForks);\n      }\n\n      return resultingFirstChild;\n    }\n\n    if (oldFiber === null) {\n      // If we don't have any more existing children we can choose a fast path\n      // since the rest will all be insertions.\n      for (; newIdx < newChildren.length; newIdx++) {\n        const newFiber = createChild(returnFiber, newChildren[newIdx], lanes);\n\n        if (newFiber === null) {\n          continue;\n        }\n\n        lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);\n\n        if (previousNewFiber === null) {\n          // TODO: Move out of the loop. This only happens for the first run.\n          resultingFirstChild = newFiber;\n        } else {\n          previousNewFiber.sibling = newFiber;\n        }\n\n        previousNewFiber = newFiber;\n      }\n\n      if (getIsHydrating()) {\n        const numberOfForks = newIdx;\n        pushTreeFork(returnFiber, numberOfForks);\n      }\n\n      return resultingFirstChild;\n    } // Add all children to a key map for quick lookups.\n\n\n    const existingChildren = mapRemainingChildren(returnFiber, oldFiber); // Keep scanning and use the map to restore deleted items as moves.\n\n    for (; newIdx < newChildren.length; newIdx++) {\n      const newFiber = updateFromMap(existingChildren, returnFiber, newIdx, newChildren[newIdx], lanes);\n\n      if (newFiber !== null) {\n        if (shouldTrackSideEffects) {\n          if (newFiber.alternate !== null) {\n            // The new fiber is a work in progress, but if there exists a\n            // current, that means that we reused the fiber. We need to delete\n            // it from the child list so that we don't add it to the deletion\n            // list.\n            existingChildren.delete(newFiber.key === null ? newIdx : newFiber.key);\n          }\n        }\n\n        lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);\n\n        if (previousNewFiber === null) {\n          resultingFirstChild = newFiber;\n        } else {\n          previousNewFiber.sibling = newFiber;\n        }\n\n        previousNewFiber = newFiber;\n      }\n    }\n\n    if (shouldTrackSideEffects) {\n      // Any existing children that weren't consumed above were deleted. We need\n      // to add them to the deletion list.\n      existingChildren.forEach(child => deleteChild(returnFiber, child));\n    }\n\n    if (getIsHydrating()) {\n      const numberOfForks = newIdx;\n      pushTreeFork(returnFiber, numberOfForks);\n    }\n\n    return resultingFirstChild;\n  }\n\n  function reconcileChildrenIterator(returnFiber, currentFirstChild, newChildrenIterable, lanes) {\n    // This is the same implementation as reconcileChildrenArray(),\n    // but using the iterator instead.\n    const iteratorFn = getIteratorFn(newChildrenIterable);\n\n    if (typeof iteratorFn !== 'function') {\n      throw Error(formatProdErrorMessage(150));\n    }\n\n    const newChildren = iteratorFn.call(newChildrenIterable);\n\n    if (newChildren == null) {\n      throw Error(formatProdErrorMessage(151));\n    }\n\n    let resultingFirstChild = null;\n    let previousNewFiber = null;\n    let oldFiber = currentFirstChild;\n    let lastPlacedIndex = 0;\n    let newIdx = 0;\n    let nextOldFiber = null;\n    let step = newChildren.next();\n\n    for (; oldFiber !== null && !step.done; newIdx++, step = newChildren.next()) {\n      if (oldFiber.index > newIdx) {\n        nextOldFiber = oldFiber;\n        oldFiber = null;\n      } else {\n        nextOldFiber = oldFiber.sibling;\n      }\n\n      const newFiber = updateSlot(returnFiber, oldFiber, step.value, lanes);\n\n      if (newFiber === null) {\n        // TODO: This breaks on empty slots like null children. That's\n        // unfortunate because it triggers the slow path all the time. We need\n        // a better way to communicate whether this was a miss or null,\n        // boolean, undefined, etc.\n        if (oldFiber === null) {\n          oldFiber = nextOldFiber;\n        }\n\n        break;\n      }\n\n      if (shouldTrackSideEffects) {\n        if (oldFiber && newFiber.alternate === null) {\n          // We matched the slot, but we didn't reuse the existing fiber, so we\n          // need to delete the existing child.\n          deleteChild(returnFiber, oldFiber);\n        }\n      }\n\n      lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);\n\n      if (previousNewFiber === null) {\n        // TODO: Move out of the loop. This only happens for the first run.\n        resultingFirstChild = newFiber;\n      } else {\n        // TODO: Defer siblings if we're not at the right index for this slot.\n        // I.e. if we had null values before, then we want to defer this\n        // for each null value. However, we also don't want to call updateSlot\n        // with the previous one.\n        previousNewFiber.sibling = newFiber;\n      }\n\n      previousNewFiber = newFiber;\n      oldFiber = nextOldFiber;\n    }\n\n    if (step.done) {\n      // We've reached the end of the new children. We can delete the rest.\n      deleteRemainingChildren(returnFiber, oldFiber);\n\n      if (getIsHydrating()) {\n        const numberOfForks = newIdx;\n        pushTreeFork(returnFiber, numberOfForks);\n      }\n\n      return resultingFirstChild;\n    }\n\n    if (oldFiber === null) {\n      // If we don't have any more existing children we can choose a fast path\n      // since the rest will all be insertions.\n      for (; !step.done; newIdx++, step = newChildren.next()) {\n        const newFiber = createChild(returnFiber, step.value, lanes);\n\n        if (newFiber === null) {\n          continue;\n        }\n\n        lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);\n\n        if (previousNewFiber === null) {\n          // TODO: Move out of the loop. This only happens for the first run.\n          resultingFirstChild = newFiber;\n        } else {\n          previousNewFiber.sibling = newFiber;\n        }\n\n        previousNewFiber = newFiber;\n      }\n\n      if (getIsHydrating()) {\n        const numberOfForks = newIdx;\n        pushTreeFork(returnFiber, numberOfForks);\n      }\n\n      return resultingFirstChild;\n    } // Add all children to a key map for quick lookups.\n\n\n    const existingChildren = mapRemainingChildren(returnFiber, oldFiber); // Keep scanning and use the map to restore deleted items as moves.\n\n    for (; !step.done; newIdx++, step = newChildren.next()) {\n      const newFiber = updateFromMap(existingChildren, returnFiber, newIdx, step.value, lanes);\n\n      if (newFiber !== null) {\n        if (shouldTrackSideEffects) {\n          if (newFiber.alternate !== null) {\n            // The new fiber is a work in progress, but if there exists a\n            // current, that means that we reused the fiber. We need to delete\n            // it from the child list so that we don't add it to the deletion\n            // list.\n            existingChildren.delete(newFiber.key === null ? newIdx : newFiber.key);\n          }\n        }\n\n        lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);\n\n        if (previousNewFiber === null) {\n          resultingFirstChild = newFiber;\n        } else {\n          previousNewFiber.sibling = newFiber;\n        }\n\n        previousNewFiber = newFiber;\n      }\n    }\n\n    if (shouldTrackSideEffects) {\n      // Any existing children that weren't consumed above were deleted. We need\n      // to add them to the deletion list.\n      existingChildren.forEach(child => deleteChild(returnFiber, child));\n    }\n\n    if (getIsHydrating()) {\n      const numberOfForks = newIdx;\n      pushTreeFork(returnFiber, numberOfForks);\n    }\n\n    return resultingFirstChild;\n  }\n\n  function reconcileSingleTextNode(returnFiber, currentFirstChild, textContent, lanes) {\n    // There's no need to check for keys on text nodes since we don't have a\n    // way to define them.\n    if (currentFirstChild !== null && currentFirstChild.tag === HostText) {\n      // We already have an existing node so let's just update it and delete\n      // the rest.\n      deleteRemainingChildren(returnFiber, currentFirstChild.sibling);\n      const existing = useFiber(currentFirstChild, textContent);\n      existing.return = returnFiber;\n      return existing;\n    } // The existing first child is not a text node so we need to create one\n    // and delete the existing ones.\n\n\n    deleteRemainingChildren(returnFiber, currentFirstChild);\n    const created = createFiberFromText(textContent, returnFiber.mode, lanes);\n    created.return = returnFiber;\n    return created;\n  }\n\n  function reconcileSingleElement(returnFiber, currentFirstChild, element, lanes) {\n    const key = element.key;\n    let child = currentFirstChild;\n\n    while (child !== null) {\n      // TODO: If key === null and child.key === null, then this only applies to\n      // the first item in the list.\n      if (child.key === key) {\n        const elementType = element.type;\n\n        if (elementType === REACT_FRAGMENT_TYPE) {\n          if (child.tag === Fragment) {\n            deleteRemainingChildren(returnFiber, child.sibling);\n            const existing = useFiber(child, element.props.children);\n            existing.return = returnFiber;\n\n            return existing;\n          }\n        } else {\n          if (child.elementType === elementType || ( // Keep this check inline so it only runs on the false path:\n           false) || // Lazy types should reconcile their resolved type.\n          // We need to do this after the Hot Reloading check above,\n          // because hot reloading has different semantics than prod because\n          // it doesn't resuspend. So we can't let the call below suspend.\n          typeof elementType === 'object' && elementType !== null && elementType.$$typeof === REACT_LAZY_TYPE && resolveLazy(elementType) === child.type) {\n            deleteRemainingChildren(returnFiber, child.sibling);\n            const existing = useFiber(child, element.props);\n            existing.ref = coerceRef(returnFiber, child, element);\n            existing.return = returnFiber;\n\n            return existing;\n          }\n        } // Didn't match.\n\n\n        deleteRemainingChildren(returnFiber, child);\n        break;\n      } else {\n        deleteChild(returnFiber, child);\n      }\n\n      child = child.sibling;\n    }\n\n    if (element.type === REACT_FRAGMENT_TYPE) {\n      const created = createFiberFromFragment(element.props.children, returnFiber.mode, lanes, element.key);\n      created.return = returnFiber;\n      return created;\n    } else {\n      const created = createFiberFromElement(element, returnFiber.mode, lanes);\n      created.ref = coerceRef(returnFiber, currentFirstChild, element);\n      created.return = returnFiber;\n      return created;\n    }\n  }\n\n  function reconcileSinglePortal(returnFiber, currentFirstChild, portal, lanes) {\n    const key = portal.key;\n    let child = currentFirstChild;\n\n    while (child !== null) {\n      // TODO: If key === null and child.key === null, then this only applies to\n      // the first item in the list.\n      if (child.key === key) {\n        if (child.tag === HostPortal && child.stateNode.containerInfo === portal.containerInfo && child.stateNode.implementation === portal.implementation) {\n          deleteRemainingChildren(returnFiber, child.sibling);\n          const existing = useFiber(child, portal.children || []);\n          existing.return = returnFiber;\n          return existing;\n        } else {\n          deleteRemainingChildren(returnFiber, child);\n          break;\n        }\n      } else {\n        deleteChild(returnFiber, child);\n      }\n\n      child = child.sibling;\n    }\n\n    const created = createFiberFromPortal(portal, returnFiber.mode, lanes);\n    created.return = returnFiber;\n    return created;\n  } // This API will tag the children with the side-effect of the reconciliation\n  // itself. They will be added to the side-effect list as we pass through the\n  // children and the parent.\n\n\n  function reconcileChildFibers(returnFiber, currentFirstChild, newChild, lanes) {\n    // This function is not recursive.\n    // If the top level item is an array, we treat it as a set of children,\n    // not as a fragment. Nested arrays on the other hand will be treated as\n    // fragment nodes. Recursion happens at the normal flow.\n    // Handle top level unkeyed fragments as if they were arrays.\n    // This leads to an ambiguity between <>{[...]}</> and <>...</>.\n    // We treat the ambiguous cases above the same.\n    const isUnkeyedTopLevelFragment = typeof newChild === 'object' && newChild !== null && newChild.type === REACT_FRAGMENT_TYPE && newChild.key === null;\n\n    if (isUnkeyedTopLevelFragment) {\n      newChild = newChild.props.children;\n    } // Handle object types\n\n\n    if (typeof newChild === 'object' && newChild !== null) {\n      switch (newChild.$$typeof) {\n        case REACT_ELEMENT_TYPE:\n          return placeSingleChild(reconcileSingleElement(returnFiber, currentFirstChild, newChild, lanes));\n\n        case REACT_PORTAL_TYPE:\n          return placeSingleChild(reconcileSinglePortal(returnFiber, currentFirstChild, newChild, lanes));\n\n        case REACT_LAZY_TYPE:\n          const payload = newChild._payload;\n          const init = newChild._init; // TODO: This function is supposed to be non-recursive.\n\n          return reconcileChildFibers(returnFiber, currentFirstChild, init(payload), lanes);\n      }\n\n      if (isArray(newChild)) {\n        return reconcileChildrenArray(returnFiber, currentFirstChild, newChild, lanes);\n      }\n\n      if (getIteratorFn(newChild)) {\n        return reconcileChildrenIterator(returnFiber, currentFirstChild, newChild, lanes);\n      }\n\n      throwOnInvalidObjectType(returnFiber, newChild);\n    }\n\n    if (typeof newChild === 'string' && newChild !== '' || typeof newChild === 'number') {\n      return placeSingleChild(reconcileSingleTextNode(returnFiber, currentFirstChild, '' + newChild, lanes));\n    }\n\n\n    return deleteRemainingChildren(returnFiber, currentFirstChild);\n  }\n\n  return reconcileChildFibers;\n}\n\nconst reconcileChildFibers = ChildReconciler(true);\nconst mountChildFibers = ChildReconciler(false);\nfunction cloneChildFibers(current, workInProgress) {\n  if (current !== null && workInProgress.child !== current.child) {\n    throw Error(formatProdErrorMessage(153));\n  }\n\n  if (workInProgress.child === null) {\n    return;\n  }\n\n  let currentChild = workInProgress.child;\n  let newChild = createWorkInProgress(currentChild, currentChild.pendingProps);\n  workInProgress.child = newChild;\n  newChild.return = workInProgress;\n\n  while (currentChild.sibling !== null) {\n    currentChild = currentChild.sibling;\n    newChild = newChild.sibling = createWorkInProgress(currentChild, currentChild.pendingProps);\n    newChild.return = workInProgress;\n  }\n\n  newChild.sibling = null;\n} // Reset a workInProgress child set to prepare it for a second pass.\n\nfunction resetChildFibers(workInProgress, lanes) {\n  let child = workInProgress.child;\n\n  while (child !== null) {\n    resetWorkInProgress(child, lanes);\n    child = child.sibling;\n  }\n}\n\nconst NO_CONTEXT = {};\nconst contextStackCursor$1 = createCursor(NO_CONTEXT);\nconst contextFiberStackCursor = createCursor(NO_CONTEXT);\nconst rootInstanceStackCursor = createCursor(NO_CONTEXT);\n\nfunction requiredContext(c) {\n  if (c === NO_CONTEXT) {\n    throw Error(formatProdErrorMessage(174));\n  }\n\n  return c;\n}\n\nfunction getRootHostContainer() {\n  const rootInstance = requiredContext(rootInstanceStackCursor.current);\n  return rootInstance;\n}\n\nfunction pushHostContainer(fiber, nextRootInstance) {\n  // Push current root instance onto the stack;\n  // This allows us to reset root when portals are popped.\n  push(rootInstanceStackCursor, nextRootInstance); // Track the context and the Fiber that provided it.\n  // This enables us to pop only Fibers that provide unique contexts.\n\n  push(contextFiberStackCursor, fiber); // Finally, we need to push the host context to the stack.\n  // However, we can't just call getRootHostContext() and push it because\n  // we'd have a different number of entries on the stack depending on\n  // whether getRootHostContext() throws somewhere in renderer code or not.\n  // So we push an empty value first. This lets us safely unwind on errors.\n\n  push(contextStackCursor$1, NO_CONTEXT);\n  const nextRootContext = getRootHostContext(nextRootInstance); // Now that we know this function doesn't throw, replace it.\n\n  pop(contextStackCursor$1);\n  push(contextStackCursor$1, nextRootContext);\n}\n\nfunction popHostContainer(fiber) {\n  pop(contextStackCursor$1);\n  pop(contextFiberStackCursor);\n  pop(rootInstanceStackCursor);\n}\n\nfunction getHostContext() {\n  const context = requiredContext(contextStackCursor$1.current);\n  return context;\n}\n\nfunction pushHostContext(fiber) {\n  const rootInstance = requiredContext(rootInstanceStackCursor.current);\n  const context = requiredContext(contextStackCursor$1.current);\n  const nextContext = getChildHostContext(context, fiber.type); // Don't push this Fiber's context unless it's unique.\n\n  if (context === nextContext) {\n    return;\n  } // Track the context and the Fiber that provided it.\n  // This enables us to pop only Fibers that provide unique contexts.\n\n\n  push(contextFiberStackCursor, fiber);\n  push(contextStackCursor$1, nextContext);\n}\n\nfunction popHostContext(fiber) {\n  // Do not pop unless this Fiber provided the current context.\n  // pushHostContext() only pushes Fibers that provide unique contexts.\n  if (contextFiberStackCursor.current !== fiber) {\n    return;\n  }\n\n  pop(contextStackCursor$1);\n  pop(contextFiberStackCursor);\n}\n\nconst DefaultSuspenseContext = 0b00; // The Suspense Context is split into two parts. The lower bits is\n// inherited deeply down the subtree. The upper bits only affect\n// this immediate suspense boundary and gets reset each new\n// boundary or suspense list.\n\nconst SubtreeSuspenseContextMask = 0b01; // Subtree Flags:\n// InvisibleParentSuspenseContext indicates that one of our parent Suspense\n// boundaries is not currently showing visible main content.\n// Either because it is already showing a fallback or is not mounted at all.\n// We can use this to determine if it is desirable to trigger a fallback at\n// the parent. If not, then we might need to trigger undesirable boundaries\n// and/or suspend the commit to avoid hiding the parent content.\n\nconst InvisibleParentSuspenseContext = 0b01; // Shallow Flags:\n// ForceSuspenseFallback can be used by SuspenseList to force newly added\n// items into their fallback state during one of the render passes.\n\nconst ForceSuspenseFallback = 0b10;\nconst suspenseStackCursor = createCursor(DefaultSuspenseContext);\nfunction hasSuspenseContext(parentContext, flag) {\n  return (parentContext & flag) !== 0;\n}\nfunction setDefaultShallowSuspenseContext(parentContext) {\n  return parentContext & SubtreeSuspenseContextMask;\n}\nfunction setShallowSuspenseContext(parentContext, shallowContext) {\n  return parentContext & SubtreeSuspenseContextMask | shallowContext;\n}\nfunction addSubtreeSuspenseContext(parentContext, subtreeContext) {\n  return parentContext | subtreeContext;\n}\nfunction pushSuspenseContext(fiber, newContext) {\n  push(suspenseStackCursor, newContext);\n}\nfunction popSuspenseContext(fiber) {\n  pop(suspenseStackCursor);\n}\n\nfunction shouldCaptureSuspense(workInProgress, hasInvisibleParent) {\n  // If it was the primary children that just suspended, capture and render the\n  // fallback. Otherwise, don't capture and bubble to the next boundary.\n  const nextState = workInProgress.memoizedState;\n\n  if (nextState !== null) {\n    if (nextState.dehydrated !== null) {\n      // A dehydrated boundary always captures.\n      return true;\n    }\n\n    return false;\n  }\n\n  const props = workInProgress.memoizedProps; // Regular boundaries always capture.\n\n  {\n    return true;\n  } // If it's a boundary we should avoid, then we prefer to bubble up to the\n}\nfunction findFirstSuspended(row) {\n  let node = row;\n\n  while (node !== null) {\n    if (node.tag === SuspenseComponent) {\n      const state = node.memoizedState;\n\n      if (state !== null) {\n        const dehydrated = state.dehydrated;\n\n        if (dehydrated === null || isSuspenseInstancePending(dehydrated) || isSuspenseInstanceFallback(dehydrated)) {\n          return node;\n        }\n      }\n    } else if (node.tag === SuspenseListComponent && // revealOrder undefined can't be trusted because it don't\n    // keep track of whether it suspended or not.\n    node.memoizedProps.revealOrder !== undefined) {\n      const didSuspend = (node.flags & DidCapture) !== NoFlags;\n\n      if (didSuspend) {\n        return node;\n      }\n    } else if (node.child !== null) {\n      node.child.return = node;\n      node = node.child;\n      continue;\n    }\n\n    if (node === row) {\n      return null;\n    }\n\n    while (node.sibling === null) {\n      if (node.return === null || node.return === row) {\n        return null;\n      }\n\n      node = node.return;\n    }\n\n    node.sibling.return = node.return;\n    node = node.sibling;\n  }\n\n  return null;\n}\n\nconst NoFlags$1 =\n/*   */\n0b0000; // Represents whether effect should fire.\n\nconst HasEffect =\n/* */\n0b0001; // Represents the phase in which the effect (not the clean-up) fires.\n\nconst Insertion =\n/*  */\n0b0010;\nconst Layout =\n/*    */\n0b0100;\nconst Passive$1 =\n/*   */\n0b1000;\n\n// and should be reset before starting a new render.\n// This tracks which mutable sources need to be reset after a render.\n\nconst workInProgressSources = [];\nfunction resetWorkInProgressVersions() {\n  for (let i = 0; i < workInProgressSources.length; i++) {\n    const mutableSource = workInProgressSources[i];\n\n    {\n      mutableSource._workInProgressVersionPrimary = null;\n    }\n  }\n\n  workInProgressSources.length = 0;\n}\n// This ensures that the version used for server rendering matches the one\n// that is eventually read during hydration.\n// If they don't match there's a potential tear and a full deopt render is required.\n\nfunction registerMutableSourceForHydration(root, mutableSource) {\n  const getVersion = mutableSource._getVersion;\n  const version = getVersion(mutableSource._source); // TODO Clear this data once all pending hydration work is finished.\n  // Retaining it forever may interfere with GC.\n\n  if (root.mutableSourceEagerHydrationData == null) {\n    root.mutableSourceEagerHydrationData = [mutableSource, version];\n  } else {\n    root.mutableSourceEagerHydrationData.push(mutableSource, version);\n  }\n}\n\nconst ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher,\n      ReactCurrentBatchConfig$2 = ReactSharedInternals.ReactCurrentBatchConfig;\n\n// These are set right before calling the component.\nlet renderLanes = NoLanes; // The work-in-progress fiber. I've named it differently to distinguish it from\n// the work-in-progress hook.\n\nlet currentlyRenderingFiber$1 = null; // Hooks are stored as a linked list on the fiber's memoizedState field. The\n// current hook list is the list that belongs to the current fiber. The\n// work-in-progress hook list is a new list that will be added to the\n// work-in-progress fiber.\n\nlet currentHook = null;\nlet workInProgressHook = null; // Whether an update was scheduled at any point during the render phase. This\n// does not get reset if we do another render pass; only when we're completely\n// finished evaluating this component. This is an optimization so we know\n// whether we need to clear render phase updates after a throw.\n\nlet didScheduleRenderPhaseUpdate = false; // Where an update was scheduled only during the current render pass. This\n// gets reset after each attempt.\n// TODO: Maybe there's some way to consolidate this with\n// `didScheduleRenderPhaseUpdate`. Or with `numberOfReRenders`.\n\nlet didScheduleRenderPhaseUpdateDuringThisPass = false; // Counts the number of useId hooks in this component.\n\nlet localIdCounter = 0; // Used for ids that are generated completely client-side (i.e. not during\n// hydration). This counter is global, so client ids are not stable across\n// render attempts.\n\nlet globalClientIdCounter = 0;\nconst RE_RENDER_LIMIT = 25; // In DEV, this is the name of the currently executing primitive hook\n\nfunction throwInvalidHookError() {\n  throw Error(formatProdErrorMessage(321));\n}\n\nfunction areHookInputsEqual(nextDeps, prevDeps) {\n\n  if (prevDeps === null) {\n\n    return false;\n  }\n\n  for (let i = 0; i < prevDeps.length && i < nextDeps.length; i++) {\n    if (objectIs(nextDeps[i], prevDeps[i])) {\n      continue;\n    }\n\n    return false;\n  }\n\n  return true;\n}\n\nfunction renderWithHooks(current, workInProgress, Component, props, secondArg, nextRenderLanes) {\n  renderLanes = nextRenderLanes;\n  currentlyRenderingFiber$1 = workInProgress;\n\n  workInProgress.memoizedState = null;\n  workInProgress.updateQueue = null;\n  workInProgress.lanes = NoLanes; // The following should have already been reset\n  // currentHook = null;\n  // workInProgressHook = null;\n  // didScheduleRenderPhaseUpdate = false;\n  // localIdCounter = 0;\n  // TODO Warn if no hooks are used at all during mount, then some are used during update.\n  // Currently we will identify the update render as a mount because memoizedState === null.\n  // This is tricky because it's valid for certain types of components (e.g. React.lazy)\n  // Using memoizedState to differentiate between mount/update only works if at least one stateful hook is used.\n  // Non-stateful hooks (e.g. context) don't get added to memoizedState,\n  // so memoizedState would be null during updates and mounts.\n\n  {\n    ReactCurrentDispatcher$1.current = current === null || current.memoizedState === null ? HooksDispatcherOnMount : HooksDispatcherOnUpdate;\n  }\n\n  let children = Component(props, secondArg); // Check if there was a render phase update\n\n  if (didScheduleRenderPhaseUpdateDuringThisPass) {\n    // Keep rendering in a loop for as long as render phase updates continue to\n    // be scheduled. Use a counter to prevent infinite loops.\n    let numberOfReRenders = 0;\n\n    do {\n      didScheduleRenderPhaseUpdateDuringThisPass = false;\n      localIdCounter = 0;\n\n      if (numberOfReRenders >= RE_RENDER_LIMIT) {\n        throw Error(formatProdErrorMessage(301));\n      }\n\n      numberOfReRenders += 1;\n\n\n      currentHook = null;\n      workInProgressHook = null;\n      workInProgress.updateQueue = null;\n\n      ReactCurrentDispatcher$1.current =  HooksDispatcherOnRerender;\n      children = Component(props, secondArg);\n    } while (didScheduleRenderPhaseUpdateDuringThisPass);\n  } // We can assume the previous dispatcher is always this one, since we set it\n  // at the beginning of the render phase and there's no re-entrance.\n\n\n  ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;\n  // hookTypesDev could catch more cases (e.g. context) but only in DEV bundles.\n\n\n  const didRenderTooFewHooks = currentHook !== null && currentHook.next !== null;\n  renderLanes = NoLanes;\n  currentlyRenderingFiber$1 = null;\n  currentHook = null;\n  workInProgressHook = null;\n\n  didScheduleRenderPhaseUpdate = false; // This is reset by checkDidRenderIdHook\n  // localIdCounter = 0;\n\n  if (didRenderTooFewHooks) {\n    throw Error(formatProdErrorMessage(300));\n  }\n\n  return children;\n}\nfunction checkDidRenderIdHook() {\n  // This should be called immediately after every renderWithHooks call.\n  // Conceptually, it's part of the return value of renderWithHooks; it's only a\n  // separate function to avoid using an array tuple.\n  const didRenderIdHook = localIdCounter !== 0;\n  localIdCounter = 0;\n  return didRenderIdHook;\n}\nfunction bailoutHooks(current, workInProgress, lanes) {\n  workInProgress.updateQueue = current.updateQueue; // TODO: Don't need to reset the flags here, because they're reset in the\n  // complete phase (bubbleProperties).\n\n  {\n    workInProgress.flags &= ~(Passive | Update);\n  }\n\n  current.lanes = removeLanes(current.lanes, lanes);\n}\nfunction resetHooksAfterThrow() {\n  // We can assume the previous dispatcher is always this one, since we set it\n  // at the beginning of the render phase and there's no re-entrance.\n  ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;\n\n  if (didScheduleRenderPhaseUpdate) {\n    // There were render phase updates. These are only valid for this render\n    // phase, which we are now aborting. Remove the updates from the queues so\n    // they do not persist to the next render. Do not remove updates from hooks\n    // that weren't processed.\n    //\n    // Only reset the updates from the queue if it has a clone. If it does\n    // not have a clone, that means it wasn't processed, and the updates were\n    // scheduled before we entered the render phase.\n    let hook = currentlyRenderingFiber$1.memoizedState;\n\n    while (hook !== null) {\n      const queue = hook.queue;\n\n      if (queue !== null) {\n        queue.pending = null;\n      }\n\n      hook = hook.next;\n    }\n\n    didScheduleRenderPhaseUpdate = false;\n  }\n\n  renderLanes = NoLanes;\n  currentlyRenderingFiber$1 = null;\n  currentHook = null;\n  workInProgressHook = null;\n\n  didScheduleRenderPhaseUpdateDuringThisPass = false;\n  localIdCounter = 0;\n}\n\nfunction mountWorkInProgressHook() {\n  const hook = {\n    memoizedState: null,\n    baseState: null,\n    baseQueue: null,\n    queue: null,\n    next: null\n  };\n\n  if (workInProgressHook === null) {\n    // This is the first hook in the list\n    currentlyRenderingFiber$1.memoizedState = workInProgressHook = hook;\n  } else {\n    // Append to the end of the list\n    workInProgressHook = workInProgressHook.next = hook;\n  }\n\n  return workInProgressHook;\n}\n\nfunction updateWorkInProgressHook() {\n  // This function is used both for updates and for re-renders triggered by a\n  // render phase update. It assumes there is either a current hook we can\n  // clone, or a work-in-progress hook from a previous render pass that we can\n  // use as a base. When we reach the end of the base list, we must switch to\n  // the dispatcher used for mounts.\n  let nextCurrentHook;\n\n  if (currentHook === null) {\n    const current = currentlyRenderingFiber$1.alternate;\n\n    if (current !== null) {\n      nextCurrentHook = current.memoizedState;\n    } else {\n      nextCurrentHook = null;\n    }\n  } else {\n    nextCurrentHook = currentHook.next;\n  }\n\n  let nextWorkInProgressHook;\n\n  if (workInProgressHook === null) {\n    nextWorkInProgressHook = currentlyRenderingFiber$1.memoizedState;\n  } else {\n    nextWorkInProgressHook = workInProgressHook.next;\n  }\n\n  if (nextWorkInProgressHook !== null) {\n    // There's already a work-in-progress. Reuse it.\n    workInProgressHook = nextWorkInProgressHook;\n    nextWorkInProgressHook = workInProgressHook.next;\n    currentHook = nextCurrentHook;\n  } else {\n    // Clone from the current hook.\n    if (nextCurrentHook === null) {\n      throw Error(formatProdErrorMessage(310));\n    }\n\n    currentHook = nextCurrentHook;\n    const newHook = {\n      memoizedState: currentHook.memoizedState,\n      baseState: currentHook.baseState,\n      baseQueue: currentHook.baseQueue,\n      queue: currentHook.queue,\n      next: null\n    };\n\n    if (workInProgressHook === null) {\n      // This is the first hook in the list.\n      currentlyRenderingFiber$1.memoizedState = workInProgressHook = newHook;\n    } else {\n      // Append to the end of the list.\n      workInProgressHook = workInProgressHook.next = newHook;\n    }\n  }\n\n  return workInProgressHook;\n}\n\nfunction createFunctionComponentUpdateQueue() {\n  return {\n    lastEffect: null,\n    stores: null\n  };\n}\n\nfunction basicStateReducer(state, action) {\n  // $FlowFixMe: Flow doesn't like mixed types\n  return typeof action === 'function' ? action(state) : action;\n}\n\nfunction mountReducer(reducer, initialArg, init) {\n  const hook = mountWorkInProgressHook();\n  let initialState;\n\n  if (init !== undefined) {\n    initialState = init(initialArg);\n  } else {\n    initialState = initialArg;\n  }\n\n  hook.memoizedState = hook.baseState = initialState;\n  const queue = {\n    pending: null,\n    interleaved: null,\n    lanes: NoLanes,\n    dispatch: null,\n    lastRenderedReducer: reducer,\n    lastRenderedState: initialState\n  };\n  hook.queue = queue;\n  const dispatch = queue.dispatch = dispatchReducerAction.bind(null, currentlyRenderingFiber$1, queue);\n  return [hook.memoizedState, dispatch];\n}\n\nfunction updateReducer(reducer, initialArg, init) {\n  const hook = updateWorkInProgressHook();\n  const queue = hook.queue;\n\n  if (queue === null) {\n    throw Error(formatProdErrorMessage(311));\n  }\n\n  queue.lastRenderedReducer = reducer;\n  const current = currentHook; // The last rebase update that is NOT part of the base state.\n\n  let baseQueue = current.baseQueue; // The last pending update that hasn't been processed yet.\n\n  const pendingQueue = queue.pending;\n\n  if (pendingQueue !== null) {\n    // We have new updates that haven't been processed yet.\n    // We'll add them to the base queue.\n    if (baseQueue !== null) {\n      // Merge the pending queue and the base queue.\n      const baseFirst = baseQueue.next;\n      const pendingFirst = pendingQueue.next;\n      baseQueue.next = pendingFirst;\n      pendingQueue.next = baseFirst;\n    }\n\n    current.baseQueue = baseQueue = pendingQueue;\n    queue.pending = null;\n  }\n\n  if (baseQueue !== null) {\n    // We have a queue to process.\n    const first = baseQueue.next;\n    let newState = current.baseState;\n    let newBaseState = null;\n    let newBaseQueueFirst = null;\n    let newBaseQueueLast = null;\n    let update = first;\n\n    do {\n      const updateLane = update.lane;\n\n      if (!isSubsetOfLanes(renderLanes, updateLane)) {\n        // Priority is insufficient. Skip this update. If this is the first\n        // skipped update, the previous update/state is the new base\n        // update/state.\n        const clone = {\n          lane: updateLane,\n          action: update.action,\n          hasEagerState: update.hasEagerState,\n          eagerState: update.eagerState,\n          next: null\n        };\n\n        if (newBaseQueueLast === null) {\n          newBaseQueueFirst = newBaseQueueLast = clone;\n          newBaseState = newState;\n        } else {\n          newBaseQueueLast = newBaseQueueLast.next = clone;\n        } // Update the remaining priority in the queue.\n        // TODO: Don't need to accumulate this. Instead, we can remove\n        // renderLanes from the original lanes.\n\n\n        currentlyRenderingFiber$1.lanes = mergeLanes(currentlyRenderingFiber$1.lanes, updateLane);\n        markSkippedUpdateLanes(updateLane);\n      } else {\n        // This update does have sufficient priority.\n        if (newBaseQueueLast !== null) {\n          const clone = {\n            // This update is going to be committed so we never want uncommit\n            // it. Using NoLane works because 0 is a subset of all bitmasks, so\n            // this will never be skipped by the check above.\n            lane: NoLane,\n            action: update.action,\n            hasEagerState: update.hasEagerState,\n            eagerState: update.eagerState,\n            next: null\n          };\n          newBaseQueueLast = newBaseQueueLast.next = clone;\n        } // Process this update.\n\n\n        if (update.hasEagerState) {\n          // If this update is a state update (not a reducer) and was processed eagerly,\n          // we can use the eagerly computed state\n          newState = update.eagerState;\n        } else {\n          const action = update.action;\n          newState = reducer(newState, action);\n        }\n      }\n\n      update = update.next;\n    } while (update !== null && update !== first);\n\n    if (newBaseQueueLast === null) {\n      newBaseState = newState;\n    } else {\n      newBaseQueueLast.next = newBaseQueueFirst;\n    } // Mark that the fiber performed work, but only if the new state is\n    // different from the current state.\n\n\n    if (!objectIs(newState, hook.memoizedState)) {\n      markWorkInProgressReceivedUpdate();\n    }\n\n    hook.memoizedState = newState;\n    hook.baseState = newBaseState;\n    hook.baseQueue = newBaseQueueLast;\n    queue.lastRenderedState = newState;\n  } // Interleaved updates are stored on a separate queue. We aren't going to\n  // process them during this render, but we do need to track which lanes\n  // are remaining.\n\n\n  const lastInterleaved = queue.interleaved;\n\n  if (lastInterleaved !== null) {\n    let interleaved = lastInterleaved;\n\n    do {\n      const interleavedLane = interleaved.lane;\n      currentlyRenderingFiber$1.lanes = mergeLanes(currentlyRenderingFiber$1.lanes, interleavedLane);\n      markSkippedUpdateLanes(interleavedLane);\n      interleaved = interleaved.next;\n    } while (interleaved !== lastInterleaved);\n  } else if (baseQueue === null) {\n    // `queue.lanes` is used for entangling transitions. We can set it back to\n    // zero once the queue is empty.\n    queue.lanes = NoLanes;\n  }\n\n  const dispatch = queue.dispatch;\n  return [hook.memoizedState, dispatch];\n}\n\nfunction rerenderReducer(reducer, initialArg, init) {\n  const hook = updateWorkInProgressHook();\n  const queue = hook.queue;\n\n  if (queue === null) {\n    throw Error(formatProdErrorMessage(311));\n  }\n\n  queue.lastRenderedReducer = reducer; // This is a re-render. Apply the new render phase updates to the previous\n  // work-in-progress hook.\n\n  const dispatch = queue.dispatch;\n  const lastRenderPhaseUpdate = queue.pending;\n  let newState = hook.memoizedState;\n\n  if (lastRenderPhaseUpdate !== null) {\n    // The queue doesn't persist past this render pass.\n    queue.pending = null;\n    const firstRenderPhaseUpdate = lastRenderPhaseUpdate.next;\n    let update = firstRenderPhaseUpdate;\n\n    do {\n      // Process this render phase update. We don't have to check the\n      // priority because it will always be the same as the current\n      // render's.\n      const action = update.action;\n      newState = reducer(newState, action);\n      update = update.next;\n    } while (update !== firstRenderPhaseUpdate); // Mark that the fiber performed work, but only if the new state is\n    // different from the current state.\n\n\n    if (!objectIs(newState, hook.memoizedState)) {\n      markWorkInProgressReceivedUpdate();\n    }\n\n    hook.memoizedState = newState; // Don't persist the state accumulated from the render phase updates to\n    // the base state unless the queue is empty.\n    // TODO: Not sure if this is the desired semantics, but it's what we\n    // do for gDSFP. I can't remember why.\n\n    if (hook.baseQueue === null) {\n      hook.baseState = newState;\n    }\n\n    queue.lastRenderedState = newState;\n  }\n\n  return [newState, dispatch];\n}\n\nfunction mountMutableSource(source, getSnapshot, subscribe) {\n  {\n    return undefined;\n  }\n}\n\nfunction updateMutableSource(source, getSnapshot, subscribe) {\n  {\n    return undefined;\n  }\n}\n\nfunction mountSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {\n  const fiber = currentlyRenderingFiber$1;\n  const hook = mountWorkInProgressHook();\n  let nextSnapshot;\n  const isHydrating = getIsHydrating();\n\n  if (isHydrating) {\n    if (getServerSnapshot === undefined) {\n      throw Error(formatProdErrorMessage(407));\n    }\n\n    nextSnapshot = getServerSnapshot();\n  } else {\n    nextSnapshot = getSnapshot();\n    // Right before committing, we will walk the tree and check if any of the\n    // stores were mutated.\n    //\n    // We won't do this if we're hydrating server-rendered content, because if\n    // the content is stale, it's already visible anyway. Instead we'll patch\n    // it up in a passive effect.\n\n\n    const root = getWorkInProgressRoot();\n\n    if (root === null) {\n      throw Error(formatProdErrorMessage(349));\n    }\n\n    if (!includesBlockingLane(root, renderLanes)) {\n      pushStoreConsistencyCheck(fiber, getSnapshot, nextSnapshot);\n    }\n  } // Read the current snapshot from the store on every render. This breaks the\n  // normal rules of React, and only works because store updates are\n  // always synchronous.\n\n\n  hook.memoizedState = nextSnapshot;\n  const inst = {\n    value: nextSnapshot,\n    getSnapshot\n  };\n  hook.queue = inst; // Schedule an effect to subscribe to the store.\n\n  mountEffect(subscribeToStore.bind(null, fiber, inst, subscribe), [subscribe]); // Schedule an effect to update the mutable instance fields. We will update\n  // this whenever subscribe, getSnapshot, or value changes. Because there's no\n  // clean-up function, and we track the deps correctly, we can call pushEffect\n  // directly, without storing any additional state. For the same reason, we\n  // don't need to set a static flag, either.\n  // TODO: We can move this to the passive phase once we add a pre-commit\n  // consistency check. See the next comment.\n\n  fiber.flags |= Passive;\n  pushEffect(HasEffect | Passive$1, updateStoreInstance.bind(null, fiber, inst, nextSnapshot, getSnapshot), undefined, null);\n  return nextSnapshot;\n}\n\nfunction updateSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {\n  const fiber = currentlyRenderingFiber$1;\n  const hook = updateWorkInProgressHook(); // Read the current snapshot from the store on every render. This breaks the\n  // normal rules of React, and only works because store updates are\n  // always synchronous.\n\n  const nextSnapshot = getSnapshot();\n\n  const prevSnapshot = hook.memoizedState;\n  const snapshotChanged = !objectIs(prevSnapshot, nextSnapshot);\n\n  if (snapshotChanged) {\n    hook.memoizedState = nextSnapshot;\n    markWorkInProgressReceivedUpdate();\n  }\n\n  const inst = hook.queue;\n  updateEffect(subscribeToStore.bind(null, fiber, inst, subscribe), [subscribe]); // Whenever getSnapshot or subscribe changes, we need to check in the\n  // commit phase if there was an interleaved mutation. In concurrent mode\n  // this can happen all the time, but even in synchronous mode, an earlier\n  // effect may have mutated the store.\n\n  if (inst.getSnapshot !== getSnapshot || snapshotChanged || // Check if the susbcribe function changed. We can save some memory by\n  // checking whether we scheduled a subscription effect above.\n  workInProgressHook !== null && workInProgressHook.memoizedState.tag & HasEffect) {\n    fiber.flags |= Passive;\n    pushEffect(HasEffect | Passive$1, updateStoreInstance.bind(null, fiber, inst, nextSnapshot, getSnapshot), undefined, null); // Unless we're rendering a blocking lane, schedule a consistency check.\n    // Right before committing, we will walk the tree and check if any of the\n    // stores were mutated.\n\n    const root = getWorkInProgressRoot();\n\n    if (root === null) {\n      throw Error(formatProdErrorMessage(349));\n    }\n\n    if (!includesBlockingLane(root, renderLanes)) {\n      pushStoreConsistencyCheck(fiber, getSnapshot, nextSnapshot);\n    }\n  }\n\n  return nextSnapshot;\n}\n\nfunction pushStoreConsistencyCheck(fiber, getSnapshot, renderedSnapshot) {\n  fiber.flags |= StoreConsistency;\n  const check = {\n    getSnapshot,\n    value: renderedSnapshot\n  };\n  let componentUpdateQueue = currentlyRenderingFiber$1.updateQueue;\n\n  if (componentUpdateQueue === null) {\n    componentUpdateQueue = createFunctionComponentUpdateQueue();\n    currentlyRenderingFiber$1.updateQueue = componentUpdateQueue;\n    componentUpdateQueue.stores = [check];\n  } else {\n    const stores = componentUpdateQueue.stores;\n\n    if (stores === null) {\n      componentUpdateQueue.stores = [check];\n    } else {\n      stores.push(check);\n    }\n  }\n}\n\nfunction updateStoreInstance(fiber, inst, nextSnapshot, getSnapshot) {\n  // These are updated in the passive phase\n  inst.value = nextSnapshot;\n  inst.getSnapshot = getSnapshot; // Something may have been mutated in between render and commit. This could\n  // have been in an event that fired before the passive effects, or it could\n  // have been in a layout effect. In that case, we would have used the old\n  // snapsho and getSnapshot values to bail out. We need to check one more time.\n\n  if (checkIfSnapshotChanged(inst)) {\n    // Force a re-render.\n    forceStoreRerender(fiber);\n  }\n}\n\nfunction subscribeToStore(fiber, inst, subscribe) {\n  const handleStoreChange = () => {\n    // The store changed. Check if the snapshot changed since the last time we\n    // read from the store.\n    if (checkIfSnapshotChanged(inst)) {\n      // Force a re-render.\n      forceStoreRerender(fiber);\n    }\n  }; // Subscribe to the store and return a clean-up function.\n\n\n  return subscribe(handleStoreChange);\n}\n\nfunction checkIfSnapshotChanged(inst) {\n  const latestGetSnapshot = inst.getSnapshot;\n  const prevValue = inst.value;\n\n  try {\n    const nextValue = latestGetSnapshot();\n    return !objectIs(prevValue, nextValue);\n  } catch (error) {\n    return true;\n  }\n}\n\nfunction forceStoreRerender(fiber) {\n  const root = enqueueConcurrentRenderForLane(fiber, SyncLane);\n\n  if (root !== null) {\n    scheduleUpdateOnFiber(root, fiber, SyncLane, NoTimestamp);\n  }\n}\n\nfunction mountState(initialState) {\n  const hook = mountWorkInProgressHook();\n\n  if (typeof initialState === 'function') {\n    // $FlowFixMe: Flow doesn't like mixed types\n    initialState = initialState();\n  }\n\n  hook.memoizedState = hook.baseState = initialState;\n  const queue = {\n    pending: null,\n    interleaved: null,\n    lanes: NoLanes,\n    dispatch: null,\n    lastRenderedReducer: basicStateReducer,\n    lastRenderedState: initialState\n  };\n  hook.queue = queue;\n  const dispatch = queue.dispatch = dispatchSetState.bind(null, currentlyRenderingFiber$1, queue);\n  return [hook.memoizedState, dispatch];\n}\n\nfunction updateState(initialState) {\n  return updateReducer(basicStateReducer);\n}\n\nfunction rerenderState(initialState) {\n  return rerenderReducer(basicStateReducer);\n}\n\nfunction pushEffect(tag, create, destroy, deps) {\n  const effect = {\n    tag,\n    create,\n    destroy,\n    deps,\n    // Circular\n    next: null\n  };\n  let componentUpdateQueue = currentlyRenderingFiber$1.updateQueue;\n\n  if (componentUpdateQueue === null) {\n    componentUpdateQueue = createFunctionComponentUpdateQueue();\n    currentlyRenderingFiber$1.updateQueue = componentUpdateQueue;\n    componentUpdateQueue.lastEffect = effect.next = effect;\n  } else {\n    const lastEffect = componentUpdateQueue.lastEffect;\n\n    if (lastEffect === null) {\n      componentUpdateQueue.lastEffect = effect.next = effect;\n    } else {\n      const firstEffect = lastEffect.next;\n      lastEffect.next = effect;\n      effect.next = firstEffect;\n      componentUpdateQueue.lastEffect = effect;\n    }\n  }\n\n  return effect;\n}\n\nfunction mountRef(initialValue) {\n  const hook = mountWorkInProgressHook();\n\n  {\n    const ref = {\n      current: initialValue\n    };\n    hook.memoizedState = ref;\n    return ref;\n  }\n}\n\nfunction updateRef(initialValue) {\n  const hook = updateWorkInProgressHook();\n  return hook.memoizedState;\n}\n\nfunction mountEffectImpl(fiberFlags, hookFlags, create, deps) {\n  const hook = mountWorkInProgressHook();\n  const nextDeps = deps === undefined ? null : deps;\n  currentlyRenderingFiber$1.flags |= fiberFlags;\n  hook.memoizedState = pushEffect(HasEffect | hookFlags, create, undefined, nextDeps);\n}\n\nfunction updateEffectImpl(fiberFlags, hookFlags, create, deps) {\n  const hook = updateWorkInProgressHook();\n  const nextDeps = deps === undefined ? null : deps;\n  let destroy = undefined;\n\n  if (currentHook !== null) {\n    const prevEffect = currentHook.memoizedState;\n    destroy = prevEffect.destroy;\n\n    if (nextDeps !== null) {\n      const prevDeps = prevEffect.deps;\n\n      if (areHookInputsEqual(nextDeps, prevDeps)) {\n        hook.memoizedState = pushEffect(hookFlags, create, destroy, nextDeps);\n        return;\n      }\n    }\n  }\n\n  currentlyRenderingFiber$1.flags |= fiberFlags;\n  hook.memoizedState = pushEffect(HasEffect | hookFlags, create, destroy, nextDeps);\n}\n\nfunction mountEffect(create, deps) {\n  {\n    return mountEffectImpl(Passive | PassiveStatic, Passive$1, create, deps);\n  }\n}\n\nfunction updateEffect(create, deps) {\n  return updateEffectImpl(Passive, Passive$1, create, deps);\n}\n\nfunction mountInsertionEffect(create, deps) {\n  return mountEffectImpl(Update, Insertion, create, deps);\n}\n\nfunction updateInsertionEffect(create, deps) {\n  return updateEffectImpl(Update, Insertion, create, deps);\n}\n\nfunction mountLayoutEffect(create, deps) {\n  let fiberFlags = Update;\n\n  {\n    fiberFlags |= LayoutStatic;\n  }\n\n  return mountEffectImpl(fiberFlags, Layout, create, deps);\n}\n\nfunction updateLayoutEffect(create, deps) {\n  return updateEffectImpl(Update, Layout, create, deps);\n}\n\nfunction imperativeHandleEffect(create, ref) {\n  if (typeof ref === 'function') {\n    const refCallback = ref;\n    const inst = create();\n    refCallback(inst);\n    return () => {\n      refCallback(null);\n    };\n  } else if (ref !== null && ref !== undefined) {\n    const refObject = ref;\n\n    const inst = create();\n    refObject.current = inst;\n    return () => {\n      refObject.current = null;\n    };\n  }\n}\n\nfunction mountImperativeHandle(ref, create, deps) {\n\n\n  const effectDeps = deps !== null && deps !== undefined ? deps.concat([ref]) : null;\n  let fiberFlags = Update;\n\n  {\n    fiberFlags |= LayoutStatic;\n  }\n\n  return mountEffectImpl(fiberFlags, Layout, imperativeHandleEffect.bind(null, create, ref), effectDeps);\n}\n\nfunction updateImperativeHandle(ref, create, deps) {\n\n\n  const effectDeps = deps !== null && deps !== undefined ? deps.concat([ref]) : null;\n  return updateEffectImpl(Update, Layout, imperativeHandleEffect.bind(null, create, ref), effectDeps);\n}\n\nfunction mountDebugValue(value, formatterFn) {// This hook is normally a no-op.\n  // The react-debug-hooks package injects its own implementation\n  // so that e.g. DevTools can display custom hook values.\n}\n\nconst updateDebugValue = mountDebugValue;\n\nfunction mountCallback(callback, deps) {\n  const hook = mountWorkInProgressHook();\n  const nextDeps = deps === undefined ? null : deps;\n  hook.memoizedState = [callback, nextDeps];\n  return callback;\n}\n\nfunction updateCallback(callback, deps) {\n  const hook = updateWorkInProgressHook();\n  const nextDeps = deps === undefined ? null : deps;\n  const prevState = hook.memoizedState;\n\n  if (prevState !== null) {\n    if (nextDeps !== null) {\n      const prevDeps = prevState[1];\n\n      if (areHookInputsEqual(nextDeps, prevDeps)) {\n        return prevState[0];\n      }\n    }\n  }\n\n  hook.memoizedState = [callback, nextDeps];\n  return callback;\n}\n\nfunction mountMemo(nextCreate, deps) {\n  const hook = mountWorkInProgressHook();\n  const nextDeps = deps === undefined ? null : deps;\n  const nextValue = nextCreate();\n  hook.memoizedState = [nextValue, nextDeps];\n  return nextValue;\n}\n\nfunction updateMemo(nextCreate, deps) {\n  const hook = updateWorkInProgressHook();\n  const nextDeps = deps === undefined ? null : deps;\n  const prevState = hook.memoizedState;\n\n  if (prevState !== null) {\n    // Assume these are defined. If they're not, areHookInputsEqual will warn.\n    if (nextDeps !== null) {\n      const prevDeps = prevState[1];\n\n      if (areHookInputsEqual(nextDeps, prevDeps)) {\n        return prevState[0];\n      }\n    }\n  }\n\n  const nextValue = nextCreate();\n  hook.memoizedState = [nextValue, nextDeps];\n  return nextValue;\n}\n\nfunction mountDeferredValue(value) {\n  const hook = mountWorkInProgressHook();\n  hook.memoizedState = value;\n  return value;\n}\n\nfunction updateDeferredValue(value) {\n  const hook = updateWorkInProgressHook();\n  const resolvedCurrentHook = currentHook;\n  const prevValue = resolvedCurrentHook.memoizedState;\n  return updateDeferredValueImpl(hook, prevValue, value);\n}\n\nfunction rerenderDeferredValue(value) {\n  const hook = updateWorkInProgressHook();\n\n  if (currentHook === null) {\n    // This is a rerender during a mount.\n    hook.memoizedState = value;\n    return value;\n  } else {\n    // This is a rerender during an update.\n    const prevValue = currentHook.memoizedState;\n    return updateDeferredValueImpl(hook, prevValue, value);\n  }\n}\n\nfunction updateDeferredValueImpl(hook, prevValue, value) {\n  const shouldDeferValue = !includesOnlyNonUrgentLanes(renderLanes);\n\n  if (shouldDeferValue) {\n    // This is an urgent update. If the value has changed, keep using the\n    // previous value and spawn a deferred render to update it later.\n    if (!objectIs(value, prevValue)) {\n      // Schedule a deferred render\n      const deferredLane = claimNextTransitionLane();\n      currentlyRenderingFiber$1.lanes = mergeLanes(currentlyRenderingFiber$1.lanes, deferredLane);\n      markSkippedUpdateLanes(deferredLane); // Set this to true to indicate that the rendered value is inconsistent\n      // from the latest value. The name \"baseState\" doesn't really match how we\n      // use it because we're reusing a state hook field instead of creating a\n      // new one.\n\n      hook.baseState = true;\n    } // Reuse the previous value\n\n\n    return prevValue;\n  } else {\n    // This is not an urgent update, so we can use the latest value regardless\n    // of what it is. No need to defer it.\n    // However, if we're currently inside a spawned render, then we need to mark\n    // this as an update to prevent the fiber from bailing out.\n    //\n    // `baseState` is true when the current value is different from the rendered\n    // value. The name doesn't really match how we use it because we're reusing\n    // a state hook field instead of creating a new one.\n    if (hook.baseState) {\n      // Flip this back to false.\n      hook.baseState = false;\n      markWorkInProgressReceivedUpdate();\n    }\n\n    hook.memoizedState = value;\n    return value;\n  }\n}\n\nfunction startTransition(setPending, callback, options) {\n  const previousPriority = getCurrentUpdatePriority();\n  setCurrentUpdatePriority(higherEventPriority(previousPriority, ContinuousEventPriority));\n  setPending(true);\n  const prevTransition = ReactCurrentBatchConfig$2.transition;\n  ReactCurrentBatchConfig$2.transition = {};\n  const currentTransition = ReactCurrentBatchConfig$2.transition;\n\n  try {\n    setPending(false);\n    callback();\n  } finally {\n    setCurrentUpdatePriority(previousPriority);\n    ReactCurrentBatchConfig$2.transition = prevTransition;\n  }\n}\n\nfunction mountTransition() {\n  const _mountState = mountState(false),\n        isPending = _mountState[0],\n        setPending = _mountState[1]; // The `start` method never changes.\n\n\n  const start = startTransition.bind(null, setPending);\n  const hook = mountWorkInProgressHook();\n  hook.memoizedState = start;\n  return [isPending, start];\n}\n\nfunction updateTransition() {\n  const _updateState = updateState(),\n        isPending = _updateState[0];\n\n  const hook = updateWorkInProgressHook();\n  const start = hook.memoizedState;\n  return [isPending, start];\n}\n\nfunction rerenderTransition() {\n  const _rerenderState = rerenderState(),\n        isPending = _rerenderState[0];\n\n  const hook = updateWorkInProgressHook();\n  const start = hook.memoizedState;\n  return [isPending, start];\n}\n\nfunction mountId() {\n  const hook = mountWorkInProgressHook();\n  const root = getWorkInProgressRoot(); // TODO: In Fizz, id generation is specific to each server config. Maybe we\n  // should do this in Fiber, too? Deferring this decision for now because\n  // there's no other place to store the prefix except for an internal field on\n  // the public createRoot object, which the fiber tree does not currently have\n  // a reference to.\n\n  const identifierPrefix = root.identifierPrefix;\n  let id;\n\n  if (getIsHydrating()) {\n    const treeId = getTreeId(); // Use a captial R prefix for server-generated ids.\n\n    id = ':' + identifierPrefix + 'R' + treeId; // Unless this is the first id at this level, append a number at the end\n    // that represents the position of this useId hook among all the useId\n    // hooks for this fiber.\n\n    const localId = localIdCounter++;\n\n    if (localId > 0) {\n      id += 'H' + localId.toString(32);\n    }\n\n    id += ':';\n  } else {\n    // Use a lowercase r prefix for client-generated ids.\n    const globalClientId = globalClientIdCounter++;\n    id = ':' + identifierPrefix + 'r' + globalClientId.toString(32) + ':';\n  }\n\n  hook.memoizedState = id;\n  return id;\n}\n\nfunction updateId() {\n  const hook = updateWorkInProgressHook();\n  const id = hook.memoizedState;\n  return id;\n}\n\nfunction dispatchReducerAction(fiber, queue, action) {\n\n  const lane = requestUpdateLane(fiber);\n  const update = {\n    lane,\n    action,\n    hasEagerState: false,\n    eagerState: null,\n    next: null\n  };\n\n  if (isRenderPhaseUpdate(fiber)) {\n    enqueueRenderPhaseUpdate(queue, update);\n  } else {\n    const root = enqueueConcurrentHookUpdate(fiber, queue, update, lane);\n\n    if (root !== null) {\n      const eventTime = requestEventTime();\n      scheduleUpdateOnFiber(root, fiber, lane, eventTime);\n      entangleTransitionUpdate(root, queue, lane);\n    }\n  }\n}\n\nfunction dispatchSetState(fiber, queue, action) {\n\n  const lane = requestUpdateLane(fiber);\n  const update = {\n    lane,\n    action,\n    hasEagerState: false,\n    eagerState: null,\n    next: null\n  };\n\n  if (isRenderPhaseUpdate(fiber)) {\n    enqueueRenderPhaseUpdate(queue, update);\n  } else {\n    const alternate = fiber.alternate;\n\n    if (fiber.lanes === NoLanes && (alternate === null || alternate.lanes === NoLanes)) {\n      // The queue is currently empty, which means we can eagerly compute the\n      // next state before entering the render phase. If the new state is the\n      // same as the current state, we may be able to bail out entirely.\n      const lastRenderedReducer = queue.lastRenderedReducer;\n\n      if (lastRenderedReducer !== null) {\n\n        try {\n          const currentState = queue.lastRenderedState;\n          const eagerState = lastRenderedReducer(currentState, action); // Stash the eagerly computed state, and the reducer used to compute\n          // it, on the update object. If the reducer hasn't changed by the\n          // time we enter the render phase, then the eager state can be used\n          // without calling the reducer again.\n\n          update.hasEagerState = true;\n          update.eagerState = eagerState;\n\n          if (objectIs(eagerState, currentState)) {\n            // Fast path. We can bail out without scheduling React to re-render.\n            // It's still possible that we'll need to rebase this update later,\n            // if the component re-renders for a different reason and by that\n            // time the reducer has changed.\n            // TODO: Do we still need to entangle transitions in this case?\n            enqueueConcurrentHookUpdateAndEagerlyBailout(fiber, queue, update, lane);\n            return;\n          }\n        } catch (error) {// Suppress the error. It will throw again in the render phase.\n        } finally {\n        }\n      }\n    }\n\n    const root = enqueueConcurrentHookUpdate(fiber, queue, update, lane);\n\n    if (root !== null) {\n      const eventTime = requestEventTime();\n      scheduleUpdateOnFiber(root, fiber, lane, eventTime);\n      entangleTransitionUpdate(root, queue, lane);\n    }\n  }\n}\n\nfunction isRenderPhaseUpdate(fiber) {\n  const alternate = fiber.alternate;\n  return fiber === currentlyRenderingFiber$1 || alternate !== null && alternate === currentlyRenderingFiber$1;\n}\n\nfunction enqueueRenderPhaseUpdate(queue, update) {\n  // This is a render phase update. Stash it in a lazily-created map of\n  // queue -> linked list of updates. After this render pass, we'll restart\n  // and apply the stashed updates on top of the work-in-progress hook.\n  didScheduleRenderPhaseUpdateDuringThisPass = didScheduleRenderPhaseUpdate = true;\n  const pending = queue.pending;\n\n  if (pending === null) {\n    // This is the first update. Create a circular list.\n    update.next = update;\n  } else {\n    update.next = pending.next;\n    pending.next = update;\n  }\n\n  queue.pending = update;\n} // TODO: Move to ReactFiberConcurrentUpdates?\n\n\nfunction entangleTransitionUpdate(root, queue, lane) {\n  if (isTransitionLane(lane)) {\n    let queueLanes = queue.lanes; // If any entangled lanes are no longer pending on the root, then they\n    // must have finished. We can remove them from the shared queue, which\n    // represents a superset of the actually pending lanes. In some cases we\n    // may entangle more than we need to, but that's OK. In fact it's worse if\n    // we *don't* entangle when we should.\n\n    queueLanes = intersectLanes(queueLanes, root.pendingLanes); // Entangle the new transition lane with the other transition lanes.\n\n    const newQueueLanes = mergeLanes(queueLanes, lane);\n    queue.lanes = newQueueLanes; // Even if queue.lanes already include lane, we don't know for certain if\n    // the lane finished since the last time we entangled it. So we need to\n    // entangle it again, just to be sure.\n\n    markRootEntangled(root, newQueueLanes);\n  }\n}\n\nconst ContextOnlyDispatcher = {\n  readContext,\n  useCallback: throwInvalidHookError,\n  useContext: throwInvalidHookError,\n  useEffect: throwInvalidHookError,\n  useImperativeHandle: throwInvalidHookError,\n  useInsertionEffect: throwInvalidHookError,\n  useLayoutEffect: throwInvalidHookError,\n  useMemo: throwInvalidHookError,\n  useReducer: throwInvalidHookError,\n  useRef: throwInvalidHookError,\n  useState: throwInvalidHookError,\n  useDebugValue: throwInvalidHookError,\n  useDeferredValue: throwInvalidHookError,\n  useTransition: throwInvalidHookError,\n  useMutableSource: throwInvalidHookError,\n  useSyncExternalStore: throwInvalidHookError,\n  useId: throwInvalidHookError,\n  unstable_isNewReconciler: enableNewReconciler\n};\n\nconst HooksDispatcherOnMount = {\n  readContext,\n  useCallback: mountCallback,\n  useContext: readContext,\n  useEffect: mountEffect,\n  useImperativeHandle: mountImperativeHandle,\n  useLayoutEffect: mountLayoutEffect,\n  useInsertionEffect: mountInsertionEffect,\n  useMemo: mountMemo,\n  useReducer: mountReducer,\n  useRef: mountRef,\n  useState: mountState,\n  useDebugValue: mountDebugValue,\n  useDeferredValue: mountDeferredValue,\n  useTransition: mountTransition,\n  useMutableSource: mountMutableSource,\n  useSyncExternalStore: mountSyncExternalStore,\n  useId: mountId,\n  unstable_isNewReconciler: enableNewReconciler\n};\n\nconst HooksDispatcherOnUpdate = {\n  readContext,\n  useCallback: updateCallback,\n  useContext: readContext,\n  useEffect: updateEffect,\n  useImperativeHandle: updateImperativeHandle,\n  useInsertionEffect: updateInsertionEffect,\n  useLayoutEffect: updateLayoutEffect,\n  useMemo: updateMemo,\n  useReducer: updateReducer,\n  useRef: updateRef,\n  useState: updateState,\n  useDebugValue: updateDebugValue,\n  useDeferredValue: updateDeferredValue,\n  useTransition: updateTransition,\n  useMutableSource: updateMutableSource,\n  useSyncExternalStore: updateSyncExternalStore,\n  useId: updateId,\n  unstable_isNewReconciler: enableNewReconciler\n};\n\nconst HooksDispatcherOnRerender = {\n  readContext,\n  useCallback: updateCallback,\n  useContext: readContext,\n  useEffect: updateEffect,\n  useImperativeHandle: updateImperativeHandle,\n  useInsertionEffect: updateInsertionEffect,\n  useLayoutEffect: updateLayoutEffect,\n  useMemo: updateMemo,\n  useReducer: rerenderReducer,\n  useRef: updateRef,\n  useState: rerenderState,\n  useDebugValue: updateDebugValue,\n  useDeferredValue: rerenderDeferredValue,\n  useTransition: rerenderTransition,\n  useMutableSource: updateMutableSource,\n  useSyncExternalStore: updateSyncExternalStore,\n  useId: updateId,\n  unstable_isNewReconciler: enableNewReconciler\n};\n\nfunction stopProfilerTimerIfRunningAndRecordDelta(fiber, overrideBaseTime) {\n  {\n    return;\n  }\n}\n\nfunction recordLayoutEffectDuration(fiber) {\n  {\n    return;\n  }\n}\n\nfunction startLayoutEffectTimer() {\n  {\n    return;\n  }\n}\n\nfunction createCapturedValueAtFiber(value, source) {\n  // If the value is an error, call this function immediately after it is thrown\n  // so the stack is accurate.\n  return {\n    value,\n    source,\n    stack: getStackByFiberInDevAndProd(source),\n    digest: null\n  };\n}\nfunction createCapturedValue(value, digest, stack) {\n  return {\n    value,\n    source: null,\n    stack: stack != null ? stack : null,\n    digest: digest != null ? digest : null\n  };\n}\n\n// This module is forked in different environments.\n// By default, return `true` to log errors to the console.\n// Forks can return `false` if this isn't desirable.\nfunction showErrorDialog(boundary, errorInfo) {\n  return true;\n}\n\nfunction logCapturedError(boundary, errorInfo) {\n  try {\n    const logError = showErrorDialog(boundary, errorInfo); // Allow injected showErrorDialog() to prevent default console.error logging.\n    // This enables renderers like ReactNative to better manage redbox behavior.\n\n    if (logError === false) {\n      return;\n    }\n\n    const error = errorInfo.value;\n\n    if (false) {\n      const source = errorInfo.source;\n      const stack = errorInfo.stack;\n      const componentStack = stack !== null ? stack : ''; // Browsers support silencing uncaught errors by calling\n      // `preventDefault()` in window `error` handler.\n      // We record this information as an expando on the error.\n\n      if (error != null && error._suppressLogging) {\n        if (boundary.tag === ClassComponent) {\n          // The error is recoverable and was silenced.\n          // Ignore it and don't print the stack addendum.\n          // This is handy for testing error boundaries without noise.\n          return;\n        } // The error is fatal. Since the silencing might have\n        // been accidental, we'll surface it anyway.\n        // However, the browser would have silenced the original error\n        // so we'll print it first, and then print the stack addendum.\n\n\n        console['error'](error); // Don't transform to our wrapper\n        // For a more detailed description of this block, see:\n        // https://github.com/facebook/react/pull/13384\n      }\n\n      const componentName = source ? getComponentNameFromFiber(source) : null;\n      const componentNameMessage = componentName ? \"The above error occurred in the <\" + componentName + \"> component:\" : 'The above error occurred in one of your React components:';\n      let errorBoundaryMessage;\n\n      if (boundary.tag === HostRoot) {\n        errorBoundaryMessage = 'Consider adding an error boundary to your tree to customize error handling behavior.\\n' + 'Visit https://reactjs.org/link/error-boundaries to learn more about error boundaries.';\n      } else {\n        const errorBoundaryName = getComponentNameFromFiber(boundary) || 'Anonymous';\n        errorBoundaryMessage = \"React will try to recreate this component tree from scratch \" + (\"using the error boundary you provided, \" + errorBoundaryName + \".\");\n      }\n\n      const combinedMessage = componentNameMessage + \"\\n\" + componentStack + \"\\n\\n\" + (\"\" + errorBoundaryMessage); // In development, we provide our own message with just the component stack.\n      // We don't include the original error message and JS stack because the browser\n      // has already printed it. Even if the application swallows the error, it is still\n      // displayed by the browser thanks to the DEV-only fake event trick in ReactErrorUtils.\n\n      console['error'](combinedMessage); // Don't transform to our wrapper\n    } else {\n      // In production, we print the error directly.\n      // This will include the message, the JS stack, and anything the browser wants to show.\n      // We pass the error object instead of custom message so that the browser displays the error natively.\n      console['error'](error); // Don't transform to our wrapper\n    }\n  } catch (e) {\n    // This method must not throw, or React internal state will get messed up.\n    // If console.error is overridden, or logCapturedError() shows a dialog that throws,\n    // we want to report this error outside of the normal stack as a last resort.\n    // https://github.com/facebook/react/issues/13188\n    setTimeout(() => {\n      throw e;\n    });\n  }\n}\n\nconst PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map;\n\nfunction createRootErrorUpdate(fiber, errorInfo, lane) {\n  const update = createUpdate(NoTimestamp, lane); // Unmount the root by rendering null.\n\n  update.tag = CaptureUpdate; // Caution: React DevTools currently depends on this property\n  // being called \"element\".\n\n  update.payload = {\n    element: null\n  };\n  const error = errorInfo.value;\n\n  update.callback = () => {\n    onUncaughtError(error);\n    logCapturedError(fiber, errorInfo);\n  };\n\n  return update;\n}\n\nfunction createClassErrorUpdate(fiber, errorInfo, lane) {\n  const update = createUpdate(NoTimestamp, lane);\n  update.tag = CaptureUpdate;\n  const getDerivedStateFromError = fiber.type.getDerivedStateFromError;\n\n  if (typeof getDerivedStateFromError === 'function') {\n    const error = errorInfo.value;\n\n    update.payload = () => {\n      return getDerivedStateFromError(error);\n    };\n\n    update.callback = () => {\n\n      logCapturedError(fiber, errorInfo);\n    };\n  }\n\n  const inst = fiber.stateNode;\n\n  if (inst !== null && typeof inst.componentDidCatch === 'function') {\n    update.callback = function callback() {\n\n      logCapturedError(fiber, errorInfo);\n\n      if (typeof getDerivedStateFromError !== 'function') {\n        // To preserve the preexisting retry behavior of error boundaries,\n        // we keep track of which ones already failed during this batch.\n        // This gets reset before we yield back to the browser.\n        // TODO: Warn in strict mode if getDerivedStateFromError is\n        // not defined.\n        markLegacyErrorBoundaryAsFailed(this);\n      }\n\n      const error = errorInfo.value;\n      const stack = errorInfo.stack;\n      this.componentDidCatch(error, {\n        componentStack: stack !== null ? stack : ''\n      });\n    };\n  }\n\n  return update;\n}\n\nfunction attachPingListener(root, wakeable, lanes) {\n  // Attach a ping listener\n  //\n  // The data might resolve before we have a chance to commit the fallback. Or,\n  // in the case of a refresh, we'll never commit a fallback. So we need to\n  // attach a listener now. When it resolves (\"pings\"), we can decide whether to\n  // try rendering the tree again.\n  //\n  // Only attach a listener if one does not already exist for the lanes\n  // we're currently rendering (which acts like a \"thread ID\" here).\n  //\n  // We only need to do this in concurrent mode. Legacy Suspense always\n  // commits fallbacks synchronously, so there are no pings.\n  let pingCache = root.pingCache;\n  let threadIDs;\n\n  if (pingCache === null) {\n    pingCache = root.pingCache = new PossiblyWeakMap();\n    threadIDs = new Set();\n    pingCache.set(wakeable, threadIDs);\n  } else {\n    threadIDs = pingCache.get(wakeable);\n\n    if (threadIDs === undefined) {\n      threadIDs = new Set();\n      pingCache.set(wakeable, threadIDs);\n    }\n  }\n\n  if (!threadIDs.has(lanes)) {\n    // Memoize using the thread ID to prevent redundant listeners.\n    threadIDs.add(lanes);\n    const ping = pingSuspendedRoot.bind(null, root, wakeable, lanes);\n\n    wakeable.then(ping, ping);\n  }\n}\n\nfunction attachRetryListener(suspenseBoundary, root, wakeable, lanes) {\n  // Retry listener\n  //\n  // If the fallback does commit, we need to attach a different type of\n  // listener. This one schedules an update on the Suspense boundary to turn\n  // the fallback state off.\n  //\n  // Stash the wakeable on the boundary fiber so we can access it in the\n  // commit phase.\n  //\n  // When the wakeable resolves, we'll attempt to render the boundary\n  // again (\"retry\").\n  const wakeables = suspenseBoundary.updateQueue;\n\n  if (wakeables === null) {\n    const updateQueue = new Set();\n    updateQueue.add(wakeable);\n    suspenseBoundary.updateQueue = updateQueue;\n  } else {\n    wakeables.add(wakeable);\n  }\n}\n\nfunction resetSuspendedComponent(sourceFiber, rootRenderLanes) {\n  // A legacy mode Suspense quirk, only relevant to hook components.\n\n\n  const tag = sourceFiber.tag;\n\n  if ((sourceFiber.mode & ConcurrentMode) === NoMode && (tag === FunctionComponent || tag === ForwardRef || tag === SimpleMemoComponent)) {\n    const currentSource = sourceFiber.alternate;\n\n    if (currentSource) {\n      sourceFiber.updateQueue = currentSource.updateQueue;\n      sourceFiber.memoizedState = currentSource.memoizedState;\n      sourceFiber.lanes = currentSource.lanes;\n    } else {\n      sourceFiber.updateQueue = null;\n      sourceFiber.memoizedState = null;\n    }\n  }\n}\n\nfunction getNearestSuspenseBoundaryToCapture(returnFiber) {\n  let node = returnFiber;\n\n  do {\n    if (node.tag === SuspenseComponent && shouldCaptureSuspense(node)) {\n      return node;\n    } // This boundary already captured during this render. Continue to the next\n    // boundary.\n\n\n    node = node.return;\n  } while (node !== null);\n\n  return null;\n}\n\nfunction markSuspenseBoundaryShouldCapture(suspenseBoundary, returnFiber, sourceFiber, root, rootRenderLanes) {\n  // This marks a Suspense boundary so that when we're unwinding the stack,\n  // it captures the suspended \"exception\" and does a second (fallback) pass.\n  if ((suspenseBoundary.mode & ConcurrentMode) === NoMode) {\n    // Legacy Mode Suspense\n    //\n    // If the boundary is in legacy mode, we should *not*\n    // suspend the commit. Pretend as if the suspended component rendered\n    // null and keep rendering. When the Suspense boundary completes,\n    // we'll do a second pass to render the fallback.\n    if (suspenseBoundary === returnFiber) {\n      // Special case where we suspended while reconciling the children of\n      // a Suspense boundary's inner Offscreen wrapper fiber. This happens\n      // when a React.lazy component is a direct child of a\n      // Suspense boundary.\n      //\n      // Suspense boundaries are implemented as multiple fibers, but they\n      // are a single conceptual unit. The legacy mode behavior where we\n      // pretend the suspended fiber committed as `null` won't work,\n      // because in this case the \"suspended\" fiber is the inner\n      // Offscreen wrapper.\n      //\n      // Because the contents of the boundary haven't started rendering\n      // yet (i.e. nothing in the tree has partially rendered) we can\n      // switch to the regular, concurrent mode behavior: mark the\n      // boundary with ShouldCapture and enter the unwind phase.\n      suspenseBoundary.flags |= ShouldCapture;\n    } else {\n      suspenseBoundary.flags |= DidCapture;\n      sourceFiber.flags |= ForceUpdateForLegacySuspense; // We're going to commit this fiber even though it didn't complete.\n      // But we shouldn't call any lifecycle methods or callbacks. Remove\n      // all lifecycle effect tags.\n\n      sourceFiber.flags &= ~(LifecycleEffectMask | Incomplete);\n\n      if (sourceFiber.tag === ClassComponent) {\n        const currentSourceFiber = sourceFiber.alternate;\n\n        if (currentSourceFiber === null) {\n          // This is a new mount. Change the tag so it's not mistaken for a\n          // completed class component. For example, we should not call\n          // componentWillUnmount if it is deleted.\n          sourceFiber.tag = IncompleteClassComponent;\n        } else {\n          // When we try rendering again, we should not reuse the current fiber,\n          // since it's known to be in an inconsistent state. Use a force update to\n          // prevent a bail out.\n          const update = createUpdate(NoTimestamp, SyncLane);\n          update.tag = ForceUpdate;\n          enqueueUpdate(sourceFiber, update, SyncLane);\n        }\n      } // The source fiber did not complete. Mark it with Sync priority to\n      // indicate that it still has pending work.\n\n\n      sourceFiber.lanes = mergeLanes(sourceFiber.lanes, SyncLane);\n    }\n\n    return suspenseBoundary;\n  } // Confirmed that the boundary is in a concurrent mode tree. Continue\n  // with the normal suspend path.\n  //\n  // After this we'll use a set of heuristics to determine whether this\n  // render pass will run to completion or restart or \"suspend\" the commit.\n  // The actual logic for this is spread out in different places.\n  //\n  // This first principle is that if we're going to suspend when we complete\n  // a root, then we should also restart if we get an update or ping that\n  // might unsuspend it, and vice versa. The only reason to suspend is\n  // because you think you might want to restart before committing. However,\n  // it doesn't make sense to restart only while in the period we're suspended.\n  //\n  // Restarting too aggressively is also not good because it starves out any\n  // intermediate loading state. So we use heuristics to determine when.\n  // Suspense Heuristics\n  //\n  // If nothing threw a Promise or all the same fallbacks are already showing,\n  // then don't suspend/restart.\n  //\n  // If this is an initial render of a new tree of Suspense boundaries and\n  // those trigger a fallback, then don't suspend/restart. We want to ensure\n  // that we can show the initial loading state as quickly as possible.\n  //\n  // If we hit a \"Delayed\" case, such as when we'd switch from content back into\n  // a fallback, then we should always suspend/restart. Transitions apply\n  // to this case. If none is defined, JND is used instead.\n  //\n  // If we're already showing a fallback and it gets \"retried\", allowing us to show\n  // another level, but there's still an inner boundary that would show a fallback,\n  // then we suspend/restart for 500ms since the last time we showed a fallback\n  // anywhere in the tree. This effectively throttles progressive loading into a\n  // consistent train of commits. This also gives us an opportunity to restart to\n  // get to the completed state slightly earlier.\n  //\n  // If there's ambiguity due to batching it's resolved in preference of:\n  // 1) \"delayed\", 2) \"initial render\", 3) \"retry\".\n  //\n  // We want to ensure that a \"busy\" state doesn't get force committed. We want to\n  // ensure that new initial loading states can commit as soon as possible.\n\n\n  suspenseBoundary.flags |= ShouldCapture; // TODO: I think we can remove this, since we now use `DidCapture` in\n  // the begin phase to prevent an early bailout.\n\n  suspenseBoundary.lanes = rootRenderLanes;\n  return suspenseBoundary;\n}\n\nfunction throwException(root, returnFiber, sourceFiber, value, rootRenderLanes) {\n  // The source fiber did not complete.\n  sourceFiber.flags |= Incomplete;\n\n  if (value !== null && typeof value === 'object' && typeof value.then === 'function') {\n    // This is a wakeable. The component suspended.\n    const wakeable = value;\n    resetSuspendedComponent(sourceFiber);\n\n\n    const suspenseBoundary = getNearestSuspenseBoundaryToCapture(returnFiber);\n\n    if (suspenseBoundary !== null) {\n      suspenseBoundary.flags &= ~ForceClientRender;\n      markSuspenseBoundaryShouldCapture(suspenseBoundary, returnFiber, sourceFiber, root, rootRenderLanes); // We only attach ping listeners in concurrent mode. Legacy Suspense always\n      // commits fallbacks synchronously, so there are no pings.\n\n      if (suspenseBoundary.mode & ConcurrentMode) {\n        attachPingListener(root, wakeable, rootRenderLanes);\n      }\n\n      attachRetryListener(suspenseBoundary, root, wakeable);\n      return;\n    } else {\n      // No boundary was found. Unless this is a sync update, this is OK.\n      // We can suspend and wait for more data to arrive.\n      if (!includesSyncLane(rootRenderLanes)) {\n        // This is not a sync update. Suspend. Since we're not activating a\n        // Suspense boundary, this will unwind all the way to the root without\n        // performing a second pass to render a fallback. (This is arguably how\n        // refresh transitions should work, too, since we're not going to commit\n        // the fallbacks anyway.)\n        //\n        // This case also applies to initial hydration.\n        attachPingListener(root, wakeable, rootRenderLanes);\n        renderDidSuspendDelayIfPossible();\n        return;\n      } // This is a sync/discrete update. We treat this case like an error\n      // because discrete renders are expected to produce a complete tree\n      // synchronously to maintain consistency with external state.\n\n\n      const uncaughtSuspenseError = Error(formatProdErrorMessage(426)); // If we're outside a transition, fall through to the regular error path.\n      // The error will be caught by the nearest suspense boundary.\n\n      value = uncaughtSuspenseError;\n    }\n  } else {\n    // This is a regular error, not a Suspense wakeable.\n    if (getIsHydrating() && sourceFiber.mode & ConcurrentMode) {\n      const suspenseBoundary = getNearestSuspenseBoundaryToCapture(returnFiber); // If the error was thrown during hydration, we may be able to recover by\n      // discarding the dehydrated content and switching to a client render.\n      // Instead of surfacing the error, find the nearest Suspense boundary\n      // and render it again without hydration.\n\n      if (suspenseBoundary !== null) {\n        if ((suspenseBoundary.flags & ShouldCapture) === NoFlags) {\n          // Set a flag to indicate that we should try rendering the normal\n          // children again, not the fallback.\n          suspenseBoundary.flags |= ForceClientRender;\n        }\n\n        markSuspenseBoundaryShouldCapture(suspenseBoundary, returnFiber, sourceFiber, root, rootRenderLanes); // Even though the user may not be affected by this error, we should\n        // still log it so it can be fixed.\n\n        queueHydrationError(createCapturedValueAtFiber(value, sourceFiber));\n        return;\n      }\n    }\n  }\n\n  value = createCapturedValueAtFiber(value, sourceFiber);\n  renderDidError(value); // We didn't find a boundary that could handle this type of exception. Start\n  // over and traverse parent path again, this time treating the exception\n  // as an error.\n\n  let workInProgress = returnFiber;\n\n  do {\n    switch (workInProgress.tag) {\n      case HostRoot:\n        {\n          const errorInfo = value;\n          workInProgress.flags |= ShouldCapture;\n          const lane = pickArbitraryLane(rootRenderLanes);\n          workInProgress.lanes = mergeLanes(workInProgress.lanes, lane);\n          const update = createRootErrorUpdate(workInProgress, errorInfo, lane);\n          enqueueCapturedUpdate(workInProgress, update);\n          return;\n        }\n\n      case ClassComponent:\n        // Capture and retry\n        const errorInfo = value;\n        const ctor = workInProgress.type;\n        const instance = workInProgress.stateNode;\n\n        if ((workInProgress.flags & DidCapture) === NoFlags && (typeof ctor.getDerivedStateFromError === 'function' || instance !== null && typeof instance.componentDidCatch === 'function' && !isAlreadyFailedLegacyErrorBoundary(instance))) {\n          workInProgress.flags |= ShouldCapture;\n          const lane = pickArbitraryLane(rootRenderLanes);\n          workInProgress.lanes = mergeLanes(workInProgress.lanes, lane); // Schedule the error boundary to re-render using updated state\n\n          const update = createClassErrorUpdate(workInProgress, errorInfo, lane);\n          enqueueCapturedUpdate(workInProgress, update);\n          return;\n        }\n\n        break;\n    }\n\n    workInProgress = workInProgress.return;\n  } while (workInProgress !== null);\n}\n\nfunction getSuspendedCache() {\n  {\n    return null;\n  } // This function is called when a Suspense boundary suspends. It returns the\n}\n\nconst ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner;\nlet didReceiveUpdate = false;\n\nfunction reconcileChildren(current, workInProgress, nextChildren, renderLanes) {\n  if (current === null) {\n    // If this is a fresh new component that hasn't been rendered yet, we\n    // won't update its child set by applying minimal side-effects. Instead,\n    // we will add them all to the child before it gets rendered. That means\n    // we can optimize this reconciliation pass by not tracking side-effects.\n    workInProgress.child = mountChildFibers(workInProgress, null, nextChildren, renderLanes);\n  } else {\n    // If the current child is the same as the work in progress, it means that\n    // we haven't yet started any work on these children. Therefore, we use\n    // the clone algorithm to create a copy of all the current children.\n    // If we had any progressed work already, that is invalid at this point so\n    // let's throw it out.\n    workInProgress.child = reconcileChildFibers(workInProgress, current.child, nextChildren, renderLanes);\n  }\n}\n\nfunction forceUnmountCurrentAndReconcile(current, workInProgress, nextChildren, renderLanes) {\n  // This function is fork of reconcileChildren. It's used in cases where we\n  // want to reconcile without matching against the existing set. This has the\n  // effect of all current children being unmounted; even if the type and key\n  // are the same, the old child is unmounted and a new child is created.\n  //\n  // To do this, we're going to go through the reconcile algorithm twice. In\n  // the first pass, we schedule a deletion for all the current children by\n  // passing null.\n  workInProgress.child = reconcileChildFibers(workInProgress, current.child, null, renderLanes); // In the second pass, we mount the new children. The trick here is that we\n  // pass null in place of where we usually pass the current child set. This has\n  // the effect of remounting all children regardless of whether their\n  // identities match.\n\n  workInProgress.child = reconcileChildFibers(workInProgress, null, nextChildren, renderLanes);\n}\n\nfunction updateForwardRef(current, workInProgress, Component, nextProps, renderLanes) {\n\n  const render = Component.render;\n  const ref = workInProgress.ref; // The rest is a fork of updateFunctionComponent\n\n  let nextChildren;\n  let hasId;\n  prepareToReadContext(workInProgress, renderLanes);\n\n  {\n    nextChildren = renderWithHooks(current, workInProgress, render, nextProps, ref, renderLanes);\n    hasId = checkDidRenderIdHook();\n  }\n\n  if (current !== null && !didReceiveUpdate) {\n    bailoutHooks(current, workInProgress, renderLanes);\n    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);\n  }\n\n  if (getIsHydrating() && hasId) {\n    pushMaterializedTreeId(workInProgress);\n  } // React DevTools reads this flag.\n\n\n  workInProgress.flags |= PerformedWork;\n  reconcileChildren(current, workInProgress, nextChildren, renderLanes);\n  return workInProgress.child;\n}\n\nfunction updateMemoComponent(current, workInProgress, Component, nextProps, renderLanes) {\n  if (current === null) {\n    const type = Component.type;\n\n    if (isSimpleFunctionComponent(type) && Component.compare === null && // SimpleMemoComponent codepath doesn't resolve outer props either.\n    Component.defaultProps === undefined) {\n      let resolvedType = type;\n      // and with only the default shallow comparison, we upgrade it\n      // to a SimpleMemoComponent to allow fast path updates.\n\n\n      workInProgress.tag = SimpleMemoComponent;\n      workInProgress.type = resolvedType;\n\n      return updateSimpleMemoComponent(current, workInProgress, resolvedType, nextProps, renderLanes);\n    }\n\n    const child = createFiberFromTypeAndProps(Component.type, null, nextProps, workInProgress, workInProgress.mode, renderLanes);\n    child.ref = workInProgress.ref;\n    child.return = workInProgress;\n    workInProgress.child = child;\n    return child;\n  }\n\n  const currentChild = current.child; // This is always exactly one child\n\n  const hasScheduledUpdateOrContext = checkScheduledUpdateOrContext(current, renderLanes);\n\n  if (!hasScheduledUpdateOrContext) {\n    // This will be the props with resolved defaultProps,\n    // unlike current.memoizedProps which will be the unresolved ones.\n    const prevProps = currentChild.memoizedProps; // Default to shallow comparison\n\n    let compare = Component.compare;\n    compare = compare !== null ? compare : shallowEqual;\n\n    if (compare(prevProps, nextProps) && current.ref === workInProgress.ref) {\n      return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);\n    }\n  } // React DevTools reads this flag.\n\n\n  workInProgress.flags |= PerformedWork;\n  const newChild = createWorkInProgress(currentChild, nextProps);\n  newChild.ref = workInProgress.ref;\n  newChild.return = workInProgress;\n  workInProgress.child = newChild;\n  return newChild;\n}\n\nfunction updateSimpleMemoComponent(current, workInProgress, Component, nextProps, renderLanes) {\n\n  if (current !== null) {\n    const prevProps = current.memoizedProps;\n\n    if (shallowEqual(prevProps, nextProps) && current.ref === workInProgress.ref && ( // Prevent bailout if the implementation changed due to hot reload.\n     true)) {\n      didReceiveUpdate = false; // The props are shallowly equal. Reuse the previous props object, like we\n      // would during a normal fiber bailout.\n      //\n      // We don't have strong guarantees that the props object is referentially\n      // equal during updates where we can't bail out anyway — like if the props\n      // are shallowly equal, but there's a local state or context update in the\n      // same batch.\n      //\n      // However, as a principle, we should aim to make the behavior consistent\n      // across different ways of memoizing a component. For example, React.memo\n      // has a different internal Fiber layout if you pass a normal function\n      // component (SimpleMemoComponent) versus if you pass a different type\n      // like forwardRef (MemoComponent). But this is an implementation detail.\n      // Wrapping a component in forwardRef (or React.lazy, etc) shouldn't\n      // affect whether the props object is reused during a bailout.\n\n      workInProgress.pendingProps = nextProps = prevProps;\n\n      if (!checkScheduledUpdateOrContext(current, renderLanes)) {\n        // The pending lanes were cleared at the beginning of beginWork. We're\n        // about to bail out, but there might be other lanes that weren't\n        // included in the current render. Usually, the priority level of the\n        // remaining updates is accumulated during the evaluation of the\n        // component (i.e. when processing the update queue). But since since\n        // we're bailing out early *without* evaluating the component, we need\n        // to account for it here, too. Reset to the value of the current fiber.\n        // NOTE: This only applies to SimpleMemoComponent, not MemoComponent,\n        // because a MemoComponent fiber does not have hooks or an update queue;\n        // rather, it wraps around an inner component, which may or may not\n        // contains hooks.\n        // TODO: Move the reset at in beginWork out of the common path so that\n        // this is no longer necessary.\n        workInProgress.lanes = current.lanes;\n        return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);\n      } else if ((current.flags & ForceUpdateForLegacySuspense) !== NoFlags) {\n        // This is a special case that only exists for legacy mode.\n        // See https://github.com/facebook/react/pull/19216.\n        didReceiveUpdate = true;\n      }\n    }\n  }\n\n  return updateFunctionComponent(current, workInProgress, Component, nextProps, renderLanes);\n}\n\nfunction updateOffscreenComponent(current, workInProgress, renderLanes) {\n  const nextProps = workInProgress.pendingProps;\n  const nextChildren = nextProps.children;\n  const prevState = current !== null ? current.memoizedState : null;\n\n  if (nextProps.mode === 'hidden' || enableLegacyHidden ) {\n    // Rendering a hidden tree.\n    if ((workInProgress.mode & ConcurrentMode) === NoMode) {\n      // In legacy sync mode, don't defer the subtree. Render it now.\n      // TODO: Consider how Offscreen should work with transitions in the future\n      const nextState = {\n        baseLanes: NoLanes,\n        cachePool: null,\n        transitions: null\n      };\n      workInProgress.memoizedState = nextState;\n\n      pushRenderLanes(workInProgress, renderLanes);\n    } else if (!includesSomeLane(renderLanes, OffscreenLane)) {\n      let spawnedCachePool = null; // We're hidden, and we're not rendering at Offscreen. We will bail out\n      // and resume this tree later.\n\n      let nextBaseLanes;\n\n      if (prevState !== null) {\n        const prevBaseLanes = prevState.baseLanes;\n        nextBaseLanes = mergeLanes(prevBaseLanes, renderLanes);\n      } else {\n        nextBaseLanes = renderLanes;\n      } // Schedule this fiber to re-render at offscreen priority. Then bailout.\n\n\n      workInProgress.lanes = workInProgress.childLanes = laneToLanes(OffscreenLane);\n      const nextState = {\n        baseLanes: nextBaseLanes,\n        cachePool: spawnedCachePool,\n        transitions: null\n      };\n      workInProgress.memoizedState = nextState;\n      workInProgress.updateQueue = null;\n      // to avoid a push/pop misalignment.\n\n\n      pushRenderLanes(workInProgress, nextBaseLanes);\n\n      return null;\n    } else {\n      // This is the second render. The surrounding visible content has already\n      // committed. Now we resume rendering the hidden tree.\n      // Rendering at offscreen, so we can clear the base lanes.\n      const nextState = {\n        baseLanes: NoLanes,\n        cachePool: null,\n        transitions: null\n      };\n      workInProgress.memoizedState = nextState; // Push the lanes that were skipped when we bailed out.\n\n      const subtreeRenderLanes = prevState !== null ? prevState.baseLanes : renderLanes;\n\n      pushRenderLanes(workInProgress, subtreeRenderLanes);\n    }\n  } else {\n    // Rendering a visible tree.\n    let subtreeRenderLanes;\n\n    if (prevState !== null) {\n      // We're going from hidden -> visible.\n      subtreeRenderLanes = mergeLanes(prevState.baseLanes, renderLanes);\n\n      workInProgress.memoizedState = null;\n    } else {\n      // We weren't previously hidden, and we still aren't, so there's nothing\n      // special to do. Need to push to the stack regardless, though, to avoid\n      // a push/pop misalignment.\n      subtreeRenderLanes = renderLanes;\n    }\n\n    pushRenderLanes(workInProgress, subtreeRenderLanes);\n  }\n\n  reconcileChildren(current, workInProgress, nextChildren, renderLanes);\n  return workInProgress.child;\n} // Note: These happen to have identical begin phases, for now. We shouldn't hold\n\nfunction updateFragment(current, workInProgress, renderLanes) {\n  const nextChildren = workInProgress.pendingProps;\n  reconcileChildren(current, workInProgress, nextChildren, renderLanes);\n  return workInProgress.child;\n}\n\nfunction updateMode(current, workInProgress, renderLanes) {\n  const nextChildren = workInProgress.pendingProps.children;\n  reconcileChildren(current, workInProgress, nextChildren, renderLanes);\n  return workInProgress.child;\n}\n\nfunction updateProfiler(current, workInProgress, renderLanes) {\n\n  const nextProps = workInProgress.pendingProps;\n  const nextChildren = nextProps.children;\n  reconcileChildren(current, workInProgress, nextChildren, renderLanes);\n  return workInProgress.child;\n}\n\nfunction markRef(current, workInProgress) {\n  const ref = workInProgress.ref;\n\n  if (current === null && ref !== null || current !== null && current.ref !== ref) {\n    // Schedule a Ref effect\n    workInProgress.flags |= Ref;\n\n    {\n      workInProgress.flags |= RefStatic;\n    }\n  }\n}\n\nfunction updateFunctionComponent(current, workInProgress, Component, nextProps, renderLanes) {\n\n  let context;\n\n  {\n    const unmaskedContext = getUnmaskedContext(workInProgress, Component, true);\n    context = getMaskedContext(workInProgress, unmaskedContext);\n  }\n\n  let nextChildren;\n  let hasId;\n  prepareToReadContext(workInProgress, renderLanes);\n\n  {\n    nextChildren = renderWithHooks(current, workInProgress, Component, nextProps, context, renderLanes);\n    hasId = checkDidRenderIdHook();\n  }\n\n  if (current !== null && !didReceiveUpdate) {\n    bailoutHooks(current, workInProgress, renderLanes);\n    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);\n  }\n\n  if (getIsHydrating() && hasId) {\n    pushMaterializedTreeId(workInProgress);\n  } // React DevTools reads this flag.\n\n\n  workInProgress.flags |= PerformedWork;\n  reconcileChildren(current, workInProgress, nextChildren, renderLanes);\n  return workInProgress.child;\n}\n\nfunction updateClassComponent(current, workInProgress, Component, nextProps, renderLanes) {\n  // During mounting we don't know the child context yet as the instance doesn't exist.\n  // We will invalidate the child context in finishClassComponent() right after rendering.\n\n\n  let hasContext;\n\n  if (isContextProvider(Component)) {\n    hasContext = true;\n    pushContextProvider(workInProgress);\n  } else {\n    hasContext = false;\n  }\n\n  prepareToReadContext(workInProgress, renderLanes);\n  const instance = workInProgress.stateNode;\n  let shouldUpdate;\n\n  if (instance === null) {\n    resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress); // In the initial pass we might need to construct the instance.\n\n    constructClassInstance(workInProgress, Component, nextProps);\n    mountClassInstance(workInProgress, Component, nextProps, renderLanes);\n    shouldUpdate = true;\n  } else if (current === null) {\n    // In a resume, we'll already have an instance we can reuse.\n    shouldUpdate = resumeMountClassInstance(workInProgress, Component, nextProps, renderLanes);\n  } else {\n    shouldUpdate = updateClassInstance(current, workInProgress, Component, nextProps, renderLanes);\n  }\n\n  const nextUnitOfWork = finishClassComponent(current, workInProgress, Component, shouldUpdate, hasContext, renderLanes);\n\n  return nextUnitOfWork;\n}\n\nfunction finishClassComponent(current, workInProgress, Component, shouldUpdate, hasContext, renderLanes) {\n  // Refs should update even if shouldComponentUpdate returns false\n  markRef(current, workInProgress);\n  const didCaptureError = (workInProgress.flags & DidCapture) !== NoFlags;\n\n  if (!shouldUpdate && !didCaptureError) {\n    // Context providers should defer to sCU for rendering\n    if (hasContext) {\n      invalidateContextProvider(workInProgress, Component, false);\n    }\n\n    return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);\n  }\n\n  const instance = workInProgress.stateNode; // Rerender\n\n  ReactCurrentOwner$1.current = workInProgress;\n  let nextChildren;\n\n  if (didCaptureError && typeof Component.getDerivedStateFromError !== 'function') {\n    // If we captured an error, but getDerivedStateFromError is not defined,\n    // unmount all the children. componentDidCatch will schedule an update to\n    // re-render a fallback. This is temporary until we migrate everyone to\n    // the new API.\n    // TODO: Warn in a future release.\n    nextChildren = null;\n  } else {\n\n    {\n      nextChildren = instance.render();\n    }\n  } // React DevTools reads this flag.\n\n\n  workInProgress.flags |= PerformedWork;\n\n  if (current !== null && didCaptureError) {\n    // If we're recovering from an error, reconcile without reusing any of\n    // the existing children. Conceptually, the normal children and the children\n    // that are shown on error are two different sets, so we shouldn't reuse\n    // normal children even if their identities match.\n    forceUnmountCurrentAndReconcile(current, workInProgress, nextChildren, renderLanes);\n  } else {\n    reconcileChildren(current, workInProgress, nextChildren, renderLanes);\n  } // Memoize state using the values we just used to render.\n  // TODO: Restructure so we never read values from the instance.\n\n\n  workInProgress.memoizedState = instance.state; // The context might have changed so we need to recalculate it.\n\n  if (hasContext) {\n    invalidateContextProvider(workInProgress, Component, true);\n  }\n\n  return workInProgress.child;\n}\n\nfunction pushHostRootContext(workInProgress) {\n  const root = workInProgress.stateNode;\n\n  if (root.pendingContext) {\n    pushTopLevelContextObject(workInProgress, root.pendingContext, root.pendingContext !== root.context);\n  } else if (root.context) {\n    // Should always be set\n    pushTopLevelContextObject(workInProgress, root.context, false);\n  }\n\n  pushHostContainer(workInProgress, root.containerInfo);\n}\n\nfunction updateHostRoot(current, workInProgress, renderLanes) {\n  pushHostRootContext(workInProgress);\n\n  if (current === null) {\n    throw Error(formatProdErrorMessage(387));\n  }\n\n  const nextProps = workInProgress.pendingProps;\n  const prevState = workInProgress.memoizedState;\n  const prevChildren = prevState.element;\n  cloneUpdateQueue(current, workInProgress);\n  processUpdateQueue(workInProgress, nextProps, null, renderLanes);\n  const nextState = workInProgress.memoizedState;\n  const root = workInProgress.stateNode;\n  // being called \"element\".\n\n\n  const nextChildren = nextState.element;\n\n  if ( prevState.isDehydrated) {\n    // This is a hydration root whose shell has not yet hydrated. We should\n    // attempt to hydrate.\n    // Flip isDehydrated to false to indicate that when this render\n    // finishes, the root will no longer be dehydrated.\n    const overrideState = {\n      element: nextChildren,\n      isDehydrated: false,\n      cache: nextState.cache,\n      pendingSuspenseBoundaries: nextState.pendingSuspenseBoundaries,\n      transitions: nextState.transitions\n    };\n    const updateQueue = workInProgress.updateQueue; // `baseState` can always be the last state because the root doesn't\n    // have reducer functions so it doesn't need rebasing.\n\n    updateQueue.baseState = overrideState;\n    workInProgress.memoizedState = overrideState;\n\n    if (workInProgress.flags & ForceClientRender) {\n      // Something errored during a previous attempt to hydrate the shell, so we\n      // forced a client render.\n      const recoverableError = createCapturedValueAtFiber(Error(formatProdErrorMessage(423)), workInProgress);\n      return mountHostRootWithoutHydrating(current, workInProgress, nextChildren, renderLanes, recoverableError);\n    } else if (nextChildren !== prevChildren) {\n      const recoverableError = createCapturedValueAtFiber(Error(formatProdErrorMessage(424)), workInProgress);\n      return mountHostRootWithoutHydrating(current, workInProgress, nextChildren, renderLanes, recoverableError);\n    } else {\n      // The outermost shell has not hydrated yet. Start hydrating.\n      enterHydrationState(workInProgress);\n\n      const child = mountChildFibers(workInProgress, null, nextChildren, renderLanes);\n      workInProgress.child = child;\n      let node = child;\n\n      while (node) {\n        // Mark each child as hydrating. This is a fast path to know whether this\n        // tree is part of a hydrating tree. This is used to determine if a child\n        // node has fully mounted yet, and for scheduling event replaying.\n        // Conceptually this is similar to Placement in that a new subtree is\n        // inserted into the React tree here. It just happens to not need DOM\n        // mutations because it already exists.\n        node.flags = node.flags & ~Placement | Hydrating;\n        node = node.sibling;\n      }\n    }\n  } else {\n    // Root is not dehydrated. Either this is a client-only root, or it\n    // already hydrated.\n    resetHydrationState();\n\n    if (nextChildren === prevChildren) {\n      return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);\n    }\n\n    reconcileChildren(current, workInProgress, nextChildren, renderLanes);\n  }\n\n  return workInProgress.child;\n}\n\nfunction mountHostRootWithoutHydrating(current, workInProgress, nextChildren, renderLanes, recoverableError) {\n  // Revert to client rendering.\n  resetHydrationState();\n  queueHydrationError(recoverableError);\n  workInProgress.flags |= ForceClientRender;\n  reconcileChildren(current, workInProgress, nextChildren, renderLanes);\n  return workInProgress.child;\n}\n\nfunction updateHostComponent(current, workInProgress, renderLanes) {\n  pushHostContext(workInProgress);\n\n  if (current === null) {\n    tryToClaimNextHydratableInstance(workInProgress);\n  }\n\n  const type = workInProgress.type;\n  const nextProps = workInProgress.pendingProps;\n  const prevProps = current !== null ? current.memoizedProps : null;\n  let nextChildren = nextProps.children;\n  const isDirectTextChild = shouldSetTextContent(type, nextProps);\n\n  if (isDirectTextChild) {\n    // We special case a direct text child of a host node. This is a common\n    // case. We won't handle it as a reified child. We will instead handle\n    // this in the host environment that also has access to this prop. That\n    // avoids allocating another HostText fiber and traversing it.\n    nextChildren = null;\n  } else if (prevProps !== null && shouldSetTextContent(type, prevProps)) {\n    // If we're switching from a direct text child to a normal child, or to\n    // empty, we need to schedule the text content to be reset.\n    workInProgress.flags |= ContentReset;\n  }\n\n  markRef(current, workInProgress);\n  reconcileChildren(current, workInProgress, nextChildren, renderLanes);\n  return workInProgress.child;\n}\n\nfunction updateHostText(current, workInProgress) {\n  if (current === null) {\n    tryToClaimNextHydratableInstance(workInProgress);\n  } // Nothing to do here. This is terminal. We'll do the completion step\n  // immediately after.\n\n\n  return null;\n}\n\nfunction mountLazyComponent(_current, workInProgress, elementType, renderLanes) {\n  resetSuspendedCurrentOnMountInLegacyMode(_current, workInProgress);\n  const props = workInProgress.pendingProps;\n  const lazyComponent = elementType;\n  const payload = lazyComponent._payload;\n  const init = lazyComponent._init;\n  let Component = init(payload); // Store the unwrapped component in the type.\n\n  workInProgress.type = Component;\n  const resolvedTag = workInProgress.tag = resolveLazyComponentTag(Component);\n  const resolvedProps = resolveDefaultProps(Component, props);\n  let child;\n\n  switch (resolvedTag) {\n    case FunctionComponent:\n      {\n\n        child = updateFunctionComponent(null, workInProgress, Component, resolvedProps, renderLanes);\n        return child;\n      }\n\n    case ClassComponent:\n      {\n\n        child = updateClassComponent(null, workInProgress, Component, resolvedProps, renderLanes);\n        return child;\n      }\n\n    case ForwardRef:\n      {\n\n        child = updateForwardRef(null, workInProgress, Component, resolvedProps, renderLanes);\n        return child;\n      }\n\n    case MemoComponent:\n      {\n\n        child = updateMemoComponent(null, workInProgress, Component, resolveDefaultProps(Component.type, resolvedProps), // The inner type can have defaults too\n        renderLanes);\n        return child;\n      }\n  }\n\n  let hint = '';\n  // because the fact that it's a separate type of work is an\n  // implementation detail.\n\n\n  throw Error(formatProdErrorMessage(306, Component, hint));\n}\n\nfunction mountIncompleteClassComponent(_current, workInProgress, Component, nextProps, renderLanes) {\n  resetSuspendedCurrentOnMountInLegacyMode(_current, workInProgress); // Promote the fiber to a class and try rendering again.\n\n  workInProgress.tag = ClassComponent; // The rest of this function is a fork of `updateClassComponent`\n  // Push context providers early to prevent context stack mismatches.\n  // During mounting we don't know the child context yet as the instance doesn't exist.\n  // We will invalidate the child context in finishClassComponent() right after rendering.\n\n  let hasContext;\n\n  if (isContextProvider(Component)) {\n    hasContext = true;\n    pushContextProvider(workInProgress);\n  } else {\n    hasContext = false;\n  }\n\n  prepareToReadContext(workInProgress, renderLanes);\n  constructClassInstance(workInProgress, Component, nextProps);\n  mountClassInstance(workInProgress, Component, nextProps, renderLanes);\n  return finishClassComponent(null, workInProgress, Component, true, hasContext, renderLanes);\n}\n\nfunction mountIndeterminateComponent(_current, workInProgress, Component, renderLanes) {\n  resetSuspendedCurrentOnMountInLegacyMode(_current, workInProgress);\n  const props = workInProgress.pendingProps;\n  let context;\n\n  {\n    const unmaskedContext = getUnmaskedContext(workInProgress, Component, false);\n    context = getMaskedContext(workInProgress, unmaskedContext);\n  }\n\n  prepareToReadContext(workInProgress, renderLanes);\n  let value;\n  let hasId;\n\n  {\n    value = renderWithHooks(null, workInProgress, Component, props, context, renderLanes);\n    hasId = checkDidRenderIdHook();\n  }\n\n\n  workInProgress.flags |= PerformedWork;\n\n  if ( // Run these checks in production only if the flag is off.\n  // Eventually we'll delete this branch altogether.\n   typeof value === 'object' && value !== null && typeof value.render === 'function' && value.$$typeof === undefined) {\n\n\n    workInProgress.tag = ClassComponent; // Throw out any hooks that were used.\n\n    workInProgress.memoizedState = null;\n    workInProgress.updateQueue = null; // Push context providers early to prevent context stack mismatches.\n    // During mounting we don't know the child context yet as the instance doesn't exist.\n    // We will invalidate the child context in finishClassComponent() right after rendering.\n\n    let hasContext = false;\n\n    if (isContextProvider(Component)) {\n      hasContext = true;\n      pushContextProvider(workInProgress);\n    } else {\n      hasContext = false;\n    }\n\n    workInProgress.memoizedState = value.state !== null && value.state !== undefined ? value.state : null;\n    initializeUpdateQueue(workInProgress);\n    adoptClassInstance(workInProgress, value);\n    mountClassInstance(workInProgress, Component, props, renderLanes);\n    return finishClassComponent(null, workInProgress, Component, true, hasContext, renderLanes);\n  } else {\n    // Proceed under the assumption that this is a function component\n    workInProgress.tag = FunctionComponent;\n\n    if (getIsHydrating() && hasId) {\n      pushMaterializedTreeId(workInProgress);\n    }\n\n    reconcileChildren(null, workInProgress, value, renderLanes);\n\n    return workInProgress.child;\n  }\n}\n\nconst SUSPENDED_MARKER = {\n  dehydrated: null,\n  treeContext: null,\n  retryLane: NoLane\n};\n\nfunction mountSuspenseOffscreenState(renderLanes) {\n  return {\n    baseLanes: renderLanes,\n    cachePool: getSuspendedCache(),\n    transitions: null\n  };\n}\n\nfunction updateSuspenseOffscreenState(prevOffscreenState, renderLanes) {\n  let cachePool = null;\n\n  return {\n    baseLanes: mergeLanes(prevOffscreenState.baseLanes, renderLanes),\n    cachePool,\n    transitions: prevOffscreenState.transitions\n  };\n} // TODO: Probably should inline this back\n\n\nfunction shouldRemainOnFallback(suspenseContext, current, workInProgress, renderLanes) {\n  // If we're already showing a fallback, there are cases where we need to\n  // remain on that fallback regardless of whether the content has resolved.\n  // For example, SuspenseList coordinates when nested content appears.\n  if (current !== null) {\n    const suspenseState = current.memoizedState;\n\n    if (suspenseState === null) {\n      // Currently showing content. Don't hide it, even if ForceSuspenseFallback\n      // is true. More precise name might be \"ForceRemainSuspenseFallback\".\n      // Note: This is a factoring smell. Can't remain on a fallback if there's\n      // no fallback to remain on.\n      return false;\n    }\n  } // Not currently showing content. Consult the Suspense context.\n\n\n  return hasSuspenseContext(suspenseContext, ForceSuspenseFallback);\n}\n\nfunction getRemainingWorkInPrimaryTree(current, renderLanes) {\n  // TODO: Should not remove render lanes that were pinged during this render\n  return removeLanes(current.childLanes, renderLanes);\n}\n\nfunction updateSuspenseComponent(current, workInProgress, renderLanes) {\n  const nextProps = workInProgress.pendingProps; // This is used by DevTools to force a boundary to suspend.\n\n  let suspenseContext = suspenseStackCursor.current;\n  let showFallback = false;\n  const didSuspend = (workInProgress.flags & DidCapture) !== NoFlags;\n\n  if (didSuspend || shouldRemainOnFallback(suspenseContext, current)) {\n    // Something in this boundary's subtree already suspended. Switch to\n    // rendering the fallback children.\n    showFallback = true;\n    workInProgress.flags &= ~DidCapture;\n  } else {\n    // Attempting the main content\n    if (current === null || current.memoizedState !== null) {\n      // This is a new mount or this boundary is already showing a fallback state.\n      // Mark this subtree context as having at least one invisible parent that could\n      // handle the fallback state.\n      // Avoided boundaries are not considered since they cannot handle preferred fallback states.\n      {\n        suspenseContext = addSubtreeSuspenseContext(suspenseContext, InvisibleParentSuspenseContext);\n      }\n    }\n  }\n\n  suspenseContext = setDefaultShallowSuspenseContext(suspenseContext);\n  pushSuspenseContext(workInProgress, suspenseContext); // OK, the next part is confusing. We're about to reconcile the Suspense\n  // boundary's children. This involves some custom reconciliation logic. Two\n  // main reasons this is so complicated.\n  //\n  // First, Legacy Mode has different semantics for backwards compatibility. The\n  // primary tree will commit in an inconsistent state, so when we do the\n  // second pass to render the fallback, we do some exceedingly, uh, clever\n  // hacks to make that not totally break. Like transferring effects and\n  // deletions from hidden tree. In Concurrent Mode, it's much simpler,\n  // because we bailout on the primary tree completely and leave it in its old\n  // state, no effects. Same as what we do for Offscreen (except that\n  // Offscreen doesn't have the first render pass).\n  //\n  // Second is hydration. During hydration, the Suspense fiber has a slightly\n  // different layout, where the child points to a dehydrated fragment, which\n  // contains the DOM rendered by the server.\n  //\n  // Third, even if you set all that aside, Suspense is like error boundaries in\n  // that we first we try to render one tree, and if that fails, we render again\n  // and switch to a different tree. Like a try/catch block. So we have to track\n  // which branch we're currently rendering. Ideally we would model this using\n  // a stack.\n\n  if (current === null) {\n    // Initial mount\n    // Special path for hydration\n    // If we're currently hydrating, try to hydrate this boundary.\n    tryToClaimNextHydratableInstance(workInProgress); // This could've been a dehydrated suspense component.\n\n    const suspenseState = workInProgress.memoizedState;\n\n    if (suspenseState !== null) {\n      const dehydrated = suspenseState.dehydrated;\n\n      if (dehydrated !== null) {\n        return mountDehydratedSuspenseComponent(workInProgress, dehydrated);\n      }\n    }\n\n    const nextPrimaryChildren = nextProps.children;\n    const nextFallbackChildren = nextProps.fallback;\n\n    if (showFallback) {\n      const fallbackFragment = mountSuspenseFallbackChildren(workInProgress, nextPrimaryChildren, nextFallbackChildren, renderLanes);\n      const primaryChildFragment = workInProgress.child;\n      primaryChildFragment.memoizedState = mountSuspenseOffscreenState(renderLanes);\n      workInProgress.memoizedState = SUSPENDED_MARKER;\n\n      return fallbackFragment;\n    } else {\n      return mountSuspensePrimaryChildren(workInProgress, nextPrimaryChildren);\n    }\n  } else {\n    // This is an update.\n    // Special path for hydration\n    const prevState = current.memoizedState;\n\n    if (prevState !== null) {\n      const dehydrated = prevState.dehydrated;\n\n      if (dehydrated !== null) {\n        return updateDehydratedSuspenseComponent(current, workInProgress, didSuspend, nextProps, dehydrated, prevState, renderLanes);\n      }\n    }\n\n    if (showFallback) {\n      const nextFallbackChildren = nextProps.fallback;\n      const nextPrimaryChildren = nextProps.children;\n      const fallbackChildFragment = updateSuspenseFallbackChildren(current, workInProgress, nextPrimaryChildren, nextFallbackChildren, renderLanes);\n      const primaryChildFragment = workInProgress.child;\n      const prevOffscreenState = current.child.memoizedState;\n      primaryChildFragment.memoizedState = prevOffscreenState === null ? mountSuspenseOffscreenState(renderLanes) : updateSuspenseOffscreenState(prevOffscreenState, renderLanes);\n\n      primaryChildFragment.childLanes = getRemainingWorkInPrimaryTree(current, renderLanes);\n      workInProgress.memoizedState = SUSPENDED_MARKER;\n      return fallbackChildFragment;\n    } else {\n      const nextPrimaryChildren = nextProps.children;\n      const primaryChildFragment = updateSuspensePrimaryChildren(current, workInProgress, nextPrimaryChildren, renderLanes);\n      workInProgress.memoizedState = null;\n      return primaryChildFragment;\n    }\n  }\n}\n\nfunction mountSuspensePrimaryChildren(workInProgress, primaryChildren, renderLanes) {\n  const mode = workInProgress.mode;\n  const primaryChildProps = {\n    mode: 'visible',\n    children: primaryChildren\n  };\n  const primaryChildFragment = mountWorkInProgressOffscreenFiber(primaryChildProps, mode);\n  primaryChildFragment.return = workInProgress;\n  workInProgress.child = primaryChildFragment;\n  return primaryChildFragment;\n}\n\nfunction mountSuspenseFallbackChildren(workInProgress, primaryChildren, fallbackChildren, renderLanes) {\n  const mode = workInProgress.mode;\n  const progressedPrimaryFragment = workInProgress.child;\n  const primaryChildProps = {\n    mode: 'hidden',\n    children: primaryChildren\n  };\n  let primaryChildFragment;\n  let fallbackChildFragment;\n\n  if ((mode & ConcurrentMode) === NoMode && progressedPrimaryFragment !== null) {\n    // In legacy mode, we commit the primary tree as if it successfully\n    // completed, even though it's in an inconsistent state.\n    primaryChildFragment = progressedPrimaryFragment;\n    primaryChildFragment.childLanes = NoLanes;\n    primaryChildFragment.pendingProps = primaryChildProps;\n\n    fallbackChildFragment = createFiberFromFragment(fallbackChildren, mode, renderLanes, null);\n  } else {\n    primaryChildFragment = mountWorkInProgressOffscreenFiber(primaryChildProps, mode);\n    fallbackChildFragment = createFiberFromFragment(fallbackChildren, mode, renderLanes, null);\n  }\n\n  primaryChildFragment.return = workInProgress;\n  fallbackChildFragment.return = workInProgress;\n  primaryChildFragment.sibling = fallbackChildFragment;\n  workInProgress.child = primaryChildFragment;\n  return fallbackChildFragment;\n}\n\nfunction mountWorkInProgressOffscreenFiber(offscreenProps, mode, renderLanes) {\n  // The props argument to `createFiberFromOffscreen` is `any` typed, so we use\n  // this wrapper function to constrain it.\n  return createFiberFromOffscreen(offscreenProps, mode, NoLanes, null);\n}\n\nfunction updateWorkInProgressOffscreenFiber(current, offscreenProps) {\n  // The props argument to `createWorkInProgress` is `any` typed, so we use this\n  // wrapper function to constrain it.\n  return createWorkInProgress(current, offscreenProps);\n}\n\nfunction updateSuspensePrimaryChildren(current, workInProgress, primaryChildren, renderLanes) {\n  const currentPrimaryChildFragment = current.child;\n  const currentFallbackChildFragment = currentPrimaryChildFragment.sibling;\n  const primaryChildFragment = updateWorkInProgressOffscreenFiber(currentPrimaryChildFragment, {\n    mode: 'visible',\n    children: primaryChildren\n  });\n\n  if ((workInProgress.mode & ConcurrentMode) === NoMode) {\n    primaryChildFragment.lanes = renderLanes;\n  }\n\n  primaryChildFragment.return = workInProgress;\n  primaryChildFragment.sibling = null;\n\n  if (currentFallbackChildFragment !== null) {\n    // Delete the fallback child fragment\n    const deletions = workInProgress.deletions;\n\n    if (deletions === null) {\n      workInProgress.deletions = [currentFallbackChildFragment];\n      workInProgress.flags |= ChildDeletion;\n    } else {\n      deletions.push(currentFallbackChildFragment);\n    }\n  }\n\n  workInProgress.child = primaryChildFragment;\n  return primaryChildFragment;\n}\n\nfunction updateSuspenseFallbackChildren(current, workInProgress, primaryChildren, fallbackChildren, renderLanes) {\n  const mode = workInProgress.mode;\n  const currentPrimaryChildFragment = current.child;\n  const currentFallbackChildFragment = currentPrimaryChildFragment.sibling;\n  const primaryChildProps = {\n    mode: 'hidden',\n    children: primaryChildren\n  };\n  let primaryChildFragment;\n\n  if ( // In legacy mode, we commit the primary tree as if it successfully\n  // completed, even though it's in an inconsistent state.\n  (mode & ConcurrentMode) === NoMode && // Make sure we're on the second pass, i.e. the primary child fragment was\n  // already cloned. In legacy mode, the only case where this isn't true is\n  // when DevTools forces us to display a fallback; we skip the first render\n  // pass entirely and go straight to rendering the fallback. (In Concurrent\n  // Mode, SuspenseList can also trigger this scenario, but this is a legacy-\n  // only codepath.)\n  workInProgress.child !== currentPrimaryChildFragment) {\n    const progressedPrimaryFragment = workInProgress.child;\n    primaryChildFragment = progressedPrimaryFragment;\n    primaryChildFragment.childLanes = NoLanes;\n    primaryChildFragment.pendingProps = primaryChildProps;\n    // However, since we're going to remain on the fallback, we no longer want\n    // to delete it.\n\n\n    workInProgress.deletions = null;\n  } else {\n    primaryChildFragment = updateWorkInProgressOffscreenFiber(currentPrimaryChildFragment, primaryChildProps); // Since we're reusing a current tree, we need to reuse the flags, too.\n    // (We don't do this in legacy mode, because in legacy mode we don't re-use\n    // the current tree; see previous branch.)\n\n    primaryChildFragment.subtreeFlags = currentPrimaryChildFragment.subtreeFlags & StaticMask;\n  }\n\n  let fallbackChildFragment;\n\n  if (currentFallbackChildFragment !== null) {\n    fallbackChildFragment = createWorkInProgress(currentFallbackChildFragment, fallbackChildren);\n  } else {\n    fallbackChildFragment = createFiberFromFragment(fallbackChildren, mode, renderLanes, null); // Needs a placement effect because the parent (the Suspense boundary) already\n    // mounted but this is a new fiber.\n\n    fallbackChildFragment.flags |= Placement;\n  }\n\n  fallbackChildFragment.return = workInProgress;\n  primaryChildFragment.return = workInProgress;\n  primaryChildFragment.sibling = fallbackChildFragment;\n  workInProgress.child = primaryChildFragment;\n  return fallbackChildFragment;\n}\n\nfunction retrySuspenseComponentWithoutHydrating(current, workInProgress, renderLanes, recoverableError) {\n  // Falling back to client rendering. Because this has performance\n  // implications, it's considered a recoverable error, even though the user\n  // likely won't observe anything wrong with the UI.\n  //\n  // The error is passed in as an argument to enforce that every caller provide\n  // a custom message, or explicitly opt out (currently the only path that opts\n  // out is legacy mode; every concurrent path provides an error).\n  if (recoverableError !== null) {\n    queueHydrationError(recoverableError);\n  } // This will add the old fiber to the deletion list\n\n\n  reconcileChildFibers(workInProgress, current.child, null, renderLanes); // We're now not suspended nor dehydrated.\n\n  const nextProps = workInProgress.pendingProps;\n  const primaryChildren = nextProps.children;\n  const primaryChildFragment = mountSuspensePrimaryChildren(workInProgress, primaryChildren); // Needs a placement effect because the parent (the Suspense boundary) already\n  // mounted but this is a new fiber.\n\n  primaryChildFragment.flags |= Placement;\n  workInProgress.memoizedState = null;\n  return primaryChildFragment;\n}\n\nfunction mountSuspenseFallbackAfterRetryWithoutHydrating(current, workInProgress, primaryChildren, fallbackChildren, renderLanes) {\n  const fiberMode = workInProgress.mode;\n  const primaryChildProps = {\n    mode: 'visible',\n    children: primaryChildren\n  };\n  const primaryChildFragment = mountWorkInProgressOffscreenFiber(primaryChildProps, fiberMode);\n  const fallbackChildFragment = createFiberFromFragment(fallbackChildren, fiberMode, renderLanes, null); // Needs a placement effect because the parent (the Suspense\n  // boundary) already mounted but this is a new fiber.\n\n  fallbackChildFragment.flags |= Placement;\n  primaryChildFragment.return = workInProgress;\n  fallbackChildFragment.return = workInProgress;\n  primaryChildFragment.sibling = fallbackChildFragment;\n  workInProgress.child = primaryChildFragment;\n\n  if ((workInProgress.mode & ConcurrentMode) !== NoMode) {\n    // We will have dropped the effect list which contains the\n    // deletion. We need to reconcile to delete the current child.\n    reconcileChildFibers(workInProgress, current.child, null, renderLanes);\n  }\n\n  return fallbackChildFragment;\n}\n\nfunction mountDehydratedSuspenseComponent(workInProgress, suspenseInstance, renderLanes) {\n  // During the first pass, we'll bail out and not drill into the children.\n  // Instead, we'll leave the content in place and try to hydrate it later.\n  if ((workInProgress.mode & ConcurrentMode) === NoMode) {\n\n    workInProgress.lanes = laneToLanes(SyncLane);\n  } else if (isSuspenseInstanceFallback(suspenseInstance)) {\n    // This is a client-only boundary. Since we won't get any content from the server\n    // for this, we need to schedule that at a higher priority based on when it would\n    // have timed out. In theory we could render it in this pass but it would have the\n    // wrong priority associated with it and will prevent hydration of parent path.\n    // Instead, we'll leave work left on it to render it in a separate commit.\n    // TODO This time should be the time at which the server rendered response that is\n    // a parent to this boundary was displayed. However, since we currently don't have\n    // a protocol to transfer that time, we'll just estimate it by using the current\n    // time. This will mean that Suspense timeouts are slightly shifted to later than\n    // they should be.\n    // Schedule a normal pri update to render this content.\n    workInProgress.lanes = laneToLanes(DefaultHydrationLane);\n  } else {\n    // We'll continue hydrating the rest at offscreen priority since we'll already\n    // be showing the right content coming from the server, it is no rush.\n    workInProgress.lanes = laneToLanes(OffscreenLane);\n  }\n\n  return null;\n}\n\nfunction updateDehydratedSuspenseComponent(current, workInProgress, didSuspend, nextProps, suspenseInstance, suspenseState, renderLanes) {\n  if (!didSuspend) {\n\n    if ((workInProgress.mode & ConcurrentMode) === NoMode) {\n      return retrySuspenseComponentWithoutHydrating(current, workInProgress, renderLanes, // TODO: When we delete legacy mode, we should make this error argument\n      // required — every concurrent mode path that causes hydration to\n      // de-opt to client rendering should have an error message.\n      null);\n    }\n\n    if (isSuspenseInstanceFallback(suspenseInstance)) {\n      // This boundary is in a permanent fallback state. In this case, we'll never\n      // get an update and we'll never be able to hydrate the final content. Let's just try the\n      // client side render instead.\n      let digest, stack;\n\n      {\n        var _getSuspenseInstanceF2 = getSuspenseInstanceFallbackErrorDetails(suspenseInstance);\n\n        digest = _getSuspenseInstanceF2.digest;\n      }\n\n      let error;\n\n      {\n        error = Error(formatProdErrorMessage(419));\n      }\n\n      const capturedValue = createCapturedValue(error, digest, stack);\n      return retrySuspenseComponentWithoutHydrating(current, workInProgress, renderLanes, capturedValue);\n    }\n    // any context has changed, we need to treat is as if the input might have changed.\n\n\n    const hasContextChanged = includesSomeLane(renderLanes, current.childLanes);\n\n    if (didReceiveUpdate || hasContextChanged) {\n      // This boundary has changed since the first render. This means that we are now unable to\n      // hydrate it. We might still be able to hydrate it using a higher priority lane.\n      const root = getWorkInProgressRoot();\n\n      if (root !== null) {\n        const attemptHydrationAtLane = getBumpedLaneForHydration(root, renderLanes);\n\n        if (attemptHydrationAtLane !== NoLane && attemptHydrationAtLane !== suspenseState.retryLane) {\n          // Intentionally mutating since this render will get interrupted. This\n          // is one of the very rare times where we mutate the current tree\n          // during the render phase.\n          suspenseState.retryLane = attemptHydrationAtLane; // TODO: Ideally this would inherit the event time of the current render\n\n          const eventTime = NoTimestamp;\n          enqueueConcurrentRenderForLane(current, attemptHydrationAtLane);\n          scheduleUpdateOnFiber(root, current, attemptHydrationAtLane, eventTime);\n        }\n      } // If we have scheduled higher pri work above, this will probably just abort the render\n      // since we now have higher priority work, but in case it doesn't, we need to prepare to\n      // render something, if we time out. Even if that requires us to delete everything and\n      // skip hydration.\n      // Delay having to do this as long as the suspense timeout allows us.\n\n\n      renderDidSuspendDelayIfPossible();\n      const capturedValue = createCapturedValue(Error(formatProdErrorMessage(421)));\n      return retrySuspenseComponentWithoutHydrating(current, workInProgress, renderLanes, capturedValue);\n    } else if (isSuspenseInstancePending(suspenseInstance)) {\n      // This component is still pending more data from the server, so we can't hydrate its\n      // content. We treat it as if this component suspended itself. It might seem as if\n      // we could just try to render it client-side instead. However, this will perform a\n      // lot of unnecessary work and is unlikely to complete since it often will suspend\n      // on missing data anyway. Additionally, the server might be able to render more\n      // than we can on the client yet. In that case we'd end up with more fallback states\n      // on the client than if we just leave it alone. If the server times out or errors\n      // these should update this boundary to the permanent Fallback state instead.\n      // Mark it as having captured (i.e. suspended).\n      workInProgress.flags |= DidCapture; // Leave the child in place. I.e. the dehydrated fragment.\n\n      workInProgress.child = current.child; // Register a callback to retry this boundary once the server has sent the result.\n\n      const retry = retryDehydratedSuspenseBoundary.bind(null, current);\n      registerSuspenseInstanceRetry(suspenseInstance, retry);\n      return null;\n    } else {\n      // This is the first attempt.\n      reenterHydrationStateFromDehydratedSuspenseInstance(workInProgress, suspenseInstance, suspenseState.treeContext);\n      const primaryChildren = nextProps.children;\n      const primaryChildFragment = mountSuspensePrimaryChildren(workInProgress, primaryChildren); // Mark the children as hydrating. This is a fast path to know whether this\n      // tree is part of a hydrating tree. This is used to determine if a child\n      // node has fully mounted yet, and for scheduling event replaying.\n      // Conceptually this is similar to Placement in that a new subtree is\n      // inserted into the React tree here. It just happens to not need DOM\n      // mutations because it already exists.\n\n      primaryChildFragment.flags |= Hydrating;\n      return primaryChildFragment;\n    }\n  } else {\n    // This is the second render pass. We already attempted to hydrated, but\n    // something either suspended or errored.\n    if (workInProgress.flags & ForceClientRender) {\n      // Something errored during hydration. Try again without hydrating.\n      workInProgress.flags &= ~ForceClientRender;\n      const capturedValue = createCapturedValue(Error(formatProdErrorMessage(422)));\n      return retrySuspenseComponentWithoutHydrating(current, workInProgress, renderLanes, capturedValue);\n    } else if (workInProgress.memoizedState !== null) {\n      // Something suspended and we should still be in dehydrated mode.\n      // Leave the existing child in place.\n      workInProgress.child = current.child; // The dehydrated completion pass expects this flag to be there\n      // but the normal suspense pass doesn't.\n\n      workInProgress.flags |= DidCapture;\n      return null;\n    } else {\n      // Suspended but we should no longer be in dehydrated mode.\n      // Therefore we now have to render the fallback.\n      const nextPrimaryChildren = nextProps.children;\n      const nextFallbackChildren = nextProps.fallback;\n      const fallbackChildFragment = mountSuspenseFallbackAfterRetryWithoutHydrating(current, workInProgress, nextPrimaryChildren, nextFallbackChildren, renderLanes);\n      const primaryChildFragment = workInProgress.child;\n      primaryChildFragment.memoizedState = mountSuspenseOffscreenState(renderLanes);\n      workInProgress.memoizedState = SUSPENDED_MARKER;\n      return fallbackChildFragment;\n    }\n  }\n}\n\nfunction scheduleSuspenseWorkOnFiber(fiber, renderLanes, propagationRoot) {\n  fiber.lanes = mergeLanes(fiber.lanes, renderLanes);\n  const alternate = fiber.alternate;\n\n  if (alternate !== null) {\n    alternate.lanes = mergeLanes(alternate.lanes, renderLanes);\n  }\n\n  scheduleContextWorkOnParentPath(fiber.return, renderLanes, propagationRoot);\n}\n\nfunction propagateSuspenseContextChange(workInProgress, firstChild, renderLanes) {\n  // Mark any Suspense boundaries with fallbacks as having work to do.\n  // If they were previously forced into fallbacks, they may now be able\n  // to unblock.\n  let node = firstChild;\n\n  while (node !== null) {\n    if (node.tag === SuspenseComponent) {\n      const state = node.memoizedState;\n\n      if (state !== null) {\n        scheduleSuspenseWorkOnFiber(node, renderLanes, workInProgress);\n      }\n    } else if (node.tag === SuspenseListComponent) {\n      // If the tail is hidden there might not be an Suspense boundaries\n      // to schedule work on. In this case we have to schedule it on the\n      // list itself.\n      // We don't have to traverse to the children of the list since\n      // the list will propagate the change when it rerenders.\n      scheduleSuspenseWorkOnFiber(node, renderLanes, workInProgress);\n    } else if (node.child !== null) {\n      node.child.return = node;\n      node = node.child;\n      continue;\n    }\n\n    if (node === workInProgress) {\n      return;\n    }\n\n    while (node.sibling === null) {\n      if (node.return === null || node.return === workInProgress) {\n        return;\n      }\n\n      node = node.return;\n    }\n\n    node.sibling.return = node.return;\n    node = node.sibling;\n  }\n}\n\nfunction findLastContentRow(firstChild) {\n  // This is going to find the last row among these children that is already\n  // showing content on the screen, as opposed to being in fallback state or\n  // new. If a row has multiple Suspense boundaries, any of them being in the\n  // fallback state, counts as the whole row being in a fallback state.\n  // Note that the \"rows\" will be workInProgress, but any nested children\n  // will still be current since we haven't rendered them yet. The mounted\n  // order may not be the same as the new order. We use the new order.\n  let row = firstChild;\n  let lastContentRow = null;\n\n  while (row !== null) {\n    const currentRow = row.alternate; // New rows can't be content rows.\n\n    if (currentRow !== null && findFirstSuspended(currentRow) === null) {\n      lastContentRow = row;\n    }\n\n    row = row.sibling;\n  }\n\n  return lastContentRow;\n}\n\nfunction initSuspenseListRenderState(workInProgress, isBackwards, tail, lastContentRow, tailMode) {\n  const renderState = workInProgress.memoizedState;\n\n  if (renderState === null) {\n    workInProgress.memoizedState = {\n      isBackwards: isBackwards,\n      rendering: null,\n      renderingStartTime: 0,\n      last: lastContentRow,\n      tail: tail,\n      tailMode: tailMode\n    };\n  } else {\n    // We can reuse the existing object from previous renders.\n    renderState.isBackwards = isBackwards;\n    renderState.rendering = null;\n    renderState.renderingStartTime = 0;\n    renderState.last = lastContentRow;\n    renderState.tail = tail;\n    renderState.tailMode = tailMode;\n  }\n} // This can end up rendering this component multiple passes.\n// The first pass splits the children fibers into two sets. A head and tail.\n// We first render the head. If anything is in fallback state, we do another\n// pass through beginWork to rerender all children (including the tail) with\n// the force suspend context. If the first render didn't have anything in\n// in fallback state. Then we render each row in the tail one-by-one.\n// That happens in the completeWork phase without going back to beginWork.\n\n\nfunction updateSuspenseListComponent(current, workInProgress, renderLanes) {\n  const nextProps = workInProgress.pendingProps;\n  const revealOrder = nextProps.revealOrder;\n  const tailMode = nextProps.tail;\n  const newChildren = nextProps.children;\n  reconcileChildren(current, workInProgress, newChildren, renderLanes);\n  let suspenseContext = suspenseStackCursor.current;\n  const shouldForceFallback = hasSuspenseContext(suspenseContext, ForceSuspenseFallback);\n\n  if (shouldForceFallback) {\n    suspenseContext = setShallowSuspenseContext(suspenseContext, ForceSuspenseFallback);\n    workInProgress.flags |= DidCapture;\n  } else {\n    const didSuspendBefore = current !== null && (current.flags & DidCapture) !== NoFlags;\n\n    if (didSuspendBefore) {\n      // If we previously forced a fallback, we need to schedule work\n      // on any nested boundaries to let them know to try to render\n      // again. This is the same as context updating.\n      propagateSuspenseContextChange(workInProgress, workInProgress.child, renderLanes);\n    }\n\n    suspenseContext = setDefaultShallowSuspenseContext(suspenseContext);\n  }\n\n  pushSuspenseContext(workInProgress, suspenseContext);\n\n  if ((workInProgress.mode & ConcurrentMode) === NoMode) {\n    // In legacy mode, SuspenseList doesn't work so we just\n    // use make it a noop by treating it as the default revealOrder.\n    workInProgress.memoizedState = null;\n  } else {\n    switch (revealOrder) {\n      case 'forwards':\n        {\n          const lastContentRow = findLastContentRow(workInProgress.child);\n          let tail;\n\n          if (lastContentRow === null) {\n            // The whole list is part of the tail.\n            // TODO: We could fast path by just rendering the tail now.\n            tail = workInProgress.child;\n            workInProgress.child = null;\n          } else {\n            // Disconnect the tail rows after the content row.\n            // We're going to render them separately later.\n            tail = lastContentRow.sibling;\n            lastContentRow.sibling = null;\n          }\n\n          initSuspenseListRenderState(workInProgress, false, // isBackwards\n          tail, lastContentRow, tailMode);\n          break;\n        }\n\n      case 'backwards':\n        {\n          // We're going to find the first row that has existing content.\n          // At the same time we're going to reverse the list of everything\n          // we pass in the meantime. That's going to be our tail in reverse\n          // order.\n          let tail = null;\n          let row = workInProgress.child;\n          workInProgress.child = null;\n\n          while (row !== null) {\n            const currentRow = row.alternate; // New rows can't be content rows.\n\n            if (currentRow !== null && findFirstSuspended(currentRow) === null) {\n              // This is the beginning of the main content.\n              workInProgress.child = row;\n              break;\n            }\n\n            const nextRow = row.sibling;\n            row.sibling = tail;\n            tail = row;\n            row = nextRow;\n          } // TODO: If workInProgress.child is null, we can continue on the tail immediately.\n\n\n          initSuspenseListRenderState(workInProgress, true, // isBackwards\n          tail, null, // last\n          tailMode);\n          break;\n        }\n\n      case 'together':\n        {\n          initSuspenseListRenderState(workInProgress, false, // isBackwards\n          null, // tail\n          null, // last\n          undefined);\n          break;\n        }\n\n      default:\n        {\n          // The default reveal order is the same as not having\n          // a boundary.\n          workInProgress.memoizedState = null;\n        }\n    }\n  }\n\n  return workInProgress.child;\n}\n\nfunction updatePortalComponent(current, workInProgress, renderLanes) {\n  pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);\n  const nextChildren = workInProgress.pendingProps;\n\n  if (current === null) {\n    // Portals are special because we don't append the children during mount\n    // but at commit. Therefore we need to track insertions which the normal\n    // flow doesn't do during mount. This doesn't happen at the root because\n    // the root always starts with a \"current\" with a null child.\n    // TODO: Consider unifying this with how the root works.\n    workInProgress.child = reconcileChildFibers(workInProgress, null, nextChildren, renderLanes);\n  } else {\n    reconcileChildren(current, workInProgress, nextChildren, renderLanes);\n  }\n\n  return workInProgress.child;\n}\n\nfunction updateContextProvider(current, workInProgress, renderLanes) {\n  const providerType = workInProgress.type;\n  const context = providerType._context;\n  const newProps = workInProgress.pendingProps;\n  const oldProps = workInProgress.memoizedProps;\n  const newValue = newProps.value;\n\n  pushProvider(workInProgress, context, newValue);\n\n  {\n    if (oldProps !== null) {\n      const oldValue = oldProps.value;\n\n      if (objectIs(oldValue, newValue)) {\n        // No change. Bailout early if children are the same.\n        if (oldProps.children === newProps.children && !hasContextChanged()) {\n          return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);\n        }\n      } else {\n        // The context value changed. Search for matching consumers and schedule\n        // them to update.\n        propagateContextChange(workInProgress, context, renderLanes);\n      }\n    }\n  }\n\n  const newChildren = newProps.children;\n  reconcileChildren(current, workInProgress, newChildren, renderLanes);\n  return workInProgress.child;\n}\n\nfunction updateContextConsumer(current, workInProgress, renderLanes) {\n  let context = workInProgress.type; // The logic below for Context differs depending on PROD or DEV mode. In\n\n  const newProps = workInProgress.pendingProps;\n  const render = newProps.children;\n\n  prepareToReadContext(workInProgress, renderLanes);\n  const newValue = readContext(context);\n\n  let newChildren;\n\n  {\n    newChildren = render(newValue);\n  }\n\n\n  workInProgress.flags |= PerformedWork;\n  reconcileChildren(current, workInProgress, newChildren, renderLanes);\n  return workInProgress.child;\n}\n\nfunction markWorkInProgressReceivedUpdate() {\n  didReceiveUpdate = true;\n}\n\nfunction resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress) {\n  if ((workInProgress.mode & ConcurrentMode) === NoMode) {\n    if (current !== null) {\n      // A lazy component only mounts if it suspended inside a non-\n      // concurrent tree, in an inconsistent state. We want to treat it like\n      // a new mount, even though an empty version of it already committed.\n      // Disconnect the alternate pointers.\n      current.alternate = null;\n      workInProgress.alternate = null; // Since this is conceptually a new fiber, schedule a Placement effect\n\n      workInProgress.flags |= Placement;\n    }\n  }\n}\n\nfunction bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes) {\n  if (current !== null) {\n    // Reuse previous dependencies\n    workInProgress.dependencies = current.dependencies;\n  }\n\n  markSkippedUpdateLanes(workInProgress.lanes); // Check if the children have any pending work.\n\n  if (!includesSomeLane(renderLanes, workInProgress.childLanes)) {\n    // The children don't have any work either. We can skip them.\n    // TODO: Once we add back resuming, we should check if the children are\n    // a work-in-progress set. If so, we need to transfer their effects.\n    {\n      return null;\n    }\n  } // This fiber doesn't have work, but its subtree does. Clone the child\n  // fibers and continue.\n\n\n  cloneChildFibers(current, workInProgress);\n  return workInProgress.child;\n}\n\nfunction checkScheduledUpdateOrContext(current, renderLanes) {\n  // Before performing an early bailout, we must check if there are pending\n  // updates or context.\n  const updateLanes = current.lanes;\n\n  if (includesSomeLane(updateLanes, renderLanes)) {\n    return true;\n  } // No pending update, but because context is propagated lazily, we need\n\n  return false;\n}\n\nfunction attemptEarlyBailoutIfNoScheduledUpdate(current, workInProgress, renderLanes) {\n  // This fiber does not have any pending work. Bailout without entering\n  // the begin phase. There's still some bookkeeping we that needs to be done\n  // in this optimized path, mostly pushing stuff onto the stack.\n  switch (workInProgress.tag) {\n    case HostRoot:\n      pushHostRootContext(workInProgress);\n      const root = workInProgress.stateNode;\n\n      resetHydrationState();\n      break;\n\n    case HostComponent:\n      pushHostContext(workInProgress);\n      break;\n\n    case ClassComponent:\n      {\n        const Component = workInProgress.type;\n\n        if (isContextProvider(Component)) {\n          pushContextProvider(workInProgress);\n        }\n\n        break;\n      }\n\n    case HostPortal:\n      pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);\n      break;\n\n    case ContextProvider:\n      {\n        const newValue = workInProgress.memoizedProps.value;\n        const context = workInProgress.type._context;\n        pushProvider(workInProgress, context, newValue);\n        break;\n      }\n\n    case Profiler:\n\n      break;\n\n    case SuspenseComponent:\n      {\n        const state = workInProgress.memoizedState;\n\n        if (state !== null) {\n          if (state.dehydrated !== null) {\n            pushSuspenseContext(workInProgress, setDefaultShallowSuspenseContext(suspenseStackCursor.current)); // We know that this component will suspend again because if it has\n            // been unsuspended it has committed as a resolved Suspense component.\n            // If it needs to be retried, it should have work scheduled on it.\n\n            workInProgress.flags |= DidCapture; // We should never render the children of a dehydrated boundary until we\n            // upgrade it. We return null instead of bailoutOnAlreadyFinishedWork.\n\n            return null;\n          } // If this boundary is currently timed out, we need to decide\n          // whether to retry the primary children, or to skip over it and\n          // go straight to the fallback. Check the priority of the primary\n          // child fragment.\n\n\n          const primaryChildFragment = workInProgress.child;\n          const primaryChildLanes = primaryChildFragment.childLanes;\n\n          if (includesSomeLane(renderLanes, primaryChildLanes)) {\n            // The primary children have pending work. Use the normal path\n            // to attempt to render the primary children again.\n            return updateSuspenseComponent(current, workInProgress, renderLanes);\n          } else {\n            // The primary child fragment does not have pending work marked\n            // on it\n            pushSuspenseContext(workInProgress, setDefaultShallowSuspenseContext(suspenseStackCursor.current)); // The primary children do not have pending work with sufficient\n            // priority. Bailout.\n\n            const child = bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);\n\n            if (child !== null) {\n              // The fallback children have pending work. Skip over the\n              // primary children and work on the fallback.\n              return child.sibling;\n            } else {\n              // Note: We can return `null` here because we already checked\n              // whether there were nested context consumers, via the call to\n              // `bailoutOnAlreadyFinishedWork` above.\n              return null;\n            }\n          }\n        } else {\n          pushSuspenseContext(workInProgress, setDefaultShallowSuspenseContext(suspenseStackCursor.current));\n        }\n\n        break;\n      }\n\n    case SuspenseListComponent:\n      {\n        const didSuspendBefore = (current.flags & DidCapture) !== NoFlags;\n        let hasChildWork = includesSomeLane(renderLanes, workInProgress.childLanes);\n\n        if (didSuspendBefore) {\n          if (hasChildWork) {\n            // If something was in fallback state last time, and we have all the\n            // same children then we're still in progressive loading state.\n            // Something might get unblocked by state updates or retries in the\n            // tree which will affect the tail. So we need to use the normal\n            // path to compute the correct tail.\n            return updateSuspenseListComponent(current, workInProgress, renderLanes);\n          } // If none of the children had any work, that means that none of\n          // them got retried so they'll still be blocked in the same way\n          // as before. We can fast bail out.\n\n\n          workInProgress.flags |= DidCapture;\n        } // If nothing suspended before and we're rendering the same children,\n        // then the tail doesn't matter. Anything new that suspends will work\n        // in the \"together\" mode, so we can continue from the state we had.\n\n\n        const renderState = workInProgress.memoizedState;\n\n        if (renderState !== null) {\n          // Reset to the \"together\" mode in case we've started a different\n          // update in the past but didn't complete it.\n          renderState.rendering = null;\n          renderState.tail = null;\n          renderState.lastEffect = null;\n        }\n\n        pushSuspenseContext(workInProgress, suspenseStackCursor.current);\n\n        if (hasChildWork) {\n          break;\n        } else {\n          // If none of the children had any work, that means that none of\n          // them got retried so they'll still be blocked in the same way\n          // as before. We can fast bail out.\n          return null;\n        }\n      }\n\n    case OffscreenComponent:\n    case LegacyHiddenComponent:\n      {\n        // Need to check if the tree still needs to be deferred. This is\n        // almost identical to the logic used in the normal update path,\n        // so we'll just enter that. The only difference is we'll bail out\n        // at the next level instead of this one, because the child props\n        // have not changed. Which is fine.\n        // TODO: Probably should refactor `beginWork` to split the bailout\n        // path from the normal path. I'm tempted to do a labeled break here\n        // but I won't :)\n        workInProgress.lanes = NoLanes;\n        return updateOffscreenComponent(current, workInProgress, renderLanes);\n      }\n  }\n\n  return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);\n}\n\nfunction beginWork(current, workInProgress, renderLanes) {\n\n  if (current !== null) {\n    const oldProps = current.memoizedProps;\n    const newProps = workInProgress.pendingProps;\n\n    if (oldProps !== newProps || hasContextChanged() || ( // Force a re-render if the implementation changed due to hot reload:\n     false)) {\n      // If props or context changed, mark the fiber as having performed work.\n      // This may be unset if the props are determined to be equal later (memo).\n      didReceiveUpdate = true;\n    } else {\n      // Neither props nor legacy context changes. Check if there's a pending\n      // update or context change.\n      const hasScheduledUpdateOrContext = checkScheduledUpdateOrContext(current, renderLanes);\n\n      if (!hasScheduledUpdateOrContext && // If this is the second pass of an error or suspense boundary, there\n      // may not be work scheduled on `current`, so we check for this flag.\n      (workInProgress.flags & DidCapture) === NoFlags) {\n        // No pending updates or context. Bail out now.\n        didReceiveUpdate = false;\n        return attemptEarlyBailoutIfNoScheduledUpdate(current, workInProgress, renderLanes);\n      }\n\n      if ((current.flags & ForceUpdateForLegacySuspense) !== NoFlags) {\n        // This is a special case that only exists for legacy mode.\n        // See https://github.com/facebook/react/pull/19216.\n        didReceiveUpdate = true;\n      } else {\n        // An update was scheduled on this fiber, but there are no new props\n        // nor legacy context. Set this to false. If an update queue or context\n        // consumer produces a changed value, it will set this to true. Otherwise,\n        // the component will assume the children have not changed and bail out.\n        didReceiveUpdate = false;\n      }\n    }\n  } else {\n    didReceiveUpdate = false;\n\n    if (getIsHydrating() && isForkedChild(workInProgress)) {\n      // Check if this child belongs to a list of muliple children in\n      // its parent.\n      //\n      // In a true multi-threaded implementation, we would render children on\n      // parallel threads. This would represent the beginning of a new render\n      // thread for this subtree.\n      //\n      // We only use this for id generation during hydration, which is why the\n      // logic is located in this special branch.\n      const slotIndex = workInProgress.index;\n      const numberOfForks = getForksAtLevel();\n      pushTreeId(workInProgress, numberOfForks, slotIndex);\n    }\n  } // Before entering the begin phase, clear pending update priority.\n  // TODO: This assumes that we're about to evaluate the component and process\n  // the update queue. However, there's an exception: SimpleMemoComponent\n  // sometimes bails out later in the begin phase. This indicates that we should\n  // move this assignment out of the common path and into each branch.\n\n\n  workInProgress.lanes = NoLanes;\n\n  switch (workInProgress.tag) {\n    case IndeterminateComponent:\n      {\n        return mountIndeterminateComponent(current, workInProgress, workInProgress.type, renderLanes);\n      }\n\n    case LazyComponent:\n      {\n        const elementType = workInProgress.elementType;\n        return mountLazyComponent(current, workInProgress, elementType, renderLanes);\n      }\n\n    case FunctionComponent:\n      {\n        const Component = workInProgress.type;\n        const unresolvedProps = workInProgress.pendingProps;\n        const resolvedProps = workInProgress.elementType === Component ? unresolvedProps : resolveDefaultProps(Component, unresolvedProps);\n        return updateFunctionComponent(current, workInProgress, Component, resolvedProps, renderLanes);\n      }\n\n    case ClassComponent:\n      {\n        const Component = workInProgress.type;\n        const unresolvedProps = workInProgress.pendingProps;\n        const resolvedProps = workInProgress.elementType === Component ? unresolvedProps : resolveDefaultProps(Component, unresolvedProps);\n        return updateClassComponent(current, workInProgress, Component, resolvedProps, renderLanes);\n      }\n\n    case HostRoot:\n      return updateHostRoot(current, workInProgress, renderLanes);\n\n    case HostComponent:\n      return updateHostComponent(current, workInProgress, renderLanes);\n\n    case HostText:\n      return updateHostText(current, workInProgress);\n\n    case SuspenseComponent:\n      return updateSuspenseComponent(current, workInProgress, renderLanes);\n\n    case HostPortal:\n      return updatePortalComponent(current, workInProgress, renderLanes);\n\n    case ForwardRef:\n      {\n        const type = workInProgress.type;\n        const unresolvedProps = workInProgress.pendingProps;\n        const resolvedProps = workInProgress.elementType === type ? unresolvedProps : resolveDefaultProps(type, unresolvedProps);\n        return updateForwardRef(current, workInProgress, type, resolvedProps, renderLanes);\n      }\n\n    case Fragment:\n      return updateFragment(current, workInProgress, renderLanes);\n\n    case Mode:\n      return updateMode(current, workInProgress, renderLanes);\n\n    case Profiler:\n      return updateProfiler(current, workInProgress, renderLanes);\n\n    case ContextProvider:\n      return updateContextProvider(current, workInProgress, renderLanes);\n\n    case ContextConsumer:\n      return updateContextConsumer(current, workInProgress, renderLanes);\n\n    case MemoComponent:\n      {\n        const type = workInProgress.type;\n        const unresolvedProps = workInProgress.pendingProps; // Resolve outer props first, then resolve inner props.\n\n        let resolvedProps = resolveDefaultProps(type, unresolvedProps);\n\n        resolvedProps = resolveDefaultProps(type.type, resolvedProps);\n        return updateMemoComponent(current, workInProgress, type, resolvedProps, renderLanes);\n      }\n\n    case SimpleMemoComponent:\n      {\n        return updateSimpleMemoComponent(current, workInProgress, workInProgress.type, workInProgress.pendingProps, renderLanes);\n      }\n\n    case IncompleteClassComponent:\n      {\n        const Component = workInProgress.type;\n        const unresolvedProps = workInProgress.pendingProps;\n        const resolvedProps = workInProgress.elementType === Component ? unresolvedProps : resolveDefaultProps(Component, unresolvedProps);\n        return mountIncompleteClassComponent(current, workInProgress, Component, resolvedProps, renderLanes);\n      }\n\n    case SuspenseListComponent:\n      {\n        return updateSuspenseListComponent(current, workInProgress, renderLanes);\n      }\n\n    case ScopeComponent:\n      {\n\n        break;\n      }\n\n    case OffscreenComponent:\n      {\n        return updateOffscreenComponent(current, workInProgress, renderLanes);\n      }\n  }\n\n  throw Error(formatProdErrorMessage(156, workInProgress.tag));\n}\n\nfunction markUpdate(workInProgress) {\n  // Tag the fiber with an update effect. This turns a Placement into\n  // a PlacementAndUpdate.\n  workInProgress.flags |= Update;\n}\n\nfunction markRef$1(workInProgress) {\n  workInProgress.flags |= Ref;\n\n  {\n    workInProgress.flags |= RefStatic;\n  }\n}\n\nlet appendAllChildren;\nlet updateHostContainer;\nlet updateHostComponent$1;\nlet updateHostText$1;\n\n{\n  // Mutation mode\n  appendAllChildren = function (parent, workInProgress, needsVisibilityToggle, isHidden) {\n    // We only have the top Fiber that was created but we need recurse down its\n    // children to find all the terminal nodes.\n    let node = workInProgress.child;\n\n    while (node !== null) {\n      if (node.tag === HostComponent || node.tag === HostText) {\n        appendInitialChild(parent, node.stateNode);\n      } else if (node.tag === HostPortal) ; else if (node.child !== null) {\n        node.child.return = node;\n        node = node.child;\n        continue;\n      }\n\n      if (node === workInProgress) {\n        return;\n      }\n\n      while (node.sibling === null) {\n        if (node.return === null || node.return === workInProgress) {\n          return;\n        }\n\n        node = node.return;\n      }\n\n      node.sibling.return = node.return;\n      node = node.sibling;\n    }\n  };\n\n  updateHostContainer = function (current, workInProgress) {// Noop\n  };\n\n  updateHostComponent$1 = function (current, workInProgress, type, newProps, rootContainerInstance) {\n    // If we have an alternate, that means this is an update and we need to\n    // schedule a side-effect to do the updates.\n    const oldProps = current.memoizedProps;\n\n    if (oldProps === newProps) {\n      // In mutation mode, this is sufficient for a bailout because\n      // we won't touch this node even if children changed.\n      return;\n    } // If we get updated because one of our children updated, we don't\n    // have newProps so we'll have to reuse them.\n    // TODO: Split the update API as separate for the props vs. children.\n    // Even better would be if children weren't special cased at all tho.\n\n\n    const instance = workInProgress.stateNode;\n    const currentHostContext = getHostContext(); // TODO: Experiencing an error where oldProps is null. Suggests a host\n    // component is hitting the resume path. Figure out why. Possibly\n    // related to `hidden`.\n\n    const updatePayload = prepareUpdate(instance, type, oldProps, newProps); // TODO: Type this specific to this type of component.\n\n    workInProgress.updateQueue = updatePayload; // If the update payload indicates that there is a change or if there\n    // is a new ref we mark this as an update. All the work is done in commitWork.\n\n    if (updatePayload) {\n      markUpdate(workInProgress);\n    }\n  };\n\n  updateHostText$1 = function (current, workInProgress, oldText, newText) {\n    // If the text differs, mark it as an update. All the work in done in commitWork.\n    if (oldText !== newText) {\n      markUpdate(workInProgress);\n    }\n  };\n}\n\nfunction cutOffTailIfNeeded(renderState, hasRenderedATailFallback) {\n  if (getIsHydrating()) {\n    // If we're hydrating, we should consume as many items as we can\n    // so we don't leave any behind.\n    return;\n  }\n\n  switch (renderState.tailMode) {\n    case 'hidden':\n      {\n        // Any insertions at the end of the tail list after this point\n        // should be invisible. If there are already mounted boundaries\n        // anything before them are not considered for collapsing.\n        // Therefore we need to go through the whole tail to find if\n        // there are any.\n        let tailNode = renderState.tail;\n        let lastTailNode = null;\n\n        while (tailNode !== null) {\n          if (tailNode.alternate !== null) {\n            lastTailNode = tailNode;\n          }\n\n          tailNode = tailNode.sibling;\n        } // Next we're simply going to delete all insertions after the\n        // last rendered item.\n\n\n        if (lastTailNode === null) {\n          // All remaining items in the tail are insertions.\n          renderState.tail = null;\n        } else {\n          // Detach the insertion after the last node that was already\n          // inserted.\n          lastTailNode.sibling = null;\n        }\n\n        break;\n      }\n\n    case 'collapsed':\n      {\n        // Any insertions at the end of the tail list after this point\n        // should be invisible. If there are already mounted boundaries\n        // anything before them are not considered for collapsing.\n        // Therefore we need to go through the whole tail to find if\n        // there are any.\n        let tailNode = renderState.tail;\n        let lastTailNode = null;\n\n        while (tailNode !== null) {\n          if (tailNode.alternate !== null) {\n            lastTailNode = tailNode;\n          }\n\n          tailNode = tailNode.sibling;\n        } // Next we're simply going to delete all insertions after the\n        // last rendered item.\n\n\n        if (lastTailNode === null) {\n          // All remaining items in the tail are insertions.\n          if (!hasRenderedATailFallback && renderState.tail !== null) {\n            // We suspended during the head. We want to show at least one\n            // row at the tail. So we'll keep on and cut off the rest.\n            renderState.tail.sibling = null;\n          } else {\n            renderState.tail = null;\n          }\n        } else {\n          // Detach the insertion after the last node that was already\n          // inserted.\n          lastTailNode.sibling = null;\n        }\n\n        break;\n      }\n  }\n}\n\nfunction bubbleProperties(completedWork) {\n  const didBailout = completedWork.alternate !== null && completedWork.alternate.child === completedWork.child;\n  let newChildLanes = NoLanes;\n  let subtreeFlags = NoFlags;\n\n  if (!didBailout) {\n    // Bubble up the earliest expiration time.\n    {\n      let child = completedWork.child;\n\n      while (child !== null) {\n        newChildLanes = mergeLanes(newChildLanes, mergeLanes(child.lanes, child.childLanes));\n        subtreeFlags |= child.subtreeFlags;\n        subtreeFlags |= child.flags; // Update the return pointer so the tree is consistent. This is a code\n        // smell because it assumes the commit phase is never concurrent with\n        // the render phase. Will address during refactor to alternate model.\n\n        child.return = completedWork;\n        child = child.sibling;\n      }\n    }\n\n    completedWork.subtreeFlags |= subtreeFlags;\n  } else {\n    // Bubble up the earliest expiration time.\n    {\n      let child = completedWork.child;\n\n      while (child !== null) {\n        newChildLanes = mergeLanes(newChildLanes, mergeLanes(child.lanes, child.childLanes)); // \"Static\" flags share the lifetime of the fiber/hook they belong to,\n        // so we should bubble those up even during a bailout. All the other\n        // flags have a lifetime only of a single render + commit, so we should\n        // ignore them.\n\n        subtreeFlags |= child.subtreeFlags & StaticMask;\n        subtreeFlags |= child.flags & StaticMask; // Update the return pointer so the tree is consistent. This is a code\n        // smell because it assumes the commit phase is never concurrent with\n        // the render phase. Will address during refactor to alternate model.\n\n        child.return = completedWork;\n        child = child.sibling;\n      }\n    }\n\n    completedWork.subtreeFlags |= subtreeFlags;\n  }\n\n  completedWork.childLanes = newChildLanes;\n  return didBailout;\n}\n\nfunction completeDehydratedSuspenseBoundary(current, workInProgress, nextState) {\n  if (hasUnhydratedTailNodes() && (workInProgress.mode & ConcurrentMode) !== NoMode && (workInProgress.flags & DidCapture) === NoFlags) {\n    warnIfUnhydratedTailNodes();\n    resetHydrationState();\n    workInProgress.flags |= ForceClientRender | Incomplete | ShouldCapture;\n    return false;\n  }\n\n  const wasHydrated = popHydrationState(workInProgress);\n\n  if (nextState !== null && nextState.dehydrated !== null) {\n    // We might be inside a hydration state the first time we're picking up this\n    // Suspense boundary, and also after we've reentered it for further hydration.\n    if (current === null) {\n      if (!wasHydrated) {\n        throw Error(formatProdErrorMessage(318));\n      }\n\n      prepareToHydrateHostSuspenseInstance(workInProgress);\n      bubbleProperties(workInProgress);\n\n      return false;\n    } else {\n      // We might have reentered this boundary to hydrate it. If so, we need to reset the hydration\n      // state since we're now exiting out of it. popHydrationState doesn't do that for us.\n      resetHydrationState();\n\n      if ((workInProgress.flags & DidCapture) === NoFlags) {\n        // This boundary did not suspend so it's now hydrated and unsuspended.\n        workInProgress.memoizedState = null;\n      } // If nothing suspended, we need to schedule an effect to mark this boundary\n      // as having hydrated so events know that they're free to be invoked.\n      // It's also a signal to replay events and the suspense callback.\n      // If something suspended, schedule an effect to attach retry listeners.\n      // So we might as well always mark this.\n\n\n      workInProgress.flags |= Update;\n      bubbleProperties(workInProgress);\n\n      return false;\n    }\n  } else {\n    // Successfully completed this tree. If this was a forced client render,\n    // there may have been recoverable errors during first hydration\n    // attempt. If so, add them to a queue so we can log them in the\n    // commit phase.\n    upgradeHydrationErrorsToRecoverable(); // Fall through to normal Suspense path\n\n    return true;\n  }\n}\n\nfunction completeWork(current, workInProgress, renderLanes) {\n  const newProps = workInProgress.pendingProps; // Note: This intentionally doesn't check if we're hydrating because comparing\n  // to the current tree provider fiber is just as fast and less error-prone.\n  // Ideally we would have a special version of the work loop only\n  // for hydration.\n\n  popTreeContext(workInProgress);\n\n  switch (workInProgress.tag) {\n    case IndeterminateComponent:\n    case LazyComponent:\n    case SimpleMemoComponent:\n    case FunctionComponent:\n    case ForwardRef:\n    case Fragment:\n    case Mode:\n    case Profiler:\n    case ContextConsumer:\n    case MemoComponent:\n      bubbleProperties(workInProgress);\n      return null;\n\n    case ClassComponent:\n      {\n        const Component = workInProgress.type;\n\n        if (isContextProvider(Component)) {\n          popContext();\n        }\n\n        bubbleProperties(workInProgress);\n        return null;\n      }\n\n    case HostRoot:\n      {\n        const fiberRoot = workInProgress.stateNode;\n        popHostContainer();\n        popTopLevelContextObject();\n        resetWorkInProgressVersions();\n\n        if (fiberRoot.pendingContext) {\n          fiberRoot.context = fiberRoot.pendingContext;\n          fiberRoot.pendingContext = null;\n        }\n\n        if (current === null || current.child === null) {\n          // If we hydrated, pop so that we can delete any remaining children\n          // that weren't hydrated.\n          const wasHydrated = popHydrationState(workInProgress);\n\n          if (wasHydrated) {\n            // If we hydrated, then we'll need to schedule an update for\n            // the commit side-effects on the root.\n            markUpdate(workInProgress);\n          } else {\n            if (current !== null) {\n              const prevState = current.memoizedState;\n\n              if ( // Check if this is a client root\n              !prevState.isDehydrated || // Check if we reverted to client rendering (e.g. due to an error)\n              (workInProgress.flags & ForceClientRender) !== NoFlags) {\n                // Schedule an effect to clear this container at the start of the\n                // next commit. This handles the case of React rendering into a\n                // container with previous children. It's also safe to do for\n                // updates too, because current.child would only be null if the\n                // previous render was null (so the container would already\n                // be empty).\n                workInProgress.flags |= Snapshot; // If this was a forced client render, there may have been\n                // recoverable errors during first hydration attempt. If so, add\n                // them to a queue so we can log them in the commit phase.\n\n                upgradeHydrationErrorsToRecoverable();\n              }\n            }\n          }\n        }\n\n        updateHostContainer(current, workInProgress);\n        bubbleProperties(workInProgress);\n\n        return null;\n      }\n\n    case HostComponent:\n      {\n        popHostContext(workInProgress);\n        const rootContainerInstance = getRootHostContainer();\n        const type = workInProgress.type;\n\n        if (current !== null && workInProgress.stateNode != null) {\n          updateHostComponent$1(current, workInProgress, type, newProps, rootContainerInstance);\n\n          if (current.ref !== workInProgress.ref) {\n            markRef$1(workInProgress);\n          }\n        } else {\n          if (!newProps) {\n            if (workInProgress.stateNode === null) {\n              throw Error(formatProdErrorMessage(166));\n            } // This can happen when we abort work.\n\n\n            bubbleProperties(workInProgress);\n            return null;\n          }\n\n          const currentHostContext = getHostContext(); // TODO: Move createInstance to beginWork and keep it on a context\n          // \"stack\" as the parent. Then append children as we go in beginWork\n          // or completeWork depending on whether we want to add them top->down or\n          // bottom->up. Top->down is faster in IE11.\n\n          const wasHydrated = popHydrationState(workInProgress);\n\n          if (wasHydrated) {\n            // TODO: Move this and createInstance step into the beginPhase\n            // to consolidate.\n            if (prepareToHydrateHostInstance(workInProgress, rootContainerInstance, currentHostContext)) {\n              // If changes to the hydrated node need to be applied at the\n              // commit-phase we mark this as such.\n              markUpdate(workInProgress);\n            }\n          } else {\n            const instance = createInstance(type, newProps, rootContainerInstance, currentHostContext, workInProgress);\n            appendAllChildren(instance, workInProgress, false, false);\n            workInProgress.stateNode = instance; // Certain renderers require commit-time effects for initial mount.\n            // (eg DOM renderer supports auto-focus for certain elements).\n            // Make sure such renderers get scheduled for later work.\n\n            if (finalizeInitialChildren(instance, type, newProps, rootContainerInstance)) {\n              markUpdate(workInProgress);\n            }\n          }\n\n          if (workInProgress.ref !== null) {\n            // If there is a ref on a host node we need to schedule a callback\n            markRef$1(workInProgress);\n          }\n        }\n\n        bubbleProperties(workInProgress);\n        return null;\n      }\n\n    case HostText:\n      {\n        const newText = newProps;\n\n        if (current && workInProgress.stateNode != null) {\n          const oldText = current.memoizedProps; // If we have an alternate, that means this is an update and we need\n          // to schedule a side-effect to do the updates.\n\n          updateHostText$1(current, workInProgress, oldText, newText);\n        } else {\n          if (typeof newText !== 'string') {\n            if (workInProgress.stateNode === null) {\n              throw Error(formatProdErrorMessage(166));\n            } // This can happen when we abort work.\n\n          }\n\n          const rootContainerInstance = getRootHostContainer();\n          const currentHostContext = getHostContext();\n          const wasHydrated = popHydrationState(workInProgress);\n\n          if (wasHydrated) {\n            if (prepareToHydrateHostTextInstance(workInProgress)) {\n              markUpdate(workInProgress);\n            }\n          } else {\n            workInProgress.stateNode = createTextInstance(newText, rootContainerInstance, currentHostContext, workInProgress);\n          }\n        }\n\n        bubbleProperties(workInProgress);\n        return null;\n      }\n\n    case SuspenseComponent:\n      {\n        popSuspenseContext();\n        const nextState = workInProgress.memoizedState; // Special path for dehydrated boundaries. We may eventually move this\n        // to its own fiber type so that we can add other kinds of hydration\n        // boundaries that aren't associated with a Suspense tree. In anticipation\n        // of such a refactor, all the hydration logic is contained in\n        // this branch.\n\n        if (current === null || current.memoizedState !== null && current.memoizedState.dehydrated !== null) {\n          const fallthroughToNormalSuspensePath = completeDehydratedSuspenseBoundary(current, workInProgress, nextState);\n\n          if (!fallthroughToNormalSuspensePath) {\n            if (workInProgress.flags & ShouldCapture) {\n              // Special case. There were remaining unhydrated nodes. We treat\n              // this as a mismatch. Revert to client rendering.\n              return workInProgress;\n            } else {\n              // Did not finish hydrating, either because this is the initial\n              // render or because something suspended.\n              return null;\n            }\n          } // Continue with the normal Suspense path.\n\n        }\n\n        if ((workInProgress.flags & DidCapture) !== NoFlags) {\n          // Something suspended. Re-render with the fallback children.\n          workInProgress.lanes = renderLanes; // Do not reset the effect list.\n\n\n          return workInProgress;\n        }\n\n        const nextDidTimeout = nextState !== null;\n        const prevDidTimeout = current !== null && current.memoizedState !== null;\n        // a passive effect, which is when we process the transitions\n\n\n        if (nextDidTimeout !== prevDidTimeout) {\n          // an effect to toggle the subtree's visibility. When we switch from\n          // fallback -> primary, the inner Offscreen fiber schedules this effect\n          // as part of its normal complete phase. But when we switch from\n          // primary -> fallback, the inner Offscreen fiber does not have a complete\n          // phase. So we need to schedule its effect here.\n          //\n          // We also use this flag to connect/disconnect the effects, but the same\n          // logic applies: when re-connecting, the Offscreen fiber's complete\n          // phase will handle scheduling the effect. It's only when the fallback\n          // is active that we have to do anything special.\n\n\n          if (nextDidTimeout) {\n            const offscreenFiber = workInProgress.child;\n            offscreenFiber.flags |= Visibility; // TODO: This will still suspend a synchronous tree if anything\n            // in the concurrent tree already suspended during this render.\n            // This is a known bug.\n\n            if ((workInProgress.mode & ConcurrentMode) !== NoMode) {\n              // TODO: Move this back to throwException because this is too late\n              // if this is a large tree which is common for initial loads. We\n              // don't know if we should restart a render or not until we get\n              // this marker, and this is too late.\n              // If this render already had a ping or lower pri updates,\n              // and this is the first time we know we're going to suspend we\n              // should be able to immediately restart from within throwException.\n              const hasInvisibleChildContext = current === null && (workInProgress.memoizedProps.unstable_avoidThisFallback !== true || !enableSuspenseAvoidThisFallback);\n\n              if (hasInvisibleChildContext || hasSuspenseContext(suspenseStackCursor.current, InvisibleParentSuspenseContext)) {\n                // If this was in an invisible tree or a new render, then showing\n                // this boundary is ok.\n                renderDidSuspend();\n              } else {\n                // Otherwise, we're going to have to hide content so we should\n                // suspend for longer if possible.\n                renderDidSuspendDelayIfPossible();\n              }\n            }\n          }\n        }\n\n        const wakeables = workInProgress.updateQueue;\n\n        if (wakeables !== null) {\n          // Schedule an effect to attach a retry listener to the promise.\n          // TODO: Move to passive phase\n          workInProgress.flags |= Update;\n        }\n\n        bubbleProperties(workInProgress);\n\n        return null;\n      }\n\n    case HostPortal:\n      popHostContainer();\n      updateHostContainer(current, workInProgress);\n\n      if (current === null) {\n        preparePortalMount(workInProgress.stateNode.containerInfo);\n      }\n\n      bubbleProperties(workInProgress);\n      return null;\n\n    case ContextProvider:\n      // Pop provider fiber\n      const context = workInProgress.type._context;\n      popProvider(context);\n      bubbleProperties(workInProgress);\n      return null;\n\n    case IncompleteClassComponent:\n      {\n        // Same as class component case. I put it down here so that the tags are\n        // sequential to ensure this switch is compiled to a jump table.\n        const Component = workInProgress.type;\n\n        if (isContextProvider(Component)) {\n          popContext();\n        }\n\n        bubbleProperties(workInProgress);\n        return null;\n      }\n\n    case SuspenseListComponent:\n      {\n        popSuspenseContext();\n        const renderState = workInProgress.memoizedState;\n\n        if (renderState === null) {\n          // We're running in the default, \"independent\" mode.\n          // We don't do anything in this mode.\n          bubbleProperties(workInProgress);\n          return null;\n        }\n\n        let didSuspendAlready = (workInProgress.flags & DidCapture) !== NoFlags;\n        const renderedTail = renderState.rendering;\n\n        if (renderedTail === null) {\n          // We just rendered the head.\n          if (!didSuspendAlready) {\n            // This is the first pass. We need to figure out if anything is still\n            // suspended in the rendered set.\n            // If new content unsuspended, but there's still some content that\n            // didn't. Then we need to do a second pass that forces everything\n            // to keep showing their fallbacks.\n            // We might be suspended if something in this render pass suspended, or\n            // something in the previous committed pass suspended. Otherwise,\n            // there's no chance so we can skip the expensive call to\n            // findFirstSuspended.\n            const cannotBeSuspended = renderHasNotSuspendedYet() && (current === null || (current.flags & DidCapture) === NoFlags);\n\n            if (!cannotBeSuspended) {\n              let row = workInProgress.child;\n\n              while (row !== null) {\n                const suspended = findFirstSuspended(row);\n\n                if (suspended !== null) {\n                  didSuspendAlready = true;\n                  workInProgress.flags |= DidCapture;\n                  cutOffTailIfNeeded(renderState, false); // If this is a newly suspended tree, it might not get committed as\n                  // part of the second pass. In that case nothing will subscribe to\n                  // its thenables. Instead, we'll transfer its thenables to the\n                  // SuspenseList so that it can retry if they resolve.\n                  // There might be multiple of these in the list but since we're\n                  // going to wait for all of them anyway, it doesn't really matter\n                  // which ones gets to ping. In theory we could get clever and keep\n                  // track of how many dependencies remain but it gets tricky because\n                  // in the meantime, we can add/remove/change items and dependencies.\n                  // We might bail out of the loop before finding any but that\n                  // doesn't matter since that means that the other boundaries that\n                  // we did find already has their listeners attached.\n\n                  const newThenables = suspended.updateQueue;\n\n                  if (newThenables !== null) {\n                    workInProgress.updateQueue = newThenables;\n                    workInProgress.flags |= Update;\n                  } // Rerender the whole list, but this time, we'll force fallbacks\n                  // to stay in place.\n                  // Reset the effect flags before doing the second pass since that's now invalid.\n                  // Reset the child fibers to their original state.\n\n\n                  workInProgress.subtreeFlags = NoFlags;\n                  resetChildFibers(workInProgress, renderLanes); // Set up the Suspense Context to force suspense and immediately\n                  // rerender the children.\n\n                  pushSuspenseContext(workInProgress, setShallowSuspenseContext(suspenseStackCursor.current, ForceSuspenseFallback)); // Don't bubble properties in this case.\n\n                  return workInProgress.child;\n                }\n\n                row = row.sibling;\n              }\n            }\n\n            if (renderState.tail !== null && now() > getRenderTargetTime()) {\n              // We have already passed our CPU deadline but we still have rows\n              // left in the tail. We'll just give up further attempts to render\n              // the main content and only render fallbacks.\n              workInProgress.flags |= DidCapture;\n              didSuspendAlready = true;\n              cutOffTailIfNeeded(renderState, false); // Since nothing actually suspended, there will nothing to ping this\n              // to get it started back up to attempt the next item. While in terms\n              // of priority this work has the same priority as this current render,\n              // it's not part of the same transition once the transition has\n              // committed. If it's sync, we still want to yield so that it can be\n              // painted. Conceptually, this is really the same as pinging.\n              // We can use any RetryLane even if it's the one currently rendering\n              // since we're leaving it behind on this node.\n\n              workInProgress.lanes = SomeRetryLane;\n            }\n          } else {\n            cutOffTailIfNeeded(renderState, false);\n          } // Next we're going to render the tail.\n\n        } else {\n          // Append the rendered row to the child list.\n          if (!didSuspendAlready) {\n            const suspended = findFirstSuspended(renderedTail);\n\n            if (suspended !== null) {\n              workInProgress.flags |= DidCapture;\n              didSuspendAlready = true; // Ensure we transfer the update queue to the parent so that it doesn't\n              // get lost if this row ends up dropped during a second pass.\n\n              const newThenables = suspended.updateQueue;\n\n              if (newThenables !== null) {\n                workInProgress.updateQueue = newThenables;\n                workInProgress.flags |= Update;\n              }\n\n              cutOffTailIfNeeded(renderState, true); // This might have been modified.\n\n              if (renderState.tail === null && renderState.tailMode === 'hidden' && !renderedTail.alternate && !getIsHydrating() // We don't cut it if we're hydrating.\n              ) {\n                  // We're done.\n                  bubbleProperties(workInProgress);\n                  return null;\n                }\n            } else if ( // The time it took to render last row is greater than the remaining\n            // time we have to render. So rendering one more row would likely\n            // exceed it.\n            now() * 2 - renderState.renderingStartTime > getRenderTargetTime() && renderLanes !== OffscreenLane) {\n              // We have now passed our CPU deadline and we'll just give up further\n              // attempts to render the main content and only render fallbacks.\n              // The assumption is that this is usually faster.\n              workInProgress.flags |= DidCapture;\n              didSuspendAlready = true;\n              cutOffTailIfNeeded(renderState, false); // Since nothing actually suspended, there will nothing to ping this\n              // to get it started back up to attempt the next item. While in terms\n              // of priority this work has the same priority as this current render,\n              // it's not part of the same transition once the transition has\n              // committed. If it's sync, we still want to yield so that it can be\n              // painted. Conceptually, this is really the same as pinging.\n              // We can use any RetryLane even if it's the one currently rendering\n              // since we're leaving it behind on this node.\n\n              workInProgress.lanes = SomeRetryLane;\n            }\n          }\n\n          if (renderState.isBackwards) {\n            // The effect list of the backwards tail will have been added\n            // to the end. This breaks the guarantee that life-cycles fire in\n            // sibling order but that isn't a strong guarantee promised by React.\n            // Especially since these might also just pop in during future commits.\n            // Append to the beginning of the list.\n            renderedTail.sibling = workInProgress.child;\n            workInProgress.child = renderedTail;\n          } else {\n            const previousSibling = renderState.last;\n\n            if (previousSibling !== null) {\n              previousSibling.sibling = renderedTail;\n            } else {\n              workInProgress.child = renderedTail;\n            }\n\n            renderState.last = renderedTail;\n          }\n        }\n\n        if (renderState.tail !== null) {\n          // We still have tail rows to render.\n          // Pop a row.\n          const next = renderState.tail;\n          renderState.rendering = next;\n          renderState.tail = next.sibling;\n          renderState.renderingStartTime = now();\n          next.sibling = null; // Restore the context.\n          // TODO: We can probably just avoid popping it instead and only\n          // setting it the first time we go from not suspended to suspended.\n\n          let suspenseContext = suspenseStackCursor.current;\n\n          if (didSuspendAlready) {\n            suspenseContext = setShallowSuspenseContext(suspenseContext, ForceSuspenseFallback);\n          } else {\n            suspenseContext = setDefaultShallowSuspenseContext(suspenseContext);\n          }\n\n          pushSuspenseContext(workInProgress, suspenseContext); // Do a pass over the next row.\n          // Don't bubble properties in this case.\n\n          return next;\n        }\n\n        bubbleProperties(workInProgress);\n        return null;\n      }\n\n    case ScopeComponent:\n      {\n\n        break;\n      }\n\n    case OffscreenComponent:\n    case LegacyHiddenComponent:\n      {\n        popRenderLanes();\n        const nextState = workInProgress.memoizedState;\n        const nextIsHidden = nextState !== null;\n\n        if (current !== null) {\n          const prevState = current.memoizedState;\n          const prevIsHidden = prevState !== null;\n\n          if (prevIsHidden !== nextIsHidden && ( // LegacyHidden doesn't do any hiding — it only pre-renders.\n          !enableLegacyHidden )) {\n            workInProgress.flags |= Visibility;\n          }\n        }\n\n        if (!nextIsHidden || (workInProgress.mode & ConcurrentMode) === NoMode) {\n          bubbleProperties(workInProgress);\n        } else {\n          // Don't bubble properties for hidden children unless we're rendering\n          // at offscreen priority.\n          if (includesSomeLane(subtreeRenderLanes, OffscreenLane)) {\n            bubbleProperties(workInProgress);\n\n            {\n              // Check if there was an insertion or update in the hidden subtree.\n              // If so, we need to hide those nodes in the commit phase, so\n              // schedule a visibility effect.\n              if ( workInProgress.subtreeFlags & (Placement | Update)) {\n                workInProgress.flags |= Visibility;\n              }\n            }\n          }\n        }\n        return null;\n      }\n\n    case CacheComponent:\n      {\n\n        return null;\n      }\n\n    case TracingMarkerComponent:\n      {\n\n        return null;\n      }\n  }\n\n  throw Error(formatProdErrorMessage(156, workInProgress.tag));\n}\n\nfunction unwindWork(current, workInProgress, renderLanes) {\n  // Note: This intentionally doesn't check if we're hydrating because comparing\n  // to the current tree provider fiber is just as fast and less error-prone.\n  // Ideally we would have a special version of the work loop only\n  // for hydration.\n  popTreeContext(workInProgress);\n\n  switch (workInProgress.tag) {\n    case ClassComponent:\n      {\n        const Component = workInProgress.type;\n\n        if (isContextProvider(Component)) {\n          popContext();\n        }\n\n        const flags = workInProgress.flags;\n\n        if (flags & ShouldCapture) {\n          workInProgress.flags = flags & ~ShouldCapture | DidCapture;\n\n          return workInProgress;\n        }\n\n        return null;\n      }\n\n    case HostRoot:\n      {\n        const root = workInProgress.stateNode;\n        popHostContainer();\n        popTopLevelContextObject();\n        resetWorkInProgressVersions();\n        const flags = workInProgress.flags;\n\n        if ((flags & ShouldCapture) !== NoFlags && (flags & DidCapture) === NoFlags) {\n          // There was an error during render that wasn't captured by a suspense\n          // boundary. Do a second pass on the root to unmount the children.\n          workInProgress.flags = flags & ~ShouldCapture | DidCapture;\n          return workInProgress;\n        } // We unwound to the root without completing it. Exit.\n\n\n        return null;\n      }\n\n    case HostComponent:\n      {\n        // TODO: popHydrationState\n        popHostContext(workInProgress);\n        return null;\n      }\n\n    case SuspenseComponent:\n      {\n        popSuspenseContext();\n        const suspenseState = workInProgress.memoizedState;\n\n        if (suspenseState !== null && suspenseState.dehydrated !== null) {\n          if (workInProgress.alternate === null) {\n            throw Error(formatProdErrorMessage(340));\n          }\n\n          resetHydrationState();\n        }\n\n        const flags = workInProgress.flags;\n\n        if (flags & ShouldCapture) {\n          workInProgress.flags = flags & ~ShouldCapture | DidCapture; // Captured a suspense effect. Re-render the boundary.\n\n          return workInProgress;\n        }\n\n        return null;\n      }\n\n    case SuspenseListComponent:\n      {\n        popSuspenseContext(); // SuspenseList doesn't actually catch anything. It should've been\n        // caught by a nested boundary. If not, it should bubble through.\n\n        return null;\n      }\n\n    case HostPortal:\n      popHostContainer();\n      return null;\n\n    case ContextProvider:\n      const context = workInProgress.type._context;\n      popProvider(context);\n      return null;\n\n    case OffscreenComponent:\n    case LegacyHiddenComponent:\n      popRenderLanes();\n      return null;\n\n    case CacheComponent:\n\n      return null;\n\n    default:\n      return null;\n  }\n}\n\nfunction unwindInterruptedWork(current, interruptedWork, renderLanes) {\n  // Note: This intentionally doesn't check if we're hydrating because comparing\n  // to the current tree provider fiber is just as fast and less error-prone.\n  // Ideally we would have a special version of the work loop only\n  // for hydration.\n  popTreeContext(interruptedWork);\n\n  switch (interruptedWork.tag) {\n    case ClassComponent:\n      {\n        const childContextTypes = interruptedWork.type.childContextTypes;\n\n        if (childContextTypes !== null && childContextTypes !== undefined) {\n          popContext();\n        }\n\n        break;\n      }\n\n    case HostRoot:\n      {\n        const root = interruptedWork.stateNode;\n        popHostContainer();\n        popTopLevelContextObject();\n        resetWorkInProgressVersions();\n        break;\n      }\n\n    case HostComponent:\n      {\n        popHostContext(interruptedWork);\n        break;\n      }\n\n    case HostPortal:\n      popHostContainer();\n      break;\n\n    case SuspenseComponent:\n      popSuspenseContext();\n      break;\n\n    case SuspenseListComponent:\n      popSuspenseContext();\n      break;\n\n    case ContextProvider:\n      const context = interruptedWork.type._context;\n      popProvider(context);\n      break;\n\n    case OffscreenComponent:\n    case LegacyHiddenComponent:\n      popRenderLanes();\n      break;\n  }\n}\n\n// Allows us to avoid traversing the return path to find the nearest Offscreen ancestor.\n// Only used when enableSuspenseLayoutEffectSemantics is enabled.\n\n\nlet offscreenSubtreeIsHidden = false;\nlet offscreenSubtreeWasHidden = false;\nconst PossiblyWeakSet = typeof WeakSet === 'function' ? WeakSet : Set;\nlet nextEffect = null; // Used for Profiling builds to track updaters.\n\nconst callComponentWillUnmountWithTimer = function (current, instance) {\n  instance.props = current.memoizedProps;\n  instance.state = current.memoizedState;\n\n  {\n    instance.componentWillUnmount();\n  }\n}; // Capture errors so they don't interrupt mounting.\n\n\nfunction safelyCallCommitHookLayoutEffectListMount(current, nearestMountedAncestor) {\n  try {\n    commitHookEffectListMount(Layout, current);\n  } catch (error) {\n    captureCommitPhaseError(current, nearestMountedAncestor, error);\n  }\n} // Capture errors so they don't interrupt unmounting.\n\n\nfunction safelyCallComponentWillUnmount(current, nearestMountedAncestor, instance) {\n  try {\n    callComponentWillUnmountWithTimer(current, instance);\n  } catch (error) {\n    captureCommitPhaseError(current, nearestMountedAncestor, error);\n  }\n} // Capture errors so they don't interrupt mounting.\n\n\nfunction safelyCallComponentDidMount(current, nearestMountedAncestor, instance) {\n  try {\n    instance.componentDidMount();\n  } catch (error) {\n    captureCommitPhaseError(current, nearestMountedAncestor, error);\n  }\n} // Capture errors so they don't interrupt mounting.\n\n\nfunction safelyAttachRef(current, nearestMountedAncestor) {\n  try {\n    commitAttachRef(current);\n  } catch (error) {\n    captureCommitPhaseError(current, nearestMountedAncestor, error);\n  }\n}\n\nfunction safelyDetachRef(current, nearestMountedAncestor) {\n  const ref = current.ref;\n\n  if (ref !== null) {\n    if (typeof ref === 'function') {\n      let retVal;\n\n      try {\n        if (enableProfilerTimer && enableProfilerCommitHooks && current.mode & ProfileMode) {\n          try {\n            startLayoutEffectTimer();\n            retVal = ref(null);\n          } finally {\n            recordLayoutEffectDuration(current);\n          }\n        } else {\n          retVal = ref(null);\n        }\n      } catch (error) {\n        captureCommitPhaseError(current, nearestMountedAncestor, error);\n      }\n    } else {\n      ref.current = null;\n    }\n  }\n}\n\nfunction safelyCallDestroy(current, nearestMountedAncestor, destroy) {\n  try {\n    destroy();\n  } catch (error) {\n    captureCommitPhaseError(current, nearestMountedAncestor, error);\n  }\n}\n\nlet focusedInstanceHandle = null;\nlet shouldFireAfterActiveInstanceBlur = false;\nfunction commitBeforeMutationEffects(root, firstChild) {\n  focusedInstanceHandle = prepareForCommit(root.containerInfo);\n  nextEffect = firstChild;\n  commitBeforeMutationEffects_begin(); // We no longer need to track the active instance fiber\n\n  const shouldFire = shouldFireAfterActiveInstanceBlur;\n  shouldFireAfterActiveInstanceBlur = false;\n  focusedInstanceHandle = null;\n  return shouldFire;\n}\n\nfunction commitBeforeMutationEffects_begin() {\n  while (nextEffect !== null) {\n    const fiber = nextEffect; // This phase is only used for beforeActiveInstanceBlur.\n\n    const child = fiber.child;\n\n    if ((fiber.subtreeFlags & BeforeMutationMask) !== NoFlags && child !== null) {\n      child.return = fiber;\n      nextEffect = child;\n    } else {\n      commitBeforeMutationEffects_complete();\n    }\n  }\n}\n\nfunction commitBeforeMutationEffects_complete() {\n  while (nextEffect !== null) {\n    const fiber = nextEffect;\n\n    try {\n      commitBeforeMutationEffectsOnFiber(fiber);\n    } catch (error) {\n      captureCommitPhaseError(fiber, fiber.return, error);\n    }\n    const sibling = fiber.sibling;\n\n    if (sibling !== null) {\n      sibling.return = fiber.return;\n      nextEffect = sibling;\n      return;\n    }\n\n    nextEffect = fiber.return;\n  }\n}\n\nfunction commitBeforeMutationEffectsOnFiber(finishedWork) {\n  const current = finishedWork.alternate;\n  const flags = finishedWork.flags;\n\n  if ((flags & Snapshot) !== NoFlags) {\n\n    switch (finishedWork.tag) {\n      case FunctionComponent:\n      case ForwardRef:\n      case SimpleMemoComponent:\n        {\n          break;\n        }\n\n      case ClassComponent:\n        {\n          if (current !== null) {\n            const prevProps = current.memoizedProps;\n            const prevState = current.memoizedState;\n            const instance = finishedWork.stateNode; // We could update instance props and state here,\n\n            const snapshot = instance.getSnapshotBeforeUpdate(finishedWork.elementType === finishedWork.type ? prevProps : resolveDefaultProps(finishedWork.type, prevProps), prevState);\n\n            instance.__reactInternalSnapshotBeforeUpdate = snapshot;\n          }\n\n          break;\n        }\n\n      case HostRoot:\n        {\n          {\n            const root = finishedWork.stateNode;\n            clearContainer(root.containerInfo);\n          }\n\n          break;\n        }\n\n      case HostComponent:\n      case HostText:\n      case HostPortal:\n      case IncompleteClassComponent:\n        // Nothing to do for these component types\n        break;\n\n      default:\n        {\n          throw Error(formatProdErrorMessage(163));\n        }\n    }\n  }\n}\n\nfunction commitHookEffectListUnmount(flags, finishedWork, nearestMountedAncestor) {\n  const updateQueue = finishedWork.updateQueue;\n  const lastEffect = updateQueue !== null ? updateQueue.lastEffect : null;\n\n  if (lastEffect !== null) {\n    const firstEffect = lastEffect.next;\n    let effect = firstEffect;\n\n    do {\n      if ((effect.tag & flags) === flags) {\n        // Unmount\n        const destroy = effect.destroy;\n        effect.destroy = undefined;\n\n        if (destroy !== undefined) {\n\n          safelyCallDestroy(finishedWork, nearestMountedAncestor, destroy);\n        }\n      }\n\n      effect = effect.next;\n    } while (effect !== firstEffect);\n  }\n}\n\nfunction commitHookEffectListMount(flags, finishedWork) {\n  const updateQueue = finishedWork.updateQueue;\n  const lastEffect = updateQueue !== null ? updateQueue.lastEffect : null;\n\n  if (lastEffect !== null) {\n    const firstEffect = lastEffect.next;\n    let effect = firstEffect;\n\n    do {\n      if ((effect.tag & flags) === flags) {\n\n\n        const create = effect.create;\n\n        effect.destroy = create();\n      }\n\n      effect = effect.next;\n    } while (effect !== firstEffect);\n  }\n}\n\nfunction commitLayoutEffectOnFiber(finishedRoot, current, finishedWork, committedLanes) {\n  if ((finishedWork.flags & LayoutMask) !== NoFlags) {\n    switch (finishedWork.tag) {\n      case FunctionComponent:\n      case ForwardRef:\n      case SimpleMemoComponent:\n        {\n          if ( !offscreenSubtreeWasHidden) {\n            // At this point layout effects have already been destroyed (during mutation phase).\n            // This is done to prevent sibling component effects from interfering with each other,\n            // e.g. a destroy function in one component should never override a ref set\n            // by a create function in another component during the same commit.\n            {\n              commitHookEffectListMount(Layout | HasEffect, finishedWork);\n            }\n          }\n\n          break;\n        }\n\n      case ClassComponent:\n        {\n          const instance = finishedWork.stateNode;\n\n          if (finishedWork.flags & Update) {\n            if (!offscreenSubtreeWasHidden) {\n              if (current === null) {\n\n                {\n                  instance.componentDidMount();\n                }\n              } else {\n                const prevProps = finishedWork.elementType === finishedWork.type ? current.memoizedProps : resolveDefaultProps(finishedWork.type, current.memoizedProps);\n                const prevState = current.memoizedState; // We could update instance props and state here,\n\n                {\n                  instance.componentDidUpdate(prevProps, prevState, instance.__reactInternalSnapshotBeforeUpdate);\n                }\n              }\n            }\n          } // TODO: I think this is now always non-null by the time it reaches the\n          // commit phase. Consider removing the type check.\n\n\n          const updateQueue = finishedWork.updateQueue;\n\n          if (updateQueue !== null) {\n            // but instead we rely on them being set during last render.\n            // TODO: revisit this when we implement resuming.\n\n\n            commitUpdateQueue(finishedWork, updateQueue, instance);\n          }\n\n          break;\n        }\n\n      case HostRoot:\n        {\n          // TODO: I think this is now always non-null by the time it reaches the\n          // commit phase. Consider removing the type check.\n          const updateQueue = finishedWork.updateQueue;\n\n          if (updateQueue !== null) {\n            let instance = null;\n\n            if (finishedWork.child !== null) {\n              switch (finishedWork.child.tag) {\n                case HostComponent:\n                  instance = getPublicInstance(finishedWork.child.stateNode);\n                  break;\n\n                case ClassComponent:\n                  instance = finishedWork.child.stateNode;\n                  break;\n              }\n            }\n\n            commitUpdateQueue(finishedWork, updateQueue, instance);\n          }\n\n          break;\n        }\n\n      case HostComponent:\n        {\n          const instance = finishedWork.stateNode; // Renderers may schedule work to be done after host components are mounted\n          // (eg DOM renderer may schedule auto-focus for inputs and form controls).\n          // These effects should only be committed when components are first mounted,\n          // aka when there is no current/alternate.\n\n          if (current === null && finishedWork.flags & Update) {\n            const type = finishedWork.type;\n            const props = finishedWork.memoizedProps;\n            commitMount(instance, type, props);\n          }\n\n          break;\n        }\n\n      case HostText:\n        {\n          // We have no life-cycles associated with text.\n          break;\n        }\n\n      case HostPortal:\n        {\n          // We have no life-cycles associated with portals.\n          break;\n        }\n\n      case Profiler:\n        {\n\n          break;\n        }\n\n      case SuspenseComponent:\n        {\n          commitSuspenseHydrationCallbacks(finishedRoot, finishedWork);\n          break;\n        }\n\n      case SuspenseListComponent:\n      case IncompleteClassComponent:\n      case ScopeComponent:\n      case OffscreenComponent:\n      case LegacyHiddenComponent:\n      case TracingMarkerComponent:\n        {\n          break;\n        }\n\n      default:\n        throw Error(formatProdErrorMessage(163));\n    }\n  }\n\n  if ( !offscreenSubtreeWasHidden) {\n    {\n      if (finishedWork.flags & Ref) {\n        commitAttachRef(finishedWork);\n      }\n    }\n  }\n}\n\nfunction reappearLayoutEffectsOnFiber(node) {\n  // Turn on layout effects in a tree that previously disappeared.\n  // TODO (Offscreen) Check: flags & LayoutStatic\n  switch (node.tag) {\n    case FunctionComponent:\n    case ForwardRef:\n    case SimpleMemoComponent:\n      {\n        {\n          safelyCallCommitHookLayoutEffectListMount(node, node.return);\n        }\n\n        break;\n      }\n\n    case ClassComponent:\n      {\n        const instance = node.stateNode;\n\n        if (typeof instance.componentDidMount === 'function') {\n          safelyCallComponentDidMount(node, node.return, instance);\n        }\n\n        safelyAttachRef(node, node.return);\n        break;\n      }\n\n    case HostComponent:\n      {\n        safelyAttachRef(node, node.return);\n        break;\n      }\n  }\n}\n\nfunction hideOrUnhideAllChildren(finishedWork, isHidden) {\n  // Only hide or unhide the top-most host nodes.\n  let hostSubtreeRoot = null;\n\n  {\n    // We only have the top Fiber that was inserted but we need to recurse down its\n    // children to find all the terminal nodes.\n    let node = finishedWork;\n\n    while (true) {\n      if (node.tag === HostComponent) {\n        if (hostSubtreeRoot === null) {\n          hostSubtreeRoot = node;\n\n          try {\n            const instance = node.stateNode;\n\n            if (isHidden) {\n              hideInstance(instance);\n            } else {\n              unhideInstance(node.stateNode, node.memoizedProps);\n            }\n          } catch (error) {\n            captureCommitPhaseError(finishedWork, finishedWork.return, error);\n          }\n        }\n      } else if (node.tag === HostText) {\n        if (hostSubtreeRoot === null) {\n          try {\n            const instance = node.stateNode;\n\n            if (isHidden) {\n              hideTextInstance(instance);\n            } else {\n              unhideTextInstance(instance, node.memoizedProps);\n            }\n          } catch (error) {\n            captureCommitPhaseError(finishedWork, finishedWork.return, error);\n          }\n        }\n      } else if ((node.tag === OffscreenComponent || node.tag === LegacyHiddenComponent) && node.memoizedState !== null && node !== finishedWork) ; else if (node.child !== null) {\n        node.child.return = node;\n        node = node.child;\n        continue;\n      }\n\n      if (node === finishedWork) {\n        return;\n      }\n\n      while (node.sibling === null) {\n        if (node.return === null || node.return === finishedWork) {\n          return;\n        }\n\n        if (hostSubtreeRoot === node) {\n          hostSubtreeRoot = null;\n        }\n\n        node = node.return;\n      }\n\n      if (hostSubtreeRoot === node) {\n        hostSubtreeRoot = null;\n      }\n\n      node.sibling.return = node.return;\n      node = node.sibling;\n    }\n  }\n}\n\nfunction commitAttachRef(finishedWork) {\n  const ref = finishedWork.ref;\n\n  if (ref !== null) {\n    const instance = finishedWork.stateNode;\n    let instanceToUse;\n\n    switch (finishedWork.tag) {\n      case HostComponent:\n        instanceToUse = getPublicInstance(instance);\n        break;\n\n      default:\n        instanceToUse = instance;\n    } // Moved outside to ensure DCE works with this flag\n\n    if (typeof ref === 'function') {\n      let retVal;\n\n      {\n        retVal = ref(instanceToUse);\n      }\n    } else {\n\n      ref.current = instanceToUse;\n    }\n  }\n}\n\nfunction detachFiberMutation(fiber) {\n  // Cut off the return pointer to disconnect it from the tree.\n  // This enables us to detect and warn against state updates on an unmounted component.\n  // It also prevents events from bubbling from within disconnected components.\n  //\n  // Ideally, we should also clear the child pointer of the parent alternate to let this\n  // get GC:ed but we don't know which for sure which parent is the current\n  // one so we'll settle for GC:ing the subtree of this child.\n  // This child itself will be GC:ed when the parent updates the next time.\n  //\n  // Note that we can't clear child or sibling pointers yet.\n  // They're needed for passive effects and for findDOMNode.\n  // We defer those fields, and all other cleanup, to the passive phase (see detachFiberAfterEffects).\n  //\n  // Don't reset the alternate yet, either. We need that so we can detach the\n  // alternate's fields in the passive phase. Clearing the return pointer is\n  // sufficient for findDOMNode semantics.\n  const alternate = fiber.alternate;\n\n  if (alternate !== null) {\n    alternate.return = null;\n  }\n\n  fiber.return = null;\n}\n\nfunction detachFiberAfterEffects(fiber) {\n  const alternate = fiber.alternate;\n\n  if (alternate !== null) {\n    fiber.alternate = null;\n    detachFiberAfterEffects(alternate);\n  } // Note: Defensively using negation instead of < in case\n  // `deletedTreeCleanUpLevel` is undefined.\n\n\n  {\n    // Clear cyclical Fiber fields. This level alone is designed to roughly\n    // approximate the planned Fiber refactor. In that world, `setState` will be\n    // bound to a special \"instance\" object instead of a Fiber. The Instance\n    // object will not have any of these fields. It will only be connected to\n    // the fiber tree via a single link at the root. So if this level alone is\n    // sufficient to fix memory issues, that bodes well for our plans.\n    fiber.child = null;\n    fiber.deletions = null;\n    fiber.sibling = null; // The `stateNode` is cyclical because on host nodes it points to the host\n    // tree, which has its own pointers to children, parents, and siblings.\n    // The other host nodes also point back to fibers, so we should detach that\n    // one, too.\n\n    if (fiber.tag === HostComponent) {\n      const hostInstance = fiber.stateNode;\n\n      if (hostInstance !== null) {\n        detachDeletedInstance(hostInstance);\n      }\n    }\n\n    fiber.stateNode = null; // I'm intentionally not clearing the `return` field in this level. We\n\n    {\n      // Theoretically, nothing in here should be necessary, because we already\n      // disconnected the fiber from the tree. So even if something leaks this\n      // particular fiber, it won't leak anything else\n      //\n      // The purpose of this branch is to be super aggressive so we can measure\n      // if there's any difference in memory impact. If there is, that could\n      // indicate a React leak we don't know about.\n      fiber.return = null;\n      fiber.dependencies = null;\n      fiber.memoizedProps = null;\n      fiber.memoizedState = null;\n      fiber.pendingProps = null;\n      fiber.stateNode = null; // TODO: Move to `commitPassiveUnmountInsideDeletedTreeOnFiber` instead.\n\n      fiber.updateQueue = null;\n    }\n  }\n}\n\nfunction getHostParentFiber(fiber) {\n  let parent = fiber.return;\n\n  while (parent !== null) {\n    if (isHostParent(parent)) {\n      return parent;\n    }\n\n    parent = parent.return;\n  }\n\n  throw Error(formatProdErrorMessage(160));\n}\n\nfunction isHostParent(fiber) {\n  return fiber.tag === HostComponent || fiber.tag === HostRoot || fiber.tag === HostPortal;\n}\n\nfunction getHostSibling(fiber) {\n  // We're going to search forward into the tree until we find a sibling host\n  // node. Unfortunately, if multiple insertions are done in a row we have to\n  // search past them. This leads to exponential search for the next sibling.\n  // TODO: Find a more efficient way to do this.\n  let node = fiber;\n\n  siblings: while (true) {\n    // If we didn't find anything, let's try the next sibling.\n    while (node.sibling === null) {\n      if (node.return === null || isHostParent(node.return)) {\n        // If we pop out of the root or hit the parent the fiber we are the\n        // last sibling.\n        return null;\n      }\n\n      node = node.return;\n    }\n\n    node.sibling.return = node.return;\n    node = node.sibling;\n\n    while (node.tag !== HostComponent && node.tag !== HostText && node.tag !== DehydratedFragment) {\n      // If it is not host node and, we might have a host node inside it.\n      // Try to search down until we find one.\n      if (node.flags & Placement) {\n        // If we don't have a child, try the siblings instead.\n        continue siblings;\n      } // If we don't have a child, try the siblings instead.\n      // We also skip portals because they are not part of this host tree.\n\n\n      if (node.child === null || node.tag === HostPortal) {\n        continue siblings;\n      } else {\n        node.child.return = node;\n        node = node.child;\n      }\n    } // Check if this host node is stable or about to be placed.\n\n\n    if (!(node.flags & Placement)) {\n      // Found it!\n      return node.stateNode;\n    }\n  }\n}\n\nfunction commitPlacement(finishedWork) {\n\n\n  const parentFiber = getHostParentFiber(finishedWork); // Note: these two variables *must* always be updated together.\n\n  switch (parentFiber.tag) {\n    case HostComponent:\n      {\n        const parent = parentFiber.stateNode;\n\n        if (parentFiber.flags & ContentReset) {\n          // Reset the text content of the parent before doing any insertions\n          resetTextContent(parent); // Clear ContentReset from the effect tag\n\n          parentFiber.flags &= ~ContentReset;\n        }\n\n        const before = getHostSibling(finishedWork); // We only have the top Fiber that was inserted but we need to recurse down its\n        // children to find all the terminal nodes.\n\n        insertOrAppendPlacementNode(finishedWork, before, parent);\n        break;\n      }\n\n    case HostRoot:\n    case HostPortal:\n      {\n        const parent = parentFiber.stateNode.containerInfo;\n        const before = getHostSibling(finishedWork);\n        insertOrAppendPlacementNodeIntoContainer(finishedWork, before, parent);\n        break;\n      }\n    // eslint-disable-next-line-no-fallthrough\n\n    default:\n      throw Error(formatProdErrorMessage(161));\n  }\n}\n\nfunction insertOrAppendPlacementNodeIntoContainer(node, before, parent) {\n  const tag = node.tag;\n  const isHost = tag === HostComponent || tag === HostText;\n\n  if (isHost) {\n    const stateNode = node.stateNode;\n\n    if (before) {\n      insertInContainerBefore(parent, stateNode, before);\n    } else {\n      appendChildToContainer(parent, stateNode);\n    }\n  } else if (tag === HostPortal) ; else {\n    const child = node.child;\n\n    if (child !== null) {\n      insertOrAppendPlacementNodeIntoContainer(child, before, parent);\n      let sibling = child.sibling;\n\n      while (sibling !== null) {\n        insertOrAppendPlacementNodeIntoContainer(sibling, before, parent);\n        sibling = sibling.sibling;\n      }\n    }\n  }\n}\n\nfunction insertOrAppendPlacementNode(node, before, parent) {\n  const tag = node.tag;\n  const isHost = tag === HostComponent || tag === HostText;\n\n  if (isHost) {\n    const stateNode = node.stateNode;\n\n    if (before) {\n      insertBefore(parent, stateNode, before);\n    } else {\n      appendChild(parent, stateNode);\n    }\n  } else if (tag === HostPortal) ; else {\n    const child = node.child;\n\n    if (child !== null) {\n      insertOrAppendPlacementNode(child, before, parent);\n      let sibling = child.sibling;\n\n      while (sibling !== null) {\n        insertOrAppendPlacementNode(sibling, before, parent);\n        sibling = sibling.sibling;\n      }\n    }\n  }\n} // These are tracked on the stack as we recursively traverse a\n// deleted subtree.\n// TODO: Update these during the whole mutation phase, not just during\n// a deletion.\n\n\nlet hostParent = null;\nlet hostParentIsContainer = false;\n\nfunction commitDeletionEffects(root, returnFiber, deletedFiber) {\n  {\n    // We only have the top Fiber that was deleted but we need to recurse down its\n    // children to find all the terminal nodes.\n    // Recursively delete all host nodes from the parent, detach refs, clean\n    // up mounted layout effects, and call componentWillUnmount.\n    // We only need to remove the topmost host child in each branch. But then we\n    // still need to keep traversing to unmount effects, refs, and cWU. TODO: We\n    // could split this into two separate traversals functions, where the second\n    // one doesn't include any removeChild logic. This is maybe the same\n    // function as \"disappearLayoutEffects\" (or whatever that turns into after\n    // the layout phase is refactored to use recursion).\n    // Before starting, find the nearest host parent on the stack so we know\n    // which instance/container to remove the children from.\n    // TODO: Instead of searching up the fiber return path on every deletion, we\n    // can track the nearest host component on the JS stack as we traverse the\n    // tree during the commit phase. This would make insertions faster, too.\n    let parent = returnFiber;\n\n    findParent: while (parent !== null) {\n      switch (parent.tag) {\n        case HostComponent:\n          {\n            hostParent = parent.stateNode;\n            hostParentIsContainer = false;\n            break findParent;\n          }\n\n        case HostRoot:\n          {\n            hostParent = parent.stateNode.containerInfo;\n            hostParentIsContainer = true;\n            break findParent;\n          }\n\n        case HostPortal:\n          {\n            hostParent = parent.stateNode.containerInfo;\n            hostParentIsContainer = true;\n            break findParent;\n          }\n      }\n\n      parent = parent.return;\n    }\n\n    if (hostParent === null) {\n      throw Error(formatProdErrorMessage(160));\n    }\n\n    commitDeletionEffectsOnFiber(root, returnFiber, deletedFiber);\n    hostParent = null;\n    hostParentIsContainer = false;\n  }\n\n  detachFiberMutation(deletedFiber);\n}\n\nfunction recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, parent) {\n  // TODO: Use a static flag to skip trees that don't have unmount effects\n  let child = parent.child;\n\n  while (child !== null) {\n    commitDeletionEffectsOnFiber(finishedRoot, nearestMountedAncestor, child);\n    child = child.sibling;\n  }\n}\n\nfunction commitDeletionEffectsOnFiber(finishedRoot, nearestMountedAncestor, deletedFiber) {\n  onCommitUnmount(deletedFiber); // The cases in this outer switch modify the stack before they traverse\n  // into their subtree. There are simpler cases in the inner switch\n  // that don't modify the stack.\n\n  switch (deletedFiber.tag) {\n    case HostComponent:\n      {\n        if (!offscreenSubtreeWasHidden) {\n          safelyDetachRef(deletedFiber, nearestMountedAncestor);\n        } // Intentional fallthrough to next branch\n\n      }\n    // eslint-disable-next-line-no-fallthrough\n\n    case HostText:\n      {\n        // We only need to remove the nearest host child. Set the host parent\n        // to `null` on the stack to indicate that nested children don't\n        // need to be removed.\n        {\n          const prevHostParent = hostParent;\n          const prevHostParentIsContainer = hostParentIsContainer;\n          hostParent = null;\n          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);\n          hostParent = prevHostParent;\n          hostParentIsContainer = prevHostParentIsContainer;\n\n          if (hostParent !== null) {\n            // Now that all the child effects have unmounted, we can remove the\n            // node from the tree.\n            if (hostParentIsContainer) {\n              removeChildFromContainer(hostParent, deletedFiber.stateNode);\n            } else {\n              removeChild(hostParent, deletedFiber.stateNode);\n            }\n          }\n        }\n\n        return;\n      }\n\n    case DehydratedFragment:\n      {\n        // Delete the dehydrated suspense boundary and all of its content.\n\n\n        {\n          if (hostParent !== null) {\n            if (hostParentIsContainer) {\n              clearSuspenseBoundaryFromContainer(hostParent, deletedFiber.stateNode);\n            } else {\n              clearSuspenseBoundary(hostParent, deletedFiber.stateNode);\n            }\n          }\n        }\n\n        return;\n      }\n\n    case HostPortal:\n      {\n        {\n          // When we go into a portal, it becomes the parent to remove from.\n          const prevHostParent = hostParent;\n          const prevHostParentIsContainer = hostParentIsContainer;\n          hostParent = deletedFiber.stateNode.containerInfo;\n          hostParentIsContainer = true;\n          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);\n          hostParent = prevHostParent;\n          hostParentIsContainer = prevHostParentIsContainer;\n        }\n\n        return;\n      }\n\n    case FunctionComponent:\n    case ForwardRef:\n    case MemoComponent:\n    case SimpleMemoComponent:\n      {\n        if (!offscreenSubtreeWasHidden) {\n          const updateQueue = deletedFiber.updateQueue;\n\n          if (updateQueue !== null) {\n            const lastEffect = updateQueue.lastEffect;\n\n            if (lastEffect !== null) {\n              const firstEffect = lastEffect.next;\n              let effect = firstEffect;\n\n              do {\n                const _effect = effect,\n                      destroy = _effect.destroy,\n                      tag = _effect.tag;\n\n                if (destroy !== undefined) {\n                  if ((tag & Insertion) !== NoFlags$1) {\n                    safelyCallDestroy(deletedFiber, nearestMountedAncestor, destroy);\n                  } else if ((tag & Layout) !== NoFlags$1) {\n\n                    {\n                      safelyCallDestroy(deletedFiber, nearestMountedAncestor, destroy);\n                    }\n                  }\n                }\n\n                effect = effect.next;\n              } while (effect !== firstEffect);\n            }\n          }\n        }\n\n        recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);\n        return;\n      }\n\n    case ClassComponent:\n      {\n        if (!offscreenSubtreeWasHidden) {\n          safelyDetachRef(deletedFiber, nearestMountedAncestor);\n          const instance = deletedFiber.stateNode;\n\n          if (typeof instance.componentWillUnmount === 'function') {\n            safelyCallComponentWillUnmount(deletedFiber, nearestMountedAncestor, instance);\n          }\n        }\n\n        recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);\n        return;\n      }\n\n    case ScopeComponent:\n      {\n\n        recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);\n        return;\n      }\n\n    case OffscreenComponent:\n      {\n        if ( // TODO: Remove this dead flag\n         deletedFiber.mode & ConcurrentMode) {\n          // If this offscreen component is hidden, we already unmounted it. Before\n          // deleting the children, track that it's already unmounted so that we\n          // don't attempt to unmount the effects again.\n          // TODO: If the tree is hidden, in most cases we should be able to skip\n          // over the nested children entirely. An exception is we haven't yet found\n          // the topmost host node to delete, which we already track on the stack.\n          // But the other case is portals, which need to be detached no matter how\n          // deeply they are nested. We should use a subtree flag to track whether a\n          // subtree includes a nested portal.\n          const prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;\n          offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden || deletedFiber.memoizedState !== null;\n          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);\n          offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;\n        } else {\n          recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);\n        }\n\n        break;\n      }\n\n    default:\n      {\n        recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, deletedFiber);\n        return;\n      }\n  }\n}\n\nfunction commitSuspenseCallback(finishedWork) {\n  // TODO: Move this to passive phase\n  const newState = finishedWork.memoizedState;\n}\n\nfunction commitSuspenseHydrationCallbacks(finishedRoot, finishedWork) {\n\n  const newState = finishedWork.memoizedState;\n\n  if (newState === null) {\n    const current = finishedWork.alternate;\n\n    if (current !== null) {\n      const prevState = current.memoizedState;\n\n      if (prevState !== null) {\n        const suspenseInstance = prevState.dehydrated;\n\n        if (suspenseInstance !== null) {\n          commitHydratedSuspenseInstance(suspenseInstance);\n        }\n      }\n    }\n  }\n}\n\nfunction attachSuspenseRetryListeners(finishedWork) {\n  // If this boundary just timed out, then it will have a set of wakeables.\n  // For each wakeable, attach a listener so that when it resolves, React\n  // attempts to re-render the boundary in the primary (pre-timeout) state.\n  const wakeables = finishedWork.updateQueue;\n\n  if (wakeables !== null) {\n    finishedWork.updateQueue = null;\n    let retryCache = finishedWork.stateNode;\n\n    if (retryCache === null) {\n      retryCache = finishedWork.stateNode = new PossiblyWeakSet();\n    }\n\n    wakeables.forEach(wakeable => {\n      // Memoize using the boundary fiber to prevent redundant listeners.\n      const retry = resolveRetryWakeable.bind(null, finishedWork, wakeable);\n\n      if (!retryCache.has(wakeable)) {\n        retryCache.add(wakeable);\n\n        wakeable.then(retry, retry);\n      }\n    });\n  }\n} // This function detects when a Suspense boundary goes from visible to hidden.\nfunction commitMutationEffects(root, finishedWork, committedLanes) {\n  commitMutationEffectsOnFiber(finishedWork, root);\n}\n\nfunction recursivelyTraverseMutationEffects(root, parentFiber, lanes) {\n  // Deletions effects can be scheduled on any fiber type. They need to happen\n  // before the children effects hae fired.\n  const deletions = parentFiber.deletions;\n\n  if (deletions !== null) {\n    for (let i = 0; i < deletions.length; i++) {\n      const childToDelete = deletions[i];\n\n      try {\n        commitDeletionEffects(root, parentFiber, childToDelete);\n      } catch (error) {\n        captureCommitPhaseError(childToDelete, parentFiber, error);\n      }\n    }\n  }\n\n  if (parentFiber.subtreeFlags & MutationMask) {\n    let child = parentFiber.child;\n\n    while (child !== null) {\n      commitMutationEffectsOnFiber(child, root);\n      child = child.sibling;\n    }\n  }\n}\n\nfunction commitMutationEffectsOnFiber(finishedWork, root, lanes) {\n  const current = finishedWork.alternate;\n  const flags = finishedWork.flags; // The effect flag should be checked *after* we refine the type of fiber,\n  // because the fiber tag is more specific. An exception is any flag related\n  // to reconcilation, because those can be set on all fiber types.\n\n  switch (finishedWork.tag) {\n    case FunctionComponent:\n    case ForwardRef:\n    case MemoComponent:\n    case SimpleMemoComponent:\n      {\n        recursivelyTraverseMutationEffects(root, finishedWork);\n        commitReconciliationEffects(finishedWork);\n\n        if (flags & Update) {\n          try {\n            commitHookEffectListUnmount(Insertion | HasEffect, finishedWork, finishedWork.return);\n            commitHookEffectListMount(Insertion | HasEffect, finishedWork);\n          } catch (error) {\n            captureCommitPhaseError(finishedWork, finishedWork.return, error);\n          } // Layout effects are destroyed during the mutation phase so that all\n          // destroy functions for all fibers are called before any create functions.\n          // This prevents sibling component effects from interfering with each other,\n          // e.g. a destroy function in one component should never override a ref set\n          // by a create function in another component during the same commit.\n\n\n          {\n            try {\n              commitHookEffectListUnmount(Layout | HasEffect, finishedWork, finishedWork.return);\n            } catch (error) {\n              captureCommitPhaseError(finishedWork, finishedWork.return, error);\n            }\n          }\n        }\n\n        return;\n      }\n\n    case ClassComponent:\n      {\n        recursivelyTraverseMutationEffects(root, finishedWork);\n        commitReconciliationEffects(finishedWork);\n\n        if (flags & Ref) {\n          if (current !== null) {\n            safelyDetachRef(current, current.return);\n          }\n        }\n\n        return;\n      }\n\n    case HostComponent:\n      {\n        recursivelyTraverseMutationEffects(root, finishedWork);\n        commitReconciliationEffects(finishedWork);\n\n        if (flags & Ref) {\n          if (current !== null) {\n            safelyDetachRef(current, current.return);\n          }\n        }\n\n        {\n          // TODO: ContentReset gets cleared by the children during the commit\n          // phase. This is a refactor hazard because it means we must read\n          // flags the flags after `commitReconciliationEffects` has already run;\n          // the order matters. We should refactor so that ContentReset does not\n          // rely on mutating the flag during commit. Like by setting a flag\n          // during the render phase instead.\n          if (finishedWork.flags & ContentReset) {\n            const instance = finishedWork.stateNode;\n\n            try {\n              resetTextContent(instance);\n            } catch (error) {\n              captureCommitPhaseError(finishedWork, finishedWork.return, error);\n            }\n          }\n\n          if (flags & Update) {\n            const instance = finishedWork.stateNode;\n\n            if (instance != null) {\n              // Commit the work prepared earlier.\n              const newProps = finishedWork.memoizedProps; // For hydration we reuse the update path but we treat the oldProps\n              // as the newProps. The updatePayload will contain the real change in\n              // this case.\n\n              const oldProps = current !== null ? current.memoizedProps : newProps;\n              const type = finishedWork.type; // TODO: Type the updateQueue to be specific to host components.\n\n              const updatePayload = finishedWork.updateQueue;\n              finishedWork.updateQueue = null;\n\n              if (updatePayload !== null) {\n                try {\n                  commitUpdate(instance, updatePayload, type, oldProps, newProps, finishedWork);\n                } catch (error) {\n                  captureCommitPhaseError(finishedWork, finishedWork.return, error);\n                }\n              }\n            }\n          }\n        }\n\n        return;\n      }\n\n    case HostText:\n      {\n        recursivelyTraverseMutationEffects(root, finishedWork);\n        commitReconciliationEffects(finishedWork);\n\n        if (flags & Update) {\n          {\n            if (finishedWork.stateNode === null) {\n              throw Error(formatProdErrorMessage(162));\n            }\n\n            const textInstance = finishedWork.stateNode;\n            const newText = finishedWork.memoizedProps; // For hydration we reuse the update path but we treat the oldProps\n            // as the newProps. The updatePayload will contain the real change in\n            // this case.\n\n            const oldText = current !== null ? current.memoizedProps : newText;\n\n            try {\n              commitTextUpdate(textInstance, oldText, newText);\n            } catch (error) {\n              captureCommitPhaseError(finishedWork, finishedWork.return, error);\n            }\n          }\n        }\n\n        return;\n      }\n\n    case HostRoot:\n      {\n        recursivelyTraverseMutationEffects(root, finishedWork);\n        commitReconciliationEffects(finishedWork);\n\n        if (flags & Update) {\n          {\n            if (current !== null) {\n              const prevRootState = current.memoizedState;\n\n              if (prevRootState.isDehydrated) {\n                try {\n                  commitHydratedContainer(root.containerInfo);\n                } catch (error) {\n                  captureCommitPhaseError(finishedWork, finishedWork.return, error);\n                }\n              }\n            }\n          }\n        }\n\n        return;\n      }\n\n    case HostPortal:\n      {\n        recursivelyTraverseMutationEffects(root, finishedWork);\n        commitReconciliationEffects(finishedWork);\n\n        return;\n      }\n\n    case SuspenseComponent:\n      {\n        recursivelyTraverseMutationEffects(root, finishedWork);\n        commitReconciliationEffects(finishedWork);\n        const offscreenFiber = finishedWork.child;\n\n        if (offscreenFiber.flags & Visibility) {\n          const offscreenInstance = offscreenFiber.stateNode;\n          const newState = offscreenFiber.memoizedState;\n          const isHidden = newState !== null; // Track the current state on the Offscreen instance so we can\n          // read it during an event\n\n          offscreenInstance.isHidden = isHidden;\n\n          if (isHidden) {\n            const wasHidden = offscreenFiber.alternate !== null && offscreenFiber.alternate.memoizedState !== null;\n\n            if (!wasHidden) {\n              // TODO: Move to passive phase\n              markCommitTimeOfFallback();\n            }\n          }\n        }\n\n        if (flags & Update) {\n          try {\n            commitSuspenseCallback(finishedWork);\n          } catch (error) {\n            captureCommitPhaseError(finishedWork, finishedWork.return, error);\n          }\n\n          attachSuspenseRetryListeners(finishedWork);\n        }\n\n        return;\n      }\n\n    case OffscreenComponent:\n      {\n        const wasHidden = current !== null && current.memoizedState !== null;\n\n        if ( // TODO: Remove this dead flag\n         finishedWork.mode & ConcurrentMode) {\n          // Before committing the children, track on the stack whether this\n          // offscreen subtree was already hidden, so that we don't unmount the\n          // effects again.\n          const prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;\n          offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden || wasHidden;\n          recursivelyTraverseMutationEffects(root, finishedWork);\n          offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;\n        } else {\n          recursivelyTraverseMutationEffects(root, finishedWork);\n        }\n\n        commitReconciliationEffects(finishedWork);\n\n        if (flags & Visibility) {\n          const offscreenInstance = finishedWork.stateNode;\n          const newState = finishedWork.memoizedState;\n          const isHidden = newState !== null;\n          const offscreenBoundary = finishedWork; // Track the current state on the Offscreen instance so we can\n          // read it during an event\n\n          offscreenInstance.isHidden = isHidden;\n\n          {\n            if (isHidden) {\n              if (!wasHidden) {\n                if ((offscreenBoundary.mode & ConcurrentMode) !== NoMode) {\n                  nextEffect = offscreenBoundary;\n                  let offscreenChild = offscreenBoundary.child;\n\n                  while (offscreenChild !== null) {\n                    nextEffect = offscreenChild;\n                    disappearLayoutEffects_begin(offscreenChild);\n                    offscreenChild = offscreenChild.sibling;\n                  }\n                }\n              }\n            }\n          }\n\n          {\n            // TODO: This needs to run whenever there's an insertion or update\n            // inside a hidden Offscreen tree.\n            hideOrUnhideAllChildren(offscreenBoundary, isHidden);\n          }\n        }\n\n        return;\n      }\n\n    case SuspenseListComponent:\n      {\n        recursivelyTraverseMutationEffects(root, finishedWork);\n        commitReconciliationEffects(finishedWork);\n\n        if (flags & Update) {\n          attachSuspenseRetryListeners(finishedWork);\n        }\n\n        return;\n      }\n\n    case ScopeComponent:\n      {\n\n        return;\n      }\n\n    default:\n      {\n        recursivelyTraverseMutationEffects(root, finishedWork);\n        commitReconciliationEffects(finishedWork);\n        return;\n      }\n  }\n}\n\nfunction commitReconciliationEffects(finishedWork) {\n  // Placement effects (insertions, reorders) can be scheduled on any fiber\n  // type. They needs to happen after the children effects have fired, but\n  // before the effects on this fiber have fired.\n  const flags = finishedWork.flags;\n\n  if (flags & Placement) {\n    try {\n      commitPlacement(finishedWork);\n    } catch (error) {\n      captureCommitPhaseError(finishedWork, finishedWork.return, error);\n    } // Clear the \"placement\" from effect tag so that we know that this is\n    // inserted, before any life-cycles like componentDidMount gets called.\n    // TODO: findDOMNode doesn't rely on this any more but isMounted does\n    // and isMounted is deprecated anyway so we should be able to kill this.\n\n\n    finishedWork.flags &= ~Placement;\n  }\n\n  if (flags & Hydrating) {\n    finishedWork.flags &= ~Hydrating;\n  }\n}\n\nfunction commitLayoutEffects(finishedWork, root, committedLanes) {\n  nextEffect = finishedWork;\n  commitLayoutEffects_begin(finishedWork, root, committedLanes);\n}\n\nfunction commitLayoutEffects_begin(subtreeRoot, root, committedLanes) {\n  // Suspense layout effects semantics don't change for legacy roots.\n  const isModernRoot = (subtreeRoot.mode & ConcurrentMode) !== NoMode;\n\n  while (nextEffect !== null) {\n    const fiber = nextEffect;\n    const firstChild = fiber.child;\n\n    if ( fiber.tag === OffscreenComponent && isModernRoot) {\n      // Keep track of the current Offscreen stack's state.\n      const isHidden = fiber.memoizedState !== null;\n      const newOffscreenSubtreeIsHidden = isHidden || offscreenSubtreeIsHidden;\n\n      if (newOffscreenSubtreeIsHidden) {\n        // The Offscreen tree is hidden. Skip over its layout effects.\n        commitLayoutMountEffects_complete(subtreeRoot, root, committedLanes);\n        continue;\n      } else {\n        // TODO (Offscreen) Also check: subtreeFlags & LayoutMask\n        const current = fiber.alternate;\n        const wasHidden = current !== null && current.memoizedState !== null;\n        const newOffscreenSubtreeWasHidden = wasHidden || offscreenSubtreeWasHidden;\n        const prevOffscreenSubtreeIsHidden = offscreenSubtreeIsHidden;\n        const prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden; // Traverse the Offscreen subtree with the current Offscreen as the root.\n\n        offscreenSubtreeIsHidden = newOffscreenSubtreeIsHidden;\n        offscreenSubtreeWasHidden = newOffscreenSubtreeWasHidden;\n\n        if (offscreenSubtreeWasHidden && !prevOffscreenSubtreeWasHidden) {\n          // This is the root of a reappearing boundary. Turn its layout effects\n          // back on.\n          nextEffect = fiber;\n          reappearLayoutEffects_begin(fiber);\n        }\n\n        let child = firstChild;\n\n        while (child !== null) {\n          nextEffect = child;\n          commitLayoutEffects_begin(child, // New root; bubble back up to here and stop.\n          root, committedLanes);\n          child = child.sibling;\n        } // Restore Offscreen state and resume in our-progress traversal.\n\n\n        nextEffect = fiber;\n        offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden;\n        offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;\n        commitLayoutMountEffects_complete(subtreeRoot, root, committedLanes);\n        continue;\n      }\n    }\n\n    if ((fiber.subtreeFlags & LayoutMask) !== NoFlags && firstChild !== null) {\n      firstChild.return = fiber;\n      nextEffect = firstChild;\n    } else {\n      commitLayoutMountEffects_complete(subtreeRoot, root, committedLanes);\n    }\n  }\n}\n\nfunction commitLayoutMountEffects_complete(subtreeRoot, root, committedLanes) {\n  while (nextEffect !== null) {\n    const fiber = nextEffect;\n\n    if ((fiber.flags & LayoutMask) !== NoFlags) {\n      const current = fiber.alternate;\n\n      try {\n        commitLayoutEffectOnFiber(root, current, fiber, committedLanes);\n      } catch (error) {\n        captureCommitPhaseError(fiber, fiber.return, error);\n      }\n    }\n\n    if (fiber === subtreeRoot) {\n      nextEffect = null;\n      return;\n    }\n\n    const sibling = fiber.sibling;\n\n    if (sibling !== null) {\n      sibling.return = fiber.return;\n      nextEffect = sibling;\n      return;\n    }\n\n    nextEffect = fiber.return;\n  }\n}\n\nfunction disappearLayoutEffects_begin(subtreeRoot) {\n  while (nextEffect !== null) {\n    const fiber = nextEffect;\n    const firstChild = fiber.child; // TODO (Offscreen) Check: flags & (RefStatic | LayoutStatic)\n\n    switch (fiber.tag) {\n      case FunctionComponent:\n      case ForwardRef:\n      case MemoComponent:\n      case SimpleMemoComponent:\n        {\n          {\n            commitHookEffectListUnmount(Layout, fiber, fiber.return);\n          }\n\n          break;\n        }\n\n      case ClassComponent:\n        {\n          // TODO (Offscreen) Check: flags & RefStatic\n          safelyDetachRef(fiber, fiber.return);\n          const instance = fiber.stateNode;\n\n          if (typeof instance.componentWillUnmount === 'function') {\n            safelyCallComponentWillUnmount(fiber, fiber.return, instance);\n          }\n\n          break;\n        }\n\n      case HostComponent:\n        {\n          safelyDetachRef(fiber, fiber.return);\n          break;\n        }\n\n      case OffscreenComponent:\n        {\n          // Check if this is a\n          const isHidden = fiber.memoizedState !== null;\n\n          if (isHidden) {\n            // Nested Offscreen tree is already hidden. Don't disappear\n            // its effects.\n            disappearLayoutEffects_complete(subtreeRoot);\n            continue;\n          }\n\n          break;\n        }\n    } // TODO (Offscreen) Check: subtreeFlags & LayoutStatic\n\n\n    if (firstChild !== null) {\n      firstChild.return = fiber;\n      nextEffect = firstChild;\n    } else {\n      disappearLayoutEffects_complete(subtreeRoot);\n    }\n  }\n}\n\nfunction disappearLayoutEffects_complete(subtreeRoot) {\n  while (nextEffect !== null) {\n    const fiber = nextEffect;\n\n    if (fiber === subtreeRoot) {\n      nextEffect = null;\n      return;\n    }\n\n    const sibling = fiber.sibling;\n\n    if (sibling !== null) {\n      sibling.return = fiber.return;\n      nextEffect = sibling;\n      return;\n    }\n\n    nextEffect = fiber.return;\n  }\n}\n\nfunction reappearLayoutEffects_begin(subtreeRoot) {\n  while (nextEffect !== null) {\n    const fiber = nextEffect;\n    const firstChild = fiber.child;\n\n    if (fiber.tag === OffscreenComponent) {\n      const isHidden = fiber.memoizedState !== null;\n\n      if (isHidden) {\n        // Nested Offscreen tree is still hidden. Don't re-appear its effects.\n        reappearLayoutEffects_complete(subtreeRoot);\n        continue;\n      }\n    } // TODO (Offscreen) Check: subtreeFlags & LayoutStatic\n\n\n    if (firstChild !== null) {\n      // This node may have been reused from a previous render, so we can't\n      // assume its return pointer is correct.\n      firstChild.return = fiber;\n      nextEffect = firstChild;\n    } else {\n      reappearLayoutEffects_complete(subtreeRoot);\n    }\n  }\n}\n\nfunction reappearLayoutEffects_complete(subtreeRoot) {\n  while (nextEffect !== null) {\n    const fiber = nextEffect; // TODO (Offscreen) Check: flags & LayoutStatic\n\n    try {\n      reappearLayoutEffectsOnFiber(fiber);\n    } catch (error) {\n      captureCommitPhaseError(fiber, fiber.return, error);\n    }\n\n    if (fiber === subtreeRoot) {\n      nextEffect = null;\n      return;\n    }\n\n    const sibling = fiber.sibling;\n\n    if (sibling !== null) {\n      // This node may have been reused from a previous render, so we can't\n      // assume its return pointer is correct.\n      sibling.return = fiber.return;\n      nextEffect = sibling;\n      return;\n    }\n\n    nextEffect = fiber.return;\n  }\n}\n\nfunction commitPassiveMountEffects(root, finishedWork, committedLanes, committedTransitions) {\n  nextEffect = finishedWork;\n  commitPassiveMountEffects_begin(finishedWork, root, committedLanes, committedTransitions);\n}\n\nfunction commitPassiveMountEffects_begin(subtreeRoot, root, committedLanes, committedTransitions) {\n  while (nextEffect !== null) {\n    const fiber = nextEffect;\n    const firstChild = fiber.child;\n\n    if ((fiber.subtreeFlags & PassiveMask) !== NoFlags && firstChild !== null) {\n      firstChild.return = fiber;\n      nextEffect = firstChild;\n    } else {\n      commitPassiveMountEffects_complete(subtreeRoot, root, committedLanes, committedTransitions);\n    }\n  }\n}\n\nfunction commitPassiveMountEffects_complete(subtreeRoot, root, committedLanes, committedTransitions) {\n  while (nextEffect !== null) {\n    const fiber = nextEffect;\n\n    if ((fiber.flags & Passive) !== NoFlags) {\n\n      try {\n        commitPassiveMountOnFiber(root, fiber, committedLanes, committedTransitions);\n      } catch (error) {\n        captureCommitPhaseError(fiber, fiber.return, error);\n      }\n    }\n\n    if (fiber === subtreeRoot) {\n      nextEffect = null;\n      return;\n    }\n\n    const sibling = fiber.sibling;\n\n    if (sibling !== null) {\n      sibling.return = fiber.return;\n      nextEffect = sibling;\n      return;\n    }\n\n    nextEffect = fiber.return;\n  }\n}\n\nfunction commitPassiveMountOnFiber(finishedRoot, finishedWork, committedLanes, committedTransitions) {\n  switch (finishedWork.tag) {\n    case FunctionComponent:\n    case ForwardRef:\n    case SimpleMemoComponent:\n      {\n        {\n          commitHookEffectListMount(Passive$1 | HasEffect, finishedWork);\n        }\n\n        break;\n      }\n  }\n}\n\nfunction commitPassiveUnmountEffects(firstChild) {\n  nextEffect = firstChild;\n  commitPassiveUnmountEffects_begin();\n}\n\nfunction commitPassiveUnmountEffects_begin() {\n  while (nextEffect !== null) {\n    const fiber = nextEffect;\n    const child = fiber.child;\n\n    if ((nextEffect.flags & ChildDeletion) !== NoFlags) {\n      const deletions = fiber.deletions;\n\n      if (deletions !== null) {\n        for (let i = 0; i < deletions.length; i++) {\n          const fiberToDelete = deletions[i];\n          nextEffect = fiberToDelete;\n          commitPassiveUnmountEffectsInsideOfDeletedTree_begin(fiberToDelete, fiber);\n        }\n\n        {\n          // A fiber was deleted from this parent fiber, but it's still part of\n          // the previous (alternate) parent fiber's list of children. Because\n          // children are a linked list, an earlier sibling that's still alive\n          // will be connected to the deleted fiber via its `alternate`:\n          //\n          //   live fiber\n          //   --alternate--> previous live fiber\n          //   --sibling--> deleted fiber\n          //\n          // We can't disconnect `alternate` on nodes that haven't been deleted\n          // yet, but we can disconnect the `sibling` and `child` pointers.\n          const previousFiber = fiber.alternate;\n\n          if (previousFiber !== null) {\n            let detachedChild = previousFiber.child;\n\n            if (detachedChild !== null) {\n              previousFiber.child = null;\n\n              do {\n                const detachedSibling = detachedChild.sibling;\n                detachedChild.sibling = null;\n                detachedChild = detachedSibling;\n              } while (detachedChild !== null);\n            }\n          }\n        }\n\n        nextEffect = fiber;\n      }\n    }\n\n    if ((fiber.subtreeFlags & PassiveMask) !== NoFlags && child !== null) {\n      child.return = fiber;\n      nextEffect = child;\n    } else {\n      commitPassiveUnmountEffects_complete();\n    }\n  }\n}\n\nfunction commitPassiveUnmountEffects_complete() {\n  while (nextEffect !== null) {\n    const fiber = nextEffect;\n\n    if ((fiber.flags & Passive) !== NoFlags) {\n      commitPassiveUnmountOnFiber(fiber);\n    }\n\n    const sibling = fiber.sibling;\n\n    if (sibling !== null) {\n      sibling.return = fiber.return;\n      nextEffect = sibling;\n      return;\n    }\n\n    nextEffect = fiber.return;\n  }\n}\n\nfunction commitPassiveUnmountOnFiber(finishedWork) {\n  switch (finishedWork.tag) {\n    case FunctionComponent:\n    case ForwardRef:\n    case SimpleMemoComponent:\n      {\n        {\n          commitHookEffectListUnmount(Passive$1 | HasEffect, finishedWork, finishedWork.return);\n        }\n\n        break;\n      }\n  }\n}\n\nfunction commitPassiveUnmountEffectsInsideOfDeletedTree_begin(deletedSubtreeRoot, nearestMountedAncestor) {\n  while (nextEffect !== null) {\n    const fiber = nextEffect; // Deletion effects fire in parent -> child order\n    commitPassiveUnmountInsideDeletedTreeOnFiber(fiber, nearestMountedAncestor);\n    const child = fiber.child; // TODO: Only traverse subtree if it has a PassiveStatic flag. (But, if we\n    // do this, still need to handle `deletedTreeCleanUpLevel` correctly.)\n\n    if (child !== null) {\n      child.return = fiber;\n      nextEffect = child;\n    } else {\n      commitPassiveUnmountEffectsInsideOfDeletedTree_complete(deletedSubtreeRoot);\n    }\n  }\n}\n\nfunction commitPassiveUnmountEffectsInsideOfDeletedTree_complete(deletedSubtreeRoot) {\n  while (nextEffect !== null) {\n    const fiber = nextEffect;\n    const sibling = fiber.sibling;\n    const returnFiber = fiber.return;\n\n    {\n      // Recursively traverse the entire deleted tree and clean up fiber fields.\n      // This is more aggressive than ideal, and the long term goal is to only\n      // have to detach the deleted tree at the root.\n      detachFiberAfterEffects(fiber);\n\n      if (fiber === deletedSubtreeRoot) {\n        nextEffect = null;\n        return;\n      }\n    }\n\n    if (sibling !== null) {\n      sibling.return = returnFiber;\n      nextEffect = sibling;\n      return;\n    }\n\n    nextEffect = returnFiber;\n  }\n}\n\nfunction commitPassiveUnmountInsideDeletedTreeOnFiber(current, nearestMountedAncestor) {\n  switch (current.tag) {\n    case FunctionComponent:\n    case ForwardRef:\n    case SimpleMemoComponent:\n      {\n        {\n          commitHookEffectListUnmount(Passive$1, current, nearestMountedAncestor);\n        }\n\n        break;\n      }\n  }\n} // TODO: Reuse reappearLayoutEffects traversal here?\n\nconst ReactCurrentActQueue = ReactSharedInternals.ReactCurrentActQueue;\n\nconst ceil = Math.ceil;\nconst ReactCurrentDispatcher$2 = ReactSharedInternals.ReactCurrentDispatcher,\n      ReactCurrentOwner$2 = ReactSharedInternals.ReactCurrentOwner,\n      ReactCurrentBatchConfig$3 = ReactSharedInternals.ReactCurrentBatchConfig,\n      ReactCurrentActQueue$1 = ReactSharedInternals.ReactCurrentActQueue;\nconst NoContext =\n/*             */\n0b000;\nconst BatchedContext =\n/*               */\n0b001;\nconst RenderContext =\n/*                */\n0b010;\nconst CommitContext =\n/*                */\n0b100;\nconst RootInProgress = 0;\nconst RootFatalErrored = 1;\nconst RootErrored = 2;\nconst RootSuspended = 3;\nconst RootSuspendedWithDelay = 4;\nconst RootCompleted = 5;\nconst RootDidNotComplete = 6; // Describes where we are in the React execution stack\n\nlet executionContext = NoContext; // The root we're working on\n\nlet workInProgressRoot = null; // The fiber we're working on\n\nlet workInProgress = null; // The lanes we're rendering\n\nlet workInProgressRootRenderLanes = NoLanes; // Stack that allows components to change the render lanes for its subtree\n// This is a superset of the lanes we started working on at the root. The only\n// case where it's different from `workInProgressRootRenderLanes` is when we\n// enter a subtree that is hidden and needs to be unhidden: Suspense and\n// Offscreen component.\n//\n// Most things in the work loop should deal with workInProgressRootRenderLanes.\n// Most things in begin/complete phases should deal with subtreeRenderLanes.\n\nlet subtreeRenderLanes = NoLanes;\nconst subtreeRenderLanesCursor = createCursor(NoLanes); // Whether to root completed, errored, suspended, etc.\n\nlet workInProgressRootExitStatus = RootInProgress; // A fatal error, if one is thrown\n\nlet workInProgressRootFatalError = null; // \"Included\" lanes refer to lanes that were worked on during this render. It's\n// slightly different than `renderLanes` because `renderLanes` can change as you\n// enter and exit an Offscreen tree. This value is the combination of all render\n// lanes for the entire render phase.\n\nlet workInProgressRootIncludedLanes = NoLanes; // The work left over by components that were visited during this render. Only\n// includes unprocessed updates, not work in bailed out children.\n\nlet workInProgressRootSkippedLanes = NoLanes; // Lanes that were updated (in an interleaved event) during this render.\n\nlet workInProgressRootInterleavedUpdatedLanes = NoLanes; // Lanes that were updated during the render phase (*not* an interleaved event).\n\nlet workInProgressRootPingedLanes = NoLanes; // Errors that are thrown during the render phase.\n\nlet workInProgressRootConcurrentErrors = null; // These are errors that we recovered from without surfacing them to the UI.\n// We will log them once the tree commits.\n\nlet workInProgressRootRecoverableErrors = null; // The most recent time we committed a fallback. This lets us ensure a train\n// model where we don't commit new loading states in too quick succession.\n\nlet globalMostRecentFallbackTime = 0;\nconst FALLBACK_THROTTLE_MS = 500; // The absolute time for when we should start giving up on rendering\n// more and prefer CPU suspense heuristics instead.\n\nlet workInProgressRootRenderTargetTime = Infinity; // How long a render is supposed to take before we start following CPU\n// suspense heuristics and opt out of rendering more content.\n\nconst RENDER_TIMEOUT_MS = 500;\nlet workInProgressTransitions = null;\n\nfunction resetRenderTimer() {\n  workInProgressRootRenderTargetTime = now() + RENDER_TIMEOUT_MS;\n}\n\nfunction getRenderTargetTime() {\n  return workInProgressRootRenderTargetTime;\n}\nlet hasUncaughtError = false;\nlet firstUncaughtError = null;\nlet legacyErrorBoundariesThatAlreadyFailed = null; // Only used when enableProfilerNestedUpdateScheduledHook is true;\nlet rootDoesHavePassiveEffects = false;\nlet rootWithPendingPassiveEffects = null;\nlet pendingPassiveEffectsLanes = NoLanes;\nlet pendingPassiveTransitions = null; // Use these to prevent an infinite loop of nested updates\n\nconst NESTED_UPDATE_LIMIT = 50;\nlet nestedUpdateCount = 0;\nlet rootWithNestedUpdates = null;\n// event times as simultaneous, even if the actual clock time has advanced\n// between the first and second call.\n\nlet currentEventTime = NoTimestamp;\nlet currentEventTransitionLane = NoLanes;\nfunction getWorkInProgressRoot() {\n  return workInProgressRoot;\n}\nfunction requestEventTime() {\n  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {\n    // We're inside React, so it's fine to read the actual time.\n    return now();\n  } // We're not inside React, so we may be in the middle of a browser event.\n\n\n  if (currentEventTime !== NoTimestamp) {\n    // Use the same start time for all updates until we enter React again.\n    return currentEventTime;\n  } // This is the first update since React yielded. Compute a new start time.\n\n\n  currentEventTime = now();\n  return currentEventTime;\n}\nfunction requestUpdateLane(fiber) {\n  // Special cases\n  const mode = fiber.mode;\n\n  if ((mode & ConcurrentMode) === NoMode) {\n    return SyncLane;\n  } else if ( (executionContext & RenderContext) !== NoContext && workInProgressRootRenderLanes !== NoLanes) {\n    // This is a render phase update. These are not officially supported. The\n    // old behavior is to give this the same \"thread\" (lanes) as\n    // whatever is currently rendering. So if you call `setState` on a component\n    // that happens later in the same render, it will flush. Ideally, we want to\n    // remove the special case and treat them as if they came from an\n    // interleaved event. Regardless, this pattern is not officially supported.\n    // This behavior is only a fallback. The flag only exists until we can roll\n    // out the setState warning, since existing code might accidentally rely on\n    // the current behavior.\n    return pickArbitraryLane(workInProgressRootRenderLanes);\n  }\n\n  const isTransition = requestCurrentTransition() !== NoTransition;\n\n  if (isTransition) {\n    // updates at the same priority within the same event. To do this, the\n    // inputs to the algorithm must be the same.\n    //\n    // The trick we use is to cache the first of each of these inputs within an\n    // event. Then reset the cached values once we can be sure the event is\n    // over. Our heuristic for that is whenever we enter a concurrent work loop.\n\n\n    if (currentEventTransitionLane === NoLane) {\n      // All transitions within the same event are assigned the same lane.\n      currentEventTransitionLane = claimNextTransitionLane();\n    }\n\n    return currentEventTransitionLane;\n  } // Updates originating inside certain React methods, like flushSync, have\n  // their priority set by tracking it with a context variable.\n  //\n  // The opaque type returned by the host config is internally a lane, so we can\n  // use that directly.\n  // TODO: Move this type conversion to the event priority module.\n\n\n  const updateLane = getCurrentUpdatePriority();\n\n  if (updateLane !== NoLane) {\n    return updateLane;\n  } // This update originated outside React. Ask the host environment for an\n  // appropriate priority, based on the type of event.\n  //\n  // The opaque type returned by the host config is internally a lane, so we can\n  // use that directly.\n  // TODO: Move this type conversion to the event priority module.\n\n\n  const eventLane = getCurrentEventPriority();\n  return eventLane;\n}\n\nfunction requestRetryLane(fiber) {\n  // This is a fork of `requestUpdateLane` designed specifically for Suspense\n  // \"retries\" — a special update that attempts to flip a Suspense boundary\n  // from its placeholder state to its primary/resolved state.\n  // Special cases\n  const mode = fiber.mode;\n\n  if ((mode & ConcurrentMode) === NoMode) {\n    return SyncLane;\n  }\n\n  return claimNextRetryLane();\n}\n\nfunction scheduleUpdateOnFiber(root, fiber, lane, eventTime) {\n  checkForNestedUpdates();\n\n\n  markRootUpdated(root, lane, eventTime);\n\n  if ((executionContext & RenderContext) !== NoLanes && root === workInProgressRoot) ; else {\n\n    if (root === workInProgressRoot) {\n      // Received an update to a tree that's in the middle of rendering. Mark\n      // that there was an interleaved update work on this root. Unless the\n      // `deferRenderPhaseUpdateToNextBatch` flag is off and this is a render\n      // phase update. In that case, we don't treat render phase updates as if\n      // they were interleaved, for backwards compat reasons.\n      if ( (executionContext & RenderContext) === NoContext) {\n        workInProgressRootInterleavedUpdatedLanes = mergeLanes(workInProgressRootInterleavedUpdatedLanes, lane);\n      }\n\n      if (workInProgressRootExitStatus === RootSuspendedWithDelay) {\n        // The root already suspended with a delay, which means this render\n        // definitely won't finish. Since we have a new update, let's mark it as\n        // suspended now, right before marking the incoming update. This has the\n        // effect of interrupting the current render and switching to the update.\n        // TODO: Make sure this doesn't override pings that happen while we've\n        // already started rendering.\n        markRootSuspended$1(root, workInProgressRootRenderLanes);\n      }\n    }\n\n    ensureRootIsScheduled(root, eventTime);\n\n    if (lane === SyncLane && executionContext === NoContext && (fiber.mode & ConcurrentMode) === NoMode && // Treat `act` as if it's inside `batchedUpdates`, even in legacy mode.\n    !(false )) {\n      // Flush the synchronous work now, unless we're already working or inside\n      // a batch. This is intentionally inside scheduleUpdateOnFiber instead of\n      // scheduleCallbackForFiber to preserve the ability to schedule a callback\n      // without immediately flushing it. We only do this for user-initiated\n      // updates, to preserve historical behavior of legacy mode.\n      resetRenderTimer();\n      flushSyncCallbacksOnlyInLegacyMode();\n    }\n  }\n}\nfunction scheduleInitialHydrationOnRoot(root, lane, eventTime) {\n  // This is a special fork of scheduleUpdateOnFiber that is only used to\n  // schedule the initial hydration of a root that has just been created. Most\n  // of the stuff in scheduleUpdateOnFiber can be skipped.\n  //\n  // The main reason for this separate path, though, is to distinguish the\n  // initial children from subsequent updates. In fully client-rendered roots\n  // (createRoot instead of hydrateRoot), all top-level renders are modeled as\n  // updates, but hydration roots are special because the initial render must\n  // match what was rendered on the server.\n  const current = root.current;\n  current.lanes = lane;\n  markRootUpdated(root, lane, eventTime);\n  ensureRootIsScheduled(root, eventTime);\n}\nfunction isUnsafeClassRenderPhaseUpdate(fiber) {\n  // Check if this is a render phase update. Only called by class components,\n  // which special (deprecated) behavior for UNSAFE_componentWillReceive props.\n  return (// TODO: Remove outdated deferRenderPhaseUpdateToNextBatch experiment. We\n    // decided not to enable it.\n     (executionContext & RenderContext) !== NoContext\n  );\n} // Use this function to schedule a task for a root. There's only one task per\n// root; if a task was already scheduled, we'll check to make sure the priority\n// of the existing task is the same as the priority of the next level that the\n// root has work on. This function is called on every update, and right before\n// exiting a task.\n\nfunction ensureRootIsScheduled(root, currentTime) {\n  const existingCallbackNode = root.callbackNode; // Check if any lanes are being starved by other work. If so, mark them as\n  // expired so we know to work on those next.\n\n  markStarvedLanesAsExpired(root, currentTime); // Determine the next lanes to work on, and their priority.\n\n  const nextLanes = getNextLanes(root, root === workInProgressRoot ? workInProgressRootRenderLanes : NoLanes);\n\n  if (nextLanes === NoLanes) {\n    // Special case: There's nothing to work on.\n    if (existingCallbackNode !== null) {\n      cancelCallback$1(existingCallbackNode);\n    }\n\n    root.callbackNode = null;\n    root.callbackPriority = NoLane;\n    return;\n  } // We use the highest priority lane to represent the priority of the callback.\n\n\n  const newCallbackPriority = getHighestPriorityLane(nextLanes); // Check if there's an existing task. We may be able to reuse it.\n\n  const existingCallbackPriority = root.callbackPriority;\n\n  if (existingCallbackPriority === newCallbackPriority && // Special case related to `act`. If the currently scheduled task is a\n  // Scheduler task, rather than an `act` task, cancel it and re-scheduled\n  // on the `act` queue.\n  !(false  )) {\n\n\n    return;\n  }\n\n  if (existingCallbackNode != null) {\n    // Cancel the existing callback. We'll schedule a new one below.\n    cancelCallback$1(existingCallbackNode);\n  } // Schedule a new callback.\n\n\n  let newCallbackNode;\n\n  if (newCallbackPriority === SyncLane) {\n    // Special case: Sync React callbacks are scheduled on a special\n    // internal queue\n    if (root.tag === LegacyRoot) {\n\n      scheduleLegacySyncCallback(performSyncWorkOnRoot.bind(null, root));\n    } else {\n      scheduleSyncCallback(performSyncWorkOnRoot.bind(null, root));\n    }\n\n    {\n      // Flush the queue in a microtask.\n      {\n        scheduleMicrotask(() => {\n          // In Safari, appending an iframe forces microtasks to run.\n          // https://github.com/facebook/react/issues/22459\n          // We don't support running callbacks in the middle of render\n          // or commit so we need to check against that.\n          if ((executionContext & (RenderContext | CommitContext)) === NoContext) {\n            // Note that this would still prematurely flush the callbacks\n            // if this happens outside render or commit phase (e.g. in an event).\n            flushSyncCallbacks();\n          }\n        });\n      }\n    }\n\n    newCallbackNode = null;\n  } else {\n    let schedulerPriorityLevel;\n\n    switch (lanesToEventPriority(nextLanes)) {\n      case DiscreteEventPriority:\n        schedulerPriorityLevel = ImmediatePriority;\n        break;\n\n      case ContinuousEventPriority:\n        schedulerPriorityLevel = UserBlockingPriority;\n        break;\n\n      case DefaultEventPriority:\n        schedulerPriorityLevel = NormalPriority;\n        break;\n\n      case IdleEventPriority:\n        schedulerPriorityLevel = IdlePriority;\n        break;\n\n      default:\n        schedulerPriorityLevel = NormalPriority;\n        break;\n    }\n\n    newCallbackNode = scheduleCallback$1(schedulerPriorityLevel, performConcurrentWorkOnRoot.bind(null, root));\n  }\n\n  root.callbackPriority = newCallbackPriority;\n  root.callbackNode = newCallbackNode;\n} // This is the entry point for every concurrent task, i.e. anything that\n// goes through Scheduler.\n\n\nfunction performConcurrentWorkOnRoot(root, didTimeout) {\n  // event time. The next update will compute a new event time.\n\n\n  currentEventTime = NoTimestamp;\n  currentEventTransitionLane = NoLanes;\n\n  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {\n    throw Error(formatProdErrorMessage(327));\n  } // Flush any pending passive effects before deciding which lanes to work on,\n  // in case they schedule additional work.\n\n\n  const originalCallbackNode = root.callbackNode;\n  const didFlushPassiveEffects = flushPassiveEffects();\n\n  if (didFlushPassiveEffects) {\n    // Something in the passive effect phase may have canceled the current task.\n    // Check if the task node for this root was changed.\n    if (root.callbackNode !== originalCallbackNode) {\n      // The current task was canceled. Exit. We don't need to call\n      // `ensureRootIsScheduled` because the check above implies either that\n      // there's a new task, or that there's no remaining work on this root.\n      return null;\n    }\n  } // Determine the next lanes to work on, using the fields stored\n  // on the root.\n\n\n  let lanes = getNextLanes(root, root === workInProgressRoot ? workInProgressRootRenderLanes : NoLanes);\n\n  if (lanes === NoLanes) {\n    // Defensive coding. This is never expected to happen.\n    return null;\n  } // We disable time-slicing in some cases: if the work has been CPU-bound\n  // for too long (\"expired\" work, to prevent starvation), or we're in\n  // sync-updates-by-default mode.\n  // TODO: We only check `didTimeout` defensively, to account for a Scheduler\n  // bug we're still investigating. Once the bug in Scheduler is fixed,\n  // we can remove this, since we track expiration ourselves.\n\n\n  const shouldTimeSlice = !includesBlockingLane(root, lanes) && !includesExpiredLane(root, lanes) && ( !didTimeout);\n  let exitStatus = shouldTimeSlice ? renderRootConcurrent(root, lanes) : renderRootSync(root, lanes);\n\n  if (exitStatus !== RootInProgress) {\n    if (exitStatus === RootErrored) {\n      // If something threw an error, try rendering one more time. We'll\n      // render synchronously to block concurrent data mutations, and we'll\n      // includes all pending updates are included. If it still fails after\n      // the second attempt, we'll give up and commit the resulting tree.\n      const errorRetryLanes = getLanesToRetrySynchronouslyOnError(root);\n\n      if (errorRetryLanes !== NoLanes) {\n        lanes = errorRetryLanes;\n        exitStatus = recoverFromConcurrentError(root, errorRetryLanes);\n      }\n    }\n\n    if (exitStatus === RootFatalErrored) {\n      const fatalError = workInProgressRootFatalError;\n      prepareFreshStack(root, NoLanes);\n      markRootSuspended$1(root, lanes);\n      ensureRootIsScheduled(root, now());\n      throw fatalError;\n    }\n\n    if (exitStatus === RootDidNotComplete) {\n      // The render unwound without completing the tree. This happens in special\n      // cases where need to exit the current render without producing a\n      // consistent tree or committing.\n      //\n      // This should only happen during a concurrent render, not a discrete or\n      // synchronous update. We should have already checked for this when we\n      // unwound the stack.\n      markRootSuspended$1(root, lanes);\n    } else {\n      // The render completed.\n      // Check if this render may have yielded to a concurrent event, and if so,\n      // confirm that any newly rendered stores are consistent.\n      // TODO: It's possible that even a concurrent render may never have yielded\n      // to the main thread, if it was fast enough, or if it expired. We could\n      // skip the consistency check in that case, too.\n      const renderWasConcurrent = !includesBlockingLane(root, lanes);\n      const finishedWork = root.current.alternate;\n\n      if (renderWasConcurrent && !isRenderConsistentWithExternalStores(finishedWork)) {\n        // A store was mutated in an interleaved event. Render again,\n        // synchronously, to block further mutations.\n        exitStatus = renderRootSync(root, lanes); // We need to check again if something threw\n\n        if (exitStatus === RootErrored) {\n          const errorRetryLanes = getLanesToRetrySynchronouslyOnError(root);\n\n          if (errorRetryLanes !== NoLanes) {\n            lanes = errorRetryLanes;\n            exitStatus = recoverFromConcurrentError(root, errorRetryLanes); // We assume the tree is now consistent because we didn't yield to any\n            // concurrent events.\n          }\n        }\n\n        if (exitStatus === RootFatalErrored) {\n          const fatalError = workInProgressRootFatalError;\n          prepareFreshStack(root, NoLanes);\n          markRootSuspended$1(root, lanes);\n          ensureRootIsScheduled(root, now());\n          throw fatalError;\n        }\n      } // We now have a consistent tree. The next step is either to commit it,\n      // or, if something suspended, wait to commit it after a timeout.\n\n\n      root.finishedWork = finishedWork;\n      root.finishedLanes = lanes;\n      finishConcurrentRender(root, exitStatus, lanes);\n    }\n  }\n\n  ensureRootIsScheduled(root, now());\n\n  if (root.callbackNode === originalCallbackNode) {\n    // The task node scheduled for this root is the same one that's\n    // currently executed. Need to return a continuation.\n    return performConcurrentWorkOnRoot.bind(null, root);\n  }\n\n  return null;\n}\n\nfunction recoverFromConcurrentError(root, errorRetryLanes) {\n  // If an error occurred during hydration, discard server response and fall\n  // back to client side render.\n  // Before rendering again, save the errors from the previous attempt.\n  const errorsFromFirstAttempt = workInProgressRootConcurrentErrors;\n\n  if (isRootDehydrated(root)) {\n    // The shell failed to hydrate. Set a flag to force a client rendering\n    // during the next attempt. To do this, we call prepareFreshStack now\n    // to create the root work-in-progress fiber. This is a bit weird in terms\n    // of factoring, because it relies on renderRootSync not calling\n    // prepareFreshStack again in the call below, which happens because the\n    // root and lanes haven't changed.\n    //\n    // TODO: I think what we should do is set ForceClientRender inside\n    // throwException, like we do for nested Suspense boundaries. The reason\n    // it's here instead is so we can switch to the synchronous work loop, too.\n    // Something to consider for a future refactor.\n    const rootWorkInProgress = prepareFreshStack(root, errorRetryLanes);\n    rootWorkInProgress.flags |= ForceClientRender;\n  }\n\n  const exitStatus = renderRootSync(root, errorRetryLanes);\n\n  if (exitStatus !== RootErrored) {\n    // Successfully finished rendering on retry\n    // The errors from the failed first attempt have been recovered. Add\n    // them to the collection of recoverable errors. We'll log them in the\n    // commit phase.\n    const errorsFromSecondAttempt = workInProgressRootRecoverableErrors;\n    workInProgressRootRecoverableErrors = errorsFromFirstAttempt; // The errors from the second attempt should be queued after the errors\n    // from the first attempt, to preserve the causal sequence.\n\n    if (errorsFromSecondAttempt !== null) {\n      queueRecoverableErrors(errorsFromSecondAttempt);\n    }\n  }\n\n  return exitStatus;\n}\n\nfunction queueRecoverableErrors(errors) {\n  if (workInProgressRootRecoverableErrors === null) {\n    workInProgressRootRecoverableErrors = errors;\n  } else {\n    workInProgressRootRecoverableErrors.push.apply(workInProgressRootRecoverableErrors, errors);\n  }\n}\n\nfunction finishConcurrentRender(root, exitStatus, lanes) {\n  switch (exitStatus) {\n    case RootInProgress:\n    case RootFatalErrored:\n      {\n        throw Error(formatProdErrorMessage(345));\n      }\n    // Flow knows about invariant, so it complains if I add a break\n    // statement, but eslint doesn't know about invariant, so it complains\n    // if I do. eslint-disable-next-line no-fallthrough\n\n    case RootErrored:\n      {\n        // We should have already attempted to retry this tree. If we reached\n        // this point, it errored again. Commit it.\n        commitRoot(root, workInProgressRootRecoverableErrors, workInProgressTransitions);\n        break;\n      }\n\n    case RootSuspended:\n      {\n        markRootSuspended$1(root, lanes); // We have an acceptable loading state. We need to figure out if we\n        // should immediately commit it or wait a bit.\n\n        if (includesOnlyRetries(lanes) && // do not delay if we're inside an act() scope\n        !shouldForceFlushFallbacksInDEV()) {\n          // This render only included retries, no updates. Throttle committing\n          // retries so that we don't show too many loading states too quickly.\n          const msUntilTimeout = globalMostRecentFallbackTime + FALLBACK_THROTTLE_MS - now(); // Don't bother with a very short suspense time.\n\n          if (msUntilTimeout > 10) {\n            const nextLanes = getNextLanes(root, NoLanes);\n\n            if (nextLanes !== NoLanes) {\n              // There's additional work on this root.\n              break;\n            }\n\n            const suspendedLanes = root.suspendedLanes;\n\n            if (!isSubsetOfLanes(suspendedLanes, lanes)) {\n              // We should prefer to render the fallback of at the last\n              // suspended level. Ping the last suspended level to try\n              // rendering it again.\n              // FIXME: What if the suspended lanes are Idle? Should not restart.\n              const eventTime = requestEventTime();\n              markRootPinged(root, suspendedLanes);\n              break;\n            } // The render is suspended, it hasn't timed out, and there's no\n            // lower priority work to do. Instead of committing the fallback\n            // immediately, wait for more data to arrive.\n\n\n            root.timeoutHandle = scheduleTimeout(commitRoot.bind(null, root, workInProgressRootRecoverableErrors, workInProgressTransitions), msUntilTimeout);\n            break;\n          }\n        } // The work expired. Commit immediately.\n\n\n        commitRoot(root, workInProgressRootRecoverableErrors, workInProgressTransitions);\n        break;\n      }\n\n    case RootSuspendedWithDelay:\n      {\n        markRootSuspended$1(root, lanes);\n\n        if (includesOnlyTransitions(lanes)) {\n          // This is a transition, so we should exit without committing a\n          // placeholder and without scheduling a timeout. Delay indefinitely\n          // until we receive more data.\n          break;\n        }\n\n        {\n          // This is not a transition, but we did trigger an avoided state.\n          // Schedule a placeholder to display after a short delay, using the Just\n          // Noticeable Difference.\n          // TODO: Is the JND optimization worth the added complexity? If this is\n          // the only reason we track the event time, then probably not.\n          // Consider removing.\n          const mostRecentEventTime = getMostRecentEventTime(root, lanes);\n          const eventTimeMs = mostRecentEventTime;\n          const timeElapsedMs = now() - eventTimeMs;\n          const msUntilTimeout = jnd(timeElapsedMs) - timeElapsedMs; // Don't bother with a very short suspense time.\n\n          if (msUntilTimeout > 10) {\n            // Instead of committing the fallback immediately, wait for more data\n            // to arrive.\n            root.timeoutHandle = scheduleTimeout(commitRoot.bind(null, root, workInProgressRootRecoverableErrors, workInProgressTransitions), msUntilTimeout);\n            break;\n          }\n        } // Commit the placeholder.\n\n\n        commitRoot(root, workInProgressRootRecoverableErrors, workInProgressTransitions);\n        break;\n      }\n\n    case RootCompleted:\n      {\n        // The work completed. Ready to commit.\n        commitRoot(root, workInProgressRootRecoverableErrors, workInProgressTransitions);\n        break;\n      }\n\n    default:\n      {\n        throw Error(formatProdErrorMessage(329));\n      }\n  }\n}\n\nfunction isRenderConsistentWithExternalStores(finishedWork) {\n  // Search the rendered tree for external store reads, and check whether the\n  // stores were mutated in a concurrent event. Intentionally using an iterative\n  // loop instead of recursion so we can exit early.\n  let node = finishedWork;\n\n  while (true) {\n    if (node.flags & StoreConsistency) {\n      const updateQueue = node.updateQueue;\n\n      if (updateQueue !== null) {\n        const checks = updateQueue.stores;\n\n        if (checks !== null) {\n          for (let i = 0; i < checks.length; i++) {\n            const check = checks[i];\n            const getSnapshot = check.getSnapshot;\n            const renderedValue = check.value;\n\n            try {\n              if (!objectIs(getSnapshot(), renderedValue)) {\n                // Found an inconsistent store.\n                return false;\n              }\n            } catch (error) {\n              // If `getSnapshot` throws, return `false`. This will schedule\n              // a re-render, and the error will be rethrown during render.\n              return false;\n            }\n          }\n        }\n      }\n    }\n\n    const child = node.child;\n\n    if (node.subtreeFlags & StoreConsistency && child !== null) {\n      child.return = node;\n      node = child;\n      continue;\n    }\n\n    if (node === finishedWork) {\n      return true;\n    }\n\n    while (node.sibling === null) {\n      if (node.return === null || node.return === finishedWork) {\n        return true;\n      }\n\n      node = node.return;\n    }\n\n    node.sibling.return = node.return;\n    node = node.sibling;\n  } // Flow doesn't know this is unreachable, but eslint does\n  // eslint-disable-next-line no-unreachable\n\n\n  return true;\n}\n\nfunction markRootSuspended$1(root, suspendedLanes) {\n  // When suspending, we should always exclude lanes that were pinged or (more\n  // rarely, since we try to avoid it) updated during the render phase.\n  // TODO: Lol maybe there's a better way to factor this besides this\n  // obnoxiously named function :)\n  suspendedLanes = removeLanes(suspendedLanes, workInProgressRootPingedLanes);\n  suspendedLanes = removeLanes(suspendedLanes, workInProgressRootInterleavedUpdatedLanes);\n  markRootSuspended(root, suspendedLanes);\n} // This is the entry point for synchronous tasks that don't go\n// through Scheduler\n\n\nfunction performSyncWorkOnRoot(root) {\n\n  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {\n    throw Error(formatProdErrorMessage(327));\n  }\n\n  flushPassiveEffects();\n  let lanes = getNextLanes(root, NoLanes);\n\n  if (!includesSomeLane(lanes, SyncLane)) {\n    // There's no remaining sync work left.\n    ensureRootIsScheduled(root, now());\n    return null;\n  }\n\n  let exitStatus = renderRootSync(root, lanes);\n\n  if (root.tag !== LegacyRoot && exitStatus === RootErrored) {\n    // If something threw an error, try rendering one more time. We'll render\n    // synchronously to block concurrent data mutations, and we'll includes\n    // all pending updates are included. If it still fails after the second\n    // attempt, we'll give up and commit the resulting tree.\n    const errorRetryLanes = getLanesToRetrySynchronouslyOnError(root);\n\n    if (errorRetryLanes !== NoLanes) {\n      lanes = errorRetryLanes;\n      exitStatus = recoverFromConcurrentError(root, errorRetryLanes);\n    }\n  }\n\n  if (exitStatus === RootFatalErrored) {\n    const fatalError = workInProgressRootFatalError;\n    prepareFreshStack(root, NoLanes);\n    markRootSuspended$1(root, lanes);\n    ensureRootIsScheduled(root, now());\n    throw fatalError;\n  }\n\n  if (exitStatus === RootDidNotComplete) {\n    throw Error(formatProdErrorMessage(345));\n  } // We now have a consistent tree. Because this is a sync render, we\n  // will commit it even if something suspended.\n\n\n  const finishedWork = root.current.alternate;\n  root.finishedWork = finishedWork;\n  root.finishedLanes = lanes;\n  commitRoot(root, workInProgressRootRecoverableErrors, workInProgressTransitions); // Before exiting, make sure there's a callback scheduled for the next\n  // pending level.\n\n  ensureRootIsScheduled(root, now());\n  return null;\n}\n\nfunction flushRoot(root, lanes) {\n  if (lanes !== NoLanes) {\n    markRootEntangled(root, mergeLanes(lanes, SyncLane));\n    ensureRootIsScheduled(root, now());\n\n    if ((executionContext & (RenderContext | CommitContext)) === NoContext) {\n      resetRenderTimer();\n      flushSyncCallbacks();\n    }\n  }\n}\nfunction batchedUpdates$1(fn, a) {\n  const prevExecutionContext = executionContext;\n  executionContext |= BatchedContext;\n\n  try {\n    return fn(a);\n  } finally {\n    executionContext = prevExecutionContext; // If there were legacy sync updates, flush them at the end of the outer\n    // most batchedUpdates-like method.\n\n    if (executionContext === NoContext && // Treat `act` as if it's inside `batchedUpdates`, even in legacy mode.\n    !(false )) {\n      resetRenderTimer();\n      flushSyncCallbacksOnlyInLegacyMode();\n    }\n  }\n}\nfunction discreteUpdates(fn, a, b, c, d) {\n  const previousPriority = getCurrentUpdatePriority();\n  const prevTransition = ReactCurrentBatchConfig$3.transition;\n\n  try {\n    ReactCurrentBatchConfig$3.transition = null;\n    setCurrentUpdatePriority(DiscreteEventPriority);\n    return fn(a, b, c, d);\n  } finally {\n    setCurrentUpdatePriority(previousPriority);\n    ReactCurrentBatchConfig$3.transition = prevTransition;\n\n    if (executionContext === NoContext) {\n      resetRenderTimer();\n    }\n  }\n} // Overload the definition to the two valid signatures.\n// Warning, this opts-out of checking the function body.\n\n// eslint-disable-next-line no-redeclare\nfunction flushSync(fn) {\n  // In legacy mode, we flush pending passive effects at the beginning of the\n  // next event, not at the end of the previous one.\n  if (rootWithPendingPassiveEffects !== null && rootWithPendingPassiveEffects.tag === LegacyRoot && (executionContext & (RenderContext | CommitContext)) === NoContext) {\n    flushPassiveEffects();\n  }\n\n  const prevExecutionContext = executionContext;\n  executionContext |= BatchedContext;\n  const prevTransition = ReactCurrentBatchConfig$3.transition;\n  const previousPriority = getCurrentUpdatePriority();\n\n  try {\n    ReactCurrentBatchConfig$3.transition = null;\n    setCurrentUpdatePriority(DiscreteEventPriority);\n\n    if (fn) {\n      return fn();\n    } else {\n      return undefined;\n    }\n  } finally {\n    setCurrentUpdatePriority(previousPriority);\n    ReactCurrentBatchConfig$3.transition = prevTransition;\n    executionContext = prevExecutionContext; // Flush the immediate callbacks that were scheduled during this batch.\n    // Note that this will happen even if batchedUpdates is higher up\n    // the stack.\n\n    if ((executionContext & (RenderContext | CommitContext)) === NoContext) {\n      flushSyncCallbacks();\n    }\n  }\n}\nfunction pushRenderLanes(fiber, lanes) {\n  push(subtreeRenderLanesCursor, subtreeRenderLanes);\n  subtreeRenderLanes = mergeLanes(subtreeRenderLanes, lanes);\n  workInProgressRootIncludedLanes = mergeLanes(workInProgressRootIncludedLanes, lanes);\n}\nfunction popRenderLanes(fiber) {\n  subtreeRenderLanes = subtreeRenderLanesCursor.current;\n  pop(subtreeRenderLanesCursor);\n}\n\nfunction prepareFreshStack(root, lanes) {\n  root.finishedWork = null;\n  root.finishedLanes = NoLanes;\n  const timeoutHandle = root.timeoutHandle;\n\n  if (timeoutHandle !== noTimeout) {\n    // The root previous suspended and scheduled a timeout to commit a fallback\n    // state. Now that we have additional work, cancel the timeout.\n    root.timeoutHandle = noTimeout; // $FlowFixMe Complains noTimeout is not a TimeoutID, despite the check above\n\n    cancelTimeout(timeoutHandle);\n  }\n\n  if (workInProgress !== null) {\n    let interruptedWork = workInProgress.return;\n\n    while (interruptedWork !== null) {\n      const current = interruptedWork.alternate;\n      unwindInterruptedWork(current, interruptedWork);\n      interruptedWork = interruptedWork.return;\n    }\n  }\n\n  workInProgressRoot = root;\n  const rootWorkInProgress = createWorkInProgress(root.current, null);\n  workInProgress = rootWorkInProgress;\n  workInProgressRootRenderLanes = subtreeRenderLanes = workInProgressRootIncludedLanes = lanes;\n  workInProgressRootExitStatus = RootInProgress;\n  workInProgressRootFatalError = null;\n  workInProgressRootSkippedLanes = NoLanes;\n  workInProgressRootInterleavedUpdatedLanes = NoLanes;\n  workInProgressRootPingedLanes = NoLanes;\n  workInProgressRootConcurrentErrors = null;\n  workInProgressRootRecoverableErrors = null;\n  finishQueueingConcurrentUpdates();\n\n  return rootWorkInProgress;\n}\n\nfunction handleError(root, thrownValue) {\n  do {\n    let erroredWork = workInProgress;\n\n    try {\n      // Reset module-level state that was set during the render phase.\n      resetContextDependencies();\n      resetHooksAfterThrow();\n      resetCurrentFiber(); // TODO: I found and added this missing line while investigating a\n      // separate issue. Write a regression test using string refs.\n\n      ReactCurrentOwner$2.current = null;\n\n      if (erroredWork === null || erroredWork.return === null) {\n        // Expected to be working on a non-root fiber. This is a fatal error\n        // because there's no ancestor that can handle it; the root is\n        // supposed to capture all errors that weren't caught by an error\n        // boundary.\n        workInProgressRootExitStatus = RootFatalErrored;\n        workInProgressRootFatalError = thrownValue; // Set `workInProgress` to null. This represents advancing to the next\n        // sibling, or the parent if there are no siblings. But since the root\n        // has no siblings nor a parent, we set it to null. Usually this is\n        // handled by `completeUnitOfWork` or `unwindWork`, but since we're\n        // intentionally not calling those, we need set it here.\n        // TODO: Consider calling `unwindWork` to pop the contexts.\n\n        workInProgress = null;\n        return;\n      }\n\n      if (enableProfilerTimer && erroredWork.mode & ProfileMode) {\n        // Record the time spent rendering before an error was thrown. This\n        // avoids inaccurate Profiler durations in the case of a\n        // suspended render.\n        stopProfilerTimerIfRunningAndRecordDelta(erroredWork, true);\n      }\n\n      if (enableSchedulingProfiler) {\n        markComponentRenderStopped();\n\n        if (thrownValue !== null && typeof thrownValue === 'object' && typeof thrownValue.then === 'function') {\n          const wakeable = thrownValue;\n          markComponentSuspended(erroredWork, wakeable, workInProgressRootRenderLanes);\n        } else {\n          markComponentErrored(erroredWork, thrownValue, workInProgressRootRenderLanes);\n        }\n      }\n\n      throwException(root, erroredWork.return, erroredWork, thrownValue, workInProgressRootRenderLanes);\n      completeUnitOfWork(erroredWork);\n    } catch (yetAnotherThrownValue) {\n      // Something in the return path also threw.\n      thrownValue = yetAnotherThrownValue;\n\n      if (workInProgress === erroredWork && erroredWork !== null) {\n        // If this boundary has already errored, then we had trouble processing\n        // the error. Bubble it to the next boundary.\n        erroredWork = erroredWork.return;\n        workInProgress = erroredWork;\n      } else {\n        erroredWork = workInProgress;\n      }\n\n      continue;\n    } // Return to the normal work loop.\n\n\n    return;\n  } while (true);\n}\n\nfunction pushDispatcher() {\n  const prevDispatcher = ReactCurrentDispatcher$2.current;\n  ReactCurrentDispatcher$2.current = ContextOnlyDispatcher;\n\n  if (prevDispatcher === null) {\n    // The React isomorphic package does not include a default dispatcher.\n    // Instead the first renderer will lazily attach one, in order to give\n    // nicer error messages.\n    return ContextOnlyDispatcher;\n  } else {\n    return prevDispatcher;\n  }\n}\n\nfunction popDispatcher(prevDispatcher) {\n  ReactCurrentDispatcher$2.current = prevDispatcher;\n}\n\nfunction markCommitTimeOfFallback() {\n  globalMostRecentFallbackTime = now();\n}\nfunction markSkippedUpdateLanes(lane) {\n  workInProgressRootSkippedLanes = mergeLanes(lane, workInProgressRootSkippedLanes);\n}\nfunction renderDidSuspend() {\n  if (workInProgressRootExitStatus === RootInProgress) {\n    workInProgressRootExitStatus = RootSuspended;\n  }\n}\nfunction renderDidSuspendDelayIfPossible() {\n  if (workInProgressRootExitStatus === RootInProgress || workInProgressRootExitStatus === RootSuspended || workInProgressRootExitStatus === RootErrored) {\n    workInProgressRootExitStatus = RootSuspendedWithDelay;\n  } // Check if there are updates that we skipped tree that might have unblocked\n  // this render.\n\n\n  if (workInProgressRoot !== null && (includesNonIdleWork(workInProgressRootSkippedLanes) || includesNonIdleWork(workInProgressRootInterleavedUpdatedLanes))) {\n    // Mark the current render as suspended so that we switch to working on\n    // the updates that were skipped. Usually we only suspend at the end of\n    // the render phase.\n    // TODO: We should probably always mark the root as suspended immediately\n    // (inside this function), since by suspending at the end of the render\n    // phase introduces a potential mistake where we suspend lanes that were\n    // pinged or updated while we were rendering.\n    markRootSuspended$1(workInProgressRoot, workInProgressRootRenderLanes);\n  }\n}\nfunction renderDidError(error) {\n  if (workInProgressRootExitStatus !== RootSuspendedWithDelay) {\n    workInProgressRootExitStatus = RootErrored;\n  }\n\n  if (workInProgressRootConcurrentErrors === null) {\n    workInProgressRootConcurrentErrors = [error];\n  } else {\n    workInProgressRootConcurrentErrors.push(error);\n  }\n} // Called during render to determine if anything has suspended.\n// Returns false if we're not sure.\n\nfunction renderHasNotSuspendedYet() {\n  // If something errored or completed, we can't really be sure,\n  // so those are false.\n  return workInProgressRootExitStatus === RootInProgress;\n}\n\nfunction renderRootSync(root, lanes) {\n  const prevExecutionContext = executionContext;\n  executionContext |= RenderContext;\n  const prevDispatcher = pushDispatcher(); // If the root or lanes have changed, throw out the existing stack\n  // and prepare a fresh one. Otherwise we'll continue where we left off.\n\n  if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes) {\n\n    workInProgressTransitions = getTransitionsForLanes();\n    prepareFreshStack(root, lanes);\n  }\n\n  do {\n    try {\n      workLoopSync();\n      break;\n    } catch (thrownValue) {\n      handleError(root, thrownValue);\n    }\n  } while (true);\n\n  resetContextDependencies();\n  executionContext = prevExecutionContext;\n  popDispatcher(prevDispatcher);\n\n  if (workInProgress !== null) {\n    // This is a sync render, so we should have finished the whole tree.\n    throw Error(formatProdErrorMessage(261));\n  }\n\n\n  workInProgressRoot = null;\n  workInProgressRootRenderLanes = NoLanes;\n  return workInProgressRootExitStatus;\n} // The work loop is an extremely hot path. Tell Closure not to inline it.\n\n/** @noinline */\n\n\nfunction workLoopSync() {\n  // Already timed out, so perform work without checking if we need to yield.\n  while (workInProgress !== null) {\n    performUnitOfWork(workInProgress);\n  }\n}\n\nfunction renderRootConcurrent(root, lanes) {\n  const prevExecutionContext = executionContext;\n  executionContext |= RenderContext;\n  const prevDispatcher = pushDispatcher(); // If the root or lanes have changed, throw out the existing stack\n  // and prepare a fresh one. Otherwise we'll continue where we left off.\n\n  if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes) {\n\n    workInProgressTransitions = getTransitionsForLanes();\n    resetRenderTimer();\n    prepareFreshStack(root, lanes);\n  }\n\n  do {\n    try {\n      workLoopConcurrent();\n      break;\n    } catch (thrownValue) {\n      handleError(root, thrownValue);\n    }\n  } while (true);\n\n  resetContextDependencies();\n  popDispatcher(prevDispatcher);\n  executionContext = prevExecutionContext;\n\n\n  if (workInProgress !== null) {\n\n    return RootInProgress;\n  } else {\n\n\n    workInProgressRoot = null;\n    workInProgressRootRenderLanes = NoLanes; // Return the final exit status.\n\n    return workInProgressRootExitStatus;\n  }\n}\n/** @noinline */\n\n\nfunction workLoopConcurrent() {\n  // Perform work until Scheduler asks us to yield\n  while (workInProgress !== null && !shouldYield()) {\n    performUnitOfWork(workInProgress);\n  }\n}\n\nfunction performUnitOfWork(unitOfWork) {\n  // The current, flushed, state of this fiber is the alternate. Ideally\n  // nothing should rely on this, but relying on it here means that we don't\n  // need an additional field on the work in progress.\n  const current = unitOfWork.alternate;\n  let next;\n\n  {\n    next = beginWork$1(current, unitOfWork, subtreeRenderLanes);\n  }\n  unitOfWork.memoizedProps = unitOfWork.pendingProps;\n\n  if (next === null) {\n    // If this doesn't spawn new work, complete the current work.\n    completeUnitOfWork(unitOfWork);\n  } else {\n    workInProgress = next;\n  }\n\n  ReactCurrentOwner$2.current = null;\n}\n\nfunction completeUnitOfWork(unitOfWork) {\n  // Attempt to complete the current unit of work, then move to the next\n  // sibling. If there are no more siblings, return to the parent fiber.\n  let completedWork = unitOfWork;\n\n  do {\n    // The current, flushed, state of this fiber is the alternate. Ideally\n    // nothing should rely on this, but relying on it here means that we don't\n    // need an additional field on the work in progress.\n    const current = completedWork.alternate;\n    const returnFiber = completedWork.return; // Check if the work completed or if something threw.\n\n    if ((completedWork.flags & Incomplete) === NoFlags) {\n      let next;\n\n      {\n        next = completeWork(current, completedWork, subtreeRenderLanes);\n      }\n\n      if (next !== null) {\n        // Completing this fiber spawned new work. Work on that next.\n        workInProgress = next;\n        return;\n      }\n    } else {\n      // This fiber did not complete because something threw. Pop values off\n      // the stack without entering the complete phase. If this is a boundary,\n      // capture values if possible.\n      const next = unwindWork(current, completedWork); // Because this fiber did not complete, don't reset its lanes.\n\n      if (next !== null) {\n        // If completing this work spawned new work, do that next. We'll come\n        // back here again.\n        // Since we're restarting, remove anything that is not a host effect\n        // from the effect tag.\n        next.flags &= HostEffectMask;\n        workInProgress = next;\n        return;\n      }\n\n      if (returnFiber !== null) {\n        // Mark the parent fiber as incomplete and clear its subtree flags.\n        returnFiber.flags |= Incomplete;\n        returnFiber.subtreeFlags = NoFlags;\n        returnFiber.deletions = null;\n      } else {\n        // We've unwound all the way to the root.\n        workInProgressRootExitStatus = RootDidNotComplete;\n        workInProgress = null;\n        return;\n      }\n    }\n\n    const siblingFiber = completedWork.sibling;\n\n    if (siblingFiber !== null) {\n      // If there is more work to do in this returnFiber, do that next.\n      workInProgress = siblingFiber;\n      return;\n    } // Otherwise, return to the parent\n\n\n    completedWork = returnFiber; // Update the next thing we're working on in case something throws.\n\n    workInProgress = completedWork;\n  } while (completedWork !== null); // We've reached the root.\n\n\n  if (workInProgressRootExitStatus === RootInProgress) {\n    workInProgressRootExitStatus = RootCompleted;\n  }\n}\n\nfunction commitRoot(root, recoverableErrors, transitions) {\n  // TODO: This no longer makes any sense. We already wrap the mutation and\n  // layout phases. Should be able to remove.\n  const previousUpdateLanePriority = getCurrentUpdatePriority();\n  const prevTransition = ReactCurrentBatchConfig$3.transition;\n\n  try {\n    ReactCurrentBatchConfig$3.transition = null;\n    setCurrentUpdatePriority(DiscreteEventPriority);\n    commitRootImpl(root, recoverableErrors, transitions, previousUpdateLanePriority);\n  } finally {\n    ReactCurrentBatchConfig$3.transition = prevTransition;\n    setCurrentUpdatePriority(previousUpdateLanePriority);\n  }\n\n  return null;\n}\n\nfunction commitRootImpl(root, recoverableErrors, transitions, renderPriorityLevel) {\n  do {\n    // `flushPassiveEffects` will call `flushSyncUpdateQueue` at the end, which\n    // means `flushPassiveEffects` will sometimes result in additional\n    // passive effects. So we need to keep flushing in a loop until there are\n    // no more pending effects.\n    // TODO: Might be better if `flushPassiveEffects` did not automatically\n    // flush synchronous work at the end, to avoid factoring hazards like this.\n    flushPassiveEffects();\n  } while (rootWithPendingPassiveEffects !== null);\n\n  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {\n    throw Error(formatProdErrorMessage(327));\n  }\n\n  const finishedWork = root.finishedWork;\n  const lanes = root.finishedLanes;\n\n  if (finishedWork === null) {\n\n    return null;\n  }\n\n  root.finishedWork = null;\n  root.finishedLanes = NoLanes;\n\n  if (finishedWork === root.current) {\n    throw Error(formatProdErrorMessage(177));\n  } // commitRoot never returns a continuation; it always finishes synchronously.\n  // So we can clear these now to allow a new callback to be scheduled.\n\n\n  root.callbackNode = null;\n  root.callbackPriority = NoLane; // Update the first and last pending times on this root. The new first\n  // pending time is whatever is left on the root fiber.\n\n  let remainingLanes = mergeLanes(finishedWork.lanes, finishedWork.childLanes);\n  markRootFinished(root, remainingLanes);\n\n  if (root === workInProgressRoot) {\n    // We can reset these now that they are finished.\n    workInProgressRoot = null;\n    workInProgress = null;\n    workInProgressRootRenderLanes = NoLanes;\n  } // If there are pending passive effects, schedule a callback to process them.\n  // Do this as early as possible, so it is queued before anything else that\n  // might get scheduled in the commit phase. (See #16714.)\n  // TODO: Delete all other places that schedule the passive effect callback\n  // They're redundant.\n\n\n  if ((finishedWork.subtreeFlags & PassiveMask) !== NoFlags || (finishedWork.flags & PassiveMask) !== NoFlags) {\n    if (!rootDoesHavePassiveEffects) {\n      rootDoesHavePassiveEffects = true;\n      // to store it in pendingPassiveTransitions until they get processed\n      // We need to pass this through as an argument to commitRoot\n      // because workInProgressTransitions might have changed between\n      // the previous render and commit if we throttle the commit\n      // with setTimeout\n\n      pendingPassiveTransitions = transitions;\n      scheduleCallback$1(NormalPriority, () => {\n        flushPassiveEffects(); // This render triggered passive effects: release the root cache pool\n        // *after* passive effects fire to avoid freeing a cache pool that may\n        // be referenced by a node in the tree (HostRoot, Cache boundary etc)\n\n        return null;\n      });\n    }\n  } // Check if there are any effects in the whole tree.\n  // TODO: This is left over from the effect list implementation, where we had\n  // to check for the existence of `firstEffect` to satisfy Flow. I think the\n  // only other reason this optimization exists is because it affects profiling.\n  // Reconsider whether this is necessary.\n\n\n  const subtreeHasEffects = (finishedWork.subtreeFlags & (BeforeMutationMask | MutationMask | LayoutMask | PassiveMask)) !== NoFlags;\n  const rootHasEffect = (finishedWork.flags & (BeforeMutationMask | MutationMask | LayoutMask | PassiveMask)) !== NoFlags;\n\n  if (subtreeHasEffects || rootHasEffect) {\n    const prevTransition = ReactCurrentBatchConfig$3.transition;\n    ReactCurrentBatchConfig$3.transition = null;\n    const previousPriority = getCurrentUpdatePriority();\n    setCurrentUpdatePriority(DiscreteEventPriority);\n    const prevExecutionContext = executionContext;\n    executionContext |= CommitContext; // Reset this to null before calling lifecycles\n\n    ReactCurrentOwner$2.current = null; // The commit phase is broken into several sub-phases. We do a separate pass\n    // of the effect list for each phase: all mutation effects come before all\n    // layout effects, and so on.\n    // The first phase a \"before mutation\" phase. We use this phase to read the\n    // state of the host tree right before we mutate it. This is where\n    // getSnapshotBeforeUpdate is called.\n\n    const shouldFireAfterActiveInstanceBlur = commitBeforeMutationEffects(root, finishedWork);\n\n\n    commitMutationEffects(root, finishedWork);\n\n    resetAfterCommit(root.containerInfo); // The work-in-progress tree is now the current tree. This must come after\n    // the mutation phase, so that the previous tree is still current during\n    // componentWillUnmount, but before the layout phase, so that the finished\n    // work is current during componentDidMount/Update.\n\n    root.current = finishedWork; // The next phase is the layout phase, where we call effects that read\n\n    commitLayoutEffects(finishedWork, root, lanes);\n    // opportunity to paint.\n\n\n    requestPaint();\n    executionContext = prevExecutionContext; // Reset the priority to the previous non-sync value.\n\n    setCurrentUpdatePriority(previousPriority);\n    ReactCurrentBatchConfig$3.transition = prevTransition;\n  } else {\n    // No effects.\n    root.current = finishedWork; // Measure these anyway so the flamegraph explicitly shows that there were\n  }\n\n  if (rootDoesHavePassiveEffects) {\n    // This commit has passive effects. Stash a reference to them. But don't\n    // schedule a callback until after flushing layout work.\n    rootDoesHavePassiveEffects = false;\n    rootWithPendingPassiveEffects = root;\n    pendingPassiveEffectsLanes = lanes;\n  } // Read this again, since an effect might have updated it\n\n\n  remainingLanes = root.pendingLanes; // Check if there's remaining work on this root\n  // TODO: This is part of the `componentDidCatch` implementation. Its purpose\n  // is to detect whether something might have called setState inside\n  // `componentDidCatch`. The mechanism is known to be flawed because `setState`\n  // inside `componentDidCatch` is itself flawed — that's why we recommend\n  // `getDerivedStateFromError` instead. However, it could be improved by\n  // checking if remainingLanes includes Sync work, instead of whether there's\n  // any work remaining at all (which would also include stuff like Suspense\n  // retries or transitions). It's been like this for a while, though, so fixing\n  // it probably isn't that urgent.\n\n  if (remainingLanes === NoLanes) {\n    // If there's no remaining work, we can clear the set of already failed\n    // error boundaries.\n    legacyErrorBoundariesThatAlreadyFailed = null;\n  }\n\n  onCommitRoot(finishedWork.stateNode, renderPriorityLevel);\n  // additional work on this root is scheduled.\n\n\n  ensureRootIsScheduled(root, now());\n\n  if (recoverableErrors !== null) {\n    // There were errors during this render, but recovered from them without\n    // needing to surface it to the UI. We log them here.\n    const onRecoverableError = root.onRecoverableError;\n\n    for (let i = 0; i < recoverableErrors.length; i++) {\n      const recoverableError = recoverableErrors[i];\n      const componentStack = recoverableError.stack;\n      const digest = recoverableError.digest;\n      onRecoverableError(recoverableError.value, {\n        componentStack,\n        digest\n      });\n    }\n  }\n\n  if (hasUncaughtError) {\n    hasUncaughtError = false;\n    const error = firstUncaughtError;\n    firstUncaughtError = null;\n    throw error;\n  } // If the passive effects are the result of a discrete render, flush them\n  // synchronously at the end of the current task so that the result is\n  // immediately observable. Otherwise, we assume that they are not\n  // order-dependent and do not need to be observed by external systems, so we\n  // can wait until after paint.\n  // TODO: We can optimize this by not scheduling the callback earlier. Since we\n  // currently schedule the callback in multiple places, will wait until those\n  // are consolidated.\n\n\n  if (includesSomeLane(pendingPassiveEffectsLanes, SyncLane) && root.tag !== LegacyRoot) {\n    flushPassiveEffects();\n  } // Read this again, since a passive effect might have updated it\n\n\n  remainingLanes = root.pendingLanes;\n\n  if (includesSomeLane(remainingLanes, SyncLane)) {\n    // finishing. If there are too many, it indicates an infinite update loop.\n\n\n    if (root === rootWithNestedUpdates) {\n      nestedUpdateCount++;\n    } else {\n      nestedUpdateCount = 0;\n      rootWithNestedUpdates = root;\n    }\n  } else {\n    nestedUpdateCount = 0;\n  } // If layout work was scheduled, flush it now.\n\n\n  flushSyncCallbacks();\n\n  return null;\n}\n\nfunction flushPassiveEffects() {\n  // Returns whether passive effects were flushed.\n  // TODO: Combine this check with the one in flushPassiveEFfectsImpl. We should\n  // probably just combine the two functions. I believe they were only separate\n  // in the first place because we used to wrap it with\n  // `Scheduler.runWithPriority`, which accepts a function. But now we track the\n  // priority within React itself, so we can mutate the variable directly.\n  if (rootWithPendingPassiveEffects !== null) {\n    const renderPriority = lanesToEventPriority(pendingPassiveEffectsLanes);\n    const priority = lowerEventPriority(DefaultEventPriority, renderPriority);\n    const prevTransition = ReactCurrentBatchConfig$3.transition;\n    const previousPriority = getCurrentUpdatePriority();\n\n    try {\n      ReactCurrentBatchConfig$3.transition = null;\n      setCurrentUpdatePriority(priority);\n      return flushPassiveEffectsImpl();\n    } finally {\n      setCurrentUpdatePriority(previousPriority);\n      ReactCurrentBatchConfig$3.transition = prevTransition; // Once passive effects have run for the tree - giving components a\n    }\n  }\n\n  return false;\n}\n\nfunction flushPassiveEffectsImpl() {\n  if (rootWithPendingPassiveEffects === null) {\n    return false;\n  } // Cache and clear the transitions flag\n\n\n  const transitions = pendingPassiveTransitions;\n  pendingPassiveTransitions = null;\n  const root = rootWithPendingPassiveEffects;\n  const lanes = pendingPassiveEffectsLanes;\n  rootWithPendingPassiveEffects = null; // TODO: This is sometimes out of sync with rootWithPendingPassiveEffects.\n  // Figure out why and fix it. It's not causing any known issues (probably\n  // because it's only used for profiling), but it's a refactor hazard.\n\n  pendingPassiveEffectsLanes = NoLanes;\n\n  if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {\n    throw Error(formatProdErrorMessage(331));\n  }\n\n  const prevExecutionContext = executionContext;\n  executionContext |= CommitContext;\n  commitPassiveUnmountEffects(root.current);\n  commitPassiveMountEffects(root, root.current, lanes, transitions); // TODO: Move to commitPassiveMountEffects\n\n  executionContext = prevExecutionContext;\n  flushSyncCallbacks();\n\n\n  onPostCommitRoot(root);\n\n  return true;\n}\n\nfunction isAlreadyFailedLegacyErrorBoundary(instance) {\n  return legacyErrorBoundariesThatAlreadyFailed !== null && legacyErrorBoundariesThatAlreadyFailed.has(instance);\n}\nfunction markLegacyErrorBoundaryAsFailed(instance) {\n  if (legacyErrorBoundariesThatAlreadyFailed === null) {\n    legacyErrorBoundariesThatAlreadyFailed = new Set([instance]);\n  } else {\n    legacyErrorBoundariesThatAlreadyFailed.add(instance);\n  }\n}\n\nfunction prepareToThrowUncaughtError(error) {\n  if (!hasUncaughtError) {\n    hasUncaughtError = true;\n    firstUncaughtError = error;\n  }\n}\n\nconst onUncaughtError = prepareToThrowUncaughtError;\n\nfunction captureCommitPhaseErrorOnRoot(rootFiber, sourceFiber, error) {\n  const errorInfo = createCapturedValueAtFiber(error, sourceFiber);\n  const update = createRootErrorUpdate(rootFiber, errorInfo, SyncLane);\n  const root = enqueueUpdate(rootFiber, update, SyncLane);\n  const eventTime = requestEventTime();\n\n  if (root !== null) {\n    markRootUpdated(root, SyncLane, eventTime);\n    ensureRootIsScheduled(root, eventTime);\n  }\n}\n\nfunction captureCommitPhaseError(sourceFiber, nearestMountedAncestor, error) {\n\n  if (sourceFiber.tag === HostRoot) {\n    // Error was thrown at the root. There is no parent, so the root\n    // itself should capture it.\n    captureCommitPhaseErrorOnRoot(sourceFiber, sourceFiber, error);\n    return;\n  }\n\n  let fiber = null;\n\n  {\n    fiber = nearestMountedAncestor;\n  }\n\n  while (fiber !== null) {\n    if (fiber.tag === HostRoot) {\n      captureCommitPhaseErrorOnRoot(fiber, sourceFiber, error);\n      return;\n    } else if (fiber.tag === ClassComponent) {\n      const ctor = fiber.type;\n      const instance = fiber.stateNode;\n\n      if (typeof ctor.getDerivedStateFromError === 'function' || typeof instance.componentDidCatch === 'function' && !isAlreadyFailedLegacyErrorBoundary(instance)) {\n        const errorInfo = createCapturedValueAtFiber(error, sourceFiber);\n        const update = createClassErrorUpdate(fiber, errorInfo, SyncLane);\n        const root = enqueueUpdate(fiber, update, SyncLane);\n        const eventTime = requestEventTime();\n\n        if (root !== null) {\n          markRootUpdated(root, SyncLane, eventTime);\n          ensureRootIsScheduled(root, eventTime);\n        }\n\n        return;\n      }\n    }\n\n    fiber = fiber.return;\n  }\n}\nfunction pingSuspendedRoot(root, wakeable, pingedLanes) {\n  const pingCache = root.pingCache;\n\n  if (pingCache !== null) {\n    // The wakeable resolved, so we no longer need to memoize, because it will\n    // never be thrown again.\n    pingCache.delete(wakeable);\n  }\n\n  const eventTime = requestEventTime();\n  markRootPinged(root, pingedLanes);\n\n  if (workInProgressRoot === root && isSubsetOfLanes(workInProgressRootRenderLanes, pingedLanes)) {\n    // Received a ping at the same priority level at which we're currently\n    // rendering. We might want to restart this render. This should mirror\n    // the logic of whether or not a root suspends once it completes.\n    // TODO: If we're rendering sync either due to Sync, Batched or expired,\n    // we should probably never restart.\n    // If we're suspended with delay, or if it's a retry, we'll always suspend\n    // so we can always restart.\n    if (workInProgressRootExitStatus === RootSuspendedWithDelay || workInProgressRootExitStatus === RootSuspended && includesOnlyRetries(workInProgressRootRenderLanes) && now() - globalMostRecentFallbackTime < FALLBACK_THROTTLE_MS) {\n      // Restart from the root.\n      prepareFreshStack(root, NoLanes);\n    } else {\n      // Even though we can't restart right now, we might get an\n      // opportunity later. So we mark this render as having a ping.\n      workInProgressRootPingedLanes = mergeLanes(workInProgressRootPingedLanes, pingedLanes);\n    }\n  }\n\n  ensureRootIsScheduled(root, eventTime);\n}\n\nfunction retryTimedOutBoundary(boundaryFiber, retryLane) {\n  // The boundary fiber (a Suspense component or SuspenseList component)\n  // previously was rendered in its fallback state. One of the promises that\n  // suspended it has resolved, which means at least part of the tree was\n  // likely unblocked. Try rendering again, at a new lanes.\n  if (retryLane === NoLane) {\n    // TODO: Assign this to `suspenseState.retryLane`? to avoid\n    // unnecessary entanglement?\n    retryLane = requestRetryLane(boundaryFiber);\n  } // TODO: Special case idle priority?\n\n\n  const eventTime = requestEventTime();\n  const root = enqueueConcurrentRenderForLane(boundaryFiber, retryLane);\n\n  if (root !== null) {\n    markRootUpdated(root, retryLane, eventTime);\n    ensureRootIsScheduled(root, eventTime);\n  }\n}\n\nfunction retryDehydratedSuspenseBoundary(boundaryFiber) {\n  const suspenseState = boundaryFiber.memoizedState;\n  let retryLane = NoLane;\n\n  if (suspenseState !== null) {\n    retryLane = suspenseState.retryLane;\n  }\n\n  retryTimedOutBoundary(boundaryFiber, retryLane);\n}\nfunction resolveRetryWakeable(boundaryFiber, wakeable) {\n  let retryLane = NoLane; // Default\n\n  let retryCache;\n\n  switch (boundaryFiber.tag) {\n    case SuspenseComponent:\n      retryCache = boundaryFiber.stateNode;\n      const suspenseState = boundaryFiber.memoizedState;\n\n      if (suspenseState !== null) {\n        retryLane = suspenseState.retryLane;\n      }\n\n      break;\n\n    case SuspenseListComponent:\n      retryCache = boundaryFiber.stateNode;\n      break;\n\n    default:\n      throw Error(formatProdErrorMessage(314));\n  }\n\n  if (retryCache !== null) {\n    // The wakeable resolved, so we no longer need to memoize, because it will\n    // never be thrown again.\n    retryCache.delete(wakeable);\n  }\n\n  retryTimedOutBoundary(boundaryFiber, retryLane);\n} // Computes the next Just Noticeable Difference (JND) boundary.\n// The theory is that a person can't tell the difference between small differences in time.\n// Therefore, if we wait a bit longer than necessary that won't translate to a noticeable\n// difference in the experience. However, waiting for longer might mean that we can avoid\n// showing an intermediate loading state. The longer we have already waited, the harder it\n// is to tell small differences in time. Therefore, the longer we've already waited,\n// the longer we can wait additionally. At some point we have to give up though.\n// We pick a train model where the next boundary commits at a consistent schedule.\n// These particular numbers are vague estimates. We expect to adjust them based on research.\n\nfunction jnd(timeElapsed) {\n  return timeElapsed < 120 ? 120 : timeElapsed < 480 ? 480 : timeElapsed < 1080 ? 1080 : timeElapsed < 1920 ? 1920 : timeElapsed < 3000 ? 3000 : timeElapsed < 4320 ? 4320 : ceil(timeElapsed / 1960) * 1960;\n}\n\nfunction checkForNestedUpdates() {\n  if (nestedUpdateCount > NESTED_UPDATE_LIMIT) {\n    nestedUpdateCount = 0;\n    rootWithNestedUpdates = null;\n    throw Error(formatProdErrorMessage(185));\n  }\n}\nlet beginWork$1;\n\n{\n  beginWork$1 = beginWork;\n}\n\nfunction scheduleCallback$1(priorityLevel, callback) {\n  {\n    // In production, always call Scheduler. This function will be stripped out.\n    return scheduleCallback(priorityLevel, callback);\n  }\n}\n\nfunction cancelCallback$1(callbackNode) {\n\n\n  return cancelCallback(callbackNode);\n}\n\nfunction shouldForceFlushFallbacksInDEV() {\n  // Never force flush in production. This function should get stripped out.\n  return false ;\n}\n\nfunction FiberNode(tag, pendingProps, key, mode) {\n  // Instance\n  this.tag = tag;\n  this.key = key;\n  this.elementType = null;\n  this.type = null;\n  this.stateNode = null; // Fiber\n\n  this.return = null;\n  this.child = null;\n  this.sibling = null;\n  this.index = 0;\n  this.ref = null;\n  this.pendingProps = pendingProps;\n  this.memoizedProps = null;\n  this.updateQueue = null;\n  this.memoizedState = null;\n  this.dependencies = null;\n  this.mode = mode; // Effects\n\n  this.flags = NoFlags;\n  this.subtreeFlags = NoFlags;\n  this.deletions = null;\n  this.lanes = NoLanes;\n  this.childLanes = NoLanes;\n  this.alternate = null;\n} // This is a constructor function, rather than a POJO constructor, still\n// please ensure we do the following:\n// 1) Nobody should add any instance methods on this. Instance methods can be\n//    more difficult to predict when they get optimized and they are almost\n//    never inlined properly in static compilers.\n// 2) Nobody should rely on `instanceof Fiber` for type testing. We should\n//    always know when it is a fiber.\n// 3) We might want to experiment with using numeric keys since they are easier\n//    to optimize in a non-JIT environment.\n// 4) We can easily go from a constructor to a createFiber object literal if that\n//    is faster.\n// 5) It should be easy to port this to a C struct and keep a C implementation\n//    compatible.\n\n\nconst createFiber = function (tag, pendingProps, key, mode) {\n  // $FlowFixMe: the shapes are exact here but Flow doesn't like constructors\n  return new FiberNode(tag, pendingProps, key, mode);\n};\n\nfunction shouldConstruct(Component) {\n  const prototype = Component.prototype;\n  return !!(prototype && prototype.isReactComponent);\n}\n\nfunction isSimpleFunctionComponent(type) {\n  return typeof type === 'function' && !shouldConstruct(type) && type.defaultProps === undefined;\n}\nfunction resolveLazyComponentTag(Component) {\n  if (typeof Component === 'function') {\n    return shouldConstruct(Component) ? ClassComponent : FunctionComponent;\n  } else if (Component !== undefined && Component !== null) {\n    const $$typeof = Component.$$typeof;\n\n    if ($$typeof === REACT_FORWARD_REF_TYPE) {\n      return ForwardRef;\n    }\n\n    if ($$typeof === REACT_MEMO_TYPE) {\n      return MemoComponent;\n    }\n  }\n\n  return IndeterminateComponent;\n} // This is used to create an alternate fiber to do work on.\n\nfunction createWorkInProgress(current, pendingProps) {\n  let workInProgress = current.alternate;\n\n  if (workInProgress === null) {\n    // We use a double buffering pooling technique because we know that we'll\n    // only ever need at most two versions of a tree. We pool the \"other\" unused\n    // node that we're free to reuse. This is lazily created to avoid allocating\n    // extra objects for things that are never updated. It also allow us to\n    // reclaim the extra memory if needed.\n    workInProgress = createFiber(current.tag, pendingProps, current.key, current.mode);\n    workInProgress.elementType = current.elementType;\n    workInProgress.type = current.type;\n    workInProgress.stateNode = current.stateNode;\n\n    workInProgress.alternate = current;\n    current.alternate = workInProgress;\n  } else {\n    workInProgress.pendingProps = pendingProps; // Needed because Blocks store data on type.\n\n    workInProgress.type = current.type; // We already have an alternate.\n    // Reset the effect tag.\n\n    workInProgress.flags = NoFlags; // The effects are no longer valid.\n\n    workInProgress.subtreeFlags = NoFlags;\n    workInProgress.deletions = null;\n  } // Reset all effects except static ones.\n  // Static effects are not specific to a render.\n\n\n  workInProgress.flags = current.flags & StaticMask;\n  workInProgress.childLanes = current.childLanes;\n  workInProgress.lanes = current.lanes;\n  workInProgress.child = current.child;\n  workInProgress.memoizedProps = current.memoizedProps;\n  workInProgress.memoizedState = current.memoizedState;\n  workInProgress.updateQueue = current.updateQueue; // Clone the dependencies object. This is mutated during the render phase, so\n  // it cannot be shared with the current fiber.\n\n  const currentDependencies = current.dependencies;\n  workInProgress.dependencies = currentDependencies === null ? null : {\n    lanes: currentDependencies.lanes,\n    firstContext: currentDependencies.firstContext\n  }; // These will be overridden during the parent's reconciliation\n\n  workInProgress.sibling = current.sibling;\n  workInProgress.index = current.index;\n  workInProgress.ref = current.ref;\n\n  return workInProgress;\n} // Used to reuse a Fiber for a second pass.\n\nfunction resetWorkInProgress(workInProgress, renderLanes) {\n  // This resets the Fiber to what createFiber or createWorkInProgress would\n  // have set the values to before during the first pass. Ideally this wouldn't\n  // be necessary but unfortunately many code paths reads from the workInProgress\n  // when they should be reading from current and writing to workInProgress.\n  // We assume pendingProps, index, key, ref, return are still untouched to\n  // avoid doing another reconciliation.\n  // Reset the effect flags but keep any Placement tags, since that's something\n  // that child fiber is setting, not the reconciliation.\n  workInProgress.flags &= StaticMask | Placement; // The effects are no longer valid.\n\n  const current = workInProgress.alternate;\n\n  if (current === null) {\n    // Reset to createFiber's initial values.\n    workInProgress.childLanes = NoLanes;\n    workInProgress.lanes = renderLanes;\n    workInProgress.child = null;\n    workInProgress.subtreeFlags = NoFlags;\n    workInProgress.memoizedProps = null;\n    workInProgress.memoizedState = null;\n    workInProgress.updateQueue = null;\n    workInProgress.dependencies = null;\n    workInProgress.stateNode = null;\n  } else {\n    // Reset to the cloned values that createWorkInProgress would've.\n    workInProgress.childLanes = current.childLanes;\n    workInProgress.lanes = current.lanes;\n    workInProgress.child = current.child;\n    workInProgress.subtreeFlags = NoFlags;\n    workInProgress.deletions = null;\n    workInProgress.memoizedProps = current.memoizedProps;\n    workInProgress.memoizedState = current.memoizedState;\n    workInProgress.updateQueue = current.updateQueue; // Needed because Blocks store data on type.\n\n    workInProgress.type = current.type; // Clone the dependencies object. This is mutated during the render phase, so\n    // it cannot be shared with the current fiber.\n\n    const currentDependencies = current.dependencies;\n    workInProgress.dependencies = currentDependencies === null ? null : {\n      lanes: currentDependencies.lanes,\n      firstContext: currentDependencies.firstContext\n    };\n  }\n\n  return workInProgress;\n}\nfunction createHostRootFiber(tag, isStrictMode, concurrentUpdatesByDefaultOverride) {\n  let mode;\n\n  if (tag === ConcurrentRoot) {\n    mode = ConcurrentMode;\n\n    if (isStrictMode === true) {\n      mode |= StrictLegacyMode;\n    }\n  } else {\n    mode = NoMode;\n  }\n\n  return createFiber(HostRoot, null, null, mode);\n}\nfunction createFiberFromTypeAndProps(type, // React$ElementType\nkey, pendingProps, owner, mode, lanes) {\n  let fiberTag = IndeterminateComponent; // The resolved type is set if we know what the final type will be. I.e. it's not lazy.\n\n  let resolvedType = type;\n\n  if (typeof type === 'function') {\n    if (shouldConstruct(type)) {\n      fiberTag = ClassComponent;\n    }\n  } else if (typeof type === 'string') {\n    fiberTag = HostComponent;\n  } else {\n    getTag: switch (type) {\n      case REACT_FRAGMENT_TYPE:\n        return createFiberFromFragment(pendingProps.children, mode, lanes, key);\n\n      case REACT_STRICT_MODE_TYPE:\n        fiberTag = Mode;\n        mode |= StrictLegacyMode;\n\n        break;\n\n      case REACT_PROFILER_TYPE:\n        return createFiberFromProfiler(pendingProps, mode, lanes, key);\n\n      case REACT_SUSPENSE_TYPE:\n        return createFiberFromSuspense(pendingProps, mode, lanes, key);\n\n      case REACT_SUSPENSE_LIST_TYPE:\n        return createFiberFromSuspenseList(pendingProps, mode, lanes, key);\n\n      case REACT_OFFSCREEN_TYPE:\n        return createFiberFromOffscreen(pendingProps, mode, lanes, key);\n\n      case REACT_LEGACY_HIDDEN_TYPE:\n\n      // eslint-disable-next-line no-fallthrough\n\n      case REACT_SCOPE_TYPE:\n\n      // eslint-disable-next-line no-fallthrough\n\n      case REACT_CACHE_TYPE:\n\n      // eslint-disable-next-line no-fallthrough\n\n      case REACT_TRACING_MARKER_TYPE:\n\n      // eslint-disable-next-line no-fallthrough\n\n      case REACT_DEBUG_TRACING_MODE_TYPE:\n\n      // eslint-disable-next-line no-fallthrough\n\n      default:\n        {\n          if (typeof type === 'object' && type !== null) {\n            switch (type.$$typeof) {\n              case REACT_PROVIDER_TYPE:\n                fiberTag = ContextProvider;\n                break getTag;\n\n              case REACT_CONTEXT_TYPE:\n                // This is a consumer\n                fiberTag = ContextConsumer;\n                break getTag;\n\n              case REACT_FORWARD_REF_TYPE:\n                fiberTag = ForwardRef;\n\n                break getTag;\n\n              case REACT_MEMO_TYPE:\n                fiberTag = MemoComponent;\n                break getTag;\n\n              case REACT_LAZY_TYPE:\n                fiberTag = LazyComponent;\n                resolvedType = null;\n                break getTag;\n            }\n          }\n\n          let info = '';\n\n          throw Error(formatProdErrorMessage(130, type == null ? type : typeof type, info));\n        }\n    }\n  }\n\n  const fiber = createFiber(fiberTag, pendingProps, key, mode);\n  fiber.elementType = type;\n  fiber.type = resolvedType;\n  fiber.lanes = lanes;\n\n  return fiber;\n}\nfunction createFiberFromElement(element, mode, lanes) {\n  let owner = null;\n\n  const type = element.type;\n  const key = element.key;\n  const pendingProps = element.props;\n  const fiber = createFiberFromTypeAndProps(type, key, pendingProps, owner, mode, lanes);\n\n  return fiber;\n}\nfunction createFiberFromFragment(elements, mode, lanes, key) {\n  const fiber = createFiber(Fragment, elements, key, mode);\n  fiber.lanes = lanes;\n  return fiber;\n}\n\nfunction createFiberFromProfiler(pendingProps, mode, lanes, key) {\n\n  const fiber = createFiber(Profiler, pendingProps, key, mode | ProfileMode);\n  fiber.elementType = REACT_PROFILER_TYPE;\n  fiber.lanes = lanes;\n\n  return fiber;\n}\n\nfunction createFiberFromSuspense(pendingProps, mode, lanes, key) {\n  const fiber = createFiber(SuspenseComponent, pendingProps, key, mode);\n  fiber.elementType = REACT_SUSPENSE_TYPE;\n  fiber.lanes = lanes;\n  return fiber;\n}\nfunction createFiberFromSuspenseList(pendingProps, mode, lanes, key) {\n  const fiber = createFiber(SuspenseListComponent, pendingProps, key, mode);\n  fiber.elementType = REACT_SUSPENSE_LIST_TYPE;\n  fiber.lanes = lanes;\n  return fiber;\n}\nfunction createFiberFromOffscreen(pendingProps, mode, lanes, key) {\n  const fiber = createFiber(OffscreenComponent, pendingProps, key, mode);\n  fiber.elementType = REACT_OFFSCREEN_TYPE;\n  fiber.lanes = lanes;\n  const primaryChildInstance = {\n    isHidden: false\n  };\n  fiber.stateNode = primaryChildInstance;\n  return fiber;\n}\nfunction createFiberFromText(content, mode, lanes) {\n  const fiber = createFiber(HostText, content, null, mode);\n  fiber.lanes = lanes;\n  return fiber;\n}\nfunction createFiberFromHostInstanceForDeletion() {\n  const fiber = createFiber(HostComponent, null, null, NoMode);\n  fiber.elementType = 'DELETED';\n  return fiber;\n}\nfunction createFiberFromDehydratedFragment(dehydratedNode) {\n  const fiber = createFiber(DehydratedFragment, null, null, NoMode);\n  fiber.stateNode = dehydratedNode;\n  return fiber;\n}\nfunction createFiberFromPortal(portal, mode, lanes) {\n  const pendingProps = portal.children !== null ? portal.children : [];\n  const fiber = createFiber(HostPortal, pendingProps, portal.key, mode);\n  fiber.lanes = lanes;\n  fiber.stateNode = {\n    containerInfo: portal.containerInfo,\n    pendingChildren: null,\n    // Used by persistent updates\n    implementation: portal.implementation\n  };\n  return fiber;\n} // Used for stashing WIP properties to replay failed work in DEV.\n\nfunction FiberRootNode(containerInfo, tag, hydrate, identifierPrefix, onRecoverableError) {\n  this.tag = tag;\n  this.containerInfo = containerInfo;\n  this.pendingChildren = null;\n  this.current = null;\n  this.pingCache = null;\n  this.finishedWork = null;\n  this.timeoutHandle = noTimeout;\n  this.context = null;\n  this.pendingContext = null;\n  this.callbackNode = null;\n  this.callbackPriority = NoLane;\n  this.eventTimes = createLaneMap(NoLanes);\n  this.expirationTimes = createLaneMap(NoTimestamp);\n  this.pendingLanes = NoLanes;\n  this.suspendedLanes = NoLanes;\n  this.pingedLanes = NoLanes;\n  this.expiredLanes = NoLanes;\n  this.mutableReadLanes = NoLanes;\n  this.finishedLanes = NoLanes;\n  this.entangledLanes = NoLanes;\n  this.entanglements = createLaneMap(NoLanes);\n  this.identifierPrefix = identifierPrefix;\n  this.onRecoverableError = onRecoverableError;\n\n  {\n    this.mutableSourceEagerHydrationData = null;\n  }\n}\n\nfunction createFiberRoot(containerInfo, tag, hydrate, initialChildren, hydrationCallbacks, isStrictMode, concurrentUpdatesByDefaultOverride, // TODO: We have several of these arguments that are conceptually part of the\n// host config, but because they are passed in at runtime, we have to thread\n// them through the root constructor. Perhaps we should put them all into a\n// single type, like a DynamicHostConfig that is defined by the renderer.\nidentifierPrefix, onRecoverableError, transitionCallbacks) {\n  const root = new FiberRootNode(containerInfo, tag, hydrate, identifierPrefix, onRecoverableError);\n  // stateNode is any.\n\n\n  const uninitializedFiber = createHostRootFiber(tag, isStrictMode);\n  root.current = uninitializedFiber;\n  uninitializedFiber.stateNode = root;\n\n  {\n    const initialState = {\n      element: initialChildren,\n      isDehydrated: hydrate,\n      cache: null,\n      // not enabled yet\n      transitions: null,\n      pendingSuspenseBoundaries: null\n    };\n    uninitializedFiber.memoizedState = initialState;\n  }\n\n  initializeUpdateQueue(uninitializedFiber);\n  return root;\n}\n\nvar ReactVersion = '18.2.0';\n\nfunction createPortal(children, containerInfo, // TODO: figure out the API for cross-renderer implementation.\nimplementation) {\n  let key = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;\n\n  return {\n    // This tag allow us to uniquely identify this as a React Portal\n    $$typeof: REACT_PORTAL_TYPE,\n    key: key == null ? null : '' + key,\n    children,\n    containerInfo,\n    implementation\n  };\n}\n\nfunction getContextForSubtree(parentComponent) {\n  if (!parentComponent) {\n    return emptyContextObject;\n  }\n\n  const fiber = get(parentComponent);\n  const parentContext = findCurrentUnmaskedContext(fiber);\n\n  if (fiber.tag === ClassComponent) {\n    const Component = fiber.type;\n\n    if (isContextProvider(Component)) {\n      return processChildContext(fiber, Component, parentContext);\n    }\n  }\n\n  return parentContext;\n}\n\nfunction findHostInstance(component) {\n  const fiber = get(component);\n\n  if (fiber === undefined) {\n    if (typeof component.render === 'function') {\n      throw Error(formatProdErrorMessage(188));\n    } else {\n      const keys = Object.keys(component).join(',');\n      throw Error(formatProdErrorMessage(268, keys));\n    }\n  }\n\n  const hostFiber = findCurrentHostFiber(fiber);\n\n  if (hostFiber === null) {\n    return null;\n  }\n\n  return hostFiber.stateNode;\n}\n\nfunction createContainer(containerInfo, tag, hydrationCallbacks, isStrictMode, concurrentUpdatesByDefaultOverride, identifierPrefix, onRecoverableError, transitionCallbacks) {\n  const hydrate = false;\n  const initialChildren = null;\n  return createFiberRoot(containerInfo, tag, hydrate, initialChildren, hydrationCallbacks, isStrictMode, concurrentUpdatesByDefaultOverride, identifierPrefix, onRecoverableError);\n}\nfunction createHydrationContainer(initialChildren, // TODO: Remove `callback` when we delete legacy mode.\ncallback, containerInfo, tag, hydrationCallbacks, isStrictMode, concurrentUpdatesByDefaultOverride, identifierPrefix, onRecoverableError, transitionCallbacks) {\n  const hydrate = true;\n  const root = createFiberRoot(containerInfo, tag, hydrate, initialChildren, hydrationCallbacks, isStrictMode, concurrentUpdatesByDefaultOverride, identifierPrefix, onRecoverableError); // TODO: Move this to FiberRoot constructor\n\n  root.context = getContextForSubtree(null); // Schedule the initial render. In a hydration root, this is different from\n  // a regular update because the initial render must match was was rendered\n  // on the server.\n  // NOTE: This update intentionally doesn't have a payload. We're only using\n  // the update to schedule work on the root fiber (and, for legacy roots, to\n  // enqueue the callback if one is provided).\n\n  const current = root.current;\n  const eventTime = requestEventTime();\n  const lane = requestUpdateLane(current);\n  const update = createUpdate(eventTime, lane);\n  update.callback = callback !== undefined && callback !== null ? callback : null;\n  enqueueUpdate(current, update, lane);\n  scheduleInitialHydrationOnRoot(root, lane, eventTime);\n  return root;\n}\nfunction updateContainer(element, container, parentComponent, callback) {\n\n  const current = container.current;\n  const eventTime = requestEventTime();\n  const lane = requestUpdateLane(current);\n\n  const context = getContextForSubtree(parentComponent);\n\n  if (container.context === null) {\n    container.context = context;\n  } else {\n    container.pendingContext = context;\n  }\n\n  const update = createUpdate(eventTime, lane); // Caution: React DevTools currently depends on this property\n  // being called \"element\".\n\n  update.payload = {\n    element\n  };\n  callback = callback === undefined ? null : callback;\n\n  if (callback !== null) {\n\n    update.callback = callback;\n  }\n\n  const root = enqueueUpdate(current, update, lane);\n\n  if (root !== null) {\n    scheduleUpdateOnFiber(root, current, lane, eventTime);\n    entangleTransitions(root, current, lane);\n  }\n\n  return lane;\n}\nfunction getPublicRootInstance(container) {\n  const containerFiber = container.current;\n\n  if (!containerFiber.child) {\n    return null;\n  }\n\n  switch (containerFiber.child.tag) {\n    case HostComponent:\n      return getPublicInstance(containerFiber.child.stateNode);\n\n    default:\n      return containerFiber.child.stateNode;\n  }\n}\nfunction attemptSynchronousHydration$1(fiber) {\n  switch (fiber.tag) {\n    case HostRoot:\n      {\n        const root = fiber.stateNode;\n\n        if (isRootDehydrated(root)) {\n          // Flush the first scheduled \"update\".\n          const lanes = getHighestPriorityPendingLanes(root);\n          flushRoot(root, lanes);\n        }\n\n        break;\n      }\n\n    case SuspenseComponent:\n      {\n        flushSync(() => {\n          const root = enqueueConcurrentRenderForLane(fiber, SyncLane);\n\n          if (root !== null) {\n            const eventTime = requestEventTime();\n            scheduleUpdateOnFiber(root, fiber, SyncLane, eventTime);\n          }\n        }); // If we're still blocked after this, we need to increase\n        // the priority of any promises resolving within this\n        // boundary so that they next attempt also has higher pri.\n\n        const retryLane = SyncLane;\n        markRetryLaneIfNotHydrated(fiber, retryLane);\n        break;\n      }\n  }\n}\n\nfunction markRetryLaneImpl(fiber, retryLane) {\n  const suspenseState = fiber.memoizedState;\n\n  if (suspenseState !== null && suspenseState.dehydrated !== null) {\n    suspenseState.retryLane = higherPriorityLane(suspenseState.retryLane, retryLane);\n  }\n} // Increases the priority of thenables when they resolve within this boundary.\n\n\nfunction markRetryLaneIfNotHydrated(fiber, retryLane) {\n  markRetryLaneImpl(fiber, retryLane);\n  const alternate = fiber.alternate;\n\n  if (alternate) {\n    markRetryLaneImpl(alternate, retryLane);\n  }\n}\nfunction attemptContinuousHydration$1(fiber) {\n  if (fiber.tag !== SuspenseComponent) {\n    // We ignore HostRoots here because we can't increase\n    // their priority and they should not suspend on I/O,\n    // since you have to wrap anything that might suspend in\n    // Suspense.\n    return;\n  }\n\n  const lane = SelectiveHydrationLane;\n  const root = enqueueConcurrentRenderForLane(fiber, lane);\n\n  if (root !== null) {\n    const eventTime = requestEventTime();\n    scheduleUpdateOnFiber(root, fiber, lane, eventTime);\n  }\n\n  markRetryLaneIfNotHydrated(fiber, lane);\n}\nfunction attemptHydrationAtCurrentPriority$1(fiber) {\n  if (fiber.tag !== SuspenseComponent) {\n    // We ignore HostRoots here because we can't increase\n    // their priority other than synchronously flush it.\n    return;\n  }\n\n  const lane = requestUpdateLane(fiber);\n  const root = enqueueConcurrentRenderForLane(fiber, lane);\n\n  if (root !== null) {\n    const eventTime = requestEventTime();\n    scheduleUpdateOnFiber(root, fiber, lane, eventTime);\n  }\n\n  markRetryLaneIfNotHydrated(fiber, lane);\n}\nlet overrideHookState = null;\nlet overrideHookStateDeletePath = null;\nlet overrideHookStateRenamePath = null;\nlet overrideProps = null;\nlet overridePropsDeletePath = null;\nlet overridePropsRenamePath = null;\nlet scheduleUpdate = null;\nlet setErrorHandler = null;\nlet setSuspenseHandler = null;\n\nfunction findHostInstanceByFiber(fiber) {\n  const hostFiber = findCurrentHostFiber(fiber);\n\n  if (hostFiber === null) {\n    return null;\n  }\n\n  return hostFiber.stateNode;\n}\n\nfunction emptyFindFiberByHostInstance(instance) {\n  return null;\n}\n\nfunction injectIntoDevTools(devToolsConfig) {\n  const findFiberByHostInstance = devToolsConfig.findFiberByHostInstance;\n  const ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;\n  return injectInternals({\n    bundleType: devToolsConfig.bundleType,\n    version: devToolsConfig.version,\n    rendererPackageName: devToolsConfig.rendererPackageName,\n    rendererConfig: devToolsConfig.rendererConfig,\n    overrideHookState,\n    overrideHookStateDeletePath,\n    overrideHookStateRenamePath,\n    overrideProps,\n    overridePropsDeletePath,\n    overridePropsRenamePath,\n    setErrorHandler,\n    setSuspenseHandler,\n    scheduleUpdate,\n    currentDispatcherRef: ReactCurrentDispatcher,\n    findHostInstanceByFiber,\n    findFiberByHostInstance: findFiberByHostInstance || emptyFindFiberByHostInstance,\n    // React Refresh\n    findHostInstancesForRefresh:  null,\n    scheduleRefresh:  null,\n    scheduleRoot:  null,\n    setRefreshHandler:  null,\n    // Enables DevTools to append owner stacks to error messages in DEV mode.\n    getCurrentFiber:  null,\n    // Enables DevTools to detect reconciler version rather than renderer version\n    // which may not match for third party renderers.\n    reconcilerVersion: '18.2.0-next-9e3b772b8-20220608'\n  });\n}\n\n/* global reportError */\n\nconst defaultOnRecoverableError = typeof reportError === 'function' ? // In modern browsers, reportError will dispatch an error event,\n// emulating an uncaught JavaScript error.\nreportError : error => {\n  // In older browsers and test environments, fallback to console.error.\n  // eslint-disable-next-line react-internal/no-production-logging\n  console['error'](error);\n};\n\nfunction ReactDOMRoot(internalRoot) {\n  this._internalRoot = internalRoot;\n}\n\nReactDOMHydrationRoot.prototype.render = ReactDOMRoot.prototype.render = function (children) {\n  const root = this._internalRoot;\n\n  if (root === null) {\n    throw Error(formatProdErrorMessage(409));\n  }\n\n  updateContainer(children, root, null, null);\n};\n\nReactDOMHydrationRoot.prototype.unmount = ReactDOMRoot.prototype.unmount = function () {\n\n  const root = this._internalRoot;\n\n  if (root !== null) {\n    this._internalRoot = null;\n    const container = root.containerInfo;\n\n    flushSync(() => {\n      updateContainer(null, root, null, null);\n    });\n    unmarkContainerAsRoot(container);\n  }\n};\n\nfunction createRoot(container, options) {\n  if (!isValidContainer(container)) {\n    throw Error(formatProdErrorMessage(299));\n  }\n  let isStrictMode = false;\n  let concurrentUpdatesByDefaultOverride = false;\n  let identifierPrefix = '';\n  let onRecoverableError = defaultOnRecoverableError;\n  let transitionCallbacks = null;\n\n  if (options !== null && options !== undefined) {\n\n    if (options.unstable_strictMode === true) {\n      isStrictMode = true;\n    }\n\n    if (options.identifierPrefix !== undefined) {\n      identifierPrefix = options.identifierPrefix;\n    }\n\n    if (options.onRecoverableError !== undefined) {\n      onRecoverableError = options.onRecoverableError;\n    }\n\n    if (options.transitionCallbacks !== undefined) {\n      transitionCallbacks = options.transitionCallbacks;\n    }\n  }\n\n  const root = createContainer(container, ConcurrentRoot, null, isStrictMode, concurrentUpdatesByDefaultOverride, identifierPrefix, onRecoverableError);\n  markContainerAsRoot(root.current, container);\n  const rootContainerElement = container.nodeType === COMMENT_NODE ? container.parentNode : container;\n  listenToAllSupportedEvents(rootContainerElement);\n  return new ReactDOMRoot(root);\n}\n\nfunction ReactDOMHydrationRoot(internalRoot) {\n  this._internalRoot = internalRoot;\n}\n\nfunction scheduleHydration(target) {\n  if (target) {\n    queueExplicitHydrationTarget(target);\n  }\n}\n\nReactDOMHydrationRoot.prototype.unstable_scheduleHydration = scheduleHydration;\nfunction hydrateRoot(container, initialChildren, options) {\n  if (!isValidContainer(container)) {\n    throw Error(formatProdErrorMessage(405));\n  }\n  // the hydration callbacks.\n\n\n  const hydrationCallbacks = options != null ? options : null; // TODO: Delete this option\n\n  const mutableSources = options != null && options.hydratedSources || null;\n  let isStrictMode = false;\n  let concurrentUpdatesByDefaultOverride = false;\n  let identifierPrefix = '';\n  let onRecoverableError = defaultOnRecoverableError;\n\n  if (options !== null && options !== undefined) {\n    if (options.unstable_strictMode === true) {\n      isStrictMode = true;\n    }\n\n    if (options.identifierPrefix !== undefined) {\n      identifierPrefix = options.identifierPrefix;\n    }\n\n    if (options.onRecoverableError !== undefined) {\n      onRecoverableError = options.onRecoverableError;\n    }\n  }\n\n  const root = createHydrationContainer(initialChildren, null, container, ConcurrentRoot, hydrationCallbacks, isStrictMode, concurrentUpdatesByDefaultOverride, identifierPrefix, onRecoverableError);\n  markContainerAsRoot(root.current, container); // This can't be a comment node since hydration doesn't work on comment nodes anyway.\n\n  listenToAllSupportedEvents(container);\n\n  if (mutableSources) {\n    for (let i = 0; i < mutableSources.length; i++) {\n      const mutableSource = mutableSources[i];\n      registerMutableSourceForHydration(root, mutableSource);\n    }\n  }\n\n  return new ReactDOMHydrationRoot(root);\n}\nfunction isValidContainer(node) {\n  return !!(node && (node.nodeType === ELEMENT_NODE || node.nodeType === DOCUMENT_NODE || node.nodeType === DOCUMENT_FRAGMENT_NODE || !disableCommentsAsDOMContainers  ));\n} // TODO: Remove this function which also includes comment nodes.\n// We only use it in places that are currently more relaxed.\n\nfunction isValidContainerLegacy(node) {\n  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 '));\n}\n\nconst ReactCurrentOwner$3 = ReactSharedInternals.ReactCurrentOwner;\n\nfunction noopOnRecoverableError() {// This isn't reachable because onRecoverableError isn't called in the\n  // legacy API.\n}\n\nfunction legacyCreateRootFromDOMContainer(container, initialChildren, parentComponent, callback, isHydrationContainer) {\n  if (isHydrationContainer) {\n    if (typeof callback === 'function') {\n      const originalCallback = callback;\n\n      callback = function () {\n        const instance = getPublicRootInstance(root);\n        originalCallback.call(instance);\n      };\n    }\n\n    const root = createHydrationContainer(initialChildren, callback, container, LegacyRoot, null, // hydrationCallbacks\n    false, // isStrictMode\n    false, // concurrentUpdatesByDefaultOverride,\n    '', // identifierPrefix\n    noopOnRecoverableError);\n    container._reactRootContainer = root;\n    markContainerAsRoot(root.current, container);\n    const rootContainerElement = container.nodeType === COMMENT_NODE ? container.parentNode : container;\n    listenToAllSupportedEvents(rootContainerElement);\n    flushSync();\n    return root;\n  } else {\n    // First clear any existing content.\n    let rootSibling;\n\n    while (rootSibling = container.lastChild) {\n      container.removeChild(rootSibling);\n    }\n\n    if (typeof callback === 'function') {\n      const originalCallback = callback;\n\n      callback = function () {\n        const instance = getPublicRootInstance(root);\n        originalCallback.call(instance);\n      };\n    }\n\n    const root = createContainer(container, LegacyRoot, null, // hydrationCallbacks\n    false, // isStrictMode\n    false, // concurrentUpdatesByDefaultOverride,\n    '', // identifierPrefix\n    noopOnRecoverableError);\n    container._reactRootContainer = root;\n    markContainerAsRoot(root.current, container);\n    const rootContainerElement = container.nodeType === COMMENT_NODE ? container.parentNode : container;\n    listenToAllSupportedEvents(rootContainerElement); // Initial mount should not be batched.\n\n    flushSync(() => {\n      updateContainer(initialChildren, root, parentComponent, callback);\n    });\n    return root;\n  }\n}\n\nfunction legacyRenderSubtreeIntoContainer(parentComponent, children, container, forceHydrate, callback) {\n\n  const maybeRoot = container._reactRootContainer;\n  let root;\n\n  if (!maybeRoot) {\n    // Initial mount\n    root = legacyCreateRootFromDOMContainer(container, children, parentComponent, callback, forceHydrate);\n  } else {\n    root = maybeRoot;\n\n    if (typeof callback === 'function') {\n      const originalCallback = callback;\n\n      callback = function () {\n        const instance = getPublicRootInstance(root);\n        originalCallback.call(instance);\n      };\n    } // Update\n\n\n    updateContainer(children, root, parentComponent, callback);\n  }\n\n  return getPublicRootInstance(root);\n}\n\nfunction findDOMNode(componentOrElement) {\n\n  if (componentOrElement == null) {\n    return null;\n  }\n\n  if (componentOrElement.nodeType === ELEMENT_NODE) {\n    return componentOrElement;\n  }\n\n  return findHostInstance(componentOrElement);\n}\nfunction hydrate(element, container, callback) {\n\n  if (!isValidContainerLegacy(container)) {\n    throw Error(formatProdErrorMessage(200));\n  }\n\n\n  return legacyRenderSubtreeIntoContainer(null, element, container, true, callback);\n}\nfunction render(element, container, callback) {\n\n  if (!isValidContainerLegacy(container)) {\n    throw Error(formatProdErrorMessage(200));\n  }\n\n  return legacyRenderSubtreeIntoContainer(null, element, container, false, callback);\n}\nfunction unstable_renderSubtreeIntoContainer(parentComponent, element, containerNode, callback) {\n\n  if (!isValidContainerLegacy(containerNode)) {\n    throw Error(formatProdErrorMessage(200));\n  }\n\n  if (parentComponent == null || !has(parentComponent)) {\n    throw Error(formatProdErrorMessage(38));\n  }\n\n  return legacyRenderSubtreeIntoContainer(parentComponent, element, containerNode, false, callback);\n}\nfunction unmountComponentAtNode(container) {\n  if (!isValidContainerLegacy(container)) {\n    throw Error(formatProdErrorMessage(40));\n  }\n\n  if (container._reactRootContainer) {\n\n\n    flushSync(() => {\n      legacyRenderSubtreeIntoContainer(null, null, container, false, () => {\n        // $FlowFixMe This should probably use `delete container._reactRootContainer`\n        container._reactRootContainer = null;\n        unmarkContainerAsRoot(container);\n      });\n    }); // If you call unmountComponentAtNode twice in quick succession, you'll\n    // get `true` twice. That's probably fine?\n\n    return true;\n  } else {\n\n    return false;\n  }\n}\n\nsetAttemptSynchronousHydration(attemptSynchronousHydration$1);\nsetAttemptContinuousHydration(attemptContinuousHydration$1);\nsetAttemptHydrationAtCurrentPriority(attemptHydrationAtCurrentPriority$1);\nsetGetCurrentUpdatePriority(getCurrentUpdatePriority);\nsetAttemptHydrationAtPriority(runWithPriority);\n\nsetRestoreImplementation(restoreControlledState$3);\nsetBatchingImplementation(batchedUpdates$1, discreteUpdates, flushSync);\n\nfunction createPortal$1(children, container) {\n  let key = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;\n\n  if (!isValidContainer(container)) {\n    throw Error(formatProdErrorMessage(200));\n  } // TODO: pass ReactDOM portal implementation as third argument\n  // $FlowFixMe The Flow type is opaque but there's no way to actually create it.\n\n\n  return createPortal(children, container, null, key);\n}\n\nfunction renderSubtreeIntoContainer(parentComponent, element, containerNode, callback) {\n  return unstable_renderSubtreeIntoContainer(parentComponent, element, containerNode, callback);\n}\n\nconst Internals = {\n  usingClientEntryPoint: false,\n  // Keep in sync with ReactTestUtils.js.\n  // This is an array for better minification.\n  Events: [getInstanceFromNode, getNodeFromInstance, getFiberCurrentPropsFromNode, enqueueStateRestore, restoreStateIfNeeded, batchedUpdates$1]\n};\n\nfunction createRoot$1(container, options) {\n\n  return createRoot(container, options);\n}\n\nfunction hydrateRoot$1(container, initialChildren, options) {\n\n  return hydrateRoot(container, initialChildren, options);\n} // Overload the definition to the two valid signatures.\n// Warning, this opts-out of checking the function body.\n\n\n// eslint-disable-next-line no-redeclare\nfunction flushSync$1(fn) {\n\n  return flushSync(fn);\n}\n\nconst actualVersion = '18.2.0-next-9e3b772b8-20220608';\nconst foundDevTools = injectIntoDevTools({\n  findFiberByHostInstance: getClosestInstanceFromNode,\n  bundleType:  0,\n  version: ReactVersion,\n  rendererPackageName: 'react-dom'\n});\n\nexports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = Internals;\nexports.createPortal = createPortal$1;\nexports.createRoot = createRoot$1;\nexports.findDOMNode = findDOMNode;\nexports.flushSync = flushSync$1;\nexports.hydrate = hydrate;\nexports.hydrateRoot = hydrateRoot$1;\nexports.render = render;\nexports.unmountComponentAtNode = unmountComponentAtNode;\nexports.unstable_batchedUpdates = batchedUpdates$1;\nexports.unstable_renderSubtreeIntoContainer = renderSubtreeIntoContainer;\nexports.version = actualVersion;",
    "'use strict';\n\nfunction checkDCE() {\n  /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */\n  if (\n    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === 'undefined' ||\n    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE !== 'function'\n  ) {\n    return;\n  }\n  if (process.env.NODE_ENV !== 'production') {\n    // This branch is unreachable because this function is only called\n    // in production, but the condition is true only in development.\n    // Therefore if the branch is still here, dead code elimination wasn't\n    // properly applied.\n    // Don't change the message. React DevTools relies on it. Also make sure\n    // this message doesn't occur elsewhere in this function, or it will cause\n    // a false positive.\n    throw new Error('^_^');\n  }\n  try {\n    // Verify that the code above has been dead code eliminated (DCE'd).\n    __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(checkDCE);\n  } catch (err) {\n    // DevTools shouldn't crash React, no matter what.\n    // We should still report in case we break this code.\n    console.error(err);\n  }\n}\n\nif (process.env.NODE_ENV === 'production') {\n  // DCE check should happen before ReactDOM bundle executes so that\n  // DevTools can report bad minification during injection.\n  checkDCE();\n  module.exports = require('./cjs/react-dom.production.min.js');\n} else {\n  module.exports = require('./cjs/react-dom.development.js');\n}\n",
    "'use strict';\n\nvar m = require('react-dom');\nif (process.env.NODE_ENV === 'production') {\n  exports.createRoot = m.createRoot;\n  exports.hydrateRoot = m.hydrateRoot;\n} else {\n  var i = m.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;\n  exports.createRoot = function(c, o) {\n    i.usingClientEntryPoint = true;\n    try {\n      return m.createRoot(c, o);\n    } finally {\n      i.usingClientEntryPoint = false;\n    }\n  };\n  exports.hydrateRoot = function(c, h, o) {\n    i.usingClientEntryPoint = true;\n    try {\n      return m.hydrateRoot(c, h, o);\n    } finally {\n      i.usingClientEntryPoint = false;\n    }\n  };\n}\n",
    "/**\n * @license React\n * use-sync-external-store-with-selector.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n'use strict';var g=require(\"react\");function n(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var p=\"function\"===typeof Object.is?Object.is:n,q=g.useSyncExternalStore,r=g.useRef,t=g.useEffect,u=g.useMemo,v=g.useDebugValue;\nexports.useSyncExternalStoreWithSelector=function(a,b,e,l,h){var c=r(null);if(null===c.current){var f={hasValue:!1,value:null};c.current=f}else f=c.current;c=u(function(){function a(a){if(!c){c=!0;d=a;a=l(a);if(void 0!==h&&f.hasValue){var b=f.value;if(h(b,a))return k=b}return k=a}b=k;if(p(d,a))return b;var e=l(a);if(void 0!==h&&h(b,e))return b;d=a;return k=e}var c=!1,d,k,m=void 0===e?null:e;return[function(){return a(b())},null===m?void 0:function(){return a(m())}]},[b,e,l,h]);var d=q(a,c[0],c[1]);\nt(function(){f.hasValue=!0;f.value=d},[d]);v(d);return d};\n",
    "'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/use-sync-external-store-with-selector.production.min.js');\n} else {\n  module.exports = require('./cjs/use-sync-external-store-with-selector.development.js');\n}\n",
    "// src/index.ts\nimport * as React2 from \"react\";\nimport { useSyncExternalStoreWithSelector as useSyncExternalStoreWithSelector2 } from \"use-sync-external-store/with-selector.js\";\n\n// src/utils/react.ts\nimport * as ReactOriginal from \"react\";\nvar React = (\n  // prettier-ignore\n  // @ts-ignore\n  \"default\" in ReactOriginal ? ReactOriginal[\"default\"] : ReactOriginal\n);\n\n// src/components/Context.ts\nvar ContextKey = Symbol.for(`react-redux-context`);\nvar gT = typeof globalThis !== \"undefined\" ? globalThis : (\n  /* fall back to a per-module scope (pre-8.1 behaviour) if `globalThis` is not available */\n  {}\n);\nfunction getContext() {\n  if (!React.createContext)\n    return {};\n  const contextMap = gT[ContextKey] ?? (gT[ContextKey] = /* @__PURE__ */ new Map());\n  let realContext = contextMap.get(React.createContext);\n  if (!realContext) {\n    realContext = React.createContext(\n      null\n    );\n    if (process.env.NODE_ENV !== \"production\") {\n      realContext.displayName = \"ReactRedux\";\n    }\n    contextMap.set(React.createContext, realContext);\n  }\n  return realContext;\n}\nvar ReactReduxContext = /* @__PURE__ */ getContext();\n\n// src/utils/useSyncExternalStore.ts\nvar notInitialized = () => {\n  throw new Error(\"uSES not initialized!\");\n};\n\n// src/hooks/useReduxContext.ts\nfunction createReduxContextHook(context = ReactReduxContext) {\n  return function useReduxContext2() {\n    const contextValue = React.useContext(context);\n    if (process.env.NODE_ENV !== \"production\" && !contextValue) {\n      throw new Error(\n        \"could not find react-redux context value; please ensure the component is wrapped in a <Provider>\"\n      );\n    }\n    return contextValue;\n  };\n}\nvar useReduxContext = /* @__PURE__ */ createReduxContextHook();\n\n// src/hooks/useSelector.ts\nvar useSyncExternalStoreWithSelector = notInitialized;\nvar initializeUseSelector = (fn) => {\n  useSyncExternalStoreWithSelector = fn;\n};\nvar refEquality = (a, b) => a === b;\nfunction createSelectorHook(context = ReactReduxContext) {\n  const useReduxContext2 = context === ReactReduxContext ? useReduxContext : createReduxContextHook(context);\n  const useSelector2 = (selector, equalityFnOrOptions = {}) => {\n    const { equalityFn = refEquality, devModeChecks = {} } = typeof equalityFnOrOptions === \"function\" ? { equalityFn: equalityFnOrOptions } : equalityFnOrOptions;\n    if (process.env.NODE_ENV !== \"production\") {\n      if (!selector) {\n        throw new Error(`You must pass a selector to useSelector`);\n      }\n      if (typeof selector !== \"function\") {\n        throw new Error(`You must pass a function as a selector to useSelector`);\n      }\n      if (typeof equalityFn !== \"function\") {\n        throw new Error(\n          `You must pass a function as an equality function to useSelector`\n        );\n      }\n    }\n    const {\n      store,\n      subscription,\n      getServerState,\n      stabilityCheck,\n      identityFunctionCheck\n    } = useReduxContext2();\n    const firstRun = React.useRef(true);\n    const wrappedSelector = React.useCallback(\n      {\n        [selector.name](state) {\n          const selected = selector(state);\n          if (process.env.NODE_ENV !== \"production\") {\n            const {\n              identityFunctionCheck: finalIdentityFunctionCheck,\n              stabilityCheck: finalStabilityCheck\n            } = {\n              stabilityCheck,\n              identityFunctionCheck,\n              ...devModeChecks\n            };\n            if (finalStabilityCheck === \"always\" || finalStabilityCheck === \"once\" && firstRun.current) {\n              const toCompare = selector(state);\n              if (!equalityFn(selected, toCompare)) {\n                let stack = void 0;\n                try {\n                  throw new Error();\n                } catch (e) {\n                  ;\n                  ({ stack } = e);\n                }\n                console.warn(\n                  \"Selector \" + (selector.name || \"unknown\") + \" returned a different result when called with the same parameters. This can lead to unnecessary rerenders.\\nSelectors that return a new reference (such as an object or an array) should be memoized: https://redux.js.org/usage/deriving-data-selectors#optimizing-selectors-with-memoization\",\n                  {\n                    state,\n                    selected,\n                    selected2: toCompare,\n                    stack\n                  }\n                );\n              }\n            }\n            if (finalIdentityFunctionCheck === \"always\" || finalIdentityFunctionCheck === \"once\" && firstRun.current) {\n              if (selected === state) {\n                let stack = void 0;\n                try {\n                  throw new Error();\n                } catch (e) {\n                  ;\n                  ({ stack } = e);\n                }\n                console.warn(\n                  \"Selector \" + (selector.name || \"unknown\") + \" returned the root state when called. This can lead to unnecessary rerenders.\\nSelectors that return the entire state are almost certainly a mistake, as they will cause a rerender whenever *anything* in state changes.\",\n                  { stack }\n                );\n              }\n            }\n            if (firstRun.current)\n              firstRun.current = false;\n          }\n          return selected;\n        }\n      }[selector.name],\n      [selector, stabilityCheck, devModeChecks.stabilityCheck]\n    );\n    const selectedState = useSyncExternalStoreWithSelector(\n      subscription.addNestedSub,\n      store.getState,\n      getServerState || store.getState,\n      wrappedSelector,\n      equalityFn\n    );\n    React.useDebugValue(selectedState);\n    return selectedState;\n  };\n  Object.assign(useSelector2, {\n    withTypes: () => useSelector2\n  });\n  return useSelector2;\n}\nvar useSelector = /* @__PURE__ */ createSelectorHook();\n\n// src/utils/react-is.ts\nvar REACT_ELEMENT_TYPE = Symbol.for(\"react.element\");\nvar REACT_PORTAL_TYPE = Symbol.for(\"react.portal\");\nvar REACT_FRAGMENT_TYPE = Symbol.for(\"react.fragment\");\nvar REACT_STRICT_MODE_TYPE = Symbol.for(\"react.strict_mode\");\nvar REACT_PROFILER_TYPE = Symbol.for(\"react.profiler\");\nvar REACT_PROVIDER_TYPE = Symbol.for(\"react.provider\");\nvar REACT_CONTEXT_TYPE = Symbol.for(\"react.context\");\nvar REACT_SERVER_CONTEXT_TYPE = Symbol.for(\"react.server_context\");\nvar REACT_FORWARD_REF_TYPE = Symbol.for(\"react.forward_ref\");\nvar REACT_SUSPENSE_TYPE = Symbol.for(\"react.suspense\");\nvar REACT_SUSPENSE_LIST_TYPE = Symbol.for(\"react.suspense_list\");\nvar REACT_MEMO_TYPE = Symbol.for(\"react.memo\");\nvar REACT_LAZY_TYPE = Symbol.for(\"react.lazy\");\nvar REACT_OFFSCREEN_TYPE = Symbol.for(\"react.offscreen\");\nvar REACT_CLIENT_REFERENCE = Symbol.for(\"react.client.reference\");\nvar ForwardRef = REACT_FORWARD_REF_TYPE;\nvar Memo = REACT_MEMO_TYPE;\nfunction isValidElementType(type) {\n  if (typeof type === \"string\" || typeof type === \"function\") {\n    return true;\n  }\n  if (type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || type === REACT_OFFSCREEN_TYPE) {\n    return true;\n  }\n  if (typeof type === \"object\" && type !== null) {\n    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\n    // types supported by any Flight configuration anywhere since\n    // we don't know which Flight build this will end up being used\n    // with.\n    type.$$typeof === REACT_CLIENT_REFERENCE || type.getModuleId !== void 0) {\n      return true;\n    }\n  }\n  return false;\n}\nfunction typeOf(object) {\n  if (typeof object === \"object\" && object !== null) {\n    const $$typeof = object.$$typeof;\n    switch ($$typeof) {\n      case REACT_ELEMENT_TYPE: {\n        const type = object.type;\n        switch (type) {\n          case REACT_FRAGMENT_TYPE:\n          case REACT_PROFILER_TYPE:\n          case REACT_STRICT_MODE_TYPE:\n          case REACT_SUSPENSE_TYPE:\n          case REACT_SUSPENSE_LIST_TYPE:\n            return type;\n          default: {\n            const $$typeofType = type && type.$$typeof;\n            switch ($$typeofType) {\n              case REACT_SERVER_CONTEXT_TYPE:\n              case REACT_CONTEXT_TYPE:\n              case REACT_FORWARD_REF_TYPE:\n              case REACT_LAZY_TYPE:\n              case REACT_MEMO_TYPE:\n              case REACT_PROVIDER_TYPE:\n                return $$typeofType;\n              default:\n                return $$typeof;\n            }\n          }\n        }\n      }\n      case REACT_PORTAL_TYPE: {\n        return $$typeof;\n      }\n    }\n  }\n  return void 0;\n}\nfunction isContextConsumer(object) {\n  return typeOf(object) === REACT_CONTEXT_TYPE;\n}\nfunction isMemo(object) {\n  return typeOf(object) === REACT_MEMO_TYPE;\n}\n\n// src/utils/warning.ts\nfunction warning(message) {\n  if (typeof console !== \"undefined\" && typeof console.error === \"function\") {\n    console.error(message);\n  }\n  try {\n    throw new Error(message);\n  } catch (e) {\n  }\n}\n\n// src/connect/verifySubselectors.ts\nfunction verify(selector, methodName) {\n  if (!selector) {\n    throw new Error(`Unexpected value for ${methodName} in connect.`);\n  } else if (methodName === \"mapStateToProps\" || methodName === \"mapDispatchToProps\") {\n    if (!Object.prototype.hasOwnProperty.call(selector, \"dependsOnOwnProps\")) {\n      warning(\n        `The selector for ${methodName} of connect did not specify a value for dependsOnOwnProps.`\n      );\n    }\n  }\n}\nfunction verifySubselectors(mapStateToProps, mapDispatchToProps, mergeProps) {\n  verify(mapStateToProps, \"mapStateToProps\");\n  verify(mapDispatchToProps, \"mapDispatchToProps\");\n  verify(mergeProps, \"mergeProps\");\n}\n\n// src/connect/selectorFactory.ts\nfunction pureFinalPropsSelectorFactory(mapStateToProps, mapDispatchToProps, mergeProps, dispatch, {\n  areStatesEqual,\n  areOwnPropsEqual,\n  areStatePropsEqual\n}) {\n  let hasRunAtLeastOnce = false;\n  let state;\n  let ownProps;\n  let stateProps;\n  let dispatchProps;\n  let mergedProps;\n  function handleFirstCall(firstState, firstOwnProps) {\n    state = firstState;\n    ownProps = firstOwnProps;\n    stateProps = mapStateToProps(state, ownProps);\n    dispatchProps = mapDispatchToProps(dispatch, ownProps);\n    mergedProps = mergeProps(stateProps, dispatchProps, ownProps);\n    hasRunAtLeastOnce = true;\n    return mergedProps;\n  }\n  function handleNewPropsAndNewState() {\n    stateProps = mapStateToProps(state, ownProps);\n    if (mapDispatchToProps.dependsOnOwnProps)\n      dispatchProps = mapDispatchToProps(dispatch, ownProps);\n    mergedProps = mergeProps(stateProps, dispatchProps, ownProps);\n    return mergedProps;\n  }\n  function handleNewProps() {\n    if (mapStateToProps.dependsOnOwnProps)\n      stateProps = mapStateToProps(state, ownProps);\n    if (mapDispatchToProps.dependsOnOwnProps)\n      dispatchProps = mapDispatchToProps(dispatch, ownProps);\n    mergedProps = mergeProps(stateProps, dispatchProps, ownProps);\n    return mergedProps;\n  }\n  function handleNewState() {\n    const nextStateProps = mapStateToProps(state, ownProps);\n    const statePropsChanged = !areStatePropsEqual(nextStateProps, stateProps);\n    stateProps = nextStateProps;\n    if (statePropsChanged)\n      mergedProps = mergeProps(stateProps, dispatchProps, ownProps);\n    return mergedProps;\n  }\n  function handleSubsequentCalls(nextState, nextOwnProps) {\n    const propsChanged = !areOwnPropsEqual(nextOwnProps, ownProps);\n    const stateChanged = !areStatesEqual(\n      nextState,\n      state,\n      nextOwnProps,\n      ownProps\n    );\n    state = nextState;\n    ownProps = nextOwnProps;\n    if (propsChanged && stateChanged)\n      return handleNewPropsAndNewState();\n    if (propsChanged)\n      return handleNewProps();\n    if (stateChanged)\n      return handleNewState();\n    return mergedProps;\n  }\n  return function pureFinalPropsSelector(nextState, nextOwnProps) {\n    return hasRunAtLeastOnce ? handleSubsequentCalls(nextState, nextOwnProps) : handleFirstCall(nextState, nextOwnProps);\n  };\n}\nfunction finalPropsSelectorFactory(dispatch, {\n  initMapStateToProps,\n  initMapDispatchToProps,\n  initMergeProps,\n  ...options\n}) {\n  const mapStateToProps = initMapStateToProps(dispatch, options);\n  const mapDispatchToProps = initMapDispatchToProps(dispatch, options);\n  const mergeProps = initMergeProps(dispatch, options);\n  if (process.env.NODE_ENV !== \"production\") {\n    verifySubselectors(mapStateToProps, mapDispatchToProps, mergeProps);\n  }\n  return pureFinalPropsSelectorFactory(mapStateToProps, mapDispatchToProps, mergeProps, dispatch, options);\n}\n\n// src/utils/bindActionCreators.ts\nfunction bindActionCreators(actionCreators, dispatch) {\n  const boundActionCreators = {};\n  for (const key in actionCreators) {\n    const actionCreator = actionCreators[key];\n    if (typeof actionCreator === \"function\") {\n      boundActionCreators[key] = (...args) => dispatch(actionCreator(...args));\n    }\n  }\n  return boundActionCreators;\n}\n\n// src/utils/isPlainObject.ts\nfunction isPlainObject(obj) {\n  if (typeof obj !== \"object\" || obj === null)\n    return false;\n  const proto = Object.getPrototypeOf(obj);\n  if (proto === null)\n    return true;\n  let baseProto = proto;\n  while (Object.getPrototypeOf(baseProto) !== null) {\n    baseProto = Object.getPrototypeOf(baseProto);\n  }\n  return proto === baseProto;\n}\n\n// src/utils/verifyPlainObject.ts\nfunction verifyPlainObject(value, displayName, methodName) {\n  if (!isPlainObject(value)) {\n    warning(\n      `${methodName}() in ${displayName} must return a plain object. Instead received ${value}.`\n    );\n  }\n}\n\n// src/connect/wrapMapToProps.ts\nfunction wrapMapToPropsConstant(getConstant) {\n  return function initConstantSelector(dispatch) {\n    const constant = getConstant(dispatch);\n    function constantSelector() {\n      return constant;\n    }\n    constantSelector.dependsOnOwnProps = false;\n    return constantSelector;\n  };\n}\nfunction getDependsOnOwnProps(mapToProps) {\n  return mapToProps.dependsOnOwnProps ? Boolean(mapToProps.dependsOnOwnProps) : mapToProps.length !== 1;\n}\nfunction wrapMapToPropsFunc(mapToProps, methodName) {\n  return function initProxySelector(dispatch, { displayName }) {\n    const proxy = function mapToPropsProxy(stateOrDispatch, ownProps) {\n      return proxy.dependsOnOwnProps ? proxy.mapToProps(stateOrDispatch, ownProps) : proxy.mapToProps(stateOrDispatch, void 0);\n    };\n    proxy.dependsOnOwnProps = true;\n    proxy.mapToProps = function detectFactoryAndVerify(stateOrDispatch, ownProps) {\n      proxy.mapToProps = mapToProps;\n      proxy.dependsOnOwnProps = getDependsOnOwnProps(mapToProps);\n      let props = proxy(stateOrDispatch, ownProps);\n      if (typeof props === \"function\") {\n        proxy.mapToProps = props;\n        proxy.dependsOnOwnProps = getDependsOnOwnProps(props);\n        props = proxy(stateOrDispatch, ownProps);\n      }\n      if (process.env.NODE_ENV !== \"production\")\n        verifyPlainObject(props, displayName, methodName);\n      return props;\n    };\n    return proxy;\n  };\n}\n\n// src/connect/invalidArgFactory.ts\nfunction createInvalidArgFactory(arg, name) {\n  return (dispatch, options) => {\n    throw new Error(\n      `Invalid value of type ${typeof arg} for ${name} argument when connecting component ${options.wrappedComponentName}.`\n    );\n  };\n}\n\n// src/connect/mapDispatchToProps.ts\nfunction mapDispatchToPropsFactory(mapDispatchToProps) {\n  return mapDispatchToProps && typeof mapDispatchToProps === \"object\" ? wrapMapToPropsConstant(\n    (dispatch) => (\n      // @ts-ignore\n      bindActionCreators(mapDispatchToProps, dispatch)\n    )\n  ) : !mapDispatchToProps ? wrapMapToPropsConstant((dispatch) => ({\n    dispatch\n  })) : typeof mapDispatchToProps === \"function\" ? (\n    // @ts-ignore\n    wrapMapToPropsFunc(mapDispatchToProps, \"mapDispatchToProps\")\n  ) : createInvalidArgFactory(mapDispatchToProps, \"mapDispatchToProps\");\n}\n\n// src/connect/mapStateToProps.ts\nfunction mapStateToPropsFactory(mapStateToProps) {\n  return !mapStateToProps ? wrapMapToPropsConstant(() => ({})) : typeof mapStateToProps === \"function\" ? (\n    // @ts-ignore\n    wrapMapToPropsFunc(mapStateToProps, \"mapStateToProps\")\n  ) : createInvalidArgFactory(mapStateToProps, \"mapStateToProps\");\n}\n\n// src/connect/mergeProps.ts\nfunction defaultMergeProps(stateProps, dispatchProps, ownProps) {\n  return { ...ownProps, ...stateProps, ...dispatchProps };\n}\nfunction wrapMergePropsFunc(mergeProps) {\n  return function initMergePropsProxy(dispatch, { displayName, areMergedPropsEqual }) {\n    let hasRunOnce = false;\n    let mergedProps;\n    return function mergePropsProxy(stateProps, dispatchProps, ownProps) {\n      const nextMergedProps = mergeProps(stateProps, dispatchProps, ownProps);\n      if (hasRunOnce) {\n        if (!areMergedPropsEqual(nextMergedProps, mergedProps))\n          mergedProps = nextMergedProps;\n      } else {\n        hasRunOnce = true;\n        mergedProps = nextMergedProps;\n        if (process.env.NODE_ENV !== \"production\")\n          verifyPlainObject(mergedProps, displayName, \"mergeProps\");\n      }\n      return mergedProps;\n    };\n  };\n}\nfunction mergePropsFactory(mergeProps) {\n  return !mergeProps ? () => defaultMergeProps : typeof mergeProps === \"function\" ? wrapMergePropsFunc(mergeProps) : createInvalidArgFactory(mergeProps, \"mergeProps\");\n}\n\n// src/utils/batch.ts\nfunction defaultNoopBatch(callback) {\n  callback();\n}\n\n// src/utils/Subscription.ts\nfunction createListenerCollection() {\n  let first = null;\n  let last = null;\n  return {\n    clear() {\n      first = null;\n      last = null;\n    },\n    notify() {\n      defaultNoopBatch(() => {\n        let listener = first;\n        while (listener) {\n          listener.callback();\n          listener = listener.next;\n        }\n      });\n    },\n    get() {\n      const listeners = [];\n      let listener = first;\n      while (listener) {\n        listeners.push(listener);\n        listener = listener.next;\n      }\n      return listeners;\n    },\n    subscribe(callback) {\n      let isSubscribed = true;\n      const listener = last = {\n        callback,\n        next: null,\n        prev: last\n      };\n      if (listener.prev) {\n        listener.prev.next = listener;\n      } else {\n        first = listener;\n      }\n      return function unsubscribe() {\n        if (!isSubscribed || first === null)\n          return;\n        isSubscribed = false;\n        if (listener.next) {\n          listener.next.prev = listener.prev;\n        } else {\n          last = listener.prev;\n        }\n        if (listener.prev) {\n          listener.prev.next = listener.next;\n        } else {\n          first = listener.next;\n        }\n      };\n    }\n  };\n}\nvar nullListeners = {\n  notify() {\n  },\n  get: () => []\n};\nfunction createSubscription(store, parentSub) {\n  let unsubscribe;\n  let listeners = nullListeners;\n  let subscriptionsAmount = 0;\n  let selfSubscribed = false;\n  function addNestedSub(listener) {\n    trySubscribe();\n    const cleanupListener = listeners.subscribe(listener);\n    let removed = false;\n    return () => {\n      if (!removed) {\n        removed = true;\n        cleanupListener();\n        tryUnsubscribe();\n      }\n    };\n  }\n  function notifyNestedSubs() {\n    listeners.notify();\n  }\n  function handleChangeWrapper() {\n    if (subscription.onStateChange) {\n      subscription.onStateChange();\n    }\n  }\n  function isSubscribed() {\n    return selfSubscribed;\n  }\n  function trySubscribe() {\n    subscriptionsAmount++;\n    if (!unsubscribe) {\n      unsubscribe = parentSub ? parentSub.addNestedSub(handleChangeWrapper) : store.subscribe(handleChangeWrapper);\n      listeners = createListenerCollection();\n    }\n  }\n  function tryUnsubscribe() {\n    subscriptionsAmount--;\n    if (unsubscribe && subscriptionsAmount === 0) {\n      unsubscribe();\n      unsubscribe = void 0;\n      listeners.clear();\n      listeners = nullListeners;\n    }\n  }\n  function trySubscribeSelf() {\n    if (!selfSubscribed) {\n      selfSubscribed = true;\n      trySubscribe();\n    }\n  }\n  function tryUnsubscribeSelf() {\n    if (selfSubscribed) {\n      selfSubscribed = false;\n      tryUnsubscribe();\n    }\n  }\n  const subscription = {\n    addNestedSub,\n    notifyNestedSubs,\n    handleChangeWrapper,\n    isSubscribed,\n    trySubscribe: trySubscribeSelf,\n    tryUnsubscribe: tryUnsubscribeSelf,\n    getListeners: () => listeners\n  };\n  return subscription;\n}\n\n// src/utils/useIsomorphicLayoutEffect.ts\nvar canUseDOM = !!(typeof window !== \"undefined\" && typeof window.document !== \"undefined\" && typeof window.document.createElement !== \"undefined\");\nvar isReactNative = typeof navigator !== \"undefined\" && navigator.product === \"ReactNative\";\nvar useIsomorphicLayoutEffect = canUseDOM || isReactNative ? React.useLayoutEffect : React.useEffect;\n\n// src/utils/shallowEqual.ts\nfunction is(x, y) {\n  if (x === y) {\n    return x !== 0 || y !== 0 || 1 / x === 1 / y;\n  } else {\n    return x !== x && y !== y;\n  }\n}\nfunction shallowEqual(objA, objB) {\n  if (is(objA, objB))\n    return true;\n  if (typeof objA !== \"object\" || objA === null || typeof objB !== \"object\" || objB === null) {\n    return false;\n  }\n  const keysA = Object.keys(objA);\n  const keysB = Object.keys(objB);\n  if (keysA.length !== keysB.length)\n    return false;\n  for (let i = 0; i < keysA.length; i++) {\n    if (!Object.prototype.hasOwnProperty.call(objB, keysA[i]) || !is(objA[keysA[i]], objB[keysA[i]])) {\n      return false;\n    }\n  }\n  return true;\n}\n\n// src/utils/hoistStatics.ts\nvar REACT_STATICS = {\n  childContextTypes: true,\n  contextType: true,\n  contextTypes: true,\n  defaultProps: true,\n  displayName: true,\n  getDefaultProps: true,\n  getDerivedStateFromError: true,\n  getDerivedStateFromProps: true,\n  mixins: true,\n  propTypes: true,\n  type: true\n};\nvar KNOWN_STATICS = {\n  name: true,\n  length: true,\n  prototype: true,\n  caller: true,\n  callee: true,\n  arguments: true,\n  arity: true\n};\nvar FORWARD_REF_STATICS = {\n  $$typeof: true,\n  render: true,\n  defaultProps: true,\n  displayName: true,\n  propTypes: true\n};\nvar MEMO_STATICS = {\n  $$typeof: true,\n  compare: true,\n  defaultProps: true,\n  displayName: true,\n  propTypes: true,\n  type: true\n};\nvar TYPE_STATICS = {\n  [ForwardRef]: FORWARD_REF_STATICS,\n  [Memo]: MEMO_STATICS\n};\nfunction getStatics(component) {\n  if (isMemo(component)) {\n    return MEMO_STATICS;\n  }\n  return TYPE_STATICS[component[\"$$typeof\"]] || REACT_STATICS;\n}\nvar defineProperty = Object.defineProperty;\nvar getOwnPropertyNames = Object.getOwnPropertyNames;\nvar getOwnPropertySymbols = Object.getOwnPropertySymbols;\nvar getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\nvar getPrototypeOf = Object.getPrototypeOf;\nvar objectPrototype = Object.prototype;\nfunction hoistNonReactStatics(targetComponent, sourceComponent) {\n  if (typeof sourceComponent !== \"string\") {\n    if (objectPrototype) {\n      const inheritedComponent = getPrototypeOf(sourceComponent);\n      if (inheritedComponent && inheritedComponent !== objectPrototype) {\n        hoistNonReactStatics(targetComponent, inheritedComponent);\n      }\n    }\n    let keys = getOwnPropertyNames(sourceComponent);\n    if (getOwnPropertySymbols) {\n      keys = keys.concat(getOwnPropertySymbols(sourceComponent));\n    }\n    const targetStatics = getStatics(targetComponent);\n    const sourceStatics = getStatics(sourceComponent);\n    for (let i = 0; i < keys.length; ++i) {\n      const key = keys[i];\n      if (!KNOWN_STATICS[key] && !(sourceStatics && sourceStatics[key]) && !(targetStatics && targetStatics[key])) {\n        const descriptor = getOwnPropertyDescriptor(sourceComponent, key);\n        try {\n          defineProperty(targetComponent, key, descriptor);\n        } catch (e) {\n        }\n      }\n    }\n  }\n  return targetComponent;\n}\n\n// src/components/connect.tsx\nvar useSyncExternalStore = notInitialized;\nvar initializeConnect = (fn) => {\n  useSyncExternalStore = fn;\n};\nvar NO_SUBSCRIPTION_ARRAY = [null, null];\nvar stringifyComponent = (Comp) => {\n  try {\n    return JSON.stringify(Comp);\n  } catch (err) {\n    return String(Comp);\n  }\n};\nfunction useIsomorphicLayoutEffectWithArgs(effectFunc, effectArgs, dependencies) {\n  useIsomorphicLayoutEffect(() => effectFunc(...effectArgs), dependencies);\n}\nfunction captureWrapperProps(lastWrapperProps, lastChildProps, renderIsScheduled, wrapperProps, childPropsFromStoreUpdate, notifyNestedSubs) {\n  lastWrapperProps.current = wrapperProps;\n  renderIsScheduled.current = false;\n  if (childPropsFromStoreUpdate.current) {\n    childPropsFromStoreUpdate.current = null;\n    notifyNestedSubs();\n  }\n}\nfunction subscribeUpdates(shouldHandleStateChanges, store, subscription, childPropsSelector, lastWrapperProps, lastChildProps, renderIsScheduled, isMounted, childPropsFromStoreUpdate, notifyNestedSubs, additionalSubscribeListener) {\n  if (!shouldHandleStateChanges)\n    return () => {\n    };\n  let didUnsubscribe = false;\n  let lastThrownError = null;\n  const checkForUpdates = () => {\n    if (didUnsubscribe || !isMounted.current) {\n      return;\n    }\n    const latestStoreState = store.getState();\n    let newChildProps, error;\n    try {\n      newChildProps = childPropsSelector(\n        latestStoreState,\n        lastWrapperProps.current\n      );\n    } catch (e) {\n      error = e;\n      lastThrownError = e;\n    }\n    if (!error) {\n      lastThrownError = null;\n    }\n    if (newChildProps === lastChildProps.current) {\n      if (!renderIsScheduled.current) {\n        notifyNestedSubs();\n      }\n    } else {\n      lastChildProps.current = newChildProps;\n      childPropsFromStoreUpdate.current = newChildProps;\n      renderIsScheduled.current = true;\n      additionalSubscribeListener();\n    }\n  };\n  subscription.onStateChange = checkForUpdates;\n  subscription.trySubscribe();\n  checkForUpdates();\n  const unsubscribeWrapper = () => {\n    didUnsubscribe = true;\n    subscription.tryUnsubscribe();\n    subscription.onStateChange = null;\n    if (lastThrownError) {\n      throw lastThrownError;\n    }\n  };\n  return unsubscribeWrapper;\n}\nfunction strictEqual(a, b) {\n  return a === b;\n}\nvar hasWarnedAboutDeprecatedPureOption = false;\nfunction connect(mapStateToProps, mapDispatchToProps, mergeProps, {\n  // The `pure` option has been removed, so TS doesn't like us destructuring this to check its existence.\n  // @ts-ignore\n  pure,\n  areStatesEqual = strictEqual,\n  areOwnPropsEqual = shallowEqual,\n  areStatePropsEqual = shallowEqual,\n  areMergedPropsEqual = shallowEqual,\n  // use React's forwardRef to expose a ref of the wrapped component\n  forwardRef = false,\n  // the context consumer to use\n  context = ReactReduxContext\n} = {}) {\n  if (process.env.NODE_ENV !== \"production\") {\n    if (pure !== void 0 && !hasWarnedAboutDeprecatedPureOption) {\n      hasWarnedAboutDeprecatedPureOption = true;\n      warning(\n        'The `pure` option has been removed. `connect` is now always a \"pure/memoized\" component'\n      );\n    }\n  }\n  const Context = context;\n  const initMapStateToProps = mapStateToPropsFactory(mapStateToProps);\n  const initMapDispatchToProps = mapDispatchToPropsFactory(mapDispatchToProps);\n  const initMergeProps = mergePropsFactory(mergeProps);\n  const shouldHandleStateChanges = Boolean(mapStateToProps);\n  const wrapWithConnect = (WrappedComponent) => {\n    if (process.env.NODE_ENV !== \"production\") {\n      const isValid = /* @__PURE__ */ isValidElementType(WrappedComponent);\n      if (!isValid)\n        throw new Error(\n          `You must pass a component to the function returned by connect. Instead received ${stringifyComponent(\n            WrappedComponent\n          )}`\n        );\n    }\n    const wrappedComponentName = WrappedComponent.displayName || WrappedComponent.name || \"Component\";\n    const displayName = `Connect(${wrappedComponentName})`;\n    const selectorFactoryOptions = {\n      shouldHandleStateChanges,\n      displayName,\n      wrappedComponentName,\n      WrappedComponent,\n      // @ts-ignore\n      initMapStateToProps,\n      // @ts-ignore\n      initMapDispatchToProps,\n      initMergeProps,\n      areStatesEqual,\n      areStatePropsEqual,\n      areOwnPropsEqual,\n      areMergedPropsEqual\n    };\n    function ConnectFunction(props) {\n      const [propsContext, reactReduxForwardedRef, wrapperProps] = React.useMemo(() => {\n        const { reactReduxForwardedRef: reactReduxForwardedRef2, ...wrapperProps2 } = props;\n        return [props.context, reactReduxForwardedRef2, wrapperProps2];\n      }, [props]);\n      const ContextToUse = React.useMemo(() => {\n        let ResultContext = Context;\n        if (propsContext?.Consumer) {\n          if (process.env.NODE_ENV !== \"production\") {\n            const isValid = /* @__PURE__ */ isContextConsumer(\n              // @ts-ignore\n              /* @__PURE__ */ React.createElement(propsContext.Consumer, null)\n            );\n            if (!isValid) {\n              throw new Error(\n                \"You must pass a valid React context consumer as `props.context`\"\n              );\n            }\n            ResultContext = propsContext;\n          }\n        }\n        return ResultContext;\n      }, [propsContext, Context]);\n      const contextValue = React.useContext(ContextToUse);\n      const didStoreComeFromProps = Boolean(props.store) && Boolean(props.store.getState) && Boolean(props.store.dispatch);\n      const didStoreComeFromContext = Boolean(contextValue) && Boolean(contextValue.store);\n      if (process.env.NODE_ENV !== \"production\" && !didStoreComeFromProps && !didStoreComeFromContext) {\n        throw new Error(\n          `Could not find \"store\" in the context of \"${displayName}\". Either wrap the root component in a <Provider>, or pass a custom React context provider to <Provider> and the corresponding React context consumer to ${displayName} in connect options.`\n        );\n      }\n      const store = didStoreComeFromProps ? props.store : contextValue.store;\n      const getServerState = didStoreComeFromContext ? contextValue.getServerState : store.getState;\n      const childPropsSelector = React.useMemo(() => {\n        return finalPropsSelectorFactory(store.dispatch, selectorFactoryOptions);\n      }, [store]);\n      const [subscription, notifyNestedSubs] = React.useMemo(() => {\n        if (!shouldHandleStateChanges)\n          return NO_SUBSCRIPTION_ARRAY;\n        const subscription2 = createSubscription(\n          store,\n          didStoreComeFromProps ? void 0 : contextValue.subscription\n        );\n        const notifyNestedSubs2 = subscription2.notifyNestedSubs.bind(subscription2);\n        return [subscription2, notifyNestedSubs2];\n      }, [store, didStoreComeFromProps, contextValue]);\n      const overriddenContextValue = React.useMemo(() => {\n        if (didStoreComeFromProps) {\n          return contextValue;\n        }\n        return {\n          ...contextValue,\n          subscription\n        };\n      }, [didStoreComeFromProps, contextValue, subscription]);\n      const lastChildProps = React.useRef(void 0);\n      const lastWrapperProps = React.useRef(wrapperProps);\n      const childPropsFromStoreUpdate = React.useRef(void 0);\n      const renderIsScheduled = React.useRef(false);\n      const isMounted = React.useRef(false);\n      const latestSubscriptionCallbackError = React.useRef(\n        void 0\n      );\n      useIsomorphicLayoutEffect(() => {\n        isMounted.current = true;\n        return () => {\n          isMounted.current = false;\n        };\n      }, []);\n      const actualChildPropsSelector = React.useMemo(() => {\n        const selector = () => {\n          if (childPropsFromStoreUpdate.current && wrapperProps === lastWrapperProps.current) {\n            return childPropsFromStoreUpdate.current;\n          }\n          return childPropsSelector(store.getState(), wrapperProps);\n        };\n        return selector;\n      }, [store, wrapperProps]);\n      const subscribeForReact = React.useMemo(() => {\n        const subscribe = (reactListener) => {\n          if (!subscription) {\n            return () => {\n            };\n          }\n          return subscribeUpdates(\n            shouldHandleStateChanges,\n            store,\n            subscription,\n            // @ts-ignore\n            childPropsSelector,\n            lastWrapperProps,\n            lastChildProps,\n            renderIsScheduled,\n            isMounted,\n            childPropsFromStoreUpdate,\n            notifyNestedSubs,\n            reactListener\n          );\n        };\n        return subscribe;\n      }, [subscription]);\n      useIsomorphicLayoutEffectWithArgs(captureWrapperProps, [\n        lastWrapperProps,\n        lastChildProps,\n        renderIsScheduled,\n        wrapperProps,\n        childPropsFromStoreUpdate,\n        notifyNestedSubs\n      ]);\n      let actualChildProps;\n      try {\n        actualChildProps = useSyncExternalStore(\n          // TODO We're passing through a big wrapper that does a bunch of extra side effects besides subscribing\n          subscribeForReact,\n          // TODO This is incredibly hacky. We've already processed the store update and calculated new child props,\n          // TODO and we're just passing that through so it triggers a re-render for us rather than relying on `uSES`.\n          actualChildPropsSelector,\n          getServerState ? () => childPropsSelector(getServerState(), wrapperProps) : actualChildPropsSelector\n        );\n      } catch (err) {\n        if (latestSubscriptionCallbackError.current) {\n          ;\n          err.message += `\nThe error may be correlated with this previous error:\n${latestSubscriptionCallbackError.current.stack}\n\n`;\n        }\n        throw err;\n      }\n      useIsomorphicLayoutEffect(() => {\n        latestSubscriptionCallbackError.current = void 0;\n        childPropsFromStoreUpdate.current = void 0;\n        lastChildProps.current = actualChildProps;\n      });\n      const renderedWrappedComponent = React.useMemo(() => {\n        return (\n          // @ts-ignore\n          /* @__PURE__ */ React.createElement(\n            WrappedComponent,\n            {\n              ...actualChildProps,\n              ref: reactReduxForwardedRef\n            }\n          )\n        );\n      }, [reactReduxForwardedRef, WrappedComponent, actualChildProps]);\n      const renderedChild = React.useMemo(() => {\n        if (shouldHandleStateChanges) {\n          return /* @__PURE__ */ React.createElement(ContextToUse.Provider, { value: overriddenContextValue }, renderedWrappedComponent);\n        }\n        return renderedWrappedComponent;\n      }, [ContextToUse, renderedWrappedComponent, overriddenContextValue]);\n      return renderedChild;\n    }\n    const _Connect = React.memo(ConnectFunction);\n    const Connect = _Connect;\n    Connect.WrappedComponent = WrappedComponent;\n    Connect.displayName = ConnectFunction.displayName = displayName;\n    if (forwardRef) {\n      const _forwarded = React.forwardRef(\n        function forwardConnectRef(props, ref) {\n          return /* @__PURE__ */ React.createElement(Connect, { ...props, reactReduxForwardedRef: ref });\n        }\n      );\n      const forwarded = _forwarded;\n      forwarded.displayName = displayName;\n      forwarded.WrappedComponent = WrappedComponent;\n      return /* @__PURE__ */ hoistNonReactStatics(forwarded, WrappedComponent);\n    }\n    return /* @__PURE__ */ hoistNonReactStatics(Connect, WrappedComponent);\n  };\n  return wrapWithConnect;\n}\nvar connect_default = connect;\n\n// src/components/Provider.tsx\nfunction Provider({\n  store,\n  context,\n  children,\n  serverState,\n  stabilityCheck = \"once\",\n  identityFunctionCheck = \"once\"\n}) {\n  const contextValue = React.useMemo(() => {\n    const subscription = createSubscription(store);\n    return {\n      store,\n      subscription,\n      getServerState: serverState ? () => serverState : void 0,\n      stabilityCheck,\n      identityFunctionCheck\n    };\n  }, [store, serverState, stabilityCheck, identityFunctionCheck]);\n  const previousState = React.useMemo(() => store.getState(), [store]);\n  useIsomorphicLayoutEffect(() => {\n    const { subscription } = contextValue;\n    subscription.onStateChange = subscription.notifyNestedSubs;\n    subscription.trySubscribe();\n    if (previousState !== store.getState()) {\n      subscription.notifyNestedSubs();\n    }\n    return () => {\n      subscription.tryUnsubscribe();\n      subscription.onStateChange = void 0;\n    };\n  }, [contextValue, previousState]);\n  const Context = context || ReactReduxContext;\n  return /* @__PURE__ */ React.createElement(Context.Provider, { value: contextValue }, children);\n}\nvar Provider_default = Provider;\n\n// src/hooks/useStore.ts\nfunction createStoreHook(context = ReactReduxContext) {\n  const useReduxContext2 = context === ReactReduxContext ? useReduxContext : (\n    // @ts-ignore\n    createReduxContextHook(context)\n  );\n  const useStore2 = () => {\n    const { store } = useReduxContext2();\n    return store;\n  };\n  Object.assign(useStore2, {\n    withTypes: () => useStore2\n  });\n  return useStore2;\n}\nvar useStore = /* @__PURE__ */ createStoreHook();\n\n// src/hooks/useDispatch.ts\nfunction createDispatchHook(context = ReactReduxContext) {\n  const useStore2 = context === ReactReduxContext ? useStore : createStoreHook(context);\n  const useDispatch2 = () => {\n    const store = useStore2();\n    return store.dispatch;\n  };\n  Object.assign(useDispatch2, {\n    withTypes: () => useDispatch2\n  });\n  return useDispatch2;\n}\nvar useDispatch = /* @__PURE__ */ createDispatchHook();\n\n// src/exports.ts\nvar batch = defaultNoopBatch;\n\n// src/index.ts\ninitializeUseSelector(useSyncExternalStoreWithSelector2);\ninitializeConnect(React2.useSyncExternalStore);\nexport {\n  Provider_default as Provider,\n  ReactReduxContext,\n  batch,\n  connect_default as connect,\n  createDispatchHook,\n  createSelectorHook,\n  createStoreHook,\n  shallowEqual,\n  useDispatch,\n  useSelector,\n  useStore\n};\n//# sourceMappingURL=react-redux.mjs.map",
    "// src/utils/formatProdErrorMessage.ts\nfunction formatProdErrorMessage(code) {\n  return `Minified Redux error #${code}; visit https://redux.js.org/Errors?code=${code} for the full message or use the non-minified dev environment for full errors. `;\n}\n\n// src/utils/symbol-observable.ts\nvar $$observable = /* @__PURE__ */ (() => typeof Symbol === \"function\" && Symbol.observable || \"@@observable\")();\nvar symbol_observable_default = $$observable;\n\n// src/utils/actionTypes.ts\nvar randomString = () => Math.random().toString(36).substring(7).split(\"\").join(\".\");\nvar ActionTypes = {\n  INIT: `@@redux/INIT${/* @__PURE__ */ randomString()}`,\n  REPLACE: `@@redux/REPLACE${/* @__PURE__ */ randomString()}`,\n  PROBE_UNKNOWN_ACTION: () => `@@redux/PROBE_UNKNOWN_ACTION${randomString()}`\n};\nvar actionTypes_default = ActionTypes;\n\n// src/utils/isPlainObject.ts\nfunction isPlainObject(obj) {\n  if (typeof obj !== \"object\" || obj === null)\n    return false;\n  let proto = obj;\n  while (Object.getPrototypeOf(proto) !== null) {\n    proto = Object.getPrototypeOf(proto);\n  }\n  return Object.getPrototypeOf(obj) === proto || Object.getPrototypeOf(obj) === null;\n}\n\n// src/utils/kindOf.ts\nfunction miniKindOf(val) {\n  if (val === void 0)\n    return \"undefined\";\n  if (val === null)\n    return \"null\";\n  const type = typeof val;\n  switch (type) {\n    case \"boolean\":\n    case \"string\":\n    case \"number\":\n    case \"symbol\":\n    case \"function\": {\n      return type;\n    }\n  }\n  if (Array.isArray(val))\n    return \"array\";\n  if (isDate(val))\n    return \"date\";\n  if (isError(val))\n    return \"error\";\n  const constructorName = ctorName(val);\n  switch (constructorName) {\n    case \"Symbol\":\n    case \"Promise\":\n    case \"WeakMap\":\n    case \"WeakSet\":\n    case \"Map\":\n    case \"Set\":\n      return constructorName;\n  }\n  return Object.prototype.toString.call(val).slice(8, -1).toLowerCase().replace(/\\s/g, \"\");\n}\nfunction ctorName(val) {\n  return typeof val.constructor === \"function\" ? val.constructor.name : null;\n}\nfunction isError(val) {\n  return val instanceof Error || typeof val.message === \"string\" && val.constructor && typeof val.constructor.stackTraceLimit === \"number\";\n}\nfunction isDate(val) {\n  if (val instanceof Date)\n    return true;\n  return typeof val.toDateString === \"function\" && typeof val.getDate === \"function\" && typeof val.setDate === \"function\";\n}\nfunction kindOf(val) {\n  let typeOfVal = typeof val;\n  if (process.env.NODE_ENV !== \"production\") {\n    typeOfVal = miniKindOf(val);\n  }\n  return typeOfVal;\n}\n\n// src/createStore.ts\nfunction createStore(reducer, preloadedState, enhancer) {\n  if (typeof reducer !== \"function\") {\n    throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(2) : `Expected the root reducer to be a function. Instead, received: '${kindOf(reducer)}'`);\n  }\n  if (typeof preloadedState === \"function\" && typeof enhancer === \"function\" || typeof enhancer === \"function\" && typeof arguments[3] === \"function\") {\n    throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(0) : \"It looks like you are passing several store enhancers to createStore(). This is not supported. Instead, compose them together to a single function. See https://redux.js.org/tutorials/fundamentals/part-4-store#creating-a-store-with-enhancers for an example.\");\n  }\n  if (typeof preloadedState === \"function\" && typeof enhancer === \"undefined\") {\n    enhancer = preloadedState;\n    preloadedState = void 0;\n  }\n  if (typeof enhancer !== \"undefined\") {\n    if (typeof enhancer !== \"function\") {\n      throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(1) : `Expected the enhancer to be a function. Instead, received: '${kindOf(enhancer)}'`);\n    }\n    return enhancer(createStore)(reducer, preloadedState);\n  }\n  let currentReducer = reducer;\n  let currentState = preloadedState;\n  let currentListeners = /* @__PURE__ */ new Map();\n  let nextListeners = currentListeners;\n  let listenerIdCounter = 0;\n  let isDispatching = false;\n  function ensureCanMutateNextListeners() {\n    if (nextListeners === currentListeners) {\n      nextListeners = /* @__PURE__ */ new Map();\n      currentListeners.forEach((listener, key) => {\n        nextListeners.set(key, listener);\n      });\n    }\n  }\n  function getState() {\n    if (isDispatching) {\n      throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(3) : \"You may not call store.getState() while the reducer is executing. The reducer has already received the state as an argument. Pass it down from the top reducer instead of reading it from the store.\");\n    }\n    return currentState;\n  }\n  function subscribe(listener) {\n    if (typeof listener !== \"function\") {\n      throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(4) : `Expected the listener to be a function. Instead, received: '${kindOf(listener)}'`);\n    }\n    if (isDispatching) {\n      throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(5) : \"You may not call store.subscribe() while the reducer is executing. If you would like to be notified after the store has been updated, subscribe from a component and invoke store.getState() in the callback to access the latest state. See https://redux.js.org/api/store#subscribelistener for more details.\");\n    }\n    let isSubscribed = true;\n    ensureCanMutateNextListeners();\n    const listenerId = listenerIdCounter++;\n    nextListeners.set(listenerId, listener);\n    return function unsubscribe() {\n      if (!isSubscribed) {\n        return;\n      }\n      if (isDispatching) {\n        throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(6) : \"You may not unsubscribe from a store listener while the reducer is executing. See https://redux.js.org/api/store#subscribelistener for more details.\");\n      }\n      isSubscribed = false;\n      ensureCanMutateNextListeners();\n      nextListeners.delete(listenerId);\n      currentListeners = null;\n    };\n  }\n  function dispatch(action) {\n    if (!isPlainObject(action)) {\n      throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(7) : `Actions must be plain objects. Instead, the actual type was: '${kindOf(action)}'. You may need to add middleware to your store setup to handle dispatching other values, such as 'redux-thunk' to handle dispatching functions. See https://redux.js.org/tutorials/fundamentals/part-4-store#middleware and https://redux.js.org/tutorials/fundamentals/part-6-async-logic#using-the-redux-thunk-middleware for examples.`);\n    }\n    if (typeof action.type === \"undefined\") {\n      throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(8) : 'Actions may not have an undefined \"type\" property. You may have misspelled an action type string constant.');\n    }\n    if (typeof action.type !== \"string\") {\n      throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(17) : `Action \"type\" property must be a string. Instead, the actual type was: '${kindOf(action.type)}'. Value was: '${action.type}' (stringified)`);\n    }\n    if (isDispatching) {\n      throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(9) : \"Reducers may not dispatch actions.\");\n    }\n    try {\n      isDispatching = true;\n      currentState = currentReducer(currentState, action);\n    } finally {\n      isDispatching = false;\n    }\n    const listeners = currentListeners = nextListeners;\n    listeners.forEach((listener) => {\n      listener();\n    });\n    return action;\n  }\n  function replaceReducer(nextReducer) {\n    if (typeof nextReducer !== \"function\") {\n      throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(10) : `Expected the nextReducer to be a function. Instead, received: '${kindOf(nextReducer)}`);\n    }\n    currentReducer = nextReducer;\n    dispatch({\n      type: actionTypes_default.REPLACE\n    });\n  }\n  function observable() {\n    const outerSubscribe = subscribe;\n    return {\n      /**\n       * The minimal observable subscription method.\n       * @param observer Any object that can be used as an observer.\n       * The observer object should have a `next` method.\n       * @returns An object with an `unsubscribe` method that can\n       * be used to unsubscribe the observable from the store, and prevent further\n       * emission of values from the observable.\n       */\n      subscribe(observer) {\n        if (typeof observer !== \"object\" || observer === null) {\n          throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(11) : `Expected the observer to be an object. Instead, received: '${kindOf(observer)}'`);\n        }\n        function observeState() {\n          const observerAsObserver = observer;\n          if (observerAsObserver.next) {\n            observerAsObserver.next(getState());\n          }\n        }\n        observeState();\n        const unsubscribe = outerSubscribe(observeState);\n        return {\n          unsubscribe\n        };\n      },\n      [symbol_observable_default]() {\n        return this;\n      }\n    };\n  }\n  dispatch({\n    type: actionTypes_default.INIT\n  });\n  const store = {\n    dispatch,\n    subscribe,\n    getState,\n    replaceReducer,\n    [symbol_observable_default]: observable\n  };\n  return store;\n}\nfunction legacy_createStore(reducer, preloadedState, enhancer) {\n  return createStore(reducer, preloadedState, enhancer);\n}\n\n// src/utils/warning.ts\nfunction warning(message) {\n  if (typeof console !== \"undefined\" && typeof console.error === \"function\") {\n    console.error(message);\n  }\n  try {\n    throw new Error(message);\n  } catch (e) {\n  }\n}\n\n// src/combineReducers.ts\nfunction getUnexpectedStateShapeWarningMessage(inputState, reducers, action, unexpectedKeyCache) {\n  const reducerKeys = Object.keys(reducers);\n  const argumentName = action && action.type === actionTypes_default.INIT ? \"preloadedState argument passed to createStore\" : \"previous state received by the reducer\";\n  if (reducerKeys.length === 0) {\n    return \"Store does not have a valid reducer. Make sure the argument passed to combineReducers is an object whose values are reducers.\";\n  }\n  if (!isPlainObject(inputState)) {\n    return `The ${argumentName} has unexpected type of \"${kindOf(inputState)}\". Expected argument to be an object with the following keys: \"${reducerKeys.join('\", \"')}\"`;\n  }\n  const unexpectedKeys = Object.keys(inputState).filter((key) => !reducers.hasOwnProperty(key) && !unexpectedKeyCache[key]);\n  unexpectedKeys.forEach((key) => {\n    unexpectedKeyCache[key] = true;\n  });\n  if (action && action.type === actionTypes_default.REPLACE)\n    return;\n  if (unexpectedKeys.length > 0) {\n    return `Unexpected ${unexpectedKeys.length > 1 ? \"keys\" : \"key\"} \"${unexpectedKeys.join('\", \"')}\" found in ${argumentName}. Expected to find one of the known reducer keys instead: \"${reducerKeys.join('\", \"')}\". Unexpected keys will be ignored.`;\n  }\n}\nfunction assertReducerShape(reducers) {\n  Object.keys(reducers).forEach((key) => {\n    const reducer = reducers[key];\n    const initialState = reducer(void 0, {\n      type: actionTypes_default.INIT\n    });\n    if (typeof initialState === \"undefined\") {\n      throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(12) : `The slice reducer for key \"${key}\" returned undefined during initialization. If the state passed to the reducer is undefined, you must explicitly return the initial state. The initial state may not be undefined. If you don't want to set a value for this reducer, you can use null instead of undefined.`);\n    }\n    if (typeof reducer(void 0, {\n      type: actionTypes_default.PROBE_UNKNOWN_ACTION()\n    }) === \"undefined\") {\n      throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(13) : `The slice reducer for key \"${key}\" returned undefined when probed with a random type. Don't try to handle '${actionTypes_default.INIT}' or other actions in \"redux/*\" namespace. They are considered private. Instead, you must return the current state for any unknown actions, unless it is undefined, in which case you must return the initial state, regardless of the action type. The initial state may not be undefined, but can be null.`);\n    }\n  });\n}\nfunction combineReducers(reducers) {\n  const reducerKeys = Object.keys(reducers);\n  const finalReducers = {};\n  for (let i = 0; i < reducerKeys.length; i++) {\n    const key = reducerKeys[i];\n    if (process.env.NODE_ENV !== \"production\") {\n      if (typeof reducers[key] === \"undefined\") {\n        warning(`No reducer provided for key \"${key}\"`);\n      }\n    }\n    if (typeof reducers[key] === \"function\") {\n      finalReducers[key] = reducers[key];\n    }\n  }\n  const finalReducerKeys = Object.keys(finalReducers);\n  let unexpectedKeyCache;\n  if (process.env.NODE_ENV !== \"production\") {\n    unexpectedKeyCache = {};\n  }\n  let shapeAssertionError;\n  try {\n    assertReducerShape(finalReducers);\n  } catch (e) {\n    shapeAssertionError = e;\n  }\n  return function combination(state = {}, action) {\n    if (shapeAssertionError) {\n      throw shapeAssertionError;\n    }\n    if (process.env.NODE_ENV !== \"production\") {\n      const warningMessage = getUnexpectedStateShapeWarningMessage(state, finalReducers, action, unexpectedKeyCache);\n      if (warningMessage) {\n        warning(warningMessage);\n      }\n    }\n    let hasChanged = false;\n    const nextState = {};\n    for (let i = 0; i < finalReducerKeys.length; i++) {\n      const key = finalReducerKeys[i];\n      const reducer = finalReducers[key];\n      const previousStateForKey = state[key];\n      const nextStateForKey = reducer(previousStateForKey, action);\n      if (typeof nextStateForKey === \"undefined\") {\n        const actionType = action && action.type;\n        throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(14) : `When called with an action of type ${actionType ? `\"${String(actionType)}\"` : \"(unknown type)\"}, the slice reducer for key \"${key}\" returned undefined. To ignore an action, you must explicitly return the previous state. If you want this reducer to hold no value, you can return null instead of undefined.`);\n      }\n      nextState[key] = nextStateForKey;\n      hasChanged = hasChanged || nextStateForKey !== previousStateForKey;\n    }\n    hasChanged = hasChanged || finalReducerKeys.length !== Object.keys(state).length;\n    return hasChanged ? nextState : state;\n  };\n}\n\n// src/bindActionCreators.ts\nfunction bindActionCreator(actionCreator, dispatch) {\n  return function(...args) {\n    return dispatch(actionCreator.apply(this, args));\n  };\n}\nfunction bindActionCreators(actionCreators, dispatch) {\n  if (typeof actionCreators === \"function\") {\n    return bindActionCreator(actionCreators, dispatch);\n  }\n  if (typeof actionCreators !== \"object\" || actionCreators === null) {\n    throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(16) : `bindActionCreators expected an object or a function, but instead received: '${kindOf(actionCreators)}'. Did you write \"import ActionCreators from\" instead of \"import * as ActionCreators from\"?`);\n  }\n  const boundActionCreators = {};\n  for (const key in actionCreators) {\n    const actionCreator = actionCreators[key];\n    if (typeof actionCreator === \"function\") {\n      boundActionCreators[key] = bindActionCreator(actionCreator, dispatch);\n    }\n  }\n  return boundActionCreators;\n}\n\n// src/compose.ts\nfunction compose(...funcs) {\n  if (funcs.length === 0) {\n    return (arg) => arg;\n  }\n  if (funcs.length === 1) {\n    return funcs[0];\n  }\n  return funcs.reduce((a, b) => (...args) => a(b(...args)));\n}\n\n// src/applyMiddleware.ts\nfunction applyMiddleware(...middlewares) {\n  return (createStore2) => (reducer, preloadedState) => {\n    const store = createStore2(reducer, preloadedState);\n    let dispatch = () => {\n      throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(15) : \"Dispatching while constructing your middleware is not allowed. Other middleware would not be applied to this dispatch.\");\n    };\n    const middlewareAPI = {\n      getState: store.getState,\n      dispatch: (action, ...args) => dispatch(action, ...args)\n    };\n    const chain = middlewares.map((middleware) => middleware(middlewareAPI));\n    dispatch = compose(...chain)(store.dispatch);\n    return {\n      ...store,\n      dispatch\n    };\n  };\n}\n\n// src/utils/isAction.ts\nfunction isAction(action) {\n  return isPlainObject(action) && \"type\" in action && typeof action.type === \"string\";\n}\nexport {\n  actionTypes_default as __DO_NOT_USE__ActionTypes,\n  applyMiddleware,\n  bindActionCreators,\n  combineReducers,\n  compose,\n  createStore,\n  isAction,\n  isPlainObject,\n  legacy_createStore\n};\n//# sourceMappingURL=redux.mjs.map",
    "// src/utils/env.ts\nvar NOTHING = Symbol.for(\"immer-nothing\");\nvar DRAFTABLE = Symbol.for(\"immer-draftable\");\nvar DRAFT_STATE = Symbol.for(\"immer-state\");\n\n// src/utils/errors.ts\nvar errors = process.env.NODE_ENV !== \"production\" ? [\n  // All error codes, starting by 0:\n  function(plugin) {\n    return `The plugin for '${plugin}' has not been loaded into Immer. To enable the plugin, import and call \\`enable${plugin}()\\` when initializing your application.`;\n  },\n  function(thing) {\n    return `produce can only be called on things that are draftable: plain objects, arrays, Map, Set or classes that are marked with '[immerable]: true'. Got '${thing}'`;\n  },\n  \"This object has been frozen and should not be mutated\",\n  function(data) {\n    return \"Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? \" + data;\n  },\n  \"An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft.\",\n  \"Immer forbids circular references\",\n  \"The first or second argument to `produce` must be a function\",\n  \"The third argument to `produce` must be a function or undefined\",\n  \"First argument to `createDraft` must be a plain object, an array, or an immerable object\",\n  \"First argument to `finishDraft` must be a draft returned by `createDraft`\",\n  function(thing) {\n    return `'current' expects a draft, got: ${thing}`;\n  },\n  \"Object.defineProperty() cannot be used on an Immer draft\",\n  \"Object.setPrototypeOf() cannot be used on an Immer draft\",\n  \"Immer only supports deleting array indices\",\n  \"Immer only supports setting array indices and the 'length' property\",\n  function(thing) {\n    return `'original' expects a draft, got: ${thing}`;\n  }\n  // Note: if more errors are added, the errorOffset in Patches.ts should be increased\n  // See Patches.ts for additional errors\n] : [];\nfunction die(error, ...args) {\n  if (process.env.NODE_ENV !== \"production\") {\n    const e = errors[error];\n    const msg = typeof e === \"function\" ? e.apply(null, args) : e;\n    throw new Error(`[Immer] ${msg}`);\n  }\n  throw new Error(\n    `[Immer] minified error nr: ${error}. Full error at: https://bit.ly/3cXEKWf`\n  );\n}\n\n// src/utils/common.ts\nvar getPrototypeOf = Object.getPrototypeOf;\nfunction isDraft(value) {\n  return !!value && !!value[DRAFT_STATE];\n}\nfunction isDraftable(value) {\n  if (!value)\n    return false;\n  return isPlainObject(value) || Array.isArray(value) || !!value[DRAFTABLE] || !!value.constructor?.[DRAFTABLE] || isMap(value) || isSet(value);\n}\nvar objectCtorString = Object.prototype.constructor.toString();\nfunction isPlainObject(value) {\n  if (!value || typeof value !== \"object\")\n    return false;\n  const proto = getPrototypeOf(value);\n  if (proto === null) {\n    return true;\n  }\n  const Ctor = Object.hasOwnProperty.call(proto, \"constructor\") && proto.constructor;\n  if (Ctor === Object)\n    return true;\n  return typeof Ctor == \"function\" && Function.toString.call(Ctor) === objectCtorString;\n}\nfunction original(value) {\n  if (!isDraft(value))\n    die(15, value);\n  return value[DRAFT_STATE].base_;\n}\nfunction each(obj, iter) {\n  if (getArchtype(obj) === 0 /* Object */) {\n    Object.entries(obj).forEach(([key, value]) => {\n      iter(key, value, obj);\n    });\n  } else {\n    obj.forEach((entry, index) => iter(index, entry, obj));\n  }\n}\nfunction getArchtype(thing) {\n  const state = thing[DRAFT_STATE];\n  return state ? state.type_ : Array.isArray(thing) ? 1 /* Array */ : isMap(thing) ? 2 /* Map */ : isSet(thing) ? 3 /* Set */ : 0 /* Object */;\n}\nfunction has(thing, prop) {\n  return getArchtype(thing) === 2 /* Map */ ? thing.has(prop) : Object.prototype.hasOwnProperty.call(thing, prop);\n}\nfunction get(thing, prop) {\n  return getArchtype(thing) === 2 /* Map */ ? thing.get(prop) : thing[prop];\n}\nfunction set(thing, propOrOldValue, value) {\n  const t = getArchtype(thing);\n  if (t === 2 /* Map */)\n    thing.set(propOrOldValue, value);\n  else if (t === 3 /* Set */) {\n    thing.add(value);\n  } else\n    thing[propOrOldValue] = value;\n}\nfunction is(x, y) {\n  if (x === y) {\n    return x !== 0 || 1 / x === 1 / y;\n  } else {\n    return x !== x && y !== y;\n  }\n}\nfunction isMap(target) {\n  return target instanceof Map;\n}\nfunction isSet(target) {\n  return target instanceof Set;\n}\nfunction latest(state) {\n  return state.copy_ || state.base_;\n}\nfunction shallowCopy(base, strict) {\n  if (isMap(base)) {\n    return new Map(base);\n  }\n  if (isSet(base)) {\n    return new Set(base);\n  }\n  if (Array.isArray(base))\n    return Array.prototype.slice.call(base);\n  if (!strict && isPlainObject(base)) {\n    if (!getPrototypeOf(base)) {\n      const obj = /* @__PURE__ */ Object.create(null);\n      return Object.assign(obj, base);\n    }\n    return { ...base };\n  }\n  const descriptors = Object.getOwnPropertyDescriptors(base);\n  delete descriptors[DRAFT_STATE];\n  let keys = Reflect.ownKeys(descriptors);\n  for (let i = 0; i < keys.length; i++) {\n    const key = keys[i];\n    const desc = descriptors[key];\n    if (desc.writable === false) {\n      desc.writable = true;\n      desc.configurable = true;\n    }\n    if (desc.get || desc.set)\n      descriptors[key] = {\n        configurable: true,\n        writable: true,\n        // could live with !!desc.set as well here...\n        enumerable: desc.enumerable,\n        value: base[key]\n      };\n  }\n  return Object.create(getPrototypeOf(base), descriptors);\n}\nfunction freeze(obj, deep = false) {\n  if (isFrozen(obj) || isDraft(obj) || !isDraftable(obj))\n    return obj;\n  if (getArchtype(obj) > 1) {\n    obj.set = obj.add = obj.clear = obj.delete = dontMutateFrozenCollections;\n  }\n  Object.freeze(obj);\n  if (deep)\n    each(obj, (_key, value) => freeze(value, true), true);\n  return obj;\n}\nfunction dontMutateFrozenCollections() {\n  die(2);\n}\nfunction isFrozen(obj) {\n  return Object.isFrozen(obj);\n}\n\n// src/utils/plugins.ts\nvar plugins = {};\nfunction getPlugin(pluginKey) {\n  const plugin = plugins[pluginKey];\n  if (!plugin) {\n    die(0, pluginKey);\n  }\n  return plugin;\n}\nfunction loadPlugin(pluginKey, implementation) {\n  if (!plugins[pluginKey])\n    plugins[pluginKey] = implementation;\n}\n\n// src/core/scope.ts\nvar currentScope;\nfunction getCurrentScope() {\n  return currentScope;\n}\nfunction createScope(parent_, immer_) {\n  return {\n    drafts_: [],\n    parent_,\n    immer_,\n    // Whenever the modified draft contains a draft from another scope, we\n    // need to prevent auto-freezing so the unowned draft can be finalized.\n    canAutoFreeze_: true,\n    unfinalizedDrafts_: 0\n  };\n}\nfunction usePatchesInScope(scope, patchListener) {\n  if (patchListener) {\n    getPlugin(\"Patches\");\n    scope.patches_ = [];\n    scope.inversePatches_ = [];\n    scope.patchListener_ = patchListener;\n  }\n}\nfunction revokeScope(scope) {\n  leaveScope(scope);\n  scope.drafts_.forEach(revokeDraft);\n  scope.drafts_ = null;\n}\nfunction leaveScope(scope) {\n  if (scope === currentScope) {\n    currentScope = scope.parent_;\n  }\n}\nfunction enterScope(immer2) {\n  return currentScope = createScope(currentScope, immer2);\n}\nfunction revokeDraft(draft) {\n  const state = draft[DRAFT_STATE];\n  if (state.type_ === 0 /* Object */ || state.type_ === 1 /* Array */)\n    state.revoke_();\n  else\n    state.revoked_ = true;\n}\n\n// src/core/finalize.ts\nfunction processResult(result, scope) {\n  scope.unfinalizedDrafts_ = scope.drafts_.length;\n  const baseDraft = scope.drafts_[0];\n  const isReplaced = result !== void 0 && result !== baseDraft;\n  if (isReplaced) {\n    if (baseDraft[DRAFT_STATE].modified_) {\n      revokeScope(scope);\n      die(4);\n    }\n    if (isDraftable(result)) {\n      result = finalize(scope, result);\n      if (!scope.parent_)\n        maybeFreeze(scope, result);\n    }\n    if (scope.patches_) {\n      getPlugin(\"Patches\").generateReplacementPatches_(\n        baseDraft[DRAFT_STATE].base_,\n        result,\n        scope.patches_,\n        scope.inversePatches_\n      );\n    }\n  } else {\n    result = finalize(scope, baseDraft, []);\n  }\n  revokeScope(scope);\n  if (scope.patches_) {\n    scope.patchListener_(scope.patches_, scope.inversePatches_);\n  }\n  return result !== NOTHING ? result : void 0;\n}\nfunction finalize(rootScope, value, path) {\n  if (isFrozen(value))\n    return value;\n  const state = value[DRAFT_STATE];\n  if (!state) {\n    each(\n      value,\n      (key, childValue) => finalizeProperty(rootScope, state, value, key, childValue, path),\n      true\n      // See #590, don't recurse into non-enumerable of non drafted objects\n    );\n    return value;\n  }\n  if (state.scope_ !== rootScope)\n    return value;\n  if (!state.modified_) {\n    maybeFreeze(rootScope, state.base_, true);\n    return state.base_;\n  }\n  if (!state.finalized_) {\n    state.finalized_ = true;\n    state.scope_.unfinalizedDrafts_--;\n    const result = state.copy_;\n    let resultEach = result;\n    let isSet2 = false;\n    if (state.type_ === 3 /* Set */) {\n      resultEach = new Set(result);\n      result.clear();\n      isSet2 = true;\n    }\n    each(\n      resultEach,\n      (key, childValue) => finalizeProperty(rootScope, state, result, key, childValue, path, isSet2)\n    );\n    maybeFreeze(rootScope, result, false);\n    if (path && rootScope.patches_) {\n      getPlugin(\"Patches\").generatePatches_(\n        state,\n        path,\n        rootScope.patches_,\n        rootScope.inversePatches_\n      );\n    }\n  }\n  return state.copy_;\n}\nfunction finalizeProperty(rootScope, parentState, targetObject, prop, childValue, rootPath, targetIsSet) {\n  if (process.env.NODE_ENV !== \"production\" && childValue === targetObject)\n    die(5);\n  if (isDraft(childValue)) {\n    const path = rootPath && parentState && parentState.type_ !== 3 /* Set */ && // Set objects are atomic since they have no keys.\n    !has(parentState.assigned_, prop) ? rootPath.concat(prop) : void 0;\n    const res = finalize(rootScope, childValue, path);\n    set(targetObject, prop, res);\n    if (isDraft(res)) {\n      rootScope.canAutoFreeze_ = false;\n    } else\n      return;\n  } else if (targetIsSet) {\n    targetObject.add(childValue);\n  }\n  if (isDraftable(childValue) && !isFrozen(childValue)) {\n    if (!rootScope.immer_.autoFreeze_ && rootScope.unfinalizedDrafts_ < 1) {\n      return;\n    }\n    finalize(rootScope, childValue);\n    if (!parentState || !parentState.scope_.parent_)\n      maybeFreeze(rootScope, childValue);\n  }\n}\nfunction maybeFreeze(scope, value, deep = false) {\n  if (!scope.parent_ && scope.immer_.autoFreeze_ && scope.canAutoFreeze_) {\n    freeze(value, deep);\n  }\n}\n\n// src/core/proxy.ts\nfunction createProxyProxy(base, parent) {\n  const isArray = Array.isArray(base);\n  const state = {\n    type_: isArray ? 1 /* Array */ : 0 /* Object */,\n    // Track which produce call this is associated with.\n    scope_: parent ? parent.scope_ : getCurrentScope(),\n    // True for both shallow and deep changes.\n    modified_: false,\n    // Used during finalization.\n    finalized_: false,\n    // Track which properties have been assigned (true) or deleted (false).\n    assigned_: {},\n    // The parent draft state.\n    parent_: parent,\n    // The base state.\n    base_: base,\n    // The base proxy.\n    draft_: null,\n    // set below\n    // The base copy with any updated values.\n    copy_: null,\n    // Called by the `produce` function.\n    revoke_: null,\n    isManual_: false\n  };\n  let target = state;\n  let traps = objectTraps;\n  if (isArray) {\n    target = [state];\n    traps = arrayTraps;\n  }\n  const { revoke, proxy } = Proxy.revocable(target, traps);\n  state.draft_ = proxy;\n  state.revoke_ = revoke;\n  return proxy;\n}\nvar objectTraps = {\n  get(state, prop) {\n    if (prop === DRAFT_STATE)\n      return state;\n    const source = latest(state);\n    if (!has(source, prop)) {\n      return readPropFromProto(state, source, prop);\n    }\n    const value = source[prop];\n    if (state.finalized_ || !isDraftable(value)) {\n      return value;\n    }\n    if (value === peek(state.base_, prop)) {\n      prepareCopy(state);\n      return state.copy_[prop] = createProxy(value, state);\n    }\n    return value;\n  },\n  has(state, prop) {\n    return prop in latest(state);\n  },\n  ownKeys(state) {\n    return Reflect.ownKeys(latest(state));\n  },\n  set(state, prop, value) {\n    const desc = getDescriptorFromProto(latest(state), prop);\n    if (desc?.set) {\n      desc.set.call(state.draft_, value);\n      return true;\n    }\n    if (!state.modified_) {\n      const current2 = peek(latest(state), prop);\n      const currentState = current2?.[DRAFT_STATE];\n      if (currentState && currentState.base_ === value) {\n        state.copy_[prop] = value;\n        state.assigned_[prop] = false;\n        return true;\n      }\n      if (is(value, current2) && (value !== void 0 || has(state.base_, prop)))\n        return true;\n      prepareCopy(state);\n      markChanged(state);\n    }\n    if (state.copy_[prop] === value && // special case: handle new props with value 'undefined'\n    (value !== void 0 || prop in state.copy_) || // special case: NaN\n    Number.isNaN(value) && Number.isNaN(state.copy_[prop]))\n      return true;\n    state.copy_[prop] = value;\n    state.assigned_[prop] = true;\n    return true;\n  },\n  deleteProperty(state, prop) {\n    if (peek(state.base_, prop) !== void 0 || prop in state.base_) {\n      state.assigned_[prop] = false;\n      prepareCopy(state);\n      markChanged(state);\n    } else {\n      delete state.assigned_[prop];\n    }\n    if (state.copy_) {\n      delete state.copy_[prop];\n    }\n    return true;\n  },\n  // Note: We never coerce `desc.value` into an Immer draft, because we can't make\n  // the same guarantee in ES5 mode.\n  getOwnPropertyDescriptor(state, prop) {\n    const owner = latest(state);\n    const desc = Reflect.getOwnPropertyDescriptor(owner, prop);\n    if (!desc)\n      return desc;\n    return {\n      writable: true,\n      configurable: state.type_ !== 1 /* Array */ || prop !== \"length\",\n      enumerable: desc.enumerable,\n      value: owner[prop]\n    };\n  },\n  defineProperty() {\n    die(11);\n  },\n  getPrototypeOf(state) {\n    return getPrototypeOf(state.base_);\n  },\n  setPrototypeOf() {\n    die(12);\n  }\n};\nvar arrayTraps = {};\neach(objectTraps, (key, fn) => {\n  arrayTraps[key] = function() {\n    arguments[0] = arguments[0][0];\n    return fn.apply(this, arguments);\n  };\n});\narrayTraps.deleteProperty = function(state, prop) {\n  if (process.env.NODE_ENV !== \"production\" && isNaN(parseInt(prop)))\n    die(13);\n  return arrayTraps.set.call(this, state, prop, void 0);\n};\narrayTraps.set = function(state, prop, value) {\n  if (process.env.NODE_ENV !== \"production\" && prop !== \"length\" && isNaN(parseInt(prop)))\n    die(14);\n  return objectTraps.set.call(this, state[0], prop, value, state[0]);\n};\nfunction peek(draft, prop) {\n  const state = draft[DRAFT_STATE];\n  const source = state ? latest(state) : draft;\n  return source[prop];\n}\nfunction readPropFromProto(state, source, prop) {\n  const desc = getDescriptorFromProto(source, prop);\n  return desc ? `value` in desc ? desc.value : (\n    // This is a very special case, if the prop is a getter defined by the\n    // prototype, we should invoke it with the draft as context!\n    desc.get?.call(state.draft_)\n  ) : void 0;\n}\nfunction getDescriptorFromProto(source, prop) {\n  if (!(prop in source))\n    return void 0;\n  let proto = getPrototypeOf(source);\n  while (proto) {\n    const desc = Object.getOwnPropertyDescriptor(proto, prop);\n    if (desc)\n      return desc;\n    proto = getPrototypeOf(proto);\n  }\n  return void 0;\n}\nfunction markChanged(state) {\n  if (!state.modified_) {\n    state.modified_ = true;\n    if (state.parent_) {\n      markChanged(state.parent_);\n    }\n  }\n}\nfunction prepareCopy(state) {\n  if (!state.copy_) {\n    state.copy_ = shallowCopy(\n      state.base_,\n      state.scope_.immer_.useStrictShallowCopy_\n    );\n  }\n}\n\n// src/core/immerClass.ts\nvar Immer2 = class {\n  constructor(config) {\n    this.autoFreeze_ = true;\n    this.useStrictShallowCopy_ = false;\n    /**\n     * The `produce` function takes a value and a \"recipe function\" (whose\n     * return value often depends on the base state). The recipe function is\n     * free to mutate its first argument however it wants. All mutations are\n     * only ever applied to a __copy__ of the base state.\n     *\n     * Pass only a function to create a \"curried producer\" which relieves you\n     * from passing the recipe function every time.\n     *\n     * Only plain objects and arrays are made mutable. All other objects are\n     * considered uncopyable.\n     *\n     * Note: This function is __bound__ to its `Immer` instance.\n     *\n     * @param {any} base - the initial state\n     * @param {Function} recipe - function that receives a proxy of the base state as first argument and which can be freely modified\n     * @param {Function} patchListener - optional function that will be called with all the patches produced here\n     * @returns {any} a new state, or the initial state if nothing was modified\n     */\n    this.produce = (base, recipe, patchListener) => {\n      if (typeof base === \"function\" && typeof recipe !== \"function\") {\n        const defaultBase = recipe;\n        recipe = base;\n        const self = this;\n        return function curriedProduce(base2 = defaultBase, ...args) {\n          return self.produce(base2, (draft) => recipe.call(this, draft, ...args));\n        };\n      }\n      if (typeof recipe !== \"function\")\n        die(6);\n      if (patchListener !== void 0 && typeof patchListener !== \"function\")\n        die(7);\n      let result;\n      if (isDraftable(base)) {\n        const scope = enterScope(this);\n        const proxy = createProxy(base, void 0);\n        let hasError = true;\n        try {\n          result = recipe(proxy);\n          hasError = false;\n        } finally {\n          if (hasError)\n            revokeScope(scope);\n          else\n            leaveScope(scope);\n        }\n        usePatchesInScope(scope, patchListener);\n        return processResult(result, scope);\n      } else if (!base || typeof base !== \"object\") {\n        result = recipe(base);\n        if (result === void 0)\n          result = base;\n        if (result === NOTHING)\n          result = void 0;\n        if (this.autoFreeze_)\n          freeze(result, true);\n        if (patchListener) {\n          const p = [];\n          const ip = [];\n          getPlugin(\"Patches\").generateReplacementPatches_(base, result, p, ip);\n          patchListener(p, ip);\n        }\n        return result;\n      } else\n        die(1, base);\n    };\n    this.produceWithPatches = (base, recipe) => {\n      if (typeof base === \"function\") {\n        return (state, ...args) => this.produceWithPatches(state, (draft) => base(draft, ...args));\n      }\n      let patches, inversePatches;\n      const result = this.produce(base, recipe, (p, ip) => {\n        patches = p;\n        inversePatches = ip;\n      });\n      return [result, patches, inversePatches];\n    };\n    if (typeof config?.autoFreeze === \"boolean\")\n      this.setAutoFreeze(config.autoFreeze);\n    if (typeof config?.useStrictShallowCopy === \"boolean\")\n      this.setUseStrictShallowCopy(config.useStrictShallowCopy);\n  }\n  createDraft(base) {\n    if (!isDraftable(base))\n      die(8);\n    if (isDraft(base))\n      base = current(base);\n    const scope = enterScope(this);\n    const proxy = createProxy(base, void 0);\n    proxy[DRAFT_STATE].isManual_ = true;\n    leaveScope(scope);\n    return proxy;\n  }\n  finishDraft(draft, patchListener) {\n    const state = draft && draft[DRAFT_STATE];\n    if (!state || !state.isManual_)\n      die(9);\n    const { scope_: scope } = state;\n    usePatchesInScope(scope, patchListener);\n    return processResult(void 0, scope);\n  }\n  /**\n   * Pass true to automatically freeze all copies created by Immer.\n   *\n   * By default, auto-freezing is enabled.\n   */\n  setAutoFreeze(value) {\n    this.autoFreeze_ = value;\n  }\n  /**\n   * Pass true to enable strict shallow copy.\n   *\n   * By default, immer does not copy the object descriptors such as getter, setter and non-enumrable properties.\n   */\n  setUseStrictShallowCopy(value) {\n    this.useStrictShallowCopy_ = value;\n  }\n  applyPatches(base, patches) {\n    let i;\n    for (i = patches.length - 1; i >= 0; i--) {\n      const patch = patches[i];\n      if (patch.path.length === 0 && patch.op === \"replace\") {\n        base = patch.value;\n        break;\n      }\n    }\n    if (i > -1) {\n      patches = patches.slice(i + 1);\n    }\n    const applyPatchesImpl = getPlugin(\"Patches\").applyPatches_;\n    if (isDraft(base)) {\n      return applyPatchesImpl(base, patches);\n    }\n    return this.produce(\n      base,\n      (draft) => applyPatchesImpl(draft, patches)\n    );\n  }\n};\nfunction createProxy(value, parent) {\n  const draft = isMap(value) ? getPlugin(\"MapSet\").proxyMap_(value, parent) : isSet(value) ? getPlugin(\"MapSet\").proxySet_(value, parent) : createProxyProxy(value, parent);\n  const scope = parent ? parent.scope_ : getCurrentScope();\n  scope.drafts_.push(draft);\n  return draft;\n}\n\n// src/core/current.ts\nfunction current(value) {\n  if (!isDraft(value))\n    die(10, value);\n  return currentImpl(value);\n}\nfunction currentImpl(value) {\n  if (!isDraftable(value) || isFrozen(value))\n    return value;\n  const state = value[DRAFT_STATE];\n  let copy;\n  if (state) {\n    if (!state.modified_)\n      return state.base_;\n    state.finalized_ = true;\n    copy = shallowCopy(value, state.scope_.immer_.useStrictShallowCopy_);\n  } else {\n    copy = shallowCopy(value, true);\n  }\n  each(copy, (key, childValue) => {\n    set(copy, key, currentImpl(childValue));\n  });\n  if (state) {\n    state.finalized_ = false;\n  }\n  return copy;\n}\n\n// src/plugins/patches.ts\nfunction enablePatches() {\n  const errorOffset = 16;\n  if (process.env.NODE_ENV !== \"production\") {\n    errors.push(\n      'Sets cannot have \"replace\" patches.',\n      function(op) {\n        return \"Unsupported patch operation: \" + op;\n      },\n      function(path) {\n        return \"Cannot apply patch, path doesn't resolve: \" + path;\n      },\n      \"Patching reserved attributes like __proto__, prototype and constructor is not allowed\"\n    );\n  }\n  const REPLACE = \"replace\";\n  const ADD = \"add\";\n  const REMOVE = \"remove\";\n  function generatePatches_(state, basePath, patches, inversePatches) {\n    switch (state.type_) {\n      case 0 /* Object */:\n      case 2 /* Map */:\n        return generatePatchesFromAssigned(\n          state,\n          basePath,\n          patches,\n          inversePatches\n        );\n      case 1 /* Array */:\n        return generateArrayPatches(state, basePath, patches, inversePatches);\n      case 3 /* Set */:\n        return generateSetPatches(\n          state,\n          basePath,\n          patches,\n          inversePatches\n        );\n    }\n  }\n  function generateArrayPatches(state, basePath, patches, inversePatches) {\n    let { base_, assigned_ } = state;\n    let copy_ = state.copy_;\n    if (copy_.length < base_.length) {\n      ;\n      [base_, copy_] = [copy_, base_];\n      [patches, inversePatches] = [inversePatches, patches];\n    }\n    for (let i = 0; i < base_.length; i++) {\n      if (assigned_[i] && copy_[i] !== base_[i]) {\n        const path = basePath.concat([i]);\n        patches.push({\n          op: REPLACE,\n          path,\n          // Need to maybe clone it, as it can in fact be the original value\n          // due to the base/copy inversion at the start of this function\n          value: clonePatchValueIfNeeded(copy_[i])\n        });\n        inversePatches.push({\n          op: REPLACE,\n          path,\n          value: clonePatchValueIfNeeded(base_[i])\n        });\n      }\n    }\n    for (let i = base_.length; i < copy_.length; i++) {\n      const path = basePath.concat([i]);\n      patches.push({\n        op: ADD,\n        path,\n        // Need to maybe clone it, as it can in fact be the original value\n        // due to the base/copy inversion at the start of this function\n        value: clonePatchValueIfNeeded(copy_[i])\n      });\n    }\n    for (let i = copy_.length - 1; base_.length <= i; --i) {\n      const path = basePath.concat([i]);\n      inversePatches.push({\n        op: REMOVE,\n        path\n      });\n    }\n  }\n  function generatePatchesFromAssigned(state, basePath, patches, inversePatches) {\n    const { base_, copy_ } = state;\n    each(state.assigned_, (key, assignedValue) => {\n      const origValue = get(base_, key);\n      const value = get(copy_, key);\n      const op = !assignedValue ? REMOVE : has(base_, key) ? REPLACE : ADD;\n      if (origValue === value && op === REPLACE)\n        return;\n      const path = basePath.concat(key);\n      patches.push(op === REMOVE ? { op, path } : { op, path, value });\n      inversePatches.push(\n        op === ADD ? { op: REMOVE, path } : op === REMOVE ? { op: ADD, path, value: clonePatchValueIfNeeded(origValue) } : { op: REPLACE, path, value: clonePatchValueIfNeeded(origValue) }\n      );\n    });\n  }\n  function generateSetPatches(state, basePath, patches, inversePatches) {\n    let { base_, copy_ } = state;\n    let i = 0;\n    base_.forEach((value) => {\n      if (!copy_.has(value)) {\n        const path = basePath.concat([i]);\n        patches.push({\n          op: REMOVE,\n          path,\n          value\n        });\n        inversePatches.unshift({\n          op: ADD,\n          path,\n          value\n        });\n      }\n      i++;\n    });\n    i = 0;\n    copy_.forEach((value) => {\n      if (!base_.has(value)) {\n        const path = basePath.concat([i]);\n        patches.push({\n          op: ADD,\n          path,\n          value\n        });\n        inversePatches.unshift({\n          op: REMOVE,\n          path,\n          value\n        });\n      }\n      i++;\n    });\n  }\n  function generateReplacementPatches_(baseValue, replacement, patches, inversePatches) {\n    patches.push({\n      op: REPLACE,\n      path: [],\n      value: replacement === NOTHING ? void 0 : replacement\n    });\n    inversePatches.push({\n      op: REPLACE,\n      path: [],\n      value: baseValue\n    });\n  }\n  function applyPatches_(draft, patches) {\n    patches.forEach((patch) => {\n      const { path, op } = patch;\n      let base = draft;\n      for (let i = 0; i < path.length - 1; i++) {\n        const parentType = getArchtype(base);\n        let p = path[i];\n        if (typeof p !== \"string\" && typeof p !== \"number\") {\n          p = \"\" + p;\n        }\n        if ((parentType === 0 /* Object */ || parentType === 1 /* Array */) && (p === \"__proto__\" || p === \"constructor\"))\n          die(errorOffset + 3);\n        if (typeof base === \"function\" && p === \"prototype\")\n          die(errorOffset + 3);\n        base = get(base, p);\n        if (typeof base !== \"object\")\n          die(errorOffset + 2, path.join(\"/\"));\n      }\n      const type = getArchtype(base);\n      const value = deepClonePatchValue(patch.value);\n      const key = path[path.length - 1];\n      switch (op) {\n        case REPLACE:\n          switch (type) {\n            case 2 /* Map */:\n              return base.set(key, value);\n            case 3 /* Set */:\n              die(errorOffset);\n            default:\n              return base[key] = value;\n          }\n        case ADD:\n          switch (type) {\n            case 1 /* Array */:\n              return key === \"-\" ? base.push(value) : base.splice(key, 0, value);\n            case 2 /* Map */:\n              return base.set(key, value);\n            case 3 /* Set */:\n              return base.add(value);\n            default:\n              return base[key] = value;\n          }\n        case REMOVE:\n          switch (type) {\n            case 1 /* Array */:\n              return base.splice(key, 1);\n            case 2 /* Map */:\n              return base.delete(key);\n            case 3 /* Set */:\n              return base.delete(patch.value);\n            default:\n              return delete base[key];\n          }\n        default:\n          die(errorOffset + 1, op);\n      }\n    });\n    return draft;\n  }\n  function deepClonePatchValue(obj) {\n    if (!isDraftable(obj))\n      return obj;\n    if (Array.isArray(obj))\n      return obj.map(deepClonePatchValue);\n    if (isMap(obj))\n      return new Map(\n        Array.from(obj.entries()).map(([k, v]) => [k, deepClonePatchValue(v)])\n      );\n    if (isSet(obj))\n      return new Set(Array.from(obj).map(deepClonePatchValue));\n    const cloned = Object.create(getPrototypeOf(obj));\n    for (const key in obj)\n      cloned[key] = deepClonePatchValue(obj[key]);\n    if (has(obj, DRAFTABLE))\n      cloned[DRAFTABLE] = obj[DRAFTABLE];\n    return cloned;\n  }\n  function clonePatchValueIfNeeded(obj) {\n    if (isDraft(obj)) {\n      return deepClonePatchValue(obj);\n    } else\n      return obj;\n  }\n  loadPlugin(\"Patches\", {\n    applyPatches_,\n    generatePatches_,\n    generateReplacementPatches_\n  });\n}\n\n// src/plugins/mapset.ts\nfunction enableMapSet() {\n  class DraftMap extends Map {\n    constructor(target, parent) {\n      super();\n      this[DRAFT_STATE] = {\n        type_: 2 /* Map */,\n        parent_: parent,\n        scope_: parent ? parent.scope_ : getCurrentScope(),\n        modified_: false,\n        finalized_: false,\n        copy_: void 0,\n        assigned_: void 0,\n        base_: target,\n        draft_: this,\n        isManual_: false,\n        revoked_: false\n      };\n    }\n    get size() {\n      return latest(this[DRAFT_STATE]).size;\n    }\n    has(key) {\n      return latest(this[DRAFT_STATE]).has(key);\n    }\n    set(key, value) {\n      const state = this[DRAFT_STATE];\n      assertUnrevoked(state);\n      if (!latest(state).has(key) || latest(state).get(key) !== value) {\n        prepareMapCopy(state);\n        markChanged(state);\n        state.assigned_.set(key, true);\n        state.copy_.set(key, value);\n        state.assigned_.set(key, true);\n      }\n      return this;\n    }\n    delete(key) {\n      if (!this.has(key)) {\n        return false;\n      }\n      const state = this[DRAFT_STATE];\n      assertUnrevoked(state);\n      prepareMapCopy(state);\n      markChanged(state);\n      if (state.base_.has(key)) {\n        state.assigned_.set(key, false);\n      } else {\n        state.assigned_.delete(key);\n      }\n      state.copy_.delete(key);\n      return true;\n    }\n    clear() {\n      const state = this[DRAFT_STATE];\n      assertUnrevoked(state);\n      if (latest(state).size) {\n        prepareMapCopy(state);\n        markChanged(state);\n        state.assigned_ = /* @__PURE__ */ new Map();\n        each(state.base_, (key) => {\n          state.assigned_.set(key, false);\n        });\n        state.copy_.clear();\n      }\n    }\n    forEach(cb, thisArg) {\n      const state = this[DRAFT_STATE];\n      latest(state).forEach((_value, key, _map) => {\n        cb.call(thisArg, this.get(key), key, this);\n      });\n    }\n    get(key) {\n      const state = this[DRAFT_STATE];\n      assertUnrevoked(state);\n      const value = latest(state).get(key);\n      if (state.finalized_ || !isDraftable(value)) {\n        return value;\n      }\n      if (value !== state.base_.get(key)) {\n        return value;\n      }\n      const draft = createProxy(value, state);\n      prepareMapCopy(state);\n      state.copy_.set(key, draft);\n      return draft;\n    }\n    keys() {\n      return latest(this[DRAFT_STATE]).keys();\n    }\n    values() {\n      const iterator = this.keys();\n      return {\n        [Symbol.iterator]: () => this.values(),\n        next: () => {\n          const r = iterator.next();\n          if (r.done)\n            return r;\n          const value = this.get(r.value);\n          return {\n            done: false,\n            value\n          };\n        }\n      };\n    }\n    entries() {\n      const iterator = this.keys();\n      return {\n        [Symbol.iterator]: () => this.entries(),\n        next: () => {\n          const r = iterator.next();\n          if (r.done)\n            return r;\n          const value = this.get(r.value);\n          return {\n            done: false,\n            value: [r.value, value]\n          };\n        }\n      };\n    }\n    [(DRAFT_STATE, Symbol.iterator)]() {\n      return this.entries();\n    }\n  }\n  function proxyMap_(target, parent) {\n    return new DraftMap(target, parent);\n  }\n  function prepareMapCopy(state) {\n    if (!state.copy_) {\n      state.assigned_ = /* @__PURE__ */ new Map();\n      state.copy_ = new Map(state.base_);\n    }\n  }\n  class DraftSet extends Set {\n    constructor(target, parent) {\n      super();\n      this[DRAFT_STATE] = {\n        type_: 3 /* Set */,\n        parent_: parent,\n        scope_: parent ? parent.scope_ : getCurrentScope(),\n        modified_: false,\n        finalized_: false,\n        copy_: void 0,\n        base_: target,\n        draft_: this,\n        drafts_: /* @__PURE__ */ new Map(),\n        revoked_: false,\n        isManual_: false\n      };\n    }\n    get size() {\n      return latest(this[DRAFT_STATE]).size;\n    }\n    has(value) {\n      const state = this[DRAFT_STATE];\n      assertUnrevoked(state);\n      if (!state.copy_) {\n        return state.base_.has(value);\n      }\n      if (state.copy_.has(value))\n        return true;\n      if (state.drafts_.has(value) && state.copy_.has(state.drafts_.get(value)))\n        return true;\n      return false;\n    }\n    add(value) {\n      const state = this[DRAFT_STATE];\n      assertUnrevoked(state);\n      if (!this.has(value)) {\n        prepareSetCopy(state);\n        markChanged(state);\n        state.copy_.add(value);\n      }\n      return this;\n    }\n    delete(value) {\n      if (!this.has(value)) {\n        return false;\n      }\n      const state = this[DRAFT_STATE];\n      assertUnrevoked(state);\n      prepareSetCopy(state);\n      markChanged(state);\n      return state.copy_.delete(value) || (state.drafts_.has(value) ? state.copy_.delete(state.drafts_.get(value)) : (\n        /* istanbul ignore next */\n        false\n      ));\n    }\n    clear() {\n      const state = this[DRAFT_STATE];\n      assertUnrevoked(state);\n      if (latest(state).size) {\n        prepareSetCopy(state);\n        markChanged(state);\n        state.copy_.clear();\n      }\n    }\n    values() {\n      const state = this[DRAFT_STATE];\n      assertUnrevoked(state);\n      prepareSetCopy(state);\n      return state.copy_.values();\n    }\n    entries() {\n      const state = this[DRAFT_STATE];\n      assertUnrevoked(state);\n      prepareSetCopy(state);\n      return state.copy_.entries();\n    }\n    keys() {\n      return this.values();\n    }\n    [(DRAFT_STATE, Symbol.iterator)]() {\n      return this.values();\n    }\n    forEach(cb, thisArg) {\n      const iterator = this.values();\n      let result = iterator.next();\n      while (!result.done) {\n        cb.call(thisArg, result.value, result.value, this);\n        result = iterator.next();\n      }\n    }\n  }\n  function proxySet_(target, parent) {\n    return new DraftSet(target, parent);\n  }\n  function prepareSetCopy(state) {\n    if (!state.copy_) {\n      state.copy_ = /* @__PURE__ */ new Set();\n      state.base_.forEach((value) => {\n        if (isDraftable(value)) {\n          const draft = createProxy(value, state);\n          state.drafts_.set(value, draft);\n          state.copy_.add(draft);\n        } else {\n          state.copy_.add(value);\n        }\n      });\n    }\n  }\n  function assertUnrevoked(state) {\n    if (state.revoked_)\n      die(3, JSON.stringify(latest(state)));\n  }\n  loadPlugin(\"MapSet\", { proxyMap_, proxySet_ });\n}\n\n// src/immer.ts\nvar immer = new Immer2();\nvar produce = immer.produce;\nvar produceWithPatches = immer.produceWithPatches.bind(\n  immer\n);\nvar setAutoFreeze = immer.setAutoFreeze.bind(immer);\nvar setUseStrictShallowCopy = immer.setUseStrictShallowCopy.bind(immer);\nvar applyPatches = immer.applyPatches.bind(immer);\nvar createDraft = immer.createDraft.bind(immer);\nvar finishDraft = immer.finishDraft.bind(immer);\nfunction castDraft(value) {\n  return value;\n}\nfunction castImmutable(value) {\n  return value;\n}\nexport {\n  Immer2 as Immer,\n  applyPatches,\n  castDraft,\n  castImmutable,\n  createDraft,\n  current,\n  enableMapSet,\n  enablePatches,\n  finishDraft,\n  freeze,\n  DRAFTABLE as immerable,\n  isDraft,\n  isDraftable,\n  NOTHING as nothing,\n  original,\n  produce,\n  produceWithPatches,\n  setAutoFreeze,\n  setUseStrictShallowCopy\n};\n//# sourceMappingURL=immer.mjs.map",
    "// src/devModeChecks/identityFunctionCheck.ts\nvar runIdentityFunctionCheck = (resultFunc) => {\n  let isInputSameAsOutput = false;\n  try {\n    const emptyObject = {};\n    if (resultFunc(emptyObject) === emptyObject)\n      isInputSameAsOutput = true;\n  } catch {\n  }\n  if (isInputSameAsOutput) {\n    let stack = void 0;\n    try {\n      throw new Error();\n    } catch (e) {\n      ;\n      ({ stack } = e);\n    }\n    console.warn(\n      \"The result function returned its own inputs without modification. e.g\\n`createSelector([state => state.todos], todos => todos)`\\nThis could lead to inefficient memoization and unnecessary re-renders.\\nEnsure transformation logic is in the result function, and extraction logic is in the input selectors.\",\n      { stack }\n    );\n  }\n};\n\n// src/devModeChecks/inputStabilityCheck.ts\nvar runInputStabilityCheck = (inputSelectorResultsObject, options, inputSelectorArgs) => {\n  const { memoize, memoizeOptions } = options;\n  const { inputSelectorResults, inputSelectorResultsCopy } = inputSelectorResultsObject;\n  const createAnEmptyObject = memoize(() => ({}), ...memoizeOptions);\n  const areInputSelectorResultsEqual = createAnEmptyObject.apply(null, inputSelectorResults) === createAnEmptyObject.apply(null, inputSelectorResultsCopy);\n  if (!areInputSelectorResultsEqual) {\n    let stack = void 0;\n    try {\n      throw new Error();\n    } catch (e) {\n      ;\n      ({ stack } = e);\n    }\n    console.warn(\n      \"An input selector returned a different result when passed same arguments.\\nThis means your output selector will likely run more frequently than intended.\\nAvoid returning a new reference inside your input selector, e.g.\\n`createSelector([state => state.todos.map(todo => todo.id)], todoIds => todoIds.length)`\",\n      {\n        arguments: inputSelectorArgs,\n        firstInputs: inputSelectorResults,\n        secondInputs: inputSelectorResultsCopy,\n        stack\n      }\n    );\n  }\n};\n\n// src/devModeChecks/setGlobalDevModeChecks.ts\nvar globalDevModeChecks = {\n  inputStabilityCheck: \"once\",\n  identityFunctionCheck: \"once\"\n};\nvar setGlobalDevModeChecks = (devModeChecks) => {\n  Object.assign(globalDevModeChecks, devModeChecks);\n};\n\n// src/utils.ts\nvar NOT_FOUND = \"NOT_FOUND\";\nfunction assertIsFunction(func, errorMessage = `expected a function, instead received ${typeof func}`) {\n  if (typeof func !== \"function\") {\n    throw new TypeError(errorMessage);\n  }\n}\nfunction assertIsObject(object, errorMessage = `expected an object, instead received ${typeof object}`) {\n  if (typeof object !== \"object\") {\n    throw new TypeError(errorMessage);\n  }\n}\nfunction assertIsArrayOfFunctions(array, errorMessage = `expected all items to be functions, instead received the following types: `) {\n  if (!array.every((item) => typeof item === \"function\")) {\n    const itemTypes = array.map(\n      (item) => typeof item === \"function\" ? `function ${item.name || \"unnamed\"}()` : typeof item\n    ).join(\", \");\n    throw new TypeError(`${errorMessage}[${itemTypes}]`);\n  }\n}\nvar ensureIsArray = (item) => {\n  return Array.isArray(item) ? item : [item];\n};\nfunction getDependencies(createSelectorArgs) {\n  const dependencies = Array.isArray(createSelectorArgs[0]) ? createSelectorArgs[0] : createSelectorArgs;\n  assertIsArrayOfFunctions(\n    dependencies,\n    `createSelector expects all input-selectors to be functions, but received the following types: `\n  );\n  return dependencies;\n}\nfunction collectInputSelectorResults(dependencies, inputSelectorArgs) {\n  const inputSelectorResults = [];\n  const { length } = dependencies;\n  for (let i = 0; i < length; i++) {\n    inputSelectorResults.push(dependencies[i].apply(null, inputSelectorArgs));\n  }\n  return inputSelectorResults;\n}\nvar getDevModeChecksExecutionInfo = (firstRun, devModeChecks) => {\n  const { identityFunctionCheck, inputStabilityCheck } = {\n    ...globalDevModeChecks,\n    ...devModeChecks\n  };\n  return {\n    identityFunctionCheck: {\n      shouldRun: identityFunctionCheck === \"always\" || identityFunctionCheck === \"once\" && firstRun,\n      run: runIdentityFunctionCheck\n    },\n    inputStabilityCheck: {\n      shouldRun: inputStabilityCheck === \"always\" || inputStabilityCheck === \"once\" && firstRun,\n      run: runInputStabilityCheck\n    }\n  };\n};\n\n// src/autotrackMemoize/autotracking.ts\nvar $REVISION = 0;\nvar CURRENT_TRACKER = null;\nvar Cell = class {\n  revision = $REVISION;\n  _value;\n  _lastValue;\n  _isEqual = tripleEq;\n  constructor(initialValue, isEqual = tripleEq) {\n    this._value = this._lastValue = initialValue;\n    this._isEqual = isEqual;\n  }\n  // Whenever a storage value is read, it'll add itself to the current tracker if\n  // one exists, entangling its state with that cache.\n  get value() {\n    CURRENT_TRACKER?.add(this);\n    return this._value;\n  }\n  // Whenever a storage value is updated, we bump the global revision clock,\n  // assign the revision for this storage to the new value, _and_ we schedule a\n  // rerender. This is important, and it's what makes autotracking  _pull_\n  // based. We don't actively tell the caches which depend on the storage that\n  // anything has happened. Instead, we recompute the caches when needed.\n  set value(newValue) {\n    if (this.value === newValue)\n      return;\n    this._value = newValue;\n    this.revision = ++$REVISION;\n  }\n};\nfunction tripleEq(a, b) {\n  return a === b;\n}\nvar TrackingCache = class {\n  _cachedValue;\n  _cachedRevision = -1;\n  _deps = [];\n  hits = 0;\n  fn;\n  constructor(fn) {\n    this.fn = fn;\n  }\n  clear() {\n    this._cachedValue = void 0;\n    this._cachedRevision = -1;\n    this._deps = [];\n    this.hits = 0;\n  }\n  get value() {\n    if (this.revision > this._cachedRevision) {\n      const { fn } = this;\n      const currentTracker = /* @__PURE__ */ new Set();\n      const prevTracker = CURRENT_TRACKER;\n      CURRENT_TRACKER = currentTracker;\n      this._cachedValue = fn();\n      CURRENT_TRACKER = prevTracker;\n      this.hits++;\n      this._deps = Array.from(currentTracker);\n      this._cachedRevision = this.revision;\n    }\n    CURRENT_TRACKER?.add(this);\n    return this._cachedValue;\n  }\n  get revision() {\n    return Math.max(...this._deps.map((d) => d.revision), 0);\n  }\n};\nfunction getValue(cell) {\n  if (!(cell instanceof Cell)) {\n    console.warn(\"Not a valid cell! \", cell);\n  }\n  return cell.value;\n}\nfunction setValue(storage, value) {\n  if (!(storage instanceof Cell)) {\n    throw new TypeError(\n      \"setValue must be passed a tracked store created with `createStorage`.\"\n    );\n  }\n  storage.value = storage._lastValue = value;\n}\nfunction createCell(initialValue, isEqual = tripleEq) {\n  return new Cell(initialValue, isEqual);\n}\nfunction createCache(fn) {\n  assertIsFunction(\n    fn,\n    \"the first parameter to `createCache` must be a function\"\n  );\n  return new TrackingCache(fn);\n}\n\n// src/autotrackMemoize/tracking.ts\nvar neverEq = (a, b) => false;\nfunction createTag() {\n  return createCell(null, neverEq);\n}\nfunction dirtyTag(tag, value) {\n  setValue(tag, value);\n}\nvar consumeCollection = (node) => {\n  let tag = node.collectionTag;\n  if (tag === null) {\n    tag = node.collectionTag = createTag();\n  }\n  getValue(tag);\n};\nvar dirtyCollection = (node) => {\n  const tag = node.collectionTag;\n  if (tag !== null) {\n    dirtyTag(tag, null);\n  }\n};\n\n// src/autotrackMemoize/proxy.ts\nvar REDUX_PROXY_LABEL = Symbol();\nvar nextId = 0;\nvar proto = Object.getPrototypeOf({});\nvar ObjectTreeNode = class {\n  constructor(value) {\n    this.value = value;\n    this.value = value;\n    this.tag.value = value;\n  }\n  proxy = new Proxy(this, objectProxyHandler);\n  tag = createTag();\n  tags = {};\n  children = {};\n  collectionTag = null;\n  id = nextId++;\n};\nvar objectProxyHandler = {\n  get(node, key) {\n    function calculateResult() {\n      const { value } = node;\n      const childValue = Reflect.get(value, key);\n      if (typeof key === \"symbol\") {\n        return childValue;\n      }\n      if (key in proto) {\n        return childValue;\n      }\n      if (typeof childValue === \"object\" && childValue !== null) {\n        let childNode = node.children[key];\n        if (childNode === void 0) {\n          childNode = node.children[key] = createNode(childValue);\n        }\n        if (childNode.tag) {\n          getValue(childNode.tag);\n        }\n        return childNode.proxy;\n      } else {\n        let tag = node.tags[key];\n        if (tag === void 0) {\n          tag = node.tags[key] = createTag();\n          tag.value = childValue;\n        }\n        getValue(tag);\n        return childValue;\n      }\n    }\n    const res = calculateResult();\n    return res;\n  },\n  ownKeys(node) {\n    consumeCollection(node);\n    return Reflect.ownKeys(node.value);\n  },\n  getOwnPropertyDescriptor(node, prop) {\n    return Reflect.getOwnPropertyDescriptor(node.value, prop);\n  },\n  has(node, prop) {\n    return Reflect.has(node.value, prop);\n  }\n};\nvar ArrayTreeNode = class {\n  constructor(value) {\n    this.value = value;\n    this.value = value;\n    this.tag.value = value;\n  }\n  proxy = new Proxy([this], arrayProxyHandler);\n  tag = createTag();\n  tags = {};\n  children = {};\n  collectionTag = null;\n  id = nextId++;\n};\nvar arrayProxyHandler = {\n  get([node], key) {\n    if (key === \"length\") {\n      consumeCollection(node);\n    }\n    return objectProxyHandler.get(node, key);\n  },\n  ownKeys([node]) {\n    return objectProxyHandler.ownKeys(node);\n  },\n  getOwnPropertyDescriptor([node], prop) {\n    return objectProxyHandler.getOwnPropertyDescriptor(node, prop);\n  },\n  has([node], prop) {\n    return objectProxyHandler.has(node, prop);\n  }\n};\nfunction createNode(value) {\n  if (Array.isArray(value)) {\n    return new ArrayTreeNode(value);\n  }\n  return new ObjectTreeNode(value);\n}\nfunction updateNode(node, newValue) {\n  const { value, tags, children } = node;\n  node.value = newValue;\n  if (Array.isArray(value) && Array.isArray(newValue) && value.length !== newValue.length) {\n    dirtyCollection(node);\n  } else {\n    if (value !== newValue) {\n      let oldKeysSize = 0;\n      let newKeysSize = 0;\n      let anyKeysAdded = false;\n      for (const _key in value) {\n        oldKeysSize++;\n      }\n      for (const key in newValue) {\n        newKeysSize++;\n        if (!(key in value)) {\n          anyKeysAdded = true;\n          break;\n        }\n      }\n      const isDifferent = anyKeysAdded || oldKeysSize !== newKeysSize;\n      if (isDifferent) {\n        dirtyCollection(node);\n      }\n    }\n  }\n  for (const key in tags) {\n    const childValue = value[key];\n    const newChildValue = newValue[key];\n    if (childValue !== newChildValue) {\n      dirtyCollection(node);\n      dirtyTag(tags[key], newChildValue);\n    }\n    if (typeof newChildValue === \"object\" && newChildValue !== null) {\n      delete tags[key];\n    }\n  }\n  for (const key in children) {\n    const childNode = children[key];\n    const newChildValue = newValue[key];\n    const childValue = childNode.value;\n    if (childValue === newChildValue) {\n      continue;\n    } else if (typeof newChildValue === \"object\" && newChildValue !== null) {\n      updateNode(childNode, newChildValue);\n    } else {\n      deleteNode(childNode);\n      delete children[key];\n    }\n  }\n}\nfunction deleteNode(node) {\n  if (node.tag) {\n    dirtyTag(node.tag, null);\n  }\n  dirtyCollection(node);\n  for (const key in node.tags) {\n    dirtyTag(node.tags[key], null);\n  }\n  for (const key in node.children) {\n    deleteNode(node.children[key]);\n  }\n}\n\n// src/lruMemoize.ts\nfunction createSingletonCache(equals) {\n  let entry;\n  return {\n    get(key) {\n      if (entry && equals(entry.key, key)) {\n        return entry.value;\n      }\n      return NOT_FOUND;\n    },\n    put(key, value) {\n      entry = { key, value };\n    },\n    getEntries() {\n      return entry ? [entry] : [];\n    },\n    clear() {\n      entry = void 0;\n    }\n  };\n}\nfunction createLruCache(maxSize, equals) {\n  let entries = [];\n  function get(key) {\n    const cacheIndex = entries.findIndex((entry) => equals(key, entry.key));\n    if (cacheIndex > -1) {\n      const entry = entries[cacheIndex];\n      if (cacheIndex > 0) {\n        entries.splice(cacheIndex, 1);\n        entries.unshift(entry);\n      }\n      return entry.value;\n    }\n    return NOT_FOUND;\n  }\n  function put(key, value) {\n    if (get(key) === NOT_FOUND) {\n      entries.unshift({ key, value });\n      if (entries.length > maxSize) {\n        entries.pop();\n      }\n    }\n  }\n  function getEntries() {\n    return entries;\n  }\n  function clear() {\n    entries = [];\n  }\n  return { get, put, getEntries, clear };\n}\nvar referenceEqualityCheck = (a, b) => a === b;\nfunction createCacheKeyComparator(equalityCheck) {\n  return function areArgumentsShallowlyEqual(prev, next) {\n    if (prev === null || next === null || prev.length !== next.length) {\n      return false;\n    }\n    const { length } = prev;\n    for (let i = 0; i < length; i++) {\n      if (!equalityCheck(prev[i], next[i])) {\n        return false;\n      }\n    }\n    return true;\n  };\n}\nfunction lruMemoize(func, equalityCheckOrOptions) {\n  const providedOptions = typeof equalityCheckOrOptions === \"object\" ? equalityCheckOrOptions : { equalityCheck: equalityCheckOrOptions };\n  const {\n    equalityCheck = referenceEqualityCheck,\n    maxSize = 1,\n    resultEqualityCheck\n  } = providedOptions;\n  const comparator = createCacheKeyComparator(equalityCheck);\n  let resultsCount = 0;\n  const cache = maxSize === 1 ? createSingletonCache(comparator) : createLruCache(maxSize, comparator);\n  function memoized() {\n    let value = cache.get(arguments);\n    if (value === NOT_FOUND) {\n      value = func.apply(null, arguments);\n      resultsCount++;\n      if (resultEqualityCheck) {\n        const entries = cache.getEntries();\n        const matchingEntry = entries.find(\n          (entry) => resultEqualityCheck(entry.value, value)\n        );\n        if (matchingEntry) {\n          value = matchingEntry.value;\n          resultsCount !== 0 && resultsCount--;\n        }\n      }\n      cache.put(arguments, value);\n    }\n    return value;\n  }\n  memoized.clearCache = () => {\n    cache.clear();\n    memoized.resetResultsCount();\n  };\n  memoized.resultsCount = () => resultsCount;\n  memoized.resetResultsCount = () => {\n    resultsCount = 0;\n  };\n  return memoized;\n}\n\n// src/autotrackMemoize/autotrackMemoize.ts\nfunction autotrackMemoize(func) {\n  const node = createNode(\n    []\n  );\n  let lastArgs = null;\n  const shallowEqual = createCacheKeyComparator(referenceEqualityCheck);\n  const cache = createCache(() => {\n    const res = func.apply(null, node.proxy);\n    return res;\n  });\n  function memoized() {\n    if (!shallowEqual(lastArgs, arguments)) {\n      updateNode(node, arguments);\n      lastArgs = arguments;\n    }\n    return cache.value;\n  }\n  memoized.clearCache = () => {\n    return cache.clear();\n  };\n  return memoized;\n}\n\n// src/weakMapMemoize.ts\nvar StrongRef = class {\n  constructor(value) {\n    this.value = value;\n  }\n  deref() {\n    return this.value;\n  }\n};\nvar Ref = typeof WeakRef !== \"undefined\" ? WeakRef : StrongRef;\nvar UNTERMINATED = 0;\nvar TERMINATED = 1;\nfunction createCacheNode() {\n  return {\n    s: UNTERMINATED,\n    v: void 0,\n    o: null,\n    p: null\n  };\n}\nfunction weakMapMemoize(func, options = {}) {\n  let fnNode = createCacheNode();\n  const { resultEqualityCheck } = options;\n  let lastResult;\n  let resultsCount = 0;\n  function memoized() {\n    let cacheNode = fnNode;\n    const { length } = arguments;\n    for (let i = 0, l = length; i < l; i++) {\n      const arg = arguments[i];\n      if (typeof arg === \"function\" || typeof arg === \"object\" && arg !== null) {\n        let objectCache = cacheNode.o;\n        if (objectCache === null) {\n          cacheNode.o = objectCache = /* @__PURE__ */ new WeakMap();\n        }\n        const objectNode = objectCache.get(arg);\n        if (objectNode === void 0) {\n          cacheNode = createCacheNode();\n          objectCache.set(arg, cacheNode);\n        } else {\n          cacheNode = objectNode;\n        }\n      } else {\n        let primitiveCache = cacheNode.p;\n        if (primitiveCache === null) {\n          cacheNode.p = primitiveCache = /* @__PURE__ */ new Map();\n        }\n        const primitiveNode = primitiveCache.get(arg);\n        if (primitiveNode === void 0) {\n          cacheNode = createCacheNode();\n          primitiveCache.set(arg, cacheNode);\n        } else {\n          cacheNode = primitiveNode;\n        }\n      }\n    }\n    const terminatedNode = cacheNode;\n    let result;\n    if (cacheNode.s === TERMINATED) {\n      result = cacheNode.v;\n    } else {\n      result = func.apply(null, arguments);\n      resultsCount++;\n    }\n    terminatedNode.s = TERMINATED;\n    if (resultEqualityCheck) {\n      const lastResultValue = lastResult?.deref() ?? lastResult;\n      if (lastResultValue != null && resultEqualityCheck(lastResultValue, result)) {\n        result = lastResultValue;\n        resultsCount !== 0 && resultsCount--;\n      }\n      const needsWeakRef = typeof result === \"object\" && result !== null || typeof result === \"function\";\n      lastResult = needsWeakRef ? new Ref(result) : result;\n    }\n    terminatedNode.v = result;\n    return result;\n  }\n  memoized.clearCache = () => {\n    fnNode = createCacheNode();\n    memoized.resetResultsCount();\n  };\n  memoized.resultsCount = () => resultsCount;\n  memoized.resetResultsCount = () => {\n    resultsCount = 0;\n  };\n  return memoized;\n}\n\n// src/createSelectorCreator.ts\nfunction createSelectorCreator(memoizeOrOptions, ...memoizeOptionsFromArgs) {\n  const createSelectorCreatorOptions = typeof memoizeOrOptions === \"function\" ? {\n    memoize: memoizeOrOptions,\n    memoizeOptions: memoizeOptionsFromArgs\n  } : memoizeOrOptions;\n  const createSelector2 = (...createSelectorArgs) => {\n    let recomputations = 0;\n    let dependencyRecomputations = 0;\n    let lastResult;\n    let directlyPassedOptions = {};\n    let resultFunc = createSelectorArgs.pop();\n    if (typeof resultFunc === \"object\") {\n      directlyPassedOptions = resultFunc;\n      resultFunc = createSelectorArgs.pop();\n    }\n    assertIsFunction(\n      resultFunc,\n      `createSelector expects an output function after the inputs, but received: [${typeof resultFunc}]`\n    );\n    const combinedOptions = {\n      ...createSelectorCreatorOptions,\n      ...directlyPassedOptions\n    };\n    const {\n      memoize,\n      memoizeOptions = [],\n      argsMemoize = weakMapMemoize,\n      argsMemoizeOptions = [],\n      devModeChecks = {}\n    } = combinedOptions;\n    const finalMemoizeOptions = ensureIsArray(memoizeOptions);\n    const finalArgsMemoizeOptions = ensureIsArray(argsMemoizeOptions);\n    const dependencies = getDependencies(createSelectorArgs);\n    const memoizedResultFunc = memoize(function recomputationWrapper() {\n      recomputations++;\n      return resultFunc.apply(\n        null,\n        arguments\n      );\n    }, ...finalMemoizeOptions);\n    let firstRun = true;\n    const selector = argsMemoize(function dependenciesChecker() {\n      dependencyRecomputations++;\n      const inputSelectorResults = collectInputSelectorResults(\n        dependencies,\n        arguments\n      );\n      if (process.env.NODE_ENV !== \"production\") {\n        const { identityFunctionCheck, inputStabilityCheck } = getDevModeChecksExecutionInfo(firstRun, devModeChecks);\n        if (identityFunctionCheck.shouldRun) {\n          identityFunctionCheck.run(\n            resultFunc\n          );\n        }\n        if (inputStabilityCheck.shouldRun) {\n          const inputSelectorResultsCopy = collectInputSelectorResults(\n            dependencies,\n            arguments\n          );\n          inputStabilityCheck.run(\n            { inputSelectorResults, inputSelectorResultsCopy },\n            { memoize, memoizeOptions: finalMemoizeOptions },\n            arguments\n          );\n        }\n        if (firstRun)\n          firstRun = false;\n      }\n      lastResult = memoizedResultFunc.apply(null, inputSelectorResults);\n      return lastResult;\n    }, ...finalArgsMemoizeOptions);\n    return Object.assign(selector, {\n      resultFunc,\n      memoizedResultFunc,\n      dependencies,\n      dependencyRecomputations: () => dependencyRecomputations,\n      resetDependencyRecomputations: () => {\n        dependencyRecomputations = 0;\n      },\n      lastResult: () => lastResult,\n      recomputations: () => recomputations,\n      resetRecomputations: () => {\n        recomputations = 0;\n      },\n      memoize,\n      argsMemoize\n    });\n  };\n  return createSelector2;\n}\nvar createSelector = /* @__PURE__ */ createSelectorCreator(weakMapMemoize);\n\n// src/createStructuredSelector.ts\nvar createStructuredSelector = (inputSelectorsObject, selectorCreator = createSelector) => {\n  assertIsObject(\n    inputSelectorsObject,\n    `createStructuredSelector expects first argument to be an object where each property is a selector, instead received a ${typeof inputSelectorsObject}`\n  );\n  const inputSelectorKeys = Object.keys(inputSelectorsObject);\n  const dependencies = inputSelectorKeys.map((key) => inputSelectorsObject[key]);\n  const structuredSelector = selectorCreator(\n    dependencies,\n    (...inputSelectorResults) => {\n      return inputSelectorResults.reduce((composition, value, index) => {\n        composition[inputSelectorKeys[index]] = value;\n        return composition;\n      }, {});\n    }\n  );\n  return structuredSelector;\n};\nexport {\n  createSelector,\n  createSelectorCreator,\n  createStructuredSelector,\n  lruMemoize,\n  referenceEqualityCheck,\n  setGlobalDevModeChecks,\n  autotrackMemoize as unstable_autotrackMemoize,\n  weakMapMemoize\n};\n//# sourceMappingURL=reselect.mjs.map",
    "// src/index.ts\nfunction createThunkMiddleware(extraArgument) {\n  const middleware = ({ dispatch, getState }) => (next) => (action) => {\n    if (typeof action === \"function\") {\n      return action(dispatch, getState, extraArgument);\n    }\n    return next(action);\n  };\n  return middleware;\n}\nvar thunk = createThunkMiddleware();\nvar withExtraArgument = createThunkMiddleware;\nexport {\n  thunk,\n  withExtraArgument\n};\n",
    "// src/index.ts\nexport * from \"redux\";\nimport { produce, current as current2, freeze, original as original2, isDraft as isDraft4 } from \"immer\";\nimport { createSelector, createSelectorCreator as createSelectorCreator2, lruMemoize, weakMapMemoize as weakMapMemoize2 } from \"reselect\";\n\n// src/createDraftSafeSelector.ts\nimport { current, isDraft } from \"immer\";\nimport { createSelectorCreator, weakMapMemoize } from \"reselect\";\nvar createDraftSafeSelectorCreator = (...args) => {\n  const createSelector2 = createSelectorCreator(...args);\n  const createDraftSafeSelector2 = Object.assign((...args2) => {\n    const selector = createSelector2(...args2);\n    const wrappedSelector = (value, ...rest) => selector(isDraft(value) ? current(value) : value, ...rest);\n    Object.assign(wrappedSelector, selector);\n    return wrappedSelector;\n  }, {\n    withTypes: () => createDraftSafeSelector2\n  });\n  return createDraftSafeSelector2;\n};\nvar createDraftSafeSelector = createDraftSafeSelectorCreator(weakMapMemoize);\n\n// src/configureStore.ts\nimport { applyMiddleware, createStore, compose as compose2, combineReducers, isPlainObject as isPlainObject2 } from \"redux\";\n\n// src/devtoolsExtension.ts\nimport { compose } from \"redux\";\nvar composeWithDevTools = typeof window !== \"undefined\" && window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ ? window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ : function() {\n  if (arguments.length === 0)\n    return void 0;\n  if (typeof arguments[0] === \"object\")\n    return compose;\n  return compose.apply(null, arguments);\n};\nvar devToolsEnhancer = typeof window !== \"undefined\" && window.__REDUX_DEVTOOLS_EXTENSION__ ? window.__REDUX_DEVTOOLS_EXTENSION__ : function() {\n  return function(noop3) {\n    return noop3;\n  };\n};\n\n// src/getDefaultMiddleware.ts\nimport { thunk as thunkMiddleware, withExtraArgument } from \"redux-thunk\";\n\n// src/createAction.ts\nimport { isAction } from \"redux\";\n\n// src/tsHelpers.ts\nvar hasMatchFunction = (v) => {\n  return v && typeof v.match === \"function\";\n};\n\n// src/createAction.ts\nfunction createAction(type, prepareAction) {\n  function actionCreator(...args) {\n    if (prepareAction) {\n      let prepared = prepareAction(...args);\n      if (!prepared) {\n        throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(0) : \"prepareAction did not return an object\");\n      }\n      return {\n        type,\n        payload: prepared.payload,\n        ...\"meta\" in prepared && {\n          meta: prepared.meta\n        },\n        ...\"error\" in prepared && {\n          error: prepared.error\n        }\n      };\n    }\n    return {\n      type,\n      payload: args[0]\n    };\n  }\n  actionCreator.toString = () => `${type}`;\n  actionCreator.type = type;\n  actionCreator.match = (action) => isAction(action) && action.type === type;\n  return actionCreator;\n}\nfunction isActionCreator(action) {\n  return typeof action === \"function\" && \"type\" in action && // hasMatchFunction only wants Matchers but I don't see the point in rewriting it\n  hasMatchFunction(action);\n}\nfunction isFSA(action) {\n  return isAction(action) && Object.keys(action).every(isValidKey);\n}\nfunction isValidKey(key) {\n  return [\"type\", \"payload\", \"error\", \"meta\"].indexOf(key) > -1;\n}\n\n// src/actionCreatorInvariantMiddleware.ts\nfunction getMessage(type) {\n  const splitType = type ? `${type}`.split(\"/\") : [];\n  const actionName = splitType[splitType.length - 1] || \"actionCreator\";\n  return `Detected an action creator with type \"${type || \"unknown\"}\" being dispatched. \nMake sure you're calling the action creator before dispatching, i.e. \\`dispatch(${actionName}())\\` instead of \\`dispatch(${actionName})\\`. This is necessary even if the action has no payload.`;\n}\nfunction createActionCreatorInvariantMiddleware(options = {}) {\n  if (process.env.NODE_ENV === \"production\") {\n    return () => (next) => (action) => next(action);\n  }\n  const {\n    isActionCreator: isActionCreator2 = isActionCreator\n  } = options;\n  return () => (next) => (action) => {\n    if (isActionCreator2(action)) {\n      console.warn(getMessage(action.type));\n    }\n    return next(action);\n  };\n}\n\n// src/utils.ts\nimport { produce as createNextState, isDraftable } from \"immer\";\nfunction getTimeMeasureUtils(maxDelay, fnName) {\n  let elapsed = 0;\n  return {\n    measureTime(fn) {\n      const started = Date.now();\n      try {\n        return fn();\n      } finally {\n        const finished = Date.now();\n        elapsed += finished - started;\n      }\n    },\n    warnIfExceeded() {\n      if (elapsed > maxDelay) {\n        console.warn(`${fnName} took ${elapsed}ms, which is more than the warning threshold of ${maxDelay}ms. \nIf your state or actions are very large, you may want to disable the middleware as it might cause too much of a slowdown in development mode. See https://redux-toolkit.js.org/api/getDefaultMiddleware for instructions.\nIt is disabled in production builds, so you don't need to worry about that.`);\n      }\n    }\n  };\n}\nfunction find(iterable, comparator) {\n  for (const entry of iterable) {\n    if (comparator(entry)) {\n      return entry;\n    }\n  }\n  return void 0;\n}\nvar Tuple = class _Tuple extends Array {\n  constructor(...items) {\n    super(...items);\n    Object.setPrototypeOf(this, _Tuple.prototype);\n  }\n  static get [Symbol.species]() {\n    return _Tuple;\n  }\n  concat(...arr) {\n    return super.concat.apply(this, arr);\n  }\n  prepend(...arr) {\n    if (arr.length === 1 && Array.isArray(arr[0])) {\n      return new _Tuple(...arr[0].concat(this));\n    }\n    return new _Tuple(...arr.concat(this));\n  }\n};\nfunction freezeDraftable(val) {\n  return isDraftable(val) ? createNextState(val, () => {\n  }) : val;\n}\nfunction emplace(map, key, handler) {\n  if (map.has(key)) {\n    let value = map.get(key);\n    if (handler.update) {\n      value = handler.update(value, key, map);\n      map.set(key, value);\n    }\n    return value;\n  }\n  if (!handler.insert)\n    throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(10) : \"No insert provided for key not already in map\");\n  const inserted = handler.insert(key, map);\n  map.set(key, inserted);\n  return inserted;\n}\n\n// src/immutableStateInvariantMiddleware.ts\nfunction isImmutableDefault(value) {\n  return typeof value !== \"object\" || value == null || Object.isFrozen(value);\n}\nfunction trackForMutations(isImmutable, ignorePaths, obj) {\n  const trackedProperties = trackProperties(isImmutable, ignorePaths, obj);\n  return {\n    detectMutations() {\n      return detectMutations(isImmutable, ignorePaths, trackedProperties, obj);\n    }\n  };\n}\nfunction trackProperties(isImmutable, ignorePaths = [], obj, path = \"\", checkedObjects = /* @__PURE__ */ new Set()) {\n  const tracked = {\n    value: obj\n  };\n  if (!isImmutable(obj) && !checkedObjects.has(obj)) {\n    checkedObjects.add(obj);\n    tracked.children = {};\n    for (const key in obj) {\n      const childPath = path ? path + \".\" + key : key;\n      if (ignorePaths.length && ignorePaths.indexOf(childPath) !== -1) {\n        continue;\n      }\n      tracked.children[key] = trackProperties(isImmutable, ignorePaths, obj[key], childPath);\n    }\n  }\n  return tracked;\n}\nfunction detectMutations(isImmutable, ignoredPaths = [], trackedProperty, obj, sameParentRef = false, path = \"\") {\n  const prevObj = trackedProperty ? trackedProperty.value : void 0;\n  const sameRef = prevObj === obj;\n  if (sameParentRef && !sameRef && !Number.isNaN(obj)) {\n    return {\n      wasMutated: true,\n      path\n    };\n  }\n  if (isImmutable(prevObj) || isImmutable(obj)) {\n    return {\n      wasMutated: false\n    };\n  }\n  const keysToDetect = {};\n  for (let key in trackedProperty.children) {\n    keysToDetect[key] = true;\n  }\n  for (let key in obj) {\n    keysToDetect[key] = true;\n  }\n  const hasIgnoredPaths = ignoredPaths.length > 0;\n  for (let key in keysToDetect) {\n    const nestedPath = path ? path + \".\" + key : key;\n    if (hasIgnoredPaths) {\n      const hasMatches = ignoredPaths.some((ignored) => {\n        if (ignored instanceof RegExp) {\n          return ignored.test(nestedPath);\n        }\n        return nestedPath === ignored;\n      });\n      if (hasMatches) {\n        continue;\n      }\n    }\n    const result = detectMutations(isImmutable, ignoredPaths, trackedProperty.children[key], obj[key], sameRef, nestedPath);\n    if (result.wasMutated) {\n      return result;\n    }\n  }\n  return {\n    wasMutated: false\n  };\n}\nfunction createImmutableStateInvariantMiddleware(options = {}) {\n  if (process.env.NODE_ENV === \"production\") {\n    return () => (next) => (action) => next(action);\n  } else {\n    let stringify2 = function(obj, serializer, indent, decycler) {\n      return JSON.stringify(obj, getSerialize2(serializer, decycler), indent);\n    }, getSerialize2 = function(serializer, decycler) {\n      let stack = [], keys = [];\n      if (!decycler)\n        decycler = function(_, value) {\n          if (stack[0] === value)\n            return \"[Circular ~]\";\n          return \"[Circular ~.\" + keys.slice(0, stack.indexOf(value)).join(\".\") + \"]\";\n        };\n      return function(key, value) {\n        if (stack.length > 0) {\n          var thisPos = stack.indexOf(this);\n          ~thisPos ? stack.splice(thisPos + 1) : stack.push(this);\n          ~thisPos ? keys.splice(thisPos, Infinity, key) : keys.push(key);\n          if (~stack.indexOf(value))\n            value = decycler.call(this, key, value);\n        } else\n          stack.push(value);\n        return serializer == null ? value : serializer.call(this, key, value);\n      };\n    };\n    var stringify = stringify2, getSerialize = getSerialize2;\n    let {\n      isImmutable = isImmutableDefault,\n      ignoredPaths,\n      warnAfter = 32\n    } = options;\n    const track = trackForMutations.bind(null, isImmutable, ignoredPaths);\n    return ({\n      getState\n    }) => {\n      let state = getState();\n      let tracker = track(state);\n      let result;\n      return (next) => (action) => {\n        const measureUtils = getTimeMeasureUtils(warnAfter, \"ImmutableStateInvariantMiddleware\");\n        measureUtils.measureTime(() => {\n          state = getState();\n          result = tracker.detectMutations();\n          tracker = track(state);\n          if (result.wasMutated) {\n            throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(19) : `A state mutation was detected between dispatches, in the path '${result.path || \"\"}'.  This may cause incorrect behavior. (https://redux.js.org/style-guide/style-guide#do-not-mutate-state)`);\n          }\n        });\n        const dispatchedAction = next(action);\n        measureUtils.measureTime(() => {\n          state = getState();\n          result = tracker.detectMutations();\n          tracker = track(state);\n          if (result.wasMutated) {\n            throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(20) : `A state mutation was detected inside a dispatch, in the path: ${result.path || \"\"}. Take a look at the reducer(s) handling the action ${stringify2(action)}. (https://redux.js.org/style-guide/style-guide#do-not-mutate-state)`);\n          }\n        });\n        measureUtils.warnIfExceeded();\n        return dispatchedAction;\n      };\n    };\n  }\n}\n\n// src/serializableStateInvariantMiddleware.ts\nimport { isAction as isAction2, isPlainObject } from \"redux\";\nfunction isPlain(val) {\n  const type = typeof val;\n  return val == null || type === \"string\" || type === \"boolean\" || type === \"number\" || Array.isArray(val) || isPlainObject(val);\n}\nfunction findNonSerializableValue(value, path = \"\", isSerializable = isPlain, getEntries, ignoredPaths = [], cache) {\n  let foundNestedSerializable;\n  if (!isSerializable(value)) {\n    return {\n      keyPath: path || \"<root>\",\n      value\n    };\n  }\n  if (typeof value !== \"object\" || value === null) {\n    return false;\n  }\n  if (cache?.has(value))\n    return false;\n  const entries = getEntries != null ? getEntries(value) : Object.entries(value);\n  const hasIgnoredPaths = ignoredPaths.length > 0;\n  for (const [key, nestedValue] of entries) {\n    const nestedPath = path ? path + \".\" + key : key;\n    if (hasIgnoredPaths) {\n      const hasMatches = ignoredPaths.some((ignored) => {\n        if (ignored instanceof RegExp) {\n          return ignored.test(nestedPath);\n        }\n        return nestedPath === ignored;\n      });\n      if (hasMatches) {\n        continue;\n      }\n    }\n    if (!isSerializable(nestedValue)) {\n      return {\n        keyPath: nestedPath,\n        value: nestedValue\n      };\n    }\n    if (typeof nestedValue === \"object\") {\n      foundNestedSerializable = findNonSerializableValue(nestedValue, nestedPath, isSerializable, getEntries, ignoredPaths, cache);\n      if (foundNestedSerializable) {\n        return foundNestedSerializable;\n      }\n    }\n  }\n  if (cache && isNestedFrozen(value))\n    cache.add(value);\n  return false;\n}\nfunction isNestedFrozen(value) {\n  if (!Object.isFrozen(value))\n    return false;\n  for (const nestedValue of Object.values(value)) {\n    if (typeof nestedValue !== \"object\" || nestedValue === null)\n      continue;\n    if (!isNestedFrozen(nestedValue))\n      return false;\n  }\n  return true;\n}\nfunction createSerializableStateInvariantMiddleware(options = {}) {\n  if (process.env.NODE_ENV === \"production\") {\n    return () => (next) => (action) => next(action);\n  } else {\n    const {\n      isSerializable = isPlain,\n      getEntries,\n      ignoredActions = [],\n      ignoredActionPaths = [\"meta.arg\", \"meta.baseQueryMeta\"],\n      ignoredPaths = [],\n      warnAfter = 32,\n      ignoreState = false,\n      ignoreActions = false,\n      disableCache = false\n    } = options;\n    const cache = !disableCache && WeakSet ? /* @__PURE__ */ new WeakSet() : void 0;\n    return (storeAPI) => (next) => (action) => {\n      if (!isAction2(action)) {\n        return next(action);\n      }\n      const result = next(action);\n      const measureUtils = getTimeMeasureUtils(warnAfter, \"SerializableStateInvariantMiddleware\");\n      if (!ignoreActions && !(ignoredActions.length && ignoredActions.indexOf(action.type) !== -1)) {\n        measureUtils.measureTime(() => {\n          const foundActionNonSerializableValue = findNonSerializableValue(action, \"\", isSerializable, getEntries, ignoredActionPaths, cache);\n          if (foundActionNonSerializableValue) {\n            const {\n              keyPath,\n              value\n            } = foundActionNonSerializableValue;\n            console.error(`A non-serializable value was detected in an action, in the path: \\`${keyPath}\\`. Value:`, value, \"\\nTake a look at the logic that dispatched this action: \", action, \"\\n(See https://redux.js.org/faq/actions#why-should-type-be-a-string-or-at-least-serializable-why-should-my-action-types-be-constants)\", \"\\n(To allow non-serializable values see: https://redux-toolkit.js.org/usage/usage-guide#working-with-non-serializable-data)\");\n          }\n        });\n      }\n      if (!ignoreState) {\n        measureUtils.measureTime(() => {\n          const state = storeAPI.getState();\n          const foundStateNonSerializableValue = findNonSerializableValue(state, \"\", isSerializable, getEntries, ignoredPaths, cache);\n          if (foundStateNonSerializableValue) {\n            const {\n              keyPath,\n              value\n            } = foundStateNonSerializableValue;\n            console.error(`A non-serializable value was detected in the state, in the path: \\`${keyPath}\\`. Value:`, value, `\nTake a look at the reducer(s) handling this action type: ${action.type}.\n(See https://redux.js.org/faq/organizing-state#can-i-put-functions-promises-or-other-non-serializable-items-in-my-store-state)`);\n          }\n        });\n        measureUtils.warnIfExceeded();\n      }\n      return result;\n    };\n  }\n}\n\n// src/getDefaultMiddleware.ts\nfunction isBoolean(x) {\n  return typeof x === \"boolean\";\n}\nvar buildGetDefaultMiddleware = () => function getDefaultMiddleware(options) {\n  const {\n    thunk = true,\n    immutableCheck = true,\n    serializableCheck = true,\n    actionCreatorCheck = true\n  } = options ?? {};\n  let middlewareArray = new Tuple();\n  if (thunk) {\n    if (isBoolean(thunk)) {\n      middlewareArray.push(thunkMiddleware);\n    } else {\n      middlewareArray.push(withExtraArgument(thunk.extraArgument));\n    }\n  }\n  if (process.env.NODE_ENV !== \"production\") {\n    if (immutableCheck) {\n      let immutableOptions = {};\n      if (!isBoolean(immutableCheck)) {\n        immutableOptions = immutableCheck;\n      }\n      middlewareArray.unshift(createImmutableStateInvariantMiddleware(immutableOptions));\n    }\n    if (serializableCheck) {\n      let serializableOptions = {};\n      if (!isBoolean(serializableCheck)) {\n        serializableOptions = serializableCheck;\n      }\n      middlewareArray.push(createSerializableStateInvariantMiddleware(serializableOptions));\n    }\n    if (actionCreatorCheck) {\n      let actionCreatorOptions = {};\n      if (!isBoolean(actionCreatorCheck)) {\n        actionCreatorOptions = actionCreatorCheck;\n      }\n      middlewareArray.unshift(createActionCreatorInvariantMiddleware(actionCreatorOptions));\n    }\n  }\n  return middlewareArray;\n};\n\n// src/autoBatchEnhancer.ts\nvar SHOULD_AUTOBATCH = \"RTK_autoBatch\";\nvar prepareAutoBatched = () => (payload) => ({\n  payload,\n  meta: {\n    [SHOULD_AUTOBATCH]: true\n  }\n});\nvar createQueueWithTimer = (timeout) => {\n  return (notify) => {\n    setTimeout(notify, timeout);\n  };\n};\nvar rAF = typeof window !== \"undefined\" && window.requestAnimationFrame ? window.requestAnimationFrame : createQueueWithTimer(10);\nvar autoBatchEnhancer = (options = {\n  type: \"raf\"\n}) => (next) => (...args) => {\n  const store = next(...args);\n  let notifying = true;\n  let shouldNotifyAtEndOfTick = false;\n  let notificationQueued = false;\n  const listeners = /* @__PURE__ */ new Set();\n  const queueCallback = options.type === \"tick\" ? queueMicrotask : options.type === \"raf\" ? rAF : options.type === \"callback\" ? options.queueNotification : createQueueWithTimer(options.timeout);\n  const notifyListeners = () => {\n    notificationQueued = false;\n    if (shouldNotifyAtEndOfTick) {\n      shouldNotifyAtEndOfTick = false;\n      listeners.forEach((l) => l());\n    }\n  };\n  return Object.assign({}, store, {\n    // Override the base `store.subscribe` method to keep original listeners\n    // from running if we're delaying notifications\n    subscribe(listener2) {\n      const wrappedListener = () => notifying && listener2();\n      const unsubscribe = store.subscribe(wrappedListener);\n      listeners.add(listener2);\n      return () => {\n        unsubscribe();\n        listeners.delete(listener2);\n      };\n    },\n    // Override the base `store.dispatch` method so that we can check actions\n    // for the `shouldAutoBatch` flag and determine if batching is active\n    dispatch(action) {\n      try {\n        notifying = !action?.meta?.[SHOULD_AUTOBATCH];\n        shouldNotifyAtEndOfTick = !notifying;\n        if (shouldNotifyAtEndOfTick) {\n          if (!notificationQueued) {\n            notificationQueued = true;\n            queueCallback(notifyListeners);\n          }\n        }\n        return store.dispatch(action);\n      } finally {\n        notifying = true;\n      }\n    }\n  });\n};\n\n// src/getDefaultEnhancers.ts\nvar buildGetDefaultEnhancers = (middlewareEnhancer) => function getDefaultEnhancers(options) {\n  const {\n    autoBatch = true\n  } = options ?? {};\n  let enhancerArray = new Tuple(middlewareEnhancer);\n  if (autoBatch) {\n    enhancerArray.push(autoBatchEnhancer(typeof autoBatch === \"object\" ? autoBatch : void 0));\n  }\n  return enhancerArray;\n};\n\n// src/configureStore.ts\nvar IS_PRODUCTION = process.env.NODE_ENV === \"production\";\nfunction configureStore(options) {\n  const getDefaultMiddleware = buildGetDefaultMiddleware();\n  const {\n    reducer = void 0,\n    middleware,\n    devTools = true,\n    preloadedState = void 0,\n    enhancers = void 0\n  } = options || {};\n  let rootReducer;\n  if (typeof reducer === \"function\") {\n    rootReducer = reducer;\n  } else if (isPlainObject2(reducer)) {\n    rootReducer = combineReducers(reducer);\n  } else {\n    throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(1) : \"`reducer` is a required argument, and must be a function or an object of functions that can be passed to combineReducers\");\n  }\n  if (!IS_PRODUCTION && middleware && typeof middleware !== \"function\") {\n    throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(2) : \"`middleware` field must be a callback\");\n  }\n  let finalMiddleware;\n  if (typeof middleware === \"function\") {\n    finalMiddleware = middleware(getDefaultMiddleware);\n    if (!IS_PRODUCTION && !Array.isArray(finalMiddleware)) {\n      throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(3) : \"when using a middleware builder function, an array of middleware must be returned\");\n    }\n  } else {\n    finalMiddleware = getDefaultMiddleware();\n  }\n  if (!IS_PRODUCTION && finalMiddleware.some((item) => typeof item !== \"function\")) {\n    throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(4) : \"each middleware provided to configureStore must be a function\");\n  }\n  let finalCompose = compose2;\n  if (devTools) {\n    finalCompose = composeWithDevTools({\n      // Enable capture of stack traces for dispatched Redux actions\n      trace: !IS_PRODUCTION,\n      ...typeof devTools === \"object\" && devTools\n    });\n  }\n  const middlewareEnhancer = applyMiddleware(...finalMiddleware);\n  const getDefaultEnhancers = buildGetDefaultEnhancers(middlewareEnhancer);\n  if (!IS_PRODUCTION && enhancers && typeof enhancers !== \"function\") {\n    throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(5) : \"`enhancers` field must be a callback\");\n  }\n  let storeEnhancers = typeof enhancers === \"function\" ? enhancers(getDefaultEnhancers) : getDefaultEnhancers();\n  if (!IS_PRODUCTION && !Array.isArray(storeEnhancers)) {\n    throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(6) : \"`enhancers` callback must return an array\");\n  }\n  if (!IS_PRODUCTION && storeEnhancers.some((item) => typeof item !== \"function\")) {\n    throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(7) : \"each enhancer provided to configureStore must be a function\");\n  }\n  if (!IS_PRODUCTION && finalMiddleware.length && !storeEnhancers.includes(middlewareEnhancer)) {\n    console.error(\"middlewares were provided, but middleware enhancer was not included in final enhancers - make sure to call `getDefaultEnhancers`\");\n  }\n  const composedEnhancer = finalCompose(...storeEnhancers);\n  return createStore(rootReducer, preloadedState, composedEnhancer);\n}\n\n// src/createReducer.ts\nimport { produce as createNextState2, isDraft as isDraft2, isDraftable as isDraftable2 } from \"immer\";\n\n// src/mapBuilders.ts\nfunction executeReducerBuilderCallback(builderCallback) {\n  const actionsMap = {};\n  const actionMatchers = [];\n  let defaultCaseReducer;\n  const builder = {\n    addCase(typeOrActionCreator, reducer) {\n      if (process.env.NODE_ENV !== \"production\") {\n        if (actionMatchers.length > 0) {\n          throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(26) : \"`builder.addCase` should only be called before calling `builder.addMatcher`\");\n        }\n        if (defaultCaseReducer) {\n          throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(27) : \"`builder.addCase` should only be called before calling `builder.addDefaultCase`\");\n        }\n      }\n      const type = typeof typeOrActionCreator === \"string\" ? typeOrActionCreator : typeOrActionCreator.type;\n      if (!type) {\n        throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(28) : \"`builder.addCase` cannot be called with an empty action type\");\n      }\n      if (type in actionsMap) {\n        throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(29) : `\\`builder.addCase\\` cannot be called with two reducers for the same action type '${type}'`);\n      }\n      actionsMap[type] = reducer;\n      return builder;\n    },\n    addMatcher(matcher, reducer) {\n      if (process.env.NODE_ENV !== \"production\") {\n        if (defaultCaseReducer) {\n          throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(30) : \"`builder.addMatcher` should only be called before calling `builder.addDefaultCase`\");\n        }\n      }\n      actionMatchers.push({\n        matcher,\n        reducer\n      });\n      return builder;\n    },\n    addDefaultCase(reducer) {\n      if (process.env.NODE_ENV !== \"production\") {\n        if (defaultCaseReducer) {\n          throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(31) : \"`builder.addDefaultCase` can only be called once\");\n        }\n      }\n      defaultCaseReducer = reducer;\n      return builder;\n    }\n  };\n  builderCallback(builder);\n  return [actionsMap, actionMatchers, defaultCaseReducer];\n}\n\n// src/createReducer.ts\nfunction isStateFunction(x) {\n  return typeof x === \"function\";\n}\nfunction createReducer(initialState, mapOrBuilderCallback) {\n  if (process.env.NODE_ENV !== \"production\") {\n    if (typeof mapOrBuilderCallback === \"object\") {\n      throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(8) : \"The object notation for `createReducer` has been removed. Please use the 'builder callback' notation instead: https://redux-toolkit.js.org/api/createReducer\");\n    }\n  }\n  let [actionsMap, finalActionMatchers, finalDefaultCaseReducer] = executeReducerBuilderCallback(mapOrBuilderCallback);\n  let getInitialState;\n  if (isStateFunction(initialState)) {\n    getInitialState = () => freezeDraftable(initialState());\n  } else {\n    const frozenInitialState = freezeDraftable(initialState);\n    getInitialState = () => frozenInitialState;\n  }\n  function reducer(state = getInitialState(), action) {\n    let caseReducers = [actionsMap[action.type], ...finalActionMatchers.filter(({\n      matcher\n    }) => matcher(action)).map(({\n      reducer: reducer2\n    }) => reducer2)];\n    if (caseReducers.filter((cr) => !!cr).length === 0) {\n      caseReducers = [finalDefaultCaseReducer];\n    }\n    return caseReducers.reduce((previousState, caseReducer) => {\n      if (caseReducer) {\n        if (isDraft2(previousState)) {\n          const draft = previousState;\n          const result = caseReducer(draft, action);\n          if (result === void 0) {\n            return previousState;\n          }\n          return result;\n        } else if (!isDraftable2(previousState)) {\n          const result = caseReducer(previousState, action);\n          if (result === void 0) {\n            if (previousState === null) {\n              return previousState;\n            }\n            throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(9) : \"A case reducer on a non-draftable value must not return undefined\");\n          }\n          return result;\n        } else {\n          return createNextState2(previousState, (draft) => {\n            return caseReducer(draft, action);\n          });\n        }\n      }\n      return previousState;\n    }, state);\n  }\n  reducer.getInitialState = getInitialState;\n  return reducer;\n}\n\n// src/nanoid.ts\nvar urlAlphabet = \"ModuleSymbhasOwnPr-0123456789ABCDEFGHNRVfgctiUvz_KqYTJkLxpZXIjQW\";\nvar nanoid = (size = 21) => {\n  let id = \"\";\n  let i = size;\n  while (i--) {\n    id += urlAlphabet[Math.random() * 64 | 0];\n  }\n  return id;\n};\n\n// src/matchers.ts\nvar matches = (matcher, action) => {\n  if (hasMatchFunction(matcher)) {\n    return matcher.match(action);\n  } else {\n    return matcher(action);\n  }\n};\nfunction isAnyOf(...matchers) {\n  return (action) => {\n    return matchers.some((matcher) => matches(matcher, action));\n  };\n}\nfunction isAllOf(...matchers) {\n  return (action) => {\n    return matchers.every((matcher) => matches(matcher, action));\n  };\n}\nfunction hasExpectedRequestMetadata(action, validStatus) {\n  if (!action || !action.meta)\n    return false;\n  const hasValidRequestId = typeof action.meta.requestId === \"string\";\n  const hasValidRequestStatus = validStatus.indexOf(action.meta.requestStatus) > -1;\n  return hasValidRequestId && hasValidRequestStatus;\n}\nfunction isAsyncThunkArray(a) {\n  return typeof a[0] === \"function\" && \"pending\" in a[0] && \"fulfilled\" in a[0] && \"rejected\" in a[0];\n}\nfunction isPending(...asyncThunks) {\n  if (asyncThunks.length === 0) {\n    return (action) => hasExpectedRequestMetadata(action, [\"pending\"]);\n  }\n  if (!isAsyncThunkArray(asyncThunks)) {\n    return isPending()(asyncThunks[0]);\n  }\n  return (action) => {\n    const matchers = asyncThunks.map((asyncThunk) => asyncThunk.pending);\n    const combinedMatcher = isAnyOf(...matchers);\n    return combinedMatcher(action);\n  };\n}\nfunction isRejected(...asyncThunks) {\n  if (asyncThunks.length === 0) {\n    return (action) => hasExpectedRequestMetadata(action, [\"rejected\"]);\n  }\n  if (!isAsyncThunkArray(asyncThunks)) {\n    return isRejected()(asyncThunks[0]);\n  }\n  return (action) => {\n    const matchers = asyncThunks.map((asyncThunk) => asyncThunk.rejected);\n    const combinedMatcher = isAnyOf(...matchers);\n    return combinedMatcher(action);\n  };\n}\nfunction isRejectedWithValue(...asyncThunks) {\n  const hasFlag = (action) => {\n    return action && action.meta && action.meta.rejectedWithValue;\n  };\n  if (asyncThunks.length === 0) {\n    return (action) => {\n      const combinedMatcher = isAllOf(isRejected(...asyncThunks), hasFlag);\n      return combinedMatcher(action);\n    };\n  }\n  if (!isAsyncThunkArray(asyncThunks)) {\n    return isRejectedWithValue()(asyncThunks[0]);\n  }\n  return (action) => {\n    const combinedMatcher = isAllOf(isRejected(...asyncThunks), hasFlag);\n    return combinedMatcher(action);\n  };\n}\nfunction isFulfilled(...asyncThunks) {\n  if (asyncThunks.length === 0) {\n    return (action) => hasExpectedRequestMetadata(action, [\"fulfilled\"]);\n  }\n  if (!isAsyncThunkArray(asyncThunks)) {\n    return isFulfilled()(asyncThunks[0]);\n  }\n  return (action) => {\n    const matchers = asyncThunks.map((asyncThunk) => asyncThunk.fulfilled);\n    const combinedMatcher = isAnyOf(...matchers);\n    return combinedMatcher(action);\n  };\n}\nfunction isAsyncThunkAction(...asyncThunks) {\n  if (asyncThunks.length === 0) {\n    return (action) => hasExpectedRequestMetadata(action, [\"pending\", \"fulfilled\", \"rejected\"]);\n  }\n  if (!isAsyncThunkArray(asyncThunks)) {\n    return isAsyncThunkAction()(asyncThunks[0]);\n  }\n  return (action) => {\n    const matchers = [];\n    for (const asyncThunk of asyncThunks) {\n      matchers.push(asyncThunk.pending, asyncThunk.rejected, asyncThunk.fulfilled);\n    }\n    const combinedMatcher = isAnyOf(...matchers);\n    return combinedMatcher(action);\n  };\n}\n\n// src/createAsyncThunk.ts\nvar commonProperties = [\"name\", \"message\", \"stack\", \"code\"];\nvar RejectWithValue = class {\n  constructor(payload, meta) {\n    this.payload = payload;\n    this.meta = meta;\n  }\n  /*\n  type-only property to distinguish between RejectWithValue and FulfillWithMeta\n  does not exist at runtime\n  */\n  _type;\n};\nvar FulfillWithMeta = class {\n  constructor(payload, meta) {\n    this.payload = payload;\n    this.meta = meta;\n  }\n  /*\n  type-only property to distinguish between RejectWithValue and FulfillWithMeta\n  does not exist at runtime\n  */\n  _type;\n};\nvar miniSerializeError = (value) => {\n  if (typeof value === \"object\" && value !== null) {\n    const simpleError = {};\n    for (const property of commonProperties) {\n      if (typeof value[property] === \"string\") {\n        simpleError[property] = value[property];\n      }\n    }\n    return simpleError;\n  }\n  return {\n    message: String(value)\n  };\n};\nvar createAsyncThunk = /* @__PURE__ */ (() => {\n  function createAsyncThunk2(typePrefix, payloadCreator, options) {\n    const fulfilled = createAction(typePrefix + \"/fulfilled\", (payload, requestId, arg, meta) => ({\n      payload,\n      meta: {\n        ...meta || {},\n        arg,\n        requestId,\n        requestStatus: \"fulfilled\"\n      }\n    }));\n    const pending = createAction(typePrefix + \"/pending\", (requestId, arg, meta) => ({\n      payload: void 0,\n      meta: {\n        ...meta || {},\n        arg,\n        requestId,\n        requestStatus: \"pending\"\n      }\n    }));\n    const rejected = createAction(typePrefix + \"/rejected\", (error, requestId, arg, payload, meta) => ({\n      payload,\n      error: (options && options.serializeError || miniSerializeError)(error || \"Rejected\"),\n      meta: {\n        ...meta || {},\n        arg,\n        requestId,\n        rejectedWithValue: !!payload,\n        requestStatus: \"rejected\",\n        aborted: error?.name === \"AbortError\",\n        condition: error?.name === \"ConditionError\"\n      }\n    }));\n    function actionCreator(arg) {\n      return (dispatch, getState, extra) => {\n        const requestId = options?.idGenerator ? options.idGenerator(arg) : nanoid();\n        const abortController = new AbortController();\n        let abortHandler;\n        let abortReason;\n        function abort(reason) {\n          abortReason = reason;\n          abortController.abort();\n        }\n        const promise = async function() {\n          let finalAction;\n          try {\n            let conditionResult = options?.condition?.(arg, {\n              getState,\n              extra\n            });\n            if (isThenable(conditionResult)) {\n              conditionResult = await conditionResult;\n            }\n            if (conditionResult === false || abortController.signal.aborted) {\n              throw {\n                name: \"ConditionError\",\n                message: \"Aborted due to condition callback returning false.\"\n              };\n            }\n            const abortedPromise = new Promise((_, reject) => {\n              abortHandler = () => {\n                reject({\n                  name: \"AbortError\",\n                  message: abortReason || \"Aborted\"\n                });\n              };\n              abortController.signal.addEventListener(\"abort\", abortHandler);\n            });\n            dispatch(pending(requestId, arg, options?.getPendingMeta?.({\n              requestId,\n              arg\n            }, {\n              getState,\n              extra\n            })));\n            finalAction = await Promise.race([abortedPromise, Promise.resolve(payloadCreator(arg, {\n              dispatch,\n              getState,\n              extra,\n              requestId,\n              signal: abortController.signal,\n              abort,\n              rejectWithValue: (value, meta) => {\n                return new RejectWithValue(value, meta);\n              },\n              fulfillWithValue: (value, meta) => {\n                return new FulfillWithMeta(value, meta);\n              }\n            })).then((result) => {\n              if (result instanceof RejectWithValue) {\n                throw result;\n              }\n              if (result instanceof FulfillWithMeta) {\n                return fulfilled(result.payload, requestId, arg, result.meta);\n              }\n              return fulfilled(result, requestId, arg);\n            })]);\n          } catch (err) {\n            finalAction = err instanceof RejectWithValue ? rejected(null, requestId, arg, err.payload, err.meta) : rejected(err, requestId, arg);\n          } finally {\n            if (abortHandler) {\n              abortController.signal.removeEventListener(\"abort\", abortHandler);\n            }\n          }\n          const skipDispatch = options && !options.dispatchConditionRejection && rejected.match(finalAction) && finalAction.meta.condition;\n          if (!skipDispatch) {\n            dispatch(finalAction);\n          }\n          return finalAction;\n        }();\n        return Object.assign(promise, {\n          abort,\n          requestId,\n          arg,\n          unwrap() {\n            return promise.then(unwrapResult);\n          }\n        });\n      };\n    }\n    return Object.assign(actionCreator, {\n      pending,\n      rejected,\n      fulfilled,\n      settled: isAnyOf(rejected, fulfilled),\n      typePrefix\n    });\n  }\n  createAsyncThunk2.withTypes = () => createAsyncThunk2;\n  return createAsyncThunk2;\n})();\nfunction unwrapResult(action) {\n  if (action.meta && action.meta.rejectedWithValue) {\n    throw action.payload;\n  }\n  if (action.error) {\n    throw action.error;\n  }\n  return action.payload;\n}\nfunction isThenable(value) {\n  return value !== null && typeof value === \"object\" && typeof value.then === \"function\";\n}\n\n// src/createSlice.ts\nvar asyncThunkSymbol = /* @__PURE__ */ Symbol.for(\"rtk-slice-createasyncthunk\");\nvar asyncThunkCreator = {\n  [asyncThunkSymbol]: createAsyncThunk\n};\nvar ReducerType = /* @__PURE__ */ ((ReducerType2) => {\n  ReducerType2[\"reducer\"] = \"reducer\";\n  ReducerType2[\"reducerWithPrepare\"] = \"reducerWithPrepare\";\n  ReducerType2[\"asyncThunk\"] = \"asyncThunk\";\n  return ReducerType2;\n})(ReducerType || {});\nfunction getType(slice, actionKey) {\n  return `${slice}/${actionKey}`;\n}\nfunction buildCreateSlice({\n  creators\n} = {}) {\n  const cAT = creators?.asyncThunk?.[asyncThunkSymbol];\n  return function createSlice2(options) {\n    const {\n      name,\n      reducerPath = name\n    } = options;\n    if (!name) {\n      throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(11) : \"`name` is a required option for createSlice\");\n    }\n    if (typeof process !== \"undefined\" && process.env.NODE_ENV === \"development\") {\n      if (options.initialState === void 0) {\n        console.error(\"You must provide an `initialState` value that is not `undefined`. You may have misspelled `initialState`\");\n      }\n    }\n    const reducers = (typeof options.reducers === \"function\" ? options.reducers(buildReducerCreators()) : options.reducers) || {};\n    const reducerNames = Object.keys(reducers);\n    const context = {\n      sliceCaseReducersByName: {},\n      sliceCaseReducersByType: {},\n      actionCreators: {},\n      sliceMatchers: []\n    };\n    const contextMethods = {\n      addCase(typeOrActionCreator, reducer2) {\n        const type = typeof typeOrActionCreator === \"string\" ? typeOrActionCreator : typeOrActionCreator.type;\n        if (!type) {\n          throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(12) : \"`context.addCase` cannot be called with an empty action type\");\n        }\n        if (type in context.sliceCaseReducersByType) {\n          throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(13) : \"`context.addCase` cannot be called with two reducers for the same action type: \" + type);\n        }\n        context.sliceCaseReducersByType[type] = reducer2;\n        return contextMethods;\n      },\n      addMatcher(matcher, reducer2) {\n        context.sliceMatchers.push({\n          matcher,\n          reducer: reducer2\n        });\n        return contextMethods;\n      },\n      exposeAction(name2, actionCreator) {\n        context.actionCreators[name2] = actionCreator;\n        return contextMethods;\n      },\n      exposeCaseReducer(name2, reducer2) {\n        context.sliceCaseReducersByName[name2] = reducer2;\n        return contextMethods;\n      }\n    };\n    reducerNames.forEach((reducerName) => {\n      const reducerDefinition = reducers[reducerName];\n      const reducerDetails = {\n        reducerName,\n        type: getType(name, reducerName),\n        createNotation: typeof options.reducers === \"function\"\n      };\n      if (isAsyncThunkSliceReducerDefinition(reducerDefinition)) {\n        handleThunkCaseReducerDefinition(reducerDetails, reducerDefinition, contextMethods, cAT);\n      } else {\n        handleNormalReducerDefinition(reducerDetails, reducerDefinition, contextMethods);\n      }\n    });\n    function buildReducer() {\n      if (process.env.NODE_ENV !== \"production\") {\n        if (typeof options.extraReducers === \"object\") {\n          throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(14) : \"The object notation for `createSlice.extraReducers` has been removed. Please use the 'builder callback' notation instead: https://redux-toolkit.js.org/api/createSlice\");\n        }\n      }\n      const [extraReducers = {}, actionMatchers = [], defaultCaseReducer = void 0] = typeof options.extraReducers === \"function\" ? executeReducerBuilderCallback(options.extraReducers) : [options.extraReducers];\n      const finalCaseReducers = {\n        ...extraReducers,\n        ...context.sliceCaseReducersByType\n      };\n      return createReducer(options.initialState, (builder) => {\n        for (let key in finalCaseReducers) {\n          builder.addCase(key, finalCaseReducers[key]);\n        }\n        for (let sM of context.sliceMatchers) {\n          builder.addMatcher(sM.matcher, sM.reducer);\n        }\n        for (let m of actionMatchers) {\n          builder.addMatcher(m.matcher, m.reducer);\n        }\n        if (defaultCaseReducer) {\n          builder.addDefaultCase(defaultCaseReducer);\n        }\n      });\n    }\n    const selectSelf = (state) => state;\n    const injectedSelectorCache = /* @__PURE__ */ new Map();\n    let _reducer;\n    function reducer(state, action) {\n      if (!_reducer)\n        _reducer = buildReducer();\n      return _reducer(state, action);\n    }\n    function getInitialState() {\n      if (!_reducer)\n        _reducer = buildReducer();\n      return _reducer.getInitialState();\n    }\n    function makeSelectorProps(reducerPath2, injected = false) {\n      function selectSlice(state) {\n        let sliceState = state[reducerPath2];\n        if (typeof sliceState === \"undefined\") {\n          if (injected) {\n            sliceState = getInitialState();\n          } else if (process.env.NODE_ENV !== \"production\") {\n            throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(15) : \"selectSlice returned undefined for an uninjected slice reducer\");\n          }\n        }\n        return sliceState;\n      }\n      function getSelectors(selectState = selectSelf) {\n        const selectorCache = emplace(injectedSelectorCache, injected, {\n          insert: () => /* @__PURE__ */ new WeakMap()\n        });\n        return emplace(selectorCache, selectState, {\n          insert: () => {\n            const map = {};\n            for (const [name2, selector] of Object.entries(options.selectors ?? {})) {\n              map[name2] = wrapSelector(selector, selectState, getInitialState, injected);\n            }\n            return map;\n          }\n        });\n      }\n      return {\n        reducerPath: reducerPath2,\n        getSelectors,\n        get selectors() {\n          return getSelectors(selectSlice);\n        },\n        selectSlice\n      };\n    }\n    const slice = {\n      name,\n      reducer,\n      actions: context.actionCreators,\n      caseReducers: context.sliceCaseReducersByName,\n      getInitialState,\n      ...makeSelectorProps(reducerPath),\n      injectInto(injectable, {\n        reducerPath: pathOpt,\n        ...config\n      } = {}) {\n        const newReducerPath = pathOpt ?? reducerPath;\n        injectable.inject({\n          reducerPath: newReducerPath,\n          reducer\n        }, config);\n        return {\n          ...slice,\n          ...makeSelectorProps(newReducerPath, true)\n        };\n      }\n    };\n    return slice;\n  };\n}\nfunction wrapSelector(selector, selectState, getInitialState, injected) {\n  function wrapper(rootState, ...args) {\n    let sliceState = selectState(rootState);\n    if (typeof sliceState === \"undefined\") {\n      if (injected) {\n        sliceState = getInitialState();\n      } else if (process.env.NODE_ENV !== \"production\") {\n        throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(16) : \"selectState returned undefined for an uninjected slice reducer\");\n      }\n    }\n    return selector(sliceState, ...args);\n  }\n  wrapper.unwrapped = selector;\n  return wrapper;\n}\nvar createSlice = /* @__PURE__ */ buildCreateSlice();\nfunction buildReducerCreators() {\n  function asyncThunk(payloadCreator, config) {\n    return {\n      _reducerDefinitionType: \"asyncThunk\" /* asyncThunk */,\n      payloadCreator,\n      ...config\n    };\n  }\n  asyncThunk.withTypes = () => asyncThunk;\n  return {\n    reducer(caseReducer) {\n      return Object.assign({\n        // hack so the wrapping function has the same name as the original\n        // we need to create a wrapper so the `reducerDefinitionType` is not assigned to the original\n        [caseReducer.name](...args) {\n          return caseReducer(...args);\n        }\n      }[caseReducer.name], {\n        _reducerDefinitionType: \"reducer\" /* reducer */\n      });\n    },\n    preparedReducer(prepare, reducer) {\n      return {\n        _reducerDefinitionType: \"reducerWithPrepare\" /* reducerWithPrepare */,\n        prepare,\n        reducer\n      };\n    },\n    asyncThunk\n  };\n}\nfunction handleNormalReducerDefinition({\n  type,\n  reducerName,\n  createNotation\n}, maybeReducerWithPrepare, context) {\n  let caseReducer;\n  let prepareCallback;\n  if (\"reducer\" in maybeReducerWithPrepare) {\n    if (createNotation && !isCaseReducerWithPrepareDefinition(maybeReducerWithPrepare)) {\n      throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(17) : \"Please use the `create.preparedReducer` notation for prepared action creators with the `create` notation.\");\n    }\n    caseReducer = maybeReducerWithPrepare.reducer;\n    prepareCallback = maybeReducerWithPrepare.prepare;\n  } else {\n    caseReducer = maybeReducerWithPrepare;\n  }\n  context.addCase(type, caseReducer).exposeCaseReducer(reducerName, caseReducer).exposeAction(reducerName, prepareCallback ? createAction(type, prepareCallback) : createAction(type));\n}\nfunction isAsyncThunkSliceReducerDefinition(reducerDefinition) {\n  return reducerDefinition._reducerDefinitionType === \"asyncThunk\" /* asyncThunk */;\n}\nfunction isCaseReducerWithPrepareDefinition(reducerDefinition) {\n  return reducerDefinition._reducerDefinitionType === \"reducerWithPrepare\" /* reducerWithPrepare */;\n}\nfunction handleThunkCaseReducerDefinition({\n  type,\n  reducerName\n}, reducerDefinition, context, cAT) {\n  if (!cAT) {\n    throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(18) : \"Cannot use `create.asyncThunk` in the built-in `createSlice`. Use `buildCreateSlice({ creators: { asyncThunk: asyncThunkCreator } })` to create a customised version of `createSlice`.\");\n  }\n  const {\n    payloadCreator,\n    fulfilled,\n    pending,\n    rejected,\n    settled,\n    options\n  } = reducerDefinition;\n  const thunk = cAT(type, payloadCreator, options);\n  context.exposeAction(reducerName, thunk);\n  if (fulfilled) {\n    context.addCase(thunk.fulfilled, fulfilled);\n  }\n  if (pending) {\n    context.addCase(thunk.pending, pending);\n  }\n  if (rejected) {\n    context.addCase(thunk.rejected, rejected);\n  }\n  if (settled) {\n    context.addMatcher(thunk.settled, settled);\n  }\n  context.exposeCaseReducer(reducerName, {\n    fulfilled: fulfilled || noop,\n    pending: pending || noop,\n    rejected: rejected || noop,\n    settled: settled || noop\n  });\n}\nfunction noop() {\n}\n\n// src/entities/entity_state.ts\nfunction getInitialEntityState() {\n  return {\n    ids: [],\n    entities: {}\n  };\n}\nfunction createInitialStateFactory(stateAdapter) {\n  function getInitialState(additionalState = {}, entities) {\n    const state = Object.assign(getInitialEntityState(), additionalState);\n    return entities ? stateAdapter.setAll(state, entities) : state;\n  }\n  return {\n    getInitialState\n  };\n}\n\n// src/entities/state_selectors.ts\nfunction createSelectorsFactory() {\n  function getSelectors(selectState, options = {}) {\n    const {\n      createSelector: createSelector2 = createDraftSafeSelector\n    } = options;\n    const selectIds = (state) => state.ids;\n    const selectEntities = (state) => state.entities;\n    const selectAll = createSelector2(selectIds, selectEntities, (ids, entities) => ids.map((id) => entities[id]));\n    const selectId = (_, id) => id;\n    const selectById = (entities, id) => entities[id];\n    const selectTotal = createSelector2(selectIds, (ids) => ids.length);\n    if (!selectState) {\n      return {\n        selectIds,\n        selectEntities,\n        selectAll,\n        selectTotal,\n        selectById: createSelector2(selectEntities, selectId, selectById)\n      };\n    }\n    const selectGlobalizedEntities = createSelector2(selectState, selectEntities);\n    return {\n      selectIds: createSelector2(selectState, selectIds),\n      selectEntities: selectGlobalizedEntities,\n      selectAll: createSelector2(selectState, selectAll),\n      selectTotal: createSelector2(selectState, selectTotal),\n      selectById: createSelector2(selectGlobalizedEntities, selectId, selectById)\n    };\n  }\n  return {\n    getSelectors\n  };\n}\n\n// src/entities/state_adapter.ts\nimport { produce as createNextState3, isDraft as isDraft3 } from \"immer\";\nvar isDraftTyped = isDraft3;\nfunction createSingleArgumentStateOperator(mutator) {\n  const operator = createStateOperator((_, state) => mutator(state));\n  return function operation(state) {\n    return operator(state, void 0);\n  };\n}\nfunction createStateOperator(mutator) {\n  return function operation(state, arg) {\n    function isPayloadActionArgument(arg2) {\n      return isFSA(arg2);\n    }\n    const runMutator = (draft) => {\n      if (isPayloadActionArgument(arg)) {\n        mutator(arg.payload, draft);\n      } else {\n        mutator(arg, draft);\n      }\n    };\n    if (isDraftTyped(state)) {\n      runMutator(state);\n      return state;\n    }\n    return createNextState3(state, runMutator);\n  };\n}\n\n// src/entities/utils.ts\nfunction selectIdValue(entity, selectId) {\n  const key = selectId(entity);\n  if (process.env.NODE_ENV !== \"production\" && key === void 0) {\n    console.warn(\"The entity passed to the `selectId` implementation returned undefined.\", \"You should probably provide your own `selectId` implementation.\", \"The entity that was passed:\", entity, \"The `selectId` implementation:\", selectId.toString());\n  }\n  return key;\n}\nfunction ensureEntitiesArray(entities) {\n  if (!Array.isArray(entities)) {\n    entities = Object.values(entities);\n  }\n  return entities;\n}\nfunction splitAddedUpdatedEntities(newEntities, selectId, state) {\n  newEntities = ensureEntitiesArray(newEntities);\n  const added = [];\n  const updated = [];\n  for (const entity of newEntities) {\n    const id = selectIdValue(entity, selectId);\n    if (id in state.entities) {\n      updated.push({\n        id,\n        changes: entity\n      });\n    } else {\n      added.push(entity);\n    }\n  }\n  return [added, updated];\n}\n\n// src/entities/unsorted_state_adapter.ts\nfunction createUnsortedStateAdapter(selectId) {\n  function addOneMutably(entity, state) {\n    const key = selectIdValue(entity, selectId);\n    if (key in state.entities) {\n      return;\n    }\n    state.ids.push(key);\n    state.entities[key] = entity;\n  }\n  function addManyMutably(newEntities, state) {\n    newEntities = ensureEntitiesArray(newEntities);\n    for (const entity of newEntities) {\n      addOneMutably(entity, state);\n    }\n  }\n  function setOneMutably(entity, state) {\n    const key = selectIdValue(entity, selectId);\n    if (!(key in state.entities)) {\n      state.ids.push(key);\n    }\n    ;\n    state.entities[key] = entity;\n  }\n  function setManyMutably(newEntities, state) {\n    newEntities = ensureEntitiesArray(newEntities);\n    for (const entity of newEntities) {\n      setOneMutably(entity, state);\n    }\n  }\n  function setAllMutably(newEntities, state) {\n    newEntities = ensureEntitiesArray(newEntities);\n    state.ids = [];\n    state.entities = {};\n    addManyMutably(newEntities, state);\n  }\n  function removeOneMutably(key, state) {\n    return removeManyMutably([key], state);\n  }\n  function removeManyMutably(keys, state) {\n    let didMutate = false;\n    keys.forEach((key) => {\n      if (key in state.entities) {\n        delete state.entities[key];\n        didMutate = true;\n      }\n    });\n    if (didMutate) {\n      state.ids = state.ids.filter((id) => id in state.entities);\n    }\n  }\n  function removeAllMutably(state) {\n    Object.assign(state, {\n      ids: [],\n      entities: {}\n    });\n  }\n  function takeNewKey(keys, update, state) {\n    const original3 = state.entities[update.id];\n    if (original3 === void 0) {\n      return false;\n    }\n    const updated = Object.assign({}, original3, update.changes);\n    const newKey = selectIdValue(updated, selectId);\n    const hasNewKey = newKey !== update.id;\n    if (hasNewKey) {\n      keys[update.id] = newKey;\n      delete state.entities[update.id];\n    }\n    ;\n    state.entities[newKey] = updated;\n    return hasNewKey;\n  }\n  function updateOneMutably(update, state) {\n    return updateManyMutably([update], state);\n  }\n  function updateManyMutably(updates, state) {\n    const newKeys = {};\n    const updatesPerEntity = {};\n    updates.forEach((update) => {\n      if (update.id in state.entities) {\n        updatesPerEntity[update.id] = {\n          id: update.id,\n          // Spreads ignore falsy values, so this works even if there isn't\n          // an existing update already at this key\n          changes: {\n            ...updatesPerEntity[update.id] ? updatesPerEntity[update.id].changes : null,\n            ...update.changes\n          }\n        };\n      }\n    });\n    updates = Object.values(updatesPerEntity);\n    const didMutateEntities = updates.length > 0;\n    if (didMutateEntities) {\n      const didMutateIds = updates.filter((update) => takeNewKey(newKeys, update, state)).length > 0;\n      if (didMutateIds) {\n        state.ids = Object.values(state.entities).map((e) => selectIdValue(e, selectId));\n      }\n    }\n  }\n  function upsertOneMutably(entity, state) {\n    return upsertManyMutably([entity], state);\n  }\n  function upsertManyMutably(newEntities, state) {\n    const [added, updated] = splitAddedUpdatedEntities(newEntities, selectId, state);\n    updateManyMutably(updated, state);\n    addManyMutably(added, state);\n  }\n  return {\n    removeAll: createSingleArgumentStateOperator(removeAllMutably),\n    addOne: createStateOperator(addOneMutably),\n    addMany: createStateOperator(addManyMutably),\n    setOne: createStateOperator(setOneMutably),\n    setMany: createStateOperator(setManyMutably),\n    setAll: createStateOperator(setAllMutably),\n    updateOne: createStateOperator(updateOneMutably),\n    updateMany: createStateOperator(updateManyMutably),\n    upsertOne: createStateOperator(upsertOneMutably),\n    upsertMany: createStateOperator(upsertManyMutably),\n    removeOne: createStateOperator(removeOneMutably),\n    removeMany: createStateOperator(removeManyMutably)\n  };\n}\n\n// src/entities/sorted_state_adapter.ts\nfunction createSortedStateAdapter(selectId, sort) {\n  const {\n    removeOne,\n    removeMany,\n    removeAll\n  } = createUnsortedStateAdapter(selectId);\n  function addOneMutably(entity, state) {\n    return addManyMutably([entity], state);\n  }\n  function addManyMutably(newEntities, state) {\n    newEntities = ensureEntitiesArray(newEntities);\n    const models = newEntities.filter((model) => !(selectIdValue(model, selectId) in state.entities));\n    if (models.length !== 0) {\n      merge(models, state);\n    }\n  }\n  function setOneMutably(entity, state) {\n    return setManyMutably([entity], state);\n  }\n  function setManyMutably(newEntities, state) {\n    newEntities = ensureEntitiesArray(newEntities);\n    if (newEntities.length !== 0) {\n      merge(newEntities, state);\n    }\n  }\n  function setAllMutably(newEntities, state) {\n    newEntities = ensureEntitiesArray(newEntities);\n    state.entities = {};\n    state.ids = [];\n    addManyMutably(newEntities, state);\n  }\n  function updateOneMutably(update, state) {\n    return updateManyMutably([update], state);\n  }\n  function updateManyMutably(updates, state) {\n    let appliedUpdates = false;\n    for (let update of updates) {\n      const entity = state.entities[update.id];\n      if (!entity) {\n        continue;\n      }\n      appliedUpdates = true;\n      Object.assign(entity, update.changes);\n      const newId = selectId(entity);\n      if (update.id !== newId) {\n        delete state.entities[update.id];\n        state.entities[newId] = entity;\n      }\n    }\n    if (appliedUpdates) {\n      resortEntities(state);\n    }\n  }\n  function upsertOneMutably(entity, state) {\n    return upsertManyMutably([entity], state);\n  }\n  function upsertManyMutably(newEntities, state) {\n    const [added, updated] = splitAddedUpdatedEntities(newEntities, selectId, state);\n    updateManyMutably(updated, state);\n    addManyMutably(added, state);\n  }\n  function areArraysEqual(a, b) {\n    if (a.length !== b.length) {\n      return false;\n    }\n    for (let i = 0; i < a.length && i < b.length; i++) {\n      if (a[i] === b[i]) {\n        continue;\n      }\n      return false;\n    }\n    return true;\n  }\n  function merge(models, state) {\n    models.forEach((model) => {\n      ;\n      state.entities[selectId(model)] = model;\n    });\n    resortEntities(state);\n  }\n  function resortEntities(state) {\n    const allEntities = Object.values(state.entities);\n    allEntities.sort(sort);\n    const newSortedIds = allEntities.map(selectId);\n    const {\n      ids\n    } = state;\n    if (!areArraysEqual(ids, newSortedIds)) {\n      state.ids = newSortedIds;\n    }\n  }\n  return {\n    removeOne,\n    removeMany,\n    removeAll,\n    addOne: createStateOperator(addOneMutably),\n    updateOne: createStateOperator(updateOneMutably),\n    upsertOne: createStateOperator(upsertOneMutably),\n    setOne: createStateOperator(setOneMutably),\n    setMany: createStateOperator(setManyMutably),\n    setAll: createStateOperator(setAllMutably),\n    addMany: createStateOperator(addManyMutably),\n    updateMany: createStateOperator(updateManyMutably),\n    upsertMany: createStateOperator(upsertManyMutably)\n  };\n}\n\n// src/entities/create_adapter.ts\nfunction createEntityAdapter(options = {}) {\n  const {\n    selectId,\n    sortComparer\n  } = {\n    sortComparer: false,\n    selectId: (instance) => instance.id,\n    ...options\n  };\n  const stateAdapter = sortComparer ? createSortedStateAdapter(selectId, sortComparer) : createUnsortedStateAdapter(selectId);\n  const stateFactory = createInitialStateFactory(stateAdapter);\n  const selectorsFactory = createSelectorsFactory();\n  return {\n    selectId,\n    sortComparer,\n    ...stateFactory,\n    ...selectorsFactory,\n    ...stateAdapter\n  };\n}\n\n// src/listenerMiddleware/index.ts\nimport { isAction as isAction3 } from \"redux\";\n\n// src/listenerMiddleware/exceptions.ts\nvar task = \"task\";\nvar listener = \"listener\";\nvar completed = \"completed\";\nvar cancelled = \"cancelled\";\nvar taskCancelled = `task-${cancelled}`;\nvar taskCompleted = `task-${completed}`;\nvar listenerCancelled = `${listener}-${cancelled}`;\nvar listenerCompleted = `${listener}-${completed}`;\nvar TaskAbortError = class {\n  constructor(code) {\n    this.code = code;\n    this.message = `${task} ${cancelled} (reason: ${code})`;\n  }\n  name = \"TaskAbortError\";\n  message;\n};\n\n// src/listenerMiddleware/utils.ts\nvar assertFunction = (func, expected) => {\n  if (typeof func !== \"function\") {\n    throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(32) : `${expected} is not a function`);\n  }\n};\nvar noop2 = () => {\n};\nvar catchRejection = (promise, onError = noop2) => {\n  promise.catch(onError);\n  return promise;\n};\nvar addAbortSignalListener = (abortSignal, callback) => {\n  abortSignal.addEventListener(\"abort\", callback, {\n    once: true\n  });\n  return () => abortSignal.removeEventListener(\"abort\", callback);\n};\nvar abortControllerWithReason = (abortController, reason) => {\n  const signal = abortController.signal;\n  if (signal.aborted) {\n    return;\n  }\n  if (!(\"reason\" in signal)) {\n    Object.defineProperty(signal, \"reason\", {\n      enumerable: true,\n      value: reason,\n      configurable: true,\n      writable: true\n    });\n  }\n  ;\n  abortController.abort(reason);\n};\n\n// src/listenerMiddleware/task.ts\nvar validateActive = (signal) => {\n  if (signal.aborted) {\n    const {\n      reason\n    } = signal;\n    throw new TaskAbortError(reason);\n  }\n};\nfunction raceWithSignal(signal, promise) {\n  let cleanup = noop2;\n  return new Promise((resolve, reject) => {\n    const notifyRejection = () => reject(new TaskAbortError(signal.reason));\n    if (signal.aborted) {\n      notifyRejection();\n      return;\n    }\n    cleanup = addAbortSignalListener(signal, notifyRejection);\n    promise.finally(() => cleanup()).then(resolve, reject);\n  }).finally(() => {\n    cleanup = noop2;\n  });\n}\nvar runTask = async (task2, cleanUp) => {\n  try {\n    await Promise.resolve();\n    const value = await task2();\n    return {\n      status: \"ok\",\n      value\n    };\n  } catch (error) {\n    return {\n      status: error instanceof TaskAbortError ? \"cancelled\" : \"rejected\",\n      error\n    };\n  } finally {\n    cleanUp?.();\n  }\n};\nvar createPause = (signal) => {\n  return (promise) => {\n    return catchRejection(raceWithSignal(signal, promise).then((output) => {\n      validateActive(signal);\n      return output;\n    }));\n  };\n};\nvar createDelay = (signal) => {\n  const pause = createPause(signal);\n  return (timeoutMs) => {\n    return pause(new Promise((resolve) => setTimeout(resolve, timeoutMs)));\n  };\n};\n\n// src/listenerMiddleware/index.ts\nvar {\n  assign\n} = Object;\nvar INTERNAL_NIL_TOKEN = {};\nvar alm = \"listenerMiddleware\";\nvar createFork = (parentAbortSignal, parentBlockingPromises) => {\n  const linkControllers = (controller) => addAbortSignalListener(parentAbortSignal, () => abortControllerWithReason(controller, parentAbortSignal.reason));\n  return (taskExecutor, opts) => {\n    assertFunction(taskExecutor, \"taskExecutor\");\n    const childAbortController = new AbortController();\n    linkControllers(childAbortController);\n    const result = runTask(async () => {\n      validateActive(parentAbortSignal);\n      validateActive(childAbortController.signal);\n      const result2 = await taskExecutor({\n        pause: createPause(childAbortController.signal),\n        delay: createDelay(childAbortController.signal),\n        signal: childAbortController.signal\n      });\n      validateActive(childAbortController.signal);\n      return result2;\n    }, () => abortControllerWithReason(childAbortController, taskCompleted));\n    if (opts?.autoJoin) {\n      parentBlockingPromises.push(result.catch(noop2));\n    }\n    return {\n      result: createPause(parentAbortSignal)(result),\n      cancel() {\n        abortControllerWithReason(childAbortController, taskCancelled);\n      }\n    };\n  };\n};\nvar createTakePattern = (startListening, signal) => {\n  const take = async (predicate, timeout) => {\n    validateActive(signal);\n    let unsubscribe = () => {\n    };\n    const tuplePromise = new Promise((resolve, reject) => {\n      let stopListening = startListening({\n        predicate,\n        effect: (action, listenerApi) => {\n          listenerApi.unsubscribe();\n          resolve([action, listenerApi.getState(), listenerApi.getOriginalState()]);\n        }\n      });\n      unsubscribe = () => {\n        stopListening();\n        reject();\n      };\n    });\n    const promises = [tuplePromise];\n    if (timeout != null) {\n      promises.push(new Promise((resolve) => setTimeout(resolve, timeout, null)));\n    }\n    try {\n      const output = await raceWithSignal(signal, Promise.race(promises));\n      validateActive(signal);\n      return output;\n    } finally {\n      unsubscribe();\n    }\n  };\n  return (predicate, timeout) => catchRejection(take(predicate, timeout));\n};\nvar getListenerEntryPropsFrom = (options) => {\n  let {\n    type,\n    actionCreator,\n    matcher,\n    predicate,\n    effect\n  } = options;\n  if (type) {\n    predicate = createAction(type).match;\n  } else if (actionCreator) {\n    type = actionCreator.type;\n    predicate = actionCreator.match;\n  } else if (matcher) {\n    predicate = matcher;\n  } else if (predicate) {\n  } else {\n    throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(21) : \"Creating or removing a listener requires one of the known fields for matching an action\");\n  }\n  assertFunction(effect, \"options.listener\");\n  return {\n    predicate,\n    type,\n    effect\n  };\n};\nvar createListenerEntry = Object.assign((options) => {\n  const {\n    type,\n    predicate,\n    effect\n  } = getListenerEntryPropsFrom(options);\n  const id = nanoid();\n  const entry = {\n    id,\n    effect,\n    type,\n    predicate,\n    pending: /* @__PURE__ */ new Set(),\n    unsubscribe: () => {\n      throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(22) : \"Unsubscribe not initialized\");\n    }\n  };\n  return entry;\n}, {\n  withTypes: () => createListenerEntry\n});\nvar cancelActiveListeners = (entry) => {\n  entry.pending.forEach((controller) => {\n    abortControllerWithReason(controller, listenerCancelled);\n  });\n};\nvar createClearListenerMiddleware = (listenerMap) => {\n  return () => {\n    listenerMap.forEach(cancelActiveListeners);\n    listenerMap.clear();\n  };\n};\nvar safelyNotifyError = (errorHandler, errorToNotify, errorInfo) => {\n  try {\n    errorHandler(errorToNotify, errorInfo);\n  } catch (errorHandlerError) {\n    setTimeout(() => {\n      throw errorHandlerError;\n    }, 0);\n  }\n};\nvar addListener = Object.assign(createAction(`${alm}/add`), {\n  withTypes: () => addListener\n});\nvar clearAllListeners = createAction(`${alm}/removeAll`);\nvar removeListener = Object.assign(createAction(`${alm}/remove`), {\n  withTypes: () => removeListener\n});\nvar defaultErrorHandler = (...args) => {\n  console.error(`${alm}/error`, ...args);\n};\nvar createListenerMiddleware = (middlewareOptions = {}) => {\n  const listenerMap = /* @__PURE__ */ new Map();\n  const {\n    extra,\n    onError = defaultErrorHandler\n  } = middlewareOptions;\n  assertFunction(onError, \"onError\");\n  const insertEntry = (entry) => {\n    entry.unsubscribe = () => listenerMap.delete(entry.id);\n    listenerMap.set(entry.id, entry);\n    return (cancelOptions) => {\n      entry.unsubscribe();\n      if (cancelOptions?.cancelActive) {\n        cancelActiveListeners(entry);\n      }\n    };\n  };\n  const startListening = (options) => {\n    let entry = find(Array.from(listenerMap.values()), (existingEntry) => existingEntry.effect === options.effect);\n    if (!entry) {\n      entry = createListenerEntry(options);\n    }\n    return insertEntry(entry);\n  };\n  Object.assign(startListening, {\n    withTypes: () => startListening\n  });\n  const stopListening = (options) => {\n    const {\n      type,\n      effect,\n      predicate\n    } = getListenerEntryPropsFrom(options);\n    const entry = find(Array.from(listenerMap.values()), (entry2) => {\n      const matchPredicateOrType = typeof type === \"string\" ? entry2.type === type : entry2.predicate === predicate;\n      return matchPredicateOrType && entry2.effect === effect;\n    });\n    if (entry) {\n      entry.unsubscribe();\n      if (options.cancelActive) {\n        cancelActiveListeners(entry);\n      }\n    }\n    return !!entry;\n  };\n  Object.assign(stopListening, {\n    withTypes: () => stopListening\n  });\n  const notifyListener = async (entry, action, api, getOriginalState) => {\n    const internalTaskController = new AbortController();\n    const take = createTakePattern(startListening, internalTaskController.signal);\n    const autoJoinPromises = [];\n    try {\n      entry.pending.add(internalTaskController);\n      await Promise.resolve(entry.effect(\n        action,\n        // Use assign() rather than ... to avoid extra helper functions added to bundle\n        assign({}, api, {\n          getOriginalState,\n          condition: (predicate, timeout) => take(predicate, timeout).then(Boolean),\n          take,\n          delay: createDelay(internalTaskController.signal),\n          pause: createPause(internalTaskController.signal),\n          extra,\n          signal: internalTaskController.signal,\n          fork: createFork(internalTaskController.signal, autoJoinPromises),\n          unsubscribe: entry.unsubscribe,\n          subscribe: () => {\n            listenerMap.set(entry.id, entry);\n          },\n          cancelActiveListeners: () => {\n            entry.pending.forEach((controller, _, set) => {\n              if (controller !== internalTaskController) {\n                abortControllerWithReason(controller, listenerCancelled);\n                set.delete(controller);\n              }\n            });\n          },\n          cancel: () => {\n            abortControllerWithReason(internalTaskController, listenerCancelled);\n            entry.pending.delete(internalTaskController);\n          },\n          throwIfCancelled: () => {\n            validateActive(internalTaskController.signal);\n          }\n        })\n      ));\n    } catch (listenerError) {\n      if (!(listenerError instanceof TaskAbortError)) {\n        safelyNotifyError(onError, listenerError, {\n          raisedBy: \"effect\"\n        });\n      }\n    } finally {\n      await Promise.all(autoJoinPromises);\n      abortControllerWithReason(internalTaskController, listenerCompleted);\n      entry.pending.delete(internalTaskController);\n    }\n  };\n  const clearListenerMiddleware = createClearListenerMiddleware(listenerMap);\n  const middleware = (api) => (next) => (action) => {\n    if (!isAction3(action)) {\n      return next(action);\n    }\n    if (addListener.match(action)) {\n      return startListening(action.payload);\n    }\n    if (clearAllListeners.match(action)) {\n      clearListenerMiddleware();\n      return;\n    }\n    if (removeListener.match(action)) {\n      return stopListening(action.payload);\n    }\n    let originalState = api.getState();\n    const getOriginalState = () => {\n      if (originalState === INTERNAL_NIL_TOKEN) {\n        throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(23) : `${alm}: getOriginalState can only be called synchronously`);\n      }\n      return originalState;\n    };\n    let result;\n    try {\n      result = next(action);\n      if (listenerMap.size > 0) {\n        const currentState = api.getState();\n        const listenerEntries = Array.from(listenerMap.values());\n        for (const entry of listenerEntries) {\n          let runListener = false;\n          try {\n            runListener = entry.predicate(action, currentState, originalState);\n          } catch (predicateError) {\n            runListener = false;\n            safelyNotifyError(onError, predicateError, {\n              raisedBy: \"predicate\"\n            });\n          }\n          if (!runListener) {\n            continue;\n          }\n          notifyListener(entry, action, api, getOriginalState);\n        }\n      }\n    } finally {\n      originalState = INTERNAL_NIL_TOKEN;\n    }\n    return result;\n  };\n  return {\n    middleware,\n    startListening,\n    stopListening,\n    clearListeners: clearListenerMiddleware\n  };\n};\n\n// src/dynamicMiddleware/index.ts\nimport { compose as compose3 } from \"redux\";\nvar createMiddlewareEntry = (middleware) => ({\n  id: nanoid(),\n  middleware,\n  applied: /* @__PURE__ */ new Map()\n});\nvar matchInstance = (instanceId) => (action) => action?.meta?.instanceId === instanceId;\nvar createDynamicMiddleware = () => {\n  const instanceId = nanoid();\n  const middlewareMap = /* @__PURE__ */ new Map();\n  const withMiddleware = Object.assign(createAction(\"dynamicMiddleware/add\", (...middlewares) => ({\n    payload: middlewares,\n    meta: {\n      instanceId\n    }\n  })), {\n    withTypes: () => withMiddleware\n  });\n  const addMiddleware = Object.assign(function addMiddleware2(...middlewares) {\n    middlewares.forEach((middleware2) => {\n      let entry = find(Array.from(middlewareMap.values()), (entry2) => entry2.middleware === middleware2);\n      if (!entry) {\n        entry = createMiddlewareEntry(middleware2);\n      }\n      middlewareMap.set(entry.id, entry);\n    });\n  }, {\n    withTypes: () => addMiddleware\n  });\n  const getFinalMiddleware = (api) => {\n    const appliedMiddleware = Array.from(middlewareMap.values()).map((entry) => emplace(entry.applied, api, {\n      insert: () => entry.middleware(api)\n    }));\n    return compose3(...appliedMiddleware);\n  };\n  const isWithMiddleware = isAllOf(withMiddleware, matchInstance(instanceId));\n  const middleware = (api) => (next) => (action) => {\n    if (isWithMiddleware(action)) {\n      addMiddleware(...action.payload);\n      return api.dispatch;\n    }\n    return getFinalMiddleware(api)(next)(action);\n  };\n  return {\n    middleware,\n    addMiddleware,\n    withMiddleware,\n    instanceId\n  };\n};\n\n// src/combineSlices.ts\nimport { combineReducers as combineReducers2 } from \"redux\";\nvar isSliceLike = (maybeSliceLike) => \"reducerPath\" in maybeSliceLike && typeof maybeSliceLike.reducerPath === \"string\";\nvar getReducers = (slices) => slices.flatMap((sliceOrMap) => isSliceLike(sliceOrMap) ? [[sliceOrMap.reducerPath, sliceOrMap.reducer]] : Object.entries(sliceOrMap));\nvar ORIGINAL_STATE = Symbol.for(\"rtk-state-proxy-original\");\nvar isStateProxy = (value) => !!value && !!value[ORIGINAL_STATE];\nvar stateProxyMap = /* @__PURE__ */ new WeakMap();\nvar createStateProxy = (state, reducerMap) => emplace(stateProxyMap, state, {\n  insert: () => new Proxy(state, {\n    get: (target, prop, receiver) => {\n      if (prop === ORIGINAL_STATE)\n        return target;\n      const result = Reflect.get(target, prop, receiver);\n      if (typeof result === \"undefined\") {\n        const reducer = reducerMap[prop.toString()];\n        if (reducer) {\n          const reducerResult = reducer(void 0, {\n            type: nanoid()\n          });\n          if (typeof reducerResult === \"undefined\") {\n            throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(24) : `The slice reducer for key \"${prop.toString()}\" returned undefined when called for selector(). If the state passed to the reducer is undefined, you must explicitly return the initial state. The initial state may not be undefined. If you don't want to set a value for this reducer, you can use null instead of undefined.`);\n          }\n          return reducerResult;\n        }\n      }\n      return result;\n    }\n  })\n});\nvar original = (state) => {\n  if (!isStateProxy(state)) {\n    throw new Error(process.env.NODE_ENV === \"production\" ? formatProdErrorMessage(25) : \"original must be used on state Proxy\");\n  }\n  return state[ORIGINAL_STATE];\n};\nvar noopReducer = (state = {}) => state;\nfunction combineSlices(...slices) {\n  const reducerMap = Object.fromEntries(getReducers(slices));\n  const getReducer = () => Object.keys(reducerMap).length ? combineReducers2(reducerMap) : noopReducer;\n  let reducer = getReducer();\n  function combinedReducer(state, action) {\n    return reducer(state, action);\n  }\n  combinedReducer.withLazyLoadedSlices = () => combinedReducer;\n  const inject = (slice, config = {}) => {\n    const {\n      reducerPath,\n      reducer: reducerToInject\n    } = slice;\n    const currentReducer = reducerMap[reducerPath];\n    if (!config.overrideExisting && currentReducer && currentReducer !== reducerToInject) {\n      if (typeof process !== \"undefined\" && process.env.NODE_ENV === \"development\") {\n        console.error(`called \\`inject\\` to override already-existing reducer ${reducerPath} without specifying \\`overrideExisting: true\\``);\n      }\n      return combinedReducer;\n    }\n    reducerMap[reducerPath] = reducerToInject;\n    reducer = getReducer();\n    return combinedReducer;\n  };\n  const selector = Object.assign(function makeSelector(selectorFn, selectState) {\n    return function selector2(state, ...args) {\n      return selectorFn(createStateProxy(selectState ? selectState(state, ...args) : state, reducerMap), ...args);\n    };\n  }, {\n    original\n  });\n  return Object.assign(combinedReducer, {\n    inject,\n    selector\n  });\n}\n\n// src/formatProdErrorMessage.ts\nfunction formatProdErrorMessage(code) {\n  return `Minified Redux Toolkit error #${code}; visit https://redux-toolkit.js.org/Errors?code=${code} for the full message or use the non-minified dev environment for full errors. `;\n}\nexport {\n  ReducerType,\n  SHOULD_AUTOBATCH,\n  TaskAbortError,\n  Tuple,\n  addListener,\n  asyncThunkCreator,\n  autoBatchEnhancer,\n  buildCreateSlice,\n  clearAllListeners,\n  combineSlices,\n  configureStore,\n  createAction,\n  createActionCreatorInvariantMiddleware,\n  createAsyncThunk,\n  createDraftSafeSelector,\n  createDraftSafeSelectorCreator,\n  createDynamicMiddleware,\n  createEntityAdapter,\n  createImmutableStateInvariantMiddleware,\n  createListenerMiddleware,\n  produce as createNextState,\n  createReducer,\n  createSelector,\n  createSelectorCreator2 as createSelectorCreator,\n  createSerializableStateInvariantMiddleware,\n  createSlice,\n  current2 as current,\n  findNonSerializableValue,\n  formatProdErrorMessage,\n  freeze,\n  isActionCreator,\n  isAllOf,\n  isAnyOf,\n  isAsyncThunkAction,\n  isDraft4 as isDraft,\n  isFSA as isFluxStandardAction,\n  isFulfilled,\n  isImmutableDefault,\n  isPending,\n  isPlain,\n  isRejected,\n  isRejectedWithValue,\n  lruMemoize,\n  miniSerializeError,\n  nanoid,\n  original2 as original,\n  prepareAutoBatched,\n  removeListener,\n  unwrapResult,\n  weakMapMemoize2 as weakMapMemoize\n};\n//# sourceMappingURL=redux-toolkit.modern.mjs.map",
    "// src/query/core/apiState.ts\nvar QueryStatus = /* @__PURE__ */ ((QueryStatus2) => {\n  QueryStatus2[\"uninitialized\"] = \"uninitialized\";\n  QueryStatus2[\"pending\"] = \"pending\";\n  QueryStatus2[\"fulfilled\"] = \"fulfilled\";\n  QueryStatus2[\"rejected\"] = \"rejected\";\n  return QueryStatus2;\n})(QueryStatus || {});\nfunction getRequestStatusFlags(status) {\n  return {\n    status,\n    isUninitialized: status === \"uninitialized\" /* uninitialized */,\n    isLoading: status === \"pending\" /* pending */,\n    isSuccess: status === \"fulfilled\" /* fulfilled */,\n    isError: status === \"rejected\" /* rejected */\n  };\n}\n\n// src/query/utils/isAbsoluteUrl.ts\nfunction isAbsoluteUrl(url) {\n  return new RegExp(`(^|:)//`).test(url);\n}\n\n// src/query/utils/joinUrls.ts\nvar withoutTrailingSlash = (url) => url.replace(/\\/$/, \"\");\nvar withoutLeadingSlash = (url) => url.replace(/^\\//, \"\");\nfunction joinUrls(base, url) {\n  if (!base) {\n    return url;\n  }\n  if (!url) {\n    return base;\n  }\n  if (isAbsoluteUrl(url)) {\n    return url;\n  }\n  const delimiter = base.endsWith(\"/\") || !url.startsWith(\"?\") ? \"/\" : \"\";\n  base = withoutTrailingSlash(base);\n  url = withoutLeadingSlash(url);\n  return `${base}${delimiter}${url}`;\n}\n\n// src/query/utils/flatten.ts\nvar flatten = (arr) => [].concat(...arr);\n\n// src/query/utils/isOnline.ts\nfunction isOnline() {\n  return typeof navigator === \"undefined\" ? true : navigator.onLine === void 0 ? true : navigator.onLine;\n}\n\n// src/query/utils/isDocumentVisible.ts\nfunction isDocumentVisible() {\n  if (typeof document === \"undefined\") {\n    return true;\n  }\n  return document.visibilityState !== \"hidden\";\n}\n\n// src/query/core/rtkImports.ts\nimport { createAction, createSlice, createSelector, createAsyncThunk, combineReducers, createNextState, isAnyOf, isAllOf, isAction, isPending, isRejected, isFulfilled, isRejectedWithValue, isAsyncThunkAction, prepareAutoBatched, SHOULD_AUTOBATCH, isPlainObject, nanoid } from \"@reduxjs/toolkit\";\n\n// src/query/utils/copyWithStructuralSharing.ts\nvar isPlainObject2 = isPlainObject;\nfunction copyWithStructuralSharing(oldObj, newObj) {\n  if (oldObj === newObj || !(isPlainObject2(oldObj) && isPlainObject2(newObj) || Array.isArray(oldObj) && Array.isArray(newObj))) {\n    return newObj;\n  }\n  const newKeys = Object.keys(newObj);\n  const oldKeys = Object.keys(oldObj);\n  let isSameObject = newKeys.length === oldKeys.length;\n  const mergeObj = Array.isArray(newObj) ? [] : {};\n  for (const key of newKeys) {\n    mergeObj[key] = copyWithStructuralSharing(oldObj[key], newObj[key]);\n    if (isSameObject)\n      isSameObject = oldObj[key] === mergeObj[key];\n  }\n  return isSameObject ? oldObj : mergeObj;\n}\n\n// src/query/fetchBaseQuery.ts\nvar defaultFetchFn = (...args) => fetch(...args);\nvar defaultValidateStatus = (response) => response.status >= 200 && response.status <= 299;\nvar defaultIsJsonContentType = (headers) => (\n  /*applicat*/\n  /ion\\/(vnd\\.api\\+)?json/.test(headers.get(\"content-type\") || \"\")\n);\nfunction stripUndefined(obj) {\n  if (!isPlainObject(obj)) {\n    return obj;\n  }\n  const copy = {\n    ...obj\n  };\n  for (const [k, v] of Object.entries(copy)) {\n    if (v === void 0)\n      delete copy[k];\n  }\n  return copy;\n}\nfunction fetchBaseQuery({\n  baseUrl,\n  prepareHeaders = (x) => x,\n  fetchFn = defaultFetchFn,\n  paramsSerializer,\n  isJsonContentType = defaultIsJsonContentType,\n  jsonContentType = \"application/json\",\n  jsonReplacer,\n  timeout: defaultTimeout,\n  responseHandler: globalResponseHandler,\n  validateStatus: globalValidateStatus,\n  ...baseFetchOptions\n} = {}) {\n  if (typeof fetch === \"undefined\" && fetchFn === defaultFetchFn) {\n    console.warn(\"Warning: `fetch` is not available. Please supply a custom `fetchFn` property to use `fetchBaseQuery` on SSR environments.\");\n  }\n  return async (arg, api) => {\n    const {\n      signal,\n      getState,\n      extra,\n      endpoint,\n      forced,\n      type\n    } = api;\n    let meta;\n    let {\n      url,\n      headers = new Headers(baseFetchOptions.headers),\n      params = void 0,\n      responseHandler = globalResponseHandler ?? \"json\",\n      validateStatus = globalValidateStatus ?? defaultValidateStatus,\n      timeout = defaultTimeout,\n      ...rest\n    } = typeof arg == \"string\" ? {\n      url: arg\n    } : arg;\n    let config = {\n      ...baseFetchOptions,\n      signal,\n      ...rest\n    };\n    headers = new Headers(stripUndefined(headers));\n    config.headers = await prepareHeaders(headers, {\n      getState,\n      extra,\n      endpoint,\n      forced,\n      type\n    }) || headers;\n    const isJsonifiable = (body) => typeof body === \"object\" && (isPlainObject(body) || Array.isArray(body) || typeof body.toJSON === \"function\");\n    if (!config.headers.has(\"content-type\") && isJsonifiable(config.body)) {\n      config.headers.set(\"content-type\", jsonContentType);\n    }\n    if (isJsonifiable(config.body) && isJsonContentType(config.headers)) {\n      config.body = JSON.stringify(config.body, jsonReplacer);\n    }\n    if (params) {\n      const divider = ~url.indexOf(\"?\") ? \"&\" : \"?\";\n      const query = paramsSerializer ? paramsSerializer(params) : new URLSearchParams(stripUndefined(params));\n      url += divider + query;\n    }\n    url = joinUrls(baseUrl, url);\n    const request = new Request(url, config);\n    const requestClone = new Request(url, config);\n    meta = {\n      request: requestClone\n    };\n    let response, timedOut = false, timeoutId = timeout && setTimeout(() => {\n      timedOut = true;\n      api.abort();\n    }, timeout);\n    try {\n      response = await fetchFn(request);\n    } catch (e) {\n      return {\n        error: {\n          status: timedOut ? \"TIMEOUT_ERROR\" : \"FETCH_ERROR\",\n          error: String(e)\n        },\n        meta\n      };\n    } finally {\n      if (timeoutId)\n        clearTimeout(timeoutId);\n    }\n    const responseClone = response.clone();\n    meta.response = responseClone;\n    let resultData;\n    let responseText = \"\";\n    try {\n      let handleResponseError;\n      await Promise.all([\n        handleResponse(response, responseHandler).then((r) => resultData = r, (e) => handleResponseError = e),\n        // see https://github.com/node-fetch/node-fetch/issues/665#issuecomment-538995182\n        // we *have* to \"use up\" both streams at the same time or they will stop running in node-fetch scenarios\n        responseClone.text().then((r) => responseText = r, () => {\n        })\n      ]);\n      if (handleResponseError)\n        throw handleResponseError;\n    } catch (e) {\n      return {\n        error: {\n          status: \"PARSING_ERROR\",\n          originalStatus: response.status,\n          data: responseText,\n          error: String(e)\n        },\n        meta\n      };\n    }\n    return validateStatus(response, resultData) ? {\n      data: resultData,\n      meta\n    } : {\n      error: {\n        status: response.status,\n        data: resultData\n      },\n      meta\n    };\n  };\n  async function handleResponse(response, responseHandler) {\n    if (typeof responseHandler === \"function\") {\n      return responseHandler(response);\n    }\n    if (responseHandler === \"content-type\") {\n      responseHandler = isJsonContentType(response.headers) ? \"json\" : \"text\";\n    }\n    if (responseHandler === \"json\") {\n      const text = await response.text();\n      return text.length ? JSON.parse(text) : null;\n    }\n    return response.text();\n  }\n}\n\n// src/query/HandledError.ts\nvar HandledError = class {\n  constructor(value, meta = void 0) {\n    this.value = value;\n    this.meta = meta;\n  }\n};\n\n// src/query/retry.ts\nasync function defaultBackoff(attempt = 0, maxRetries = 5) {\n  const attempts = Math.min(attempt, maxRetries);\n  const timeout = ~~((Math.random() + 0.4) * (300 << attempts));\n  await new Promise((resolve) => setTimeout((res) => resolve(res), timeout));\n}\nfunction fail(e) {\n  throw Object.assign(new HandledError({\n    error: e\n  }), {\n    throwImmediately: true\n  });\n}\nvar EMPTY_OPTIONS = {};\nvar retryWithBackoff = (baseQuery, defaultOptions) => async (args, api, extraOptions) => {\n  const possibleMaxRetries = [5, (defaultOptions || EMPTY_OPTIONS).maxRetries, (extraOptions || EMPTY_OPTIONS).maxRetries].filter((x) => x !== void 0);\n  const [maxRetries] = possibleMaxRetries.slice(-1);\n  const defaultRetryCondition = (_, __, {\n    attempt\n  }) => attempt <= maxRetries;\n  const options = {\n    maxRetries,\n    backoff: defaultBackoff,\n    retryCondition: defaultRetryCondition,\n    ...defaultOptions,\n    ...extraOptions\n  };\n  let retry2 = 0;\n  while (true) {\n    try {\n      const result = await baseQuery(args, api, extraOptions);\n      if (result.error) {\n        throw new HandledError(result);\n      }\n      return result;\n    } catch (e) {\n      retry2++;\n      if (e.throwImmediately) {\n        if (e instanceof HandledError) {\n          return e.value;\n        }\n        throw e;\n      }\n      if (e instanceof HandledError && !options.retryCondition(e.value.error, args, {\n        attempt: retry2,\n        baseQueryApi: api,\n        extraOptions\n      })) {\n        return e.value;\n      }\n      await options.backoff(retry2, options.maxRetries);\n    }\n  }\n};\nvar retry = /* @__PURE__ */ Object.assign(retryWithBackoff, {\n  fail\n});\n\n// src/query/core/setupListeners.ts\nvar onFocus = /* @__PURE__ */ createAction(\"__rtkq/focused\");\nvar onFocusLost = /* @__PURE__ */ createAction(\"__rtkq/unfocused\");\nvar onOnline = /* @__PURE__ */ createAction(\"__rtkq/online\");\nvar onOffline = /* @__PURE__ */ createAction(\"__rtkq/offline\");\nvar initialized = false;\nfunction setupListeners(dispatch, customHandler) {\n  function defaultHandler() {\n    const handleFocus = () => dispatch(onFocus());\n    const handleFocusLost = () => dispatch(onFocusLost());\n    const handleOnline = () => dispatch(onOnline());\n    const handleOffline = () => dispatch(onOffline());\n    const handleVisibilityChange = () => {\n      if (window.document.visibilityState === \"visible\") {\n        handleFocus();\n      } else {\n        handleFocusLost();\n      }\n    };\n    if (!initialized) {\n      if (typeof window !== \"undefined\" && window.addEventListener) {\n        window.addEventListener(\"visibilitychange\", handleVisibilityChange, false);\n        window.addEventListener(\"focus\", handleFocus, false);\n        window.addEventListener(\"online\", handleOnline, false);\n        window.addEventListener(\"offline\", handleOffline, false);\n        initialized = true;\n      }\n    }\n    const unsubscribe = () => {\n      window.removeEventListener(\"focus\", handleFocus);\n      window.removeEventListener(\"visibilitychange\", handleVisibilityChange);\n      window.removeEventListener(\"online\", handleOnline);\n      window.removeEventListener(\"offline\", handleOffline);\n      initialized = false;\n    };\n    return unsubscribe;\n  }\n  return customHandler ? customHandler(dispatch, {\n    onFocus,\n    onFocusLost,\n    onOffline,\n    onOnline\n  }) : defaultHandler();\n}\n\n// src/query/endpointDefinitions.ts\nfunction isQueryDefinition(e) {\n  return e.type === \"query\" /* query */;\n}\nfunction isMutationDefinition(e) {\n  return e.type === \"mutation\" /* mutation */;\n}\nfunction calculateProvidedBy(description, result, error, queryArg, meta, assertTagTypes) {\n  if (isFunction(description)) {\n    return description(result, error, queryArg, meta).map(expandTagDescription).map(assertTagTypes);\n  }\n  if (Array.isArray(description)) {\n    return description.map(expandTagDescription).map(assertTagTypes);\n  }\n  return [];\n}\nfunction isFunction(t) {\n  return typeof t === \"function\";\n}\nfunction expandTagDescription(description) {\n  return typeof description === \"string\" ? {\n    type: description\n  } : description;\n}\n\n// src/query/core/buildInitiate.ts\nimport { formatProdErrorMessage as _formatProdErrorMessage } from \"@reduxjs/toolkit\";\n\n// src/query/utils/isNotNullish.ts\nfunction isNotNullish(v) {\n  return v != null;\n}\n\n// src/query/utils/countObjectKeys.ts\nfunction countObjectKeys(obj) {\n  let count = 0;\n  for (const _key in obj) {\n    count++;\n  }\n  return count;\n}\n\n// src/tsHelpers.ts\nfunction asSafePromise(promise, fallback) {\n  return promise.catch(fallback);\n}\n\n// src/query/core/buildInitiate.ts\nvar forceQueryFnSymbol = Symbol(\"forceQueryFn\");\nvar isUpsertQuery = (arg) => typeof arg[forceQueryFnSymbol] === \"function\";\nfunction buildInitiate({\n  serializeQueryArgs,\n  queryThunk,\n  mutationThunk,\n  api,\n  context\n}) {\n  const runningQueries = /* @__PURE__ */ new Map();\n  const runningMutations = /* @__PURE__ */ new Map();\n  const {\n    unsubscribeQueryResult,\n    removeMutationResult,\n    updateSubscriptionOptions\n  } = api.internalActions;\n  return {\n    buildInitiateQuery,\n    buildInitiateMutation,\n    getRunningQueryThunk,\n    getRunningMutationThunk,\n    getRunningQueriesThunk,\n    getRunningMutationsThunk\n  };\n  function getRunningQueryThunk(endpointName, queryArgs) {\n    return (dispatch) => {\n      const endpointDefinition = context.endpointDefinitions[endpointName];\n      const queryCacheKey = serializeQueryArgs({\n        queryArgs,\n        endpointDefinition,\n        endpointName\n      });\n      return runningQueries.get(dispatch)?.[queryCacheKey];\n    };\n  }\n  function getRunningMutationThunk(_endpointName, fixedCacheKeyOrRequestId) {\n    return (dispatch) => {\n      return runningMutations.get(dispatch)?.[fixedCacheKeyOrRequestId];\n    };\n  }\n  function getRunningQueriesThunk() {\n    return (dispatch) => Object.values(runningQueries.get(dispatch) || {}).filter(isNotNullish);\n  }\n  function getRunningMutationsThunk() {\n    return (dispatch) => Object.values(runningMutations.get(dispatch) || {}).filter(isNotNullish);\n  }\n  function middlewareWarning(dispatch) {\n    if (process.env.NODE_ENV !== \"production\") {\n      if (middlewareWarning.triggered)\n        return;\n      const returnedValue = dispatch(api.internalActions.internal_getRTKQSubscriptions());\n      middlewareWarning.triggered = true;\n      if (typeof returnedValue !== \"object\" || typeof returnedValue?.type === \"string\") {\n        throw new Error(process.env.NODE_ENV === \"production\" ? _formatProdErrorMessage(34) : `Warning: Middleware for RTK-Query API at reducerPath \"${api.reducerPath}\" has not been added to the store.\nYou must add the middleware for RTK-Query to function correctly!`);\n      }\n    }\n  }\n  function buildInitiateQuery(endpointName, endpointDefinition) {\n    const queryAction = (arg, {\n      subscribe = true,\n      forceRefetch,\n      subscriptionOptions,\n      [forceQueryFnSymbol]: forceQueryFn,\n      ...rest\n    } = {}) => (dispatch, getState) => {\n      const queryCacheKey = serializeQueryArgs({\n        queryArgs: arg,\n        endpointDefinition,\n        endpointName\n      });\n      const thunk = queryThunk({\n        ...rest,\n        type: \"query\",\n        subscribe,\n        forceRefetch,\n        subscriptionOptions,\n        endpointName,\n        originalArgs: arg,\n        queryCacheKey,\n        [forceQueryFnSymbol]: forceQueryFn\n      });\n      const selector = api.endpoints[endpointName].select(arg);\n      const thunkResult = dispatch(thunk);\n      const stateAfter = selector(getState());\n      middlewareWarning(dispatch);\n      const {\n        requestId,\n        abort\n      } = thunkResult;\n      const skippedSynchronously = stateAfter.requestId !== requestId;\n      const runningQuery = runningQueries.get(dispatch)?.[queryCacheKey];\n      const selectFromState = () => selector(getState());\n      const statePromise = Object.assign(forceQueryFn ? (\n        // a query has been forced (upsertQueryData)\n        // -> we want to resolve it once data has been written with the data that will be written\n        thunkResult.then(selectFromState)\n      ) : skippedSynchronously && !runningQuery ? (\n        // a query has been skipped due to a condition and we do not have any currently running query\n        // -> we want to resolve it immediately with the current data\n        Promise.resolve(stateAfter)\n      ) : (\n        // query just started or one is already in flight\n        // -> wait for the running query, then resolve with data from after that\n        Promise.all([runningQuery, thunkResult]).then(selectFromState)\n      ), {\n        arg,\n        requestId,\n        subscriptionOptions,\n        queryCacheKey,\n        abort,\n        async unwrap() {\n          const result = await statePromise;\n          if (result.isError) {\n            throw result.error;\n          }\n          return result.data;\n        },\n        refetch: () => dispatch(queryAction(arg, {\n          subscribe: false,\n          forceRefetch: true\n        })),\n        unsubscribe() {\n          if (subscribe)\n            dispatch(unsubscribeQueryResult({\n              queryCacheKey,\n              requestId\n            }));\n        },\n        updateSubscriptionOptions(options) {\n          statePromise.subscriptionOptions = options;\n          dispatch(updateSubscriptionOptions({\n            endpointName,\n            requestId,\n            queryCacheKey,\n            options\n          }));\n        }\n      });\n      if (!runningQuery && !skippedSynchronously && !forceQueryFn) {\n        const running = runningQueries.get(dispatch) || {};\n        running[queryCacheKey] = statePromise;\n        runningQueries.set(dispatch, running);\n        statePromise.then(() => {\n          delete running[queryCacheKey];\n          if (!countObjectKeys(running)) {\n            runningQueries.delete(dispatch);\n          }\n        });\n      }\n      return statePromise;\n    };\n    return queryAction;\n  }\n  function buildInitiateMutation(endpointName) {\n    return (arg, {\n      track = true,\n      fixedCacheKey\n    } = {}) => (dispatch, getState) => {\n      const thunk = mutationThunk({\n        type: \"mutation\",\n        endpointName,\n        originalArgs: arg,\n        track,\n        fixedCacheKey\n      });\n      const thunkResult = dispatch(thunk);\n      middlewareWarning(dispatch);\n      const {\n        requestId,\n        abort,\n        unwrap\n      } = thunkResult;\n      const returnValuePromise = asSafePromise(thunkResult.unwrap().then((data) => ({\n        data\n      })), (error) => ({\n        error\n      }));\n      const reset = () => {\n        dispatch(removeMutationResult({\n          requestId,\n          fixedCacheKey\n        }));\n      };\n      const ret = Object.assign(returnValuePromise, {\n        arg: thunkResult.arg,\n        requestId,\n        abort,\n        unwrap,\n        reset\n      });\n      const running = runningMutations.get(dispatch) || {};\n      runningMutations.set(dispatch, running);\n      running[requestId] = ret;\n      ret.then(() => {\n        delete running[requestId];\n        if (!countObjectKeys(running)) {\n          runningMutations.delete(dispatch);\n        }\n      });\n      if (fixedCacheKey) {\n        running[fixedCacheKey] = ret;\n        ret.then(() => {\n          if (running[fixedCacheKey] === ret) {\n            delete running[fixedCacheKey];\n            if (!countObjectKeys(running)) {\n              runningMutations.delete(dispatch);\n            }\n          }\n        });\n      }\n      return ret;\n    };\n  }\n}\n\n// src/query/core/buildThunks.ts\nimport { isDraftable, produceWithPatches } from \"immer\";\nfunction defaultTransformResponse(baseQueryReturnValue) {\n  return baseQueryReturnValue;\n}\nfunction buildThunks({\n  reducerPath,\n  baseQuery,\n  context: {\n    endpointDefinitions\n  },\n  serializeQueryArgs,\n  api,\n  assertTagType\n}) {\n  const patchQueryData = (endpointName, args, patches, updateProvided) => (dispatch, getState) => {\n    const endpointDefinition = endpointDefinitions[endpointName];\n    const queryCacheKey = serializeQueryArgs({\n      queryArgs: args,\n      endpointDefinition,\n      endpointName\n    });\n    dispatch(api.internalActions.queryResultPatched({\n      queryCacheKey,\n      patches\n    }));\n    if (!updateProvided) {\n      return;\n    }\n    const newValue = api.endpoints[endpointName].select(args)(\n      // Work around TS 4.1 mismatch\n      getState()\n    );\n    const providedTags = calculateProvidedBy(endpointDefinition.providesTags, newValue.data, void 0, args, {}, assertTagType);\n    dispatch(api.internalActions.updateProvidedBy({\n      queryCacheKey,\n      providedTags\n    }));\n  };\n  const updateQueryData = (endpointName, args, updateRecipe, updateProvided = true) => (dispatch, getState) => {\n    const endpointDefinition = api.endpoints[endpointName];\n    const currentState = endpointDefinition.select(args)(\n      // Work around TS 4.1 mismatch\n      getState()\n    );\n    let ret = {\n      patches: [],\n      inversePatches: [],\n      undo: () => dispatch(api.util.patchQueryData(endpointName, args, ret.inversePatches, updateProvided))\n    };\n    if (currentState.status === \"uninitialized\" /* uninitialized */) {\n      return ret;\n    }\n    let newValue;\n    if (\"data\" in currentState) {\n      if (isDraftable(currentState.data)) {\n        const [value, patches, inversePatches] = produceWithPatches(currentState.data, updateRecipe);\n        ret.patches.push(...patches);\n        ret.inversePatches.push(...inversePatches);\n        newValue = value;\n      } else {\n        newValue = updateRecipe(currentState.data);\n        ret.patches.push({\n          op: \"replace\",\n          path: [],\n          value: newValue\n        });\n        ret.inversePatches.push({\n          op: \"replace\",\n          path: [],\n          value: currentState.data\n        });\n      }\n    }\n    if (ret.patches.length === 0) {\n      return ret;\n    }\n    dispatch(api.util.patchQueryData(endpointName, args, ret.patches, updateProvided));\n    return ret;\n  };\n  const upsertQueryData = (endpointName, args, value) => (dispatch) => {\n    return dispatch(api.endpoints[endpointName].initiate(args, {\n      subscribe: false,\n      forceRefetch: true,\n      [forceQueryFnSymbol]: () => ({\n        data: value\n      })\n    }));\n  };\n  const executeEndpoint = async (arg, {\n    signal,\n    abort,\n    rejectWithValue,\n    fulfillWithValue,\n    dispatch,\n    getState,\n    extra\n  }) => {\n    const endpointDefinition = endpointDefinitions[arg.endpointName];\n    try {\n      let transformResponse = defaultTransformResponse;\n      let result;\n      const baseQueryApi = {\n        signal,\n        abort,\n        dispatch,\n        getState,\n        extra,\n        endpoint: arg.endpointName,\n        type: arg.type,\n        forced: arg.type === \"query\" ? isForcedQuery(arg, getState()) : void 0\n      };\n      const forceQueryFn = arg.type === \"query\" ? arg[forceQueryFnSymbol] : void 0;\n      if (forceQueryFn) {\n        result = forceQueryFn();\n      } else if (endpointDefinition.query) {\n        result = await baseQuery(endpointDefinition.query(arg.originalArgs), baseQueryApi, endpointDefinition.extraOptions);\n        if (endpointDefinition.transformResponse) {\n          transformResponse = endpointDefinition.transformResponse;\n        }\n      } else {\n        result = await endpointDefinition.queryFn(arg.originalArgs, baseQueryApi, endpointDefinition.extraOptions, (arg2) => baseQuery(arg2, baseQueryApi, endpointDefinition.extraOptions));\n      }\n      if (typeof process !== \"undefined\" && process.env.NODE_ENV === \"development\") {\n        const what = endpointDefinition.query ? \"`baseQuery`\" : \"`queryFn`\";\n        let err;\n        if (!result) {\n          err = `${what} did not return anything.`;\n        } else if (typeof result !== \"object\") {\n          err = `${what} did not return an object.`;\n        } else if (result.error && result.data) {\n          err = `${what} returned an object containing both \\`error\\` and \\`result\\`.`;\n        } else if (result.error === void 0 && result.data === void 0) {\n          err = `${what} returned an object containing neither a valid \\`error\\` and \\`result\\`. At least one of them should not be \\`undefined\\``;\n        } else {\n          for (const key of Object.keys(result)) {\n            if (key !== \"error\" && key !== \"data\" && key !== \"meta\") {\n              err = `The object returned by ${what} has the unknown property ${key}.`;\n              break;\n            }\n          }\n        }\n        if (err) {\n          console.error(`Error encountered handling the endpoint ${arg.endpointName}.\n              ${err}\n              It needs to return an object with either the shape \\`{ data: <value> }\\` or \\`{ error: <value> }\\` that may contain an optional \\`meta\\` property.\n              Object returned was:`, result);\n        }\n      }\n      if (result.error)\n        throw new HandledError(result.error, result.meta);\n      return fulfillWithValue(await transformResponse(result.data, result.meta, arg.originalArgs), {\n        fulfilledTimeStamp: Date.now(),\n        baseQueryMeta: result.meta,\n        [SHOULD_AUTOBATCH]: true\n      });\n    } catch (error) {\n      let catchedError = error;\n      if (catchedError instanceof HandledError) {\n        let transformErrorResponse = defaultTransformResponse;\n        if (endpointDefinition.query && endpointDefinition.transformErrorResponse) {\n          transformErrorResponse = endpointDefinition.transformErrorResponse;\n        }\n        try {\n          return rejectWithValue(await transformErrorResponse(catchedError.value, catchedError.meta, arg.originalArgs), {\n            baseQueryMeta: catchedError.meta,\n            [SHOULD_AUTOBATCH]: true\n          });\n        } catch (e) {\n          catchedError = e;\n        }\n      }\n      if (typeof process !== \"undefined\" && process.env.NODE_ENV !== \"production\") {\n        console.error(`An unhandled error occurred processing a request for the endpoint \"${arg.endpointName}\".\nIn the case of an unhandled error, no tags will be \"provided\" or \"invalidated\".`, catchedError);\n      } else {\n        console.error(catchedError);\n      }\n      throw catchedError;\n    }\n  };\n  function isForcedQuery(arg, state) {\n    const requestState = state[reducerPath]?.queries?.[arg.queryCacheKey];\n    const baseFetchOnMountOrArgChange = state[reducerPath]?.config.refetchOnMountOrArgChange;\n    const fulfilledVal = requestState?.fulfilledTimeStamp;\n    const refetchVal = arg.forceRefetch ?? (arg.subscribe && baseFetchOnMountOrArgChange);\n    if (refetchVal) {\n      return refetchVal === true || (Number(/* @__PURE__ */ new Date()) - Number(fulfilledVal)) / 1e3 >= refetchVal;\n    }\n    return false;\n  }\n  const queryThunk = createAsyncThunk(`${reducerPath}/executeQuery`, executeEndpoint, {\n    getPendingMeta() {\n      return {\n        startedTimeStamp: Date.now(),\n        [SHOULD_AUTOBATCH]: true\n      };\n    },\n    condition(queryThunkArgs, {\n      getState\n    }) {\n      const state = getState();\n      const requestState = state[reducerPath]?.queries?.[queryThunkArgs.queryCacheKey];\n      const fulfilledVal = requestState?.fulfilledTimeStamp;\n      const currentArg = queryThunkArgs.originalArgs;\n      const previousArg = requestState?.originalArgs;\n      const endpointDefinition = endpointDefinitions[queryThunkArgs.endpointName];\n      if (isUpsertQuery(queryThunkArgs)) {\n        return true;\n      }\n      if (requestState?.status === \"pending\") {\n        return false;\n      }\n      if (isForcedQuery(queryThunkArgs, state)) {\n        return true;\n      }\n      if (isQueryDefinition(endpointDefinition) && endpointDefinition?.forceRefetch?.({\n        currentArg,\n        previousArg,\n        endpointState: requestState,\n        state\n      })) {\n        return true;\n      }\n      if (fulfilledVal) {\n        return false;\n      }\n      return true;\n    },\n    dispatchConditionRejection: true\n  });\n  const mutationThunk = createAsyncThunk(`${reducerPath}/executeMutation`, executeEndpoint, {\n    getPendingMeta() {\n      return {\n        startedTimeStamp: Date.now(),\n        [SHOULD_AUTOBATCH]: true\n      };\n    }\n  });\n  const hasTheForce = (options) => \"force\" in options;\n  const hasMaxAge = (options) => \"ifOlderThan\" in options;\n  const prefetch = (endpointName, arg, options) => (dispatch, getState) => {\n    const force = hasTheForce(options) && options.force;\n    const maxAge = hasMaxAge(options) && options.ifOlderThan;\n    const queryAction = (force2 = true) => {\n      const options2 = {\n        forceRefetch: force2,\n        isPrefetch: true\n      };\n      return api.endpoints[endpointName].initiate(arg, options2);\n    };\n    const latestStateValue = api.endpoints[endpointName].select(arg)(getState());\n    if (force) {\n      dispatch(queryAction());\n    } else if (maxAge) {\n      const lastFulfilledTs = latestStateValue?.fulfilledTimeStamp;\n      if (!lastFulfilledTs) {\n        dispatch(queryAction());\n        return;\n      }\n      const shouldRetrigger = (Number(/* @__PURE__ */ new Date()) - Number(new Date(lastFulfilledTs))) / 1e3 >= maxAge;\n      if (shouldRetrigger) {\n        dispatch(queryAction());\n      }\n    } else {\n      dispatch(queryAction(false));\n    }\n  };\n  function matchesEndpoint(endpointName) {\n    return (action) => action?.meta?.arg?.endpointName === endpointName;\n  }\n  function buildMatchThunkActions(thunk, endpointName) {\n    return {\n      matchPending: isAllOf(isPending(thunk), matchesEndpoint(endpointName)),\n      matchFulfilled: isAllOf(isFulfilled(thunk), matchesEndpoint(endpointName)),\n      matchRejected: isAllOf(isRejected(thunk), matchesEndpoint(endpointName))\n    };\n  }\n  return {\n    queryThunk,\n    mutationThunk,\n    prefetch,\n    updateQueryData,\n    upsertQueryData,\n    patchQueryData,\n    buildMatchThunkActions\n  };\n}\nfunction calculateProvidedByThunk(action, type, endpointDefinitions, assertTagType) {\n  return calculateProvidedBy(endpointDefinitions[action.meta.arg.endpointName][type], isFulfilled(action) ? action.payload : void 0, isRejectedWithValue(action) ? action.payload : void 0, action.meta.arg.originalArgs, \"baseQueryMeta\" in action.meta ? action.meta.baseQueryMeta : void 0, assertTagType);\n}\n\n// src/query/core/buildSlice.ts\nimport { isDraft } from \"immer\";\nimport { applyPatches, original } from \"immer\";\nfunction updateQuerySubstateIfExists(state, queryCacheKey, update) {\n  const substate = state[queryCacheKey];\n  if (substate) {\n    update(substate);\n  }\n}\nfunction getMutationCacheKey(id) {\n  return (\"arg\" in id ? id.arg.fixedCacheKey : id.fixedCacheKey) ?? id.requestId;\n}\nfunction updateMutationSubstateIfExists(state, id, update) {\n  const substate = state[getMutationCacheKey(id)];\n  if (substate) {\n    update(substate);\n  }\n}\nvar initialState = {};\nfunction buildSlice({\n  reducerPath,\n  queryThunk,\n  mutationThunk,\n  context: {\n    endpointDefinitions: definitions,\n    apiUid,\n    extractRehydrationInfo,\n    hasRehydrationInfo\n  },\n  assertTagType,\n  config\n}) {\n  const resetApiState = createAction(`${reducerPath}/resetApiState`);\n  const querySlice = createSlice({\n    name: `${reducerPath}/queries`,\n    initialState,\n    reducers: {\n      removeQueryResult: {\n        reducer(draft, {\n          payload: {\n            queryCacheKey\n          }\n        }) {\n          delete draft[queryCacheKey];\n        },\n        prepare: prepareAutoBatched()\n      },\n      queryResultPatched: {\n        reducer(draft, {\n          payload: {\n            queryCacheKey,\n            patches\n          }\n        }) {\n          updateQuerySubstateIfExists(draft, queryCacheKey, (substate) => {\n            substate.data = applyPatches(substate.data, patches.concat());\n          });\n        },\n        prepare: prepareAutoBatched()\n      }\n    },\n    extraReducers(builder) {\n      builder.addCase(queryThunk.pending, (draft, {\n        meta,\n        meta: {\n          arg\n        }\n      }) => {\n        const upserting = isUpsertQuery(arg);\n        draft[arg.queryCacheKey] ??= {\n          status: \"uninitialized\" /* uninitialized */,\n          endpointName: arg.endpointName\n        };\n        updateQuerySubstateIfExists(draft, arg.queryCacheKey, (substate) => {\n          substate.status = \"pending\" /* pending */;\n          substate.requestId = upserting && substate.requestId ? (\n            // for `upsertQuery` **updates**, keep the current `requestId`\n            substate.requestId\n          ) : (\n            // for normal queries or `upsertQuery` **inserts** always update the `requestId`\n            meta.requestId\n          );\n          if (arg.originalArgs !== void 0) {\n            substate.originalArgs = arg.originalArgs;\n          }\n          substate.startedTimeStamp = meta.startedTimeStamp;\n        });\n      }).addCase(queryThunk.fulfilled, (draft, {\n        meta,\n        payload\n      }) => {\n        updateQuerySubstateIfExists(draft, meta.arg.queryCacheKey, (substate) => {\n          if (substate.requestId !== meta.requestId && !isUpsertQuery(meta.arg))\n            return;\n          const {\n            merge\n          } = definitions[meta.arg.endpointName];\n          substate.status = \"fulfilled\" /* fulfilled */;\n          if (merge) {\n            if (substate.data !== void 0) {\n              const {\n                fulfilledTimeStamp,\n                arg,\n                baseQueryMeta,\n                requestId\n              } = meta;\n              let newData = createNextState(substate.data, (draftSubstateData) => {\n                return merge(draftSubstateData, payload, {\n                  arg: arg.originalArgs,\n                  baseQueryMeta,\n                  fulfilledTimeStamp,\n                  requestId\n                });\n              });\n              substate.data = newData;\n            } else {\n              substate.data = payload;\n            }\n          } else {\n            substate.data = definitions[meta.arg.endpointName].structuralSharing ?? true ? copyWithStructuralSharing(isDraft(substate.data) ? original(substate.data) : substate.data, payload) : payload;\n          }\n          delete substate.error;\n          substate.fulfilledTimeStamp = meta.fulfilledTimeStamp;\n        });\n      }).addCase(queryThunk.rejected, (draft, {\n        meta: {\n          condition,\n          arg,\n          requestId\n        },\n        error,\n        payload\n      }) => {\n        updateQuerySubstateIfExists(draft, arg.queryCacheKey, (substate) => {\n          if (condition) {\n          } else {\n            if (substate.requestId !== requestId)\n              return;\n            substate.status = \"rejected\" /* rejected */;\n            substate.error = payload ?? error;\n          }\n        });\n      }).addMatcher(hasRehydrationInfo, (draft, action) => {\n        const {\n          queries\n        } = extractRehydrationInfo(action);\n        for (const [key, entry] of Object.entries(queries)) {\n          if (\n            // do not rehydrate entries that were currently in flight.\n            entry?.status === \"fulfilled\" /* fulfilled */ || entry?.status === \"rejected\" /* rejected */\n          ) {\n            draft[key] = entry;\n          }\n        }\n      });\n    }\n  });\n  const mutationSlice = createSlice({\n    name: `${reducerPath}/mutations`,\n    initialState,\n    reducers: {\n      removeMutationResult: {\n        reducer(draft, {\n          payload\n        }) {\n          const cacheKey = getMutationCacheKey(payload);\n          if (cacheKey in draft) {\n            delete draft[cacheKey];\n          }\n        },\n        prepare: prepareAutoBatched()\n      }\n    },\n    extraReducers(builder) {\n      builder.addCase(mutationThunk.pending, (draft, {\n        meta,\n        meta: {\n          requestId,\n          arg,\n          startedTimeStamp\n        }\n      }) => {\n        if (!arg.track)\n          return;\n        draft[getMutationCacheKey(meta)] = {\n          requestId,\n          status: \"pending\" /* pending */,\n          endpointName: arg.endpointName,\n          startedTimeStamp\n        };\n      }).addCase(mutationThunk.fulfilled, (draft, {\n        payload,\n        meta\n      }) => {\n        if (!meta.arg.track)\n          return;\n        updateMutationSubstateIfExists(draft, meta, (substate) => {\n          if (substate.requestId !== meta.requestId)\n            return;\n          substate.status = \"fulfilled\" /* fulfilled */;\n          substate.data = payload;\n          substate.fulfilledTimeStamp = meta.fulfilledTimeStamp;\n        });\n      }).addCase(mutationThunk.rejected, (draft, {\n        payload,\n        error,\n        meta\n      }) => {\n        if (!meta.arg.track)\n          return;\n        updateMutationSubstateIfExists(draft, meta, (substate) => {\n          if (substate.requestId !== meta.requestId)\n            return;\n          substate.status = \"rejected\" /* rejected */;\n          substate.error = payload ?? error;\n        });\n      }).addMatcher(hasRehydrationInfo, (draft, action) => {\n        const {\n          mutations\n        } = extractRehydrationInfo(action);\n        for (const [key, entry] of Object.entries(mutations)) {\n          if (\n            // do not rehydrate entries that were currently in flight.\n            (entry?.status === \"fulfilled\" /* fulfilled */ || entry?.status === \"rejected\" /* rejected */) && // only rehydrate endpoints that were persisted using a `fixedCacheKey`\n            key !== entry?.requestId\n          ) {\n            draft[key] = entry;\n          }\n        }\n      });\n    }\n  });\n  const invalidationSlice = createSlice({\n    name: `${reducerPath}/invalidation`,\n    initialState,\n    reducers: {\n      updateProvidedBy: {\n        reducer(draft, action) {\n          const {\n            queryCacheKey,\n            providedTags\n          } = action.payload;\n          for (const tagTypeSubscriptions of Object.values(draft)) {\n            for (const idSubscriptions of Object.values(tagTypeSubscriptions)) {\n              const foundAt = idSubscriptions.indexOf(queryCacheKey);\n              if (foundAt !== -1) {\n                idSubscriptions.splice(foundAt, 1);\n              }\n            }\n          }\n          for (const {\n            type,\n            id\n          } of providedTags) {\n            const subscribedQueries = (draft[type] ??= {})[id || \"__internal_without_id\"] ??= [];\n            const alreadySubscribed = subscribedQueries.includes(queryCacheKey);\n            if (!alreadySubscribed) {\n              subscribedQueries.push(queryCacheKey);\n            }\n          }\n        },\n        prepare: prepareAutoBatched()\n      }\n    },\n    extraReducers(builder) {\n      builder.addCase(querySlice.actions.removeQueryResult, (draft, {\n        payload: {\n          queryCacheKey\n        }\n      }) => {\n        for (const tagTypeSubscriptions of Object.values(draft)) {\n          for (const idSubscriptions of Object.values(tagTypeSubscriptions)) {\n            const foundAt = idSubscriptions.indexOf(queryCacheKey);\n            if (foundAt !== -1) {\n              idSubscriptions.splice(foundAt, 1);\n            }\n          }\n        }\n      }).addMatcher(hasRehydrationInfo, (draft, action) => {\n        const {\n          provided\n        } = extractRehydrationInfo(action);\n        for (const [type, incomingTags] of Object.entries(provided)) {\n          for (const [id, cacheKeys] of Object.entries(incomingTags)) {\n            const subscribedQueries = (draft[type] ??= {})[id || \"__internal_without_id\"] ??= [];\n            for (const queryCacheKey of cacheKeys) {\n              const alreadySubscribed = subscribedQueries.includes(queryCacheKey);\n              if (!alreadySubscribed) {\n                subscribedQueries.push(queryCacheKey);\n              }\n            }\n          }\n        }\n      }).addMatcher(isAnyOf(isFulfilled(queryThunk), isRejectedWithValue(queryThunk)), (draft, action) => {\n        const providedTags = calculateProvidedByThunk(action, \"providesTags\", definitions, assertTagType);\n        const {\n          queryCacheKey\n        } = action.meta.arg;\n        invalidationSlice.caseReducers.updateProvidedBy(draft, invalidationSlice.actions.updateProvidedBy({\n          queryCacheKey,\n          providedTags\n        }));\n      });\n    }\n  });\n  const subscriptionSlice = createSlice({\n    name: `${reducerPath}/subscriptions`,\n    initialState,\n    reducers: {\n      updateSubscriptionOptions(d, a) {\n      },\n      unsubscribeQueryResult(d, a) {\n      },\n      internal_getRTKQSubscriptions() {\n      }\n    }\n  });\n  const internalSubscriptionsSlice = createSlice({\n    name: `${reducerPath}/internalSubscriptions`,\n    initialState,\n    reducers: {\n      subscriptionsUpdated: {\n        reducer(state, action) {\n          return applyPatches(state, action.payload);\n        },\n        prepare: prepareAutoBatched()\n      }\n    }\n  });\n  const configSlice = createSlice({\n    name: `${reducerPath}/config`,\n    initialState: {\n      online: isOnline(),\n      focused: isDocumentVisible(),\n      middlewareRegistered: false,\n      ...config\n    },\n    reducers: {\n      middlewareRegistered(state, {\n        payload\n      }) {\n        state.middlewareRegistered = state.middlewareRegistered === \"conflict\" || apiUid !== payload ? \"conflict\" : true;\n      }\n    },\n    extraReducers: (builder) => {\n      builder.addCase(onOnline, (state) => {\n        state.online = true;\n      }).addCase(onOffline, (state) => {\n        state.online = false;\n      }).addCase(onFocus, (state) => {\n        state.focused = true;\n      }).addCase(onFocusLost, (state) => {\n        state.focused = false;\n      }).addMatcher(hasRehydrationInfo, (draft) => ({\n        ...draft\n      }));\n    }\n  });\n  const combinedReducer = combineReducers({\n    queries: querySlice.reducer,\n    mutations: mutationSlice.reducer,\n    provided: invalidationSlice.reducer,\n    subscriptions: internalSubscriptionsSlice.reducer,\n    config: configSlice.reducer\n  });\n  const reducer = (state, action) => combinedReducer(resetApiState.match(action) ? void 0 : state, action);\n  const actions = {\n    ...configSlice.actions,\n    ...querySlice.actions,\n    ...subscriptionSlice.actions,\n    ...internalSubscriptionsSlice.actions,\n    ...mutationSlice.actions,\n    ...invalidationSlice.actions,\n    resetApiState\n  };\n  return {\n    reducer,\n    actions\n  };\n}\n\n// src/query/core/buildSelectors.ts\nvar skipToken = /* @__PURE__ */ Symbol.for(\"RTKQ/skipToken\");\nvar initialSubState = {\n  status: \"uninitialized\" /* uninitialized */\n};\nvar defaultQuerySubState = /* @__PURE__ */ createNextState(initialSubState, () => {\n});\nvar defaultMutationSubState = /* @__PURE__ */ createNextState(initialSubState, () => {\n});\nfunction buildSelectors({\n  serializeQueryArgs,\n  reducerPath,\n  createSelector: createSelector2\n}) {\n  const selectSkippedQuery = (state) => defaultQuerySubState;\n  const selectSkippedMutation = (state) => defaultMutationSubState;\n  return {\n    buildQuerySelector,\n    buildMutationSelector,\n    selectInvalidatedBy,\n    selectCachedArgsForQuery\n  };\n  function withRequestFlags(substate) {\n    return {\n      ...substate,\n      ...getRequestStatusFlags(substate.status)\n    };\n  }\n  function selectInternalState(rootState) {\n    const state = rootState[reducerPath];\n    if (process.env.NODE_ENV !== \"production\") {\n      if (!state) {\n        if (selectInternalState.triggered)\n          return state;\n        selectInternalState.triggered = true;\n        console.error(`Error: No data found at \\`state.${reducerPath}\\`. Did you forget to add the reducer to the store?`);\n      }\n    }\n    return state;\n  }\n  function buildQuerySelector(endpointName, endpointDefinition) {\n    return (queryArgs) => {\n      const serializedArgs = serializeQueryArgs({\n        queryArgs,\n        endpointDefinition,\n        endpointName\n      });\n      const selectQuerySubstate = (state) => selectInternalState(state)?.queries?.[serializedArgs] ?? defaultQuerySubState;\n      const finalSelectQuerySubState = queryArgs === skipToken ? selectSkippedQuery : selectQuerySubstate;\n      return createSelector2(finalSelectQuerySubState, withRequestFlags);\n    };\n  }\n  function buildMutationSelector() {\n    return (id) => {\n      let mutationId;\n      if (typeof id === \"object\") {\n        mutationId = getMutationCacheKey(id) ?? skipToken;\n      } else {\n        mutationId = id;\n      }\n      const selectMutationSubstate = (state) => selectInternalState(state)?.mutations?.[mutationId] ?? defaultMutationSubState;\n      const finalSelectMutationSubstate = mutationId === skipToken ? selectSkippedMutation : selectMutationSubstate;\n      return createSelector2(finalSelectMutationSubstate, withRequestFlags);\n    };\n  }\n  function selectInvalidatedBy(state, tags) {\n    const apiState = state[reducerPath];\n    const toInvalidate = /* @__PURE__ */ new Set();\n    for (const tag of tags.map(expandTagDescription)) {\n      const provided = apiState.provided[tag.type];\n      if (!provided) {\n        continue;\n      }\n      let invalidateSubscriptions = (tag.id !== void 0 ? (\n        // id given: invalidate all queries that provide this type & id\n        provided[tag.id]\n      ) : (\n        // no id: invalidate all queries that provide this type\n        flatten(Object.values(provided))\n      )) ?? [];\n      for (const invalidate of invalidateSubscriptions) {\n        toInvalidate.add(invalidate);\n      }\n    }\n    return flatten(Array.from(toInvalidate.values()).map((queryCacheKey) => {\n      const querySubState = apiState.queries[queryCacheKey];\n      return querySubState ? [{\n        queryCacheKey,\n        endpointName: querySubState.endpointName,\n        originalArgs: querySubState.originalArgs\n      }] : [];\n    }));\n  }\n  function selectCachedArgsForQuery(state, queryName) {\n    return Object.values(state[reducerPath].queries).filter((entry) => entry?.endpointName === queryName && entry.status !== \"uninitialized\" /* uninitialized */).map((entry) => entry.originalArgs);\n  }\n}\n\n// src/query/createApi.ts\nimport { formatProdErrorMessage as _formatProdErrorMessage2 } from \"@reduxjs/toolkit\";\n\n// src/query/defaultSerializeQueryArgs.ts\nvar cache = WeakMap ? /* @__PURE__ */ new WeakMap() : void 0;\nvar defaultSerializeQueryArgs = ({\n  endpointName,\n  queryArgs\n}) => {\n  let serialized = \"\";\n  const cached = cache?.get(queryArgs);\n  if (typeof cached === \"string\") {\n    serialized = cached;\n  } else {\n    const stringified = JSON.stringify(queryArgs, (key, value) => isPlainObject(value) ? Object.keys(value).sort().reduce((acc, key2) => {\n      acc[key2] = value[key2];\n      return acc;\n    }, {}) : value);\n    if (isPlainObject(queryArgs)) {\n      cache?.set(queryArgs, stringified);\n    }\n    serialized = stringified;\n  }\n  return `${endpointName}(${serialized})`;\n};\n\n// src/query/createApi.ts\nimport { weakMapMemoize } from \"reselect\";\nfunction buildCreateApi(...modules) {\n  return function baseCreateApi(options) {\n    const extractRehydrationInfo = weakMapMemoize((action) => options.extractRehydrationInfo?.(action, {\n      reducerPath: options.reducerPath ?? \"api\"\n    }));\n    const optionsWithDefaults = {\n      reducerPath: \"api\",\n      keepUnusedDataFor: 60,\n      refetchOnMountOrArgChange: false,\n      refetchOnFocus: false,\n      refetchOnReconnect: false,\n      invalidationBehavior: \"delayed\",\n      ...options,\n      extractRehydrationInfo,\n      serializeQueryArgs(queryArgsApi) {\n        let finalSerializeQueryArgs = defaultSerializeQueryArgs;\n        if (\"serializeQueryArgs\" in queryArgsApi.endpointDefinition) {\n          const endpointSQA = queryArgsApi.endpointDefinition.serializeQueryArgs;\n          finalSerializeQueryArgs = (queryArgsApi2) => {\n            const initialResult = endpointSQA(queryArgsApi2);\n            if (typeof initialResult === \"string\") {\n              return initialResult;\n            } else {\n              return defaultSerializeQueryArgs({\n                ...queryArgsApi2,\n                queryArgs: initialResult\n              });\n            }\n          };\n        } else if (options.serializeQueryArgs) {\n          finalSerializeQueryArgs = options.serializeQueryArgs;\n        }\n        return finalSerializeQueryArgs(queryArgsApi);\n      },\n      tagTypes: [...options.tagTypes || []]\n    };\n    const context = {\n      endpointDefinitions: {},\n      batch(fn) {\n        fn();\n      },\n      apiUid: nanoid(),\n      extractRehydrationInfo,\n      hasRehydrationInfo: weakMapMemoize((action) => extractRehydrationInfo(action) != null)\n    };\n    const api = {\n      injectEndpoints,\n      enhanceEndpoints({\n        addTagTypes,\n        endpoints\n      }) {\n        if (addTagTypes) {\n          for (const eT of addTagTypes) {\n            if (!optionsWithDefaults.tagTypes.includes(eT)) {\n              ;\n              optionsWithDefaults.tagTypes.push(eT);\n            }\n          }\n        }\n        if (endpoints) {\n          for (const [endpointName, partialDefinition] of Object.entries(endpoints)) {\n            if (typeof partialDefinition === \"function\") {\n              partialDefinition(context.endpointDefinitions[endpointName]);\n            } else {\n              Object.assign(context.endpointDefinitions[endpointName] || {}, partialDefinition);\n            }\n          }\n        }\n        return api;\n      }\n    };\n    const initializedModules = modules.map((m) => m.init(api, optionsWithDefaults, context));\n    function injectEndpoints(inject) {\n      const evaluatedEndpoints = inject.endpoints({\n        query: (x) => ({\n          ...x,\n          type: \"query\" /* query */\n        }),\n        mutation: (x) => ({\n          ...x,\n          type: \"mutation\" /* mutation */\n        })\n      });\n      for (const [endpointName, definition] of Object.entries(evaluatedEndpoints)) {\n        if (inject.overrideExisting !== true && endpointName in context.endpointDefinitions) {\n          if (inject.overrideExisting === \"throw\") {\n            throw new Error(process.env.NODE_ENV === \"production\" ? _formatProdErrorMessage2(39) : `called \\`injectEndpoints\\` to override already-existing endpointName ${endpointName} without specifying \\`overrideExisting: true\\``);\n          } else if (typeof process !== \"undefined\" && process.env.NODE_ENV === \"development\") {\n            console.error(`called \\`injectEndpoints\\` to override already-existing endpointName ${endpointName} without specifying \\`overrideExisting: true\\``);\n          }\n          continue;\n        }\n        context.endpointDefinitions[endpointName] = definition;\n        for (const m of initializedModules) {\n          m.injectEndpoint(endpointName, definition);\n        }\n      }\n      return api;\n    }\n    return api.injectEndpoints({\n      endpoints: options.endpoints\n    });\n  };\n}\n\n// src/query/fakeBaseQuery.ts\nimport { formatProdErrorMessage as _formatProdErrorMessage3 } from \"@reduxjs/toolkit\";\nfunction fakeBaseQuery() {\n  return function() {\n    throw new Error(process.env.NODE_ENV === \"production\" ? _formatProdErrorMessage3(33) : \"When using `fakeBaseQuery`, all queries & mutations must use the `queryFn` definition syntax.\");\n  };\n}\n\n// src/query/core/buildMiddleware/cacheCollection.ts\nimport { isAnyOf as isAnyOf2 } from \"@reduxjs/toolkit\";\nfunction isObjectEmpty(obj) {\n  for (let k in obj) {\n    return false;\n  }\n  return true;\n}\nvar THIRTY_TWO_BIT_MAX_TIMER_SECONDS = 2147483647 / 1e3 - 1;\nvar buildCacheCollectionHandler = ({\n  reducerPath,\n  api,\n  queryThunk,\n  context,\n  internalState\n}) => {\n  const {\n    removeQueryResult,\n    unsubscribeQueryResult\n  } = api.internalActions;\n  const canTriggerUnsubscribe = isAnyOf2(unsubscribeQueryResult.match, queryThunk.fulfilled, queryThunk.rejected);\n  function anySubscriptionsRemainingForKey(queryCacheKey) {\n    const subscriptions = internalState.currentSubscriptions[queryCacheKey];\n    return !!subscriptions && !isObjectEmpty(subscriptions);\n  }\n  const currentRemovalTimeouts = {};\n  const handler = (action, mwApi, internalState2) => {\n    if (canTriggerUnsubscribe(action)) {\n      const state = mwApi.getState()[reducerPath];\n      const {\n        queryCacheKey\n      } = unsubscribeQueryResult.match(action) ? action.payload : action.meta.arg;\n      handleUnsubscribe(queryCacheKey, state.queries[queryCacheKey]?.endpointName, mwApi, state.config);\n    }\n    if (api.util.resetApiState.match(action)) {\n      for (const [key, timeout] of Object.entries(currentRemovalTimeouts)) {\n        if (timeout)\n          clearTimeout(timeout);\n        delete currentRemovalTimeouts[key];\n      }\n    }\n    if (context.hasRehydrationInfo(action)) {\n      const state = mwApi.getState()[reducerPath];\n      const {\n        queries\n      } = context.extractRehydrationInfo(action);\n      for (const [queryCacheKey, queryState] of Object.entries(queries)) {\n        handleUnsubscribe(queryCacheKey, queryState?.endpointName, mwApi, state.config);\n      }\n    }\n  };\n  function handleUnsubscribe(queryCacheKey, endpointName, api2, config) {\n    const endpointDefinition = context.endpointDefinitions[endpointName];\n    const keepUnusedDataFor = endpointDefinition?.keepUnusedDataFor ?? config.keepUnusedDataFor;\n    if (keepUnusedDataFor === Infinity) {\n      return;\n    }\n    const finalKeepUnusedDataFor = Math.max(0, Math.min(keepUnusedDataFor, THIRTY_TWO_BIT_MAX_TIMER_SECONDS));\n    if (!anySubscriptionsRemainingForKey(queryCacheKey)) {\n      const currentTimeout = currentRemovalTimeouts[queryCacheKey];\n      if (currentTimeout) {\n        clearTimeout(currentTimeout);\n      }\n      currentRemovalTimeouts[queryCacheKey] = setTimeout(() => {\n        if (!anySubscriptionsRemainingForKey(queryCacheKey)) {\n          api2.dispatch(removeQueryResult({\n            queryCacheKey\n          }));\n        }\n        delete currentRemovalTimeouts[queryCacheKey];\n      }, finalKeepUnusedDataFor * 1e3);\n    }\n  }\n  return handler;\n};\n\n// src/query/core/buildMiddleware/invalidationByTags.ts\nvar buildInvalidationByTagsHandler = ({\n  reducerPath,\n  context,\n  context: {\n    endpointDefinitions\n  },\n  mutationThunk,\n  queryThunk,\n  api,\n  assertTagType,\n  refetchQuery,\n  internalState\n}) => {\n  const {\n    removeQueryResult\n  } = api.internalActions;\n  const isThunkActionWithTags = isAnyOf(isFulfilled(mutationThunk), isRejectedWithValue(mutationThunk));\n  const isQueryEnd = isAnyOf(isFulfilled(mutationThunk, queryThunk), isRejected(mutationThunk, queryThunk));\n  let pendingTagInvalidations = [];\n  const handler = (action, mwApi) => {\n    if (isThunkActionWithTags(action)) {\n      invalidateTags(calculateProvidedByThunk(action, \"invalidatesTags\", endpointDefinitions, assertTagType), mwApi);\n    } else if (isQueryEnd(action)) {\n      invalidateTags([], mwApi);\n    } else if (api.util.invalidateTags.match(action)) {\n      invalidateTags(calculateProvidedBy(action.payload, void 0, void 0, void 0, void 0, assertTagType), mwApi);\n    }\n  };\n  function hasPendingRequests(state) {\n    for (const key in state.queries) {\n      if (state.queries[key]?.status === \"pending\" /* pending */)\n        return true;\n    }\n    for (const key in state.mutations) {\n      if (state.mutations[key]?.status === \"pending\" /* pending */)\n        return true;\n    }\n    return false;\n  }\n  function invalidateTags(newTags, mwApi) {\n    const rootState = mwApi.getState();\n    const state = rootState[reducerPath];\n    pendingTagInvalidations.push(...newTags);\n    if (state.config.invalidationBehavior === \"delayed\" && hasPendingRequests(state)) {\n      return;\n    }\n    const tags = pendingTagInvalidations;\n    pendingTagInvalidations = [];\n    if (tags.length === 0)\n      return;\n    const toInvalidate = api.util.selectInvalidatedBy(rootState, tags);\n    context.batch(() => {\n      const valuesArray = Array.from(toInvalidate.values());\n      for (const {\n        queryCacheKey\n      } of valuesArray) {\n        const querySubState = state.queries[queryCacheKey];\n        const subscriptionSubState = internalState.currentSubscriptions[queryCacheKey] ?? {};\n        if (querySubState) {\n          if (countObjectKeys(subscriptionSubState) === 0) {\n            mwApi.dispatch(removeQueryResult({\n              queryCacheKey\n            }));\n          } else if (querySubState.status !== \"uninitialized\" /* uninitialized */) {\n            mwApi.dispatch(refetchQuery(querySubState, queryCacheKey));\n          }\n        }\n      }\n    });\n  }\n  return handler;\n};\n\n// src/query/core/buildMiddleware/polling.ts\nvar buildPollingHandler = ({\n  reducerPath,\n  queryThunk,\n  api,\n  refetchQuery,\n  internalState\n}) => {\n  const currentPolls = {};\n  const handler = (action, mwApi) => {\n    if (api.internalActions.updateSubscriptionOptions.match(action) || api.internalActions.unsubscribeQueryResult.match(action)) {\n      updatePollingInterval(action.payload, mwApi);\n    }\n    if (queryThunk.pending.match(action) || queryThunk.rejected.match(action) && action.meta.condition) {\n      updatePollingInterval(action.meta.arg, mwApi);\n    }\n    if (queryThunk.fulfilled.match(action) || queryThunk.rejected.match(action) && !action.meta.condition) {\n      startNextPoll(action.meta.arg, mwApi);\n    }\n    if (api.util.resetApiState.match(action)) {\n      clearPolls();\n    }\n  };\n  function startNextPoll({\n    queryCacheKey\n  }, api2) {\n    const state = api2.getState()[reducerPath];\n    const querySubState = state.queries[queryCacheKey];\n    const subscriptions = internalState.currentSubscriptions[queryCacheKey];\n    if (!querySubState || querySubState.status === \"uninitialized\" /* uninitialized */)\n      return;\n    const {\n      lowestPollingInterval,\n      skipPollingIfUnfocused\n    } = findLowestPollingInterval(subscriptions);\n    if (!Number.isFinite(lowestPollingInterval))\n      return;\n    const currentPoll = currentPolls[queryCacheKey];\n    if (currentPoll?.timeout) {\n      clearTimeout(currentPoll.timeout);\n      currentPoll.timeout = void 0;\n    }\n    const nextPollTimestamp = Date.now() + lowestPollingInterval;\n    currentPolls[queryCacheKey] = {\n      nextPollTimestamp,\n      pollingInterval: lowestPollingInterval,\n      timeout: setTimeout(() => {\n        if (state.config.focused || !skipPollingIfUnfocused) {\n          api2.dispatch(refetchQuery(querySubState, queryCacheKey));\n        }\n        startNextPoll({\n          queryCacheKey\n        }, api2);\n      }, lowestPollingInterval)\n    };\n  }\n  function updatePollingInterval({\n    queryCacheKey\n  }, api2) {\n    const state = api2.getState()[reducerPath];\n    const querySubState = state.queries[queryCacheKey];\n    const subscriptions = internalState.currentSubscriptions[queryCacheKey];\n    if (!querySubState || querySubState.status === \"uninitialized\" /* uninitialized */) {\n      return;\n    }\n    const {\n      lowestPollingInterval\n    } = findLowestPollingInterval(subscriptions);\n    if (!Number.isFinite(lowestPollingInterval)) {\n      cleanupPollForKey(queryCacheKey);\n      return;\n    }\n    const currentPoll = currentPolls[queryCacheKey];\n    const nextPollTimestamp = Date.now() + lowestPollingInterval;\n    if (!currentPoll || nextPollTimestamp < currentPoll.nextPollTimestamp) {\n      startNextPoll({\n        queryCacheKey\n      }, api2);\n    }\n  }\n  function cleanupPollForKey(key) {\n    const existingPoll = currentPolls[key];\n    if (existingPoll?.timeout) {\n      clearTimeout(existingPoll.timeout);\n    }\n    delete currentPolls[key];\n  }\n  function clearPolls() {\n    for (const key of Object.keys(currentPolls)) {\n      cleanupPollForKey(key);\n    }\n  }\n  function findLowestPollingInterval(subscribers = {}) {\n    let skipPollingIfUnfocused = false;\n    let lowestPollingInterval = Number.POSITIVE_INFINITY;\n    for (let key in subscribers) {\n      if (!!subscribers[key].pollingInterval) {\n        lowestPollingInterval = Math.min(subscribers[key].pollingInterval, lowestPollingInterval);\n        skipPollingIfUnfocused = subscribers[key].skipPollingIfUnfocused || skipPollingIfUnfocused;\n      }\n    }\n    return {\n      lowestPollingInterval,\n      skipPollingIfUnfocused\n    };\n  }\n  return handler;\n};\n\n// src/query/core/buildMiddleware/windowEventHandling.ts\nvar buildWindowEventHandler = ({\n  reducerPath,\n  context,\n  api,\n  refetchQuery,\n  internalState\n}) => {\n  const {\n    removeQueryResult\n  } = api.internalActions;\n  const handler = (action, mwApi) => {\n    if (onFocus.match(action)) {\n      refetchValidQueries(mwApi, \"refetchOnFocus\");\n    }\n    if (onOnline.match(action)) {\n      refetchValidQueries(mwApi, \"refetchOnReconnect\");\n    }\n  };\n  function refetchValidQueries(api2, type) {\n    const state = api2.getState()[reducerPath];\n    const queries = state.queries;\n    const subscriptions = internalState.currentSubscriptions;\n    context.batch(() => {\n      for (const queryCacheKey of Object.keys(subscriptions)) {\n        const querySubState = queries[queryCacheKey];\n        const subscriptionSubState = subscriptions[queryCacheKey];\n        if (!subscriptionSubState || !querySubState)\n          continue;\n        const shouldRefetch = Object.values(subscriptionSubState).some((sub) => sub[type] === true) || Object.values(subscriptionSubState).every((sub) => sub[type] === void 0) && state.config[type];\n        if (shouldRefetch) {\n          if (countObjectKeys(subscriptionSubState) === 0) {\n            api2.dispatch(removeQueryResult({\n              queryCacheKey\n            }));\n          } else if (querySubState.status !== \"uninitialized\" /* uninitialized */) {\n            api2.dispatch(refetchQuery(querySubState, queryCacheKey));\n          }\n        }\n      }\n    });\n  }\n  return handler;\n};\n\n// src/query/core/buildMiddleware/cacheLifecycle.ts\nvar neverResolvedError = new Error(\"Promise never resolved before cacheEntryRemoved.\");\nvar buildCacheLifecycleHandler = ({\n  api,\n  reducerPath,\n  context,\n  queryThunk,\n  mutationThunk,\n  internalState\n}) => {\n  const isQueryThunk = isAsyncThunkAction(queryThunk);\n  const isMutationThunk = isAsyncThunkAction(mutationThunk);\n  const isFulfilledThunk = isFulfilled(queryThunk, mutationThunk);\n  const lifecycleMap = {};\n  const handler = (action, mwApi, stateBefore) => {\n    const cacheKey = getCacheKey(action);\n    if (queryThunk.pending.match(action)) {\n      const oldState = stateBefore[reducerPath].queries[cacheKey];\n      const state = mwApi.getState()[reducerPath].queries[cacheKey];\n      if (!oldState && state) {\n        handleNewKey(action.meta.arg.endpointName, action.meta.arg.originalArgs, cacheKey, mwApi, action.meta.requestId);\n      }\n    } else if (mutationThunk.pending.match(action)) {\n      const state = mwApi.getState()[reducerPath].mutations[cacheKey];\n      if (state) {\n        handleNewKey(action.meta.arg.endpointName, action.meta.arg.originalArgs, cacheKey, mwApi, action.meta.requestId);\n      }\n    } else if (isFulfilledThunk(action)) {\n      const lifecycle = lifecycleMap[cacheKey];\n      if (lifecycle?.valueResolved) {\n        lifecycle.valueResolved({\n          data: action.payload,\n          meta: action.meta.baseQueryMeta\n        });\n        delete lifecycle.valueResolved;\n      }\n    } else if (api.internalActions.removeQueryResult.match(action) || api.internalActions.removeMutationResult.match(action)) {\n      const lifecycle = lifecycleMap[cacheKey];\n      if (lifecycle) {\n        delete lifecycleMap[cacheKey];\n        lifecycle.cacheEntryRemoved();\n      }\n    } else if (api.util.resetApiState.match(action)) {\n      for (const [cacheKey2, lifecycle] of Object.entries(lifecycleMap)) {\n        delete lifecycleMap[cacheKey2];\n        lifecycle.cacheEntryRemoved();\n      }\n    }\n  };\n  function getCacheKey(action) {\n    if (isQueryThunk(action))\n      return action.meta.arg.queryCacheKey;\n    if (isMutationThunk(action)) {\n      return action.meta.arg.fixedCacheKey ?? action.meta.requestId;\n    }\n    if (api.internalActions.removeQueryResult.match(action))\n      return action.payload.queryCacheKey;\n    if (api.internalActions.removeMutationResult.match(action))\n      return getMutationCacheKey(action.payload);\n    return \"\";\n  }\n  function handleNewKey(endpointName, originalArgs, queryCacheKey, mwApi, requestId) {\n    const endpointDefinition = context.endpointDefinitions[endpointName];\n    const onCacheEntryAdded = endpointDefinition?.onCacheEntryAdded;\n    if (!onCacheEntryAdded)\n      return;\n    let lifecycle = {};\n    const cacheEntryRemoved = new Promise((resolve) => {\n      lifecycle.cacheEntryRemoved = resolve;\n    });\n    const cacheDataLoaded = Promise.race([new Promise((resolve) => {\n      lifecycle.valueResolved = resolve;\n    }), cacheEntryRemoved.then(() => {\n      throw neverResolvedError;\n    })]);\n    cacheDataLoaded.catch(() => {\n    });\n    lifecycleMap[queryCacheKey] = lifecycle;\n    const selector = api.endpoints[endpointName].select(endpointDefinition.type === \"query\" /* query */ ? originalArgs : queryCacheKey);\n    const extra = mwApi.dispatch((_, __, extra2) => extra2);\n    const lifecycleApi = {\n      ...mwApi,\n      getCacheEntry: () => selector(mwApi.getState()),\n      requestId,\n      extra,\n      updateCachedData: endpointDefinition.type === \"query\" /* query */ ? (updateRecipe) => mwApi.dispatch(api.util.updateQueryData(endpointName, originalArgs, updateRecipe)) : void 0,\n      cacheDataLoaded,\n      cacheEntryRemoved\n    };\n    const runningHandler = onCacheEntryAdded(originalArgs, lifecycleApi);\n    Promise.resolve(runningHandler).catch((e) => {\n      if (e === neverResolvedError)\n        return;\n      throw e;\n    });\n  }\n  return handler;\n};\n\n// src/query/core/buildMiddleware/queryLifecycle.ts\nvar buildQueryLifecycleHandler = ({\n  api,\n  context,\n  queryThunk,\n  mutationThunk\n}) => {\n  const isPendingThunk = isPending(queryThunk, mutationThunk);\n  const isRejectedThunk = isRejected(queryThunk, mutationThunk);\n  const isFullfilledThunk = isFulfilled(queryThunk, mutationThunk);\n  const lifecycleMap = {};\n  const handler = (action, mwApi) => {\n    if (isPendingThunk(action)) {\n      const {\n        requestId,\n        arg: {\n          endpointName,\n          originalArgs\n        }\n      } = action.meta;\n      const endpointDefinition = context.endpointDefinitions[endpointName];\n      const onQueryStarted = endpointDefinition?.onQueryStarted;\n      if (onQueryStarted) {\n        const lifecycle = {};\n        const queryFulfilled = new Promise((resolve, reject) => {\n          lifecycle.resolve = resolve;\n          lifecycle.reject = reject;\n        });\n        queryFulfilled.catch(() => {\n        });\n        lifecycleMap[requestId] = lifecycle;\n        const selector = api.endpoints[endpointName].select(endpointDefinition.type === \"query\" /* query */ ? originalArgs : requestId);\n        const extra = mwApi.dispatch((_, __, extra2) => extra2);\n        const lifecycleApi = {\n          ...mwApi,\n          getCacheEntry: () => selector(mwApi.getState()),\n          requestId,\n          extra,\n          updateCachedData: endpointDefinition.type === \"query\" /* query */ ? (updateRecipe) => mwApi.dispatch(api.util.updateQueryData(endpointName, originalArgs, updateRecipe)) : void 0,\n          queryFulfilled\n        };\n        onQueryStarted(originalArgs, lifecycleApi);\n      }\n    } else if (isFullfilledThunk(action)) {\n      const {\n        requestId,\n        baseQueryMeta\n      } = action.meta;\n      lifecycleMap[requestId]?.resolve({\n        data: action.payload,\n        meta: baseQueryMeta\n      });\n      delete lifecycleMap[requestId];\n    } else if (isRejectedThunk(action)) {\n      const {\n        requestId,\n        rejectedWithValue,\n        baseQueryMeta\n      } = action.meta;\n      lifecycleMap[requestId]?.reject({\n        error: action.payload ?? action.error,\n        isUnhandledError: !rejectedWithValue,\n        meta: baseQueryMeta\n      });\n      delete lifecycleMap[requestId];\n    }\n  };\n  return handler;\n};\n\n// src/query/core/buildMiddleware/devMiddleware.ts\nvar buildDevCheckHandler = ({\n  api,\n  context: {\n    apiUid\n  },\n  reducerPath\n}) => {\n  return (action, mwApi) => {\n    if (api.util.resetApiState.match(action)) {\n      mwApi.dispatch(api.internalActions.middlewareRegistered(apiUid));\n    }\n    if (typeof process !== \"undefined\" && process.env.NODE_ENV === \"development\") {\n      if (api.internalActions.middlewareRegistered.match(action) && action.payload === apiUid && mwApi.getState()[reducerPath]?.config?.middlewareRegistered === \"conflict\") {\n        console.warn(`There is a mismatch between slice and middleware for the reducerPath \"${reducerPath}\".\nYou can only have one api per reducer path, this will lead to crashes in various situations!${reducerPath === \"api\" ? `\nIf you have multiple apis, you *have* to specify the reducerPath option when using createApi!` : \"\"}`);\n      }\n    }\n  };\n};\n\n// src/query/core/buildMiddleware/batchActions.ts\nimport { produceWithPatches as produceWithPatches2 } from \"immer\";\nvar buildBatchedActionsHandler = ({\n  api,\n  queryThunk,\n  internalState\n}) => {\n  const subscriptionsPrefix = `${api.reducerPath}/subscriptions`;\n  let previousSubscriptions = null;\n  let updateSyncTimer = null;\n  const {\n    updateSubscriptionOptions,\n    unsubscribeQueryResult\n  } = api.internalActions;\n  const actuallyMutateSubscriptions = (mutableState, action) => {\n    if (updateSubscriptionOptions.match(action)) {\n      const {\n        queryCacheKey,\n        requestId,\n        options\n      } = action.payload;\n      if (mutableState?.[queryCacheKey]?.[requestId]) {\n        mutableState[queryCacheKey][requestId] = options;\n      }\n      return true;\n    }\n    if (unsubscribeQueryResult.match(action)) {\n      const {\n        queryCacheKey,\n        requestId\n      } = action.payload;\n      if (mutableState[queryCacheKey]) {\n        delete mutableState[queryCacheKey][requestId];\n      }\n      return true;\n    }\n    if (api.internalActions.removeQueryResult.match(action)) {\n      delete mutableState[action.payload.queryCacheKey];\n      return true;\n    }\n    if (queryThunk.pending.match(action)) {\n      const {\n        meta: {\n          arg,\n          requestId\n        }\n      } = action;\n      const substate = mutableState[arg.queryCacheKey] ??= {};\n      substate[`${requestId}_running`] = {};\n      if (arg.subscribe) {\n        substate[requestId] = arg.subscriptionOptions ?? substate[requestId] ?? {};\n      }\n      return true;\n    }\n    let mutated = false;\n    if (queryThunk.fulfilled.match(action) || queryThunk.rejected.match(action)) {\n      const state = mutableState[action.meta.arg.queryCacheKey] || {};\n      const key = `${action.meta.requestId}_running`;\n      mutated ||= !!state[key];\n      delete state[key];\n    }\n    if (queryThunk.rejected.match(action)) {\n      const {\n        meta: {\n          condition,\n          arg,\n          requestId\n        }\n      } = action;\n      if (condition && arg.subscribe) {\n        const substate = mutableState[arg.queryCacheKey] ??= {};\n        substate[requestId] = arg.subscriptionOptions ?? substate[requestId] ?? {};\n        mutated = true;\n      }\n    }\n    return mutated;\n  };\n  const getSubscriptions = () => internalState.currentSubscriptions;\n  const getSubscriptionCount = (queryCacheKey) => {\n    const subscriptions = getSubscriptions();\n    const subscriptionsForQueryArg = subscriptions[queryCacheKey] ?? {};\n    return countObjectKeys(subscriptionsForQueryArg);\n  };\n  const isRequestSubscribed = (queryCacheKey, requestId) => {\n    const subscriptions = getSubscriptions();\n    return !!subscriptions?.[queryCacheKey]?.[requestId];\n  };\n  const subscriptionSelectors = {\n    getSubscriptions,\n    getSubscriptionCount,\n    isRequestSubscribed\n  };\n  return (action, mwApi) => {\n    if (!previousSubscriptions) {\n      previousSubscriptions = JSON.parse(JSON.stringify(internalState.currentSubscriptions));\n    }\n    if (api.util.resetApiState.match(action)) {\n      previousSubscriptions = internalState.currentSubscriptions = {};\n      updateSyncTimer = null;\n      return [true, false];\n    }\n    if (api.internalActions.internal_getRTKQSubscriptions.match(action)) {\n      return [false, subscriptionSelectors];\n    }\n    const didMutate = actuallyMutateSubscriptions(internalState.currentSubscriptions, action);\n    let actionShouldContinue = true;\n    if (didMutate) {\n      if (!updateSyncTimer) {\n        updateSyncTimer = setTimeout(() => {\n          const newSubscriptions = JSON.parse(JSON.stringify(internalState.currentSubscriptions));\n          const [, patches] = produceWithPatches2(previousSubscriptions, () => newSubscriptions);\n          mwApi.next(api.internalActions.subscriptionsUpdated(patches));\n          previousSubscriptions = newSubscriptions;\n          updateSyncTimer = null;\n        }, 500);\n      }\n      const isSubscriptionSliceAction = typeof action.type == \"string\" && !!action.type.startsWith(subscriptionsPrefix);\n      const isAdditionalSubscriptionAction = queryThunk.rejected.match(action) && action.meta.condition && !!action.meta.arg.subscribe;\n      actionShouldContinue = !isSubscriptionSliceAction && !isAdditionalSubscriptionAction;\n    }\n    return [actionShouldContinue, false];\n  };\n};\n\n// src/query/core/buildMiddleware/index.ts\nfunction buildMiddleware(input) {\n  const {\n    reducerPath,\n    queryThunk,\n    api,\n    context\n  } = input;\n  const {\n    apiUid\n  } = context;\n  const actions = {\n    invalidateTags: createAction(`${reducerPath}/invalidateTags`)\n  };\n  const isThisApiSliceAction = (action) => action.type.startsWith(`${reducerPath}/`);\n  const handlerBuilders = [buildDevCheckHandler, buildCacheCollectionHandler, buildInvalidationByTagsHandler, buildPollingHandler, buildCacheLifecycleHandler, buildQueryLifecycleHandler];\n  const middleware = (mwApi) => {\n    let initialized2 = false;\n    let internalState = {\n      currentSubscriptions: {}\n    };\n    const builderArgs = {\n      ...input,\n      internalState,\n      refetchQuery,\n      isThisApiSliceAction\n    };\n    const handlers = handlerBuilders.map((build) => build(builderArgs));\n    const batchedActionsHandler = buildBatchedActionsHandler(builderArgs);\n    const windowEventsHandler = buildWindowEventHandler(builderArgs);\n    return (next) => {\n      return (action) => {\n        if (!isAction(action)) {\n          return next(action);\n        }\n        if (!initialized2) {\n          initialized2 = true;\n          mwApi.dispatch(api.internalActions.middlewareRegistered(apiUid));\n        }\n        const mwApiWithNext = {\n          ...mwApi,\n          next\n        };\n        const stateBefore = mwApi.getState();\n        const [actionShouldContinue, internalProbeResult] = batchedActionsHandler(action, mwApiWithNext, stateBefore);\n        let res;\n        if (actionShouldContinue) {\n          res = next(action);\n        } else {\n          res = internalProbeResult;\n        }\n        if (!!mwApi.getState()[reducerPath]) {\n          windowEventsHandler(action, mwApiWithNext, stateBefore);\n          if (isThisApiSliceAction(action) || context.hasRehydrationInfo(action)) {\n            for (let handler of handlers) {\n              handler(action, mwApiWithNext, stateBefore);\n            }\n          }\n        }\n        return res;\n      };\n    };\n  };\n  return {\n    middleware,\n    actions\n  };\n  function refetchQuery(querySubState, queryCacheKey, override = {}) {\n    return queryThunk({\n      type: \"query\",\n      endpointName: querySubState.endpointName,\n      originalArgs: querySubState.originalArgs,\n      subscribe: false,\n      forceRefetch: true,\n      queryCacheKey,\n      ...override\n    });\n  }\n}\n\n// src/query/tsHelpers.ts\nfunction assertCast(v) {\n}\nfunction safeAssign(target, ...args) {\n  return Object.assign(target, ...args);\n}\n\n// src/query/core/module.ts\nimport { enablePatches } from \"immer\";\nvar coreModuleName = /* @__PURE__ */ Symbol();\nvar coreModule = ({\n  createSelector: createSelector2 = createSelector\n} = {}) => ({\n  name: coreModuleName,\n  init(api, {\n    baseQuery,\n    tagTypes,\n    reducerPath,\n    serializeQueryArgs,\n    keepUnusedDataFor,\n    refetchOnMountOrArgChange,\n    refetchOnFocus,\n    refetchOnReconnect,\n    invalidationBehavior\n  }, context) {\n    enablePatches();\n    assertCast(serializeQueryArgs);\n    const assertTagType = (tag) => {\n      if (typeof process !== \"undefined\" && process.env.NODE_ENV === \"development\") {\n        if (!tagTypes.includes(tag.type)) {\n          console.error(`Tag type '${tag.type}' was used, but not specified in \\`tagTypes\\`!`);\n        }\n      }\n      return tag;\n    };\n    Object.assign(api, {\n      reducerPath,\n      endpoints: {},\n      internalActions: {\n        onOnline,\n        onOffline,\n        onFocus,\n        onFocusLost\n      },\n      util: {}\n    });\n    const {\n      queryThunk,\n      mutationThunk,\n      patchQueryData,\n      updateQueryData,\n      upsertQueryData,\n      prefetch,\n      buildMatchThunkActions\n    } = buildThunks({\n      baseQuery,\n      reducerPath,\n      context,\n      api,\n      serializeQueryArgs,\n      assertTagType\n    });\n    const {\n      reducer,\n      actions: sliceActions\n    } = buildSlice({\n      context,\n      queryThunk,\n      mutationThunk,\n      reducerPath,\n      assertTagType,\n      config: {\n        refetchOnFocus,\n        refetchOnReconnect,\n        refetchOnMountOrArgChange,\n        keepUnusedDataFor,\n        reducerPath,\n        invalidationBehavior\n      }\n    });\n    safeAssign(api.util, {\n      patchQueryData,\n      updateQueryData,\n      upsertQueryData,\n      prefetch,\n      resetApiState: sliceActions.resetApiState\n    });\n    safeAssign(api.internalActions, sliceActions);\n    const {\n      middleware,\n      actions: middlewareActions\n    } = buildMiddleware({\n      reducerPath,\n      context,\n      queryThunk,\n      mutationThunk,\n      api,\n      assertTagType\n    });\n    safeAssign(api.util, middlewareActions);\n    safeAssign(api, {\n      reducer,\n      middleware\n    });\n    const {\n      buildQuerySelector,\n      buildMutationSelector,\n      selectInvalidatedBy,\n      selectCachedArgsForQuery\n    } = buildSelectors({\n      serializeQueryArgs,\n      reducerPath,\n      createSelector: createSelector2\n    });\n    safeAssign(api.util, {\n      selectInvalidatedBy,\n      selectCachedArgsForQuery\n    });\n    const {\n      buildInitiateQuery,\n      buildInitiateMutation,\n      getRunningMutationThunk,\n      getRunningMutationsThunk,\n      getRunningQueriesThunk,\n      getRunningQueryThunk\n    } = buildInitiate({\n      queryThunk,\n      mutationThunk,\n      api,\n      serializeQueryArgs,\n      context\n    });\n    safeAssign(api.util, {\n      getRunningMutationThunk,\n      getRunningMutationsThunk,\n      getRunningQueryThunk,\n      getRunningQueriesThunk\n    });\n    return {\n      name: coreModuleName,\n      injectEndpoint(endpointName, definition) {\n        const anyApi = api;\n        anyApi.endpoints[endpointName] ??= {};\n        if (isQueryDefinition(definition)) {\n          safeAssign(anyApi.endpoints[endpointName], {\n            name: endpointName,\n            select: buildQuerySelector(endpointName, definition),\n            initiate: buildInitiateQuery(endpointName, definition)\n          }, buildMatchThunkActions(queryThunk, endpointName));\n        } else if (isMutationDefinition(definition)) {\n          safeAssign(anyApi.endpoints[endpointName], {\n            name: endpointName,\n            select: buildMutationSelector(),\n            initiate: buildInitiateMutation(endpointName)\n          }, buildMatchThunkActions(mutationThunk, endpointName));\n        }\n      }\n    };\n  }\n});\n\n// src/query/core/index.ts\nvar createApi = /* @__PURE__ */ buildCreateApi(coreModule());\nexport {\n  QueryStatus,\n  buildCreateApi,\n  copyWithStructuralSharing,\n  coreModule,\n  coreModuleName,\n  createApi,\n  defaultSerializeQueryArgs,\n  fakeBaseQuery,\n  fetchBaseQuery,\n  retry,\n  setupListeners,\n  skipToken\n};\n//# sourceMappingURL=rtk-query.modern.mjs.map",
    "// src/query/react/index.ts\nimport { buildCreateApi, coreModule } from \"@reduxjs/toolkit/query\";\n\n// src/query/react/module.ts\nimport { formatProdErrorMessage as _formatProdErrorMessage3 } from \"@reduxjs/toolkit\";\n\n// src/query/endpointDefinitions.ts\nfunction isQueryDefinition(e) {\n  return e.type === \"query\" /* query */;\n}\nfunction isMutationDefinition(e) {\n  return e.type === \"mutation\" /* mutation */;\n}\n\n// src/query/tsHelpers.ts\nfunction safeAssign(target, ...args) {\n  return Object.assign(target, ...args);\n}\n\n// src/query/utils/capitalize.ts\nfunction capitalize(str) {\n  return str.replace(str[0], str[0].toUpperCase());\n}\n\n// src/query/core/rtkImports.ts\nimport { createAction, createSlice, createSelector, createAsyncThunk, combineReducers, createNextState, isAnyOf, isAllOf, isAction, isPending, isRejected, isFulfilled, isRejectedWithValue, isAsyncThunkAction, prepareAutoBatched, SHOULD_AUTOBATCH, isPlainObject, nanoid } from \"@reduxjs/toolkit\";\n\n// src/query/react/buildHooks.ts\nimport { formatProdErrorMessage as _formatProdErrorMessage2 } from \"@reduxjs/toolkit\";\nimport { formatProdErrorMessage as _formatProdErrorMessage } from \"@reduxjs/toolkit\";\nimport { QueryStatus, skipToken } from \"@reduxjs/toolkit/query\";\nimport { useCallback, useDebugValue, useEffect as useEffect3, useLayoutEffect, useMemo as useMemo2, useRef as useRef3, useState } from \"react\";\nimport { shallowEqual as shallowEqual2 } from \"react-redux\";\n\n// src/query/defaultSerializeQueryArgs.ts\nvar cache = WeakMap ? /* @__PURE__ */ new WeakMap() : void 0;\nvar defaultSerializeQueryArgs = ({\n  endpointName,\n  queryArgs\n}) => {\n  let serialized = \"\";\n  const cached = cache?.get(queryArgs);\n  if (typeof cached === \"string\") {\n    serialized = cached;\n  } else {\n    const stringified = JSON.stringify(queryArgs, (key, value) => isPlainObject(value) ? Object.keys(value).sort().reduce((acc, key2) => {\n      acc[key2] = value[key2];\n      return acc;\n    }, {}) : value);\n    if (isPlainObject(queryArgs)) {\n      cache?.set(queryArgs, stringified);\n    }\n    serialized = stringified;\n  }\n  return `${endpointName}(${serialized})`;\n};\n\n// src/query/react/constants.ts\nvar UNINITIALIZED_VALUE = Symbol();\n\n// src/query/react/useSerializedStableValue.ts\nimport { useEffect, useRef, useMemo } from \"react\";\nfunction useStableQueryArgs(queryArgs, serialize, endpointDefinition, endpointName) {\n  const incoming = useMemo(() => ({\n    queryArgs,\n    serialized: typeof queryArgs == \"object\" ? serialize({\n      queryArgs,\n      endpointDefinition,\n      endpointName\n    }) : queryArgs\n  }), [queryArgs, serialize, endpointDefinition, endpointName]);\n  const cache2 = useRef(incoming);\n  useEffect(() => {\n    if (cache2.current.serialized !== incoming.serialized) {\n      cache2.current = incoming;\n    }\n  }, [incoming]);\n  return cache2.current.serialized === incoming.serialized ? cache2.current.queryArgs : queryArgs;\n}\n\n// src/query/react/useShallowStableValue.ts\nimport { useEffect as useEffect2, useRef as useRef2 } from \"react\";\nimport { shallowEqual } from \"react-redux\";\nfunction useShallowStableValue(value) {\n  const cache2 = useRef2(value);\n  useEffect2(() => {\n    if (!shallowEqual(cache2.current, value)) {\n      cache2.current = value;\n    }\n  }, [value]);\n  return shallowEqual(cache2.current, value) ? cache2.current : value;\n}\n\n// src/query/react/buildHooks.ts\nvar useIsomorphicLayoutEffect = typeof window !== \"undefined\" && !!window.document && !!window.document.createElement ? useLayoutEffect : useEffect3;\nvar noPendingQueryStateSelector = (selected) => {\n  if (selected.isUninitialized) {\n    return {\n      ...selected,\n      isUninitialized: false,\n      isFetching: true,\n      isLoading: selected.data !== void 0 ? false : true,\n      status: QueryStatus.pending\n    };\n  }\n  return selected;\n};\nfunction buildHooks({\n  api,\n  moduleOptions: {\n    batch,\n    hooks: {\n      useDispatch,\n      useSelector,\n      useStore\n    },\n    unstable__sideEffectsInRender,\n    createSelector: createSelector2\n  },\n  serializeQueryArgs,\n  context\n}) {\n  const usePossiblyImmediateEffect = unstable__sideEffectsInRender ? (cb) => cb() : useEffect3;\n  return {\n    buildQueryHooks,\n    buildMutationHook,\n    usePrefetch\n  };\n  function queryStatePreSelector(currentState, lastResult, queryArgs) {\n    if (lastResult?.endpointName && currentState.isUninitialized) {\n      const {\n        endpointName\n      } = lastResult;\n      const endpointDefinition = context.endpointDefinitions[endpointName];\n      if (serializeQueryArgs({\n        queryArgs: lastResult.originalArgs,\n        endpointDefinition,\n        endpointName\n      }) === serializeQueryArgs({\n        queryArgs,\n        endpointDefinition,\n        endpointName\n      }))\n        lastResult = void 0;\n    }\n    let data = currentState.isSuccess ? currentState.data : lastResult?.data;\n    if (data === void 0)\n      data = currentState.data;\n    const hasData = data !== void 0;\n    const isFetching = currentState.isLoading;\n    const isLoading = !hasData && isFetching;\n    const isSuccess = currentState.isSuccess || isFetching && hasData;\n    return {\n      ...currentState,\n      data,\n      currentData: currentState.data,\n      isFetching,\n      isLoading,\n      isSuccess\n    };\n  }\n  function usePrefetch(endpointName, defaultOptions) {\n    const dispatch = useDispatch();\n    const stableDefaultOptions = useShallowStableValue(defaultOptions);\n    return useCallback((arg, options) => dispatch(api.util.prefetch(endpointName, arg, {\n      ...stableDefaultOptions,\n      ...options\n    })), [endpointName, dispatch, stableDefaultOptions]);\n  }\n  function buildQueryHooks(name) {\n    const useQuerySubscription = (arg, {\n      refetchOnReconnect,\n      refetchOnFocus,\n      refetchOnMountOrArgChange,\n      skip = false,\n      pollingInterval = 0,\n      skipPollingIfUnfocused = false\n    } = {}) => {\n      const {\n        initiate\n      } = api.endpoints[name];\n      const dispatch = useDispatch();\n      const subscriptionSelectorsRef = useRef3();\n      if (!subscriptionSelectorsRef.current) {\n        const returnedValue = dispatch(api.internalActions.internal_getRTKQSubscriptions());\n        if (process.env.NODE_ENV !== \"production\") {\n          if (typeof returnedValue !== \"object\" || typeof returnedValue?.type === \"string\") {\n            throw new Error(process.env.NODE_ENV === \"production\" ? _formatProdErrorMessage(37) : `Warning: Middleware for RTK-Query API at reducerPath \"${api.reducerPath}\" has not been added to the store.\n    You must add the middleware for RTK-Query to function correctly!`);\n          }\n        }\n        subscriptionSelectorsRef.current = returnedValue;\n      }\n      const stableArg = useStableQueryArgs(\n        skip ? skipToken : arg,\n        // Even if the user provided a per-endpoint `serializeQueryArgs` with\n        // a consistent return value, _here_ we want to use the default behavior\n        // so we can tell if _anything_ actually changed. Otherwise, we can end up\n        // with a case where the query args did change but the serialization doesn't,\n        // and then we never try to initiate a refetch.\n        defaultSerializeQueryArgs,\n        context.endpointDefinitions[name],\n        name\n      );\n      const stableSubscriptionOptions = useShallowStableValue({\n        refetchOnReconnect,\n        refetchOnFocus,\n        pollingInterval,\n        skipPollingIfUnfocused\n      });\n      const lastRenderHadSubscription = useRef3(false);\n      const promiseRef = useRef3();\n      let {\n        queryCacheKey,\n        requestId\n      } = promiseRef.current || {};\n      let currentRenderHasSubscription = false;\n      if (queryCacheKey && requestId) {\n        currentRenderHasSubscription = subscriptionSelectorsRef.current.isRequestSubscribed(queryCacheKey, requestId);\n      }\n      const subscriptionRemoved = !currentRenderHasSubscription && lastRenderHadSubscription.current;\n      usePossiblyImmediateEffect(() => {\n        lastRenderHadSubscription.current = currentRenderHasSubscription;\n      });\n      usePossiblyImmediateEffect(() => {\n        if (subscriptionRemoved) {\n          promiseRef.current = void 0;\n        }\n      }, [subscriptionRemoved]);\n      usePossiblyImmediateEffect(() => {\n        const lastPromise = promiseRef.current;\n        if (typeof process !== \"undefined\" && process.env.NODE_ENV === \"removeMeOnCompilation\") {\n          console.log(subscriptionRemoved);\n        }\n        if (stableArg === skipToken) {\n          lastPromise?.unsubscribe();\n          promiseRef.current = void 0;\n          return;\n        }\n        const lastSubscriptionOptions = promiseRef.current?.subscriptionOptions;\n        if (!lastPromise || lastPromise.arg !== stableArg) {\n          lastPromise?.unsubscribe();\n          const promise = dispatch(initiate(stableArg, {\n            subscriptionOptions: stableSubscriptionOptions,\n            forceRefetch: refetchOnMountOrArgChange\n          }));\n          promiseRef.current = promise;\n        } else if (stableSubscriptionOptions !== lastSubscriptionOptions) {\n          lastPromise.updateSubscriptionOptions(stableSubscriptionOptions);\n        }\n      }, [dispatch, initiate, refetchOnMountOrArgChange, stableArg, stableSubscriptionOptions, subscriptionRemoved]);\n      useEffect3(() => {\n        return () => {\n          promiseRef.current?.unsubscribe();\n          promiseRef.current = void 0;\n        };\n      }, []);\n      return useMemo2(() => ({\n        /**\n         * A method to manually refetch data for the query\n         */\n        refetch: () => {\n          if (!promiseRef.current)\n            throw new Error(process.env.NODE_ENV === \"production\" ? _formatProdErrorMessage2(38) : \"Cannot refetch a query that has not been started yet.\");\n          return promiseRef.current?.refetch();\n        }\n      }), []);\n    };\n    const useLazyQuerySubscription = ({\n      refetchOnReconnect,\n      refetchOnFocus,\n      pollingInterval = 0,\n      skipPollingIfUnfocused = false\n    } = {}) => {\n      const {\n        initiate\n      } = api.endpoints[name];\n      const dispatch = useDispatch();\n      const [arg, setArg] = useState(UNINITIALIZED_VALUE);\n      const promiseRef = useRef3();\n      const stableSubscriptionOptions = useShallowStableValue({\n        refetchOnReconnect,\n        refetchOnFocus,\n        pollingInterval,\n        skipPollingIfUnfocused\n      });\n      usePossiblyImmediateEffect(() => {\n        const lastSubscriptionOptions = promiseRef.current?.subscriptionOptions;\n        if (stableSubscriptionOptions !== lastSubscriptionOptions) {\n          promiseRef.current?.updateSubscriptionOptions(stableSubscriptionOptions);\n        }\n      }, [stableSubscriptionOptions]);\n      const subscriptionOptionsRef = useRef3(stableSubscriptionOptions);\n      usePossiblyImmediateEffect(() => {\n        subscriptionOptionsRef.current = stableSubscriptionOptions;\n      }, [stableSubscriptionOptions]);\n      const trigger = useCallback(function(arg2, preferCacheValue = false) {\n        let promise;\n        batch(() => {\n          promiseRef.current?.unsubscribe();\n          promiseRef.current = promise = dispatch(initiate(arg2, {\n            subscriptionOptions: subscriptionOptionsRef.current,\n            forceRefetch: !preferCacheValue\n          }));\n          setArg(arg2);\n        });\n        return promise;\n      }, [dispatch, initiate]);\n      useEffect3(() => {\n        return () => {\n          promiseRef?.current?.unsubscribe();\n        };\n      }, []);\n      useEffect3(() => {\n        if (arg !== UNINITIALIZED_VALUE && !promiseRef.current) {\n          trigger(arg, true);\n        }\n      }, [arg, trigger]);\n      return useMemo2(() => [trigger, arg], [trigger, arg]);\n    };\n    const useQueryState = (arg, {\n      skip = false,\n      selectFromResult\n    } = {}) => {\n      const {\n        select\n      } = api.endpoints[name];\n      const stableArg = useStableQueryArgs(skip ? skipToken : arg, serializeQueryArgs, context.endpointDefinitions[name], name);\n      const lastValue = useRef3();\n      const selectDefaultResult = useMemo2(() => createSelector2([select(stableArg), (_, lastResult) => lastResult, (_) => stableArg], queryStatePreSelector, {\n        memoizeOptions: {\n          resultEqualityCheck: shallowEqual2\n        }\n      }), [select, stableArg]);\n      const querySelector = useMemo2(() => selectFromResult ? createSelector2([selectDefaultResult], selectFromResult, {\n        devModeChecks: {\n          identityFunctionCheck: \"never\"\n        }\n      }) : selectDefaultResult, [selectDefaultResult, selectFromResult]);\n      const currentState = useSelector((state) => querySelector(state, lastValue.current), shallowEqual2);\n      const store = useStore();\n      const newLastValue = selectDefaultResult(store.getState(), lastValue.current);\n      useIsomorphicLayoutEffect(() => {\n        lastValue.current = newLastValue;\n      }, [newLastValue]);\n      return currentState;\n    };\n    return {\n      useQueryState,\n      useQuerySubscription,\n      useLazyQuerySubscription,\n      useLazyQuery(options) {\n        const [trigger, arg] = useLazyQuerySubscription(options);\n        const queryStateResults = useQueryState(arg, {\n          ...options,\n          skip: arg === UNINITIALIZED_VALUE\n        });\n        const info = useMemo2(() => ({\n          lastArg: arg\n        }), [arg]);\n        return useMemo2(() => [trigger, queryStateResults, info], [trigger, queryStateResults, info]);\n      },\n      useQuery(arg, options) {\n        const querySubscriptionResults = useQuerySubscription(arg, options);\n        const queryStateResults = useQueryState(arg, {\n          selectFromResult: arg === skipToken || options?.skip ? void 0 : noPendingQueryStateSelector,\n          ...options\n        });\n        const {\n          data,\n          status,\n          isLoading,\n          isSuccess,\n          isError,\n          error\n        } = queryStateResults;\n        useDebugValue({\n          data,\n          status,\n          isLoading,\n          isSuccess,\n          isError,\n          error\n        });\n        return useMemo2(() => ({\n          ...queryStateResults,\n          ...querySubscriptionResults\n        }), [queryStateResults, querySubscriptionResults]);\n      }\n    };\n  }\n  function buildMutationHook(name) {\n    return ({\n      selectFromResult,\n      fixedCacheKey\n    } = {}) => {\n      const {\n        select,\n        initiate\n      } = api.endpoints[name];\n      const dispatch = useDispatch();\n      const [promise, setPromise] = useState();\n      useEffect3(() => () => {\n        if (!promise?.arg.fixedCacheKey) {\n          promise?.reset();\n        }\n      }, [promise]);\n      const triggerMutation = useCallback(function(arg) {\n        const promise2 = dispatch(initiate(arg, {\n          fixedCacheKey\n        }));\n        setPromise(promise2);\n        return promise2;\n      }, [dispatch, initiate, fixedCacheKey]);\n      const {\n        requestId\n      } = promise || {};\n      const selectDefaultResult = useMemo2(() => select({\n        fixedCacheKey,\n        requestId: promise?.requestId\n      }), [fixedCacheKey, promise, select]);\n      const mutationSelector = useMemo2(() => selectFromResult ? createSelector2([selectDefaultResult], selectFromResult) : selectDefaultResult, [selectFromResult, selectDefaultResult]);\n      const currentState = useSelector(mutationSelector, shallowEqual2);\n      const originalArgs = fixedCacheKey == null ? promise?.arg.originalArgs : void 0;\n      const reset = useCallback(() => {\n        batch(() => {\n          if (promise) {\n            setPromise(void 0);\n          }\n          if (fixedCacheKey) {\n            dispatch(api.internalActions.removeMutationResult({\n              requestId,\n              fixedCacheKey\n            }));\n          }\n        });\n      }, [dispatch, fixedCacheKey, promise, requestId]);\n      const {\n        endpointName,\n        data,\n        status,\n        isLoading,\n        isSuccess,\n        isError,\n        error\n      } = currentState;\n      useDebugValue({\n        endpointName,\n        data,\n        status,\n        isLoading,\n        isSuccess,\n        isError,\n        error\n      });\n      const finalState = useMemo2(() => ({\n        ...currentState,\n        originalArgs,\n        reset\n      }), [currentState, originalArgs, reset]);\n      return useMemo2(() => [triggerMutation, finalState], [triggerMutation, finalState]);\n    };\n  }\n}\n\n// src/query/react/module.ts\nimport { batch as rrBatch, useDispatch as rrUseDispatch, useSelector as rrUseSelector, useStore as rrUseStore } from \"react-redux\";\nimport { createSelector as _createSelector } from \"reselect\";\n\n// src/query/utils/countObjectKeys.ts\nfunction countObjectKeys(obj) {\n  let count = 0;\n  for (const _key in obj) {\n    count++;\n  }\n  return count;\n}\n\n// src/query/react/module.ts\nvar reactHooksModuleName = /* @__PURE__ */ Symbol();\nvar reactHooksModule = ({\n  batch = rrBatch,\n  hooks = {\n    useDispatch: rrUseDispatch,\n    useSelector: rrUseSelector,\n    useStore: rrUseStore\n  },\n  createSelector: createSelector2 = _createSelector,\n  unstable__sideEffectsInRender = false,\n  ...rest\n} = {}) => {\n  if (process.env.NODE_ENV !== \"production\") {\n    const hookNames = [\"useDispatch\", \"useSelector\", \"useStore\"];\n    let warned = false;\n    for (const hookName of hookNames) {\n      if (countObjectKeys(rest) > 0) {\n        if (rest[hookName]) {\n          if (!warned) {\n            console.warn(\"As of RTK 2.0, the hooks now need to be specified as one object, provided under a `hooks` key:\\n`reactHooksModule({ hooks: { useDispatch, useSelector, useStore } })`\");\n            warned = true;\n          }\n        }\n        hooks[hookName] = rest[hookName];\n      }\n      if (typeof hooks[hookName] !== \"function\") {\n        throw new Error(process.env.NODE_ENV === \"production\" ? _formatProdErrorMessage3(36) : `When using custom hooks for context, all ${hookNames.length} hooks need to be provided: ${hookNames.join(\", \")}.\nHook ${hookName} was either not provided or not a function.`);\n      }\n    }\n  }\n  return {\n    name: reactHooksModuleName,\n    init(api, {\n      serializeQueryArgs\n    }, context) {\n      const anyApi = api;\n      const {\n        buildQueryHooks,\n        buildMutationHook,\n        usePrefetch\n      } = buildHooks({\n        api,\n        moduleOptions: {\n          batch,\n          hooks,\n          unstable__sideEffectsInRender,\n          createSelector: createSelector2\n        },\n        serializeQueryArgs,\n        context\n      });\n      safeAssign(anyApi, {\n        usePrefetch\n      });\n      safeAssign(context, {\n        batch\n      });\n      return {\n        injectEndpoint(endpointName, definition) {\n          if (isQueryDefinition(definition)) {\n            const {\n              useQuery,\n              useLazyQuery,\n              useLazyQuerySubscription,\n              useQueryState,\n              useQuerySubscription\n            } = buildQueryHooks(endpointName);\n            safeAssign(anyApi.endpoints[endpointName], {\n              useQuery,\n              useLazyQuery,\n              useLazyQuerySubscription,\n              useQueryState,\n              useQuerySubscription\n            });\n            api[`use${capitalize(endpointName)}Query`] = useQuery;\n            api[`useLazy${capitalize(endpointName)}Query`] = useLazyQuery;\n          } else if (isMutationDefinition(definition)) {\n            const useMutation = buildMutationHook(endpointName);\n            safeAssign(anyApi.endpoints[endpointName], {\n              useMutation\n            });\n            api[`use${capitalize(endpointName)}Mutation`] = useMutation;\n          }\n        }\n      };\n    }\n  };\n};\n\n// src/query/react/index.ts\nexport * from \"@reduxjs/toolkit/query\";\n\n// src/query/react/ApiProvider.tsx\nimport { formatProdErrorMessage as _formatProdErrorMessage4 } from \"@reduxjs/toolkit\";\nimport { configureStore } from \"@reduxjs/toolkit\";\nimport { useContext } from \"react\";\nimport { useEffect as useEffect4 } from \"react\";\nimport React from \"react\";\nimport { Provider, ReactReduxContext } from \"react-redux\";\nimport { setupListeners } from \"@reduxjs/toolkit/query\";\nfunction ApiProvider(props) {\n  const context = props.context || ReactReduxContext;\n  const existingContext = useContext(context);\n  if (existingContext) {\n    throw new Error(process.env.NODE_ENV === \"production\" ? _formatProdErrorMessage4(35) : \"Existing Redux context detected. If you already have a store set up, please use the traditional Redux setup.\");\n  }\n  const [store] = React.useState(() => configureStore({\n    reducer: {\n      [props.api.reducerPath]: props.api.reducer\n    },\n    middleware: (gDM) => gDM().concat(props.api.middleware)\n  }));\n  useEffect4(() => props.setupListeners === false ? void 0 : setupListeners(store.dispatch, props.setupListeners), [props.setupListeners, store.dispatch]);\n  return /* @__PURE__ */ React.createElement(Provider, { store, context }, props.children);\n}\n\n// src/query/react/index.ts\nvar createApi = /* @__PURE__ */ buildCreateApi(coreModule(), reactHooksModule());\nexport {\n  ApiProvider,\n  createApi,\n  reactHooksModule,\n  reactHooksModuleName\n};\n//# sourceMappingURL=rtk-query-react.modern.mjs.map"
  ]
}