lawgic-dev-kit 0.2.4 → 0.3.4

package/dist/node_modules/date-fns/setMinutes.js

@@ -0,0 +1,9 @@
+import { toDate as a } from "./toDate.js";
+function n(r, u, e) {
+  const t = a(r, e == null ? void 0 : e.in);
+  return t.setMinutes(u), t;
+}
+export {
+  n as default,
+  n as setMinutes
+};

package/dist/node_modules/date-fns/setSeconds.js

@@ -0,0 +1,9 @@
+import { toDate as c } from "./toDate.js";
+function f(r, a, e) {
+  const t = c(r, e == null ? void 0 : e.in);
+  return t.setSeconds(a), t;
+}
+export {
+  f as default,
+  f as setSeconds
+};

package/dist/node_modules/date-fns/startOfDay.js

@@ -0,0 +1,9 @@
+import { toDate as e } from "./toDate.js";
+function u(a, t) {
+  const r = e(a, t == null ? void 0 : t.in);
+  return r.setHours(0, 0, 0, 0), r;
+}
+export {
+  u as default,
+  u as startOfDay
+};

package/dist/node_modules/date-fns/startOfISOWeek.js

@@ -0,0 +1,8 @@
+import { startOfWeek as r } from "./startOfWeek.js";
+function f(t, e) {
+  return r(t, { ...e, weekStartsOn: 1 });
+}
+export {
+  f as default,
+  f as startOfISOWeek
+};

package/dist/node_modules/date-fns/startOfISOWeekYear.js

@@ -0,0 +1,11 @@
+import { constructFrom as a } from "./constructFrom.js";
+import { getISOWeekYear as f } from "./getISOWeekYear.js";
+import { startOfISOWeek as s } from "./startOfISOWeek.js";
+function O(t, e) {
+  const o = f(t, e), r = a(t, 0);
+  return r.setFullYear(o, 0, 4), r.setHours(0, 0, 0, 0), s(r);
+}
+export {
+  O as default,
+  O as startOfISOWeekYear
+};

package/dist/node_modules/date-fns/startOfMonth.js

@@ -0,0 +1,9 @@
+import { toDate as a } from "./toDate.js";
+function u(r, t) {
+  const e = a(r, t == null ? void 0 : t.in);
+  return e.setDate(1), e.setHours(0, 0, 0, 0), e;
+}
+export {
+  u as default,
+  u as startOfMonth
+};

package/dist/node_modules/date-fns/startOfWeek.js

@@ -0,0 +1,11 @@
+import { getDefaultOptions as s } from "./_lib/defaultOptions.js";
+import { toDate as w } from "./toDate.js";
+function m(u, e) {
+  var c, O, l, k;
+  const a = s(), r = (e == null ? void 0 : e.weekStartsOn) ?? ((O = (c = e == null ? void 0 : e.locale) == null ? void 0 : c.options) == null ? void 0 : O.weekStartsOn) ?? a.weekStartsOn ?? ((k = (l = a.locale) == null ? void 0 : l.options) == null ? void 0 : k.weekStartsOn) ?? 0, t = w(u, e == null ? void 0 : e.in), f = t.getDay(), d = (f < r ? 7 : 0) + f - r;
+  return t.setDate(t.getDate() - d), t.setHours(0, 0, 0, 0), t;
+}
+export {
+  m as default,
+  m as startOfWeek
+};

package/dist/node_modules/date-fns/startOfWeekYear.js

@@ -0,0 +1,13 @@
+import { getDefaultOptions as W } from "./_lib/defaultOptions.js";
+import { constructFrom as n } from "./constructFrom.js";
+import { getWeekYear as u } from "./getWeekYear.js";
+import { startOfWeek as D } from "./startOfWeek.js";
+function g(r, e) {
+  var f, s, c, k;
+  const a = W(), l = (e == null ? void 0 : e.firstWeekContainsDate) ?? ((s = (f = e == null ? void 0 : e.locale) == null ? void 0 : f.options) == null ? void 0 : s.firstWeekContainsDate) ?? a.firstWeekContainsDate ?? ((k = (c = a.locale) == null ? void 0 : c.options) == null ? void 0 : k.firstWeekContainsDate) ?? 1, m = u(r, e), t = n((e == null ? void 0 : e.in) || r, 0);
+  return t.setFullYear(m, 0, l), t.setHours(0, 0, 0, 0), D(t, e);
+}
+export {
+  g as default,
+  g as startOfWeekYear
+};

package/dist/node_modules/date-fns/startOfYear.js

@@ -0,0 +1,9 @@
+import { toDate as a } from "./toDate.js";
+function l(t, r) {
+  const e = a(t, r == null ? void 0 : r.in);
+  return e.setFullYear(e.getFullYear(), 0, 1), e.setHours(0, 0, 0, 0), e;
+}
+export {
+  l as default,
+  l as startOfYear
+};

package/dist/node_modules/date-fns/subMonths.js

@@ -0,0 +1,8 @@
+import { addMonths as n } from "./addMonths.js";
+function a(t, r, o) {
+  return n(t, -1, o);
+}
+export {
+  a as default,
+  a as subMonths
+};

package/dist/node_modules/date-fns/toDate.js

@@ -0,0 +1,8 @@
+import { constructFrom as r } from "./constructFrom.js";
+function e(t, o) {
+  return r(o || t, t);
+}
+export {
+  e as default,
+  e as toDate
+};

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

@@ -0,0 +1,11 @@
+import "../../../../../motion-utils/dist/es/errors.js";
+import { motionValue as m } from "../../../../../motion-dom/dist/es/value/index.js";
+import { isMotionValue as r } from "../../value/utils/is-motion-value.js";
+import { animateMotionValue as a } from "../interfaces/motion-value.js";
+function f(o, i, n) {
+  const t = r(o) ? o : m(o);
+  return t.start(a("", t, i, n)), t.animation;
+}
+export {
+  f as animateSingleValue
+};

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

@@ -0,0 +1,205 @@
+import "../../../../../motion-utils/dist/es/errors.js";
+import { noop as y } from "../../../../../motion-utils/dist/es/noop.js";
+import { millisecondsToSeconds as g, secondsToMilliseconds as T } from "../../../../../motion-utils/dist/es/time-conversion.js";
+import { isGenerator as V } from "../../../../../motion-dom/dist/es/animation/generators/utils/is-generator.js";
+import { attachTimeline as w } from "../../../../../motion-dom/dist/es/animation/waapi/utils/attach-timeline.js";
+import { isWaapiSupportedEasing as F } from "../../../../../motion-dom/dist/es/animation/waapi/utils/easing.js";
+import { supportsLinearEasing as K } from "../../../../../motion-dom/dist/es/utils/supports/linear-easing.js";
+import { anticipate as E } from "../../easing/anticipate.js";
+import { backInOut as R } from "../../easing/back.js";
+import { circInOut as b } from "../../easing/circ.js";
+import { DOMKeyframesResolver as D } from "../../render/dom/DOMKeyframesResolver.js";
+import { BaseAnimation as M } from "./BaseAnimation.js";
+import { MainThreadAnimation as S } from "./MainThreadAnimation.js";
+import { acceleratedValues as U } from "./utils/accelerated-values.js";
+import { startWaapiAnimation as W } from "./waapi/index.js";
+import { getFinalKeyframe as x } from "./waapi/utils/get-final-keyframe.js";
+import { supportsWaapi as C } from "./waapi/utils/supports-waapi.js";
+const f = 10, G = 2e4;
+function O(r) {
+  return V(r.type) || r.type === "spring" || !F(r.ease);
+}
+function k(r, e) {
+  const t = new S({
+    ...e,
+    keyframes: r,
+    repeat: 0,
+    delay: 0,
+    isGenerator: !0
+  });
+  let i = { done: !1, value: r[0] };
+  const s = [];
+  let n = 0;
+  for (; !i.done && n < G; )
+    i = t.sample(n), s.push(i.value), n += f;
+  return {
+    times: void 0,
+    keyframes: s,
+    duration: n - f,
+    ease: "linear"
+  };
+}
+const A = {
+  anticipate: E,
+  backInOut: R,
+  circInOut: b
+};
+function I(r) {
+  return r in A;
+}
+class ne extends M {
+  constructor(e) {
+    super(e);
+    const { name: t, motionValue: i, element: s, keyframes: n } = this.options;
+    this.resolver = new D(n, (a, o) => this.onKeyframesResolved(a, o), t, i, s), this.resolver.scheduleResolve();
+  }
+  initPlayback(e, t) {
+    let { duration: i = 300, times: s, ease: n, type: a, motionValue: o, name: p, startTime: m } = this.options;
+    if (!o.owner || !o.owner.current)
+      return !1;
+    if (typeof n == "string" && K() && I(n) && (n = A[n]), O(this.options)) {
+      const { onComplete: c, onUpdate: P, motionValue: v, element: h, ...u } = this.options, d = k(e, u);
+      e = d.keyframes, e.length === 1 && (e[1] = e[0]), i = d.duration, s = d.times, n = d.ease, a = "keyframes";
+    }
+    const l = W(o.owner.current, p, e, { ...this.options, duration: i, times: s, ease: n });
+    return l.startTime = m ?? this.calcStartTime(), this.pendingTimeline ? (w(l, this.pendingTimeline), this.pendingTimeline = void 0) : l.onfinish = () => {
+      const { onComplete: c } = this.options;
+      o.set(x(e, this.options, t)), c && c(), this.cancel(), this.resolveFinishedPromise();
+    }, {
+      animation: l,
+      duration: i,
+      times: s,
+      type: a,
+      ease: n,
+      keyframes: e
+    };
+  }
+  get duration() {
+    const { resolved: e } = this;
+    if (!e)
+      return 0;
+    const { duration: t } = e;
+    return g(t);
+  }
+  get time() {
+    const { resolved: e } = this;
+    if (!e)
+      return 0;
+    const { animation: t } = e;
+    return g(t.currentTime || 0);
+  }
+  set time(e) {
+    const { resolved: t } = this;
+    if (!t)
+      return;
+    const { animation: i } = t;
+    i.currentTime = T(e);
+  }
+  get speed() {
+    const { resolved: e } = this;
+    if (!e)
+      return 1;
+    const { animation: t } = e;
+    return t.playbackRate;
+  }
+  set speed(e) {
+    const { resolved: t } = this;
+    if (!t)
+      return;
+    const { animation: i } = t;
+    i.playbackRate = e;
+  }
+  get state() {
+    const { resolved: e } = this;
+    if (!e)
+      return "idle";
+    const { animation: t } = e;
+    return t.playState;
+  }
+  get startTime() {
+    const { resolved: e } = this;
+    if (!e)
+      return null;
+    const { animation: t } = e;
+    return t.startTime;
+  }
+  /**
+   * Replace the default DocumentTimeline with another AnimationTimeline.
+   * Currently used for scroll animations.
+   */
+  attachTimeline(e) {
+    if (!this._resolved)
+      this.pendingTimeline = e;
+    else {
+      const { resolved: t } = this;
+      if (!t)
+        return y;
+      const { animation: i } = t;
+      w(i, e);
+    }
+    return y;
+  }
+  play() {
+    if (this.isStopped)
+      return;
+    const { resolved: e } = this;
+    if (!e)
+      return;
+    const { animation: t } = e;
+    t.playState === "finished" && this.updateFinishedPromise(), t.play();
+  }
+  pause() {
+    const { resolved: e } = this;
+    if (!e)
+      return;
+    const { animation: t } = e;
+    t.pause();
+  }
+  stop() {
+    if (this.resolver.cancel(), this.isStopped = !0, this.state === "idle")
+      return;
+    this.resolveFinishedPromise(), this.updateFinishedPromise();
+    const { resolved: e } = this;
+    if (!e)
+      return;
+    const { animation: t, keyframes: i, duration: s, type: n, ease: a, times: o } = e;
+    if (t.playState === "idle" || t.playState === "finished")
+      return;
+    if (this.time) {
+      const { motionValue: m, onUpdate: l, onComplete: c, element: P, ...v } = this.options, h = new S({
+        ...v,
+        keyframes: i,
+        duration: s,
+        type: n,
+        ease: a,
+        times: o,
+        isGenerator: !0
+      }), u = T(this.time);
+      m.setWithVelocity(h.sample(u - f).value, h.sample(u).value, f);
+    }
+    const { onStop: p } = this.options;
+    p && p(), this.cancel();
+  }
+  complete() {
+    const { resolved: e } = this;
+    e && e.animation.finish();
+  }
+  cancel() {
+    const { resolved: e } = this;
+    e && e.animation.cancel();
+  }
+  static supports(e) {
+    const { motionValue: t, name: i, repeatDelay: s, repeatType: n, damping: a, type: o } = e;
+    if (!t || !t.owner || !(t.owner.current instanceof HTMLElement))
+      return !1;
+    const { onUpdate: p, transformTemplate: m } = t.owner.getProps();
+    return C() && i && U.has(i) && (i !== "transform" || !m) && /**
+     * If we're outputting values to onUpdate then we can't use WAAPI as there's
+     * no way to read the value from WAAPI every frame.
+     */
+    !p && !s && n !== "mirror" && a !== 0 && o !== "inertia";
+  }
+}
+export {
+  ne as AcceleratedAnimation
+};

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

@@ -0,0 +1,83 @@
+import "../../../../../motion-utils/dist/es/errors.js";
+import { time as a } from "../../../../../motion-dom/dist/es/frameloop/sync-time.js";
+import { flushKeyframeResolvers as m } from "../../render/utils/KeyframesResolver.js";
+import { canAnimate as p } from "./utils/can-animate.js";
+import { getFinalKeyframe as v } from "./waapi/utils/get-final-keyframe.js";
+const c = 40;
+class y {
+  constructor({ autoplay: e = !0, delay: t = 0, type: i = "keyframes", repeat: o = 0, repeatDelay: r = 0, repeatType: n = "loop", ...s }) {
+    this.isStopped = !1, this.hasAttemptedResolve = !1, this.createdAt = a.now(), this.options = {
+      autoplay: e,
+      delay: t,
+      type: i,
+      repeat: o,
+      repeatDelay: r,
+      repeatType: n,
+      ...s
+    }, this.updateFinishedPromise();
+  }
+  /**
+   * This method uses the createdAt and resolvedAt to calculate the
+   * animation startTime. *Ideally*, we would use the createdAt time as t=0
+   * as the following frame would then be the first frame of the animation in
+   * progress, which would feel snappier.
+   *
+   * However, if there's a delay (main thread work) between the creation of
+   * the animation and the first commited frame, we prefer to use resolvedAt
+   * to avoid a sudden jump into the animation.
+   */
+  calcStartTime() {
+    return this.resolvedAt ? this.resolvedAt - this.createdAt > c ? this.resolvedAt : this.createdAt : this.createdAt;
+  }
+  /**
+   * A getter for resolved data. If keyframes are not yet resolved, accessing
+   * this.resolved will synchronously flush all pending keyframe resolvers.
+   * This is a deoptimisation, but at its worst still batches read/writes.
+   */
+  get resolved() {
+    return !this._resolved && !this.hasAttemptedResolve && m(), this._resolved;
+  }
+  /**
+   * A method to be called when the keyframes resolver completes. This method
+   * will check if its possible to run the animation and, if not, skip it.
+   * Otherwise, it will call initPlayback on the implementing class.
+   */
+  onKeyframesResolved(e, t) {
+    this.resolvedAt = a.now(), this.hasAttemptedResolve = !0;
+    const { name: i, type: o, velocity: r, delay: n, onComplete: s, onUpdate: h, isGenerator: d } = this.options;
+    if (!d && !p(e, i, o, r))
+      if (n)
+        this.options.duration = 0;
+      else {
+        h && h(v(e, this.options, t)), s && s(), this.resolveFinishedPromise();
+        return;
+      }
+    const l = this.initPlayback(e, t);
+    l !== !1 && (this._resolved = {
+      keyframes: e,
+      finalKeyframe: t,
+      ...l
+    }, this.onPostResolved());
+  }
+  onPostResolved() {
+  }
+  /**
+   * Allows the returned animation to be awaited or promise-chained. Currently
+   * resolves when the animation finishes at all but in a future update could/should
+   * reject if its cancels.
+   */
+  then(e, t) {
+    return this.currentFinishedPromise.then(e, t);
+  }
+  flatten() {
+    this.options.allowFlatten && (this.options.type = "keyframes", this.options.ease = "linear");
+  }
+  updateFinishedPromise() {
+    this.currentFinishedPromise = new Promise((e) => {
+      this.resolveFinishedPromise = e;
+    });
+  }
+}
+export {
+  y as BaseAnimation
+};

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

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

package/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 o, frame as a } from "../../../../../../motion-dom/dist/es/frameloop/frame.js";
+import { time as s } from "../../../../../../motion-dom/dist/es/frameloop/sync-time.js";
+const c = (e) => {
+  const r = ({ timestamp: m }) => e(m);
+  return {
+    start: () => a.update(r, !0),
+    stop: () => o(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/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/node_modules/framer-motion/dist/es/animation/animators/utils/can-animate.js

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

package/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 l } from "../../../../../../motion-dom/dist/es/animation/waapi/utils/easing.js";
+function A(t, e, o, { delay: s = 0, duration: n = 300, repeat: m = 0, repeatType: f = "loop", ease: p = "easeInOut", times: r } = {}) {
+  const i = { [e]: o };
+  r && (i.offset = r);
+  const a = l(p, n);
+  return Array.isArray(a) && (i.easing = a), t.animate(i, {
+    delay: s,
+    duration: n,
+    easing: Array.isArray(a) ? "linear" : a,
+    fill: "both",
+    iterations: m + 1,
+    direction: f === "reverse" ? "alternate" : "normal"
+  });
+}
+export {
+  A as startWaapiAnimation
+};

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

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

package/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 e = /* @__PURE__ */ t(() => Object.hasOwnProperty.call(Element.prototype, "animate"));
+export {
+  e as supportsWaapi
+};