lawgic-dev-kit 0.12.4 → 0.12.8

package/dist/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 a } from "../../projection/node/HTMLProjectionNode.js";
+const i = {
+  pan: {
+    Feature: o
+  },
+  drag: {
+    Feature: r,
+    ProjectionNode: a,
+    MeasureLayout: e
+  }
+};
+export {
+  i as drag
+};

package/dist/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 m = {
+  inView: {
+    Feature: o
+  },
+  tap: {
+    Feature: t
+  },
+  focus: {
+    Feature: r
+  },
+  hover: {
+    Feature: e
+  }
+};
+export {
+  m as gestureAnimations
+};

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

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

package/dist/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 a } from "./layout/MeasureLayout.js";
+const r = {
+  layout: {
+    ProjectionNode: o,
+    MeasureLayout: a
+  }
+};
+export {
+  r as layout
+};

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

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

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

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

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

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

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

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

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

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

package/dist/dist/node_modules/framer-motion/dist/es/motion/utils/symbol.js

@@ -0,0 +1,4 @@
+const o = Symbol.for("motionComponentSymbol");
+export {
+  o as motionComponentSymbol
+};

package/dist/dist/node_modules/framer-motion/dist/es/motion/utils/use-motion-ref.js

@@ -0,0 +1,18 @@
+import { useCallback as r } from "react";
+import { isRefObject as u } from "../../utils/is-ref-object.js";
+function c(e, o, t) {
+  return r(
+    (n) => {
+      n && e.onMount && e.onMount(n), o && (n ? o.mount(n) : o.unmount()), t && (typeof t == "function" ? t(n) : u(t) && (t.current = n));
+    },
+    /**
+     * Only pass a new ref callback to React if we've received a visual element
+     * factory. Otherwise we'll be mounting/remounting every time externalRef
+     * or other dependencies change.
+     */
+    [o]
+  );
+}
+export {
+  c as useMotionRef
+};

package/dist/dist/node_modules/framer-motion/dist/es/motion/utils/use-visual-element.js

@@ -0,0 +1,65 @@
+import "../../../../../motion-utils/dist/es/errors.js";
+import { microtask as x } from "../../../../../motion-dom/dist/es/frameloop/microtask.js";
+import { useContext as s, useRef as y, useInsertionEffect as S, useEffect as I } from "react";
+import { optimizedAppearDataAttribute as h } from "../../animation/optimized-appear/data-id.js";
+import { LazyContext as j } from "../../context/LazyContext.js";
+import { MotionConfigContext as E } from "../../context/MotionConfigContext.js";
+import { MotionContext as A } from "../../context/MotionContext/index.js";
+import { PresenceContext as b } from "../../context/PresenceContext.js";
+import { SwitchLayoutGroupContext as k } from "../../context/SwitchLayoutGroupContext.js";
+import { isRefObject as L } from "../../utils/is-ref-object.js";
+import { useIsomorphicLayoutEffect as R } from "../../utils/use-isomorphic-effect.js";
+function B(o, l, n, a, u) {
+  var e, i;
+  const { visualElement: m } = s(A), d = s(j), r = s(b), v = s(E).reducedMotion, c = y(null);
+  a = a || d.renderer, !c.current && a && (c.current = a(o, {
+    visualState: l,
+    parent: m,
+    props: n,
+    presenceContext: r,
+    blockInitialAnimation: r ? r.initial === !1 : !1,
+    reducedMotionConfig: v
+  }));
+  const t = c.current, g = s(k);
+  t && !t.projection && u && (t.type === "html" || t.type === "svg") && $(c.current, n, u, g);
+  const C = y(!1);
+  S(() => {
+    t && C.current && t.update(n, r);
+  });
+  const p = n[h], f = y(!!p && !(!((e = window.MotionHandoffIsComplete) === null || e === void 0) && e.call(window, p)) && ((i = window.MotionHasOptimisedAnimation) === null || i === void 0 ? void 0 : i.call(window, p)));
+  return R(() => {
+    t && (C.current = !0, window.MotionIsMounted = !0, t.updateFeatures(), x.render(t.render), f.current && t.animationState && t.animationState.animateChanges());
+  }), I(() => {
+    t && (!f.current && t.animationState && t.animationState.animateChanges(), f.current && (queueMicrotask(() => {
+      var w;
+      (w = window.MotionHandoffMarkAsComplete) === null || w === void 0 || w.call(window, p);
+    }), f.current = !1));
+  }), t;
+}
+function $(o, l, n, a) {
+  const { layoutId: u, layout: e, drag: i, dragConstraints: m, layoutScroll: d, layoutRoot: r } = l;
+  o.projection = new n(o.latestValues, l["data-framer-portal-id"] ? void 0 : M(o.parent)), o.projection.setOptions({
+    layoutId: u,
+    layout: e,
+    alwaysMeasureLayout: !!i || m && L(m),
+    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 e == "string" ? e : "both",
+    initialPromotionConfig: a,
+    layoutScroll: d,
+    layoutRoot: r
+  });
+}
+function M(o) {
+  if (o)
+    return o.options.allowProjection !== !1 ? o.projection : M(o.parent);
+}
+export {
+  B as useVisualElement
+};

package/dist/dist/node_modules/framer-motion/dist/es/motion/utils/use-visual-state.js

@@ -0,0 +1,53 @@
+import { useContext as A } from "react";
+import { isAnimationControls as x } from "../../animation/utils/is-animation-controls.js";
+import { MotionContext as M } from "../../context/MotionContext/index.js";
+import { PresenceContext as $ } from "../../context/PresenceContext.js";
+import { isControllingVariants as h, isVariantNode as P } from "../../render/utils/is-controlling-variants.js";
+import { resolveVariantFromProps as S } from "../../render/utils/resolve-variants.js";
+import { useConstant as U } from "../../utils/use-constant.js";
+import { resolveMotionValue as b } from "../../value/utils/resolve-motion-value.js";
+function k({ scrapeMotionValuesFromProps: o, createRenderState: a, onUpdate: n }, i, r, e) {
+  const t = {
+    latestValues: E(i, r, e, o),
+    renderState: a()
+  };
+  return n && (t.onMount = (s) => n({ props: i, current: s, ...t }), t.onUpdate = (s) => n(s)), t;
+}
+const D = (o) => (a, n) => {
+  const i = A(M), r = A($), e = () => k(o, a, i, r);
+  return n ? e() : U(e);
+};
+function E(o, a, n, i) {
+  const r = {}, e = i(o, {});
+  for (const m in e)
+    r[m] = b(e[m]);
+  let { initial: t, animate: s } = o;
+  const C = h(o), v = P(o);
+  a && v && !C && o.inherit !== !1 && (t === void 0 && (t = a.initial), s === void 0 && (s = a.animate));
+  let p = n ? n.initial === !1 : !1;
+  p = p || t === !1;
+  const l = p ? s : t;
+  if (l && typeof l != "boolean" && !x(l)) {
+    const m = Array.isArray(l) ? l : [l];
+    for (let u = 0; u < m.length; u++) {
+      const d = S(o, m[u]);
+      if (d) {
+        const { transitionEnd: V, transition: F, ...y } = d;
+        for (const c in y) {
+          let f = y[c];
+          if (Array.isArray(f)) {
+            const g = p ? f.length - 1 : 0;
+            f = f[g];
+          }
+          f !== null && (r[c] = f);
+        }
+        for (const c in V)
+          r[c] = V[c];
+      }
+    }
+  }
+  return r;
+}
+export {
+  D as makeUseVisualState
+};

package/dist/dist/node_modules/framer-motion/dist/es/motion/utils/valid-prop.js

@@ -0,0 +1,38 @@
+const a = /* @__PURE__ */ new Set([
+  "animate",
+  "exit",
+  "variants",
+  "initial",
+  "style",
+  "values",
+  "variants",
+  "transition",
+  "transformTemplate",
+  "custom",
+  "inherit",
+  "onBeforeLayoutMeasure",
+  "onAnimationStart",
+  "onAnimationComplete",
+  "onUpdate",
+  "onDragStart",
+  "onDrag",
+  "onDragEnd",
+  "onMeasureDragConstraints",
+  "onDirectionLock",
+  "onDragTransitionEnd",
+  "_dragX",
+  "_dragY",
+  "onHoverStart",
+  "onHoverEnd",
+  "onViewportEnter",
+  "onViewportLeave",
+  "globalTapTarget",
+  "ignoreStrict",
+  "viewport"
+]);
+function n(t) {
+  return t.startsWith("while") || t.startsWith("drag") && t !== "draggable" || t.startsWith("layout") || t.startsWith("onTap") || t.startsWith("onPan") || t.startsWith("onLayout") || a.has(t);
+}
+export {
+  n as isValidMotionProp
+};

package/dist/dist/node_modules/framer-motion/dist/es/projection/animation/mix-values.js

@@ -0,0 +1,31 @@
+import "../../../../../motion-utils/dist/es/errors.js";
+import { noop as g } from "../../../../../motion-utils/dist/es/noop.js";
+import { progress as l } from "../../../../../motion-utils/dist/es/progress.js";
+import { circOut as b } from "../../easing/circ.js";
+import { mixNumber as c } from "../../utils/mix/number.js";
+import { px as h, percent as m } from "../../value/types/numbers/units.js";
+const u = ["TopLeft", "TopRight", "BottomLeft", "BottomRight"], R = u.length, n = (o) => typeof o == "string" ? parseFloat(o) : o, f = (o) => typeof o == "number" || h.test(o);
+function N(o, t, r, a, v, x) {
+  v ? (o.opacity = c(
+    0,
+    // TODO Reinstate this if only child
+    r.opacity !== void 0 ? r.opacity : 1,
+    B(a)
+  ), o.opacityExit = c(t.opacity !== void 0 ? t.opacity : 1, 0, L(a))) : x && (o.opacity = c(t.opacity !== void 0 ? t.opacity : 1, r.opacity !== void 0 ? r.opacity : 1, a));
+  for (let s = 0; s < R; s++) {
+    const p = `border${u[s]}Radius`;
+    let e = y(t, p), i = y(r, p);
+    e === void 0 && i === void 0 || (e || (e = 0), i || (i = 0), e === 0 || i === 0 || f(e) === f(i) ? (o[p] = Math.max(c(n(e), n(i), a), 0), (m.test(i) || m.test(e)) && (o[p] += "%")) : o[p] = i);
+  }
+  (t.rotate || r.rotate) && (o.rotate = c(t.rotate || 0, r.rotate || 0, a));
+}
+function y(o, t) {
+  return o[t] !== void 0 ? o[t] : o.borderRadius;
+}
+const B = /* @__PURE__ */ d(0, 0.5, b), L = /* @__PURE__ */ d(0.5, 0.95, g);
+function d(o, t, r) {
+  return (a) => a < o ? 0 : a > t ? 1 : r(l(o, t, a));
+}
+export {
+  N as mixValues
+};

package/dist/dist/node_modules/framer-motion/dist/es/projection/geometry/conversion.js

@@ -0,0 +1,25 @@
+function x({ top: t, left: o, right: n, bottom: r }) {
+  return {
+    x: { min: o, max: n },
+    y: { min: t, max: r }
+  };
+}
+function i({ x: t, y: o }) {
+  return { top: o.min, right: t.max, bottom: o.max, left: t.min };
+}
+function m(t, o) {
+  if (!o)
+    return t;
+  const n = o({ x: t.left, y: t.top }), r = o({ x: t.right, y: t.bottom });
+  return {
+    top: n.y,
+    left: n.x,
+    bottom: r.y,
+    right: r.x
+  };
+}
+export {
+  x as convertBoundingBoxToBox,
+  i as convertBoxToBoundingBox,
+  m as transformBoxPoints
+};

package/dist/dist/node_modules/framer-motion/dist/es/projection/geometry/copy.js

@@ -0,0 +1,14 @@
+function n(i, t) {
+  i.min = t.min, i.max = t.max;
+}
+function a(i, t) {
+  n(i.x, t.x), n(i.y, t.y);
+}
+function o(i, t) {
+  i.translate = t.translate, i.scale = t.scale, i.originPoint = t.originPoint, i.origin = t.origin;
+}
+export {
+  o as copyAxisDeltaInto,
+  n as copyAxisInto,
+  a as copyBoxInto
+};

package/dist/dist/node_modules/framer-motion/dist/es/projection/geometry/delta-apply.js

@@ -0,0 +1,52 @@
+import { mixNumber as D } from "../../utils/mix/number.js";
+import { hasTransform as g } from "../utils/has-transform.js";
+function x(a, s, o) {
+  const e = a - o, t = s * e;
+  return o + t;
+}
+function f(a, s, o, e, t) {
+  return t !== void 0 && (a = x(a, t, e)), x(a, o, e) + s;
+}
+function c(a, s = 0, o = 1, e, t) {
+  a.min = f(a.min, s, o, e, t), a.max = f(a.max, s, o, e, t);
+}
+function A(a, { x: s, y: o }) {
+  c(a.x, s.translate, s.scale, s.originPoint), c(a.y, o.translate, o.scale, o.originPoint);
+}
+const m = 0.999999999999, y = 1.0000000000001;
+function h(a, s, o, e = !1) {
+  const t = o.length;
+  if (!t)
+    return;
+  s.x = s.y = 1;
+  let l, i;
+  for (let r = 0; r < t; r++) {
+    l = o[r], i = l.projectionDelta;
+    const { visualElement: n } = l.options;
+    n && n.props.style && n.props.style.display === "contents" || (e && l.options.layoutScroll && l.scroll && l !== l.root && u(a, {
+      x: -l.scroll.offset.x,
+      y: -l.scroll.offset.y
+    }), i && (s.x *= i.x.scale, s.y *= i.y.scale, A(a, i)), e && g(l.latestValues) && u(a, l.latestValues));
+  }
+  s.x < y && s.x > m && (s.x = 1), s.y < y && s.y > m && (s.y = 1);
+}
+function v(a, s) {
+  a.min = a.min + s, a.max = a.max + s;
+}
+function p(a, s, o, e, t = 0.5) {
+  const l = D(a.min, a.max, t);
+  c(a, s, o, l, e);
+}
+function u(a, s) {
+  p(a.x, s.x, s.scaleX, s.scale, s.originX), p(a.y, s.y, s.scaleY, s.scale, s.originY);
+}
+export {
+  c as applyAxisDelta,
+  A as applyBoxDelta,
+  f as applyPointDelta,
+  h as applyTreeDeltas,
+  x as scalePoint,
+  p as transformAxis,
+  u as transformBox,
+  v as translateAxis
+};

package/dist/dist/node_modules/framer-motion/dist/es/projection/geometry/delta-calc.js

@@ -0,0 +1,36 @@
+import { mixNumber as n } from "../../utils/mix/number.js";
+const x = 1e-4, m = 1 - x, u = 1 + x, r = 0.01, f = 0 - r, y = 0 + r;
+function e(a) {
+  return a.max - a.min;
+}
+function N(a, i, t) {
+  return Math.abs(a - i) <= t;
+}
+function o(a, i, t, s = 0.5) {
+  a.origin = s, a.originPoint = n(i.min, i.max, a.origin), a.scale = e(t) / e(i), a.translate = n(t.min, t.max, a.origin) - a.originPoint, (a.scale >= m && a.scale <= u || isNaN(a.scale)) && (a.scale = 1), (a.translate >= f && a.translate <= y || isNaN(a.translate)) && (a.translate = 0);
+}
+function v(a, i, t, s) {
+  o(a.x, i.x, t.x, s ? s.originX : void 0), o(a.y, i.y, t.y, s ? s.originY : void 0);
+}
+function c(a, i, t) {
+  a.min = t.min + i.min, a.max = a.min + e(i);
+}
+function P(a, i, t) {
+  c(a.x, i.x, t.x), c(a.y, i.y, t.y);
+}
+function l(a, i, t) {
+  a.min = i.min - t.min, a.max = a.min + e(i);
+}
+function R(a, i, t) {
+  l(a.x, i.x, t.x), l(a.y, i.y, t.y);
+}
+export {
+  o as calcAxisDelta,
+  v as calcBoxDelta,
+  e as calcLength,
+  c as calcRelativeAxis,
+  l as calcRelativeAxisPosition,
+  P as calcRelativeBox,
+  R as calcRelativePosition,
+  N as isNear
+};

package/dist/dist/node_modules/framer-motion/dist/es/projection/geometry/delta-remove.js

@@ -0,0 +1,25 @@
+import { mixNumber as x } from "../../utils/mix/number.js";
+import { percent as l } from "../../value/types/numbers/units.js";
+import { scalePoint as m } from "./delta-apply.js";
+function c(o, i, r, a, n) {
+  return o -= i, o = m(o, 1 / r, a), n !== void 0 && (o = m(o, 1 / n, a)), o;
+}
+function f(o, i = 0, r = 1, a = 0.5, n, t = o, s = o) {
+  if (l.test(i) && (i = parseFloat(i), i = x(s.min, s.max, i / 100) - s.min), typeof i != "number")
+    return;
+  let e = x(t.min, t.max, a);
+  o === t && (e -= i), o.min = c(o.min, i, r, e, n), o.max = c(o.max, i, r, e, n);
+}
+function v(o, i, [r, a, n], t, s) {
+  f(o, i[r], i[a], i[n], i.scale, t, s);
+}
+const p = ["x", "scaleX", "originX"], u = ["y", "scaleY", "originY"];
+function P(o, i, r, a) {
+  v(o.x, i, p, r ? r.x : void 0, a ? a.x : void 0), v(o.y, i, u, r ? r.y : void 0, a ? a.y : void 0);
+}
+export {
+  f as removeAxisDelta,
+  v as removeAxisTransforms,
+  P as removeBoxTransforms,
+  c as removePointDelta
+};

package/dist/dist/node_modules/framer-motion/dist/es/projection/geometry/models.js

@@ -0,0 +1,18 @@
+const a = () => ({
+  translate: 0,
+  scale: 1,
+  origin: 0,
+  originPoint: 0
+}), t = () => ({
+  x: a(),
+  y: a()
+}), e = () => ({ min: 0, max: 0 }), s = () => ({
+  x: e(),
+  y: e()
+});
+export {
+  e as createAxis,
+  a as createAxisDelta,
+  s as createBox,
+  t as createDelta
+};