framer-motion 7.0.3 → 7.1.2

package/dist/es/components/AnimatePresence/index.mjs

@@ -1,4 +1,3 @@
-import { __read, __spreadArray } from 'tslib';
 import * as React from 'react';
 import { useContext, useRef, cloneElement, Children, isValidElement } from 'react';
 import { env } from '../../utils/process.mjs';
@@ -9,17 +8,17 @@ import { LayoutGroupContext } from '../../context/LayoutGroupContext.mjs';
 import { useIsomorphicLayoutEffect } from '../../utils/use-isomorphic-effect.mjs';
 import { useUnmountEffect } from '../../utils/use-unmount-effect.mjs';
 
-var getChildKey = function (child) { return child.key || ""; };
+const getChildKey = (child) => child.key || "";
 function updateChildLookup(children, allChildren) {
-    children.forEach(function (child) {
-        var key = getChildKey(child);
+    children.forEach((child) => {
+        const key = getChildKey(child);
         allChildren.set(key, child);
     });
 }
 function onlyElements(children) {
-    var filtered = [];
+    const filtered = [];
     // We use forEach here instead of map as map mutates the component key by preprending `.$`
-    Children.forEach(children, function (child) {
+    Children.forEach(children, (child) => {
         if (isValidElement(child))
             filtered.push(child);
     });
@@ -58,50 +57,49 @@ function onlyElements(children) {
  *
  * @public
  */
-var AnimatePresence = function (_a) {
-    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;
+const AnimatePresence = ({ children, custom, initial = true, onExitComplete, exitBeforeEnter, presenceAffectsLayout = true, }) => {
     // We want to force a re-render once all exiting animations have finished. We
     // either use a local forceRender function, or one from a parent context if it exists.
-    var _d = __read(useForceUpdate(), 1), forceRender = _d[0];
-    var forceRenderLayoutGroup = useContext(LayoutGroupContext).forceRender;
+    let [forceRender] = useForceUpdate();
+    const forceRenderLayoutGroup = useContext(LayoutGroupContext).forceRender;
     if (forceRenderLayoutGroup)
         forceRender = forceRenderLayoutGroup;
-    var isMounted = useIsMounted();
+    const isMounted = useIsMounted();
     // Filter out any children that aren't ReactElements. We can only track ReactElements with a props.key
-    var filteredChildren = onlyElements(children);
-    var childrenToRender = filteredChildren;
-    var exiting = new Set();
+    const filteredChildren = onlyElements(children);
+    let childrenToRender = filteredChildren;
+    const exiting = new Set();
     // Keep a living record of the children we're actually rendering so we
     // can diff to figure out which are entering and exiting
-    var presentChildren = useRef(childrenToRender);
+    const presentChildren = useRef(childrenToRender);
     // A lookup table to quickly reference components by key
-    var allChildren = useRef(new Map()).current;
+    const allChildren = useRef(new Map()).current;
     // If this is the initial component render, just deal with logic surrounding whether
     // we play onMount animations or not.
-    var isInitialRender = useRef(true);
-    useIsomorphicLayoutEffect(function () {
+    const isInitialRender = useRef(true);
+    useIsomorphicLayoutEffect(() => {
         isInitialRender.current = false;
         updateChildLookup(filteredChildren, allChildren);
         presentChildren.current = childrenToRender;
     });
-    useUnmountEffect(function () {
+    useUnmountEffect(() => {
         isInitialRender.current = true;
         allChildren.clear();
         exiting.clear();
     });
     if (isInitialRender.current) {
-        return (React.createElement(React.Fragment, null, childrenToRender.map(function (child) { return (React.createElement(PresenceChild, { key: getChildKey(child), isPresent: true, initial: initial ? undefined : false, presenceAffectsLayout: presenceAffectsLayout }, child)); })));
+        return (React.createElement(React.Fragment, null, childrenToRender.map((child) => (React.createElement(PresenceChild, { key: getChildKey(child), isPresent: true, initial: initial ? undefined : false, presenceAffectsLayout: presenceAffectsLayout }, child)))));
     }
     // If this is a subsequent render, deal with entering and exiting children
-    childrenToRender = __spreadArray([], __read(childrenToRender), false);
+    childrenToRender = [...childrenToRender];
     // Diff the keys of the currently-present and target children to update our
     // exiting list.
-    var presentKeys = presentChildren.current.map(getChildKey);
-    var targetKeys = filteredChildren.map(getChildKey);
+    const presentKeys = presentChildren.current.map(getChildKey);
+    const targetKeys = filteredChildren.map(getChildKey);
     // Diff the present children with our target children and mark those that are exiting
-    var numPresent = presentKeys.length;
-    for (var i = 0; i < numPresent; i++) {
-        var key = presentKeys[i];
+    const numPresent = presentKeys.length;
+    for (let i = 0; i < numPresent; i++) {
+        const key = presentKeys[i];
         if (targetKeys.indexOf(key) === -1) {
             exiting.add(key);
         }
@@ -113,19 +111,19 @@ var AnimatePresence = function (_a) {
     }
     // Loop through all currently exiting components and clone them to overwrite `animate`
     // with any `exit` prop they might have defined.
-    exiting.forEach(function (key) {
+    exiting.forEach((key) => {
         // If this component is actually entering again, early return
         if (targetKeys.indexOf(key) !== -1)
             return;
-        var child = allChildren.get(key);
+        const child = allChildren.get(key);
         if (!child)
             return;
-        var insertionIndex = presentKeys.indexOf(key);
-        var onExit = function () {
+        const insertionIndex = presentKeys.indexOf(key);
+        const onExit = () => {
             allChildren.delete(key);
             exiting.delete(key);
             // Remove this child from the present children
-            var removeIndex = presentChildren.current.findIndex(function (presentChild) { return presentChild.key === key; });
+            const removeIndex = presentChildren.current.findIndex((presentChild) => presentChild.key === key);
             presentChildren.current.splice(removeIndex, 1);
             // Defer re-rendering until all exiting children have indeed left
             if (!exiting.size) {
@@ -140,18 +138,18 @@ var AnimatePresence = function (_a) {
     });
     // Add `MotionContext` even to children that don't need it to ensure we're rendering
     // the same tree between renders
-    childrenToRender = childrenToRender.map(function (child) {
-        var key = child.key;
+    childrenToRender = childrenToRender.map((child) => {
+        const key = child.key;
         return exiting.has(key) ? (child) : (React.createElement(PresenceChild, { key: getChildKey(child), isPresent: true, presenceAffectsLayout: presenceAffectsLayout }, child));
     });
     if (env !== "production" &&
         exitBeforeEnter &&
         childrenToRender.length > 1) {
-        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.");
+        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.`);
     }
     return (React.createElement(React.Fragment, null, exiting.size
         ? childrenToRender
-        : childrenToRender.map(function (child) { return cloneElement(child); })));
+        : childrenToRender.map((child) => cloneElement(child))));
 };
 
 export { AnimatePresence };

package/dist/es/components/AnimatePresence/use-presence.mjs

@@ -25,16 +25,16 @@ import { PresenceContext } from '../../context/PresenceContext.mjs';
  * @public
  */
 function usePresence() {
-    var context = useContext(PresenceContext);
+    const context = useContext(PresenceContext);
     if (context === null)
         return [true, null];
-    var isPresent = context.isPresent, onExitComplete = context.onExitComplete, register = context.register;
+    const { isPresent, onExitComplete, register } = context;
     // It's safe to call the following hooks conditionally (after an early return) because the context will always
     // either be null or non-null for the lifespan of the component.
     // Replace with useId when released in React
-    var id = useId();
-    useEffect(function () { return register(id); }, []);
-    var safeToRemove = function () { return onExitComplete === null || onExitComplete === void 0 ? void 0 : onExitComplete(id); };
+    const id = useId();
+    useEffect(() => register(id), []);
+    const safeToRemove = () => onExitComplete === null || onExitComplete === void 0 ? void 0 : onExitComplete(id);
     return !isPresent && onExitComplete ? [false, safeToRemove] : [true];
 }
 /**

package/dist/es/components/AnimateSharedLayout.mjs

@@ -3,13 +3,12 @@ import * as React from 'react';
 import { useConstant } from '../utils/use-constant.mjs';
 import { LayoutGroup } from './LayoutGroup/index.mjs';
 
-var id = 0;
-var AnimateSharedLayout = function (_a) {
-    var children = _a.children;
-    React.useEffect(function () {
+let id = 0;
+const AnimateSharedLayout = ({ children, }) => {
+    React.useEffect(() => {
         warning(false, "AnimateSharedLayout is deprecated: https://www.framer.com/docs/guide-upgrade/##shared-layout-animations");
     }, []);
-    return (React.createElement(LayoutGroup, { id: useConstant(function () { return "asl-".concat(id++); }) }, children));
+    return (React.createElement(LayoutGroup, { id: useConstant(() => `asl-${id++}`) }, children));
 };
 
 export { AnimateSharedLayout };

package/dist/es/components/LayoutGroup/index.mjs

@@ -1,4 +1,3 @@
-import { __read, __assign } from 'tslib';
 import * as React from 'react';
 import { useContext, useRef, useMemo } from 'react';
 import { LayoutGroupContext } from '../../context/LayoutGroupContext.mjs';
@@ -6,33 +5,30 @@ import { DeprecatedLayoutGroupContext } from '../../context/DeprecatedLayoutGrou
 import { useForceUpdate } from '../../utils/use-force-update.mjs';
 import { nodeGroup } from '../../projection/node/group.mjs';
 
-var shouldInheritGroup = function (inherit) { return inherit === true; };
-var shouldInheritId = function (inherit) {
-    return shouldInheritGroup(inherit === true) || inherit === "id";
-};
-var LayoutGroup = function (_a) {
-    var _b, _c;
-    var children = _a.children, id = _a.id, inheritId = _a.inheritId, _d = _a.inherit, inherit = _d === void 0 ? true : _d;
+const shouldInheritGroup = (inherit) => inherit === true;
+const shouldInheritId = (inherit) => shouldInheritGroup(inherit === true) || inherit === "id";
+const LayoutGroup = ({ children, id, inheritId, inherit = true, }) => {
+    var _a, _b;
     // Maintain backwards-compatibility with inheritId until 7.0
     if (inheritId !== undefined)
         inherit = inheritId;
-    var layoutGroupContext = useContext(LayoutGroupContext);
-    var deprecatedLayoutGroupContext = useContext(DeprecatedLayoutGroupContext);
-    var _e = __read(useForceUpdate(), 2), forceRender = _e[0], key = _e[1];
-    var context = useRef(null);
-    var upstreamId = (_b = layoutGroupContext.id) !== null && _b !== void 0 ? _b : deprecatedLayoutGroupContext;
+    const layoutGroupContext = useContext(LayoutGroupContext);
+    const deprecatedLayoutGroupContext = useContext(DeprecatedLayoutGroupContext);
+    const [forceRender, key] = useForceUpdate();
+    const context = useRef(null);
+    const upstreamId = (_a = layoutGroupContext.id) !== null && _a !== void 0 ? _a : deprecatedLayoutGroupContext;
     if (context.current === null) {
         if (shouldInheritId(inherit) && upstreamId) {
             id = id ? upstreamId + "-" + id : upstreamId;
         }
         context.current = {
-            id: id,
+            id,
             group: shouldInheritGroup(inherit)
-                ? (_c = layoutGroupContext === null || layoutGroupContext === void 0 ? void 0 : layoutGroupContext.group) !== null && _c !== void 0 ? _c : nodeGroup()
+                ? (_b = layoutGroupContext === null || layoutGroupContext === void 0 ? void 0 : layoutGroupContext.group) !== null && _b !== void 0 ? _b : nodeGroup()
                 : nodeGroup(),
         };
     }
-    var memoizedContext = useMemo(function () { return (__assign(__assign({}, context.current), { forceRender: forceRender })); }, [key]);
+    const memoizedContext = useMemo(() => (Object.assign(Object.assign({}, context.current), { forceRender })), [key]);
     return (React.createElement(LayoutGroupContext.Provider, { value: memoizedContext }, children));
 };
 

package/dist/es/components/LazyMotion/index.mjs

@@ -1,4 +1,4 @@
-import { __read, __rest } from 'tslib';
+import { __rest } from 'tslib';
 import * as React from 'react';
 import { useState, useRef, useEffect } from 'react';
 import { LazyContext } from '../../context/LazyContext.mjs';
@@ -39,29 +39,28 @@ import { loadFeatures } from '../../motion/features/definitions.mjs';
  *
  * @public
  */
-function LazyMotion(_a) {
-    var children = _a.children, features = _a.features, _b = _a.strict, strict = _b === void 0 ? false : _b;
-    var _c = __read(useState(!isLazyBundle(features)), 2), setIsLoaded = _c[1];
-    var loadedRenderer = useRef(undefined);
+function LazyMotion({ children, features, strict = false }) {
+    const [, setIsLoaded] = useState(!isLazyBundle(features));
+    const loadedRenderer = useRef(undefined);
     /**
      * If this is a synchronous load, load features immediately
      */
     if (!isLazyBundle(features)) {
-        var renderer = features.renderer, loadedFeatures = __rest(features, ["renderer"]);
+        const { renderer } = features, loadedFeatures = __rest(features, ["renderer"]);
         loadedRenderer.current = renderer;
         loadFeatures(loadedFeatures);
     }
-    useEffect(function () {
+    useEffect(() => {
         if (isLazyBundle(features)) {
-            features().then(function (_a) {
-                var renderer = _a.renderer, loadedFeatures = __rest(_a, ["renderer"]);
+            features().then((_a) => {
+                var { renderer } = _a, loadedFeatures = __rest(_a, ["renderer"]);
                 loadFeatures(loadedFeatures);
                 loadedRenderer.current = renderer;
                 setIsLoaded(true);
             });
         }
     }, []);
-    return (React.createElement(LazyContext.Provider, { value: { renderer: loadedRenderer.current, strict: strict } }, children));
+    return (React.createElement(LazyContext.Provider, { value: { renderer: loadedRenderer.current, strict } }, children));
 }
 function isLazyBundle(features) {
     return typeof features === "function";

package/dist/es/components/MotionConfig/index.mjs

@@ -1,4 +1,4 @@
-import { __rest, __assign } from 'tslib';
+import { __rest } from 'tslib';
 import * as React from 'react';
 import { useContext, useMemo } from 'react';
 import { MotionConfigContext } from '../../context/MotionConfigContext.mjs';
@@ -23,22 +23,22 @@ import { useConstant } from '../../utils/use-constant.mjs';
  * @public
  */
 function MotionConfig(_a) {
-    var children = _a.children, isValidProp = _a.isValidProp, config = __rest(_a, ["children", "isValidProp"]);
+    var { children, isValidProp } = _a, config = __rest(_a, ["children", "isValidProp"]);
     isValidProp && loadExternalIsValidProp(isValidProp);
     /**
      * Inherit props from any parent MotionConfig components
      */
-    config = __assign(__assign({}, useContext(MotionConfigContext)), config);
+    config = Object.assign(Object.assign({}, useContext(MotionConfigContext)), config);
     /**
      * Don't allow isStatic to change between renders as it affects how many hooks
      * motion components fire.
      */
-    config.isStatic = useConstant(function () { return config.isStatic; });
+    config.isStatic = useConstant(() => config.isStatic);
     /**
      * Creating a new config context object will re-render every `motion` component
      * every time it renders. So we only want to create a new one sparingly.
      */
-    var context = useMemo(function () { return config; }, [JSON.stringify(config.transition), config.transformPagePoint, config.reducedMotion]);
+    const context = useMemo(() => config, [JSON.stringify(config.transition), config.transformPagePoint, config.reducedMotion]);
     return (React.createElement(MotionConfigContext.Provider, { value: context }, children));
 }
 

package/dist/es/components/Reorder/Group.mjs

@@ -1,4 +1,4 @@
-import { __rest, __assign } from 'tslib';
+import { __rest } from 'tslib';
 import { invariant } from 'hey-listen';
 import * as React from 'react';
 import { forwardRef, useRef, useEffect } from 'react';
@@ -8,42 +8,42 @@ import { useConstant } from '../../utils/use-constant.mjs';
 import { checkReorder } from './utils/check-reorder.mjs';
 
 function ReorderGroup(_a, externalRef) {
-    var children = _a.children, _b = _a.as, as = _b === void 0 ? "ul" : _b, _c = _a.axis, axis = _c === void 0 ? "y" : _c, onReorder = _a.onReorder, values = _a.values, props = __rest(_a, ["children", "as", "axis", "onReorder", "values"]);
-    var Component = useConstant(function () { return motion(as); });
-    var order = [];
-    var isReordering = useRef(false);
+    var { children, as = "ul", axis = "y", onReorder, values } = _a, props = __rest(_a, ["children", "as", "axis", "onReorder", "values"]);
+    const Component = useConstant(() => motion(as));
+    const order = [];
+    const isReordering = useRef(false);
     invariant(Boolean(values), "Reorder.Group must be provided a values prop");
-    var context = {
-        axis: axis,
-        registerItem: function (value, layout) {
+    const context = {
+        axis,
+        registerItem: (value, layout) => {
             /**
              * Ensure entries can't add themselves more than once
              */
             if (layout &&
-                order.findIndex(function (entry) { return value === entry.value; }) === -1) {
-                order.push({ value: value, layout: layout[axis] });
+                order.findIndex((entry) => value === entry.value) === -1) {
+                order.push({ value, layout: layout[axis] });
                 order.sort(compareMin);
             }
         },
-        updateOrder: function (id, offset, velocity) {
+        updateOrder: (id, offset, velocity) => {
             if (isReordering.current)
                 return;
-            var newOrder = checkReorder(order, id, offset, velocity);
+            const newOrder = checkReorder(order, id, offset, velocity);
             if (order !== newOrder) {
                 isReordering.current = true;
                 onReorder(newOrder
                     .map(getValue)
-                    .filter(function (value) { return values.indexOf(value) !== -1; }));
+                    .filter((value) => values.indexOf(value) !== -1));
             }
         },
     };
-    useEffect(function () {
+    useEffect(() => {
         isReordering.current = false;
     });
-    return (React.createElement(Component, __assign({}, props, { ref: externalRef }),
+    return (React.createElement(Component, Object.assign({}, props, { ref: externalRef }),
         React.createElement(ReorderContext.Provider, { value: context }, children)));
 }
-var Group = forwardRef(ReorderGroup);
+const Group = forwardRef(ReorderGroup);
 function getValue(item) {
     return item.value;
 }

package/dist/es/components/Reorder/Item.mjs

@@ -1,4 +1,4 @@
-import { __rest, __read, __assign } from 'tslib';
+import { __rest } from 'tslib';
 import { invariant } from 'hey-listen';
 import * as React from 'react';
 import { forwardRef, useContext, useRef, useEffect } from 'react';
@@ -9,37 +9,33 @@ import { useMotionValue } from '../../value/use-motion-value.mjs';
 import { useTransform } from '../../value/use-transform.mjs';
 import { isMotionValue } from '../../value/utils/is-motion-value.mjs';
 
-function useDefaultMotionValue(value, defaultValue) {
-    if (defaultValue === void 0) { defaultValue = 0; }
+function useDefaultMotionValue(value, defaultValue = 0) {
     return isMotionValue(value) ? value : useMotionValue(defaultValue);
 }
 function ReorderItem(_a, externalRef) {
-    var children = _a.children, style = _a.style, value = _a.value, _b = _a.as, as = _b === void 0 ? "li" : _b, onDrag = _a.onDrag, _c = _a.layout, layout = _c === void 0 ? true : _c, props = __rest(_a, ["children", "style", "value", "as", "onDrag", "layout"]);
-    var Component = useConstant(function () { return motion(as); });
-    var context = useContext(ReorderContext);
-    var point = {
+    var { children, style, value, as = "li", onDrag, layout = true } = _a, props = __rest(_a, ["children", "style", "value", "as", "onDrag", "layout"]);
+    const Component = useConstant(() => motion(as));
+    const context = useContext(ReorderContext);
+    const point = {
         x: useDefaultMotionValue(style === null || style === void 0 ? void 0 : style.x),
         y: useDefaultMotionValue(style === null || style === void 0 ? void 0 : style.y),
     };
-    var zIndex = useTransform([point.x, point.y], function (_a) {
-        var _b = __read(_a, 2), latestX = _b[0], latestY = _b[1];
-        return latestX || latestY ? 1 : "unset";
-    });
-    var measuredLayout = useRef(null);
+    const zIndex = useTransform([point.x, point.y], ([latestX, latestY]) => latestX || latestY ? 1 : "unset");
+    const measuredLayout = useRef(null);
     invariant(Boolean(context), "Reorder.Item must be a child of Reorder.Group");
-    var _d = context, axis = _d.axis, registerItem = _d.registerItem, updateOrder = _d.updateOrder;
-    useEffect(function () {
+    const { axis, registerItem, updateOrder } = context;
+    useEffect(() => {
         registerItem(value, measuredLayout.current);
     }, [context]);
-    return (React.createElement(Component, __assign({ drag: axis }, props, { dragSnapToOrigin: true, style: __assign(__assign({}, style), { x: point.x, y: point.y, zIndex: zIndex }), layout: layout, onDrag: function (event, gesturePoint) {
-            var velocity = gesturePoint.velocity;
+    return (React.createElement(Component, Object.assign({ drag: axis }, props, { dragSnapToOrigin: true, style: Object.assign(Object.assign({}, style), { x: point.x, y: point.y, zIndex }), layout: layout, onDrag: (event, gesturePoint) => {
+            const { velocity } = gesturePoint;
             velocity[axis] &&
                 updateOrder(value, point[axis].get(), velocity[axis]);
             onDrag === null || onDrag === void 0 ? void 0 : onDrag(event, gesturePoint);
-        }, onLayoutMeasure: function (measured) {
+        }, onLayoutMeasure: (measured) => {
             measuredLayout.current = measured;
         }, ref: externalRef }), children));
 }
-var Item = forwardRef(ReorderItem);
+const Item = forwardRef(ReorderItem);
 
 export { Item, ReorderItem };

package/dist/es/components/Reorder/index.mjs

@@ -1,9 +1,9 @@
 import { Group } from './Group.mjs';
 import { Item } from './Item.mjs';
 
-var Reorder = {
-    Group: Group,
-    Item: Item,
+const Reorder = {
+    Group,
+    Item,
 };
 
 export { Reorder };

package/dist/es/components/Reorder/utils/check-reorder.mjs

@@ -4,16 +4,16 @@ import { moveItem } from '../../../utils/array.mjs';
 function checkReorder(order, value, offset, velocity) {
     if (!velocity)
         return order;
-    var index = order.findIndex(function (item) { return item.value === value; });
+    const index = order.findIndex((item) => item.value === value);
     if (index === -1)
         return order;
-    var nextOffset = velocity > 0 ? 1 : -1;
-    var nextItem = order[index + nextOffset];
+    const nextOffset = velocity > 0 ? 1 : -1;
+    const nextItem = order[index + nextOffset];
     if (!nextItem)
         return order;
-    var item = order[index];
-    var nextLayout = nextItem.layout;
-    var nextItemCenter = mix(nextLayout.min, nextLayout.max, 0.5);
+    const item = order[index];
+    const nextLayout = nextItem.layout;
+    const nextItemCenter = mix(nextLayout.min, nextLayout.max, 0.5);
     if ((nextOffset === 1 && item.layout.max + offset > nextItemCenter) ||
         (nextOffset === -1 && item.layout.min + offset < nextItemCenter)) {
         return moveItem(order, index, index + nextOffset);

package/dist/es/context/DeprecatedLayoutGroupContext.mjs

@@ -3,6 +3,6 @@ import { createContext } from 'react';
 /**
  * @deprecated
  */
-var DeprecatedLayoutGroupContext = createContext(null);
+const DeprecatedLayoutGroupContext = createContext(null);
 
 export { DeprecatedLayoutGroupContext };

package/dist/es/context/LayoutGroupContext.mjs

@@ -1,5 +1,5 @@
 import { createContext } from 'react';
 
-var LayoutGroupContext = createContext({});
+const LayoutGroupContext = createContext({});
 
 export { LayoutGroupContext };

package/dist/es/context/LazyContext.mjs

@@ -1,5 +1,5 @@
 import { createContext } from 'react';
 
-var LazyContext = createContext({ strict: false });
+const LazyContext = createContext({ strict: false });
 
 export { LazyContext };

package/dist/es/context/MotionConfigContext.mjs

@@ -3,8 +3,8 @@ import { createContext } from 'react';
 /**
  * @public
  */
-var MotionConfigContext = createContext({
-    transformPagePoint: function (p) { return p; },
+const MotionConfigContext = createContext({
+    transformPagePoint: (p) => p,
     isStatic: false,
     reducedMotion: "never",
 });

package/dist/es/context/MotionContext/create.mjs

@@ -3,8 +3,8 @@ import { MotionContext } from './index.mjs';
 import { getCurrentTreeVariants } from './utils.mjs';
 
 function useCreateMotionContext(props) {
-    var _a = getCurrentTreeVariants(props, useContext(MotionContext)), initial = _a.initial, animate = _a.animate;
-    return useMemo(function () { return ({ initial: initial, animate: animate }); }, [variantLabelsAsDependency(initial), variantLabelsAsDependency(animate)]);
+    const { initial, animate } = getCurrentTreeVariants(props, useContext(MotionContext));
+    return useMemo(() => ({ initial, animate }), [variantLabelsAsDependency(initial), variantLabelsAsDependency(animate)]);
 }
 function variantLabelsAsDependency(prop) {
     return Array.isArray(prop) ? prop.join(" ") : prop;

package/dist/es/context/MotionContext/index.mjs

@@ -1,6 +1,6 @@
 import { createContext, useContext } from 'react';
 
-var MotionContext = createContext({});
+const MotionContext = createContext({});
 function useVisualElementContext() {
     return useContext(MotionContext).visualElement;
 }

package/dist/es/context/MotionContext/utils.mjs

@@ -2,7 +2,7 @@ import { checkIfControllingVariants, isVariantLabel } from '../../render/utils/v
 
 function getCurrentTreeVariants(props, context) {
     if (checkIfControllingVariants(props)) {
-        var initial = props.initial, animate = props.animate;
+        const { initial, animate } = props;
         return {
             initial: initial === false || isVariantLabel(initial)
                 ? initial

package/dist/es/context/PresenceContext.mjs

@@ -3,6 +3,6 @@ import { createContext } from 'react';
 /**
  * @public
  */
-var PresenceContext = createContext(null);
+const PresenceContext = createContext(null);
 
 export { PresenceContext };

package/dist/es/context/ReorderContext.mjs

@@ -1,5 +1,5 @@
 import { createContext } from 'react';
 
-var ReorderContext = createContext(null);
+const ReorderContext = createContext(null);
 
 export { ReorderContext };

package/dist/es/context/SwitchLayoutGroupContext.mjs

@@ -3,6 +3,6 @@ import { createContext } from 'react';
 /**
  * Internal, exported only for usage in Framer
  */
-var SwitchLayoutGroupContext = createContext({});
+const SwitchLayoutGroupContext = createContext({});
 
 export { SwitchLayoutGroupContext };

package/dist/es/events/event-info.mjs

@@ -5,45 +5,39 @@ import { isTouchEvent } from '../gestures/utils/event-type.mjs';
  * @param eventHandler
  */
 function filterPrimaryPointer(eventHandler) {
-    return function (event) {
-        var isMouseEvent = event instanceof MouseEvent;
-        var isPrimaryPointer = !isMouseEvent ||
+    return (event) => {
+        const isMouseEvent = event instanceof MouseEvent;
+        const isPrimaryPointer = !isMouseEvent ||
             (isMouseEvent && event.button === 0);
         if (isPrimaryPointer) {
             eventHandler(event);
         }
     };
 }
-var defaultPagePoint = { pageX: 0, pageY: 0 };
-function pointFromTouch(e, pointType) {
-    if (pointType === void 0) { pointType = "page"; }
-    var primaryTouch = e.touches[0] || e.changedTouches[0];
-    var point = primaryTouch || defaultPagePoint;
+const defaultPagePoint = { pageX: 0, pageY: 0 };
+function pointFromTouch(e, pointType = "page") {
+    const primaryTouch = e.touches[0] || e.changedTouches[0];
+    const point = primaryTouch || defaultPagePoint;
     return {
         x: point[pointType + "X"],
         y: point[pointType + "Y"],
     };
 }
-function pointFromMouse(point, pointType) {
-    if (pointType === void 0) { pointType = "page"; }
+function pointFromMouse(point, pointType = "page") {
     return {
         x: point[pointType + "X"],
         y: point[pointType + "Y"],
     };
 }
-function extractEventInfo(event, pointType) {
-    if (pointType === void 0) { pointType = "page"; }
+function extractEventInfo(event, pointType = "page") {
     return {
         point: isTouchEvent(event)
             ? pointFromTouch(event, pointType)
             : pointFromMouse(event, pointType),
     };
 }
-var wrapHandler = function (handler, shouldFilterPrimaryPointer) {
-    if (shouldFilterPrimaryPointer === void 0) { shouldFilterPrimaryPointer = false; }
-    var listener = function (event) {
-        return handler(event, extractEventInfo(event));
-    };
+const wrapHandler = (handler, shouldFilterPrimaryPointer = false) => {
+    const listener = (event) => handler(event, extractEventInfo(event));
     return shouldFilterPrimaryPointer
         ? filterPrimaryPointer(listener)
         : listener;