{"version":3,"file":"static/js/vendor.mobx-react-lite.9c754d99.chunk.js","mappings":"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","sources":["../node_modules/mobx-react-lite/src/utils/assertEnvironment.ts","../node_modules/mobx-react-lite/src/utils/observerBatching.ts","../node_modules/mobx-react-lite/src/utils/printDebugValue.ts","../node_modules/mobx-react-lite/src/utils/FinalizationRegistryWrapper.ts","../node_modules/mobx-react-lite/src/utils/reactionCleanupTrackingCommon.ts","../node_modules/mobx-react-lite/src/utils/reactionCleanupTracking.ts","../node_modules/mobx-react-lite/src/utils/createReactionCleanupTrackingUsingFinalizationRegister.ts","../node_modules/mobx-react-lite/src/utils/createTimerBasedReactionCleanupTracking.ts","../node_modules/mobx-react-lite/src/staticRendering.ts","../node_modules/mobx-react-lite/src/useObserver.ts","../node_modules/mobx-react-lite/src/observer.ts","../node_modules/mobx-react-lite/src/index.ts"],"sourcesContent":["import { makeObservable } from \"mobx\"\nimport { useState } from \"react\"\n\nif (!useState) {\n    throw new Error(\"mobx-react-lite requires React with Hooks support\")\n}\nif (!makeObservable) {\n    throw new Error(\"mobx-react-lite@3 requires mobx at least version 6 to be available\")\n}\n","import { configure } from \"mobx\"\n\nexport function defaultNoopBatch(callback: () => void) {\n    callback()\n}\n\nexport function observerBatching(reactionScheduler: any) {\n    if (!reactionScheduler) {\n        reactionScheduler = defaultNoopBatch\n        if (\"production\" !== process.env.NODE_ENV) {\n            console.warn(\n                \"[MobX] Failed to get unstable_batched updates from react-dom / react-native\"\n            )\n        }\n    }\n    configure({ reactionScheduler })\n}\n\nexport const isObserverBatched = () => {\n    if (\"production\" !== process.env.NODE_ENV) {\n        console.warn(\"[MobX] Deprecated\")\n    }\n\n    return true\n}\n","import { getDependencyTree, Reaction } from \"mobx\"\n\nexport function printDebugValue(v: Reaction) {\n    return getDependencyTree(v)\n}\n","declare class FinalizationRegistryType<T> {\n    constructor(cleanup: (cleanupToken: T) => void)\n    register(object: object, cleanupToken: T, unregisterToken?: object): void\n    unregister(unregisterToken: object): void\n}\n\ndeclare const FinalizationRegistry: typeof FinalizationRegistryType | undefined\n\nconst FinalizationRegistryLocal =\n    typeof FinalizationRegistry === \"undefined\" ? undefined : FinalizationRegistry\n\nexport { FinalizationRegistryLocal as FinalizationRegistry }\n","import { Reaction } from \"mobx\"\n\nexport function createTrackingData(reaction: Reaction) {\n    const trackingData: IReactionTracking = {\n        reaction,\n        mounted: false,\n        changedBeforeMount: false,\n        cleanAt: Date.now() + CLEANUP_LEAKED_REACTIONS_AFTER_MILLIS\n    }\n    return trackingData\n}\n\n/**\n * Unified api for timers/Finalization registry cleanups\n * This abstraction make useObserver much simpler\n */\nexport interface ReactionCleanupTracking {\n    /**\n     *\n     * @param reaction The reaction to cleanup\n     * @param objectRetainedByReact This will be in actual use only when FinalizationRegister is in use\n     */\n    addReactionToTrack(\n        reactionTrackingRef: React.MutableRefObject<IReactionTracking | null>,\n        reaction: Reaction,\n        objectRetainedByReact: object\n    ): IReactionTracking\n    recordReactionAsCommitted(reactionRef: React.MutableRefObject<IReactionTracking | null>): void\n    forceCleanupTimerToRunNowForTests(): void\n    resetCleanupScheduleForTests(): void\n}\n\nexport interface IReactionTracking {\n    /** The Reaction created during first render, which may be leaked */\n    reaction: Reaction\n    /**\n     * The time (in ticks) at which point we should dispose of the reaction\n     * if this component hasn't yet been fully mounted.\n     */\n    cleanAt: number\n\n    /**\n     * Whether the component has yet completed mounting (for us, whether\n     * its useEffect has run)\n     */\n    mounted: boolean\n\n    /**\n     * Whether the observables that the component is tracking changed between\n     * the first render and the first useEffect.\n     */\n    changedBeforeMount: boolean\n\n    /**\n     * In case we are using finalization registry based cleanup,\n     * this will hold the cleanup token associated with this reaction\n     */\n    finalizationRegistryCleanupToken?: number\n}\n\n/**\n * The minimum time before we'll clean up a Reaction created in a render\n * for a component that hasn't managed to run its effects. This needs to\n * be big enough to ensure that a component won't turn up and have its\n * effects run without being re-rendered.\n */\nexport const CLEANUP_LEAKED_REACTIONS_AFTER_MILLIS = 10_000\n\n/**\n * The frequency with which we'll check for leaked reactions.\n */\nexport const CLEANUP_TIMER_LOOP_MILLIS = 10_000\n","import { FinalizationRegistry as FinalizationRegistryMaybeUndefined } from \"./FinalizationRegistryWrapper\"\nimport { createReactionCleanupTrackingUsingFinalizationRegister } from \"./createReactionCleanupTrackingUsingFinalizationRegister\"\nimport { createTimerBasedReactionCleanupTracking } from \"./createTimerBasedReactionCleanupTracking\"\nexport { IReactionTracking } from \"./reactionCleanupTrackingCommon\"\n\nconst {\n    addReactionToTrack,\n    recordReactionAsCommitted,\n    resetCleanupScheduleForTests,\n    forceCleanupTimerToRunNowForTests\n} = FinalizationRegistryMaybeUndefined\n    ? createReactionCleanupTrackingUsingFinalizationRegister(FinalizationRegistryMaybeUndefined)\n    : createTimerBasedReactionCleanupTracking()\n\nexport {\n    addReactionToTrack,\n    recordReactionAsCommitted,\n    resetCleanupScheduleForTests,\n    forceCleanupTimerToRunNowForTests\n}\n","import { FinalizationRegistry as FinalizationRegistryMaybeUndefined } from \"./FinalizationRegistryWrapper\"\nimport { Reaction } from \"mobx\"\nimport {\n    ReactionCleanupTracking,\n    IReactionTracking,\n    createTrackingData\n} from \"./reactionCleanupTrackingCommon\"\n\n/**\n * FinalizationRegistry-based uncommitted reaction cleanup\n */\nexport function createReactionCleanupTrackingUsingFinalizationRegister(\n    FinalizationRegistry: NonNullable<typeof FinalizationRegistryMaybeUndefined>\n): ReactionCleanupTracking {\n    const cleanupTokenToReactionTrackingMap = new Map<number, IReactionTracking>()\n    let globalCleanupTokensCounter = 1\n\n    const registry = new FinalizationRegistry(function cleanupFunction(token: number) {\n        const trackedReaction = cleanupTokenToReactionTrackingMap.get(token)\n        if (trackedReaction) {\n            trackedReaction.reaction.dispose()\n            cleanupTokenToReactionTrackingMap.delete(token)\n        }\n    })\n\n    return {\n        addReactionToTrack(\n            reactionTrackingRef: React.MutableRefObject<IReactionTracking | null>,\n            reaction: Reaction,\n            objectRetainedByReact: object\n        ) {\n            const token = globalCleanupTokensCounter++\n\n            registry.register(objectRetainedByReact, token, reactionTrackingRef)\n            reactionTrackingRef.current = createTrackingData(reaction)\n            reactionTrackingRef.current.finalizationRegistryCleanupToken = token\n            cleanupTokenToReactionTrackingMap.set(token, reactionTrackingRef.current)\n\n            return reactionTrackingRef.current\n        },\n        recordReactionAsCommitted(reactionRef: React.MutableRefObject<IReactionTracking | null>) {\n            registry.unregister(reactionRef)\n\n            if (reactionRef.current && reactionRef.current.finalizationRegistryCleanupToken) {\n                cleanupTokenToReactionTrackingMap.delete(\n                    reactionRef.current.finalizationRegistryCleanupToken\n                )\n            }\n        },\n        forceCleanupTimerToRunNowForTests() {\n            // When FinalizationRegistry in use, this this is no-op\n        },\n        resetCleanupScheduleForTests() {\n            // When FinalizationRegistry in use, this this is no-op\n        }\n    }\n}\n","import { Reaction } from \"mobx\"\nimport {\n    ReactionCleanupTracking,\n    IReactionTracking,\n    CLEANUP_TIMER_LOOP_MILLIS,\n    createTrackingData\n} from \"./reactionCleanupTrackingCommon\"\n\n/**\n * timers, gc-style, uncommitted reaction cleanup\n */\nexport function createTimerBasedReactionCleanupTracking(): ReactionCleanupTracking {\n    /**\n     * Reactions created by components that have yet to be fully mounted.\n     */\n    const uncommittedReactionRefs: Set<React.MutableRefObject<IReactionTracking | null>> = new Set()\n\n    /**\n     * Latest 'uncommitted reactions' cleanup timer handle.\n     */\n    let reactionCleanupHandle: ReturnType<typeof setTimeout> | undefined\n\n    /* istanbul ignore next */\n    /**\n     * Only to be used by test functions; do not export outside of mobx-react-lite\n     */\n    function forceCleanupTimerToRunNowForTests() {\n        // This allows us to control the execution of the cleanup timer\n        // to force it to run at awkward times in unit tests.\n        if (reactionCleanupHandle) {\n            clearTimeout(reactionCleanupHandle)\n            cleanUncommittedReactions()\n        }\n    }\n\n    /* istanbul ignore next */\n    function resetCleanupScheduleForTests() {\n        if (uncommittedReactionRefs.size > 0) {\n            for (const ref of uncommittedReactionRefs) {\n                const tracking = ref.current\n                if (tracking) {\n                    tracking.reaction.dispose()\n                    ref.current = null\n                }\n            }\n            uncommittedReactionRefs.clear()\n        }\n\n        if (reactionCleanupHandle) {\n            clearTimeout(reactionCleanupHandle)\n            reactionCleanupHandle = undefined\n        }\n    }\n\n    function ensureCleanupTimerRunning() {\n        if (reactionCleanupHandle === undefined) {\n            reactionCleanupHandle = setTimeout(cleanUncommittedReactions, CLEANUP_TIMER_LOOP_MILLIS)\n        }\n    }\n\n    function scheduleCleanupOfReactionIfLeaked(\n        ref: React.MutableRefObject<IReactionTracking | null>\n    ) {\n        uncommittedReactionRefs.add(ref)\n\n        ensureCleanupTimerRunning()\n    }\n\n    function recordReactionAsCommitted(\n        reactionRef: React.MutableRefObject<IReactionTracking | null>\n    ) {\n        uncommittedReactionRefs.delete(reactionRef)\n    }\n\n    /**\n     * Run by the cleanup timer to dispose any outstanding reactions\n     */\n    function cleanUncommittedReactions() {\n        reactionCleanupHandle = undefined\n\n        // Loop through all the candidate leaked reactions; those older\n        // than CLEANUP_LEAKED_REACTIONS_AFTER_MILLIS get tidied.\n\n        const now = Date.now()\n        uncommittedReactionRefs.forEach(ref => {\n            const tracking = ref.current\n            if (tracking) {\n                if (now >= tracking.cleanAt) {\n                    // It's time to tidy up this leaked reaction.\n                    tracking.reaction.dispose()\n                    ref.current = null\n                    uncommittedReactionRefs.delete(ref)\n                }\n            }\n        })\n\n        if (uncommittedReactionRefs.size > 0) {\n            // We've just finished a round of cleanups but there are still\n            // some leak candidates outstanding.\n            ensureCleanupTimerRunning()\n        }\n    }\n\n    return {\n        addReactionToTrack(\n            reactionTrackingRef: React.MutableRefObject<IReactionTracking | null>,\n            reaction: Reaction,\n            /**\n             * On timer based implementation we don't really need this object,\n             * but we keep the same api\n             */\n            objectRetainedByReact: unknown\n        ) {\n            reactionTrackingRef.current = createTrackingData(reaction)\n            scheduleCleanupOfReactionIfLeaked(reactionTrackingRef)\n            return reactionTrackingRef.current\n        },\n        recordReactionAsCommitted,\n        forceCleanupTimerToRunNowForTests,\n        resetCleanupScheduleForTests\n    }\n}\n","let globalIsUsingStaticRendering = false\n\nexport function enableStaticRendering(enable: boolean) {\n    globalIsUsingStaticRendering = enable\n}\n\nexport function isUsingStaticRendering(): boolean {\n    return globalIsUsingStaticRendering\n}\n","import { Reaction } from \"mobx\"\nimport React from \"react\"\nimport { printDebugValue } from \"./utils/printDebugValue\"\nimport {\n    addReactionToTrack,\n    IReactionTracking,\n    recordReactionAsCommitted\n} from \"./utils/reactionCleanupTracking\"\nimport { isUsingStaticRendering } from \"./staticRendering\"\n\nfunction observerComponentNameFor(baseComponentName: string) {\n    return `observer${baseComponentName}`\n}\n\n/**\n * We use class to make it easier to detect in heap snapshots by name\n */\nclass ObjectToBeRetainedByReact {}\n\nfunction objectToBeRetainedByReactFactory() {\n    return new ObjectToBeRetainedByReact()\n}\n\nexport function useObserver<T>(fn: () => T, baseComponentName: string = \"observed\"): T {\n    if (isUsingStaticRendering()) {\n        return fn()\n    }\n\n    const [objectRetainedByReact] = React.useState(objectToBeRetainedByReactFactory)\n    // Force update, see #2982\n    const [, setState] = React.useState()\n    const forceUpdate = () => setState([] as any)\n\n    // StrictMode/ConcurrentMode/Suspense may mean that our component is\n    // rendered and abandoned multiple times, so we need to track leaked\n    // Reactions.\n    const reactionTrackingRef = React.useRef<IReactionTracking | null>(null)\n\n    if (!reactionTrackingRef.current) {\n        // First render for this component (or first time since a previous\n        // reaction from an abandoned render was disposed).\n\n        const newReaction = new Reaction(observerComponentNameFor(baseComponentName), () => {\n            // Observable has changed, meaning we want to re-render\n            // BUT if we're a component that hasn't yet got to the useEffect()\n            // stage, we might be a component that _started_ to render, but\n            // got dropped, and we don't want to make state changes then.\n            // (It triggers warnings in StrictMode, for a start.)\n            if (trackingData.mounted) {\n                // We have reached useEffect(), so we're mounted, and can trigger an update\n                forceUpdate()\n            } else {\n                // We haven't yet reached useEffect(), so we'll need to trigger a re-render\n                // when (and if) useEffect() arrives.\n                trackingData.changedBeforeMount = true\n            }\n        })\n\n        const trackingData = addReactionToTrack(\n            reactionTrackingRef,\n            newReaction,\n            objectRetainedByReact\n        )\n    }\n\n    const { reaction } = reactionTrackingRef.current!\n    React.useDebugValue(reaction, printDebugValue)\n\n    React.useEffect(() => {\n        // Called on first mount only\n        recordReactionAsCommitted(reactionTrackingRef)\n\n        if (reactionTrackingRef.current) {\n            // Great. We've already got our reaction from our render;\n            // all we need to do is to record that it's now mounted,\n            // to allow future observable changes to trigger re-renders\n            reactionTrackingRef.current.mounted = true\n            // Got a change before first mount, force an update\n            if (reactionTrackingRef.current.changedBeforeMount) {\n                reactionTrackingRef.current.changedBeforeMount = false\n                forceUpdate()\n            }\n        } else {\n            // The reaction we set up in our render has been disposed.\n            // This can be due to bad timings of renderings, e.g. our\n            // component was paused for a _very_ long time, and our\n            // reaction got cleaned up\n\n            // Re-create the reaction\n            reactionTrackingRef.current = {\n                reaction: new Reaction(observerComponentNameFor(baseComponentName), () => {\n                    // We've definitely already been mounted at this point\n                    forceUpdate()\n                }),\n                mounted: true,\n                changedBeforeMount: false,\n                cleanAt: Infinity\n            }\n            forceUpdate()\n        }\n\n        return () => {\n            reactionTrackingRef.current!.reaction.dispose()\n            reactionTrackingRef.current = null\n        }\n    }, [])\n\n    // render the original component, but have the\n    // reaction track the observables, so that rendering\n    // can be invalidated (see above) once a dependency changes\n    let rendering!: T\n    let exception\n    reaction.track(() => {\n        try {\n            rendering = fn()\n        } catch (e) {\n            exception = e\n        }\n    })\n\n    if (exception) {\n        throw exception // re-throw any exceptions caught during rendering\n    }\n\n    return rendering\n}\n","import { forwardRef, memo } from \"react\"\n\nimport { isUsingStaticRendering } from \"./staticRendering\"\nimport { useObserver } from \"./useObserver\"\n\nlet warnObserverOptionsDeprecated = true\n\nconst hasSymbol = typeof Symbol === \"function\" && Symbol.for\n// Using react-is had some issues (and operates on elements, not on types), see #608 / #609\nconst ReactForwardRefSymbol = hasSymbol\n    ? Symbol.for(\"react.forward_ref\")\n    : typeof forwardRef === \"function\" && forwardRef((props: any) => null)[\"$$typeof\"]\n\nconst ReactMemoSymbol = hasSymbol\n    ? Symbol.for(\"react.memo\")\n    : typeof memo === \"function\" && memo((props: any) => null)[\"$$typeof\"]\n\nexport interface IObserverOptions {\n    readonly forwardRef?: boolean\n}\n\nexport function observer<P extends object, TRef = {}>(\n    baseComponent: React.ForwardRefRenderFunction<TRef, P>,\n    options: IObserverOptions & { forwardRef: true }\n): React.MemoExoticComponent<\n    React.ForwardRefExoticComponent<React.PropsWithoutRef<P> & React.RefAttributes<TRef>>\n>\n\nexport function observer<P extends object, TRef = {}>(\n    baseComponent: React.ForwardRefExoticComponent<\n        React.PropsWithoutRef<P> & React.RefAttributes<TRef>\n    >\n): React.MemoExoticComponent<\n    React.ForwardRefExoticComponent<React.PropsWithoutRef<P> & React.RefAttributes<TRef>>\n>\n\nexport function observer<P extends object>(\n    baseComponent: React.FunctionComponent<P>,\n    options?: IObserverOptions\n): React.FunctionComponent<P>\n\nexport function observer<\n    C extends React.FunctionComponent<any> | React.ForwardRefRenderFunction<any>,\n    Options extends IObserverOptions\n>(\n    baseComponent: C,\n    options?: Options\n): Options extends { forwardRef: true }\n    ? C extends React.ForwardRefRenderFunction<infer TRef, infer P>\n        ? C &\n              React.MemoExoticComponent<\n                  React.ForwardRefExoticComponent<\n                      React.PropsWithoutRef<P> & React.RefAttributes<TRef>\n                  >\n              >\n        : never /* forwardRef set for a non forwarding component */\n    : C & { displayName: string }\n\n// n.b. base case is not used for actual typings or exported in the typing files\nexport function observer<P extends object, TRef = {}>(\n    baseComponent:\n        | React.ForwardRefRenderFunction<TRef, P>\n        | React.FunctionComponent<P>\n        | React.ForwardRefExoticComponent<React.PropsWithoutRef<P> & React.RefAttributes<TRef>>,\n    // TODO remove in next major\n    options?: IObserverOptions\n) {\n    if (process.env.NODE_ENV !== \"production\" && warnObserverOptionsDeprecated && options) {\n        warnObserverOptionsDeprecated = false\n        console.warn(\n            `[mobx-react-lite] \\`observer(fn, { forwardRef: true })\\` is deprecated, use \\`observer(React.forwardRef(fn))\\``\n        )\n    }\n\n    if (ReactMemoSymbol && baseComponent[\"$$typeof\"] === ReactMemoSymbol) {\n        throw new Error(\n            `[mobx-react-lite] You are trying to use \\`observer\\` on a function component wrapped in either another \\`observer\\` or \\`React.memo\\`. The observer already applies 'React.memo' for you.`\n        )\n    }\n\n    // The working of observer is explained step by step in this talk: https://www.youtube.com/watch?v=cPF4iBedoF0&feature=youtu.be&t=1307\n    if (isUsingStaticRendering()) {\n        return baseComponent\n    }\n\n    let useForwardRef = options?.forwardRef ?? false\n    let render = baseComponent\n\n    const baseComponentName = baseComponent.displayName || baseComponent.name\n\n    // If already wrapped with forwardRef, unwrap,\n    // so we can patch render and apply memo\n    if (ReactForwardRefSymbol && baseComponent[\"$$typeof\"] === ReactForwardRefSymbol) {\n        useForwardRef = true\n        render = baseComponent[\"render\"]\n        if (typeof render !== \"function\") {\n            throw new Error(\n                `[mobx-react-lite] \\`render\\` property of ForwardRef was not a function`\n            )\n        }\n    }\n\n    let observerComponent = (props: any, ref: React.Ref<TRef>) => {\n        return useObserver(() => render(props, ref), baseComponentName)\n    }\n\n    // Don't set `displayName` for anonymous components,\n    // so the `displayName` can be customized by user, see #3192.\n    if (baseComponentName !== \"\") {\n        ;(observerComponent as React.FunctionComponent).displayName = baseComponentName\n    }\n\n    // Support legacy context: `contextTypes` must be applied before `memo`\n    if ((baseComponent as any).contextTypes) {\n        ;(observerComponent as React.FunctionComponent).contextTypes = (\n            baseComponent as any\n        ).contextTypes\n    }\n\n    if (useForwardRef) {\n        // `forwardRef` must be applied prior `memo`\n        // `forwardRef(observer(cmp))` throws:\n        // \"forwardRef requires a render function but received a `memo` component. Instead of forwardRef(memo(...)), use memo(forwardRef(...))\"\n        observerComponent = forwardRef(observerComponent)\n    }\n\n    // memo; we are not interested in deep updates\n    // in props; we assume that if deep objects are changed,\n    // this is in observables, which would have been tracked anyway\n    observerComponent = memo(observerComponent)\n\n    copyStaticProperties(baseComponent, observerComponent)\n\n    if (\"production\" !== process.env.NODE_ENV) {\n        Object.defineProperty(observerComponent, \"contextTypes\", {\n            set() {\n                throw new Error(\n                    `[mobx-react-lite] \\`${\n                        this.displayName || this.type?.displayName || \"Component\"\n                    }.contextTypes\\` must be set before applying \\`observer\\`.`\n                )\n            }\n        })\n    }\n\n    return observerComponent\n}\n\n// based on https://github.com/mridgway/hoist-non-react-statics/blob/master/src/index.js\nconst hoistBlackList: any = {\n    $$typeof: true,\n    render: true,\n    compare: true,\n    type: true,\n    // Don't redefine `displayName`,\n    // it's defined as getter-setter pair on `memo` (see #3192).\n    displayName: true\n}\n\nfunction copyStaticProperties(base: any, target: any) {\n    Object.keys(base).forEach(key => {\n        if (!hoistBlackList[key]) {\n            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(base, key)!)\n        }\n    })\n}\n","import \"./utils/assertEnvironment\"\n\nimport { unstable_batchedUpdates as batch } from \"./utils/reactBatchedUpdates\"\nimport { observerBatching } from \"./utils/observerBatching\"\nimport { useDeprecated } from \"./utils/utils\"\nimport { useObserver as useObserverOriginal } from \"./useObserver\"\nimport { enableStaticRendering } from \"./staticRendering\"\n\nobserverBatching(batch)\n\nexport { isUsingStaticRendering, enableStaticRendering } from \"./staticRendering\"\nexport { observer, IObserverOptions } from \"./observer\"\nexport { Observer } from \"./ObserverComponent\"\nexport { useLocalObservable } from \"./useLocalObservable\"\nexport { useLocalStore } from \"./useLocalStore\"\nexport { useAsObservableSource } from \"./useAsObservableSource\"\nexport { resetCleanupScheduleForTests as clearTimers } from \"./utils/reactionCleanupTracking\"\n\nexport function useObserver<T>(fn: () => T, baseComponentName: string = \"observed\"): T {\n    if (\"production\" !== process.env.NODE_ENV) {\n        useDeprecated(\n            \"[mobx-react-lite] 'useObserver(fn)' is deprecated. Use `<Observer>{fn}</Observer>` instead, or wrap the entire component in `observer`.\"\n        )\n    }\n    return useObserverOriginal(fn, baseComponentName)\n}\n\nexport { isObserverBatched, observerBatching } from \"./utils/observerBatching\"\n\nexport function useStaticRendering(enable: boolean) {\n    if (\"production\" !== process.env.NODE_ENV) {\n        console.warn(\n            \"[mobx-react-lite] 'useStaticRendering' is deprecated, use 'enableStaticRendering' instead\"\n        )\n    }\n    enableStaticRendering(enable)\n}\n"],"names":["useState","Error","makeObservable","defaultNoopBatch","callback","printDebugValue","v","getDependencyTree","FinalizationRegistryLocal","FinalizationRegistry","undefined","createTrackingData","reaction","mounted","changedBeforeMount","cleanAt","Date","now","CLEANUP_LEAKED_REACTIONS_AFTER_MILLIS","FinalizationRegistryMaybeUndefined","cleanupTokenToReactionTrackingMap","Map","globalCleanupTokensCounter","registry","token","trackedReaction","get","dispose","delete","addReactionToTrack","reactionTrackingRef","objectRetainedByReact","register","current","finalizationRegistryCleanupToken","set","recordReactionAsCommitted","reactionRef","unregister","forceCleanupTimerToRunNowForTests","resetCleanupScheduleForTests","createReactionCleanupTrackingUsingFinalizationRegister","reactionCleanupHandle","uncommittedReactionRefs","Set","ensureCleanupTimerRunning","setTimeout","cleanUncommittedReactions","forEach","ref","tracking","size","add","clearTimeout","clear","createTimerBasedReactionCleanupTracking","globalIsUsingStaticRendering","isUsingStaticRendering","observerComponentNameFor","baseComponentName","objectToBeRetainedByReactFactory","ObjectToBeRetainedByReact","useObserver","fn","React","setState","forceUpdate","newReaction","Reaction","trackingData_1","rendering","exception","Infinity","track","e","hasSymbol","Symbol","for","ReactForwardRefSymbol","forwardRef","props","ReactMemoSymbol","memo","observer","baseComponent","options","useForwardRef","render","displayName","name","base","target","observerComponent","contextTypes","Object","keys","key","hoistBlackList","defineProperty","getOwnPropertyDescriptor","$$typeof","compare","type","reactionScheduler","batch","configure"],"sourceRoot":""}