@code0-tech/pictor 0.9.3 → 0.10.1

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

@@ -0,0 +1,285 @@
+import { addPointerEvent as k } from "../../events/add-pointer-event.js";
+import { extractEventInfo as B } from "../../events/event-info.js";
+import { getContextWindow as j } from "../../utils/get-context-window.js";
+import { isRefObject as P } from "../../utils/is-ref-object.js";
+import { PanSession as T } from "../pan/PanSession.js";
+import { applyConstraints as b, calcRelativeConstraints as I, resolveDragElastic as w, calcViewportConstraints as R, defaultElastic as O, rebaseAxisConstraints as W, calcOrigin as z } from "./utils/constraints.js";
+import { createBox as F } from "../../../../../motion-dom/dist/es/projection/geometry/models.js";
+import { frame as C } from "../../../../../motion-dom/dist/es/frameloop/frame.js";
+import { eachAxis as p } from "../../../../../motion-dom/dist/es/projection/utils/each-axis.js";
+import { invariant as U } from "../../../../../motion-utils/dist/es/errors.js";
+import { measurePageBox as _ } from "../../../../../motion-dom/dist/es/projection/utils/measure.js";
+import { convertBoxToBoundingBox as K, convertBoundingBoxToBox as N } from "../../../../../motion-dom/dist/es/projection/geometry/conversion.js";
+import { addValueToWillChange as L } from "../../../../../motion-dom/dist/es/value/will-change/add-will-change.js";
+import { animateMotionValue as $ } from "../../../../../motion-dom/dist/es/animation/interfaces/motion-value.js";
+import { addDomEvent as q } from "../../../../../motion-dom/dist/es/events/add-dom-event.js";
+import { setDragLock as G } from "../../../../../motion-dom/dist/es/gestures/drag/state/set-active.js";
+import { resize as V } from "../../../../../motion-dom/dist/es/resize/index.js";
+import { percent as H } from "../../../../../motion-dom/dist/es/value/types/numbers/units.js";
+import { calcLength as J } from "../../../../../motion-dom/dist/es/projection/geometry/delta-calc.js";
+import { mixNumber as M } from "../../../../../motion-dom/dist/es/utils/mix/number.js";
+import { isElementTextInput as Q } from "../../../../../motion-dom/dist/es/gestures/press/utils/is-keyboard-accessible.js";
+const X = /* @__PURE__ */ new WeakMap();
+class At {
+  constructor(t) {
+    this.openDragLock = null, this.isDragging = !1, this.currentDirection = null, this.originPoint = { x: 0, y: 0 }, this.constraints = !1, this.hasMutatedConstraints = !1, this.elastic = F(), this.latestPointerEvent = null, this.latestPanInfo = null, this.visualElement = t;
+  }
+  start(t, { snapToCursor: s = !1, distanceThreshold: n } = {}) {
+    const { presenceContext: i } = this.visualElement;
+    if (i && i.isPresent === !1)
+      return;
+    const e = (r) => {
+      s && this.snapToCursor(B(r).point), this.stopAnimation();
+    }, o = (r, l) => {
+      const { drag: g, dragPropagation: d, onDragStart: v } = this.getProps();
+      if (g && !d && (this.openDragLock && this.openDragLock(), this.openDragLock = G(g), !this.openDragLock))
+        return;
+      this.latestPointerEvent = r, this.latestPanInfo = l, this.isDragging = !0, this.currentDirection = null, this.resolveConstraints(), this.visualElement.projection && (this.visualElement.projection.isAnimationBlocked = !0, this.visualElement.projection.target = void 0), p((f) => {
+        let D = this.getAxisMotionValue(f).get() || 0;
+        if (H.test(D)) {
+          const { projection: y } = this.visualElement;
+          if (y && y.layout) {
+            const x = y.layout.layoutBox[f];
+            x && (D = J(x) * (parseFloat(D) / 100));
+          }
+        }
+        this.originPoint[f] = D;
+      }), v && C.update(() => v(r, l), !1, !0), L(this.visualElement, "transform");
+      const { animationState: E } = this.visualElement;
+      E && E.setActive("whileDrag", !0);
+    }, a = (r, l) => {
+      this.latestPointerEvent = r, this.latestPanInfo = l;
+      const { dragPropagation: g, dragDirectionLock: d, onDirectionLock: v, onDrag: E } = this.getProps();
+      if (!g && !this.openDragLock)
+        return;
+      const { offset: f } = l;
+      if (d && this.currentDirection === null) {
+        this.currentDirection = Z(f), this.currentDirection !== null && v && v(this.currentDirection);
+        return;
+      }
+      this.updateAxis("x", l.point, f), this.updateAxis("y", l.point, f), this.visualElement.render(), E && C.update(() => E(r, l), !1, !0);
+    }, u = (r, l) => {
+      this.latestPointerEvent = r, this.latestPanInfo = l, this.stop(r, l), this.latestPointerEvent = null, this.latestPanInfo = null;
+    }, c = () => {
+      const { dragSnapToOrigin: r } = this.getProps();
+      (r || this.constraints) && this.startAnimation({ x: 0, y: 0 });
+    }, { dragSnapToOrigin: h } = this.getProps();
+    this.panSession = new T(t, {
+      onSessionStart: e,
+      onStart: o,
+      onMove: a,
+      onSessionEnd: u,
+      resumeAnimation: c
+    }, {
+      transformPagePoint: this.visualElement.getTransformPagePoint(),
+      dragSnapToOrigin: h,
+      distanceThreshold: n,
+      contextWindow: j(this.visualElement),
+      element: this.visualElement.current
+    });
+  }
+  /**
+   * @internal
+   */
+  stop(t, s) {
+    const n = t || this.latestPointerEvent, i = s || this.latestPanInfo, e = this.isDragging;
+    if (this.cancel(), !e || !i || !n)
+      return;
+    const { velocity: o } = i;
+    this.startAnimation(o);
+    const { onDragEnd: a } = this.getProps();
+    a && C.postRender(() => a(n, i));
+  }
+  /**
+   * @internal
+   */
+  cancel() {
+    this.isDragging = !1;
+    const { projection: t, animationState: s } = this.visualElement;
+    t && (t.isAnimationBlocked = !1), this.endPanSession();
+    const { dragPropagation: n } = this.getProps();
+    !n && this.openDragLock && (this.openDragLock(), this.openDragLock = null), s && s.setActive("whileDrag", !1);
+  }
+  /**
+   * Clean up the pan session without modifying other drag state.
+   * This is used during unmount to ensure event listeners are removed
+   * without affecting projection animations or drag locks.
+   * @internal
+   */
+  endPanSession() {
+    this.panSession && this.panSession.end(), this.panSession = void 0;
+  }
+  updateAxis(t, s, n) {
+    const { drag: i } = this.getProps();
+    if (!n || !A(t, i, this.currentDirection))
+      return;
+    const e = this.getAxisMotionValue(t);
+    let o = this.originPoint[t] + n[t];
+    this.constraints && this.constraints[t] && (o = b(o, this.constraints[t], this.elastic[t])), e.set(o);
+  }
+  resolveConstraints() {
+    const { dragConstraints: t, dragElastic: s } = this.getProps(), n = this.visualElement.projection && !this.visualElement.projection.layout ? this.visualElement.projection.measure(!1) : this.visualElement.projection?.layout, i = this.constraints;
+    t && P(t) ? this.constraints || (this.constraints = this.resolveRefConstraints()) : t && n ? this.constraints = I(n.layoutBox, t) : this.constraints = !1, this.elastic = w(s), i !== this.constraints && !P(t) && n && this.constraints && !this.hasMutatedConstraints && p((e) => {
+      this.constraints !== !1 && this.getAxisMotionValue(e) && (this.constraints[e] = W(n.layoutBox[e], this.constraints[e]));
+    });
+  }
+  resolveRefConstraints() {
+    const { dragConstraints: t, onMeasureDragConstraints: s } = this.getProps();
+    if (!t || !P(t))
+      return !1;
+    const n = t.current;
+    U(n !== null, "If `dragConstraints` is set as a React ref, that ref must be passed to another component's `ref` prop.", "drag-constraints-ref");
+    const { projection: i } = this.visualElement;
+    if (!i || !i.layout)
+      return !1;
+    i.root && (i.root.scroll = void 0, i.root.updateScroll());
+    const e = _(n, i.root, this.visualElement.getTransformPagePoint());
+    let o = R(i.layout.layoutBox, e);
+    if (s) {
+      const a = s(K(o));
+      this.hasMutatedConstraints = !!a, a && (o = N(a));
+    }
+    return o;
+  }
+  startAnimation(t) {
+    const { drag: s, dragMomentum: n, dragElastic: i, dragTransition: e, dragSnapToOrigin: o, onDragTransitionEnd: a } = this.getProps(), u = this.constraints || {}, c = p((h) => {
+      if (!A(h, s, this.currentDirection))
+        return;
+      let r = u && u[h] || {};
+      (o === !0 || o === h) && (r = { min: 0, max: 0 });
+      const l = i ? 200 : 1e6, g = i ? 40 : 1e7, d = {
+        type: "inertia",
+        velocity: n ? t[h] : 0,
+        bounceStiffness: l,
+        bounceDamping: g,
+        timeConstant: 750,
+        restDelta: 1,
+        restSpeed: 10,
+        ...e,
+        ...r
+      };
+      return this.startAxisValueAnimation(h, d);
+    });
+    return Promise.all(c).then(a);
+  }
+  startAxisValueAnimation(t, s) {
+    const n = this.getAxisMotionValue(t);
+    return L(this.visualElement, t), n.start($(t, n, 0, s, this.visualElement, !1));
+  }
+  stopAnimation() {
+    p((t) => this.getAxisMotionValue(t).stop());
+  }
+  /**
+   * Drag works differently depending on which props are provided.
+   *
+   * - If _dragX and _dragY are provided, we output the gesture delta directly to those motion values.
+   * - Otherwise, we apply the delta to the x/y motion values.
+   */
+  getAxisMotionValue(t) {
+    const s = `_drag${t.toUpperCase()}`, i = this.visualElement.getProps()[s];
+    return i || this.visualElement.getValue(t, this.visualElement.latestValues[t] ?? 0);
+  }
+  snapToCursor(t) {
+    p((s) => {
+      const { drag: n } = this.getProps();
+      if (!A(s, n, this.currentDirection))
+        return;
+      const { projection: i } = this.visualElement, e = this.getAxisMotionValue(s);
+      if (i && i.layout) {
+        const { min: o, max: a } = i.layout.layoutBox[s], u = e.get() || 0;
+        e.set(t[s] - M(o, a, 0.5) + u);
+      }
+    });
+  }
+  /**
+   * When the viewport resizes we want to check if the measured constraints
+   * have changed and, if so, reposition the element within those new constraints
+   * relative to where it was before the resize.
+   */
+  scalePositionWithinConstraints() {
+    if (!this.visualElement.current)
+      return;
+    const { drag: t, dragConstraints: s } = this.getProps(), { projection: n } = this.visualElement;
+    if (!P(s) || !n || !this.constraints)
+      return;
+    this.stopAnimation();
+    const i = { x: 0, y: 0 };
+    p((o) => {
+      const a = this.getAxisMotionValue(o);
+      if (a && this.constraints !== !1) {
+        const u = a.get();
+        i[o] = z({ min: u, max: u }, this.constraints[o]);
+      }
+    });
+    const { transformTemplate: e } = this.visualElement.getProps();
+    this.visualElement.current.style.transform = e ? e({}, "") : "none", n.root && n.root.updateScroll(), n.updateLayout(), this.constraints = !1, this.resolveConstraints(), p((o) => {
+      if (!A(o, t, null))
+        return;
+      const a = this.getAxisMotionValue(o), { min: u, max: c } = this.constraints[o];
+      a.set(M(u, c, i[o]));
+    }), this.visualElement.render();
+  }
+  addListeners() {
+    if (!this.visualElement.current)
+      return;
+    X.set(this.visualElement, this);
+    const t = this.visualElement.current, s = k(t, "pointerdown", (c) => {
+      const { drag: h, dragListener: r = !0 } = this.getProps(), l = c.target, g = l !== t && Q(l);
+      h && r && !g && this.start(c);
+    });
+    let n;
+    const i = () => {
+      const { dragConstraints: c } = this.getProps();
+      P(c) && c.current && (this.constraints = this.resolveRefConstraints(), n || (n = Y(t, c.current, () => this.scalePositionWithinConstraints())));
+    }, { projection: e } = this.visualElement, o = e.addEventListener("measure", i);
+    e && !e.layout && (e.root && e.root.updateScroll(), e.updateLayout()), C.read(i);
+    const a = q(window, "resize", () => this.scalePositionWithinConstraints()), u = e.addEventListener("didUpdate", (({ delta: c, hasLayoutChanged: h }) => {
+      this.isDragging && h && (p((r) => {
+        const l = this.getAxisMotionValue(r);
+        l && (this.originPoint[r] += c[r].translate, l.set(l.get() + c[r].translate));
+      }), this.visualElement.render());
+    }));
+    return () => {
+      a(), s(), o(), u && u(), n && n();
+    };
+  }
+  getProps() {
+    const t = this.visualElement.getProps(), { drag: s = !1, dragDirectionLock: n = !1, dragPropagation: i = !1, dragConstraints: e = !1, dragElastic: o = O, dragMomentum: a = !0 } = t;
+    return {
+      ...t,
+      drag: s,
+      dragDirectionLock: n,
+      dragPropagation: i,
+      dragConstraints: e,
+      dragElastic: o,
+      dragMomentum: a
+    };
+  }
+}
+function S(m) {
+  let t = !0;
+  return () => {
+    if (t) {
+      t = !1;
+      return;
+    }
+    m();
+  };
+}
+function Y(m, t, s) {
+  const n = V(m, S(s)), i = V(t, S(s));
+  return () => {
+    n(), i();
+  };
+}
+function A(m, t, s) {
+  return (t === !0 || t === m) && (s === null || s === m);
+}
+function Z(m, t = 10) {
+  let s = null;
+  return Math.abs(m.y) > t ? s = "y" : Math.abs(m.x) > t && (s = "x"), s;
+}
+export {
+  At as VisualElementDragControls,
+  X as elementDragControls
+};

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

@@ -0,0 +1,22 @@
+import { VisualElementDragControls as t } from "./VisualElementDragControls.js";
+import { Feature as e } from "../../../../../motion-dom/dist/es/render/Feature.js";
+import { noop as s } from "../../../../../motion-utils/dist/es/noop.js";
+class m extends e {
+  constructor(o) {
+    super(o), this.removeGroupControls = s, this.removeListeners = s, this.controls = new t(o);
+  }
+  mount() {
+    const { dragControls: o } = this.node.getProps();
+    o && (this.removeGroupControls = o.subscribe(this.controls)), this.removeListeners = this.controls.addListeners() || s;
+  }
+  update() {
+    const { dragControls: o } = this.node.getProps(), { dragControls: r } = this.node.prevProps || {};
+    o !== r && (this.removeGroupControls(), o && (this.removeGroupControls = o.subscribe(this.controls)));
+  }
+  unmount() {
+    this.removeGroupControls(), this.removeListeners(), this.controls.isDragging || this.controls.endPanSession();
+  }
+}
+export {
+  m as DragGesture
+};

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

@@ -0,0 +1,67 @@
+import { mixNumber as r } from "../../../../../../motion-dom/dist/es/utils/mix/number.js";
+import { calcLength as t } from "../../../../../../motion-dom/dist/es/projection/geometry/delta-calc.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 ? r(e, n, i.min) : Math.max(n, e) : m !== void 0 && n > m && (n = i ? r(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 = t(n), f = t(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 { Feature as i } from "../../../../motion-dom/dist/es/render/Feature.js";
+import { pipe as s } from "../../../../motion-utils/dist/es/pipe.js";
+import { addDomEvent as e } from "../../../../motion-dom/dist/es/events/add-dom-event.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-dom/dist/es/render/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,130 @@
+import { addPointerEvent as m } from "../../events/add-pointer-event.js";
+import { extractEventInfo as D } from "../../events/event-info.js";
+import { distance2D as R } from "../../utils/distance.js";
+import { frameData as y, frame as x, cancelFrame as k } from "../../../../../motion-dom/dist/es/frameloop/frame.js";
+import { isPrimaryPointer as U } from "../../../../../motion-dom/dist/es/gestures/utils/is-primary-pointer.js";
+import { pipe as X } from "../../../../../motion-utils/dist/es/pipe.js";
+import { secondsToMilliseconds as S, millisecondsToSeconds as Y } from "../../../../../motion-utils/dist/es/time-conversion.js";
+const M = /* @__PURE__ */ new Set(["auto", "scroll"]);
+class z {
+  constructor(t, s, { transformPagePoint: i, contextWindow: r = window, dragSnapToOrigin: o = !1, distanceThreshold: l = 3, element: u } = {}) {
+    if (this.startEvent = null, this.lastMoveEvent = null, this.lastMoveEventInfo = null, this.lastRawMoveEventInfo = 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;
+      this.lastRawMoveEventInfo && (this.lastMoveEventInfo = v(this.lastRawMoveEventInfo, this.transformPagePoint));
+      const e = p(this.lastMoveEventInfo, this.history), a = this.startEvent !== null, c = R(e.offset, { x: 0, y: 0 }) >= this.distanceThreshold;
+      if (!a && !c)
+        return;
+      const { point: f } = e, { timestamp: d } = y;
+      this.history.push({ ...f, timestamp: d });
+      const { onStart: h, onMove: P } = this.handlers;
+      a || (h && h(this.lastMoveEvent, e), this.startEvent = this.lastMoveEvent), P && P(this.lastMoveEvent, e);
+    }, this.handlePointerMove = (e, a) => {
+      this.lastMoveEvent = e, this.lastRawMoveEventInfo = a, this.lastMoveEventInfo = v(a, this.transformPagePoint), x.update(this.updatePoint, !0);
+    }, this.handlePointerUp = (e, a) => {
+      this.end();
+      const { onEnd: c, onSessionEnd: f, resumeAnimation: d } = this.handlers;
+      if ((this.dragSnapToOrigin || !this.startEvent) && d && d(), !(this.lastMoveEvent && this.lastMoveEventInfo))
+        return;
+      const h = p(e.type === "pointercancel" ? this.lastMoveEventInfo : v(a, this.transformPagePoint), this.history);
+      this.startEvent && c && c(e, h), f && f(e, h);
+    }, !U(t))
+      return;
+    this.dragSnapToOrigin = o, this.handlers = s, this.transformPagePoint = i, this.distanceThreshold = l, this.contextWindow = r || window;
+    const L = D(t), w = v(L, this.transformPagePoint), { point: T } = w, { timestamp: W } = y;
+    this.history = [{ ...T, timestamp: W }];
+    const { onSessionStart: E } = s;
+    E && E(t, p(w, this.history)), this.removeListeners = X(m(this.contextWindow, "pointermove", this.handlePointerMove), m(this.contextWindow, "pointerup", this.handlePointerUp), m(this.contextWindow, "pointercancel", this.handlePointerUp)), u && this.startScrollTracking(u);
+  }
+  /**
+   * Start tracking scroll on ancestors and window.
+   */
+  startScrollTracking(t) {
+    let s = t.parentElement;
+    for (; s; ) {
+      const i = getComputedStyle(s);
+      (M.has(i.overflowX) || M.has(i.overflowY)) && this.scrollPositions.set(s, {
+        x: s.scrollLeft,
+        y: s.scrollTop
+      }), s = s.parentElement;
+    }
+    this.scrollPositions.set(window, {
+      x: window.scrollX,
+      y: window.scrollY
+    }), window.addEventListener("scroll", this.onElementScroll, {
+      capture: !0
+    }), window.addEventListener("scroll", this.onWindowScroll), 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 s = this.scrollPositions.get(t);
+    if (!s)
+      return;
+    const i = t === window, r = i ? { x: window.scrollX, y: window.scrollY } : {
+      x: t.scrollLeft,
+      y: t.scrollTop
+    }, o = { x: r.x - s.x, y: r.y - s.y };
+    o.x === 0 && o.y === 0 || (i ? 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 v(n, t) {
+  return t ? { point: t(n.point) } : n;
+}
+function I(n, t) {
+  return { x: n.x - t.x, y: n.y - t.y };
+}
+function p({ point: n }, t) {
+  return {
+    point: n,
+    delta: I(n, g(t)),
+    offset: I(n, O(t)),
+    velocity: V(t, 0.1)
+  };
+}
+function O(n) {
+  return n[0];
+}
+function g(n) {
+  return n[n.length - 1];
+}
+function V(n, t) {
+  if (n.length < 2)
+    return { x: 0, y: 0 };
+  let s = n.length - 1, i = null;
+  const r = g(n);
+  for (; s >= 0 && (i = n[s], !(r.timestamp - i.timestamp > S(t))); )
+    s--;
+  if (!i)
+    return { x: 0, y: 0 };
+  i === n[0] && n.length > 2 && r.timestamp - i.timestamp > S(t) * 2 && (i = n[1]);
+  const o = Y(r.timestamp - i.timestamp);
+  if (o === 0)
+    return { x: 0, y: 0 };
+  const l = {
+    x: (r.x - i.x) / o,
+    y: (r.y - i.y) / o
+  };
+  return l.x === 1 / 0 && (l.x = 0), l.y === 1 / 0 && (l.y = 0), l;
+}
+export {
+  z 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 { getContextWindow as P } from "../../utils/get-context-window.js";
+import { PanSession as h } from "./PanSession.js";
+import { Feature as p } from "../../../../../motion-dom/dist/es/render/Feature.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 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/node_modules/framer-motion/dist/es/gestures/press.js

@@ -0,0 +1,29 @@
+import { extractEventInfo as m } from "../events/event-info.js";
+import { Feature as u } from "../../../../motion-dom/dist/es/render/Feature.js";
+import { press as c } from "../../../../motion-dom/dist/es/gestures/press/index.js";
+import { frame as f } 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 o = "onTap" + (n === "End" ? "" : n), a = r[o];
+  a && f.postRender(() => a(e, m(e)));
+}
+class g extends u {
+  mount() {
+    const { current: e } = this.node;
+    if (!e)
+      return;
+    const { globalTapTarget: n, propagate: r } = this.node.props;
+    this.unmount = c(e, (o, a) => (s(this.node, a, "Start"), (i, { success: p }) => s(this.node, i, p ? "End" : "Cancel")), {
+      useGlobalTarget: n,
+      stopPropagation: r?.tap === !1
+    });
+  }
+  unmount() {
+  }
+}
+export {
+  g as PressGesture
+};

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

@@ -0,0 +1,45 @@
+import { Feature as h } from "../../../../../../motion-dom/dist/es/render/Feature.js";
+import { resolveVariant as d } from "../../../../../../motion-dom/dist/es/render/utils/resolve-dynamic-variants.js";
+let p = 0;
+class C extends h {
+  constructor() {
+    super(...arguments), this.id = p++, this.isExitComplete = !1;
+  }
+  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;
+    if (t && n === !1) {
+      if (this.isExitComplete) {
+        const { initial: i, custom: m } = this.node.getProps();
+        if (typeof i == "string" || typeof i == "object" && i !== null && !Array.isArray(i)) {
+          const s = d(this.node, i, m);
+          if (s) {
+            const { transition: l, transitionEnd: u, ...o } = s;
+            for (const r in o)
+              this.node.getValue(r)?.jump(o[r]);
+          }
+        }
+        this.node.animationState.reset(), this.node.animationState.animateChanges();
+      } else
+        this.node.animationState.setActive("exit", !1);
+      this.isExitComplete = !1;
+      return;
+    }
+    const a = this.node.animationState.setActive("exit", !t);
+    e && !t && a.then(() => {
+      this.isExitComplete = !0, e(this.id);
+    });
+  }
+  mount() {
+    const { register: t, onExitComplete: e } = this.node.presenceContext || {};
+    e && e(this.id), t && (this.unmount = t(this.id));
+  }
+  unmount() {
+  }
+}
+export {
+  C as ExitAnimationFeature
+};