lawgic-dev-kit 0.2.4 → 0.3.4

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,27 @@
+const n = {
+  animation: [
+    "animate",
+    "variants",
+    "whileHover",
+    "whileTap",
+    "exit",
+    "whileInView",
+    "whileFocus",
+    "whileDrag"
+  ],
+  exit: ["exit"],
+  drag: ["drag", "dragControls"],
+  focus: ["whileFocus"],
+  hover: ["whileHover", "onHoverStart", "onHoverEnd"],
+  tap: ["whileTap", "onTap", "onTapStart", "onTapCancel"],
+  pan: ["onPan", "onPanStart", "onPanSessionStart", "onPanEnd"],
+  inView: ["whileInView", "onViewportEnter", "onViewportLeave"],
+  layout: ["layout", "layoutId"]
+}, t = {};
+for (const e in n)
+  t[e] = {
+    isEnabled: (o) => n[e].some((a) => !!o[a])
+  };
+export {
+  t as featureDefinitions
+};

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

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

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

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

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

@@ -0,0 +1,74 @@
+import { j as m } from "../../../../../../../../../../_virtual/jsx-runtime.js";
+import { frame as d } from "../../../../../../motion-dom/dist/es/frameloop/frame.js";
+import { microtask as c } from "../../../../../../motion-dom/dist/es/frameloop/microtask.js";
+import { useContext as u, Component as f } from "react";
+import { usePresence as l } 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 n } from "../../../projection/styles/scale-border-radius.js";
+import { correctBoxShadow as y } from "../../../projection/styles/scale-box-shadow.js";
+import { addScaleCorrector as v } from "../../../projection/styles/scale-correction.js";
+class T extends f {
+  /**
+   * This only mounts projection nodes for components that
+   * need measuring, we might want to do it for all components
+   * in order to incorporate transforms
+   */
+  componentDidMount() {
+    const { visualElement: o, layoutGroup: t, switchLayoutGroup: r, layoutId: s } = this.props, { projection: e } = o;
+    v(x), 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() || d.postRender(() => {
+      const p = i.getStack();
+      (!p || !p.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(a) {
+  const [o, t] = l(), r = u(h);
+  return m.jsx(T, { ...a, layoutGroup: r, switchLayoutGroup: u(R), isPresent: o, safeToRemove: t });
+}
+const x = {
+  borderRadius: {
+    ...n,
+    applyTo: [
+      "borderTopLeftRadius",
+      "borderTopRightRadius",
+      "borderBottomLeftRadius",
+      "borderBottomRightRadius"
+    ]
+  },
+  borderTopLeftRadius: n,
+  borderTopRightRadius: n,
+  borderBottomLeftRadius: n,
+  borderBottomRightRadius: n,
+  boxShadow: y
+};
+export {
+  k as MeasureLayout
+};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,18 @@
+import { useCallback as p } from "react";
+import { isRefObject as i } from "../../utils/is-ref-object.js";
+function b(r, u, f) {
+  return p(
+    (o) => {
+      o && r.onMount && r.onMount(o), u && (o ? u.mount(o) : u.unmount()), f && (typeof f == "function" ? f(o) : i(f) && (f.current = o));
+    },
+    /**
+     * 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.
+     */
+    [u]
+  );
+}
+export {
+  b as useMotionRef
+};

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

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

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

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

package/dist/node_modules/motion/dist/es/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/node_modules/motion/dist/es/framer-motion/dist/es/projection/animation/mix-values.js

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

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

@@ -0,0 +1,25 @@
+function r({ top: t, left: o, right: n, bottom: x }) {
+  return {
+    x: { min: o, max: n },
+    y: { min: t, max: x }
+  };
+}
+function e({ 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 }), x = o({ x: t.right, y: t.bottom });
+  return {
+    top: n.y,
+    left: n.x,
+    bottom: x.y,
+    right: x.x
+  };
+}
+export {
+  r as convertBoundingBoxToBox,
+  e as convertBoxToBoundingBox,
+  m as transformBoxPoints
+};

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

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