{"version":3,"sources":["webpack:///./node_modules/prop-types/index.js","webpack:///./node_modules/framer-motion/dist/es/context/SharedLayoutContext.js","webpack:///./node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js","webpack:///./node_modules/framer-motion/dist/es/render/dom/utils/batch-layout.js","webpack:///./node_modules/redux-devtools-extension/index.js","webpack:///./node_modules/framer-motion/dist/es/components/AnimateSharedLayout/utils/batcher.js","webpack:///./node_modules/react-use/esm/useLockBodyScroll.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/misc/util.js","webpack:///./node_modules/querystring-es3/index.js","webpack:///./node_modules/prop-types/factoryWithThrowingShims.js","webpack:///./node_modules/prop-types/lib/ReactPropTypesSecret.js","webpack:///./node_modules/framer-motion/dist/es/render/dom/projection/utils.js","webpack:///./node_modules/querystring-es3/decode.js","webpack:///./node_modules/querystring-es3/encode.js"],"names":["module","exports","SharedLayoutContext","FramerTreeLayoutContext","isSharedLayout","context","forceUpdate","reactIs","REACT_STATICS","childContextTypes","contextType","contextTypes","defaultProps","displayName","getDefaultProps","getDerivedStateFromError","getDerivedStateFromProps","mixins","propTypes","type","KNOWN_STATICS","name","length","prototype","caller","callee","arguments","arity","MEMO_STATICS","compare","TYPE_STATICS","getStatics","component","isMemo","ForwardRef","render","Memo","defineProperty","Object","getOwnPropertyNames","getOwnPropertySymbols","getOwnPropertyDescriptor","getPrototypeOf","objectPrototype","hoistNonReactStatics","targetComponent","sourceComponent","blacklist","inheritedComponent","keys","concat","targetStatics","sourceStatics","i","key","descriptor","e","unresolvedJobs","Set","pushJob","stack","job","pointer","push","batchLayout","callback","add","delete","flushLayout","size","reads","writes","setRead","setWrite","forEach","clear","numStacks","executeJob","compose","__esModule","composeWithDevTools","window","__REDUX_DEVTOOLS_EXTENSION_COMPOSE__","apply","devToolsEnhancer","__REDUX_DEVTOOLS_EXTENSION__","noop","defaultHandler","layoutReady","child","notifyLayoutReady","createBatcher","queue","flush","_a","_b","parent","read","write","order","Array","from","sort","ancestors","element","resetTransform","restoreTransform","isPresent","presence","Present","preRender","postRender","assignProjectionToSnapshot","prevViewportBox","projection","target","getClosestBody","el","tagName","document_1","contentDocument","body","offsetParent","preventDefault","rawEvent","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","presenceId","getPresenceId","id","PresenceChild","children","initial","onExitComplete","custom","presenceAffectsLayout","presenceChildren","newChildrenMap","childId","allComplete","isComplete","register","_","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","on","obj","args","_i","addEventListener","off","removeEventListener","isBrowser","decode","parse","encode","stringify","ReactPropTypesSecret","emptyFunction","emptyFunctionWithReset","resetWarningCache","shim","props","propName","componentName","location","propFullName","secret","err","Error","getShim","isRequired","ReactPropTypes","array","bool","func","number","object","string","symbol","any","arrayOf","elementType","instanceOf","node","objectOf","oneOf","oneOfType","shape","exact","checkPropTypes","PropTypes","isProjecting","visualElement","isEnabled","shouldResetTransform","collectProjectingAncestors","collectProjectingChildren","addChild","updateLayoutMeasurement","layoutState","getLayoutState","notifyBeforeLayoutMeasure","layout","isHydrated","measureViewportBox","layoutCorrected","notifyLayoutMeasure","update","rebaseProjectionTarget","snapshotViewportBox","hasOwnProperty","prop","call","qs","sep","eq","options","regexp","split","maxKeys","len","kstr","vstr","k","v","x","replace","idx","substr","decodeURIComponent","isArray","xs","toString","stringifyPrimitive","isFinite","objectKeys","ks","encodeURIComponent","join","f","res"],"mappings":"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","file":"vendors~SiteHeader-5d80cce36d619d016c79.js","sourcesContent":["/**\n * Copyright (c) 2013-present, Facebook, Inc.\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\nif (process.env.NODE_ENV !== 'production') {\n  var ReactIs = require('react-is');\n\n  // By explicitly using `prop-types` you are opting into new development behavior.\n  // http://fb.me/prop-types-in-prod\n  var throwOnDirectAccess = true;\n  module.exports = require('./factoryWithTypeCheckers')(ReactIs.isElement, throwOnDirectAccess);\n} else {\n  // By explicitly using `prop-types` you are opting into new production behavior.\n  // http://fb.me/prop-types-in-prod\n  module.exports = require('./factoryWithThrowingShims')();\n}\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 reactIs = require('react-is');\n\n/**\n * Copyright 2015, Yahoo! Inc.\n * Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.\n */\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 = {};\nTYPE_STATICS[reactIs.ForwardRef] = FORWARD_REF_STATICS;\nTYPE_STATICS[reactIs.Memo] = MEMO_STATICS;\n\nfunction getStatics(component) {\n  // React v16.11 and below\n  if (reactIs.isMemo(component)) {\n    return MEMO_STATICS;\n  } // React v16.12 and above\n\n\n  return TYPE_STATICS[component['$$typeof']] || REACT_STATICS;\n}\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, blacklist) {\n  if (typeof sourceComponent !== 'string') {\n    // don't hoist over string (html) components\n    if (objectPrototype) {\n      var inheritedComponent = getPrototypeOf(sourceComponent);\n\n      if (inheritedComponent && inheritedComponent !== objectPrototype) {\n        hoistNonReactStatics(targetComponent, inheritedComponent, blacklist);\n      }\n    }\n\n    var keys = getOwnPropertyNames(sourceComponent);\n\n    if (getOwnPropertySymbols) {\n      keys = keys.concat(getOwnPropertySymbols(sourceComponent));\n    }\n\n    var targetStatics = getStatics(targetComponent);\n    var sourceStatics = getStatics(sourceComponent);\n\n    for (var i = 0; i < keys.length; ++i) {\n      var key = keys[i];\n\n      if (!KNOWN_STATICS[key] && !(blacklist && blacklist[key]) && !(sourceStatics && sourceStatics[key]) && !(targetStatics && targetStatics[key])) {\n        var descriptor = getOwnPropertyDescriptor(sourceComponent, key);\n\n        try {\n          // Avoid failures from read-only properties\n          defineProperty(targetComponent, key, descriptor);\n        } catch (e) {}\n      }\n    }\n  }\n\n  return targetComponent;\n}\n\nmodule.exports = hoistNonReactStatics;\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","'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","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","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","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","'use strict';\n\nexports.decode = exports.parse = require('./decode');\nexports.encode = exports.stringify = require('./encode');\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\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\n'use strict';\n\nvar ReactPropTypesSecret = require('./lib/ReactPropTypesSecret');\n\nfunction emptyFunction() {}\nfunction emptyFunctionWithReset() {}\nemptyFunctionWithReset.resetWarningCache = emptyFunction;\n\nmodule.exports = function() {\n  function shim(props, propName, componentName, location, propFullName, secret) {\n    if (secret === ReactPropTypesSecret) {\n      // It is still safe when called from React.\n      return;\n    }\n    var err = new Error(\n      'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +\n      'Use PropTypes.checkPropTypes() to call them. ' +\n      'Read more at http://fb.me/use-check-prop-types'\n    );\n    err.name = 'Invariant Violation';\n    throw err;\n  };\n  shim.isRequired = shim;\n  function getShim() {\n    return shim;\n  };\n  // Important!\n  // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.\n  var ReactPropTypes = {\n    array: shim,\n    bool: shim,\n    func: shim,\n    number: shim,\n    object: shim,\n    string: shim,\n    symbol: shim,\n\n    any: shim,\n    arrayOf: getShim,\n    element: shim,\n    elementType: shim,\n    instanceOf: getShim,\n    node: shim,\n    objectOf: getShim,\n    oneOf: getShim,\n    oneOfType: getShim,\n    shape: getShim,\n    exact: getShim,\n\n    checkPropTypes: emptyFunctionWithReset,\n    resetWarningCache: emptyFunction\n  };\n\n  ReactPropTypes.PropTypes = ReactPropTypes;\n\n  return ReactPropTypes;\n};\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\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\n'use strict';\n\nvar ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';\n\nmodule.exports = ReactPropTypesSecret;\n","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","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\n// If obj.hasOwnProperty has been overridden, then calling\n// obj.hasOwnProperty(prop) will break.\n// See: https://github.com/joyent/node/issues/1707\nfunction hasOwnProperty(obj, prop) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n}\n\nmodule.exports = function(qs, sep, eq, options) {\n  sep = sep || '&';\n  eq = eq || '=';\n  var obj = {};\n\n  if (typeof qs !== 'string' || qs.length === 0) {\n    return obj;\n  }\n\n  var regexp = /\\+/g;\n  qs = qs.split(sep);\n\n  var maxKeys = 1000;\n  if (options && typeof options.maxKeys === 'number') {\n    maxKeys = options.maxKeys;\n  }\n\n  var len = qs.length;\n  // maxKeys <= 0 means that we should not limit keys count\n  if (maxKeys > 0 && len > maxKeys) {\n    len = maxKeys;\n  }\n\n  for (var i = 0; i < len; ++i) {\n    var x = qs[i].replace(regexp, '%20'),\n        idx = x.indexOf(eq),\n        kstr, vstr, k, v;\n\n    if (idx >= 0) {\n      kstr = x.substr(0, idx);\n      vstr = x.substr(idx + 1);\n    } else {\n      kstr = x;\n      vstr = '';\n    }\n\n    k = decodeURIComponent(kstr);\n    v = decodeURIComponent(vstr);\n\n    if (!hasOwnProperty(obj, k)) {\n      obj[k] = v;\n    } else if (isArray(obj[k])) {\n      obj[k].push(v);\n    } else {\n      obj[k] = [obj[k], v];\n    }\n  }\n\n  return obj;\n};\n\nvar isArray = Array.isArray || function (xs) {\n  return Object.prototype.toString.call(xs) === '[object Array]';\n};\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nvar stringifyPrimitive = function(v) {\n  switch (typeof v) {\n    case 'string':\n      return v;\n\n    case 'boolean':\n      return v ? 'true' : 'false';\n\n    case 'number':\n      return isFinite(v) ? v : '';\n\n    default:\n      return '';\n  }\n};\n\nmodule.exports = function(obj, sep, eq, name) {\n  sep = sep || '&';\n  eq = eq || '=';\n  if (obj === null) {\n    obj = undefined;\n  }\n\n  if (typeof obj === 'object') {\n    return map(objectKeys(obj), function(k) {\n      var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;\n      if (isArray(obj[k])) {\n        return map(obj[k], function(v) {\n          return ks + encodeURIComponent(stringifyPrimitive(v));\n        }).join(sep);\n      } else {\n        return ks + encodeURIComponent(stringifyPrimitive(obj[k]));\n      }\n    }).join(sep);\n\n  }\n\n  if (!name) return '';\n  return encodeURIComponent(stringifyPrimitive(name)) + eq +\n         encodeURIComponent(stringifyPrimitive(obj));\n};\n\nvar isArray = Array.isArray || function (xs) {\n  return Object.prototype.toString.call(xs) === '[object Array]';\n};\n\nfunction map (xs, f) {\n  if (xs.map) return xs.map(f);\n  var res = [];\n  for (var i = 0; i < xs.length; i++) {\n    res.push(f(xs[i], i));\n  }\n  return res;\n}\n\nvar objectKeys = Object.keys || function (obj) {\n  var res = [];\n  for (var key in obj) {\n    if (Object.prototype.hasOwnProperty.call(obj, key)) res.push(key);\n  }\n  return res;\n};\n"],"sourceRoot":""}