@code0-tech/pictor 0.9.2 → 0.10.0

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

@@ -0,0 +1,30 @@
+import { interpolate as c } from "../../utils/interpolate.js";
+import { defaultOffset as p } from "../keyframes/offsets/default.js";
+import { convertOffsetToTimes as u } from "../keyframes/offsets/time.js";
+import { isEasingArray as l } from "../../../../../motion-utils/dist/es/easing/utils/is-easing-array.js";
+import { easingDefinitionToFunction as m } from "../../../../../motion-utils/dist/es/easing/utils/map.js";
+import { easeInOut as g } from "../../../../../motion-utils/dist/es/easing/ease.js";
+function T(n, t) {
+  return n.map(() => t || g).splice(0, n.length - 1);
+}
+function y({ duration: n = 300, keyframes: t, times: o, ease: r = "easeInOut" }) {
+  const e = l(r) ? r.map(m) : m(r), i = {
+    done: !1,
+    value: t[0]
+  }, s = u(
+    // 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 : p(t),
+    n
+  ), a = c(s, t, {
+    ease: Array.isArray(e) ? e : T(t, e)
+  });
+  return {
+    calculatedDuration: n,
+    next: (f) => (i.value = a(f), i.done = f >= n, i)
+  };
+}
+export {
+  T as defaultEasing,
+  y as keyframes
+};

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

@@ -0,0 +1,178 @@
+import { generateLinearEasing as L } from "../waapi/utils/linear.js";
+import { calcGeneratorDuration as z, maxGeneratorDuration as B } from "./utils/calc-duration.js";
+import { createGeneratorEasing as H } from "./utils/create-generator-easing.js";
+import { millisecondsToSeconds as K, secondsToMilliseconds as q } from "../../../../../motion-utils/dist/es/time-conversion.js";
+import { clamp as N } from "../../../../../motion-utils/dist/es/clamp.js";
+import { warning as J } from "../../../../../motion-utils/dist/es/errors.js";
+const n = {
+  // 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
+};
+function O(e, s) {
+  return e * Math.sqrt(1 - s * s);
+}
+const Q = 12;
+function U(e, s, a) {
+  let l = a;
+  for (let f = 1; f < Q; f++)
+    l = l - e(l) / s(l);
+  return l;
+}
+const I = 1e-3;
+function W({ duration: e = n.duration, bounce: s = n.bounce, velocity: a = n.velocity, mass: l = n.mass }) {
+  let f, v;
+  J(e <= q(n.maxDuration), "Spring duration must be 10 seconds or less", "spring-duration-limit");
+  let r = 1 - s;
+  r = N(n.minDamping, n.maxDamping, r), e = N(n.minDuration, n.maxDuration, K(e)), r < 1 ? (f = (c) => {
+    const g = c * r, h = g * e, k = g - a, x = O(c, r), M = Math.exp(-h);
+    return I - k / x * M;
+  }, v = (c) => {
+    const h = c * r * e, k = h * a + a, x = Math.pow(r, 2) * Math.pow(c, 2) * e, M = Math.exp(-h), o = O(Math.pow(c, 2), r);
+    return (-f(c) + I > 0 ? -1 : 1) * ((k - x) * M) / o;
+  }) : (f = (c) => {
+    const g = Math.exp(-c * e), h = (c - a) * e + 1;
+    return -I + g * h;
+  }, v = (c) => {
+    const g = Math.exp(-c * e), h = (a - c) * (e * e);
+    return g * h;
+  });
+  const p = 5 / e, T = U(f, v, p);
+  if (e = q(e), isNaN(T))
+    return {
+      stiffness: n.stiffness,
+      damping: n.damping,
+      duration: e
+    };
+  {
+    const c = Math.pow(T, 2) * l;
+    return {
+      stiffness: c,
+      damping: r * 2 * Math.sqrt(l * c),
+      duration: e
+    };
+  }
+}
+const X = ["duration", "bounce"], Y = ["stiffness", "damping", "mass"];
+function V(e, s) {
+  return s.some((a) => e[a] !== void 0);
+}
+function Z(e) {
+  let s = {
+    velocity: n.velocity,
+    stiffness: n.stiffness,
+    damping: n.damping,
+    mass: n.mass,
+    isResolvedFromDuration: !1,
+    ...e
+  };
+  if (!V(e, Y) && V(e, X))
+    if (s.velocity = 0, e.visualDuration) {
+      const a = e.visualDuration, l = 2 * Math.PI / (a * 1.2), f = l * l, v = 2 * N(0.05, 1, 1 - (e.bounce || 0)) * Math.sqrt(f);
+      s = {
+        ...s,
+        mass: n.mass,
+        stiffness: f,
+        damping: v
+      };
+    } else {
+      const a = W({ ...e, velocity: 0 });
+      s = {
+        ...s,
+        ...a,
+        mass: n.mass
+      }, s.isResolvedFromDuration = !0;
+    }
+  return s;
+}
+function j(e = n.visualDuration, s = n.bounce) {
+  const a = typeof e != "object" ? {
+    visualDuration: e,
+    keyframes: [0, 1],
+    bounce: s
+  } : e;
+  let { restSpeed: l, restDelta: f } = a;
+  const v = a.keyframes[0], r = a.keyframes[a.keyframes.length - 1], p = { done: !1, value: v }, { stiffness: T, damping: c, mass: g, duration: h, velocity: k, isResolvedFromDuration: x } = Z({
+    ...a,
+    velocity: -K(a.velocity || 0)
+  }), M = k || 0, o = c / (2 * Math.sqrt(T * g)), m = r - v, i = K(Math.sqrt(T / g)), P = Math.abs(m) < 5;
+  l || (l = P ? n.restSpeed.granular : n.restSpeed.default), f || (f = P ? n.restDelta.granular : n.restDelta.default);
+  let G, w, d, C, A, F;
+  if (o < 1)
+    d = O(i, o), C = (M + o * i * m) / d, G = (t) => {
+      const u = Math.exp(-o * i * t);
+      return r - u * (C * Math.sin(d * t) + m * Math.cos(d * t));
+    }, A = o * i * C + m * d, F = o * i * m - C * d, w = (t) => Math.exp(-o * i * t) * (A * Math.sin(d * t) + F * Math.cos(d * t));
+  else if (o === 1) {
+    G = (u) => r - Math.exp(-i * u) * (m + (M + i * m) * u);
+    const t = M + i * m;
+    w = (u) => Math.exp(-i * u) * (i * t * u - M);
+  } else {
+    const t = i * Math.sqrt(o * o - 1);
+    G = (y) => {
+      const S = Math.exp(-o * i * y), b = Math.min(t * y, 300);
+      return r - S * ((M + o * i * m) * Math.sinh(b) + t * m * Math.cosh(b)) / t;
+    };
+    const u = (M + o * i * m) / t, D = o * i * u - m * t, R = o * i * m - u * t;
+    w = (y) => {
+      const S = Math.exp(-o * i * y), b = Math.min(t * y, 300);
+      return S * (D * Math.sinh(b) + R * Math.cosh(b));
+    };
+  }
+  const E = {
+    calculatedDuration: x && h || null,
+    velocity: (t) => q(w(t)),
+    next: (t) => {
+      if (!x && o < 1) {
+        const D = Math.exp(-o * i * t), R = Math.sin(d * t), y = Math.cos(d * t), S = r - D * (C * R + m * y), b = q(D * (A * R + F * y));
+        return p.done = Math.abs(b) <= l && Math.abs(r - S) <= f, p.value = p.done ? r : S, p;
+      }
+      const u = G(t);
+      if (x)
+        p.done = t >= h;
+      else {
+        const D = q(w(t));
+        p.done = Math.abs(D) <= l && Math.abs(r - u) <= f;
+      }
+      return p.value = p.done ? r : u, p;
+    },
+    toString: () => {
+      const t = Math.min(z(E), B), u = L((D) => E.next(t * D).value, t, 30);
+      return t + "ms " + u;
+    },
+    toTransition: () => {
+    }
+  };
+  return E;
+}
+j.applyToOptions = (e) => {
+  const s = H(e, 100, j);
+  return e.ease = s.ease, e.duration = q(s.duration), e.type = "keyframes", e;
+};
+export {
+  j as spring
+};

package/dist/node_modules/motion-dom/dist/es/animation/generators/utils/calc-duration.js

@@ -0,0 +1,13 @@
+const a = 2e4;
+function o(n) {
+  let t = 0;
+  const r = 50;
+  let e = n.next(t);
+  for (; !e.done && t < 2e4; )
+    t += r, e = n.next(t);
+  return t >= 2e4 ? 1 / 0 : t;
+}
+export {
+  o as calcGeneratorDuration,
+  a as maxGeneratorDuration
+};

package/dist/node_modules/motion-dom/dist/es/animation/generators/utils/create-generator-easing.js

@@ -0,0 +1,13 @@
+import { calcGeneratorDuration as i, maxGeneratorDuration as m } from "./calc-duration.js";
+import { millisecondsToSeconds as s } from "../../../../../../motion-utils/dist/es/time-conversion.js";
+function f(n, r = 100, o) {
+  const e = o({ ...n, keyframes: [0, r] }), t = Math.min(i(e), m);
+  return {
+    type: "keyframes",
+    ease: (a) => e.next(t * a).value / r,
+    duration: s(t)
+  };
+}
+export {
+  f as createGeneratorEasing
+};

package/dist/node_modules/motion-dom/dist/es/animation/generators/utils/is-generator.js

@@ -0,0 +1,6 @@
+function o(n) {
+  return typeof n == "function" && "applyToOptions" in n;
+}
+export {
+  o as isGenerator
+};

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

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

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

@@ -0,0 +1,46 @@
+import { AsyncMotionValueAnimation as A } from "../AsyncMotionValueAnimation.js";
+import { JSAnimation as k } from "../JSAnimation.js";
+import { getValueTransition as D } from "../utils/get-value-transition.js";
+import { makeAnimationInstant as d } from "../utils/make-animation-instant.js";
+import { getDefaultTransition as g } from "../utils/default-transitions.js";
+import { getFinalKeyframe as C } from "../keyframes/get-final.js";
+import { isTransitionDefined as T } from "../utils/is-transition-defined.js";
+import { frame as V } from "../../frameloop/frame.js";
+import { secondsToMilliseconds as s } from "../../../../../motion-utils/dist/es/time-conversion.js";
+import { MotionGlobalConfig as y } from "../../../../../motion-utils/dist/es/global-config.js";
+const x = (n, i, a, r = {}, f, p) => (u) => {
+  const o = D(r, n) || {}, c = o.delay || r.delay || 0;
+  let { elapsed: m = 0 } = r;
+  m = m - s(c);
+  const e = {
+    keyframes: Array.isArray(a) ? a : [null, a],
+    ease: "easeOut",
+    velocity: i.getVelocity(),
+    ...o,
+    delay: -m,
+    onUpdate: (t) => {
+      i.set(t), o.onUpdate && o.onUpdate(t);
+    },
+    onComplete: () => {
+      u(), o.onComplete && o.onComplete();
+    },
+    name: n,
+    motionValue: i,
+    element: p ? void 0 : f
+  };
+  T(o) || Object.assign(e, g(n, e)), e.duration && (e.duration = s(e.duration)), e.repeatDelay && (e.repeatDelay = s(e.repeatDelay)), e.from !== void 0 && (e.keyframes[0] = e.from);
+  let l = !1;
+  if ((e.type === !1 || e.duration === 0 && !e.repeatDelay) && (d(e), e.delay === 0 && (l = !0)), (y.instantAnimations || y.skipAnimations || f?.shouldSkipAnimations || o.skipAnimations) && (l = !0, d(e), e.delay = 0), e.allowFlatten = !o.type && !o.ease, l && !p && i.get() !== void 0) {
+    const t = C(e.keyframes, o);
+    if (t !== void 0) {
+      V.update(() => {
+        e.onUpdate(t), e.onComplete();
+      });
+      return;
+    }
+  }
+  return o.isSync ? new k(e) : new A(e);
+};
+export {
+  x as animateMotionValue
+};

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

@@ -0,0 +1,59 @@
+import { getValueTransition as H } from "../utils/get-value-transition.js";
+import { resolveTransition as B } from "../utils/resolve-transition.js";
+import { positionalKeys as I } from "../../render/utils/keys-position.js";
+import { setTarget as P } from "../../render/utils/setters.js";
+import { addValueToWillChange as R } from "../../value/will-change/add-will-change.js";
+import { getOptimisedAppearId as x } from "../optimized-appear/get-appear-id.js";
+import { animateMotionValue as C } from "./motion-value.js";
+import { frame as u } from "../../frameloop/frame.js";
+function D({ protectedKeys: t, needsAnimating: s }, i) {
+  const f = t.hasOwnProperty(i) && s[i] !== !0;
+  return s[i] = !1, f;
+}
+function G(t, s, { delay: i = 0, transitionOverride: f, type: d } = {}) {
+  let { transition: n, transitionEnd: m, ...p } = s;
+  const l = t.getDefaultTransition();
+  n = n ? B(n, l) : l;
+  const y = n?.reduceMotion, k = n?.skipAnimations;
+  f && (n = f);
+  const e = [], T = d && t.animationState && t.animationState.getState()[d], g = n?.path;
+  g && g.animateVisualElement(t, p, n, i, e);
+  for (const o in p) {
+    const a = t.getValue(o, t.latestValues[o] ?? null), r = p[o];
+    if (r === void 0 || T && D(T, o))
+      continue;
+    const c = {
+      delay: i,
+      ...H(n || {}, o)
+    };
+    k && (c.skipAnimations = !0);
+    const h = a.get();
+    if (h !== void 0 && !a.isAnimating() && !Array.isArray(r) && r === h && !c.velocity) {
+      u.update(() => a.set(r));
+      continue;
+    }
+    let A = !1;
+    if (window.MotionHandoffAnimation) {
+      const V = x(t);
+      if (V) {
+        const w = window.MotionHandoffAnimation(V, o, u);
+        w !== null && (c.startTime = w, A = !0);
+      }
+    }
+    R(t, o);
+    const S = y ?? t.shouldReduceMotion;
+    a.start(C(o, a, r, S && I.has(o) ? { type: !1 } : c, t, A));
+    const M = a.animation;
+    M && e.push(M);
+  }
+  if (m) {
+    const o = () => u.update(() => {
+      m && P(t, m);
+    });
+    e.length ? Promise.all(e).then(o) : o();
+  }
+  return e;
+}
+export {
+  G as animateTarget
+};

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

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

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

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

package/dist/node_modules/motion-dom/dist/es/animation/keyframes/DOMKeyframesResolver.js

@@ -0,0 +1,68 @@
+import { positionalKeys as c } from "../../render/utils/keys-position.js";
+import { findDimensionValueType as d } from "../../value/types/dimensions.js";
+import { getVariableValue as g } from "../utils/css-variables-conversion.js";
+import { isCSSVariableToken as K, containsCSSVariable as h } from "../utils/is-css-variable.js";
+import { KeyframeResolver as v } from "./KeyframesResolver.js";
+import { isNone as V } from "./utils/is-none.js";
+import { makeNoneKeyframesAnimatable as S } from "./utils/make-none-animatable.js";
+import { positionalValues as m, isNumOrPxType as p } from "./utils/unit-conversion.js";
+class M extends v {
+  constructor(e, n, r, t, o) {
+    super(e, n, r, t, o, !0);
+  }
+  readKeyframes() {
+    const { unresolvedKeyframes: e, element: n, name: r } = this;
+    if (!n || !n.current)
+      return;
+    super.readKeyframes();
+    for (let s = 0; s < e.length; s++) {
+      let i = e[s];
+      if (typeof i == "string" && (i = i.trim(), K(i))) {
+        const u = g(i, n.current);
+        u !== void 0 && (e[s] = u), s === e.length - 1 && (this.finalKeyframe = i);
+      }
+    }
+    if (this.resolveNoneKeyframes(), !c.has(r) || e.length !== 2)
+      return;
+    const [t, o] = e, a = d(t), f = d(o), l = h(t), y = h(o);
+    if (l !== y && m[r]) {
+      this.needsMeasurement = !0;
+      return;
+    }
+    if (a !== f)
+      if (p(a) && p(f))
+        for (let s = 0; s < e.length; s++) {
+          const i = e[s];
+          typeof i == "string" && (e[s] = parseFloat(i));
+        }
+      else m[r] && (this.needsMeasurement = !0);
+  }
+  resolveNoneKeyframes() {
+    const { unresolvedKeyframes: e, name: n } = this, r = [];
+    for (let t = 0; t < e.length; t++)
+      (e[t] === null || V(e[t])) && r.push(t);
+    r.length && S(e, r, n);
+  }
+  measureInitialState() {
+    const { element: e, unresolvedKeyframes: n, name: r } = this;
+    if (!e || !e.current)
+      return;
+    r === "height" && (this.suspendedScrollY = window.pageYOffset), this.measuredOrigin = m[r](e.measureViewportBox(), window.getComputedStyle(e.current)), n[0] = this.measuredOrigin;
+    const t = n[n.length - 1];
+    t !== void 0 && e.getValue(r, t).jump(t, !1);
+  }
+  measureEndState() {
+    const { element: e, name: n, unresolvedKeyframes: r } = this;
+    if (!e || !e.current)
+      return;
+    const t = e.getValue(n);
+    t && t.jump(this.measuredOrigin, !1);
+    const o = r.length - 1, a = r[o];
+    r[o] = m[n](e.measureViewportBox(), window.getComputedStyle(e.current)), a !== null && this.finalKeyframe === void 0 && (this.finalKeyframe = a), this.removedTransforms?.length && this.removedTransforms.forEach(([f, l]) => {
+      e.getValue(f).set(l);
+    }), this.resolveNoneKeyframes();
+  }
+}
+export {
+  M as DOMKeyframesResolver
+};

package/dist/node_modules/motion-dom/dist/es/animation/keyframes/KeyframesResolver.js

@@ -0,0 +1,74 @@
+import { fillWildcards as y } from "./utils/fill-wildcards.js";
+import { removeNonTranslationalTransform as p } from "./utils/unit-conversion.js";
+import { frame as c } from "../../frameloop/frame.js";
+const l = /* @__PURE__ */ new Set();
+let f = !1, d = !1, m = !1;
+function u() {
+  if (d) {
+    const a = Array.from(l).filter((e) => e.needsMeasurement), s = new Set(a.map((e) => e.element)), r = /* @__PURE__ */ new Map();
+    s.forEach((e) => {
+      const t = p(e);
+      t.length && (r.set(e, t), e.render());
+    }), a.forEach((e) => e.measureInitialState()), s.forEach((e) => {
+      e.render();
+      const t = r.get(e);
+      t && t.forEach(([n, i]) => {
+        e.getValue(n)?.set(i);
+      });
+    }), a.forEach((e) => e.measureEndState()), a.forEach((e) => {
+      e.suspendedScrollY !== void 0 && window.scrollTo(0, e.suspendedScrollY);
+    });
+  }
+  d = !1, f = !1, l.forEach((a) => a.complete(m)), l.clear();
+}
+function h() {
+  l.forEach((a) => {
+    a.readKeyframes(), a.needsMeasurement && (d = !0);
+  });
+}
+function S() {
+  m = !0, h(), u(), m = !1;
+}
+class g {
+  constructor(s, r, e, t, n, i = !1) {
+    this.state = "pending", this.isAsync = !1, this.needsMeasurement = !1, this.unresolvedKeyframes = [...s], this.onComplete = r, this.name = e, this.motionValue = t, this.element = n, this.isAsync = i;
+  }
+  scheduleResolve() {
+    this.state = "scheduled", this.isAsync ? (l.add(this), f || (f = !0, c.read(h), c.resolveKeyframes(u))) : (this.readKeyframes(), this.complete());
+  }
+  readKeyframes() {
+    const { unresolvedKeyframes: s, name: r, element: e, motionValue: t } = this;
+    if (s[0] === null) {
+      const n = t?.get(), i = s[s.length - 1];
+      if (n !== void 0)
+        s[0] = n;
+      else if (e && r) {
+        const o = e.readValue(r, i);
+        o != null && (s[0] = o);
+      }
+      s[0] === void 0 && (s[0] = i), t && n === void 0 && t.set(s[0]);
+    }
+    y(s);
+  }
+  setFinalKeyframe() {
+  }
+  measureInitialState() {
+  }
+  renderEndStyles() {
+  }
+  measureEndState() {
+  }
+  complete(s = !1) {
+    this.state = "complete", this.onComplete(this.unresolvedKeyframes, this.finalKeyframe, s), l.delete(this);
+  }
+  cancel() {
+    this.state === "scheduled" && (l.delete(this), this.state = "pending");
+  }
+  resume() {
+    this.state === "pending" && this.scheduleResolve();
+  }
+}
+export {
+  g as KeyframeResolver,
+  S as flushKeyframeResolvers
+};

package/dist/node_modules/motion-dom/dist/es/animation/keyframes/get-final.js

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

package/dist/node_modules/motion-dom/dist/es/animation/keyframes/offsets/default.js

@@ -0,0 +1,8 @@
+import { fillOffset as e } from "./fill.js";
+function n(t) {
+  const f = [0];
+  return e(f, t.length - 1), f;
+}
+export {
+  n as defaultOffset
+};

package/dist/node_modules/motion-dom/dist/es/animation/keyframes/offsets/fill.js

@@ -0,0 +1,12 @@
+import { mixNumber as e } from "../../../utils/mix/number.js";
+import { progress as f } from "../../../../../../motion-utils/dist/es/progress.js";
+function l(o, t) {
+  const s = o[o.length - 1];
+  for (let r = 1; r <= t; r++) {
+    const m = f(0, t, r);
+    o.push(e(s, 1, m));
+  }
+}
+export {
+  l as fillOffset
+};

package/dist/node_modules/motion-dom/dist/es/animation/keyframes/offsets/time.js

@@ -0,0 +1,6 @@
+function o(e, t) {
+  return e.map((n) => n * t);
+}
+export {
+  o as convertOffsetToTimes
+};

package/dist/node_modules/motion-dom/dist/es/animation/keyframes/utils/fill-wildcards.js

@@ -0,0 +1,7 @@
+function t(i) {
+  for (let l = 1; l < i.length; l++)
+    i[l] ?? (i[l] = i[l - 1]);
+}
+export {
+  t as fillWildcards
+};

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

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

package/dist/node_modules/motion-dom/dist/es/animation/keyframes/utils/make-none-animatable.js

@@ -0,0 +1,16 @@
+import { analyseComplexValue as l } from "../../../value/types/complex/index.js";
+import { getAnimatableNone as m } from "../../../value/types/utils/animatable-none.js";
+const f = /* @__PURE__ */ new Set(["auto", "none", "0"]);
+function g(e, i, o) {
+  let n = 0, a;
+  for (; n < e.length && !a; ) {
+    const t = e[n];
+    typeof t == "string" && !f.has(t) && l(t).values.length && (a = e[n]), n++;
+  }
+  if (a && o)
+    for (const t of i)
+      e[t] = m(o, a);
+}
+export {
+  g as makeNoneKeyframesAnimatable
+};

package/dist/node_modules/motion-dom/dist/es/animation/keyframes/utils/unit-conversion.js

@@ -0,0 +1,37 @@
+import { parseValueFromTransform as n } from "../../../render/dom/parse-transform.js";
+import { transformPropOrder as m } from "../../../render/utils/keys-transform.js";
+import { number as i } from "../../../value/types/numbers/index.js";
+import { px as l } from "../../../value/types/numbers/units.js";
+const h = (r) => r === i || r === l, p = /* @__PURE__ */ new Set(["x", "y", "z"]), f = m.filter((r) => !p.has(r));
+function F(r) {
+  const o = [];
+  return f.forEach((t) => {
+    const a = r.getValue(t);
+    a !== void 0 && (o.push([t, a.get()]), a.set(t.startsWith("scale") ? 1 : 0));
+  }), o;
+}
+const s = {
+  // Dimensions
+  width: ({ x: r }, { paddingLeft: o = "0", paddingRight: t = "0", boxSizing: a }) => {
+    const e = r.max - r.min;
+    return a === "border-box" ? e : e - parseFloat(o) - parseFloat(t);
+  },
+  height: ({ y: r }, { paddingTop: o = "0", paddingBottom: t = "0", boxSizing: a }) => {
+    const e = r.max - r.min;
+    return a === "border-box" ? e : e - parseFloat(o) - parseFloat(t);
+  },
+  top: (r, { top: o }) => parseFloat(o),
+  left: (r, { left: o }) => parseFloat(o),
+  bottom: ({ y: r }, { top: o }) => parseFloat(o) + (r.max - r.min),
+  right: ({ x: r }, { left: o }) => parseFloat(o) + (r.max - r.min),
+  // Transform
+  x: (r, { transform: o }) => n(o, "x"),
+  y: (r, { transform: o }) => n(o, "y")
+};
+s.translateX = s.x;
+s.translateY = s.y;
+export {
+  h as isNumOrPxType,
+  s as positionalValues,
+  F as removeNonTranslationalTransform
+};