lawgic-dev-kit 0.2.4 → 0.3.4

package/dist/node_modules/framer-motion/dist/es/animation/generators/inertia.js

@@ -0,0 +1,37 @@
+import { spring as L } from "./spring/index.js";
+import { calcGeneratorVelocity as R } from "./utils/velocity.js";
+function $({ keyframes: g, velocity: B = 0, power: M = 0.8, timeConstant: b = 325, bounceDamping: k = 10, bounceStiffness: F = 500, modifyTarget: l, min: t, max: a, restDelta: f = 0.5, restSpeed: O }) {
+  const s = g[0], n = {
+    done: !1,
+    value: s
+  }, C = (e) => t !== void 0 && e < t || a !== void 0 && e > a, D = (e) => t === void 0 ? a : a === void 0 || Math.abs(t - e) < Math.abs(a - e) ? t : a;
+  let c = M * B;
+  const d = s + c, u = l === void 0 ? d : l(d);
+  u !== d && (c = u - s);
+  const p = (e) => -c * Math.exp(-e / b), h = (e) => u + p(e), y = (e) => {
+    const o = p(e), G = h(e);
+    n.done = Math.abs(o) <= f, n.value = n.done ? u : G;
+  };
+  let r, i;
+  const v = (e) => {
+    C(n.value) && (r = e, i = L({
+      keyframes: [n.value, D(n.value)],
+      velocity: R(h, e, n.value),
+      // TODO: This should be passing * 1000
+      damping: k,
+      stiffness: F,
+      restDelta: f,
+      restSpeed: O
+    }));
+  };
+  return v(0), {
+    calculatedDuration: null,
+    next: (e) => {
+      let o = !1;
+      return !i && r === void 0 && (o = !0, y(e), v(e)), r !== void 0 && e >= r ? i.next(e - r) : (!o && y(e), n);
+    }
+  };
+}
+export {
+  $ as inertia
+};

package/dist/node_modules/framer-motion/dist/es/animation/generators/keyframes.js

@@ -0,0 +1,30 @@
+import { easeInOut as c } from "../../easing/ease.js";
+import { isEasingArray as p } from "../../easing/utils/is-easing-array.js";
+import { easingDefinitionToFunction as m } from "../../easing/utils/map.js";
+import { interpolate as u } from "../../utils/interpolate.js";
+import { defaultOffset as l } from "../../utils/offsets/default.js";
+import { convertOffsetToTimes as g } from "../../utils/offsets/time.js";
+function T(n, t) {
+  return n.map(() => t || c).splice(0, n.length - 1);
+}
+function y({ duration: n = 300, keyframes: t, times: o, ease: r = "easeInOut" }) {
+  const e = p(r) ? r.map(m) : m(r), i = {
+    done: !1,
+    value: t[0]
+  }, s = g(
+    // Only use the provided offsets if they're the correct length
+    // TODO Maybe we should warn here if there's a length mismatch
+    o && o.length === t.length ? o : l(t),
+    n
+  ), a = u(s, t, {
+    ease: Array.isArray(e) ? e : T(t, e)
+  });
+  return {
+    calculatedDuration: n,
+    next: (f) => (i.value = a(f), i.done = f >= n, i)
+  };
+}
+export {
+  T as defaultEasing,
+  y as keyframes
+};

package/dist/node_modules/framer-motion/dist/es/animation/generators/spring/defaults.js

@@ -0,0 +1,32 @@
+const a = {
+  // Default spring physics
+  stiffness: 100,
+  damping: 10,
+  mass: 1,
+  velocity: 0,
+  // Default duration/bounce-based options
+  duration: 800,
+  // in ms
+  bounce: 0.3,
+  visualDuration: 0.3,
+  // in seconds
+  // Rest thresholds
+  restSpeed: {
+    granular: 0.01,
+    default: 2
+  },
+  restDelta: {
+    granular: 5e-3,
+    default: 0.5
+  },
+  // Limits
+  minDuration: 0.01,
+  // in seconds
+  maxDuration: 10,
+  // in seconds
+  minDamping: 0.05,
+  maxDamping: 1
+};
+export {
+  a as springDefaults
+};

package/dist/node_modules/framer-motion/dist/es/animation/generators/spring/find.js

@@ -0,0 +1,52 @@
+import { warning as u } from "../../../../../../motion-utils/dist/es/errors.js";
+import { secondsToMilliseconds as g, millisecondsToSeconds as N } from "../../../../../../motion-utils/dist/es/time-conversion.js";
+import { clamp as h } from "../../../utils/clamp.js";
+import { springDefaults as n } from "./defaults.js";
+const D = 1e-3;
+function v({ duration: t = n.duration, bounce: p = n.bounce, velocity: a = n.velocity, mass: e = n.mass }) {
+  let i, f;
+  u(t <= g(n.maxDuration), "Spring duration must be 10 seconds or less");
+  let o = 1 - p;
+  o = h(n.minDamping, n.maxDamping, o), t = h(n.minDuration, n.maxDuration, N(t)), o < 1 ? (i = (s) => {
+    const r = s * o, c = r * t, l = r - a, m = b(s, o), x = Math.exp(-c);
+    return D - l / m * x;
+  }, f = (s) => {
+    const c = s * o * t, l = c * a + a, m = Math.pow(o, 2) * Math.pow(s, 2) * t, x = Math.exp(-c), S = b(Math.pow(s, 2), o);
+    return (-i(s) + D > 0 ? -1 : 1) * ((l - m) * x) / S;
+  }) : (i = (s) => {
+    const r = Math.exp(-s * t), c = (s - a) * t + 1;
+    return -1e-3 + r * c;
+  }, f = (s) => {
+    const r = Math.exp(-s * t), c = (a - s) * (t * t);
+    return r * c;
+  });
+  const w = 5 / t, M = A(i, f, w);
+  if (t = g(t), isNaN(M))
+    return {
+      stiffness: n.stiffness,
+      damping: n.damping,
+      duration: t
+    };
+  {
+    const s = Math.pow(M, 2) * e;
+    return {
+      stiffness: s,
+      damping: o * 2 * Math.sqrt(e * s),
+      duration: t
+    };
+  }
+}
+const T = 12;
+function A(t, p, a) {
+  let e = a;
+  for (let i = 1; i < T; i++)
+    e = e - t(e) / p(e);
+  return e;
+}
+function b(t, p) {
+  return t * Math.sqrt(1 - p * p);
+}
+export {
+  b as calcAngularFreq,
+  v as findSpring
+};

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

@@ -0,0 +1,92 @@
+import "../../../../../../motion-utils/dist/es/errors.js";
+import { millisecondsToSeconds as b, secondsToMilliseconds as R } from "../../../../../../motion-utils/dist/es/time-conversion.js";
+import { calcGeneratorDuration as A, maxGeneratorDuration as w } from "../../../../../../motion-dom/dist/es/animation/generators/utils/calc-duration.js";
+import { generateLinearEasing as B } from "../../../../../../motion-dom/dist/es/animation/waapi/utils/linear.js";
+import { clamp as K } from "../../../utils/clamp.js";
+import { calcGeneratorVelocity as V } from "../utils/velocity.js";
+import { springDefaults as r } from "./defaults.js";
+import { findSpring as j, calcAngularFreq as E } from "./find.js";
+const I = ["duration", "bounce"], L = ["stiffness", "damping", "mass"];
+function x(t, a) {
+  return a.some((s) => t[s] !== void 0);
+}
+function P(t) {
+  let a = {
+    velocity: r.velocity,
+    stiffness: r.stiffness,
+    damping: r.damping,
+    mass: r.mass,
+    isResolvedFromDuration: !1,
+    ...t
+  };
+  if (!x(t, L) && x(t, I))
+    if (t.visualDuration) {
+      const s = t.visualDuration, u = 2 * Math.PI / (s * 1.2), m = u * u, g = 2 * K(0.05, 1, 1 - (t.bounce || 0)) * Math.sqrt(m);
+      a = {
+        ...a,
+        mass: r.mass,
+        stiffness: m,
+        damping: g
+      };
+    } else {
+      const s = j(t);
+      a = {
+        ...a,
+        ...s,
+        mass: r.mass
+      }, a.isResolvedFromDuration = !0;
+    }
+  return a;
+}
+function W(t = r.visualDuration, a = r.bounce) {
+  const s = typeof t != "object" ? {
+    visualDuration: t,
+    keyframes: [0, 1],
+    bounce: a
+  } : t;
+  let { restSpeed: u, restDelta: m } = s;
+  const g = s.keyframes[0], f = s.keyframes[s.keyframes.length - 1], d = { done: !1, value: g }, { stiffness: M, damping: T, mass: D, duration: S, velocity: k, isResolvedFromDuration: q } = P({
+    ...s,
+    velocity: -b(s.velocity || 0)
+  }), h = k || 0, o = T / (2 * Math.sqrt(M * D)), c = f - g, i = b(Math.sqrt(M / D)), F = Math.abs(c) < 5;
+  u || (u = F ? r.restSpeed.granular : r.restSpeed.default), m || (m = F ? r.restDelta.granular : r.restDelta.default);
+  let p;
+  if (o < 1) {
+    const e = E(i, o);
+    p = (n) => {
+      const l = Math.exp(-o * i * n);
+      return f - l * ((h + o * i * c) / e * Math.sin(e * n) + c * Math.cos(e * n));
+    };
+  } else if (o === 1)
+    p = (e) => f - Math.exp(-i * e) * (c + (h + i * c) * e);
+  else {
+    const e = i * Math.sqrt(o * o - 1);
+    p = (n) => {
+      const l = Math.exp(-o * i * n), v = Math.min(e * n, 300);
+      return f - l * ((h + o * i * c) * Math.sinh(v) + e * c * Math.cosh(v)) / e;
+    };
+  }
+  const y = {
+    calculatedDuration: q && S || null,
+    next: (e) => {
+      const n = p(e);
+      if (q)
+        d.done = e >= S;
+      else {
+        let l = 0;
+        o < 1 && (l = e === 0 ? R(h) : V(p, e, n));
+        const v = Math.abs(l) <= u, G = Math.abs(f - n) <= m;
+        d.done = v && G;
+      }
+      return d.value = d.done ? f : n, d;
+    },
+    toString: () => {
+      const e = Math.min(A(y), w), n = B((l) => y.next(e * l).value, e, 30);
+      return e + "ms " + n;
+    }
+  };
+  return y;
+}
+export {
+  W as spring
+};

package/dist/node_modules/framer-motion/dist/es/animation/generators/utils/velocity.js

@@ -0,0 +1,10 @@
+import "../../../../../../motion-utils/dist/es/errors.js";
+import { velocityPerSecond as c } from "../../../../../../motion-utils/dist/es/velocity-per-second.js";
+const n = 5;
+function l(e, o, r) {
+  const t = Math.max(o - n, 0);
+  return c(r - e(t), o - t);
+}
+export {
+  l as calcGeneratorVelocity
+};

package/dist/node_modules/framer-motion/dist/es/animation/interfaces/motion-value.js

@@ -0,0 +1,47 @@
+import { GroupPlaybackControls as c } from "../../../../../motion-dom/dist/es/animation/controls/Group.js";
+import { getValueTransition as D } from "../../../../../motion-dom/dist/es/animation/utils/get-value-transition.js";
+import "../../../../../motion-utils/dist/es/errors.js";
+import { secondsToMilliseconds as p } from "../../../../../motion-utils/dist/es/time-conversion.js";
+import { frame as T } from "../../../../../motion-dom/dist/es/frameloop/frame.js";
+import { AcceleratedAnimation as d } from "../animators/AcceleratedAnimation.js";
+import { MainThreadAnimation as k } from "../animators/MainThreadAnimation.js";
+import { getFinalKeyframe as A } from "../animators/waapi/utils/get-final-keyframe.js";
+import { getDefaultTransition as C } from "../utils/default-transitions.js";
+import { isTransitionDefined as w } from "../utils/is-transition-defined.js";
+const O = (i, r, n, a = {}, s, l) => (u) => {
+  const o = D(a, i) || {}, y = o.delay || a.delay || 0;
+  let { elapsed: m = 0 } = a;
+  m = m - p(y);
+  let e = {
+    keyframes: Array.isArray(n) ? n : [null, n],
+    ease: "easeOut",
+    velocity: r.getVelocity(),
+    ...o,
+    delay: -m,
+    onUpdate: (t) => {
+      r.set(t), o.onUpdate && o.onUpdate(t);
+    },
+    onComplete: () => {
+      u(), o.onComplete && o.onComplete();
+    },
+    name: i,
+    motionValue: r,
+    element: l ? void 0 : s
+  };
+  w(o) || (e = {
+    ...e,
+    ...C(i, e)
+  }), e.duration && (e.duration = p(e.duration)), e.repeatDelay && (e.repeatDelay = p(e.repeatDelay)), e.from !== void 0 && (e.keyframes[0] = e.from);
+  let f = !1;
+  if ((e.type === !1 || e.duration === 0 && !e.repeatDelay) && (e.duration = 0, e.delay === 0 && (f = !0)), e.allowFlatten = !o.type && !o.ease, f && !l && r.get() !== void 0) {
+    const t = A(e.keyframes, o);
+    if (t !== void 0)
+      return T.update(() => {
+        e.onUpdate(t), e.onComplete();
+      }), new c([]);
+  }
+  return !l && d.supports(e) ? new d(e) : new k(e);
+};
+export {
+  O as animateMotionValue
+};

package/dist/node_modules/framer-motion/dist/es/animation/interfaces/visual-element-target.js

@@ -0,0 +1,46 @@
+import "../../../../../motion-utils/dist/es/errors.js";
+import { getValueTransition as M } from "../../../../../motion-dom/dist/es/animation/utils/get-value-transition.js";
+import { frame as V } from "../../../../../motion-dom/dist/es/frameloop/frame.js";
+import { positionalKeys as S } from "../../render/html/utils/keys-position.js";
+import { setTarget as A } from "../../render/utils/setters.js";
+import { addValueToWillChange as H } from "../../value/use-will-change/add-will-change.js";
+import { getOptimisedAppearId as y } from "../optimized-appear/get-appear-id.js";
+import { animateMotionValue as B } from "./motion-value.js";
+function I({ protectedKeys: t, needsAnimating: a }, n) {
+  const i = t.hasOwnProperty(n) && a[n] !== !0;
+  return a[n] = !1, i;
+}
+function W(t, a, { delay: n = 0, transitionOverride: i, type: m } = {}) {
+  var r;
+  let { transition: p = t.getDefaultTransition(), transitionEnd: e, ...d } = a;
+  i && (p = i);
+  const f = [], u = m && t.animationState && t.animationState.getState()[m];
+  for (const o in d) {
+    const s = t.getValue(o, (r = t.latestValues[o]) !== null && r !== void 0 ? r : null), c = d[o];
+    if (c === void 0 || u && I(u, o))
+      continue;
+    const l = {
+      delay: n,
+      ...M(p || {}, o)
+    };
+    let T = !1;
+    if (window.MotionHandoffAnimation) {
+      const h = y(t);
+      if (h) {
+        const w = window.MotionHandoffAnimation(h, o, V);
+        w !== null && (l.startTime = w, T = !0);
+      }
+    }
+    H(t, o), s.start(B(o, s, c, t.shouldReduceMotion && S.has(o) ? { type: !1 } : l, t, T));
+    const g = s.animation;
+    g && f.push(g);
+  }
+  return e && Promise.all(f).then(() => {
+    V.update(() => {
+      e && A(t, e);
+    });
+  }), f;
+}
+export {
+  W as animateTarget
+};

package/dist/node_modules/framer-motion/dist/es/animation/interfaces/visual-element-variant.js

@@ -0,0 +1,33 @@
+import { resolveVariant as h } from "../../render/utils/resolve-dynamic-variants.js";
+import { animateTarget as g } from "./visual-element-target.js";
+function C(r, t, n = {}) {
+  var i;
+  const a = h(r, t, n.type === "exit" ? (i = r.presenceContext) === null || i === void 0 ? void 0 : i.custom : void 0);
+  let { transition: s = r.getDefaultTransition() || {} } = a || {};
+  n.transitionOverride && (s = n.transitionOverride);
+  const o = a ? () => Promise.all(g(r, a, n)) : () => Promise.resolve(), d = r.variantChildren && r.variantChildren.size ? (e = 0) => {
+    const { delayChildren: f = 0, staggerChildren: m, staggerDirection: l } = s;
+    return u(r, t, f + e, m, l, n);
+  } : () => Promise.resolve(), { when: c } = s;
+  if (c) {
+    const [e, f] = c === "beforeChildren" ? [o, d] : [d, o];
+    return e().then(() => f());
+  } else
+    return Promise.all([o(), d(n.delay)]);
+}
+function u(r, t, n = 0, i = 0, a = 1, s) {
+  const o = [], d = (r.variantChildren.size - 1) * i, c = a === 1 ? (e = 0) => e * i : (e = 0) => d - e * i;
+  return Array.from(r.variantChildren).sort(y).forEach((e, f) => {
+    e.notify("AnimationStart", t), o.push(C(e, t, {
+      ...s,
+      delay: n + c(f)
+    }).then(() => e.notify("AnimationComplete", t)));
+  }), Promise.all(o);
+}
+function y(r, t) {
+  return r.sortNodePosition(t);
+}
+export {
+  C as animateVariant,
+  y as sortByTreeOrder
+};

package/dist/node_modules/framer-motion/dist/es/animation/interfaces/visual-element.js

@@ -0,0 +1,22 @@
+import { resolveVariant as c } from "../../render/utils/resolve-dynamic-variants.js";
+import { animateTarget as p } from "./visual-element-target.js";
+import { animateVariant as e } from "./visual-element-variant.js";
+function n(a, r, t = {}) {
+  a.notify("AnimationStart", r);
+  let m;
+  if (Array.isArray(r)) {
+    const o = r.map((y) => e(a, y, t));
+    m = Promise.all(o);
+  } else if (typeof r == "string")
+    m = e(a, r, t);
+  else {
+    const o = typeof r == "function" ? c(a, r, t.custom) : r;
+    m = Promise.all(p(a, o, t));
+  }
+  return m.then(() => {
+    a.notify("AnimationComplete", r);
+  });
+}
+export {
+  n as animateVisualElement
+};

package/dist/node_modules/framer-motion/dist/es/animation/optimized-appear/data-id.js

@@ -0,0 +1,6 @@
+import { camelToDash as a } from "../../render/dom/utils/camel-to-dash.js";
+const t = "framerAppearId", e = "data-" + a(t);
+export {
+  e as optimizedAppearDataAttribute,
+  t as optimizedAppearDataId
+};

package/dist/node_modules/framer-motion/dist/es/animation/optimized-appear/get-appear-id.js

@@ -0,0 +1,7 @@
+import { optimizedAppearDataAttribute as p } from "./data-id.js";
+function e(t) {
+  return t.props[p];
+}
+export {
+  e as getOptimisedAppearId
+};

package/dist/node_modules/framer-motion/dist/es/animation/utils/default-transitions.js

@@ -0,0 +1,22 @@
+import { transformProps as s } from "../../render/html/utils/keys-transform.js";
+const r = {
+  type: "spring",
+  stiffness: 500,
+  damping: 25,
+  restSpeed: 10
+}, n = (t) => ({
+  type: "spring",
+  stiffness: 550,
+  damping: t === 0 ? 2 * Math.sqrt(550) : 30,
+  restSpeed: 10
+}), i = {
+  type: "keyframes",
+  duration: 0.8
+}, a = {
+  type: "keyframes",
+  ease: [0.25, 0.1, 0.35, 1],
+  duration: 0.3
+}, o = (t, { keyframes: e }) => e.length > 2 ? i : s.has(t) ? t.startsWith("scale") ? n(e[1]) : r : a;
+export {
+  o as getDefaultTransition
+};

package/dist/node_modules/framer-motion/dist/es/animation/utils/is-animatable.js

@@ -0,0 +1,7 @@
+import { complex as e } from "../../value/types/complex/index.js";
+const n = (r, t) => t === "zIndex" ? !1 : !!(typeof r == "number" || Array.isArray(r) || typeof r == "string" && // It's animatable if we have a string
+(e.test(r) || r === "0") && // And it contains numbers and/or colors
+!r.startsWith("url("));
+export {
+  n as isAnimatable
+};

package/dist/node_modules/framer-motion/dist/es/animation/utils/is-animation-controls.js

@@ -0,0 +1,6 @@
+function n(t) {
+  return t !== null && typeof t == "object" && typeof t.start == "function";
+}
+export {
+  n as isAnimationControls
+};

package/dist/node_modules/framer-motion/dist/es/animation/utils/is-keyframes-target.js

@@ -0,0 +1,4 @@
+const e = (r) => Array.isArray(r);
+export {
+  e as isKeyframesTarget
+};

package/dist/node_modules/framer-motion/dist/es/animation/utils/is-none.js

@@ -0,0 +1,7 @@
+import { isZeroValueString as n } from "../../utils/is-zero-value-string.js";
+function t(r) {
+  return typeof r == "number" ? r === 0 : r !== null ? r === "none" || r === "0" || n(r) : !0;
+}
+export {
+  t as isNone
+};

package/dist/node_modules/framer-motion/dist/es/animation/utils/is-transition-defined.js

@@ -0,0 +1,6 @@
+function g({ when: r, delay: t, delayChildren: a, staggerChildren: n, staggerDirection: i, repeat: l, repeatType: d, repeatDelay: p, from: s, elapsed: y, ...e }) {
+  return !!Object.keys(e).length;
+}
+export {
+  g as isTransitionDefined
+};

package/dist/node_modules/framer-motion/dist/es/components/AnimatePresence/PopChild.js

@@ -0,0 +1,53 @@
+import { j as x } from "../../../../../../_virtual/jsx-runtime.js";
+import * as d from "react";
+import { useId as g, useRef as c, useContext as C, useInsertionEffect as R } from "react";
+import { MotionConfigContext as $ } from "../../context/MotionConfigContext.js";
+class w extends d.Component {
+  getSnapshotBeforeUpdate(n) {
+    const e = this.props.childRef.current;
+    if (e && n.isPresent && !this.props.isPresent) {
+      const i = e.offsetParent, o = i instanceof HTMLElement && i.offsetWidth || 0, t = this.props.sizeRef.current;
+      t.height = e.offsetHeight || 0, t.width = e.offsetWidth || 0, t.top = e.offsetTop, t.left = e.offsetLeft, t.right = o - t.width - t.left;
+    }
+    return null;
+  }
+  /**
+   * Required with getSnapshotBeforeUpdate to stop React complaining.
+   */
+  componentDidUpdate() {
+  }
+  render() {
+    return this.props.children;
+  }
+}
+function j({ children: s, isPresent: n, anchorX: e }) {
+  const i = g(), o = c(null), t = c({
+    width: 0,
+    height: 0,
+    top: 0,
+    left: 0,
+    right: 0
+  }), { nonce: p } = C($);
+  return R(() => {
+    const { width: f, height: h, top: l, left: a, right: m } = t.current;
+    if (n || !o.current || !f || !h)
+      return;
+    const u = e === "left" ? `left: ${a}` : `right: ${m}`;
+    o.current.dataset.motionPopId = i;
+    const r = document.createElement("style");
+    return p && (r.nonce = p), document.head.appendChild(r), r.sheet && r.sheet.insertRule(`
+          [data-motion-pop-id="${i}"] {
+            position: absolute !important;
+            width: ${f}px !important;
+            height: ${h}px !important;
+            ${u}px !important;
+            top: ${l}px !important;
+          }
+        `), () => {
+      document.head.removeChild(r);
+    };
+  }, [n]), x.jsx(w, { isPresent: n, childRef: o, sizeRef: t, children: d.cloneElement(s, { ref: o }) });
+}
+export {
+  j as PopChild
+};

package/dist/node_modules/framer-motion/dist/es/components/AnimatePresence/PresenceChild.js

@@ -0,0 +1,41 @@
+import { j as f } from "../../../../../../_virtual/jsx-runtime.js";
+import * as C from "react";
+import { useId as x, useCallback as j, useMemo as m } from "react";
+import { PresenceContext as M } from "../../context/PresenceContext.js";
+import { useConstant as v } from "../../utils/use-constant.js";
+import { PopChild as w } from "./PopChild.js";
+const E = ({ children: s, initial: c, isPresent: r, onExitComplete: o, custom: u, presenceAffectsLayout: i, mode: p, anchorX: l }) => {
+  const e = v(z), d = x(), n = j((t) => {
+    e.set(t, !0);
+    for (const a of e.values())
+      if (!a)
+        return;
+    o && o();
+  }, [e, o]), h = m(
+    () => ({
+      id: d,
+      initial: c,
+      isPresent: r,
+      custom: u,
+      onExitComplete: n,
+      register: (t) => (e.set(t, !1), () => e.delete(t))
+    }),
+    /**
+     * If the presence of a child affects the layout of the components around it,
+     * we want to make a new context value to ensure they get re-rendered
+     * so they can detect that layout change.
+     */
+    i ? [Math.random(), n] : [r, n]
+  );
+  return m(() => {
+    e.forEach((t, a) => e.set(a, !1));
+  }, [r]), C.useEffect(() => {
+    !r && !e.size && o && o();
+  }, [r]), p === "popLayout" && (s = f.jsx(w, { isPresent: r, anchorX: l, children: s })), f.jsx(M.Provider, { value: h, children: s });
+};
+function z() {
+  return /* @__PURE__ */ new Map();
+}
+export {
+  E as PresenceChild
+};

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

@@ -0,0 +1,45 @@
+import { j as h } from "../../../../../../_virtual/jsx-runtime.js";
+import { useMemo as K, useRef as g, useState as w, useContext as M } from "react";
+import { LayoutGroupContext as N } from "../../context/LayoutGroupContext.js";
+import { useConstant as T } from "../../utils/use-constant.js";
+import { useIsomorphicLayoutEffect as F } from "../../utils/use-isomorphic-effect.js";
+import { PresenceChild as G } from "./PresenceChild.js";
+import { usePresence as O } from "./use-presence.js";
+import { onlyElements as R, getChildKey as c } from "./utils.js";
+const H = ({ children: p, custom: j, initial: k = !0, onExitComplete: C, presenceAffectsLayout: A = !0, mode: u = "sync", propagate: l = !1, anchorX: L = "left" }) => {
+  const [x, f] = O(l), n = K(() => R(p), [p]), o = l && !x ? [] : n.map(c), y = g(!0), v = g(n), s = T(() => /* @__PURE__ */ new Map()), [b, D] = w(n), [i, E] = w(n);
+  F(() => {
+    y.current = !1, v.current = n;
+    for (let t = 0; t < i.length; t++) {
+      const e = c(i[t]);
+      o.includes(e) ? s.delete(e) : s.get(e) !== !0 && s.set(e, !1);
+    }
+  }, [i, o.length, o.join("-")]);
+  const d = [];
+  if (n !== b) {
+    let t = [...n];
+    for (let e = 0; e < i.length; e++) {
+      const r = i[e], a = c(r);
+      o.includes(a) || (t.splice(e, 0, r), d.push(r));
+    }
+    return u === "wait" && d.length && (t = d), E(R(t)), D(n), null;
+  }
+  process.env.NODE_ENV !== "production" && u === "wait" && i.length > 1 && console.warn(`You're attempting to animate multiple children within AnimatePresence, but its mode is set to "wait". This will lead to odd visual behaviour.`);
+  const { forceRender: m } = M(N);
+  return h.jsx(h.Fragment, { children: i.map((t) => {
+    const e = c(t), r = l && !x ? !1 : n === i || o.includes(e), a = () => {
+      if (s.has(e))
+        s.set(e, !0);
+      else
+        return;
+      let P = !0;
+      s.forEach((I) => {
+        I || (P = !1);
+      }), P && (m == null || m(), E(v.current), l && (f == null || f()), C && C());
+    };
+    return h.jsx(G, { isPresent: r, initial: !y.current || k ? void 0 : !1, custom: j, presenceAffectsLayout: A, mode: u, onExitComplete: r ? void 0 : a, anchorX: L, children: t }, e);
+  }) });
+};
+export {
+  H as AnimatePresence
+};

package/dist/node_modules/framer-motion/dist/es/components/AnimatePresence/use-presence.js

@@ -0,0 +1,17 @@
+import { useContext as f, useId as l, useEffect as c, useCallback as i } from "react";
+import { PresenceContext as m } from "../../context/PresenceContext.js";
+function p(e = !0) {
+  const o = f(m);
+  if (o === null)
+    return [!0, null];
+  const { isPresent: r, onExitComplete: t, register: u } = o, n = l();
+  c(() => {
+    if (e)
+      return u(n);
+  }, [e]);
+  const s = i(() => e && t && t(n), [n, t, e]);
+  return !r && t ? [!1, s] : [!0];
+}
+export {
+  p as usePresence
+};

package/dist/node_modules/framer-motion/dist/es/components/AnimatePresence/utils.js

@@ -0,0 +1,12 @@
+import { Children as o, isValidElement as r } from "react";
+const l = (e) => e.key || "";
+function f(e) {
+  const t = [];
+  return o.forEach(e, (n) => {
+    r(n) && t.push(n);
+  }), t;
+}
+export {
+  l as getChildKey,
+  f as onlyElements
+};