{"version":3,"sources":["webpack:///./node_modules/framer-motion/dist/es/render/dom/projection/utils.js","webpack:///./node_modules/framer-motion/dist/es/context/SharedLayoutContext.js","webpack:///./node_modules/redux-devtools-extension/index.js","webpack:///./node_modules/framer-motion/dist/es/render/dom/utils/batch-layout.js","webpack:///./node_modules/framer-motion/dist/es/components/AnimateSharedLayout/utils/batcher.js","webpack:///./node_modules/react-use/esm/useLockBodyScroll.js","webpack:///./node_modules/react-use/esm/misc/util.js","webpack:///./node_modules/framer-motion/dist/es/components/AnimatePresence/PresenceChild.js","webpack:///./node_modules/framer-motion/dist/es/components/AnimatePresence/index.js","webpack:///./node_modules/framer-motion/dist/es/utils/use-force-update.js","webpack:///./node_modules/react-use/esm/useFirstMountState.js","webpack:///(webpack)/buildin/global.js"],"names":["isProjecting","visualElement","projection","isEnabled","shouldResetTransform","collectProjectingAncestors","ancestors","parent","push","collectProjectingChildren","children","addChild","child","forEach","sort","updateLayoutMeasurement","layoutState","getLayoutState","notifyBeforeLayoutMeasure","layout","isHydrated","measureViewportBox","layoutCorrected","notifyLayoutMeasure","prevViewportBox","update","rebaseProjectionTarget","snapshotViewportBox","SharedLayoutContext","FramerTreeLayoutContext","isSharedLayout","context","forceUpdate","compose","exports","__esModule","composeWithDevTools","window","__REDUX_DEVTOOLS_EXTENSION_COMPOSE__","arguments","length","apply","devToolsEnhancer","__REDUX_DEVTOOLS_EXTENSION__","noop","unresolvedJobs","Set","pushJob","stack","job","pointer","batchLayout","callback","add","delete","flushLayout","size","reads","writes","setRead","setWrite","clear","numStacks","i","executeJob","defaultHandler","layoutReady","notifyLayoutReady","createBatcher","queue","flush","_a","_b","read","write","order","Array","from","element","resetTransform","restoreTransform","isPresent","presence","Present","preRender","render","postRender","assignProjectionToSnapshot","target","getClosestBody","el","tagName","document_1","contentDocument","body","offsetParent","preventDefault","rawEvent","e","event","touches","isIosDevice","navigator","platform","test","bodies","Map","doc","document","undefined","documentListenerAdded","locked","elementRef","bodyRef","unlock","bodyInfo","get","counter","ontouchmove","style","overflow","initialOverflow","set","current","passive","lock","_locked","_elementRef","on","obj","args","_i","addEventListener","off","removeEventListener","isBrowser","presenceId","getPresenceId","id","PresenceChild","initial","onExitComplete","custom","presenceAffectsLayout","presenceChildren","newChildrenMap","childId","allComplete","isComplete","register","_","key","PresenceContext","Provider","value","getChildKey","AnimatePresence","exitBeforeEnter","_c","forceRender","unloadingRef","forcedRenderCount","setForcedRenderCount","useForceUpdate","layoutContext","isInitialRender","filteredChildren","filtered","onlyElements","presentChildren","allChildren","exiting","updateChildLookup","map","childrenToRender","presentKeys","targetKeys","numPresent","indexOf","insertionIndex","splice","removeIndex","findIndex","presentChild","has","useFirstMountState","isFirst","g","this","Function","module"],"mappings":"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","file":"vendors~NewsListing~TechnicalLibrary-e52bc573a99671b87cd6.js","sourcesContent":["import sync from 'framesync';\nimport { copyAxisBox } from '../../../utils/geometry/index.js';\nimport { compareByDepth } from '../../utils/compare-by-depth.js';\n\nfunction isProjecting(visualElement) {\n    var isEnabled = visualElement.projection.isEnabled;\n    return isEnabled || visualElement.shouldResetTransform();\n}\nfunction collectProjectingAncestors(visualElement, ancestors) {\n    if (ancestors === void 0) { ancestors = []; }\n    var parent = visualElement.parent;\n    if (parent)\n        collectProjectingAncestors(parent, ancestors);\n    if (isProjecting(visualElement))\n        ancestors.push(visualElement);\n    return ancestors;\n}\nfunction collectProjectingChildren(visualElement) {\n    var children = [];\n    var addChild = function (child) {\n        if (isProjecting(child))\n            children.push(child);\n        child.children.forEach(addChild);\n    };\n    visualElement.children.forEach(addChild);\n    return children.sort(compareByDepth);\n}\n/**\n * Update the layoutState by measuring the DOM layout. This\n * should be called after resetting any layout-affecting transforms.\n */\nfunction updateLayoutMeasurement(visualElement) {\n    if (visualElement.shouldResetTransform())\n        return;\n    var layoutState = visualElement.getLayoutState();\n    visualElement.notifyBeforeLayoutMeasure(layoutState.layout);\n    layoutState.isHydrated = true;\n    layoutState.layout = visualElement.measureViewportBox();\n    layoutState.layoutCorrected = copyAxisBox(layoutState.layout);\n    visualElement.notifyLayoutMeasure(layoutState.layout, visualElement.prevViewportBox || layoutState.layout);\n    sync.update(function () { return visualElement.rebaseProjectionTarget(); });\n}\n/**\n * Record the viewport box as it was before an expected mutation/re-render\n */\nfunction snapshotViewportBox(visualElement) {\n    if (visualElement.shouldResetTransform())\n        return;\n    visualElement.prevViewportBox = visualElement.measureViewportBox(false);\n    /**\n     * Update targetBox to match the prevViewportBox. This is just to ensure\n     * that targetBox is affected by scroll in the same way as the measured box\n     */\n    visualElement.rebaseProjectionTarget(false, visualElement.prevViewportBox);\n}\n\nexport { collectProjectingAncestors, collectProjectingChildren, snapshotViewportBox, updateLayoutMeasurement };\n","import { createContext } from 'react';\nimport { createBatcher } from '../components/AnimateSharedLayout/utils/batcher.js';\n\nvar SharedLayoutContext = createContext(createBatcher());\n/**\n * @internal\n */\nvar FramerTreeLayoutContext = createContext(createBatcher());\nfunction isSharedLayout(context) {\n    return !!context.forceUpdate;\n}\n\nexport { FramerTreeLayoutContext, SharedLayoutContext, isSharedLayout };\n","'use strict';\n\nvar compose = require('redux').compose;\n\nexports.__esModule = true;\nexports.composeWithDevTools =\n  typeof window !== 'undefined' && window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__\n    ? window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__\n    : function () {\n        if (arguments.length === 0) return undefined;\n        if (typeof arguments[0] === 'object') return compose;\n        return compose.apply(null, arguments);\n      };\n\nexports.devToolsEnhancer =\n  typeof window !== 'undefined' && window.__REDUX_DEVTOOLS_EXTENSION__\n    ? window.__REDUX_DEVTOOLS_EXTENSION__\n    : function () {\n        return function (noop) {\n          return noop;\n        };\n      };\n","var unresolvedJobs = new Set();\nfunction pushJob(stack, job, pointer) {\n    if (!stack[pointer])\n        stack[pointer] = [];\n    stack[pointer].push(job);\n}\nfunction batchLayout(callback) {\n    unresolvedJobs.add(callback);\n    return function () { return unresolvedJobs.delete(callback); };\n}\nfunction flushLayout() {\n    if (!unresolvedJobs.size)\n        return;\n    var pointer = 0;\n    var reads = [[]];\n    var writes = [];\n    var setRead = function (job) { return pushJob(reads, job, pointer); };\n    var setWrite = function (job) {\n        pushJob(writes, job, pointer);\n        pointer++;\n    };\n    /**\n     * Resolve jobs into their array stacks\n     */\n    unresolvedJobs.forEach(function (callback) {\n        callback(setRead, setWrite);\n        pointer = 0;\n    });\n    unresolvedJobs.clear();\n    /**\n     * Execute jobs\n     */\n    var numStacks = writes.length;\n    for (var i = 0; i <= numStacks; i++) {\n        reads[i] && reads[i].forEach(executeJob);\n        writes[i] && writes[i].forEach(executeJob);\n    }\n}\nvar executeJob = function (job) { return job(); };\n\nexport { batchLayout, flushLayout };\n","import { __spreadArray, __read } from 'tslib';\nimport sync, { flushSync } from 'framesync';\nimport { collectProjectingAncestors, updateLayoutMeasurement } from '../../../render/dom/projection/utils.js';\nimport { batchLayout, flushLayout } from '../../../render/dom/utils/batch-layout.js';\nimport { compareByDepth } from '../../../render/utils/compare-by-depth.js';\nimport { Presence } from '../types.js';\n\n/**\n * Default handlers for batching VisualElements\n */\nvar defaultHandler = {\n    layoutReady: function (child) { return child.notifyLayoutReady(); },\n};\n/**\n * Create a batcher to process VisualElements\n */\nfunction createBatcher() {\n    var queue = new Set();\n    return {\n        add: function (child) { return queue.add(child); },\n        flush: function (_a) {\n            var _b = _a === void 0 ? defaultHandler : _a, layoutReady = _b.layoutReady, parent = _b.parent;\n            batchLayout(function (read, write) {\n                var order = Array.from(queue).sort(compareByDepth);\n                var ancestors = parent\n                    ? collectProjectingAncestors(parent)\n                    : [];\n                write(function () {\n                    var allElements = __spreadArray(__spreadArray([], __read(ancestors)), __read(order));\n                    allElements.forEach(function (element) { return element.resetTransform(); });\n                });\n                read(function () {\n                    order.forEach(updateLayoutMeasurement);\n                });\n                write(function () {\n                    ancestors.forEach(function (element) { return element.restoreTransform(); });\n                    order.forEach(layoutReady);\n                });\n                read(function () {\n                    /**\n                     * After all children have started animating, ensure any Entering components are set to Present.\n                     * If we add deferred animations (set up all animations and then start them in two loops) this\n                     * could be moved to the start loop. But it needs to happen after all the animations configs\n                     * are generated in AnimateSharedLayout as this relies on presence data\n                     */\n                    order.forEach(function (child) {\n                        if (child.isPresent)\n                            child.presence = Presence.Present;\n                    });\n                });\n                write(function () {\n                    /**\n                     * Starting these animations will have queued jobs on the frame loop. In some situations,\n                     * like when removing an element, these will be processed too late after the DOM is manipulated,\n                     * leaving a flash of incorrectly-projected content. By manually flushing these jobs\n                     * we ensure there's no flash.\n                     */\n                    flushSync.preRender();\n                    flushSync.render();\n                });\n                read(function () {\n                    /**\n                     * Schedule a callback at the end of the following frame to assign the latest projection\n                     * box to the prevViewportBox snapshot. Once global batching is in place this could be run\n                     * synchronously. But for now it ensures that if any nested `AnimateSharedLayout` top-level\n                     * child attempts to calculate its previous relative position against a prevViewportBox\n                     * it will be against its latest projection box instead, as the snapshot is useless beyond this\n                     * render.\n                     */\n                    sync.postRender(function () {\n                        return order.forEach(assignProjectionToSnapshot);\n                    });\n                    queue.clear();\n                });\n            });\n            // TODO: Need to find a layout-synchronous way of flushing this\n            flushLayout();\n        },\n    };\n}\nfunction assignProjectionToSnapshot(child) {\n    child.prevViewportBox = child.projection.target;\n}\n\nexport { createBatcher };\n","import { useEffect, useRef } from 'react';\nimport { isBrowser, off, on } from './misc/util';\nexport function getClosestBody(el) {\n    if (!el) {\n        return null;\n    }\n    else if (el.tagName === 'BODY') {\n        return el;\n    }\n    else if (el.tagName === 'IFRAME') {\n        var document_1 = el.contentDocument;\n        return document_1 ? document_1.body : null;\n    }\n    else if (!el.offsetParent) {\n        return null;\n    }\n    return getClosestBody(el.offsetParent);\n}\nfunction preventDefault(rawEvent) {\n    var e = rawEvent || window.event;\n    // Do not prevent if the event has more than one touch (usually meaning this is a multi touch gesture like pinch to zoom).\n    if (e.touches.length > 1)\n        return true;\n    if (e.preventDefault)\n        e.preventDefault();\n    return false;\n}\nvar isIosDevice = isBrowser &&\n    window.navigator &&\n    window.navigator.platform &&\n    /iP(ad|hone|od)/.test(window.navigator.platform);\nvar bodies = new Map();\nvar doc = typeof document === 'object' ? document : undefined;\nvar documentListenerAdded = false;\nexport default !doc\n    ? function useLockBodyMock(_locked, _elementRef) {\n        if (_locked === void 0) { _locked = true; }\n    }\n    : function useLockBody(locked, elementRef) {\n        if (locked === void 0) { locked = true; }\n        var bodyRef = useRef(doc.body);\n        elementRef = elementRef || bodyRef;\n        var lock = function (body) {\n            var bodyInfo = bodies.get(body);\n            if (!bodyInfo) {\n                bodies.set(body, { counter: 1, initialOverflow: body.style.overflow });\n                if (isIosDevice) {\n                    if (!documentListenerAdded) {\n                        on(document, 'touchmove', preventDefault, { passive: false });\n                        documentListenerAdded = true;\n                    }\n                }\n                else {\n                    body.style.overflow = 'hidden';\n                }\n            }\n            else {\n                bodies.set(body, {\n                    counter: bodyInfo.counter + 1,\n                    initialOverflow: bodyInfo.initialOverflow,\n                });\n            }\n        };\n        var unlock = function (body) {\n            var bodyInfo = bodies.get(body);\n            if (bodyInfo) {\n                if (bodyInfo.counter === 1) {\n                    bodies.delete(body);\n                    if (isIosDevice) {\n                        body.ontouchmove = null;\n                        if (documentListenerAdded) {\n                            off(document, 'touchmove', preventDefault);\n                            documentListenerAdded = false;\n                        }\n                    }\n                    else {\n                        body.style.overflow = bodyInfo.initialOverflow;\n                    }\n                }\n                else {\n                    bodies.set(body, {\n                        counter: bodyInfo.counter - 1,\n                        initialOverflow: bodyInfo.initialOverflow,\n                    });\n                }\n            }\n        };\n        useEffect(function () {\n            var body = getClosestBody(elementRef.current);\n            if (!body) {\n                return;\n            }\n            if (locked) {\n                lock(body);\n            }\n            else {\n                unlock(body);\n            }\n        }, [locked, elementRef.current]);\n        // clean up, on un-mount\n        useEffect(function () {\n            var body = getClosestBody(elementRef.current);\n            if (!body) {\n                return;\n            }\n            return function () {\n                unlock(body);\n            };\n        }, []);\n    };\n","export var noop = function () { };\nexport function on(obj) {\n    var args = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        args[_i - 1] = arguments[_i];\n    }\n    if (obj && obj.addEventListener) {\n        obj.addEventListener.apply(obj, args);\n    }\n}\nexport function off(obj) {\n    var args = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        args[_i - 1] = arguments[_i];\n    }\n    if (obj && obj.removeEventListener) {\n        obj.removeEventListener.apply(obj, args);\n    }\n}\nexport var isBrowser = typeof window !== 'undefined';\nexport var isNavigator = typeof navigator !== 'undefined';\n","import * as React from 'react';\nimport { useMemo } from 'react';\nimport { PresenceContext } from '../../context/PresenceContext.js';\nimport { useConstant } from '../../utils/use-constant.js';\n\nvar presenceId = 0;\nfunction getPresenceId() {\n    var id = presenceId;\n    presenceId++;\n    return id;\n}\nvar PresenceChild = function (_a) {\n    var children = _a.children, initial = _a.initial, isPresent = _a.isPresent, onExitComplete = _a.onExitComplete, custom = _a.custom, presenceAffectsLayout = _a.presenceAffectsLayout;\n    var presenceChildren = useConstant(newChildrenMap);\n    var id = useConstant(getPresenceId);\n    var context = useMemo(function () { return ({\n        id: id,\n        initial: initial,\n        isPresent: isPresent,\n        custom: custom,\n        onExitComplete: function (childId) {\n            presenceChildren.set(childId, true);\n            var allComplete = true;\n            presenceChildren.forEach(function (isComplete) {\n                if (!isComplete)\n                    allComplete = false;\n            });\n            allComplete && (onExitComplete === null || onExitComplete === void 0 ? void 0 : onExitComplete());\n        },\n        register: function (childId) {\n            presenceChildren.set(childId, false);\n            return function () { return presenceChildren.delete(childId); };\n        },\n    }); }, \n    /**\n     * If the presence of a child affects the layout of the components around it,\n     * we want to make a new context value to ensure they get re-rendered\n     * so they can detect that layout change.\n     */\n    presenceAffectsLayout ? undefined : [isPresent]);\n    useMemo(function () {\n        presenceChildren.forEach(function (_, key) { return presenceChildren.set(key, false); });\n    }, [isPresent]);\n    /**\n     * If there's no `motion` components to fire exit animations, we want to remove this\n     * component immediately.\n     */\n    React.useEffect(function () {\n        !isPresent && !presenceChildren.size && (onExitComplete === null || onExitComplete === void 0 ? void 0 : onExitComplete());\n    }, [isPresent]);\n    return (React.createElement(PresenceContext.Provider, { value: context }, children));\n};\nfunction newChildrenMap() {\n    return new Map();\n}\n\nexport { PresenceChild };\n","import { __spreadArray, __read } from 'tslib';\nimport * as React from 'react';\nimport { useContext, useRef, cloneElement, Children, isValidElement } from 'react';\nimport { useForceUpdate } from '../../utils/use-force-update.js';\nimport { PresenceChild } from './PresenceChild.js';\nimport { SharedLayoutContext, isSharedLayout } from '../../context/SharedLayoutContext.js';\n\nfunction getChildKey(child) {\n    return child.key || \"\";\n}\nfunction updateChildLookup(children, allChildren) {\n    var seenChildren = process.env.NODE_ENV !== \"production\" ? new Set() : null;\n    children.forEach(function (child) {\n        var key = getChildKey(child);\n        if (process.env.NODE_ENV !== \"production\" && seenChildren) {\n            if (seenChildren.has(key)) {\n                console.warn(\"Children of AnimatePresence require unique keys. \\\"\" + key + \"\\\" is a duplicate.\");\n            }\n            seenChildren.add(key);\n        }\n        allChildren.set(key, child);\n    });\n}\nfunction onlyElements(children) {\n    var filtered = [];\n    // We use forEach here instead of map as map mutates the component key by preprending `.$`\n    Children.forEach(children, function (child) {\n        if (isValidElement(child))\n            filtered.push(child);\n    });\n    return filtered;\n}\n/**\n * `AnimatePresence` enables the animation of components that have been removed from the tree.\n *\n * When adding/removing more than a single child, every child **must** be given a unique `key` prop.\n *\n * @library\n *\n * Any `Frame` components that have an `exit` property defined will animate out when removed from\n * the tree.\n *\n * ```jsx\n * import { Frame, AnimatePresence } from 'framer'\n *\n * // As items are added and removed from `items`\n * export function Items({ items }) {\n *   return (\n *     <AnimatePresence>\n *       {items.map(item => (\n *         <Frame\n *           key={item.id}\n *           initial={{ opacity: 0 }}\n *           animate={{ opacity: 1 }}\n *           exit={{ opacity: 0 }}\n *         />\n *       ))}\n *     </AnimatePresence>\n *   )\n * }\n * ```\n *\n * You can sequence exit animations throughout a tree using variants.\n *\n * @motion\n *\n * Any `motion` components that have an `exit` property defined will animate out when removed from\n * the tree.\n *\n * ```jsx\n * import { motion, AnimatePresence } from 'framer-motion'\n *\n * export const Items = ({ items }) => (\n *   <AnimatePresence>\n *     {items.map(item => (\n *       <motion.div\n *         key={item.id}\n *         initial={{ opacity: 0 }}\n *         animate={{ opacity: 1 }}\n *         exit={{ opacity: 0 }}\n *       />\n *     ))}\n *   </AnimatePresence>\n * )\n * ```\n *\n * You can sequence exit animations throughout a tree using variants.\n *\n * If a child contains multiple `motion` components with `exit` props, it will only unmount the child\n * once all `motion` components have finished animating out. Likewise, any components using\n * `usePresence` all need to call `safeToRemove`.\n *\n * @public\n */\nvar AnimatePresence = function (_a) {\n    var children = _a.children, custom = _a.custom, _b = _a.initial, initial = _b === void 0 ? true : _b, onExitComplete = _a.onExitComplete, exitBeforeEnter = _a.exitBeforeEnter, _c = _a.presenceAffectsLayout, presenceAffectsLayout = _c === void 0 ? true : _c;\n    // We want to force a re-render once all exiting animations have finished. We\n    // either use a local forceRender function, or one from a parent context if it exists.\n    var forceRender = useForceUpdate();\n    var layoutContext = useContext(SharedLayoutContext);\n    if (isSharedLayout(layoutContext)) {\n        forceRender = layoutContext.forceUpdate;\n    }\n    var isInitialRender = useRef(true);\n    // Filter out any children that aren't ReactElements. We can only track ReactElements with a props.key\n    var filteredChildren = onlyElements(children);\n    // Keep a living record of the children we're actually rendering so we\n    // can diff to figure out which are entering and exiting\n    var presentChildren = useRef(filteredChildren);\n    // A lookup table to quickly reference components by key\n    var allChildren = useRef(new Map())\n        .current;\n    // A living record of all currently exiting components.\n    var exiting = useRef(new Set()).current;\n    updateChildLookup(filteredChildren, allChildren);\n    // If this is the initial component render, just deal with logic surrounding whether\n    // we play onMount animations or not.\n    if (isInitialRender.current) {\n        isInitialRender.current = false;\n        return (React.createElement(React.Fragment, null, filteredChildren.map(function (child) { return (React.createElement(PresenceChild, { key: getChildKey(child), isPresent: true, initial: initial ? undefined : false, presenceAffectsLayout: presenceAffectsLayout }, child)); })));\n    }\n    // If this is a subsequent render, deal with entering and exiting children\n    var childrenToRender = __spreadArray([], __read(filteredChildren));\n    // Diff the keys of the currently-present and target children to update our\n    // exiting list.\n    var presentKeys = presentChildren.current.map(getChildKey);\n    var targetKeys = filteredChildren.map(getChildKey);\n    // Diff the present children with our target children and mark those that are exiting\n    var numPresent = presentKeys.length;\n    for (var i = 0; i < numPresent; i++) {\n        var key = presentKeys[i];\n        if (targetKeys.indexOf(key) === -1) {\n            exiting.add(key);\n        }\n        else {\n            // In case this key has re-entered, remove from the exiting list\n            exiting.delete(key);\n        }\n    }\n    // If we currently have exiting children, and we're deferring rendering incoming children\n    // until after all current children have exiting, empty the childrenToRender array\n    if (exitBeforeEnter && exiting.size) {\n        childrenToRender = [];\n    }\n    // Loop through all currently exiting components and clone them to overwrite `animate`\n    // with any `exit` prop they might have defined.\n    exiting.forEach(function (key) {\n        // If this component is actually entering again, early return\n        if (targetKeys.indexOf(key) !== -1)\n            return;\n        var child = allChildren.get(key);\n        if (!child)\n            return;\n        var insertionIndex = presentKeys.indexOf(key);\n        var onExit = function () {\n            allChildren.delete(key);\n            exiting.delete(key);\n            // Remove this child from the present children\n            var removeIndex = presentChildren.current.findIndex(function (presentChild) { return presentChild.key === key; });\n            presentChildren.current.splice(removeIndex, 1);\n            // Defer re-rendering until all exiting children have indeed left\n            if (!exiting.size) {\n                presentChildren.current = filteredChildren;\n                forceRender();\n                onExitComplete && onExitComplete();\n            }\n        };\n        childrenToRender.splice(insertionIndex, 0, React.createElement(PresenceChild, { key: getChildKey(child), isPresent: false, onExitComplete: onExit, custom: custom, presenceAffectsLayout: presenceAffectsLayout }, child));\n    });\n    // Add `MotionContext` even to children that don't need it to ensure we're rendering\n    // the same tree between renders\n    childrenToRender = childrenToRender.map(function (child) {\n        var key = child.key;\n        return exiting.has(key) ? (child) : (React.createElement(PresenceChild, { key: getChildKey(child), isPresent: true, presenceAffectsLayout: presenceAffectsLayout }, child));\n    });\n    presentChildren.current = childrenToRender;\n    if (process.env.NODE_ENV !== \"production\" &&\n        exitBeforeEnter &&\n        childrenToRender.length > 1) {\n        console.warn(\"You're attempting to animate multiple children within AnimatePresence, but its exitBeforeEnter prop is set to true. This will lead to odd visual behaviour.\");\n    }\n    return (React.createElement(React.Fragment, null, exiting.size\n        ? childrenToRender\n        : childrenToRender.map(function (child) { return cloneElement(child); })));\n};\n\nexport { AnimatePresence };\n","import { __read } from 'tslib';\nimport { useCallback, useRef, useState } from 'react';\nimport { useUnmountEffect } from './use-unmount-effect.js';\n\nfunction useForceUpdate() {\n    var unloadingRef = useRef(false);\n    var _a = __read(useState(0), 2), forcedRenderCount = _a[0], setForcedRenderCount = _a[1];\n    useUnmountEffect(function () { return (unloadingRef.current = true); });\n    return useCallback(function () {\n        !unloadingRef.current && setForcedRenderCount(forcedRenderCount + 1);\n    }, [forcedRenderCount]);\n}\n\nexport { useForceUpdate };\n","import { useRef } from 'react';\nexport function useFirstMountState() {\n    var isFirst = useRef(true);\n    if (isFirst.current) {\n        isFirst.current = false;\n        return true;\n    }\n    return isFirst.current;\n}\n","var g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || new Function(\"return this\")();\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n"],"sourceRoot":""}