@epic-web/workshop-app 4.0.0

package/node_modules/framer-motion/dist/es/index.mjs

@@ -0,0 +1,101 @@
+export { createDomMotionComponent, motion } from './render/dom/motion.mjs';
+export { m } from './render/dom/motion-minimal.mjs';
+export { AnimatePresence } from './components/AnimatePresence/index.mjs';
+export { MotionConfig } from './components/MotionConfig/index.mjs';
+export { LazyMotion } from './components/LazyMotion/index.mjs';
+export { LayoutGroup } from './components/LayoutGroup/index.mjs';
+export { Reorder } from './components/Reorder/index.mjs';
+export { domAnimation } from './render/dom/features-animation.mjs';
+export { domMax } from './render/dom/features-max.mjs';
+export { useMotionValue } from './value/use-motion-value.mjs';
+export { useMotionTemplate } from './value/use-motion-template.mjs';
+export { resolveMotionValue } from './value/utils/resolve-motion-value.mjs';
+export { useTransform } from './value/use-transform.mjs';
+export { useSpring } from './value/use-spring.mjs';
+export { useVelocity } from './value/use-velocity.mjs';
+export { useScroll } from './value/use-scroll.mjs';
+export { useElementScroll } from './value/scroll/use-element-scroll.mjs';
+export { useViewportScroll } from './value/scroll/use-viewport-scroll.mjs';
+export { useTime } from './value/use-time.mjs';
+export { useWillChange } from './value/use-will-change/index.mjs';
+export { useMotionValueEvent } from './utils/use-motion-value-event.mjs';
+export { useReducedMotion } from './utils/reduced-motion/use-reduced-motion.mjs';
+export { useReducedMotionConfig } from './utils/reduced-motion/use-reduced-motion-config.mjs';
+export { animationControls } from './animation/hooks/animation-controls.mjs';
+export { useAnimate } from './animation/hooks/use-animate.mjs';
+export { useAnimation, useAnimationControls } from './animation/hooks/use-animation.mjs';
+export { useAnimationFrame } from './utils/use-animation-frame.mjs';
+export { animateVisualElement } from './animation/interfaces/visual-element.mjs';
+export { useCycle } from './utils/use-cycle.mjs';
+export { isValidMotionProp } from './motion/utils/valid-prop.mjs';
+export { useIsPresent, usePresence } from './components/AnimatePresence/use-presence.mjs';
+export { useInView } from './utils/use-in-view.mjs';
+export { DragControls, useDragControls } from './gestures/drag/use-drag-controls.mjs';
+export { useDomEvent } from './events/use-dom-event.mjs';
+export { createMotionComponent } from './motion/index.mjs';
+export { isMotionComponent } from './motion/utils/is-motion-component.mjs';
+export { unwrapMotionComponent } from './motion/utils/unwrap-motion-component.mjs';
+export { VisualElement } from './render/VisualElement.mjs';
+export { addScaleCorrector } from './projection/styles/scale-correction.mjs';
+export { disableInstantTransitions, useInstantTransition } from './utils/use-instant-transition.mjs';
+export { useInstantLayoutTransition } from './projection/use-instant-layout-transition.mjs';
+export { useResetProjection } from './projection/use-reset-projection.mjs';
+export { buildTransform } from './render/html/utils/build-transform.mjs';
+export { visualElementStore } from './render/store.mjs';
+export { animateValue } from './animation/animators/MainThreadAnimation.mjs';
+export { color } from './value/types/color/index.mjs';
+export { complex } from './value/types/complex/index.mjs';
+export { px } from './value/types/numbers/units.mjs';
+export { MotionGlobalConfig } from './utils/GlobalConfig.mjs';
+export { AcceleratedAnimation } from './animation/animators/AcceleratedAnimation.mjs';
+export { startOptimizedAppearAnimation } from './animation/optimized-appear/start.mjs';
+export { optimizedAppearDataAttribute } from './animation/optimized-appear/data-id.mjs';
+export { spring } from './animation/generators/spring/index.mjs';
+export { MotionContext } from './context/MotionContext/index.mjs';
+export { MotionConfigContext } from './context/MotionConfigContext.mjs';
+export { PresenceContext } from './context/PresenceContext.mjs';
+export { LayoutGroupContext } from './context/LayoutGroupContext.mjs';
+export { SwitchLayoutGroupContext } from './context/SwitchLayoutGroupContext.mjs';
+export { FlatTree } from './render/utils/flat-tree.mjs';
+export { DeprecatedLayoutGroupContext } from './context/DeprecatedLayoutGroupContext.mjs';
+export { useAnimatedState as useDeprecatedAnimatedState } from './animation/hooks/use-animated-state.mjs';
+export { useInvertedScale as useDeprecatedInvertedScale } from './value/use-inverted-scale.mjs';
+export { AnimateSharedLayout } from './components/AnimateSharedLayout.mjs';
+export { MotionValue, motionValue } from './value/index.mjs';
+export { animate, createScopedAnimate } from './animation/animate.mjs';
+export { scroll } from './render/dom/scroll/index.mjs';
+export { scrollInfo } from './render/dom/scroll/track.mjs';
+export { inView } from './render/dom/viewport/index.mjs';
+export { stagger } from './animation/utils/stagger.mjs';
+export { transform } from './utils/transform.mjs';
+export { clamp } from './utils/clamp.mjs';
+export { mix } from './utils/mix/index.mjs';
+export { pipe } from './utils/pipe.mjs';
+export { progress } from './utils/progress.mjs';
+export { wrap } from './utils/wrap.mjs';
+export { cancelSync, sync } from './frameloop/index-legacy.mjs';
+export { anticipate } from './easing/anticipate.mjs';
+export { backIn, backInOut, backOut } from './easing/back.mjs';
+export { circIn, circInOut, circOut } from './easing/circ.mjs';
+export { easeIn, easeInOut, easeOut } from './easing/ease.mjs';
+export { cubicBezier } from './easing/cubic-bezier.mjs';
+export { mirrorEasing } from './easing/modifiers/mirror.mjs';
+export { reverseEasing } from './easing/modifiers/reverse.mjs';
+export { delay } from './utils/delay.mjs';
+export { distance, distance2D } from './utils/distance.mjs';
+export { invariant, warning } from './utils/errors.mjs';
+export { interpolate } from './utils/interpolate.mjs';
+export { cancelFrame, frame, frameData, steps } from './frameloop/frame.mjs';
+export { animations } from './motion/features/animations.mjs';
+export { createBox } from './projection/geometry/models.mjs';
+export { calcLength } from './projection/geometry/delta-calc.mjs';
+export { filterProps } from './render/dom/utils/filter-props.mjs';
+export { makeUseVisualState } from './motion/utils/use-visual-state.mjs';
+export { isDragActive } from './gestures/drag/utils/lock.mjs';
+export { addPointerEvent } from './events/add-pointer-event.mjs';
+export { addPointerInfo } from './events/event-info.mjs';
+export { isMotionValue } from './value/utils/is-motion-value.mjs';
+export { isBrowser } from './utils/is-browser.mjs';
+export { useUnmountEffect } from './utils/use-unmount-effect.mjs';
+export { useIsomorphicLayoutEffect } from './utils/use-isomorphic-effect.mjs';
+export { useForceUpdate } from './utils/use-force-update.mjs';

package/node_modules/framer-motion/dist/es/motion/features/Feature.mjs

@@ -0,0 +1,9 @@
+class Feature {
+    constructor(node) {
+        this.isMounted = false;
+        this.node = node;
+    }
+    update() { }
+}
+
+export { Feature };

package/node_modules/framer-motion/dist/es/motion/features/animation/exit.mjs

@@ -0,0 +1,31 @@
+import { Feature } from '../Feature.mjs';
+
+let id = 0;
+class ExitAnimationFeature extends Feature {
+    constructor() {
+        super(...arguments);
+        this.id = id++;
+    }
+    update() {
+        if (!this.node.presenceContext)
+            return;
+        const { isPresent, onExitComplete } = this.node.presenceContext;
+        const { isPresent: prevIsPresent } = this.node.prevPresenceContext || {};
+        if (!this.node.animationState || isPresent === prevIsPresent) {
+            return;
+        }
+        const exitAnimation = this.node.animationState.setActive("exit", !isPresent);
+        if (onExitComplete && !isPresent) {
+            exitAnimation.then(() => onExitComplete(this.id));
+        }
+    }
+    mount() {
+        const { register } = this.node.presenceContext || {};
+        if (register) {
+            this.unmount = register(this.id);
+        }
+    }
+    unmount() { }
+}
+
+export { ExitAnimationFeature };

package/node_modules/framer-motion/dist/es/motion/features/animation/index.mjs

@@ -0,0 +1,38 @@
+import { isAnimationControls } from '../../../animation/utils/is-animation-controls.mjs';
+import { createAnimationState } from '../../../render/utils/animation-state.mjs';
+import { Feature } from '../Feature.mjs';
+
+class AnimationFeature extends Feature {
+    /**
+     * We dynamically generate the AnimationState manager as it contains a reference
+     * to the underlying animation library. We only want to load that if we load this,
+     * so people can optionally code split it out using the `m` component.
+     */
+    constructor(node) {
+        super(node);
+        node.animationState || (node.animationState = createAnimationState(node));
+    }
+    updateAnimationControlsSubscription() {
+        const { animate } = this.node.getProps();
+        this.unmount();
+        if (isAnimationControls(animate)) {
+            this.unmount = animate.subscribe(this.node);
+        }
+    }
+    /**
+     * Subscribe any provided AnimationControls to the component's VisualElement
+     */
+    mount() {
+        this.updateAnimationControlsSubscription();
+    }
+    update() {
+        const { animate } = this.node.getProps();
+        const { animate: prevAnimate } = this.node.prevProps || {};
+        if (animate !== prevAnimate) {
+            this.updateAnimationControlsSubscription();
+        }
+    }
+    unmount() { }
+}
+
+export { AnimationFeature };

package/node_modules/framer-motion/dist/es/motion/features/animations.mjs

@@ -0,0 +1,13 @@
+import { AnimationFeature } from './animation/index.mjs';
+import { ExitAnimationFeature } from './animation/exit.mjs';
+
+const animations = {
+    animation: {
+        Feature: AnimationFeature,
+    },
+    exit: {
+        Feature: ExitAnimationFeature,
+    },
+};
+
+export { animations };

package/node_modules/framer-motion/dist/es/motion/features/definitions.mjs

@@ -0,0 +1,28 @@
+const featureProps = {
+    animation: [
+        "animate",
+        "variants",
+        "whileHover",
+        "whileTap",
+        "exit",
+        "whileInView",
+        "whileFocus",
+        "whileDrag",
+    ],
+    exit: ["exit"],
+    drag: ["drag", "dragControls"],
+    focus: ["whileFocus"],
+    hover: ["whileHover", "onHoverStart", "onHoverEnd"],
+    tap: ["whileTap", "onTap", "onTapStart", "onTapCancel"],
+    pan: ["onPan", "onPanStart", "onPanSessionStart", "onPanEnd"],
+    inView: ["whileInView", "onViewportEnter", "onViewportLeave"],
+    layout: ["layout", "layoutId"],
+};
+const featureDefinitions = {};
+for (const key in featureProps) {
+    featureDefinitions[key] = {
+        isEnabled: (props) => featureProps[key].some((name) => !!props[name]),
+    };
+}
+
+export { featureDefinitions };

package/node_modules/framer-motion/dist/es/motion/features/drag.mjs

@@ -0,0 +1,17 @@
+import { DragGesture } from '../../gestures/drag/index.mjs';
+import { PanGesture } from '../../gestures/pan/index.mjs';
+import { MeasureLayout } from './layout/MeasureLayout.mjs';
+import { HTMLProjectionNode } from '../../projection/node/HTMLProjectionNode.mjs';
+
+const drag = {
+    pan: {
+        Feature: PanGesture,
+    },
+    drag: {
+        Feature: DragGesture,
+        ProjectionNode: HTMLProjectionNode,
+        MeasureLayout,
+    },
+};
+
+export { drag };

package/node_modules/framer-motion/dist/es/motion/features/gestures.mjs

@@ -0,0 +1,21 @@
+import { HoverGesture } from '../../gestures/hover.mjs';
+import { FocusGesture } from '../../gestures/focus.mjs';
+import { PressGesture } from '../../gestures/press.mjs';
+import { InViewFeature } from './viewport/index.mjs';
+
+const gestureAnimations = {
+    inView: {
+        Feature: InViewFeature,
+    },
+    tap: {
+        Feature: PressGesture,
+    },
+    focus: {
+        Feature: FocusGesture,
+    },
+    hover: {
+        Feature: HoverGesture,
+    },
+};
+
+export { gestureAnimations };

package/node_modules/framer-motion/dist/es/motion/features/layout/MeasureLayout.mjs

@@ -0,0 +1,132 @@
+import React__default, { useContext } from 'react';
+import { usePresence } from '../../../components/AnimatePresence/use-presence.mjs';
+import { LayoutGroupContext } from '../../../context/LayoutGroupContext.mjs';
+import { SwitchLayoutGroupContext } from '../../../context/SwitchLayoutGroupContext.mjs';
+import { globalProjectionState } from '../../../projection/node/state.mjs';
+import { correctBorderRadius } from '../../../projection/styles/scale-border-radius.mjs';
+import { correctBoxShadow } from '../../../projection/styles/scale-box-shadow.mjs';
+import { addScaleCorrector } from '../../../projection/styles/scale-correction.mjs';
+import { microtask } from '../../../frameloop/microtask.mjs';
+import { frame } from '../../../frameloop/frame.mjs';
+
+class MeasureLayoutWithContext extends React__default.Component {
+    /**
+     * This only mounts projection nodes for components that
+     * need measuring, we might want to do it for all components
+     * in order to incorporate transforms
+     */
+    componentDidMount() {
+        const { visualElement, layoutGroup, switchLayoutGroup, layoutId } = this.props;
+        const { projection } = visualElement;
+        addScaleCorrector(defaultScaleCorrectors);
+        if (projection) {
+            if (layoutGroup.group)
+                layoutGroup.group.add(projection);
+            if (switchLayoutGroup && switchLayoutGroup.register && layoutId) {
+                switchLayoutGroup.register(projection);
+            }
+            projection.root.didUpdate();
+            projection.addEventListener("animationComplete", () => {
+                this.safeToRemove();
+            });
+            projection.setOptions({
+                ...projection.options,
+                onExitComplete: () => this.safeToRemove(),
+            });
+        }
+        globalProjectionState.hasEverUpdated = true;
+    }
+    getSnapshotBeforeUpdate(prevProps) {
+        const { layoutDependency, visualElement, drag, isPresent } = this.props;
+        const projection = visualElement.projection;
+        if (!projection)
+            return null;
+        /**
+         * TODO: We use this data in relegate to determine whether to
+         * promote a previous element. There's no guarantee its presence data
+         * will have updated by this point - if a bug like this arises it will
+         * have to be that we markForRelegation and then find a new lead some other way,
+         * perhaps in didUpdate
+         */
+        projection.isPresent = isPresent;
+        if (drag ||
+            prevProps.layoutDependency !== layoutDependency ||
+            layoutDependency === undefined) {
+            projection.willUpdate();
+        }
+        else {
+            this.safeToRemove();
+        }
+        if (prevProps.isPresent !== isPresent) {
+            if (isPresent) {
+                projection.promote();
+            }
+            else if (!projection.relegate()) {
+                /**
+                 * If there's another stack member taking over from this one,
+                 * it's in charge of the exit animation and therefore should
+                 * be in charge of the safe to remove. Otherwise we call it here.
+                 */
+                frame.postRender(() => {
+                    const stack = projection.getStack();
+                    if (!stack || !stack.members.length) {
+                        this.safeToRemove();
+                    }
+                });
+            }
+        }
+        return null;
+    }
+    componentDidUpdate() {
+        const { projection } = this.props.visualElement;
+        if (projection) {
+            projection.root.didUpdate();
+            microtask.postRender(() => {
+                if (!projection.currentAnimation && projection.isLead()) {
+                    this.safeToRemove();
+                }
+            });
+        }
+    }
+    componentWillUnmount() {
+        const { visualElement, layoutGroup, switchLayoutGroup: promoteContext, } = this.props;
+        const { projection } = visualElement;
+        if (projection) {
+            projection.scheduleCheckAfterUnmount();
+            if (layoutGroup && layoutGroup.group)
+                layoutGroup.group.remove(projection);
+            if (promoteContext && promoteContext.deregister)
+                promoteContext.deregister(projection);
+        }
+    }
+    safeToRemove() {
+        const { safeToRemove } = this.props;
+        safeToRemove && safeToRemove();
+    }
+    render() {
+        return null;
+    }
+}
+function MeasureLayout(props) {
+    const [isPresent, safeToRemove] = usePresence();
+    const layoutGroup = useContext(LayoutGroupContext);
+    return (React__default.createElement(MeasureLayoutWithContext, { ...props, layoutGroup: layoutGroup, switchLayoutGroup: useContext(SwitchLayoutGroupContext), isPresent: isPresent, safeToRemove: safeToRemove }));
+}
+const defaultScaleCorrectors = {
+    borderRadius: {
+        ...correctBorderRadius,
+        applyTo: [
+            "borderTopLeftRadius",
+            "borderTopRightRadius",
+            "borderBottomLeftRadius",
+            "borderBottomRightRadius",
+        ],
+    },
+    borderTopLeftRadius: correctBorderRadius,
+    borderTopRightRadius: correctBorderRadius,
+    borderBottomLeftRadius: correctBorderRadius,
+    borderBottomRightRadius: correctBorderRadius,
+    boxShadow: correctBoxShadow,
+};
+
+export { MeasureLayout };

package/node_modules/framer-motion/dist/es/motion/features/layout.mjs

@@ -0,0 +1,11 @@
+import { HTMLProjectionNode } from '../../projection/node/HTMLProjectionNode.mjs';
+import { MeasureLayout } from './layout/MeasureLayout.mjs';
+
+const layout = {
+    layout: {
+        ProjectionNode: HTMLProjectionNode,
+        MeasureLayout,
+    },
+};
+
+export { layout };

package/node_modules/framer-motion/dist/es/motion/features/load-features.mjs

@@ -0,0 +1,12 @@
+import { featureDefinitions } from './definitions.mjs';
+
+function loadFeatures(features) {
+    for (const key in features) {
+        featureDefinitions[key] = {
+            ...featureDefinitions[key],
+            ...features[key],
+        };
+    }
+}
+
+export { loadFeatures };

package/node_modules/framer-motion/dist/es/motion/features/viewport/index.mjs

@@ -0,0 +1,72 @@
+import { Feature } from '../Feature.mjs';
+import { observeIntersection } from './observers.mjs';
+
+const thresholdNames = {
+    some: 0,
+    all: 1,
+};
+class InViewFeature extends Feature {
+    constructor() {
+        super(...arguments);
+        this.hasEnteredView = false;
+        this.isInView = false;
+    }
+    startObserver() {
+        this.unmount();
+        const { viewport = {} } = this.node.getProps();
+        const { root, margin: rootMargin, amount = "some", once } = viewport;
+        const options = {
+            root: root ? root.current : undefined,
+            rootMargin,
+            threshold: typeof amount === "number" ? amount : thresholdNames[amount],
+        };
+        const onIntersectionUpdate = (entry) => {
+            const { isIntersecting } = entry;
+            /**
+             * If there's been no change in the viewport state, early return.
+             */
+            if (this.isInView === isIntersecting)
+                return;
+            this.isInView = isIntersecting;
+            /**
+             * Handle hasEnteredView. If this is only meant to run once, and
+             * element isn't visible, early return. Otherwise set hasEnteredView to true.
+             */
+            if (once && !isIntersecting && this.hasEnteredView) {
+                return;
+            }
+            else if (isIntersecting) {
+                this.hasEnteredView = true;
+            }
+            if (this.node.animationState) {
+                this.node.animationState.setActive("whileInView", isIntersecting);
+            }
+            /**
+             * Use the latest committed props rather than the ones in scope
+             * when this observer is created
+             */
+            const { onViewportEnter, onViewportLeave } = this.node.getProps();
+            const callback = isIntersecting ? onViewportEnter : onViewportLeave;
+            callback && callback(entry);
+        };
+        return observeIntersection(this.node.current, options, onIntersectionUpdate);
+    }
+    mount() {
+        this.startObserver();
+    }
+    update() {
+        if (typeof IntersectionObserver === "undefined")
+            return;
+        const { props, prevProps } = this.node;
+        const hasOptionsChanged = ["amount", "margin", "root"].some(hasViewportOptionChanged(props, prevProps));
+        if (hasOptionsChanged) {
+            this.startObserver();
+        }
+    }
+    unmount() { }
+}
+function hasViewportOptionChanged({ viewport = {} }, { viewport: prevViewport = {} } = {}) {
+    return (name) => viewport[name] !== prevViewport[name];
+}
+
+export { InViewFeature };

package/node_modules/framer-motion/dist/es/motion/features/viewport/observers.mjs

@@ -0,0 +1,49 @@
+/**
+ * Map an IntersectionHandler callback to an element. We only ever make one handler for one
+ * element, so even though these handlers might all be triggered by different
+ * observers, we can keep them in the same map.
+ */
+const observerCallbacks = new WeakMap();
+/**
+ * Multiple observers can be created for multiple element/document roots. Each with
+ * different settings. So here we store dictionaries of observers to each root,
+ * using serialised settings (threshold/margin) as lookup keys.
+ */
+const observers = new WeakMap();
+const fireObserverCallback = (entry) => {
+    const callback = observerCallbacks.get(entry.target);
+    callback && callback(entry);
+};
+const fireAllObserverCallbacks = (entries) => {
+    entries.forEach(fireObserverCallback);
+};
+function initIntersectionObserver({ root, ...options }) {
+    const lookupRoot = root || document;
+    /**
+     * If we don't have an observer lookup map for this root, create one.
+     */
+    if (!observers.has(lookupRoot)) {
+        observers.set(lookupRoot, {});
+    }
+    const rootObservers = observers.get(lookupRoot);
+    const key = JSON.stringify(options);
+    /**
+     * If we don't have an observer for this combination of root and settings,
+     * create one.
+     */
+    if (!rootObservers[key]) {
+        rootObservers[key] = new IntersectionObserver(fireAllObserverCallbacks, { root, ...options });
+    }
+    return rootObservers[key];
+}
+function observeIntersection(element, options, callback) {
+    const rootInteresectionObserver = initIntersectionObserver(options);
+    observerCallbacks.set(element, callback);
+    rootInteresectionObserver.observe(element);
+    return () => {
+        observerCallbacks.delete(element);
+        rootInteresectionObserver.unobserve(element);
+    };
+}
+
+export { observeIntersection };

package/node_modules/framer-motion/dist/es/motion/index.mjs

@@ -0,0 +1,79 @@
+import * as React from 'react';
+import { forwardRef, useContext } from 'react';
+import { MotionConfigContext } from '../context/MotionConfigContext.mjs';
+import { MotionContext } from '../context/MotionContext/index.mjs';
+import { useVisualElement } from './utils/use-visual-element.mjs';
+import { useMotionRef } from './utils/use-motion-ref.mjs';
+import { useCreateMotionContext } from '../context/MotionContext/create.mjs';
+import { loadFeatures } from './features/load-features.mjs';
+import { isBrowser } from '../utils/is-browser.mjs';
+import { LayoutGroupContext } from '../context/LayoutGroupContext.mjs';
+import { LazyContext } from '../context/LazyContext.mjs';
+import { SwitchLayoutGroupContext } from '../context/SwitchLayoutGroupContext.mjs';
+import { motionComponentSymbol } from './utils/symbol.mjs';
+
+/**
+ * Create a `motion` component.
+ *
+ * This function accepts a Component argument, which can be either a string (ie "div"
+ * for `motion.div`), or an actual React component.
+ *
+ * Alongside this is a config option which provides a way of rendering the provided
+ * component "offline", or outside the React render cycle.
+ */
+function createMotionComponent({ preloadedFeatures, createVisualElement, useRender, useVisualState, Component, }) {
+    preloadedFeatures && loadFeatures(preloadedFeatures);
+    function MotionComponent(props, externalRef) {
+        /**
+         * If we need to measure the element we load this functionality in a
+         * separate class component in order to gain access to getSnapshotBeforeUpdate.
+         */
+        let MeasureLayout;
+        const configAndProps = {
+            ...useContext(MotionConfigContext),
+            ...props,
+            layoutId: useLayoutId(props),
+        };
+        const { isStatic } = configAndProps;
+        const context = useCreateMotionContext(props);
+        const visualState = useVisualState(props, isStatic);
+        if (!isStatic && isBrowser) {
+            /**
+             * Create a VisualElement for this component. A VisualElement provides a common
+             * interface to renderer-specific APIs (ie DOM/Three.js etc) as well as
+             * providing a way of rendering to these APIs outside of the React render loop
+             * for more performant animations and interactions
+             */
+            context.visualElement = useVisualElement(Component, visualState, configAndProps, createVisualElement);
+            /**
+             * Load Motion gesture and animation features. These are rendered as renderless
+             * components so each feature can optionally make use of React lifecycle methods.
+             */
+            const initialLayoutGroupConfig = useContext(SwitchLayoutGroupContext);
+            const isStrict = useContext(LazyContext).strict;
+            if (context.visualElement) {
+                MeasureLayout = context.visualElement.loadFeatures(
+                // Note: Pass the full new combined props to correctly re-render dynamic feature components.
+                configAndProps, isStrict, preloadedFeatures, initialLayoutGroupConfig);
+            }
+        }
+        /**
+         * The mount order and hierarchy is specific to ensure our element ref
+         * is hydrated by the time features fire their effects.
+         */
+        return (React.createElement(MotionContext.Provider, { value: context },
+            MeasureLayout && context.visualElement ? (React.createElement(MeasureLayout, { visualElement: context.visualElement, ...configAndProps })) : null,
+            useRender(Component, props, useMotionRef(visualState, context.visualElement, externalRef), visualState, isStatic, context.visualElement)));
+    }
+    const ForwardRefComponent = forwardRef(MotionComponent);
+    ForwardRefComponent[motionComponentSymbol] = Component;
+    return ForwardRefComponent;
+}
+function useLayoutId({ layoutId }) {
+    const layoutGroupId = useContext(LayoutGroupContext).id;
+    return layoutGroupId && layoutId !== undefined
+        ? layoutGroupId + "-" + layoutId
+        : layoutId;
+}
+
+export { createMotionComponent };

package/node_modules/framer-motion/dist/es/motion/utils/is-forced-motion-value.mjs

@@ -0,0 +1,11 @@
+import { scaleCorrectors } from '../../projection/styles/scale-correction.mjs';
+import { transformProps } from '../../render/html/utils/transform.mjs';
+
+function isForcedMotionValue(key, { layout, layoutId }) {
+    return (transformProps.has(key) ||
+        key.startsWith("origin") ||
+        ((layout || layoutId !== undefined) &&
+            (!!scaleCorrectors[key] || key === "opacity")));
+}
+
+export { isForcedMotionValue };

package/node_modules/framer-motion/dist/es/motion/utils/is-motion-component.mjs

@@ -0,0 +1,12 @@
+import { motionComponentSymbol } from './symbol.mjs';
+
+/**
+ * Checks if a component is a `motion` component.
+ */
+function isMotionComponent(component) {
+    return (component !== null &&
+        typeof component === "object" &&
+        motionComponentSymbol in component);
+}
+
+export { isMotionComponent };

package/node_modules/framer-motion/dist/es/motion/utils/symbol.mjs

@@ -0,0 +1,3 @@
+const motionComponentSymbol = Symbol.for("motionComponentSymbol");
+
+export { motionComponentSymbol };