{"version":3,"sources":["webpack:///./node_modules/react-use/esm/misc/util.js","webpack:///./node_modules/body-scroll-lock/lib/bodyScrollLock.esm.js","webpack:///./node_modules/lodash/_Symbol.js","webpack:///./node_modules/lodash/isNumber.js","webpack:///./node_modules/lodash/_baseGetTag.js","webpack:///./node_modules/lodash/_root.js","webpack:///./node_modules/lodash/_freeGlobal.js","webpack:///./node_modules/lodash/_getRawTag.js","webpack:///./node_modules/lodash/_objectToString.js","webpack:///./node_modules/lodash/isObjectLike.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/render/dom/projection/utils.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/framer-motion/dist/es/context/SharedLayoutContext.js","webpack:///./node_modules/framer-motion/dist/es/components/AnimatePresence/index.js","webpack:///./node_modules/framer-motion/dist/es/utils/use-force-update.js"],"names":["on","obj","args","_i","arguments","length","addEventListener","apply","off","removeEventListener","isBrowser","window","hasPassiveEvents","passiveTestOptions","isIosDevice","navigator","platform","test","maxTouchPoints","locks","documentListenerAdded","initialClientY","previousBodyOverflowSetting","previousBodyPaddingRight","allowTouchMove","el","some","lock","options","preventDefault","rawEvent","e","event","target","touches","restoreOverflowSetting","undefined","document","body","style","paddingRight","overflow","disableBodyScroll","targetElement","concat","arr","Array","isArray","i","arr2","from","_toConsumableArray","ontouchstart","targetTouches","clientY","ontouchmove","scrollTop","scrollHeight","clientHeight","isTargetElementTotallyScrolled","stopPropagation","handleScroll","passive","_reserveScrollBarGap","reserveScrollBarGap","scrollBarGap","innerWidth","documentElement","clientWidth","setOverflowHidden","console","error","enableBodyScroll","filter","Symbol","module","exports","baseGetTag","isObjectLike","value","getRawTag","objectToString","symToStringTag","toStringTag","Object","freeGlobal","freeSelf","self","root","Function","global","objectProto","prototype","hasOwnProperty","nativeObjectToString","toString","isOwn","call","tag","unmasked","result","getClosestBody","tagName","document_1","contentDocument","offsetParent","bodies","Map","doc","locked","elementRef","bodyRef","unlock","bodyInfo","get","counter","delete","initialOverflow","set","current","_locked","_elementRef","presenceId","getPresenceId","id","PresenceChild","_a","children","initial","isPresent","onExitComplete","custom","presenceAffectsLayout","presenceChildren","newChildrenMap","context","childId","allComplete","forEach","isComplete","register","_","key","size","PresenceContext","Provider","isProjecting","visualElement","projection","isEnabled","shouldResetTransform","updateLayoutMeasurement","layoutState","getLayoutState","notifyBeforeLayoutMeasure","layout","isHydrated","measureViewportBox","layoutCorrected","notifyLayoutMeasure","prevViewportBox","update","rebaseProjectionTarget","unresolvedJobs","Set","pushJob","stack","job","pointer","push","executeJob","defaultHandler","layoutReady","child","notifyLayoutReady","createBatcher","queue","add","flush","callback","_b","parent","read","write","order","sort","ancestors","collectProjectingAncestors","element","resetTransform","restoreTransform","presence","Present","preRender","render","postRender","assignProjectionToSnapshot","clear","reads","writes","setRead","setWrite","numStacks","flushLayout","SharedLayoutContext","getChildKey","AnimatePresence","exitBeforeEnter","_c","forceRender","unloadingRef","forcedRenderCount","setForcedRenderCount","useForceUpdate","layoutContext","forceUpdate","isInitialRender","filteredChildren","filtered","onlyElements","presentChildren","allChildren","exiting","updateChildLookup","map","childrenToRender","presentKeys","targetKeys","numPresent","indexOf","insertionIndex","splice","removeIndex","findIndex","presentChild","has"],"mappings":"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","file":"defaultVendors~AplLandscaperListing~Header~MemberStoreHeader-8773a7ab5c11ebb046d9.js","sourcesContent":["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","function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }\n\n// Older browsers don't support event options, feature detect it.\n\n// Adopted and modified solution from Bohdan Didukh (2017)\n// https://stackoverflow.com/questions/41594997/ios-10-safari-prevent-scrolling-behind-a-fixed-overlay-and-maintain-scroll-posi\n\nvar hasPassiveEvents = false;\nif (typeof window !== 'undefined') {\n  var passiveTestOptions = {\n    get passive() {\n      hasPassiveEvents = true;\n      return undefined;\n    }\n  };\n  window.addEventListener('testPassive', null, passiveTestOptions);\n  window.removeEventListener('testPassive', null, passiveTestOptions);\n}\n\nvar isIosDevice = typeof window !== 'undefined' && window.navigator && window.navigator.platform && (/iP(ad|hone|od)/.test(window.navigator.platform) || window.navigator.platform === 'MacIntel' && window.navigator.maxTouchPoints > 1);\n\n\nvar locks = [];\nvar documentListenerAdded = false;\nvar initialClientY = -1;\nvar previousBodyOverflowSetting = void 0;\nvar previousBodyPaddingRight = void 0;\n\n// returns true if `el` should be allowed to receive touchmove events.\nvar allowTouchMove = function allowTouchMove(el) {\n  return locks.some(function (lock) {\n    if (lock.options.allowTouchMove && lock.options.allowTouchMove(el)) {\n      return true;\n    }\n\n    return false;\n  });\n};\n\nvar preventDefault = function preventDefault(rawEvent) {\n  var e = rawEvent || window.event;\n\n  // For the case whereby consumers adds a touchmove event listener to document.\n  // Recall that we do document.addEventListener('touchmove', preventDefault, { passive: false })\n  // in disableBodyScroll - so if we provide this opportunity to allowTouchMove, then\n  // the touchmove event on document will break.\n  if (allowTouchMove(e.target)) {\n    return true;\n  }\n\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) return true;\n\n  if (e.preventDefault) e.preventDefault();\n\n  return false;\n};\n\nvar setOverflowHidden = function setOverflowHidden(options) {\n  // If previousBodyPaddingRight is already set, don't set it again.\n  if (previousBodyPaddingRight === undefined) {\n    var _reserveScrollBarGap = !!options && options.reserveScrollBarGap === true;\n    var scrollBarGap = window.innerWidth - document.documentElement.clientWidth;\n\n    if (_reserveScrollBarGap && scrollBarGap > 0) {\n      previousBodyPaddingRight = document.body.style.paddingRight;\n      document.body.style.paddingRight = scrollBarGap + 'px';\n    }\n  }\n\n  // If previousBodyOverflowSetting is already set, don't set it again.\n  if (previousBodyOverflowSetting === undefined) {\n    previousBodyOverflowSetting = document.body.style.overflow;\n    document.body.style.overflow = 'hidden';\n  }\n};\n\nvar restoreOverflowSetting = function restoreOverflowSetting() {\n  if (previousBodyPaddingRight !== undefined) {\n    document.body.style.paddingRight = previousBodyPaddingRight;\n\n    // Restore previousBodyPaddingRight to undefined so setOverflowHidden knows it\n    // can be set again.\n    previousBodyPaddingRight = undefined;\n  }\n\n  if (previousBodyOverflowSetting !== undefined) {\n    document.body.style.overflow = previousBodyOverflowSetting;\n\n    // Restore previousBodyOverflowSetting to undefined\n    // so setOverflowHidden knows it can be set again.\n    previousBodyOverflowSetting = undefined;\n  }\n};\n\n// https://developer.mozilla.org/en-US/docs/Web/API/Element/scrollHeight#Problems_and_solutions\nvar isTargetElementTotallyScrolled = function isTargetElementTotallyScrolled(targetElement) {\n  return targetElement ? targetElement.scrollHeight - targetElement.scrollTop <= targetElement.clientHeight : false;\n};\n\nvar handleScroll = function handleScroll(event, targetElement) {\n  var clientY = event.targetTouches[0].clientY - initialClientY;\n\n  if (allowTouchMove(event.target)) {\n    return false;\n  }\n\n  if (targetElement && targetElement.scrollTop === 0 && clientY > 0) {\n    // element is at the top of its scroll.\n    return preventDefault(event);\n  }\n\n  if (isTargetElementTotallyScrolled(targetElement) && clientY < 0) {\n    // element is at the bottom of its scroll.\n    return preventDefault(event);\n  }\n\n  event.stopPropagation();\n  return true;\n};\n\nexport var disableBodyScroll = function disableBodyScroll(targetElement, options) {\n  // targetElement must be provided\n  if (!targetElement) {\n    // eslint-disable-next-line no-console\n    console.error('disableBodyScroll unsuccessful - targetElement must be provided when calling disableBodyScroll on IOS devices.');\n    return;\n  }\n\n  // disableBodyScroll must not have been called on this targetElement before\n  if (locks.some(function (lock) {\n    return lock.targetElement === targetElement;\n  })) {\n    return;\n  }\n\n  var lock = {\n    targetElement: targetElement,\n    options: options || {}\n  };\n\n  locks = [].concat(_toConsumableArray(locks), [lock]);\n\n  if (isIosDevice) {\n    targetElement.ontouchstart = function (event) {\n      if (event.targetTouches.length === 1) {\n        // detect single touch.\n        initialClientY = event.targetTouches[0].clientY;\n      }\n    };\n    targetElement.ontouchmove = function (event) {\n      if (event.targetTouches.length === 1) {\n        // detect single touch.\n        handleScroll(event, targetElement);\n      }\n    };\n\n    if (!documentListenerAdded) {\n      document.addEventListener('touchmove', preventDefault, hasPassiveEvents ? { passive: false } : undefined);\n      documentListenerAdded = true;\n    }\n  } else {\n    setOverflowHidden(options);\n  }\n};\n\nexport var clearAllBodyScrollLocks = function clearAllBodyScrollLocks() {\n  if (isIosDevice) {\n    // Clear all locks ontouchstart/ontouchmove handlers, and the references.\n    locks.forEach(function (lock) {\n      lock.targetElement.ontouchstart = null;\n      lock.targetElement.ontouchmove = null;\n    });\n\n    if (documentListenerAdded) {\n      document.removeEventListener('touchmove', preventDefault, hasPassiveEvents ? { passive: false } : undefined);\n      documentListenerAdded = false;\n    }\n\n    // Reset initial clientY.\n    initialClientY = -1;\n  } else {\n    restoreOverflowSetting();\n  }\n\n  locks = [];\n};\n\nexport var enableBodyScroll = function enableBodyScroll(targetElement) {\n  if (!targetElement) {\n    // eslint-disable-next-line no-console\n    console.error('enableBodyScroll unsuccessful - targetElement must be provided when calling enableBodyScroll on IOS devices.');\n    return;\n  }\n\n  locks = locks.filter(function (lock) {\n    return lock.targetElement !== targetElement;\n  });\n\n  if (isIosDevice) {\n    targetElement.ontouchstart = null;\n    targetElement.ontouchmove = null;\n\n    if (documentListenerAdded && locks.length === 0) {\n      document.removeEventListener('touchmove', preventDefault, hasPassiveEvents ? { passive: false } : undefined);\n      documentListenerAdded = false;\n    }\n  } else if (!locks.length) {\n    restoreOverflowSetting();\n  }\n};\n\n","var root = require('./_root');\n\n/** Built-in value references. */\nvar Symbol = root.Symbol;\n\nmodule.exports = Symbol;\n","var baseGetTag = require('./_baseGetTag'),\n    isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar numberTag = '[object Number]';\n\n/**\n * Checks if `value` is classified as a `Number` primitive or object.\n *\n * **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are\n * classified as numbers, use the `_.isFinite` method.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a number, else `false`.\n * @example\n *\n * _.isNumber(3);\n * // => true\n *\n * _.isNumber(Number.MIN_VALUE);\n * // => true\n *\n * _.isNumber(Infinity);\n * // => true\n *\n * _.isNumber('3');\n * // => false\n */\nfunction isNumber(value) {\n  return typeof value == 'number' ||\n    (isObjectLike(value) && baseGetTag(value) == numberTag);\n}\n\nmodule.exports = isNumber;\n","var Symbol = require('./_Symbol'),\n    getRawTag = require('./_getRawTag'),\n    objectToString = require('./_objectToString');\n\n/** `Object#toString` result references. */\nvar nullTag = '[object Null]',\n    undefinedTag = '[object Undefined]';\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n  if (value == null) {\n    return value === undefined ? undefinedTag : nullTag;\n  }\n  return (symToStringTag && symToStringTag in Object(value))\n    ? getRawTag(value)\n    : objectToString(value);\n}\n\nmodule.exports = baseGetTag;\n","var freeGlobal = require('./_freeGlobal');\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\nmodule.exports = root;\n","/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\nmodule.exports = freeGlobal;\n","var Symbol = require('./_Symbol');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n  var isOwn = hasOwnProperty.call(value, symToStringTag),\n      tag = value[symToStringTag];\n\n  try {\n    value[symToStringTag] = undefined;\n    var unmasked = true;\n  } catch (e) {}\n\n  var result = nativeObjectToString.call(value);\n  if (unmasked) {\n    if (isOwn) {\n      value[symToStringTag] = tag;\n    } else {\n      delete value[symToStringTag];\n    }\n  }\n  return result;\n}\n\nmodule.exports = getRawTag;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n  return nativeObjectToString.call(value);\n}\n\nmodule.exports = objectToString;\n","/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return value != null && typeof value == 'object';\n}\n\nmodule.exports = isObjectLike;\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 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","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 { 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","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"],"sourceRoot":""}