lawgic-dev-kit 0.12.6 → 0.12.8

package/dist/dist/node_modules/@fortawesome/pro-light-svg-icons/index.js

@@ -0,0 +1,33 @@
+/*!
+ * Font Awesome Pro 6.7.2 by @fontawesome - https://fontawesome.com
+ * License - https://fontawesome.com/license (Commercial License)
+ * Copyright 2024 Fonticons, Inc.
+ */
+const c = {
+  prefix: "fal",
+  iconName: "circle-exclamation",
+  icon: [512, 512, ["exclamation-circle"], "f06a", "M256 32a224 224 0 1 1 0 448 224 224 0 1 1 0-448zm0 480A256 256 0 1 0 256 0a256 256 0 1 0 0 512zm0-384c-8.8 0-16 7.2-16 16l0 128c0 8.8 7.2 16 16 16s16-7.2 16-16l0-128c0-8.8-7.2-16-16-16zm24 224a24 24 0 1 0 -48 0 24 24 0 1 0 48 0z"]
+}, a = {
+  prefix: "fal",
+  iconName: "circle-check",
+  icon: [512, 512, [61533, "check-circle"], "f058", "M256 32a224 224 0 1 1 0 448 224 224 0 1 1 0-448zm0 480A256 256 0 1 0 256 0a256 256 0 1 0 0 512zM363.3 203.3c6.2-6.2 6.2-16.4 0-22.6s-16.4-6.2-22.6 0L224 297.4l-52.7-52.7c-6.2-6.2-16.4-6.2-22.6 0s-6.2 16.4 0 22.6l64 64c6.2 6.2 16.4 6.2 22.6 0l128-128z"]
+}, l = {
+  prefix: "fal",
+  iconName: "circle-info",
+  icon: [512, 512, ["info-circle"], "f05a", "M256 32a224 224 0 1 1 0 448 224 224 0 1 1 0-448zm0 480A256 256 0 1 0 256 0a256 256 0 1 0 0 512zM208 352c-8.8 0-16 7.2-16 16s7.2 16 16 16l96 0c8.8 0 16-7.2 16-16s-7.2-16-16-16l-32 0 0-112c0-8.8-7.2-16-16-16l-40 0c-8.8 0-16 7.2-16 16s7.2 16 16 16l24 0 0 96-32 0zm48-168a24 24 0 1 0 0-48 24 24 0 1 0 0 48z"]
+}, i = {
+  prefix: "fal",
+  iconName: "xmark",
+  icon: [384, 512, [128473, 10005, 10006, 10060, 215, "close", "multiply", "remove", "times"], "f00d", "M324.5 411.1c6.2 6.2 16.4 6.2 22.6 0s6.2-16.4 0-22.6L214.6 256 347.1 123.5c6.2-6.2 6.2-16.4 0-22.6s-16.4-6.2-22.6 0L192 233.4 59.6 100.9c-6.2-6.2-16.4-6.2-22.6 0s-6.2 16.4 0 22.6L169.4 256 36.9 388.5c-6.2 6.2-6.2 16.4 0 22.6s16.4 6.2 22.6 0L192 278.6 324.5 411.1z"]
+}, e = {
+  prefix: "fal",
+  iconName: "triangle-exclamation",
+  icon: [512, 512, [9888, "exclamation-triangle", "warning"], "f071", "M34.5 420.4c-1.6 2.8-2.5 6-2.5 9.3c0 10.2 8.2 18.4 18.4 18.4l411.2 0c10.2 0 18.4-8.2 18.4-18.4c0-3.3-.9-6.4-2.5-9.3L276.5 75.8C272.2 68.5 264.4 64 256 64s-16.2 4.5-20.5 11.8L34.5 420.4zM6.9 404.2l201-344.6C217.9 42.5 236.2 32 256 32s38.1 10.5 48.1 27.6l201 344.6c4.5 7.7 6.9 16.5 6.9 25.4c0 27.8-22.6 50.4-50.4 50.4L50.4 480C22.6 480 0 457.4 0 429.6c0-8.9 2.4-17.7 6.9-25.4zM256 160c8.8 0 16 7.2 16 16l0 128c0 8.8-7.2 16-16 16s-16-7.2-16-16l0-128c0-8.8 7.2-16 16-16zM232 384a24 24 0 1 1 48 0 24 24 0 1 1 -48 0z"]
+};
+export {
+  a as faCircleCheck,
+  c as faCircleExclamation,
+  l as faCircleInfo,
+  e as faTriangleExclamation,
+  i as faXmark
+};

package/dist/dist/node_modules/@fortawesome/react-fontawesome/index.es.js

@@ -0,0 +1,266 @@
+import { parse as A, icon as _ } from "../fontawesome-svg-core/index.js";
+import n from "../../../_virtual/index.js";
+import C from "react";
+function E(t, r) {
+  var e = Object.keys(t);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(t);
+    r && (o = o.filter(function(a) {
+      return Object.getOwnPropertyDescriptor(t, a).enumerable;
+    })), e.push.apply(e, o);
+  }
+  return e;
+}
+function f(t) {
+  for (var r = 1; r < arguments.length; r++) {
+    var e = arguments[r] != null ? arguments[r] : {};
+    r % 2 ? E(Object(e), !0).forEach(function(o) {
+      b(t, o, e[o]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(t, Object.getOwnPropertyDescriptors(e)) : E(Object(e)).forEach(function(o) {
+      Object.defineProperty(t, o, Object.getOwnPropertyDescriptor(e, o));
+    });
+  }
+  return t;
+}
+function h(t) {
+  "@babel/helpers - typeof";
+  return h = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(r) {
+    return typeof r;
+  } : function(r) {
+    return r && typeof Symbol == "function" && r.constructor === Symbol && r !== Symbol.prototype ? "symbol" : typeof r;
+  }, h(t);
+}
+function b(t, r, e) {
+  return r in t ? Object.defineProperty(t, r, {
+    value: e,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : t[r] = e, t;
+}
+function U(t, r) {
+  if (t == null) return {};
+  var e = {}, o = Object.keys(t), a, i;
+  for (i = 0; i < o.length; i++)
+    a = o[i], !(r.indexOf(a) >= 0) && (e[a] = t[a]);
+  return e;
+}
+function L(t, r) {
+  if (t == null) return {};
+  var e = U(t, r), o, a;
+  if (Object.getOwnPropertySymbols) {
+    var i = Object.getOwnPropertySymbols(t);
+    for (a = 0; a < i.length; a++)
+      o = i[a], !(r.indexOf(o) >= 0) && Object.prototype.propertyIsEnumerable.call(t, o) && (e[o] = t[o]);
+  }
+  return e;
+}
+function P(t) {
+  return q(t) || K(t) || M(t) || V();
+}
+function q(t) {
+  if (Array.isArray(t)) return S(t);
+}
+function K(t) {
+  if (typeof Symbol < "u" && t[Symbol.iterator] != null || t["@@iterator"] != null) return Array.from(t);
+}
+function M(t, r) {
+  if (t) {
+    if (typeof t == "string") return S(t, r);
+    var e = Object.prototype.toString.call(t).slice(8, -1);
+    if (e === "Object" && t.constructor && (e = t.constructor.name), e === "Map" || e === "Set") return Array.from(t);
+    if (e === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(e)) return S(t, r);
+  }
+}
+function S(t, r) {
+  (r == null || r > t.length) && (r = t.length);
+  for (var e = 0, o = new Array(r); e < r; e++) o[e] = t[e];
+  return o;
+}
+function V() {
+  throw new TypeError(`Invalid attempt to spread non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+}
+function $(t) {
+  var r, e = t.beat, o = t.fade, a = t.beatFade, i = t.bounce, y = t.shake, m = t.flash, s = t.spin, l = t.spinPulse, u = t.spinReverse, v = t.pulse, x = t.fixedWidth, j = t.inverse, d = t.border, w = t.listItem, c = t.flip, p = t.size, O = t.rotation, k = t.pull, N = (r = {
+    "fa-beat": e,
+    "fa-fade": o,
+    "fa-beat-fade": a,
+    "fa-bounce": i,
+    "fa-shake": y,
+    "fa-flash": m,
+    "fa-spin": s,
+    "fa-spin-reverse": u,
+    "fa-spin-pulse": l,
+    "fa-pulse": v,
+    "fa-fw": x,
+    "fa-inverse": j,
+    "fa-border": d,
+    "fa-li": w,
+    "fa-flip": c === !0,
+    "fa-flip-horizontal": c === "horizontal" || c === "both",
+    "fa-flip-vertical": c === "vertical" || c === "both"
+  }, b(r, "fa-".concat(p), typeof p < "u" && p !== null), b(r, "fa-rotate-".concat(O), typeof O < "u" && O !== null && O !== 0), b(r, "fa-pull-".concat(k), typeof k < "u" && k !== null), b(r, "fa-swap-opacity", t.swapOpacity), r);
+  return Object.keys(N).map(function(g) {
+    return N[g] ? g : null;
+  }).filter(function(g) {
+    return g;
+  });
+}
+function B(t) {
+  return t = t - 0, t === t;
+}
+function D(t) {
+  return B(t) ? t : (t = t.replace(/[\-_\s]+(.)?/g, function(r, e) {
+    return e ? e.toUpperCase() : "";
+  }), t.substr(0, 1).toLowerCase() + t.substr(1));
+}
+var G = ["style"];
+function H(t) {
+  return t.charAt(0).toUpperCase() + t.slice(1);
+}
+function J(t) {
+  return t.split(";").map(function(r) {
+    return r.trim();
+  }).filter(function(r) {
+    return r;
+  }).reduce(function(r, e) {
+    var o = e.indexOf(":"), a = D(e.slice(0, o)), i = e.slice(o + 1).trim();
+    return a.startsWith("webkit") ? r[H(a)] = i : r[a] = i, r;
+  }, {});
+}
+function R(t, r) {
+  var e = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+  if (typeof r == "string")
+    return r;
+  var o = (r.children || []).map(function(s) {
+    return R(t, s);
+  }), a = Object.keys(r.attributes || {}).reduce(function(s, l) {
+    var u = r.attributes[l];
+    switch (l) {
+      case "class":
+        s.attrs.className = u, delete r.attributes.class;
+        break;
+      case "style":
+        s.attrs.style = J(u);
+        break;
+      default:
+        l.indexOf("aria-") === 0 || l.indexOf("data-") === 0 ? s.attrs[l.toLowerCase()] = u : s.attrs[D(l)] = u;
+    }
+    return s;
+  }, {
+    attrs: {}
+  }), i = e.style, y = i === void 0 ? {} : i, m = L(e, G);
+  return a.attrs.style = f(f({}, a.attrs.style), y), t.apply(void 0, [r.tag, f(f({}, a.attrs), m)].concat(P(o)));
+}
+var F = !1;
+try {
+  F = process.env.NODE_ENV === "production";
+} catch {
+}
+function Q() {
+  if (!F && console && typeof console.error == "function") {
+    var t;
+    (t = console).error.apply(t, arguments);
+  }
+}
+function z(t) {
+  if (t && h(t) === "object" && t.prefix && t.iconName && t.icon)
+    return t;
+  if (A.icon)
+    return A.icon(t);
+  if (t === null)
+    return null;
+  if (t && h(t) === "object" && t.prefix && t.iconName)
+    return t;
+  if (Array.isArray(t) && t.length === 2)
+    return {
+      prefix: t[0],
+      iconName: t[1]
+    };
+  if (typeof t == "string")
+    return {
+      prefix: "fas",
+      iconName: t
+    };
+}
+function I(t, r) {
+  return Array.isArray(r) && r.length > 0 || !Array.isArray(r) && r ? b({}, t, r) : {};
+}
+var T = {
+  border: !1,
+  className: "",
+  mask: null,
+  maskId: null,
+  fixedWidth: !1,
+  inverse: !1,
+  flip: !1,
+  icon: null,
+  listItem: !1,
+  pull: null,
+  pulse: !1,
+  rotation: null,
+  size: null,
+  spin: !1,
+  spinPulse: !1,
+  spinReverse: !1,
+  beat: !1,
+  fade: !1,
+  beatFade: !1,
+  bounce: !1,
+  shake: !1,
+  symbol: !1,
+  title: "",
+  titleId: null,
+  transform: null,
+  swapOpacity: !1
+}, W = /* @__PURE__ */ C.forwardRef(function(t, r) {
+  var e = f(f({}, T), t), o = e.icon, a = e.mask, i = e.symbol, y = e.className, m = e.title, s = e.titleId, l = e.maskId, u = z(o), v = I("classes", [].concat(P($(e)), P((y || "").split(" ")))), x = I("transform", typeof e.transform == "string" ? A.transform(e.transform) : e.transform), j = I("mask", z(a)), d = _(u, f(f(f(f({}, v), x), j), {}, {
+    symbol: i,
+    title: m,
+    titleId: s,
+    maskId: l
+  }));
+  if (!d)
+    return Q("Could not find icon", u), null;
+  var w = d.abstract, c = {
+    ref: r
+  };
+  return Object.keys(e).forEach(function(p) {
+    T.hasOwnProperty(p) || (c[p] = e[p]);
+  }), X(w[0], c);
+});
+W.displayName = "FontAwesomeIcon";
+W.propTypes = {
+  beat: n.bool,
+  border: n.bool,
+  beatFade: n.bool,
+  bounce: n.bool,
+  className: n.string,
+  fade: n.bool,
+  flash: n.bool,
+  mask: n.oneOfType([n.object, n.array, n.string]),
+  maskId: n.string,
+  fixedWidth: n.bool,
+  inverse: n.bool,
+  flip: n.oneOf([!0, !1, "horizontal", "vertical", "both"]),
+  icon: n.oneOfType([n.object, n.array, n.string]),
+  listItem: n.bool,
+  pull: n.oneOf(["right", "left"]),
+  pulse: n.bool,
+  rotation: n.oneOf([0, 90, 180, 270]),
+  shake: n.bool,
+  size: n.oneOf(["2xs", "xs", "sm", "lg", "xl", "2xl", "1x", "2x", "3x", "4x", "5x", "6x", "7x", "8x", "9x", "10x"]),
+  spin: n.bool,
+  spinPulse: n.bool,
+  spinReverse: n.bool,
+  symbol: n.oneOfType([n.bool, n.string]),
+  title: n.string,
+  titleId: n.string,
+  transform: n.oneOfType([n.string, n.object]),
+  swapOpacity: n.bool
+};
+var X = R.bind(null, C.createElement);
+export {
+  W as FontAwesomeIcon
+};

package/dist/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 n } from "../../../../../motion-dom/dist/es/value/index.js";
+import { isMotionValue as m } from "../../value/utils/is-motion-value.js";
+import { animateMotionValue as r } from "../interfaces/motion-value.js";
+function l(t, o, i) {
+  const a = m(t) ? t : n(t);
+  return a.start(r("", a, o, i)), a.animation;
+}
+export {
+  l as animateSingleValue
+};

package/dist/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 v } from "../../../../../motion-utils/dist/es/noop.js";
+import { millisecondsToSeconds as T, secondsToMilliseconds as g } from "../../../../../motion-utils/dist/es/time-conversion.js";
+import { isGenerator as P } from "../../../../../motion-dom/dist/es/animation/generators/utils/is-generator.js";
+import { attachTimeline as k } from "../../../../../motion-dom/dist/es/animation/waapi/utils/attach-timeline.js";
+import { isWaapiSupportedEasing as A } from "../../../../../motion-dom/dist/es/animation/waapi/utils/easing.js";
+import { supportsLinearEasing as V } from "../../../../../motion-dom/dist/es/utils/supports/linear-easing.js";
+import { anticipate as O } from "../../easing/anticipate.js";
+import { backInOut as b } from "../../easing/back.js";
+import { circInOut as F } from "../../easing/circ.js";
+import { DOMKeyframesResolver as I } from "../../render/dom/DOMKeyframesResolver.js";
+import { BaseAnimation as R } from "./BaseAnimation.js";
+import { MainThreadAnimation as S } from "./MainThreadAnimation.js";
+import { acceleratedValues as G } from "./utils/accelerated-values.js";
+import { startWaapiAnimation as M } from "./waapi/index.js";
+import { getFinalKeyframe as W } from "./waapi/utils/get-final-keyframe.js";
+import { supportsWaapi as C } from "./waapi/utils/supports-waapi.js";
+const f = 10, E = 2e4;
+function K(r) {
+  return P(r.type) || r.type === "spring" || !A(r.ease);
+}
+function U(r, e) {
+  const t = new S({
+    ...e,
+    keyframes: r,
+    repeat: 0,
+    delay: 0,
+    isGenerator: !0
+  });
+  let i = { done: !1, value: r[0] };
+  const n = [];
+  let s = 0;
+  for (; !i.done && s < E; )
+    i = t.sample(s), n.push(i.value), s += f;
+  return {
+    times: void 0,
+    keyframes: n,
+    duration: s - f,
+    ease: "linear"
+  };
+}
+const $ = {
+  anticipate: O,
+  backInOut: b,
+  circInOut: F
+};
+function x(r) {
+  return r in $;
+}
+class se extends R {
+  constructor(e) {
+    super(e);
+    const { name: t, motionValue: i, element: n, keyframes: s } = this.options;
+    this.resolver = new I(s, (a, o) => this.onKeyframesResolved(a, o), t, i, n), this.resolver.scheduleResolve();
+  }
+  initPlayback(e, t) {
+    let { duration: i = 300, times: n, ease: s, type: a, motionValue: o, name: m, startTime: p } = this.options;
+    if (!o.owner || !o.owner.current)
+      return !1;
+    if (typeof s == "string" && V() && x(s) && (s = $[s]), K(this.options)) {
+      const { onComplete: c, onUpdate: w, motionValue: y, element: h, ...u } = this.options, d = U(e, u);
+      e = d.keyframes, e.length === 1 && (e[1] = e[0]), i = d.duration, n = d.times, s = d.ease, a = "keyframes";
+    }
+    const l = M(o.owner.current, m, e, { ...this.options, duration: i, times: n, ease: s });
+    return l.startTime = p ?? this.calcStartTime(), this.pendingTimeline ? (k(l, this.pendingTimeline), this.pendingTimeline = void 0) : l.onfinish = () => {
+      const { onComplete: c } = this.options;
+      o.set(W(e, this.options, t)), c && c(), this.cancel(), this.resolveFinishedPromise();
+    }, {
+      animation: l,
+      duration: i,
+      times: n,
+      type: a,
+      ease: s,
+      keyframes: e
+    };
+  }
+  get duration() {
+    const { resolved: e } = this;
+    if (!e)
+      return 0;
+    const { duration: t } = e;
+    return T(t);
+  }
+  get time() {
+    const { resolved: e } = this;
+    if (!e)
+      return 0;
+    const { animation: t } = e;
+    return T(t.currentTime || 0);
+  }
+  set time(e) {
+    const { resolved: t } = this;
+    if (!t)
+      return;
+    const { animation: i } = t;
+    i.currentTime = g(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 v;
+      const { animation: i } = t;
+      k(i, e);
+    }
+    return v;
+  }
+  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: n, type: s, ease: a, times: o } = e;
+    if (t.playState === "idle" || t.playState === "finished")
+      return;
+    if (this.time) {
+      const { motionValue: p, onUpdate: l, onComplete: c, element: w, ...y } = this.options, h = new S({
+        ...y,
+        keyframes: i,
+        duration: n,
+        type: s,
+        ease: a,
+        times: o,
+        isGenerator: !0
+      }), u = g(this.time);
+      p.setWithVelocity(h.sample(u - f).value, h.sample(u).value, f);
+    }
+    const { onStop: m } = this.options;
+    m && m(), 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: n, repeatType: s, damping: a, type: o } = e;
+    if (!t || !t.owner || !(t.owner.current instanceof HTMLElement))
+      return !1;
+    const { onUpdate: m, transformTemplate: p } = t.owner.getProps();
+    return C() && i && G.has(i) && (i !== "transform" || !p) && /**
+    * 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.
+    */
+    !m && !n && s !== "mirror" && a !== 0 && o !== "inertia";
+  }
+}
+export {
+  se as AcceleratedAnimation
+};

package/dist/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 l } from "../../../../../motion-dom/dist/es/frameloop/sync-time.js";
+import { flushKeyframeResolvers as d } from "../../render/utils/KeyframesResolver.js";
+import { canAnimate as m } from "./utils/can-animate.js";
+import { getFinalKeyframe as y } from "./waapi/utils/get-final-keyframe.js";
+const f = 40;
+class R {
+  constructor({ autoplay: e = !0, delay: t = 0, type: i = "keyframes", repeat: o = 0, repeatDelay: r = 0, repeatType: a = "loop", ...s }) {
+    this.isStopped = !1, this.hasAttemptedResolve = !1, this.createdAt = l.now(), this.options = {
+      autoplay: e,
+      delay: t,
+      type: i,
+      repeat: o,
+      repeatDelay: r,
+      repeatType: a,
+      ...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 > f ? 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 && d(), 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 = l.now(), this.hasAttemptedResolve = !0;
+    const { name: i, type: o, velocity: r, delay: a, onComplete: s, onUpdate: n, isGenerator: p } = this.options;
+    if (!p && !m(e, i, o, r))
+      if (a)
+        this.options.duration = 0;
+      else {
+        n && n(y(e, this.options, t)), s && s(), this.resolveFinishedPromise();
+        return;
+      }
+    const h = this.initPlayback(e, t);
+    h !== !1 && (this._resolved = {
+      keyframes: e,
+      finalKeyframe: t,
+      ...h
+    }, 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 {
+  R as BaseAnimation
+};