@vkzstudio/muza-ui 1.0.0 → 1.0.1

package/dist/node_modules/framer-motion/dist/es/gestures/drag/utils/constraints.js

@@ -0,0 +1,67 @@
+import { calcLength as r } from "../../../projection/geometry/delta-calc.js";
+import { mixNumber as t } from "../../../../../../motion-dom/dist/es/utils/mix/number.js";
+import { progress as u } from "../../../../../../motion-utils/dist/es/progress.js";
+import { clamp as C } from "../../../../../../motion-utils/dist/es/clamp.js";
+function a(n, { min: e, max: m }, i) {
+  return e !== void 0 && n < e ? n = i ? t(e, n, i.min) : Math.max(n, e) : m !== void 0 && n > m && (n = i ? t(m, n, i.max) : Math.min(n, m)), n;
+}
+function o(n, e, m) {
+  return {
+    min: e !== void 0 ? n.min + e : void 0,
+    max: m !== void 0 ? n.max + m - (n.max - n.min) : void 0
+  };
+}
+function L(n, { top: e, left: m, bottom: i, right: f }) {
+  return {
+    x: o(n.x, m, f),
+    y: o(n.y, e, i)
+  };
+}
+function x(n, e) {
+  let m = e.min - n.min, i = e.max - n.max;
+  return e.max - e.min < n.max - n.min && ([m, i] = [i, m]), { min: m, max: i };
+}
+function w(n, e) {
+  return {
+    x: x(n.x, e.x),
+    y: x(n.y, e.y)
+  };
+}
+function y(n, e) {
+  let m = 0.5;
+  const i = r(n), f = r(e);
+  return f > i ? m = u(e.min, e.max - i, n.min) : i > f && (m = u(n.min, n.max - f, e.min)), C(0, 1, m);
+}
+function M(n, e) {
+  const m = {};
+  return e.min !== void 0 && (m.min = e.min - n.min), e.max !== void 0 && (m.max = e.max - n.min), m;
+}
+const c = 0.35;
+function R(n = c) {
+  return n === !1 ? n = 0 : n === !0 && (n = c), {
+    x: l(n, "left", "right"),
+    y: l(n, "top", "bottom")
+  };
+}
+function l(n, e, m) {
+  return {
+    min: d(n, e),
+    max: d(n, m)
+  };
+}
+function d(n, e) {
+  return typeof n == "number" ? n : n[e] || 0;
+}
+export {
+  a as applyConstraints,
+  y as calcOrigin,
+  o as calcRelativeAxisConstraints,
+  L as calcRelativeConstraints,
+  x as calcViewportAxisConstraints,
+  w as calcViewportConstraints,
+  c as defaultElastic,
+  M as rebaseAxisConstraints,
+  l as resolveAxisElastic,
+  R as resolveDragElastic,
+  d as resolvePointElastic
+};

package/dist/node_modules/framer-motion/dist/es/gestures/focus.js

@@ -0,0 +1,28 @@
+import { addDomEvent as e } from "../events/add-dom-event.js";
+import { Feature as i } from "../motion/features/Feature.js";
+import { pipe as s } from "../../../../motion-utils/dist/es/pipe.js";
+class a extends i {
+  constructor() {
+    super(...arguments), this.isActive = !1;
+  }
+  onFocus() {
+    let t = !1;
+    try {
+      t = this.node.current.matches(":focus-visible");
+    } catch {
+      t = !0;
+    }
+    !t || !this.node.animationState || (this.node.animationState.setActive("whileFocus", !0), this.isActive = !0);
+  }
+  onBlur() {
+    !this.isActive || !this.node.animationState || (this.node.animationState.setActive("whileFocus", !1), this.isActive = !1);
+  }
+  mount() {
+    this.unmount = s(e(this.node.current, "focus", () => this.onFocus()), e(this.node.current, "blur", () => this.onBlur()));
+  }
+  unmount() {
+  }
+}
+export {
+  a as FocusGesture
+};

package/dist/node_modules/framer-motion/dist/es/gestures/hover.js

@@ -0,0 +1,21 @@
+import { extractEventInfo as m } from "../events/event-info.js";
+import { Feature as s } from "../motion/features/Feature.js";
+import { hover as u } from "../../../../motion-dom/dist/es/gestures/hover.js";
+import { frame as c } from "../../../../motion-dom/dist/es/frameloop/frame.js";
+function a(e, t, r) {
+  const { props: o } = e;
+  e.animationState && o.whileHover && e.animationState.setActive("whileHover", r === "Start");
+  const n = "onHover" + r, i = o[n];
+  i && c.postRender(() => i(t, m(t)));
+}
+class d extends s {
+  mount() {
+    const { current: t } = this.node;
+    t && (this.unmount = u(t, (r, o) => (a(this.node, o, "Start"), (n) => a(this.node, n, "End"))));
+  }
+  unmount() {
+  }
+}
+export {
+  d as HoverGesture
+};

package/dist/node_modules/framer-motion/dist/es/gestures/pan/PanSession.js

@@ -0,0 +1,84 @@
+import { addPointerEvent as m } from "../../events/add-pointer-event.js";
+import { extractEventInfo as S } from "../../events/event-info.js";
+import { distance2D as T } from "../../utils/distance.js";
+import { frameData as x, frame as D, cancelFrame as W } from "../../../../../motion-dom/dist/es/frameloop/frame.js";
+import { isPrimaryPointer as L } from "../../../../../motion-dom/dist/es/gestures/utils/is-primary-pointer.js";
+import { pipe as U } from "../../../../../motion-utils/dist/es/pipe.js";
+import { secondsToMilliseconds as O, millisecondsToSeconds as V } from "../../../../../motion-utils/dist/es/time-conversion.js";
+class C {
+  constructor(n, o, { transformPagePoint: e, contextWindow: r = window, dragSnapToOrigin: h = !1, distanceThreshold: s = 3 } = {}) {
+    if (this.startEvent = null, this.lastMoveEvent = null, this.lastMoveEventInfo = null, this.handlers = {}, this.contextWindow = window, this.updatePoint = () => {
+      if (!(this.lastMoveEvent && this.lastMoveEventInfo))
+        return;
+      const i = p(this.lastMoveEventInfo, this.history), a = this.startEvent !== null, c = T(i.offset, { x: 0, y: 0 }) >= this.distanceThreshold;
+      if (!a && !c)
+        return;
+      const { point: f } = i, { timestamp: d } = x;
+      this.history.push({ ...f, timestamp: d });
+      const { onStart: l, onMove: E } = this.handlers;
+      a || (l && l(this.lastMoveEvent, i), this.startEvent = this.lastMoveEvent), E && E(this.lastMoveEvent, i);
+    }, this.handlePointerMove = (i, a) => {
+      this.lastMoveEvent = i, this.lastMoveEventInfo = v(a, this.transformPagePoint), D.update(this.updatePoint, !0);
+    }, this.handlePointerUp = (i, a) => {
+      this.end();
+      const { onEnd: c, onSessionEnd: f, resumeAnimation: d } = this.handlers;
+      if (this.dragSnapToOrigin && d && d(), !(this.lastMoveEvent && this.lastMoveEventInfo))
+        return;
+      const l = p(i.type === "pointercancel" ? this.lastMoveEventInfo : v(a, this.transformPagePoint), this.history);
+      this.startEvent && c && c(i, l), f && f(i, l);
+    }, !L(n))
+      return;
+    this.dragSnapToOrigin = h, this.handlers = o, this.transformPagePoint = e, this.distanceThreshold = s, this.contextWindow = r || window;
+    const g = S(n), u = v(g, this.transformPagePoint), { point: w } = u, { timestamp: I } = x;
+    this.history = [{ ...w, timestamp: I }];
+    const { onSessionStart: P } = o;
+    P && P(n, p(u, this.history)), this.removeListeners = U(m(this.contextWindow, "pointermove", this.handlePointerMove), m(this.contextWindow, "pointerup", this.handlePointerUp), m(this.contextWindow, "pointercancel", this.handlePointerUp));
+  }
+  updateHandlers(n) {
+    this.handlers = n;
+  }
+  end() {
+    this.removeListeners && this.removeListeners(), W(this.updatePoint);
+  }
+}
+function v(t, n) {
+  return n ? { point: n(t.point) } : t;
+}
+function y(t, n) {
+  return { x: t.x - n.x, y: t.y - n.y };
+}
+function p({ point: t }, n) {
+  return {
+    point: t,
+    delta: y(t, M(n)),
+    offset: y(t, b(n)),
+    velocity: k(n, 0.1)
+  };
+}
+function b(t) {
+  return t[0];
+}
+function M(t) {
+  return t[t.length - 1];
+}
+function k(t, n) {
+  if (t.length < 2)
+    return { x: 0, y: 0 };
+  let o = t.length - 1, e = null;
+  const r = M(t);
+  for (; o >= 0 && (e = t[o], !(r.timestamp - e.timestamp > O(n))); )
+    o--;
+  if (!e)
+    return { x: 0, y: 0 };
+  const h = V(r.timestamp - e.timestamp);
+  if (h === 0)
+    return { x: 0, y: 0 };
+  const s = {
+    x: (r.x - e.x) / h,
+    y: (r.y - e.y) / h
+  };
+  return s.x === 1 / 0 && (s.x = 0), s.y === 1 / 0 && (s.y = 0), s;
+}
+export {
+  C as PanSession
+};

package/dist/node_modules/framer-motion/dist/es/gestures/pan/index.js

@@ -0,0 +1,43 @@
+import { addPointerEvent as m } from "../../events/add-pointer-event.js";
+import { Feature as P } from "../../motion/features/Feature.js";
+import { getContextWindow as h } from "../../utils/get-context-window.js";
+import { PanSession as p } from "./PanSession.js";
+import { noop as u } from "../../../../../motion-utils/dist/es/noop.js";
+import { frame as r } from "../../../../../motion-dom/dist/es/frameloop/frame.js";
+const s = (e) => (n, o) => {
+  e && r.postRender(() => e(n, o));
+};
+class v extends P {
+  constructor() {
+    super(...arguments), this.removePointerDownListener = u;
+  }
+  onPointerDown(n) {
+    this.session = new p(n, this.createPanHandlers(), {
+      transformPagePoint: this.node.getTransformPagePoint(),
+      contextWindow: h(this.node)
+    });
+  }
+  createPanHandlers() {
+    const { onPanSessionStart: n, onPanStart: o, onPan: i, onPanEnd: t } = this.node.getProps();
+    return {
+      onSessionStart: s(n),
+      onStart: s(o),
+      onMove: i,
+      onEnd: (a, d) => {
+        delete this.session, t && r.postRender(() => t(a, d));
+      }
+    };
+  }
+  mount() {
+    this.removePointerDownListener = m(this.node.current, "pointerdown", (n) => this.onPointerDown(n));
+  }
+  update() {
+    this.session && this.session.updateHandlers(this.createPanHandlers());
+  }
+  unmount() {
+    this.removePointerDownListener(), this.session && this.session.end();
+  }
+}
+export {
+  v as PanGesture
+};

package/dist/node_modules/framer-motion/dist/es/gestures/press.js

@@ -0,0 +1,23 @@
+import { extractEventInfo as i } from "../events/event-info.js";
+import { Feature as m } from "../motion/features/Feature.js";
+import { press as u } from "../../../../motion-dom/dist/es/gestures/press/index.js";
+import { frame as p } from "../../../../motion-dom/dist/es/frameloop/frame.js";
+function s(t, e, n) {
+  const { props: r } = t;
+  if (t.current instanceof HTMLButtonElement && t.current.disabled)
+    return;
+  t.animationState && r.whileTap && t.animationState.setActive("whileTap", n === "Start");
+  const a = "onTap" + (n === "End" ? "" : n), o = r[a];
+  o && p.postRender(() => o(e, i(e)));
+}
+class d extends m {
+  mount() {
+    const { current: e } = this.node;
+    e && (this.unmount = u(e, (n, r) => (s(this.node, r, "Start"), (a, { success: o }) => s(this.node, a, o ? "End" : "Cancel")), { useGlobalTarget: this.node.props.globalTapTarget }));
+  }
+  unmount() {
+  }
+}
+export {
+  d as PressGesture
+};

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

@@ -0,0 +1,10 @@
+class s {
+  constructor(t) {
+    this.isMounted = !1, this.node = t;
+  }
+  update() {
+  }
+}
+export {
+  s as Feature
+};

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

@@ -0,0 +1,27 @@
+import { Feature as s } from "../Feature.js";
+let o = 0;
+class d extends s {
+  constructor() {
+    super(...arguments), this.id = o++;
+  }
+  update() {
+    if (!this.node.presenceContext)
+      return;
+    const { isPresent: t, onExitComplete: e } = this.node.presenceContext, { isPresent: n } = this.node.prevPresenceContext || {};
+    if (!this.node.animationState || t === n)
+      return;
+    const i = this.node.animationState.setActive("exit", !t);
+    e && !t && i.then(() => {
+      e(this.id);
+    });
+  }
+  mount() {
+    const { register: t, onExitComplete: e } = this.node.presenceContext || {};
+    e && e(this.id), t && (this.unmount = t(this.id));
+  }
+  unmount() {
+  }
+}
+export {
+  d as ExitAnimationFeature
+};

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

@@ -0,0 +1,34 @@
+import { isAnimationControls as o } from "../../../animation/utils/is-animation-controls.js";
+import { createAnimationState as i } from "../../../render/utils/animation-state.js";
+import { Feature as s } from "../Feature.js";
+class u extends s {
+  /**
+   * 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(t) {
+    super(t), t.animationState || (t.animationState = i(t));
+  }
+  updateAnimationControlsSubscription() {
+    const { animate: t } = this.node.getProps();
+    o(t) && (this.unmountControls = t.subscribe(this.node));
+  }
+  /**
+   * Subscribe any provided AnimationControls to the component's VisualElement
+   */
+  mount() {
+    this.updateAnimationControlsSubscription();
+  }
+  update() {
+    const { animate: t } = this.node.getProps(), { animate: n } = this.node.prevProps || {};
+    t !== n && this.updateAnimationControlsSubscription();
+  }
+  unmount() {
+    var t;
+    this.node.animationState.reset(), (t = this.unmountControls) == null || t.call(this);
+  }
+}
+export {
+  u as AnimationFeature
+};

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

@@ -0,0 +1,13 @@
+import { AnimationFeature as t } from "./animation/index.js";
+import { ExitAnimationFeature as i } from "./animation/exit.js";
+const o = {
+  animation: {
+    Feature: t
+  },
+  exit: {
+    Feature: i
+  }
+};
+export {
+  o as animations
+};

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

@@ -0,0 +1,27 @@
+const n = {
+  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"]
+}, t = {};
+for (const e in n)
+  t[e] = {
+    isEnabled: (o) => n[e].some((a) => !!o[a])
+  };
+export {
+  t as featureDefinitions
+};

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

@@ -0,0 +1,17 @@
+import { DragGesture as r } from "../../gestures/drag/index.js";
+import { PanGesture as o } from "../../gestures/pan/index.js";
+import { MeasureLayout as e } from "./layout/MeasureLayout.js";
+import { HTMLProjectionNode as t } from "../../projection/node/HTMLProjectionNode.js";
+const u = {
+  pan: {
+    Feature: o
+  },
+  drag: {
+    Feature: r,
+    ProjectionNode: t,
+    MeasureLayout: e
+  }
+};
+export {
+  u as drag
+};

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

@@ -0,0 +1,21 @@
+import { HoverGesture as e } from "../../gestures/hover.js";
+import { FocusGesture as r } from "../../gestures/focus.js";
+import { PressGesture as t } from "../../gestures/press.js";
+import { InViewFeature as o } from "./viewport/index.js";
+const a = {
+  inView: {
+    Feature: o
+  },
+  tap: {
+    Feature: t
+  },
+  focus: {
+    Feature: r
+  },
+  hover: {
+    Feature: e
+  }
+};
+export {
+  a as gestureAnimations
+};

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

@@ -0,0 +1,75 @@
+import { jsx as m } from "react/jsx-runtime";
+import { useContext as d, Component as f } from "react";
+import { usePresence as c } from "../../../components/AnimatePresence/use-presence.js";
+import { LayoutGroupContext as l } from "../../../context/LayoutGroupContext.js";
+import { SwitchLayoutGroupContext as h } from "../../../context/SwitchLayoutGroupContext.js";
+import { globalProjectionState as R } from "../../../projection/node/state.js";
+import { correctBorderRadius as n } from "../../../projection/styles/scale-border-radius.js";
+import { correctBoxShadow as g } from "../../../projection/styles/scale-box-shadow.js";
+import { addScaleCorrector as y } from "../../../projection/styles/scale-correction.js";
+import { frame as T } from "../../../../../../motion-dom/dist/es/frameloop/frame.js";
+import { microtask as v } from "../../../../../../motion-dom/dist/es/frameloop/microtask.js";
+let a = !1;
+class L extends f {
+  /**
+   * 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: e, layoutGroup: t, switchLayoutGroup: r, layoutId: s } = this.props, { projection: o } = e;
+    y(b), o && (t.group && t.group.add(o), r && r.register && s && r.register(o), a && o.root.didUpdate(), o.addEventListener("animationComplete", () => {
+      this.safeToRemove();
+    }), o.setOptions({
+      ...o.options,
+      onExitComplete: () => this.safeToRemove()
+    })), R.hasEverUpdated = !0;
+  }
+  getSnapshotBeforeUpdate(e) {
+    const { layoutDependency: t, visualElement: r, drag: s, isPresent: o } = this.props, { projection: i } = r;
+    return i && (i.isPresent = o, a = !0, s || e.layoutDependency !== t || t === void 0 || e.isPresent !== o ? i.willUpdate() : this.safeToRemove(), e.isPresent !== o && (o ? i.promote() : i.relegate() || T.postRender(() => {
+      const u = i.getStack();
+      (!u || !u.members.length) && this.safeToRemove();
+    }))), null;
+  }
+  componentDidUpdate() {
+    const { projection: e } = this.props.visualElement;
+    e && (e.root.didUpdate(), v.postRender(() => {
+      !e.currentAnimation && e.isLead() && this.safeToRemove();
+    }));
+  }
+  componentWillUnmount() {
+    const { visualElement: e, layoutGroup: t, switchLayoutGroup: r } = this.props, { projection: s } = e;
+    a = !0, s && (s.scheduleCheckAfterUnmount(), t && t.group && t.group.remove(s), r && r.deregister && r.deregister(s));
+  }
+  safeToRemove() {
+    const { safeToRemove: e } = this.props;
+    e && e();
+  }
+  render() {
+    return null;
+  }
+}
+function D(p) {
+  const [e, t] = c(), r = d(l);
+  return m(L, { ...p, layoutGroup: r, switchLayoutGroup: d(h), isPresent: e, safeToRemove: t });
+}
+const b = {
+  borderRadius: {
+    ...n,
+    applyTo: [
+      "borderTopLeftRadius",
+      "borderTopRightRadius",
+      "borderBottomLeftRadius",
+      "borderBottomRightRadius"
+    ]
+  },
+  borderTopLeftRadius: n,
+  borderTopRightRadius: n,
+  borderBottomLeftRadius: n,
+  borderBottomRightRadius: n,
+  boxShadow: g
+};
+export {
+  D as MeasureLayout
+};

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

@@ -0,0 +1,11 @@
+import { HTMLProjectionNode as o } from "../../projection/node/HTMLProjectionNode.js";
+import { MeasureLayout as t } from "./layout/MeasureLayout.js";
+const a = {
+  layout: {
+    ProjectionNode: o,
+    MeasureLayout: t
+  }
+};
+export {
+  a as layout
+};

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

@@ -0,0 +1,11 @@
+import { featureDefinitions as n } from "./definitions.js";
+function e(i) {
+  for (const o in i)
+    n[o] = {
+      ...n[o],
+      ...i[o]
+    };
+}
+export {
+  e as loadFeatures
+};

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

@@ -0,0 +1,44 @@
+import { Feature as m } from "../Feature.js";
+import { observeIntersection as f } from "./observers.js";
+const w = {
+  some: 0,
+  all: 1
+};
+class v extends m {
+  constructor() {
+    super(...arguments), this.hasEnteredView = !1, this.isInView = !1;
+  }
+  startObserver() {
+    this.unmount();
+    const { viewport: n = {} } = this.node.getProps(), { root: t, margin: r, amount: s = "some", once: h } = n, u = {
+      root: t ? t.current : void 0,
+      rootMargin: r,
+      threshold: typeof s == "number" ? s : w[s]
+    }, c = (i) => {
+      const { isIntersecting: e } = i;
+      if (this.isInView === e || (this.isInView = e, h && !e && this.hasEnteredView))
+        return;
+      e && (this.hasEnteredView = !0), this.node.animationState && this.node.animationState.setActive("whileInView", e);
+      const { onViewportEnter: p, onViewportLeave: d } = this.node.getProps(), a = e ? p : d;
+      a && a(i);
+    };
+    return f(this.node.current, u, c);
+  }
+  mount() {
+    this.startObserver();
+  }
+  update() {
+    if (typeof IntersectionObserver > "u")
+      return;
+    const { props: n, prevProps: t } = this.node;
+    ["amount", "margin", "root"].some(l(n, t)) && this.startObserver();
+  }
+  unmount() {
+  }
+}
+function l({ viewport: o = {} }, { viewport: n = {} } = {}) {
+  return (t) => o[t] !== n[t];
+}
+export {
+  v as InViewFeature
+};

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

@@ -0,0 +1,21 @@
+const c = /* @__PURE__ */ new WeakMap(), n = /* @__PURE__ */ new WeakMap(), a = (e) => {
+  const r = c.get(e.target);
+  r && r(e);
+}, b = (e) => {
+  e.forEach(a);
+};
+function i({ root: e, ...r }) {
+  const t = e || document;
+  n.has(t) || n.set(t, {});
+  const s = n.get(t), o = JSON.stringify(r);
+  return s[o] || (s[o] = new IntersectionObserver(b, { root: e, ...r })), s[o];
+}
+function v(e, r, t) {
+  const s = i(r);
+  return c.set(e, t), s.observe(e), () => {
+    c.delete(e), s.unobserve(e);
+  };
+}
+export {
+  v as observeIntersection
+};

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

@@ -0,0 +1,63 @@
+import { jsxs as y, jsx as v } from "react/jsx-runtime";
+import { forwardRef as S, useContext as c } from "react";
+import { LayoutGroupContext as x } from "../context/LayoutGroupContext.js";
+import { LazyContext as E } from "../context/LazyContext.js";
+import { MotionConfigContext as L } from "../context/MotionConfigContext.js";
+import { MotionContext as g } from "../context/MotionContext/index.js";
+import { useCreateMotionContext as j } from "../context/MotionContext/create.js";
+import { useRender as N } from "../render/dom/use-render.js";
+import { isSVGComponent as P } from "../render/dom/utils/is-svg-component.js";
+import { useHTMLVisualState as V } from "../render/html/use-html-visual-state.js";
+import { useSVGVisualState as w } from "../render/svg/use-svg-visual-state.js";
+import { isBrowser as C } from "../utils/is-browser.js";
+import { featureDefinitions as b } from "./features/definitions.js";
+import { loadFeatures as h } from "./features/load-features.js";
+import { motionComponentSymbol as z } from "./utils/symbol.js";
+import { useMotionRef as G } from "./utils/use-motion-ref.js";
+import { useVisualElement as R } from "./utils/use-visual-element.js";
+import { warning as D, invariant as k } from "../../../../motion-utils/dist/es/errors.js";
+function it(t, { forwardMotionProps: o = !1 } = {}, e, i) {
+  e && h(e);
+  const p = P(t) ? w : V;
+  function f(n, M) {
+    let a;
+    const r = {
+      ...c(L),
+      ...n,
+      layoutId: I(n)
+    }, { isStatic: m } = r, s = j(n), u = p(n, m);
+    if (!m && C) {
+      O(r, e);
+      const d = T(r);
+      a = d.MeasureLayout, s.visualElement = R(t, u, r, i, d.ProjectionNode);
+    }
+    return y(g.Provider, { value: s, children: [a && s.visualElement ? v(a, { visualElement: s.visualElement, ...r }) : null, N(t, n, G(u, s.visualElement, M), u, m, o)] });
+  }
+  f.displayName = `motion.${typeof t == "string" ? t : `create(${t.displayName ?? t.name ?? ""})`}`;
+  const l = S(f);
+  return l[z] = t, l;
+}
+function I({ layoutId: t }) {
+  const o = c(x).id;
+  return o && t !== void 0 ? o + "-" + t : t;
+}
+function O(t, o) {
+  const e = c(E).strict;
+  if (process.env.NODE_ENV !== "production" && o && e) {
+    const i = "You have rendered a `motion` component within a `LazyMotion` component. This will break tree shaking. Import and render a `m` component instead.";
+    t.ignoreStrict ? D(!1, i, "lazy-strict-mode") : k(!1, i, "lazy-strict-mode");
+  }
+}
+function T(t) {
+  const { drag: o, layout: e } = b;
+  if (!o && !e)
+    return {};
+  const i = { ...o, ...e };
+  return {
+    MeasureLayout: o != null && o.isEnabled(t) || e != null && e.isEnabled(t) ? i.MeasureLayout : void 0,
+    ProjectionNode: i.ProjectionNode
+  };
+}
+export {
+  it as createMotionComponent
+};

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

@@ -0,0 +1,8 @@
+import { scaleCorrectors as i } from "../../projection/styles/scale-correction.js";
+import { transformProps as n } from "../../../../../motion-dom/dist/es/render/utils/keys-transform.js";
+function c(r, { layout: o, layoutId: t }) {
+  return n.has(r) || r.startsWith("origin") || (o || t !== void 0) && (!!i[r] || r === "opacity");
+}
+export {
+  c as isForcedMotionValue
+};