laif-ds 0.1.3 → 0.1.5

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

@@ -0,0 +1,38 @@
+"use client";
+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 o = g[0], n = {
+    done: !1,
+    value: o
+  }, 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 = o + c, u = l === void 0 ? d : l(d);
+  u !== d && (c = u - o);
+  const p = (e) => -c * Math.exp(-e / b), h = (e) => u + p(e), y = (e) => {
+    const s = p(e), G = h(e);
+    n.done = Math.abs(s) <= 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 s = !1;
+      return !i && r === void 0 && (s = !0, y(e), v(e)), r !== void 0 && e >= r ? i.next(e - r) : (!s && y(e), n);
+    }
+  };
+}
+export {
+  $ as inertia
+};

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

@@ -0,0 +1,31 @@
+"use client";
+import { easeInOut as c } from "../../easing/ease.js";
+import { isEasingArray as p } from "../../easing/utils/is-easing-array.js";
+import { easingDefinitionToFunction as f } 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: e = "easeInOut" }) {
+  const r = p(e) ? e.map(f) : f(e), i = {
+    done: !1,
+    value: t[0]
+  }, m = 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(m, t, {
+    ease: Array.isArray(r) ? r : T(t, r)
+  });
+  return {
+    calculatedDuration: n,
+    next: (s) => (i.value = a(s), i.done = s >= 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,33 @@
+"use client";
+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,53 @@
+"use client";
+import { warning as S } 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: i = n.velocity, mass: o = n.mass }) {
+  let a, f;
+  S(t <= g(n.maxDuration), "Spring duration must be 10 seconds or less");
+  let e = 1 - p;
+  e = h(n.minDamping, n.maxDamping, e), t = h(n.minDuration, n.maxDuration, N(t)), e < 1 ? (a = (s) => {
+    const r = s * e, c = r * t, l = r - i, m = b(s, e), x = Math.exp(-c);
+    return D - l / m * x;
+  }, f = (s) => {
+    const c = s * e * t, l = c * i + i, m = Math.pow(e, 2) * Math.pow(s, 2) * t, x = Math.exp(-c), u = b(Math.pow(s, 2), e);
+    return (-a(s) + D > 0 ? -1 : 1) * ((l - m) * x) / u;
+  }) : (a = (s) => {
+    const r = Math.exp(-s * t), c = (s - i) * t + 1;
+    return -1e-3 + r * c;
+  }, f = (s) => {
+    const r = Math.exp(-s * t), c = (i - s) * (t * t);
+    return r * c;
+  });
+  const w = 5 / t, M = A(a, f, w);
+  if (t = g(t), isNaN(M))
+    return {
+      stiffness: n.stiffness,
+      damping: n.damping,
+      duration: t
+    };
+  {
+    const s = Math.pow(M, 2) * o;
+    return {
+      stiffness: s,
+      damping: e * 2 * Math.sqrt(o * s),
+      duration: t
+    };
+  }
+}
+const T = 12;
+function A(t, p, i) {
+  let o = i;
+  for (let a = 1; a < T; a++)
+    o = o - t(o) / p(o);
+  return o;
+}
+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,93 @@
+"use client";
+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 @@
+"use client";
+import { velocityPerSecond as r } from "../../../utils/velocity-per-second.js";
+const n = 5;
+function a(t, e, c) {
+  const o = Math.max(e - n, 0);
+  return r(c - t(o), e - o);
+}
+export {
+  a as calcGeneratorVelocity
+};

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

@@ -0,0 +1,48 @@
+"use client";
+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 f } from "../../../../../motion-utils/dist/es/time-conversion.js";
+import { frame as T } from "../../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 U } 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 - f(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
+  };
+  U(o) || (e = {
+    ...e,
+    ...C(i, e)
+  }), e.duration && (e.duration = f(e.duration)), e.repeatDelay && (e.repeatDelay = f(e.repeatDelay)), e.from !== void 0 && (e.keyframes[0] = e.from);
+  let p = !1;
+  if ((e.type === !1 || e.duration === 0 && !e.repeatDelay) && (e.duration = 0, e.delay === 0 && (p = !0)), p && !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,47 @@
+"use client";
+import "../../../../../motion-utils/dist/es/errors.js";
+import { getValueTransition as M } from "../../../../../motion-dom/dist/es/animation/utils/get-value-transition.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";
+import { frame as V } from "../../frameloop/frame.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, ...u } = a;
+  i && (p = i);
+  const f = [], c = m && t.animationState && t.animationState.getState()[m];
+  for (const o in u) {
+    const s = t.getValue(o, (r = t.latestValues[o]) !== null && r !== void 0 ? r : null), d = u[o];
+    if (d === void 0 || c && I(c, 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, d, 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,34 @@
+"use client";
+import { resolveVariant as h } from "../../render/utils/resolve-dynamic-variants.js";
+import { animateTarget as g } from "./visual-element-target.js";
+function u(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: c = 0, staggerChildren: m, staggerDirection: l } = s;
+    return C(r, t, c + e, m, l, n);
+  } : () => Promise.resolve(), { when: f } = s;
+  if (f) {
+    const [e, c] = f === "beforeChildren" ? [o, d] : [d, o];
+    return e().then(() => c());
+  } else
+    return Promise.all([o(), d(n.delay)]);
+}
+function C(r, t, n = 0, i = 0, a = 1, s) {
+  const o = [], d = (r.variantChildren.size - 1) * i, f = a === 1 ? (e = 0) => e * i : (e = 0) => d - e * i;
+  return Array.from(r.variantChildren).sort(y).forEach((e, c) => {
+    e.notify("AnimationStart", t), o.push(u(e, t, {
+      ...s,
+      delay: n + f(c)
+    }).then(() => e.notify("AnimationComplete", t)));
+  }), Promise.all(o);
+}
+function y(r, t) {
+  return r.sortNodePosition(t);
+}
+export {
+  u as animateVariant,
+  y as sortByTreeOrder
+};

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

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

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

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

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

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

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

@@ -0,0 +1,23 @@
+"use client";
+import { transformProps as s } from "../../render/html/utils/keys-transform.js";
+const r = {
+  type: "spring",
+  stiffness: 500,
+  damping: 25,
+  restSpeed: 10
+}, n = (e) => ({
+  type: "spring",
+  stiffness: 550,
+  damping: e === 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 = (e, { keyframes: t }) => t.length > 2 ? i : s.has(e) ? e.startsWith("scale") ? n(t[1]) : r : a;
+export {
+  o as getDefaultTransition
+};

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

@@ -0,0 +1,8 @@
+"use client";
+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,7 @@
+"use client";
+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,5 @@
+"use client";
+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,8 @@
+"use client";
+import { isZeroValueString as e } from "../../utils/is-zero-value-string.js";
+function t(r) {
+  return typeof r == "number" ? r === 0 : r !== null ? r === "none" || r === "0" || e(r) : !0;
+}
+export {
+  t as isNone
+};

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

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

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

@@ -0,0 +1,42 @@
+"use client";
+import { j as f } from "../../../../../../_virtual/jsx-runtime.js";
+import * as C from "react";
+import { useId as h, useCallback as x, useMemo as m } from "react";
+import { PresenceContext as j } from "../../context/PresenceContext.js";
+import { useConstant as M } from "../../utils/use-constant.js";
+import { PopChild as v } from "./PopChild.js";
+const y = ({ children: s, initial: u, isPresent: r, onExitComplete: o, custom: c, presenceAffectsLayout: i, mode: p }) => {
+  const e = M(w), l = h(), n = x((t) => {
+    e.set(t, !0);
+    for (const a of e.values())
+      if (!a)
+        return;
+    o && o();
+  }, [e, o]), d = m(
+    () => ({
+      id: l,
+      initial: u,
+      isPresent: r,
+      custom: c,
+      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(v, { isPresent: r, children: s })), f.jsx(j.Provider, { value: d, children: s });
+};
+function w() {
+  return /* @__PURE__ */ new Map();
+}
+export {
+  y as PresenceChild
+};

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

@@ -0,0 +1,47 @@
+"use client";
+import { j as h } from "../../../../../../_virtual/jsx-runtime.js";
+import { useMemo as I, useRef as g, useState as w, useContext as K } from "react";
+import { LayoutGroupContext as M } from "../../context/LayoutGroupContext.js";
+import { useConstant as N } from "../../utils/use-constant.js";
+import { PresenceChild as T } from "./PresenceChild.js";
+import { usePresence as F } from "./use-presence.js";
+import { onlyElements as R, getChildKey as c } from "./utils.js";
+import { useIsomorphicLayoutEffect as G } from "../../utils/use-isomorphic-effect.js";
+const H = ({ children: p, custom: j, initial: k = !0, onExitComplete: C, presenceAffectsLayout: A = !0, mode: u = "sync", propagate: l = !1 }) => {
+  const [x, d] = F(l), n = I(() => R(p), [p]), o = l && !x ? [] : n.map(c), y = g(!0), v = g(n), r = N(() => /* @__PURE__ */ new Map()), [L, b] = w(n), [i, E] = w(n);
+  G(() => {
+    y.current = !1, v.current = n;
+    for (let t = 0; t < i.length; t++) {
+      const e = c(i[t]);
+      o.includes(e) ? r.delete(e) : r.get(e) !== !0 && r.set(e, !1);
+    }
+  }, [i, o.length, o.join("-")]);
+  const f = [];
+  if (n !== L) {
+    let t = [...n];
+    for (let e = 0; e < i.length; e++) {
+      const s = i[e], a = c(s);
+      o.includes(a) || (t.splice(e, 0, s), f.push(s));
+    }
+    u === "wait" && f.length && (t = f), E(R(t)), b(n);
+    return;
+  }
+  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 } = K(M);
+  return h.jsx(h.Fragment, { children: i.map((t) => {
+    const e = c(t), s = l && !x ? !1 : n === i || o.includes(e), a = () => {
+      if (r.has(e))
+        r.set(e, !0);
+      else
+        return;
+      let P = !0;
+      r.forEach((D) => {
+        D || (P = !1);
+      }), P && (m == null || m(), E(v.current), l && (d == null || d()), C && C());
+    };
+    return h.jsx(T, { isPresent: s, initial: !y.current || k ? void 0 : !1, custom: s ? void 0 : j, presenceAffectsLayout: A, mode: u, onExitComplete: s ? void 0 : a, children: t }, e);
+  }) });
+};
+export {
+  H as AnimatePresence
+};

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

@@ -0,0 +1,17 @@
+"use client";
+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: s } = o, n = l();
+  c(() => {
+    e && s(n);
+  }, [e]);
+  const u = i(() => e && t && t(n), [n, t, e]);
+  return !r && t ? [!1, u] : [!0];
+}
+export {
+  p as usePresence
+};