@t-headless-ui/react 1.1.1 → 1.1.3

package/dist/es/node_modules/.pnpm/framer-motion@12.31.2_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/gestures/pan/PanSession.mjs

@@ -0,0 +1,131 @@
+import { addPointerEvent as v } from "../../events/add-pointer-event.mjs";
+import { extractEventInfo as W } from "../../events/event-info.mjs";
+import { distance2D as D } from "../../utils/distance.mjs";
+import { frameData as P, frame as x, cancelFrame as k } from "../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/frameloop/frame.mjs";
+import { isPrimaryPointer as U } from "../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/gestures/utils/is-primary-pointer.mjs";
+import { pipe as X } from "../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/pipe.mjs";
+import { secondsToMilliseconds as Y, millisecondsToSeconds as O } from "../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/time-conversion.mjs";
+const S = /* @__PURE__ */ new Set(["auto", "scroll"]);
+class B {
+  constructor(t, i, { transformPagePoint: s, contextWindow: r = window, dragSnapToOrigin: o = !1, distanceThreshold: l = 3, element: p } = {}) {
+    if (this.startEvent = null, this.lastMoveEvent = null, this.lastMoveEventInfo = null, this.handlers = {}, this.contextWindow = window, this.scrollPositions = /* @__PURE__ */ new Map(), this.removeScrollListeners = null, this.onElementScroll = (e) => {
+      this.handleScroll(e.target);
+    }, this.onWindowScroll = () => {
+      this.handleScroll(window);
+    }, this.updatePoint = () => {
+      if (!(this.lastMoveEvent && this.lastMoveEventInfo))
+        return;
+      const e = u(this.lastMoveEventInfo, this.history), h = this.startEvent !== null, c = D(e.offset, { x: 0, y: 0 }) >= this.distanceThreshold;
+      if (!h && !c)
+        return;
+      const { point: d } = e, { timestamp: f } = P;
+      this.history.push({ ...d, timestamp: f });
+      const { onStart: a, onMove: E } = this.handlers;
+      h || (a && a(this.lastMoveEvent, e), this.startEvent = this.lastMoveEvent), E && E(this.lastMoveEvent, e);
+    }, this.handlePointerMove = (e, h) => {
+      this.lastMoveEvent = e, this.lastMoveEventInfo = m(h, this.transformPagePoint), x.update(this.updatePoint, !0);
+    }, this.handlePointerUp = (e, h) => {
+      this.end();
+      const { onEnd: c, onSessionEnd: d, resumeAnimation: f } = this.handlers;
+      if ((this.dragSnapToOrigin || !this.startEvent) && f && f(), !(this.lastMoveEvent && this.lastMoveEventInfo))
+        return;
+      const a = u(e.type === "pointercancel" ? this.lastMoveEventInfo : m(h, this.transformPagePoint), this.history);
+      this.startEvent && c && c(e, a), d && d(e, a);
+    }, !U(t))
+      return;
+    this.dragSnapToOrigin = o, this.handlers = i, this.transformPagePoint = s, this.distanceThreshold = l, this.contextWindow = r || window;
+    const g = W(t), w = m(g, this.transformPagePoint), { point: L } = w, { timestamp: T } = P;
+    this.history = [{ ...L, timestamp: T }];
+    const { onSessionStart: y } = i;
+    y && y(t, u(w, this.history)), this.removeListeners = X(v(this.contextWindow, "pointermove", this.handlePointerMove), v(this.contextWindow, "pointerup", this.handlePointerUp), v(this.contextWindow, "pointercancel", this.handlePointerUp)), p && this.startScrollTracking(p);
+  }
+  /**
+   * Start tracking scroll on ancestors and window.
+   */
+  startScrollTracking(t) {
+    let i = t.parentElement;
+    for (; i; ) {
+      const s = getComputedStyle(i);
+      (S.has(s.overflowX) || S.has(s.overflowY)) && this.scrollPositions.set(i, {
+        x: i.scrollLeft,
+        y: i.scrollTop
+      }), i = i.parentElement;
+    }
+    this.scrollPositions.set(window, {
+      x: window.scrollX,
+      y: window.scrollY
+    }), window.addEventListener("scroll", this.onElementScroll, {
+      capture: !0,
+      passive: !0
+    }), window.addEventListener("scroll", this.onWindowScroll, {
+      passive: !0
+    }), this.removeScrollListeners = () => {
+      window.removeEventListener("scroll", this.onElementScroll, {
+        capture: !0
+      }), window.removeEventListener("scroll", this.onWindowScroll);
+    };
+  }
+  /**
+   * Handle scroll compensation during drag.
+   *
+   * For element scroll: adjusts history origin since pageX/pageY doesn't change.
+   * For window scroll: adjusts lastMoveEventInfo since pageX/pageY would change.
+   */
+  handleScroll(t) {
+    const i = this.scrollPositions.get(t);
+    if (!i)
+      return;
+    const s = t === window, r = s ? { x: window.scrollX, y: window.scrollY } : {
+      x: t.scrollLeft,
+      y: t.scrollTop
+    }, o = { x: r.x - i.x, y: r.y - i.y };
+    o.x === 0 && o.y === 0 || (s ? this.lastMoveEventInfo && (this.lastMoveEventInfo.point.x += o.x, this.lastMoveEventInfo.point.y += o.y) : this.history.length > 0 && (this.history[0].x -= o.x, this.history[0].y -= o.y), this.scrollPositions.set(t, r), x.update(this.updatePoint, !0));
+  }
+  updateHandlers(t) {
+    this.handlers = t;
+  }
+  end() {
+    this.removeListeners && this.removeListeners(), this.removeScrollListeners && this.removeScrollListeners(), this.scrollPositions.clear(), k(this.updatePoint);
+  }
+}
+function m(n, t) {
+  return t ? { point: t(n.point) } : n;
+}
+function M(n, t) {
+  return { x: n.x - t.x, y: n.y - t.y };
+}
+function u({ point: n }, t) {
+  return {
+    point: n,
+    delta: M(n, I(t)),
+    offset: M(n, V(t)),
+    velocity: b(t, 0.1)
+  };
+}
+function V(n) {
+  return n[0];
+}
+function I(n) {
+  return n[n.length - 1];
+}
+function b(n, t) {
+  if (n.length < 2)
+    return { x: 0, y: 0 };
+  let i = n.length - 1, s = null;
+  const r = I(n);
+  for (; i >= 0 && (s = n[i], !(r.timestamp - s.timestamp > Y(t))); )
+    i--;
+  if (!s)
+    return { x: 0, y: 0 };
+  const o = O(r.timestamp - s.timestamp);
+  if (o === 0)
+    return { x: 0, y: 0 };
+  const l = {
+    x: (r.x - s.x) / o,
+    y: (r.y - s.y) / o
+  };
+  return l.x === 1 / 0 && (l.x = 0), l.y === 1 / 0 && (l.y = 0), l;
+}
+export {
+  B as PanSession
+};

package/dist/es/node_modules/.pnpm/framer-motion@12.31.2_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/gestures/pan/index.mjs

@@ -0,0 +1,43 @@
+import { addPointerEvent as m } from "../../events/add-pointer-event.mjs";
+import { getContextWindow as P } from "../../utils/get-context-window.mjs";
+import { PanSession as h } from "./PanSession.mjs";
+import { Feature as p } from "../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/render/Feature.mjs";
+import { noop as u } from "../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/noop.mjs";
+import { frame as r } from "../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/frameloop/frame.mjs";
+const o = (e) => (n, t) => {
+  e && r.update(() => e(n, t), !1, !0);
+};
+class v extends p {
+  constructor() {
+    super(...arguments), this.removePointerDownListener = u;
+  }
+  onPointerDown(n) {
+    this.session = new h(n, this.createPanHandlers(), {
+      transformPagePoint: this.node.getTransformPagePoint(),
+      contextWindow: P(this.node)
+    });
+  }
+  createPanHandlers() {
+    const { onPanSessionStart: n, onPanStart: t, onPan: i, onPanEnd: s } = this.node.getProps();
+    return {
+      onSessionStart: o(n),
+      onStart: o(t),
+      onMove: o(i),
+      onEnd: (a, d) => {
+        delete this.session, s && r.postRender(() => s(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/es/node_modules/.pnpm/framer-motion@12.31.2_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/gestures/press.mjs

@@ -0,0 +1,23 @@
+import { extractEventInfo as i } from "../events/event-info.mjs";
+import { Feature as m } from "../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/render/Feature.mjs";
+import { press as u } from "../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/gestures/press/index.mjs";
+import { frame as p } from "../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/frameloop/frame.mjs";
+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/es/node_modules/.pnpm/framer-motion@12.31.2_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/motion/features/animation/exit.mjs

@@ -0,0 +1,27 @@
+import { Feature as s } from "../../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/render/Feature.mjs";
+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/es/node_modules/.pnpm/framer-motion@12.31.2_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/motion/features/animation/index.mjs

@@ -0,0 +1,34 @@
+import { Feature as o } from "../../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/render/Feature.mjs";
+import { createAnimationState as i } from "../../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/render/utils/animation-state.mjs";
+import { isAnimationControls as s } from "../../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/render/utils/is-animation-controls.mjs";
+class u extends o {
+  /**
+   * 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();
+    s(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/es/node_modules/.pnpm/framer-motion@12.31.2_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/motion/features/definitions.mjs

@@ -0,0 +1,39 @@
+import { getFeatureDefinitions as r, setFeatureDefinitions as s } from "../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/render/VisualElement.mjs";
+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"]
+};
+let t = !1;
+function l() {
+  if (t)
+    return;
+  const e = {};
+  for (const i in n)
+    e[i] = {
+      isEnabled: (o) => n[i].some((a) => !!o[a])
+    };
+  s(e), t = !0;
+}
+function w() {
+  return l(), r();
+}
+export {
+  w as getInitializedFeatureDefinitions,
+  l as initFeatureDefinitions
+};

package/dist/es/node_modules/.pnpm/framer-motion@12.31.2_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/motion/features/drag.mjs

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

package/dist/es/node_modules/.pnpm/framer-motion@12.31.2_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/motion/features/layout/MeasureLayout.mjs

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

package/dist/es/node_modules/.pnpm/framer-motion@12.31.2_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/motion/features/layout.mjs

@@ -0,0 +1,11 @@
+import { MeasureLayout as o } from "./layout/MeasureLayout.mjs";
+import { HTMLProjectionNode as t } from "../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/projection/node/HTMLProjectionNode.mjs";
+const a = {
+  layout: {
+    ProjectionNode: t,
+    MeasureLayout: o
+  }
+};
+export {
+  a as layout
+};

package/dist/es/node_modules/.pnpm/framer-motion@12.31.2_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/motion/features/load-features.mjs

@@ -0,0 +1,14 @@
+import { getInitializedFeatureDefinitions as o } from "./definitions.mjs";
+import { setFeatureDefinitions as n } from "../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/render/VisualElement.mjs";
+function s(e) {
+  const i = o();
+  for (const t in e)
+    i[t] = {
+      ...i[t],
+      ...e[t]
+    };
+  n(i);
+}
+export {
+  s as loadFeatures
+};

package/dist/es/node_modules/.pnpm/framer-motion@12.31.2_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/motion/features/viewport/index.mjs

@@ -0,0 +1,44 @@
+import { observeIntersection as m } from "./observers.mjs";
+import { Feature as f } from "../../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/render/Feature.mjs";
+const w = {
+  some: 0,
+  all: 1
+};
+class v extends f {
+  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 m(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/es/node_modules/.pnpm/framer-motion@12.31.2_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/motion/index.mjs

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

package/dist/es/node_modules/.pnpm/framer-motion@12.31.2_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/motion/utils/use-motion-ref.mjs

@@ -0,0 +1,23 @@
+"use client";
+import { useRef as C, useInsertionEffect as l, useCallback as y } from "react";
+function R(n, f, e) {
+  const c = C(e);
+  l(() => {
+    c.current = e;
+  });
+  const u = C(null);
+  return y((r) => {
+    var t;
+    r && ((t = n.onMount) == null || t.call(n, r)), f && (r ? f.mount(r) : f.unmount());
+    const o = c.current;
+    if (typeof o == "function")
+      if (r) {
+        const p = o(r);
+        typeof p == "function" && (u.current = p);
+      } else u.current ? (u.current(), u.current = null) : o(r);
+    else o && (o.current = r);
+  }, [f]);
+}
+export {
+  R as useMotionRef
+};

package/dist/es/node_modules/.pnpm/framer-motion@12.31.2_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/framer-motion/dist/es/motion/utils/use-visual-element.mjs

@@ -0,0 +1,67 @@
+"use client";
+import { useContext as s, useRef as l, useInsertionEffect as k, useEffect as S } from "react";
+import { LazyContext as L } from "../../context/LazyContext.mjs";
+import { MotionConfigContext as O } from "../../context/MotionConfigContext.mjs";
+import { MotionContext as R } from "../../context/MotionContext/index.mjs";
+import { PresenceContext as b } from "../../context/PresenceContext.mjs";
+import { SwitchLayoutGroupContext as H } from "../../context/SwitchLayoutGroupContext.mjs";
+import { isRefObject as z } from "../../utils/is-ref-object.mjs";
+import { useIsomorphicLayoutEffect as P } from "../../utils/use-isomorphic-effect.mjs";
+import { optimizedAppearDataAttribute as B } from "../../../../../../../motion-dom@12.31.2/node_modules/motion-dom/dist/es/animation/optimized-appear/data-id.mjs";
+function W(o, u, n, e, f, a) {
+  var w, h;
+  const { visualElement: C } = s(R), c = s(L), i = s(b), d = s(O), y = d.reducedMotion, j = d.skipAnimations, r = l(null), M = l(!1);
+  e = e || c.renderer, !r.current && e && (r.current = e(o, {
+    visualState: u,
+    parent: C,
+    props: n,
+    presenceContext: i,
+    blockInitialAnimation: i ? i.initial === !1 : !1,
+    reducedMotionConfig: y,
+    skipAnimations: j,
+    isSVG: a
+  }), M.current && r.current && (r.current.manuallyAnimateOnMount = !0));
+  const t = r.current, I = s(H);
+  t && !t.projection && f && (t.type === "html" || t.type === "svg") && G(r.current, n, f, I);
+  const g = l(!1);
+  k(() => {
+    t && g.current && t.update(n, i);
+  });
+  const m = n[B], p = l(!!m && !((w = window.MotionHandoffIsComplete) != null && w.call(window, m)) && ((h = window.MotionHasOptimisedAnimation) == null ? void 0 : h.call(window, m)));
+  return P(() => {
+    M.current = !0, t && (g.current = !0, window.MotionIsMounted = !0, t.updateFeatures(), t.scheduleRenderMicrotask(), p.current && t.animationState && t.animationState.animateChanges());
+  }), S(() => {
+    t && (!p.current && t.animationState && t.animationState.animateChanges(), p.current && (queueMicrotask(() => {
+      var x;
+      (x = window.MotionHandoffMarkAsComplete) == null || x.call(window, m);
+    }), p.current = !1), t.enteringChildren = void 0);
+  }), t;
+}
+function G(o, u, n, e) {
+  const { layoutId: f, layout: a, drag: C, dragConstraints: c, layoutScroll: i, layoutRoot: d, layoutCrossfade: y } = u;
+  o.projection = new n(o.latestValues, u["data-framer-portal-id"] ? void 0 : A(o.parent)), o.projection.setOptions({
+    layoutId: f,
+    layout: a,
+    alwaysMeasureLayout: !!C || c && z(c),
+    visualElement: o,
+    /**
+     * TODO: Update options in an effect. This could be tricky as it'll be too late
+     * to update by the time layout animations run.
+     * We also need to fix this safeToRemove by linking it up to the one returned by usePresence,
+     * ensuring it gets called if there's no potential layout animations.
+     *
+     */
+    animationType: typeof a == "string" ? a : "both",
+    initialPromotionConfig: e,
+    crossfade: y,
+    layoutScroll: i,
+    layoutRoot: d
+  });
+}
+function A(o) {
+  if (o)
+    return o.options.allowProjection !== !1 ? o.projection : A(o.parent);
+}
+export {
+  W as useVisualElement
+};