{"version":3,"file":"static/chunks/app/(auth)/layout-5194e3057251f473.js","mappings":"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","sources":["webpack://_N_E/?7edb","webpack://_N_E/../../node_modules/framer-motion/dist/es/utils/use-is-mounted.mjs","webpack://_N_E/../../node_modules/framer-motion/dist/es/utils/use-force-update.mjs","webpack://_N_E/../../node_modules/framer-motion/dist/es/components/AnimatePresence/PopChild.mjs","webpack://_N_E/../../node_modules/framer-motion/dist/es/components/AnimatePresence/PresenceChild.mjs","webpack://_N_E/../../node_modules/framer-motion/dist/es/components/AnimatePresence/index.mjs","webpack://_N_E/./src/app/(auth)/layout.tsx","webpack://_N_E/../../node_modules/framer-motion/dist/es/context/LayoutGroupContext.mjs","webpack://_N_E/../../node_modules/framer-motion/dist/es/context/PresenceContext.mjs","webpack://_N_E/../../node_modules/framer-motion/dist/es/frameloop/data.mjs","webpack://_N_E/../../node_modules/framer-motion/dist/es/frameloop/on-next-frame.mjs","webpack://_N_E/../../node_modules/framer-motion/dist/es/frameloop/create-render-step.mjs","webpack://_N_E/../../node_modules/framer-motion/dist/es/frameloop/index.mjs","webpack://_N_E/../../node_modules/framer-motion/dist/es/utils/is-browser.mjs","webpack://_N_E/../../node_modules/framer-motion/dist/es/utils/use-constant.mjs","webpack://_N_E/../../node_modules/framer-motion/dist/es/utils/use-isomorphic-effect.mjs","webpack://_N_E/../../node_modules/framer-motion/dist/es/utils/use-unmount-effect.mjs"],"sourcesContent":["import(/* webpackMode: \"eager\" */ \"/codebuild/output/src2715070955/src/quickly-next/apps/frontend/src/app/(auth)/layout.tsx\");\n","import { useRef } from 'react';\nimport { useIsomorphicLayoutEffect } from './use-isomorphic-effect.mjs';\n\nfunction useIsMounted() {\n    const isMounted = useRef(false);\n    useIsomorphicLayoutEffect(() => {\n        isMounted.current = true;\n        return () => {\n            isMounted.current = false;\n        };\n    }, []);\n    return isMounted;\n}\n\nexport { useIsMounted };\n","import { sync } from '../frameloop/index.mjs';\nimport { useState, useCallback } from 'react';\nimport { useIsMounted } from './use-is-mounted.mjs';\n\nfunction useForceUpdate() {\n    const isMounted = useIsMounted();\n    const [forcedRenderCount, setForcedRenderCount] = useState(0);\n    const forceRender = useCallback(() => {\n        isMounted.current && setForcedRenderCount(forcedRenderCount + 1);\n    }, [forcedRenderCount]);\n    /**\n     * Defer this to the end of the next animation frame in case there are multiple\n     * synchronous calls.\n     */\n    const deferredForceRender = useCallback(() => sync.postRender(forceRender), [forceRender]);\n    return [deferredForceRender, forcedRenderCount];\n}\n\nexport { useForceUpdate };\n","import * as React from 'react';\nimport { useId, useRef, useInsertionEffect } from 'react';\n\n/**\n * Measurement functionality has to be within a separate component\n * to leverage snapshot lifecycle.\n */\nclass PopChildMeasure extends React.Component {\n    getSnapshotBeforeUpdate(prevProps) {\n        const element = this.props.childRef.current;\n        if (element && prevProps.isPresent && !this.props.isPresent) {\n            const size = this.props.sizeRef.current;\n            size.height = element.offsetHeight || 0;\n            size.width = element.offsetWidth || 0;\n            size.top = element.offsetTop;\n            size.left = element.offsetLeft;\n        }\n        return null;\n    }\n    /**\n     * Required with getSnapshotBeforeUpdate to stop React complaining.\n     */\n    componentDidUpdate() { }\n    render() {\n        return this.props.children;\n    }\n}\nfunction PopChild({ children, isPresent }) {\n    const id = useId();\n    const ref = useRef(null);\n    const size = useRef({\n        width: 0,\n        height: 0,\n        top: 0,\n        left: 0,\n    });\n    /**\n     * We create and inject a style block so we can apply this explicit\n     * sizing in a non-destructive manner by just deleting the style block.\n     *\n     * We can't apply size via render as the measurement happens\n     * in getSnapshotBeforeUpdate (post-render), likewise if we apply the\n     * styles directly on the DOM node, we might be overwriting\n     * styles set via the style prop.\n     */\n    useInsertionEffect(() => {\n        const { width, height, top, left } = size.current;\n        if (isPresent || !ref.current || !width || !height)\n            return;\n        ref.current.dataset.motionPopId = id;\n        const style = document.createElement(\"style\");\n        document.head.appendChild(style);\n        if (style.sheet) {\n            style.sheet.insertRule(`\n          [data-motion-pop-id=\"${id}\"] {\n            position: absolute !important;\n            width: ${width}px !important;\n            height: ${height}px !important;\n            top: ${top}px !important;\n            left: ${left}px !important;\n          }\n        `);\n        }\n        return () => {\n            document.head.removeChild(style);\n        };\n    }, [isPresent]);\n    return (React.createElement(PopChildMeasure, { isPresent: isPresent, childRef: ref, sizeRef: size }, React.cloneElement(children, { ref })));\n}\n\nexport { PopChild };\n","import * as React from 'react';\nimport { useId, useMemo } from 'react';\nimport { PresenceContext } from '../../context/PresenceContext.mjs';\nimport { useConstant } from '../../utils/use-constant.mjs';\nimport { PopChild } from './PopChild.mjs';\n\nconst PresenceChild = ({ children, initial, isPresent, onExitComplete, custom, presenceAffectsLayout, mode, }) => {\n    const presenceChildren = useConstant(newChildrenMap);\n    const id = useId();\n    const context = useMemo(() => ({\n        id,\n        initial,\n        isPresent,\n        custom,\n        onExitComplete: (childId) => {\n            presenceChildren.set(childId, true);\n            for (const isComplete of presenceChildren.values()) {\n                if (!isComplete)\n                    return; // can stop searching when any is incomplete\n            }\n            onExitComplete && onExitComplete();\n        },\n        register: (childId) => {\n            presenceChildren.set(childId, false);\n            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(() => {\n        presenceChildren.forEach((_, key) => 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(() => {\n        !isPresent &&\n            !presenceChildren.size &&\n            onExitComplete &&\n            onExitComplete();\n    }, [isPresent]);\n    if (mode === \"popLayout\") {\n        children = React.createElement(PopChild, { isPresent: isPresent }, children);\n    }\n    return (React.createElement(PresenceContext.Provider, { value: context }, children));\n};\nfunction newChildrenMap() {\n    return new Map();\n}\n\nexport { PresenceChild };\n","import * as React from 'react';\nimport { useContext, useRef, cloneElement, Children, isValidElement } from 'react';\nimport { useForceUpdate } from '../../utils/use-force-update.mjs';\nimport { useIsMounted } from '../../utils/use-is-mounted.mjs';\nimport { PresenceChild } from './PresenceChild.mjs';\nimport { LayoutGroupContext } from '../../context/LayoutGroupContext.mjs';\nimport { useIsomorphicLayoutEffect } from '../../utils/use-isomorphic-effect.mjs';\nimport { useUnmountEffect } from '../../utils/use-unmount-effect.mjs';\nimport { warnOnce } from '../../utils/warn-once.mjs';\n\nconst getChildKey = (child) => child.key || \"\";\nfunction updateChildLookup(children, allChildren) {\n    children.forEach((child) => {\n        const key = getChildKey(child);\n        allChildren.set(key, child);\n    });\n}\nfunction onlyElements(children) {\n    const filtered = [];\n    // We use forEach here instead of map as map mutates the component key by preprending `.$`\n    Children.forEach(children, (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 * 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 */\nconst AnimatePresence = ({ children, custom, initial = true, onExitComplete, exitBeforeEnter, presenceAffectsLayout = true, mode = \"sync\", }) => {\n    // Support deprecated exitBeforeEnter prop\n    if (exitBeforeEnter) {\n        mode = \"wait\";\n        if (process.env.NODE_ENV !== \"production\") {\n            warnOnce(false, \"Replace exitBeforeEnter with mode='wait'\");\n        }\n    }\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    let [forceRender] = useForceUpdate();\n    const forceRenderLayoutGroup = useContext(LayoutGroupContext).forceRender;\n    if (forceRenderLayoutGroup)\n        forceRender = forceRenderLayoutGroup;\n    const isMounted = useIsMounted();\n    // Filter out any children that aren't ReactElements. We can only track ReactElements with a props.key\n    const filteredChildren = onlyElements(children);\n    let childrenToRender = filteredChildren;\n    const exiting = new Set();\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    const presentChildren = useRef(childrenToRender);\n    // A lookup table to quickly reference components by key\n    const allChildren = useRef(new Map()).current;\n    // If this is the initial component render, just deal with logic surrounding whether\n    // we play onMount animations or not.\n    const isInitialRender = useRef(true);\n    useIsomorphicLayoutEffect(() => {\n        isInitialRender.current = false;\n        updateChildLookup(filteredChildren, allChildren);\n        presentChildren.current = childrenToRender;\n    });\n    useUnmountEffect(() => {\n        isInitialRender.current = true;\n        allChildren.clear();\n        exiting.clear();\n    });\n    if (isInitialRender.current) {\n        return (React.createElement(React.Fragment, null, childrenToRender.map((child) => (React.createElement(PresenceChild, { key: getChildKey(child), isPresent: true, initial: initial ? undefined : false, presenceAffectsLayout: presenceAffectsLayout, mode: mode }, child)))));\n    }\n    // If this is a subsequent render, deal with entering and exiting children\n    childrenToRender = [...childrenToRender];\n    // Diff the keys of the currently-present and target children to update our\n    // exiting list.\n    const presentKeys = presentChildren.current.map(getChildKey);\n    const targetKeys = filteredChildren.map(getChildKey);\n    // Diff the present children with our target children and mark those that are exiting\n    const numPresent = presentKeys.length;\n    for (let i = 0; i < numPresent; i++) {\n        const key = presentKeys[i];\n        if (targetKeys.indexOf(key) === -1) {\n            exiting.add(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 (mode === \"wait\" && 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((key) => {\n        // If this component is actually entering again, early return\n        if (targetKeys.indexOf(key) !== -1)\n            return;\n        const child = allChildren.get(key);\n        if (!child)\n            return;\n        const insertionIndex = presentKeys.indexOf(key);\n        const onExit = () => {\n            allChildren.delete(key);\n            exiting.delete(key);\n            // Remove this child from the present children\n            const removeIndex = presentChildren.current.findIndex((presentChild) => 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                if (isMounted.current === false)\n                    return;\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, mode: mode }, 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((child) => {\n        const key = child.key;\n        return exiting.has(key) ? (child) : (React.createElement(PresenceChild, { key: getChildKey(child), isPresent: true, presenceAffectsLayout: presenceAffectsLayout, mode: mode }, child));\n    });\n    if (process.env.NODE_ENV !== \"production\" &&\n        mode === \"wait\" &&\n        childrenToRender.length > 1) {\n        console.warn(`You're attempting to animate multiple children within AnimatePresence, but its mode is set to \"wait\". This will lead to odd visual behaviour.`);\n    }\n    return (React.createElement(React.Fragment, null, exiting.size\n        ? childrenToRender\n        : childrenToRender.map((child) => cloneElement(child))));\n};\n\nexport { AnimatePresence };\n","\"use client\";\n\nimport { AnimatePresence } from \"framer-motion\";\nimport { ReactNode } from \"react\";\n\nexport default function AuthLayout({ children }: { children: ReactNode }) {\n  return (\n    <AnimatePresence mode=\"wait\">\n      <div className=\"AuthLayout\">{children}</div>\n    </AnimatePresence>\n  );\n}\n","import { createContext } from 'react';\n\nconst LayoutGroupContext = createContext({});\n\nexport { LayoutGroupContext };\n","import { createContext } from 'react';\n\n/**\n * @public\n */\nconst PresenceContext = createContext(null);\n\nexport { PresenceContext };\n","const frameData = {\n    delta: 0,\n    timestamp: 0,\n};\n\nexport { frameData };\n","/*\n  Detect and load appropriate clock setting for the execution environment\n */\nconst defaultTimestep = (1 / 60) * 1000;\nconst getCurrentTime = typeof performance !== \"undefined\"\n    ? () => performance.now()\n    : () => Date.now();\nconst onNextFrame = typeof window !== \"undefined\"\n    ? (callback) => window.requestAnimationFrame(callback)\n    : (callback) => setTimeout(() => callback(getCurrentTime()), defaultTimestep);\n\nexport { defaultTimestep, onNextFrame };\n","function createRenderStep(runNextFrame) {\n    /**\n     * We create and reuse two arrays, one to queue jobs for the current frame\n     * and one for the next. We reuse to avoid triggering GC after x frames.\n     */\n    let toRun = [];\n    let toRunNextFrame = [];\n    /**\n     *\n     */\n    let numToRun = 0;\n    /**\n     * Track whether we're currently processing jobs in this step. This way\n     * we can decide whether to schedule new jobs for this frame or next.\n     */\n    let isProcessing = false;\n    let flushNextFrame = false;\n    /**\n     * A set of processes which were marked keepAlive when scheduled.\n     */\n    const toKeepAlive = new WeakSet();\n    const step = {\n        /**\n         * Schedule a process to run on the next frame.\n         */\n        schedule: (callback, keepAlive = false, immediate = false) => {\n            const addToCurrentFrame = immediate && isProcessing;\n            const buffer = addToCurrentFrame ? toRun : toRunNextFrame;\n            if (keepAlive)\n                toKeepAlive.add(callback);\n            // If the buffer doesn't already contain this callback, add it\n            if (buffer.indexOf(callback) === -1) {\n                buffer.push(callback);\n                // If we're adding it to the currently running buffer, update its measured size\n                if (addToCurrentFrame && isProcessing)\n                    numToRun = toRun.length;\n            }\n            return callback;\n        },\n        /**\n         * Cancel the provided callback from running on the next frame.\n         */\n        cancel: (callback) => {\n            const index = toRunNextFrame.indexOf(callback);\n            if (index !== -1)\n                toRunNextFrame.splice(index, 1);\n            toKeepAlive.delete(callback);\n        },\n        /**\n         * Execute all schedule callbacks.\n         */\n        process: (frameData) => {\n            /**\n             * If we're already processing we've probably been triggered by a flushSync\n             * inside an existing process. Instead of executing, mark flushNextFrame\n             * as true and ensure we flush the following frame at the end of this one.\n             */\n            if (isProcessing) {\n                flushNextFrame = true;\n                return;\n            }\n            isProcessing = true;\n            [toRun, toRunNextFrame] = [toRunNextFrame, toRun];\n            // Clear the next frame list\n            toRunNextFrame.length = 0;\n            // Execute this frame\n            numToRun = toRun.length;\n            if (numToRun) {\n                for (let i = 0; i < numToRun; i++) {\n                    const callback = toRun[i];\n                    callback(frameData);\n                    if (toKeepAlive.has(callback)) {\n                        step.schedule(callback);\n                        runNextFrame();\n                    }\n                }\n            }\n            isProcessing = false;\n            if (flushNextFrame) {\n                flushNextFrame = false;\n                step.process(frameData);\n            }\n        },\n    };\n    return step;\n}\n\nexport { createRenderStep };\n","import { onNextFrame, defaultTimestep } from './on-next-frame.mjs';\nimport { createRenderStep } from './create-render-step.mjs';\nimport { frameData } from './data.mjs';\n\nconst maxElapsed = 40;\nlet useDefaultElapsed = true;\nlet runNextFrame = false;\nlet isProcessing = false;\nconst stepsOrder = [\n    \"read\",\n    \"update\",\n    \"preRender\",\n    \"render\",\n    \"postRender\",\n];\nconst steps = stepsOrder.reduce((acc, key) => {\n    acc[key] = createRenderStep(() => (runNextFrame = true));\n    return acc;\n}, {});\nconst sync = stepsOrder.reduce((acc, key) => {\n    const step = steps[key];\n    acc[key] = (process, keepAlive = false, immediate = false) => {\n        if (!runNextFrame)\n            startLoop();\n        return step.schedule(process, keepAlive, immediate);\n    };\n    return acc;\n}, {});\nconst cancelSync = stepsOrder.reduce((acc, key) => {\n    acc[key] = steps[key].cancel;\n    return acc;\n}, {});\nconst flushSync = stepsOrder.reduce((acc, key) => {\n    acc[key] = () => steps[key].process(frameData);\n    return acc;\n}, {});\nconst processStep = (stepId) => steps[stepId].process(frameData);\nconst processFrame = (timestamp) => {\n    runNextFrame = false;\n    frameData.delta = useDefaultElapsed\n        ? defaultTimestep\n        : Math.max(Math.min(timestamp - frameData.timestamp, maxElapsed), 1);\n    frameData.timestamp = timestamp;\n    isProcessing = true;\n    stepsOrder.forEach(processStep);\n    isProcessing = false;\n    if (runNextFrame) {\n        useDefaultElapsed = false;\n        onNextFrame(processFrame);\n    }\n};\nconst startLoop = () => {\n    runNextFrame = true;\n    useDefaultElapsed = true;\n    if (!isProcessing)\n        onNextFrame(processFrame);\n};\n\nexport { cancelSync, flushSync, sync };\n","const isBrowser = typeof document !== \"undefined\";\n\nexport { isBrowser };\n","import { useRef } from 'react';\n\n/**\n * Creates a constant value over the lifecycle of a component.\n *\n * Even if `useMemo` is provided an empty array as its final argument, it doesn't offer\n * a guarantee that it won't re-run for performance reasons later on. By using `useConstant`\n * you can ensure that initialisers don't execute twice or more.\n */\nfunction useConstant(init) {\n    const ref = useRef(null);\n    if (ref.current === null) {\n        ref.current = init();\n    }\n    return ref.current;\n}\n\nexport { useConstant };\n","import { useLayoutEffect, useEffect } from 'react';\nimport { isBrowser } from './is-browser.mjs';\n\nconst useIsomorphicLayoutEffect = isBrowser ? useLayoutEffect : useEffect;\n\nexport { useIsomorphicLayoutEffect };\n","import { useEffect } from 'react';\n\nfunction useUnmountEffect(callback) {\n    return useEffect(() => () => callback(), []);\n}\n\nexport { useUnmountEffect };\n"],"names":["Promise","resolve","then","__webpack_require__","bind","useIsMounted","isMounted","react","useRef","use_isomorphic_effect","L","current","PopChildMeasure","Component","getSnapshotBeforeUpdate","prevProps","element","props","childRef","isPresent","size","sizeRef","height","offsetHeight","width","offsetWidth","top","offsetTop","left","offsetLeft","componentDidUpdate","render","children","PopChild","id","useId","ref","useInsertionEffect","dataset","motionPopId","style","document","createElement","head","appendChild","sheet","insertRule","removeChild","cloneElement","PresenceChild","initial","onExitComplete","custom","presenceAffectsLayout","mode","presenceChildren","use_constant","h","newChildrenMap","context","useMemo","isComplete","set","childId","values","register","delete","undefined","forEach","_","key","useEffect","PresenceContext","O","Provider","value","Map","getChildKey","child","AnimatePresence","exitBeforeEnter","forceRender","useForceUpdate","forcedRenderCount","setForcedRenderCount","useState","useCallback","frameloop","Z_","postRender","forceRenderLayoutGroup","useContext","LayoutGroupContext","p","filteredChildren","onlyElements","filtered","Children","isValidElement","push","childrenToRender","exiting","Set","presentChildren","allChildren","isInitialRender","updateChildLookup","use_unmount_effect","z","clear","Fragment","map","presentKeys","targetKeys","numPresent","length","i","indexOf","add","get","insertionIndex","splice","removeIndex","findIndex","presentChild","has","AuthLayout","param","jsx_runtime","jsx","div","className","react__WEBPACK_IMPORTED_MODULE_0__","createContext","frameData","delta","timestamp","defaultTimestep","getCurrentTime","performance","now","Date","onNextFrame","window","requestAnimationFrame","callback","setTimeout","useDefaultElapsed","runNextFrame","isProcessing","stepsOrder","steps","reduce","acc","createRenderStep","toRun","toRunNextFrame","numToRun","flushNextFrame","toKeepAlive","WeakSet","step","schedule","keepAlive","immediate","addToCurrentFrame","buffer","cancel","index","process","sync","startLoop","cancelSync","flushSync","data","processStep","stepId","processFrame","Math","max","min","isBrowser","useConstant","init","useIsomorphicLayoutEffect","_is_browser_mjs__WEBPACK_IMPORTED_MODULE_1__","j","useLayoutEffect","useUnmountEffect"],"sourceRoot":""}