lawgic-dev-kit 0.12.6 → 0.12.8

package/dist/dist/node_modules/framer-motion/dist/es/animation/animators/MainThreadAnimation.js

@@ -0,0 +1,147 @@
+import { invariant as R } from "../../../../../motion-utils/dist/es/errors.js";
+import { millisecondsToSeconds as g, secondsToMilliseconds as _ } from "../../../../../motion-utils/dist/es/time-conversion.js";
+import { calcGeneratorDuration as G } from "../../../../../motion-dom/dist/es/animation/generators/utils/calc-duration.js";
+import { isGenerator as $ } from "../../../../../motion-dom/dist/es/animation/generators/utils/is-generator.js";
+import { KeyframeResolver as E } from "../../render/utils/KeyframesResolver.js";
+import { clamp as O } from "../../utils/clamp.js";
+import { mix as A } from "../../utils/mix/index.js";
+import { pipe as N } from "../../utils/pipe.js";
+import { inertia as F } from "../generators/inertia.js";
+import { keyframes as u } from "../generators/keyframes.js";
+import { spring as U } from "../generators/spring/index.js";
+import { BaseAnimation as V } from "./BaseAnimation.js";
+import { frameloopDriver as W } from "./drivers/driver-frameloop.js";
+import { getFinalKeyframe as j } from "./waapi/utils/get-final-keyframe.js";
+const B = {
+  decay: F,
+  inertia: F,
+  tween: u,
+  keyframes: u,
+  spring: U
+}, C = (k) => k / 100;
+class rt extends V {
+  constructor(t) {
+    super(t), this.holdTime = null, this.cancelTime = null, this.currentTime = 0, this.playbackSpeed = 1, this.pendingPlayState = "running", this.startTime = null, this.state = "idle", this.stop = () => {
+      if (this.resolver.cancel(), this.isStopped = !0, this.state === "idle")
+        return;
+      this.teardown();
+      const { onStop: r } = this.options;
+      r && r();
+    };
+    const { name: e, motionValue: a, element: i, keyframes: o } = this.options, p = (i == null ? void 0 : i.KeyframeResolver) || E, n = (r, l) => this.onKeyframesResolved(r, l);
+    this.resolver = new p(o, n, e, a, i), this.resolver.scheduleResolve();
+  }
+  flatten() {
+    super.flatten(), this._resolved && Object.assign(this._resolved, this.initPlayback(this._resolved.keyframes));
+  }
+  initPlayback(t) {
+    const { type: e = "keyframes", repeat: a = 0, repeatDelay: i = 0, repeatType: o, velocity: p = 0 } = this.options, n = $(e) ? e : B[e] || u;
+    let r, l;
+    process.env.NODE_ENV !== "production" && n !== u && R(t.length <= 2, `Only two keyframes currently supported with spring and inertia animations. Trying to animate ${t}`), n !== u && typeof t[0] != "number" && (r = N(C, A(t[0], t[1])), t = [0, 100]);
+    const s = n({ ...this.options, keyframes: t });
+    o === "mirror" && (l = n({
+      ...this.options,
+      keyframes: [...t].reverse(),
+      velocity: -p
+    })), s.calculatedDuration === null && (s.calculatedDuration = G(s));
+    const { calculatedDuration: m } = s, T = m + i, f = T * (a + 1) - i;
+    return {
+      generator: s,
+      mirroredGenerator: l,
+      mapPercentToKeyframes: r,
+      calculatedDuration: m,
+      resolvedDuration: T,
+      totalDuration: f
+    };
+  }
+  onPostResolved() {
+    const { autoplay: t = !0 } = this.options;
+    this.play(), this.pendingPlayState === "paused" || !t ? this.pause() : this.state = this.pendingPlayState;
+  }
+  tick(t, e = !1) {
+    const { resolved: a } = this;
+    if (!a) {
+      const { keyframes: c } = this.options;
+      return { done: !0, value: c[c.length - 1] };
+    }
+    const { finalKeyframe: i, generator: o, mirroredGenerator: p, mapPercentToKeyframes: n, keyframes: r, calculatedDuration: l, totalDuration: s, resolvedDuration: m } = a;
+    if (this.startTime === null)
+      return o.next(0);
+    const { delay: T, repeat: f, repeatType: D, repeatDelay: S, onUpdate: P } = this.options;
+    this.speed > 0 ? this.startTime = Math.min(this.startTime, t) : this.speed < 0 && (this.startTime = Math.min(t - s / this.speed, this.startTime)), e ? this.currentTime = t : this.holdTime !== null ? this.currentTime = this.holdTime : this.currentTime = Math.round(t - this.startTime) * this.speed;
+    const y = this.currentTime - T * (this.speed >= 0 ? 1 : -1), w = this.speed >= 0 ? y < 0 : y > s;
+    this.currentTime = Math.max(y, 0), this.state === "finished" && this.holdTime === null && (this.currentTime = s);
+    let M = this.currentTime, b = o;
+    if (f) {
+      const c = Math.min(this.currentTime, s) / m;
+      let v = Math.floor(c), h = c % 1;
+      !h && c >= 1 && (h = 1), h === 1 && v--, v = Math.min(v, f + 1), v % 2 && (D === "reverse" ? (h = 1 - h, S && (h -= S / m)) : D === "mirror" && (b = p)), M = O(0, 1, h) * m;
+    }
+    const d = w ? { done: !1, value: r[0] } : b.next(M);
+    n && (d.value = n(d.value));
+    let { done: K } = d;
+    !w && l !== null && (K = this.speed >= 0 ? this.currentTime >= s : this.currentTime <= 0);
+    const x = this.holdTime === null && (this.state === "finished" || this.state === "running" && K);
+    return x && i !== void 0 && (d.value = j(r, this.options, i)), P && P(d.value), x && this.finish(), d;
+  }
+  get duration() {
+    const { resolved: t } = this;
+    return t ? g(t.calculatedDuration) : 0;
+  }
+  get time() {
+    return g(this.currentTime);
+  }
+  set time(t) {
+    t = _(t), this.currentTime = t, this.holdTime !== null || this.speed === 0 ? this.holdTime = t : this.driver && (this.startTime = this.driver.now() - t / this.speed);
+  }
+  get speed() {
+    return this.playbackSpeed;
+  }
+  set speed(t) {
+    const e = this.playbackSpeed !== t;
+    this.playbackSpeed = t, e && (this.time = g(this.currentTime));
+  }
+  play() {
+    if (this.resolver.isScheduled || this.resolver.resume(), !this._resolved) {
+      this.pendingPlayState = "running";
+      return;
+    }
+    if (this.isStopped)
+      return;
+    const { driver: t = W, onPlay: e, startTime: a } = this.options;
+    this.driver || (this.driver = t((o) => this.tick(o))), e && e();
+    const i = this.driver.now();
+    this.holdTime !== null ? this.startTime = i - this.holdTime : this.startTime ? this.state === "finished" && (this.startTime = i) : this.startTime = a ?? this.calcStartTime(), this.state === "finished" && this.updateFinishedPromise(), this.cancelTime = this.startTime, this.holdTime = null, this.state = "running", this.driver.start();
+  }
+  pause() {
+    var t;
+    if (!this._resolved) {
+      this.pendingPlayState = "paused";
+      return;
+    }
+    this.state = "paused", this.holdTime = (t = this.currentTime) !== null && t !== void 0 ? t : 0;
+  }
+  complete() {
+    this.state !== "running" && this.play(), this.pendingPlayState = this.state = "finished", this.holdTime = null;
+  }
+  finish() {
+    this.teardown(), this.state = "finished";
+    const { onComplete: t } = this.options;
+    t && t();
+  }
+  cancel() {
+    this.cancelTime !== null && this.tick(this.cancelTime), this.teardown(), this.updateFinishedPromise();
+  }
+  teardown() {
+    this.state = "idle", this.stopDriver(), this.resolveFinishedPromise(), this.updateFinishedPromise(), this.startTime = this.cancelTime = null, this.resolver.cancel();
+  }
+  stopDriver() {
+    this.driver && (this.driver.stop(), this.driver = void 0);
+  }
+  sample(t) {
+    return this.startTime = 0, this.tick(t, !0);
+  }
+}
+export {
+  rt as MainThreadAnimation
+};

package/dist/dist/node_modules/framer-motion/dist/es/animation/animators/drivers/driver-frameloop.js

@@ -0,0 +1,18 @@
+import "../../../../../../motion-utils/dist/es/errors.js";
+import { frameData as t, cancelFrame as e, frame as m } from "../../../../../../motion-dom/dist/es/frameloop/frame.js";
+import { time as s } from "../../../../../../motion-dom/dist/es/frameloop/sync-time.js";
+const c = (a) => {
+  const r = ({ timestamp: o }) => a(o);
+  return {
+    start: () => m.update(r, !0),
+    stop: () => e(r),
+    /**
+     * If we're processing this frame we can use the
+     * framelocked timestamp to keep things in sync.
+     */
+    now: () => t.isProcessing ? t.timestamp : s.now()
+  };
+};
+export {
+  c as frameloopDriver
+};

package/dist/dist/node_modules/framer-motion/dist/es/animation/animators/utils/accelerated-values.js

@@ -0,0 +1,12 @@
+const e = /* @__PURE__ */ new Set([
+  "opacity",
+  "clipPath",
+  "filter",
+  "transform"
+  // TODO: Can be accelerated but currently disabled until https://issues.chromium.org/issues/41491098 is resolved
+  // or until we implement support for linear() easing.
+  // "background-color"
+]);
+export {
+  e as acceleratedValues
+};

package/dist/dist/node_modules/framer-motion/dist/es/animation/animators/utils/can-animate.js

@@ -0,0 +1,23 @@
+import { warning as u } from "../../../../../../motion-utils/dist/es/errors.js";
+import { isGenerator as f } from "../../../../../../motion-dom/dist/es/animation/generators/utils/is-generator.js";
+import { isAnimatable as s } from "../../utils/is-animatable.js";
+function m(t) {
+  const e = t[0];
+  if (t.length === 1)
+    return !0;
+  for (let n = 0; n < t.length; n++)
+    if (t[n] !== e)
+      return !0;
+}
+function h(t, e, n, l) {
+  const a = t[0];
+  if (a === null)
+    return !1;
+  if (e === "display" || e === "visibility")
+    return !0;
+  const r = t[t.length - 1], i = s(a, e), o = s(r, e);
+  return u(i === o, `You are trying to animate ${e} from "${a}" to "${r}". ${a} is not an animatable value - to enable this animation set ${a} to a value animatable to ${r} via the \`style\` property.`), !i || !o ? !1 : m(t) || (n === "spring" || f(n)) && l;
+}
+export {
+  h as canAnimate
+};

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

@@ -0,0 +1,18 @@
+import "../../../../../../motion-utils/dist/es/errors.js";
+import { mapEasingToNativeEasing as y } from "../../../../../../motion-dom/dist/es/animation/waapi/utils/easing.js";
+function d(i, n, o, { delay: s = 0, duration: r = 300, repeat: p = 0, repeatType: l = "loop", ease: m = "easeInOut", times: t } = {}) {
+  const e = { [n]: o };
+  t && (e.offset = t);
+  const a = y(m, r);
+  return Array.isArray(a) && (e.easing = a), i.animate(e, {
+    delay: s,
+    duration: r,
+    easing: Array.isArray(a) ? "linear" : a,
+    fill: "both",
+    iterations: p + 1,
+    direction: l === "reverse" ? "alternate" : "normal"
+  });
+}
+export {
+  d as startWaapiAnimation
+};

package/dist/dist/node_modules/framer-motion/dist/es/animation/animators/waapi/utils/get-final-keyframe.js

@@ -0,0 +1,8 @@
+const p = (e) => e !== null;
+function a(e, { repeat: t, repeatType: r = "loop" }, l) {
+  const n = e.filter(p), o = t && r !== "loop" && t % 2 === 1 ? 0 : n.length - 1;
+  return !o || l === void 0 ? n[o] : l;
+}
+export {
+  a as getFinalKeyframe
+};

package/dist/dist/node_modules/framer-motion/dist/es/animation/animators/waapi/utils/supports-waapi.js

@@ -0,0 +1,6 @@
+import "../../../../../../../motion-utils/dist/es/errors.js";
+import { memo as t } from "../../../../../../../motion-utils/dist/es/memo.js";
+const p = /* @__PURE__ */ t(() => Object.hasOwnProperty.call(Element.prototype, "animate"));
+export {
+  p as supportsWaapi
+};

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

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

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

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

package/dist/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/dist/node_modules/framer-motion/dist/es/animation/generators/spring/find.js

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

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

package/dist/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 e = 5;
+function l(n, t, r) {
+  const o = Math.max(t - e, 0);
+  return c(r - n(o), t - o);
+}
+export {
+  l as calcGeneratorVelocity
+};

package/dist/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 g } from "../../../../../motion-dom/dist/es/animation/utils/get-value-transition.js";
+import "../../../../../motion-utils/dist/es/errors.js";
+import { secondsToMilliseconds as l } from "../../../../../motion-utils/dist/es/time-conversion.js";
+import { frame as D } from "../../../../../motion-dom/dist/es/frameloop/frame.js";
+import { AcceleratedAnimation as d } from "../animators/AcceleratedAnimation.js";
+import { MainThreadAnimation as v } 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 T } from "../utils/is-transition-defined.js";
+const G = (r, a, n, i = {}, f, m) => (y) => {
+  const o = g(i, r) || {}, u = o.delay || i.delay || 0;
+  let { elapsed: s = 0 } = i;
+  s = s - l(u);
+  let e = {
+    keyframes: Array.isArray(n) ? n : [null, n],
+    ease: "easeOut",
+    velocity: a.getVelocity(),
+    ...o,
+    delay: -s,
+    onUpdate: (t) => {
+      a.set(t), o.onUpdate && o.onUpdate(t);
+    },
+    onComplete: () => {
+      y(), o.onComplete && o.onComplete();
+    },
+    name: r,
+    motionValue: a,
+    element: m ? void 0 : f
+  };
+  T(o) || (e = {
+    ...e,
+    ...C(r, e)
+  }), e.duration && (e.duration = l(e.duration)), e.repeatDelay && (e.repeatDelay = l(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)), e.allowFlatten = !o.type && !o.ease, p && !m && a.get() !== void 0) {
+    const t = A(e.keyframes, o);
+    if (t !== void 0)
+      return D.update(() => {
+        e.onUpdate(t), e.onComplete();
+      }), new c([]);
+  }
+  return !m && d.supports(e) ? new d(e) : new v(e);
+};
+export {
+  G as animateMotionValue
+};

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

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

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

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

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

package/dist/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", p = "data-" + a(t);
+export {
+  p as optimizedAppearDataAttribute,
+  t as optimizedAppearDataId
+};

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

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