lawgic-dev-kit 0.2.4 → 0.3.4

package/dist/node_modules/framer-motion/dist/es/context/LayoutGroupContext.js

@@ -0,0 +1,5 @@
+import { createContext as t } from "react";
+const e = t({});
+export {
+  e as LayoutGroupContext
+};

package/dist/node_modules/framer-motion/dist/es/context/LazyContext.js

@@ -0,0 +1,5 @@
+import { createContext as t } from "react";
+const o = t({ strict: !1 });
+export {
+  o as LazyContext
+};

package/dist/node_modules/framer-motion/dist/es/context/MotionConfigContext.js

@@ -0,0 +1,9 @@
+import { createContext as o } from "react";
+const n = o({
+  transformPagePoint: (t) => t,
+  isStatic: !1,
+  reducedMotion: "never"
+});
+export {
+  n as MotionConfigContext
+};

package/dist/node_modules/framer-motion/dist/es/context/MotionContext/create.js

@@ -0,0 +1,13 @@
+import { useContext as o, useMemo as i } from "react";
+import { MotionContext as a } from "./index.js";
+import { getCurrentTreeVariants as m } from "./utils.js";
+function C(t) {
+  const { initial: e, animate: n } = m(t, o(a));
+  return i(() => ({ initial: e, animate: n }), [r(e), r(n)]);
+}
+function r(t) {
+  return Array.isArray(t) ? t.join(" ") : t;
+}
+export {
+  C as useCreateMotionContext
+};

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

@@ -0,0 +1,5 @@
+import { createContext as t } from "react";
+const e = /* @__PURE__ */ t({});
+export {
+  e as MotionContext
+};

package/dist/node_modules/framer-motion/dist/es/context/MotionContext/utils.js

@@ -0,0 +1,15 @@
+import { isControllingVariants as r } from "../../render/utils/is-controlling-variants.js";
+import { isVariantLabel as e } from "../../render/utils/is-variant-label.js";
+function o(i, a) {
+  if (r(i)) {
+    const { initial: n, animate: t } = i;
+    return {
+      initial: n === !1 || e(n) ? n : void 0,
+      animate: e(t) ? t : void 0
+    };
+  }
+  return i.inherit !== !1 ? a : {};
+}
+export {
+  o as getCurrentTreeVariants
+};

package/dist/node_modules/framer-motion/dist/es/context/PresenceContext.js

@@ -0,0 +1,5 @@
+import { createContext as e } from "react";
+const o = /* @__PURE__ */ e(null);
+export {
+  o as PresenceContext
+};

package/dist/node_modules/framer-motion/dist/es/context/SwitchLayoutGroupContext.js

@@ -0,0 +1,5 @@
+import { createContext as t } from "react";
+const e = t({});
+export {
+  e as SwitchLayoutGroupContext
+};

package/dist/node_modules/framer-motion/dist/es/easing/anticipate.js

@@ -0,0 +1,5 @@
+import { backIn as o } from "./back.js";
+const c = (t) => (t *= 2) < 1 ? 0.5 * o(t) : 0.5 * (2 - Math.pow(2, -10 * (t - 1)));
+export {
+  c as anticipate
+};

package/dist/node_modules/framer-motion/dist/es/easing/back.js

@@ -0,0 +1,9 @@
+import { cubicBezier as r } from "./cubic-bezier.js";
+import { mirrorEasing as o } from "./modifiers/mirror.js";
+import { reverseEasing as t } from "./modifiers/reverse.js";
+const c = /* @__PURE__ */ r(0.33, 1.53, 0.69, 0.99), i = /* @__PURE__ */ t(c), s = /* @__PURE__ */ o(i);
+export {
+  i as backIn,
+  s as backInOut,
+  c as backOut
+};

package/dist/node_modules/framer-motion/dist/es/easing/circ.js

@@ -0,0 +1,8 @@
+import { mirrorEasing as o } from "./modifiers/mirror.js";
+import { reverseEasing as t } from "./modifiers/reverse.js";
+const r = (c) => 1 - Math.sin(Math.acos(c)), s = t(r), a = o(r);
+export {
+  r as circIn,
+  a as circInOut,
+  s as circOut
+};

package/dist/node_modules/framer-motion/dist/es/easing/cubic-bezier.js

@@ -0,0 +1,19 @@
+import "../../../../motion-utils/dist/es/errors.js";
+import { noop as b } from "../../../../motion-utils/dist/es/noop.js";
+const s = (r, i, n) => (((1 - 3 * n + 3 * i) * r + (3 * n - 6 * i)) * r + 3 * i) * r, f = 1e-7, l = 12;
+function a(r, i, n, c, o) {
+  let e, t, u = 0;
+  do
+    t = i + (n - i) / 2, e = s(t, c, o) - r, e > 0 ? n = t : i = t;
+  while (Math.abs(e) > f && ++u < l);
+  return t;
+}
+function h(r, i, n, c) {
+  if (r === i && n === c)
+    return b;
+  const o = (e) => a(e, 0, 1, r, n);
+  return (e) => e === 0 || e === 1 ? e : s(o(e), i, c);
+}
+export {
+  h as cubicBezier
+};

package/dist/node_modules/framer-motion/dist/es/easing/ease.js

@@ -0,0 +1,7 @@
+import { cubicBezier as e } from "./cubic-bezier.js";
+const o = /* @__PURE__ */ e(0.42, 0, 1, 1), s = /* @__PURE__ */ e(0, 0, 0.58, 1), c = /* @__PURE__ */ e(0.42, 0, 0.58, 1);
+export {
+  o as easeIn,
+  c as easeInOut,
+  s as easeOut
+};

package/dist/node_modules/framer-motion/dist/es/easing/modifiers/mirror.js

@@ -0,0 +1,4 @@
+const t = (o) => (r) => r <= 0.5 ? o(2 * r) / 2 : (2 - o(2 * (1 - r))) / 2;
+export {
+  t as mirrorEasing
+};

package/dist/node_modules/framer-motion/dist/es/easing/modifiers/reverse.js

@@ -0,0 +1,4 @@
+const s = (e) => (r) => 1 - e(1 - r);
+export {
+  s as reverseEasing
+};

package/dist/node_modules/framer-motion/dist/es/easing/utils/is-easing-array.js

@@ -0,0 +1,4 @@
+const n = (r) => Array.isArray(r) && typeof r[0] != "number";
+export {
+  n as isEasingArray
+};

package/dist/node_modules/framer-motion/dist/es/easing/utils/map.js

@@ -0,0 +1,32 @@
+import { invariant as t } from "../../../../../motion-utils/dist/es/errors.js";
+import { noop as i } from "../../../../../motion-utils/dist/es/noop.js";
+import { isBezierDefinition as m } from "../../../../../motion-dom/dist/es/utils/is-bezier-definition.js";
+import { anticipate as u } from "../anticipate.js";
+import { backOut as s, backInOut as p, backIn as f } from "../back.js";
+import { circOut as I, circInOut as b, circIn as l } from "../circ.js";
+import { cubicBezier as O } from "../cubic-bezier.js";
+import { easeOut as g, easeInOut as y, easeIn as k } from "../ease.js";
+const e = {
+  linear: i,
+  easeIn: k,
+  easeInOut: y,
+  easeOut: g,
+  circIn: l,
+  circInOut: b,
+  circOut: I,
+  backIn: f,
+  backInOut: p,
+  backOut: s,
+  anticipate: u
+}, L = (r) => {
+  if (m(r)) {
+    t(r.length === 4, "Cubic bezier arrays must contain four numerical values.");
+    const [o, a, n, c] = r;
+    return O(o, a, n, c);
+  } else if (typeof r == "string")
+    return t(e[r] !== void 0, `Invalid easing type '${r}'`), e[r];
+  return r;
+};
+export {
+  L as easingDefinitionToFunction
+};

package/dist/node_modules/framer-motion/dist/es/events/add-dom-event.js

@@ -0,0 +1,6 @@
+function i(e, n, t, r = { passive: !0 }) {
+  return e.addEventListener(n, t, r), () => e.removeEventListener(n, t);
+}
+export {
+  i as addDomEvent
+};

package/dist/node_modules/framer-motion/dist/es/events/add-pointer-event.js

@@ -0,0 +1,8 @@
+import { addDomEvent as d } from "./add-dom-event.js";
+import { addPointerInfo as e } from "./event-info.js";
+function f(o, r, t, n) {
+  return d(o, r, e(t), n);
+}
+export {
+  f as addPointerEvent
+};

package/dist/node_modules/framer-motion/dist/es/events/event-info.js

@@ -0,0 +1,15 @@
+import "../../../../motion-utils/dist/es/errors.js";
+import { isPrimaryPointer as t } from "../../../../motion-dom/dist/es/gestures/utils/is-primary-pointer.js";
+function i(r) {
+  return {
+    point: {
+      x: r.pageX,
+      y: r.pageY
+    }
+  };
+}
+const a = (r) => (o) => t(o) && r(o, i(o));
+export {
+  a as addPointerInfo,
+  i as extractEventInfo
+};

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

@@ -0,0 +1,256 @@
+import { invariant as L } from "../../../../../motion-utils/dist/es/errors.js";
+import { frame as C } from "../../../../../motion-dom/dist/es/frameloop/frame.js";
+import { setDragLock as M } from "../../../../../motion-dom/dist/es/gestures/drag/state/set-active.js";
+import { animateMotionValue as S } from "../../animation/interfaces/motion-value.js";
+import { addDomEvent as B } from "../../events/add-dom-event.js";
+import { addPointerEvent as k } from "../../events/add-pointer-event.js";
+import { extractEventInfo as j } from "../../events/event-info.js";
+import { convertBoxToBoundingBox as T, convertBoundingBoxToBox as w } from "../../projection/geometry/conversion.js";
+import { calcLength as b } from "../../projection/geometry/delta-calc.js";
+import { createBox as R } from "../../projection/geometry/models.js";
+import { eachAxis as u } from "../../projection/utils/each-axis.js";
+import { measurePageBox as W } from "../../projection/utils/measure.js";
+import { getContextWindow as _ } from "../../utils/get-context-window.js";
+import { isRefObject as D } from "../../utils/is-ref-object.js";
+import { mixNumber as V } from "../../utils/mix/number.js";
+import { percent as O } from "../../value/types/numbers/units.js";
+import { addValueToWillChange as x } from "../../value/use-will-change/add-will-change.js";
+import { PanSession as U } from "../pan/PanSession.js";
+import { applyConstraints as z, calcRelativeConstraints as I, resolveDragElastic as F, calcViewportConstraints as K, defaultElastic as N, rebaseAxisConstraints as $, calcOrigin as q } from "./utils/constraints.js";
+const G = /* @__PURE__ */ new WeakMap();
+class ft {
+  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 = R(), this.visualElement = t;
+  }
+  start(t, { snapToCursor: s = !1 } = {}) {
+    const { presenceContext: i } = this.visualElement;
+    if (i && i.isPresent === !1)
+      return;
+    const n = (o) => {
+      const { dragSnapToOrigin: a } = this.getProps();
+      a ? this.pauseAnimation() : this.stopAnimation(), s && this.snapToCursor(j(o).point);
+    }, r = (o, a) => {
+      const { drag: f, dragPropagation: d, onDragStart: g } = this.getProps();
+      if (f && !d && (this.openDragLock && this.openDragLock(), this.openDragLock = M(f), !this.openDragLock))
+        return;
+      this.isDragging = !0, this.currentDirection = null, this.resolveConstraints(), this.visualElement.projection && (this.visualElement.projection.isAnimationBlocked = !0, this.visualElement.projection.target = void 0), u((m) => {
+        let E = this.getAxisMotionValue(m).get() || 0;
+        if (O.test(E)) {
+          const { projection: A } = this.visualElement;
+          if (A && A.layout) {
+            const y = A.layout.layoutBox[m];
+            y && (E = b(y) * (parseFloat(E) / 100));
+          }
+        }
+        this.originPoint[m] = E;
+      }), g && C.postRender(() => g(o, a)), x(this.visualElement, "transform");
+      const { animationState: v } = this.visualElement;
+      v && v.setActive("whileDrag", !0);
+    }, e = (o, a) => {
+      const { dragPropagation: f, dragDirectionLock: d, onDirectionLock: g, onDrag: v } = this.getProps();
+      if (!f && !this.openDragLock)
+        return;
+      const { offset: m } = a;
+      if (d && this.currentDirection === null) {
+        this.currentDirection = H(m), this.currentDirection !== null && g && g(this.currentDirection);
+        return;
+      }
+      this.updateAxis("x", a.point, m), this.updateAxis("y", a.point, m), this.visualElement.render(), v && v(o, a);
+    }, l = (o, a) => this.stop(o, a), c = () => u((o) => {
+      var a;
+      return this.getAnimationState(o) === "paused" && ((a = this.getAxisMotionValue(o).animation) === null || a === void 0 ? void 0 : a.play());
+    }), { dragSnapToOrigin: h } = this.getProps();
+    this.panSession = new U(t, {
+      onSessionStart: n,
+      onStart: r,
+      onMove: e,
+      onSessionEnd: l,
+      resumeAnimation: c
+    }, {
+      transformPagePoint: this.visualElement.getTransformPagePoint(),
+      dragSnapToOrigin: h,
+      contextWindow: _(this.visualElement)
+    });
+  }
+  stop(t, s) {
+    const i = this.isDragging;
+    if (this.cancel(), !i)
+      return;
+    const { velocity: n } = s;
+    this.startAnimation(n);
+    const { onDragEnd: r } = this.getProps();
+    r && C.postRender(() => r(t, s));
+  }
+  cancel() {
+    this.isDragging = !1;
+    const { projection: t, animationState: s } = this.visualElement;
+    t && (t.isAnimationBlocked = !1), this.panSession && this.panSession.end(), this.panSession = void 0;
+    const { dragPropagation: i } = this.getProps();
+    !i && this.openDragLock && (this.openDragLock(), this.openDragLock = null), s && s.setActive("whileDrag", !1);
+  }
+  updateAxis(t, s, i) {
+    const { drag: n } = this.getProps();
+    if (!i || !P(t, n, this.currentDirection))
+      return;
+    const r = this.getAxisMotionValue(t);
+    let e = this.originPoint[t] + i[t];
+    this.constraints && this.constraints[t] && (e = z(e, this.constraints[t], this.elastic[t])), r.set(e);
+  }
+  resolveConstraints() {
+    var t;
+    const { dragConstraints: s, dragElastic: i } = this.getProps(), n = this.visualElement.projection && !this.visualElement.projection.layout ? this.visualElement.projection.measure(!1) : (t = this.visualElement.projection) === null || t === void 0 ? void 0 : t.layout, r = this.constraints;
+    s && D(s) ? this.constraints || (this.constraints = this.resolveRefConstraints()) : s && n ? this.constraints = I(n.layoutBox, s) : this.constraints = !1, this.elastic = F(i), r !== this.constraints && n && this.constraints && !this.hasMutatedConstraints && u((e) => {
+      this.constraints !== !1 && this.getAxisMotionValue(e) && (this.constraints[e] = $(n.layoutBox[e], this.constraints[e]));
+    });
+  }
+  resolveRefConstraints() {
+    const { dragConstraints: t, onMeasureDragConstraints: s } = this.getProps();
+    if (!t || !D(t))
+      return !1;
+    const i = t.current;
+    L(i !== null, "If `dragConstraints` is set as a React ref, that ref must be passed to another component's `ref` prop.");
+    const { projection: n } = this.visualElement;
+    if (!n || !n.layout)
+      return !1;
+    const r = W(i, n.root, this.visualElement.getTransformPagePoint());
+    let e = K(n.layout.layoutBox, r);
+    if (s) {
+      const l = s(T(e));
+      this.hasMutatedConstraints = !!l, l && (e = w(l));
+    }
+    return e;
+  }
+  startAnimation(t) {
+    const { drag: s, dragMomentum: i, dragElastic: n, dragTransition: r, dragSnapToOrigin: e, onDragTransitionEnd: l } = this.getProps(), c = this.constraints || {}, h = u((o) => {
+      if (!P(o, s, this.currentDirection))
+        return;
+      let a = c && c[o] || {};
+      e && (a = { min: 0, max: 0 });
+      const f = n ? 200 : 1e6, d = n ? 40 : 1e7, g = {
+        type: "inertia",
+        velocity: i ? t[o] : 0,
+        bounceStiffness: f,
+        bounceDamping: d,
+        timeConstant: 750,
+        restDelta: 1,
+        restSpeed: 10,
+        ...r,
+        ...a
+      };
+      return this.startAxisValueAnimation(o, g);
+    });
+    return Promise.all(h).then(l);
+  }
+  startAxisValueAnimation(t, s) {
+    const i = this.getAxisMotionValue(t);
+    return x(this.visualElement, t), i.start(S(t, i, 0, s, this.visualElement, !1));
+  }
+  stopAnimation() {
+    u((t) => this.getAxisMotionValue(t).stop());
+  }
+  pauseAnimation() {
+    u((t) => {
+      var s;
+      return (s = this.getAxisMotionValue(t).animation) === null || s === void 0 ? void 0 : s.pause();
+    });
+  }
+  getAnimationState(t) {
+    var s;
+    return (s = this.getAxisMotionValue(t).animation) === null || s === void 0 ? void 0 : s.state;
+  }
+  /**
+   * 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(), n = i[s];
+    return n || this.visualElement.getValue(t, (i.initial ? i.initial[t] : void 0) || 0);
+  }
+  snapToCursor(t) {
+    u((s) => {
+      const { drag: i } = this.getProps();
+      if (!P(s, i, this.currentDirection))
+        return;
+      const { projection: n } = this.visualElement, r = this.getAxisMotionValue(s);
+      if (n && n.layout) {
+        const { min: e, max: l } = n.layout.layoutBox[s];
+        r.set(t[s] - V(e, l, 0.5));
+      }
+    });
+  }
+  /**
+   * 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: i } = this.visualElement;
+    if (!D(s) || !i || !this.constraints)
+      return;
+    this.stopAnimation();
+    const n = { x: 0, y: 0 };
+    u((e) => {
+      const l = this.getAxisMotionValue(e);
+      if (l && this.constraints !== !1) {
+        const c = l.get();
+        n[e] = q({ min: c, max: c }, this.constraints[e]);
+      }
+    });
+    const { transformTemplate: r } = this.visualElement.getProps();
+    this.visualElement.current.style.transform = r ? r({}, "") : "none", i.root && i.root.updateScroll(), i.updateLayout(), this.resolveConstraints(), u((e) => {
+      if (!P(e, t, null))
+        return;
+      const l = this.getAxisMotionValue(e), { min: c, max: h } = this.constraints[e];
+      l.set(V(c, h, n[e]));
+    });
+  }
+  addListeners() {
+    if (!this.visualElement.current)
+      return;
+    G.set(this.visualElement, this);
+    const t = this.visualElement.current, s = k(t, "pointerdown", (c) => {
+      const { drag: h, dragListener: o = !0 } = this.getProps();
+      h && o && this.start(c);
+    }), i = () => {
+      const { dragConstraints: c } = this.getProps();
+      D(c) && c.current && (this.constraints = this.resolveRefConstraints());
+    }, { projection: n } = this.visualElement, r = n.addEventListener("measure", i);
+    n && !n.layout && (n.root && n.root.updateScroll(), n.updateLayout()), C.read(i);
+    const e = B(window, "resize", () => this.scalePositionWithinConstraints()), l = n.addEventListener("didUpdate", ({ delta: c, hasLayoutChanged: h }) => {
+      this.isDragging && h && (u((o) => {
+        const a = this.getAxisMotionValue(o);
+        a && (this.originPoint[o] += c[o].translate, a.set(a.get() + c[o].translate));
+      }), this.visualElement.render());
+    });
+    return () => {
+      e(), s(), r(), l && l();
+    };
+  }
+  getProps() {
+    const t = this.visualElement.getProps(), { drag: s = !1, dragDirectionLock: i = !1, dragPropagation: n = !1, dragConstraints: r = !1, dragElastic: e = N, dragMomentum: l = !0 } = t;
+    return {
+      ...t,
+      drag: s,
+      dragDirectionLock: i,
+      dragPropagation: n,
+      dragConstraints: r,
+      dragElastic: e,
+      dragMomentum: l
+    };
+  }
+}
+function P(p, t, s) {
+  return (t === !0 || t === p) && (s === null || s === p);
+}
+function H(p, t = 10) {
+  let s = null;
+  return Math.abs(p.y) > t ? s = "y" : Math.abs(p.x) > t && (s = "x"), s;
+}
+export {
+  ft as VisualElementDragControls,
+  G as elementDragControls
+};

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

@@ -0,0 +1,19 @@
+import { Feature as s } from "../../motion/features/Feature.js";
+import "../../../../../motion-utils/dist/es/errors.js";
+import { noop as r } from "../../../../../motion-utils/dist/es/noop.js";
+import { VisualElementDragControls as t } from "./VisualElementDragControls.js";
+class l extends s {
+  constructor(o) {
+    super(o), this.removeGroupControls = r, this.removeListeners = r, this.controls = new t(o);
+  }
+  mount() {
+    const { dragControls: o } = this.node.getProps();
+    o && (this.removeGroupControls = o.subscribe(this.controls)), this.removeListeners = this.controls.addListeners() || r;
+  }
+  unmount() {
+    this.removeGroupControls(), this.removeListeners();
+  }
+}
+export {
+  l as DragGesture
+};

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

@@ -0,0 +1,68 @@
+import "../../../../../../motion-utils/dist/es/errors.js";
+import { progress as r } from "../../../../../../motion-utils/dist/es/progress.js";
+import { calcLength as t } from "../../../projection/geometry/delta-calc.js";
+import { clamp as C } from "../../../utils/clamp.js";
+import { mixNumber as u } from "../../../utils/mix/number.js";
+function L(n, { min: e, max: m }, i) {
+  return e !== void 0 && n < e ? n = i ? u(e, n, i.min) : Math.max(n, e) : m !== void 0 && n > m && (n = i ? u(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 w(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 y(n, e) {
+  return {
+    x: x(n.x, e.x),
+    y: x(n.y, e.y)
+  };
+}
+function M(n, e) {
+  let m = 0.5;
+  const i = t(n), f = t(e);
+  return f > i ? m = r(e.min, e.max - i, n.min) : i > f && (m = r(n.min, n.max - f, e.min)), C(0, 1, m);
+}
+function R(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 V(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 {
+  L as applyConstraints,
+  M as calcOrigin,
+  o as calcRelativeAxisConstraints,
+  w as calcRelativeConstraints,
+  x as calcViewportAxisConstraints,
+  y as calcViewportConstraints,
+  c as defaultElastic,
+  R as rebaseAxisConstraints,
+  l as resolveAxisElastic,
+  V 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 "../utils/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,22 @@
+import "../../../../motion-utils/dist/es/errors.js";
+import { frame as a } from "../../../../motion-dom/dist/es/frameloop/frame.js";
+import { hover as s } from "../../../../motion-dom/dist/es/gestures/hover.js";
+import { extractEventInfo as u } from "../events/event-info.js";
+import { Feature as c } from "../motion/features/Feature.js";
+function m(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 && a.postRender(() => i(t, u(t)));
+}
+class l extends c {
+  mount() {
+    const { current: t } = this.node;
+    t && (this.unmount = s(t, (r, o) => (m(this.node, o, "Start"), (n) => m(this.node, n, "End"))));
+  }
+  unmount() {
+  }
+}
+export {
+  l as HoverGesture
+};