@pibit.ai/cure-design-system 0.3.8 → 0.3.10

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

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

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

@@ -0,0 +1,30 @@
+import { resolveVariant as l } from "../../render/utils/resolve-dynamic-variants.js";
+import { calcChildStagger as g } from "../utils/calc-child-stagger.js";
+import { animateTarget as C } from "./visual-element-target.js";
+function y(r, i, t = {}) {
+  var n;
+  const e = l(r, i, t.type === "exit" ? (n = r.presenceContext) == null ? void 0 : n.custom : void 0);
+  let { transition: o = r.getDefaultTransition() || {} } = e || {};
+  t.transitionOverride && (o = t.transitionOverride);
+  const a = e ? () => Promise.all(C(r, e, t)) : () => Promise.resolve(), s = r.variantChildren && r.variantChildren.size ? (f = 0) => {
+    const { delayChildren: d = 0, staggerChildren: m, staggerDirection: h } = o;
+    return P(r, i, f, d, m, h, t);
+  } : () => Promise.resolve(), { when: c } = o;
+  if (c) {
+    const [f, d] = c === "beforeChildren" ? [a, s] : [s, a];
+    return f().then(() => d());
+  } else
+    return Promise.all([a(), s(t.delay)]);
+}
+function P(r, i, t = 0, e = 0, o = 0, a = 1, s) {
+  const c = [];
+  for (const n of r.variantChildren)
+    n.notify("AnimationStart", i), c.push(y(n, i, {
+      ...s,
+      delay: t + (typeof e == "function" ? 0 : e) + g(r.variantChildren, n, e, o, a)
+    }).then(() => n.notify("AnimationComplete", i)));
+  return Promise.all(c);
+}
+export {
+  y 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,69 @@
+import { positionalKeys as c } from "../../render/utils/keys-position.js";
+import { findDimensionValueType as h } from "../../value/types/dimensions.js";
+import { getVariableValue as g } from "../utils/css-variables-conversion.js";
+import { isCSSVariableToken as K, containsCSSVariable as p } 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 y } 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 d = g(i, n.current);
+        d !== void 0 && (e[s] = d), s === e.length - 1 && (this.finalKeyframe = i);
+      }
+    }
+    if (this.resolveNoneKeyframes(), !c.has(r) || e.length !== 2)
+      return;
+    const [t, o] = e, a = h(t), f = h(o), l = p(t), u = p(o);
+    if (l !== u && m[r]) {
+      this.needsMeasurement = !0;
+      return;
+    }
+    if (a !== f)
+      if (y(a) && y(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() {
+    var f;
+    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), (f = this.removedTransforms) != null && f.length && this.removedTransforms.forEach(([l, u]) => {
+      e.getValue(l).set(u);
+    }), this.resolveNoneKeyframes();
+  }
+}
+export {
+  M as DOMKeyframesResolver
+};

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

@@ -0,0 +1,75 @@
+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 o = !1, d = !1, m = !1;
+function u() {
+  if (d) {
+    const r = Array.from(l).filter((e) => e.needsMeasurement), s = new Set(r.map((e) => e.element)), a = /* @__PURE__ */ new Map();
+    s.forEach((e) => {
+      const t = p(e);
+      t.length && (a.set(e, t), e.render());
+    }), r.forEach((e) => e.measureInitialState()), s.forEach((e) => {
+      e.render();
+      const t = a.get(e);
+      t && t.forEach(([n, i]) => {
+        var f;
+        (f = e.getValue(n)) == null || f.set(i);
+      });
+    }), r.forEach((e) => e.measureEndState()), r.forEach((e) => {
+      e.suspendedScrollY !== void 0 && window.scrollTo(0, e.suspendedScrollY);
+    });
+  }
+  d = !1, o = !1, l.forEach((r) => r.complete(m)), l.clear();
+}
+function h() {
+  l.forEach((r) => {
+    r.readKeyframes(), r.needsMeasurement && (d = !0);
+  });
+}
+function S() {
+  m = !0, h(), u(), m = !1;
+}
+class g {
+  constructor(s, a, e, t, n, i = !1) {
+    this.state = "pending", this.isAsync = !1, this.needsMeasurement = !1, this.unresolvedKeyframes = [...s], this.onComplete = a, this.name = e, this.motionValue = t, this.element = n, this.isAsync = i;
+  }
+  scheduleResolve() {
+    this.state = "scheduled", this.isAsync ? (l.add(this), o || (o = !0, c.read(h), c.resolveKeyframes(u))) : (this.readKeyframes(), this.complete());
+  }
+  readKeyframes() {
+    const { unresolvedKeyframes: s, name: a, element: e, motionValue: t } = this;
+    if (s[0] === null) {
+      const n = t == null ? void 0 : t.get(), i = s[s.length - 1];
+      if (n !== void 0)
+        s[0] = n;
+      else if (e && a) {
+        const f = e.readValue(a, i);
+        f != null && (s[0] = f);
+      }
+      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,31 @@
+import { parseValueFromTransform as e } from "../../../render/dom/parse-transform.js";
+import { transformPropOrder as n } from "../../../render/utils/keys-transform.js";
+import { number as m } from "../../../value/types/numbers/index.js";
+import { px as l } from "../../../value/types/numbers/units.js";
+const c = (o) => o === m || o === l, i = /* @__PURE__ */ new Set(["x", "y", "z"]), p = n.filter((o) => !i.has(o));
+function F(o) {
+  const r = [];
+  return p.forEach((a) => {
+    const s = o.getValue(a);
+    s !== void 0 && (r.push([a, s.get()]), s.set(a.startsWith("scale") ? 1 : 0));
+  }), r;
+}
+const t = {
+  // Dimensions
+  width: ({ x: o }, { paddingLeft: r = "0", paddingRight: a = "0" }) => o.max - o.min - parseFloat(r) - parseFloat(a),
+  height: ({ y: o }, { paddingTop: r = "0", paddingBottom: a = "0" }) => o.max - o.min - parseFloat(r) - parseFloat(a),
+  top: (o, { top: r }) => parseFloat(r),
+  left: (o, { left: r }) => parseFloat(r),
+  bottom: ({ y: o }, { top: r }) => parseFloat(r) + (o.max - o.min),
+  right: ({ x: o }, { left: r }) => parseFloat(r) + (o.max - o.min),
+  // Transform
+  x: (o, { transform: r }) => e(r, "x"),
+  y: (o, { transform: r }) => e(r, "y")
+};
+t.translateX = t.x;
+t.translateY = t.y;
+export {
+  c as isNumOrPxType,
+  t as positionalValues,
+  F as removeNonTranslationalTransform
+};

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

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

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

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

@@ -0,0 +1,27 @@
+class t {
+  constructor() {
+    this.updateFinished();
+  }
+  get finished() {
+    return this._finished;
+  }
+  updateFinished() {
+    this._finished = new Promise((i) => {
+      this.resolve = i;
+    });
+  }
+  notifyFinished() {
+    this.resolve();
+  }
+  /**
+   * Allows the animation to be awaited.
+   *
+   * @deprecated Use `finished` instead.
+   */
+  then(i, e) {
+    return this.finished.then(i, e);
+  }
+}
+export {
+  t as WithPromise
+};

package/dist/node_modules/motion-dom/dist/es/animation/utils/calc-child-stagger.js

@@ -0,0 +1,7 @@
+function x(t, s, c, o = 0, u = 1) {
+  const n = Array.from(t).sort((a, e) => a.sortNodePosition(e)).indexOf(s), i = t.size, r = (i - 1) * o;
+  return typeof c == "function" ? c(n, i) : u === 1 ? n * o : r - n * o;
+}
+export {
+  x as calcChildStagger
+};

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

@@ -0,0 +1,23 @@
+import { isGenerator as f } from "../generators/utils/is-generator.js";
+import { isAnimatable as l } from "./is-animatable.js";
+import { warning as g } from "../../../../../motion-utils/dist/es/errors.js";
+function s(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 o = t[t.length - 1], a = l(r, i), e = l(o, i);
+  return g(a === e, `You are trying to animate ${i} from "${r}" to "${o}". "${a ? o : r}" is not an animatable value.`, "value-not-animatable"), !a || !e ? !1 : s(t) || (n === "spring" || f(n)) && u;
+}
+export {
+  h as canAnimate
+};

package/dist/node_modules/motion-dom/dist/es/animation/utils/css-variables-conversion.js

@@ -0,0 +1,31 @@
+import { isCSSVariableToken as c } from "./is-css-variable.js";
+import { invariant as l } from "../../../../../motion-utils/dist/es/errors.js";
+import { isNumericalString as s } from "../../../../../motion-utils/dist/es/is-numerical-string.js";
+const m = (
+  // eslint-disable-next-line redos-detector/no-unsafe-regex -- false positive, as it can match a lot of words
+  /^var\(--(?:([\w-]+)|([\w-]+), ?([a-zA-Z\d ()%#.,-]+))\)/u
+);
+function p(a) {
+  const e = m.exec(a);
+  if (!e)
+    return [,];
+  const [, r, i, t] = e;
+  return [`--${r ?? i}`, t];
+}
+const f = 4;
+function u(a, e, r = 1) {
+  l(r <= f, `Max CSS variable fallback depth detected in property "${a}". This may indicate a circular fallback dependency.`, "max-css-var-depth");
+  const [i, t] = p(a);
+  if (!i)
+    return;
+  const o = window.getComputedStyle(e).getPropertyValue(i);
+  if (o) {
+    const n = o.trim();
+    return s(n) ? parseFloat(n) : n;
+  }
+  return c(t) ? u(t, e, r + 1) : t;
+}
+export {
+  u as getVariableValue,
+  p as parseCSSVariable
+};

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

@@ -0,0 +1,22 @@
+import { transformProps as s } from "../../render/utils/keys-transform.js";
+const r = {
+  type: "spring",
+  stiffness: 500,
+  damping: 25,
+  restSpeed: 10
+}, n = (t) => ({
+  type: "spring",
+  stiffness: 550,
+  damping: t === 0 ? 2 * Math.sqrt(550) : 30,
+  restSpeed: 10
+}), i = {
+  type: "keyframes",
+  duration: 0.8
+}, a = {
+  type: "keyframes",
+  ease: [0.25, 0.1, 0.35, 1],
+  duration: 0.3
+}, o = (t, { keyframes: e }) => e.length > 2 ? i : s.has(t) ? t.startsWith("scale") ? n(e[1]) : r : a;
+export {
+  o as getDefaultTransition
+};

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

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

package/dist/node_modules/motion-dom/dist/es/animation/utils/get-value-transition.js

@@ -0,0 +1,6 @@
+function f(e, u) {
+  return (e == null ? void 0 : e[u]) ?? (e == null ? void 0 : e.default) ?? e;
+}
+export {
+  f as getValueTransition
+};

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

@@ -0,0 +1,7 @@
+import { complex as e } from "../../value/types/complex/index.js";
+const n = (r, t) => t === "zIndex" ? !1 : !!(typeof r == "number" || Array.isArray(r) || typeof r == "string" && // It's animatable if we have a string
+(e.test(r) || r === "0") && // And it contains numbers and/or colors
+!r.startsWith("url("));
+export {
+  n as isAnimatable
+};

package/dist/node_modules/motion-dom/dist/es/animation/utils/is-css-variable.js

@@ -0,0 +1,9 @@
+const r = (t) => (s) => typeof s == "string" && s.startsWith(t), e = /* @__PURE__ */ r("--"), i = /* @__PURE__ */ r("var(--"), a = (t) => i(t) ? n.test(t.split("/*")[0].trim()) : !1, n = /var\(--(?:[\w-]+\s*|[\w-]+\s*,(?:\s*[^)(\s]|\s*\((?:[^)(]|\([^)(]*\))*\))+\s*)\)$/iu;
+function o(t) {
+  return typeof t != "string" ? !1 : t.split("/*")[0].includes("var(--");
+}
+export {
+  o as containsCSSVariable,
+  e as isCSSVariableName,
+  a as isCSSVariableToken
+};

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

@@ -0,0 +1,6 @@
+function g({ when: r, delay: t, delayChildren: a, staggerChildren: n, staggerDirection: i, repeat: l, repeatType: d, repeatDelay: p, from: s, elapsed: y, ...e }) {
+  return !!Object.keys(e).length;
+}
+export {
+  g as isTransitionDefined
+};

package/dist/node_modules/motion-dom/dist/es/animation/utils/make-animation-instant.js

@@ -0,0 +1,6 @@
+function t(n) {
+  n.duration = 0, n.type = "keyframes";
+}
+export {
+  t as makeAnimationInstant
+};

package/dist/node_modules/motion-dom/dist/es/animation/utils/replace-transition-type.js

@@ -0,0 +1,16 @@
+import { inertia as p } from "../generators/inertia.js";
+import { keyframes as r } from "../generators/keyframes.js";
+import { spring as t } from "../generators/spring/index.js";
+const o = {
+  decay: p,
+  inertia: p,
+  tween: r,
+  keyframes: r,
+  spring: t
+};
+function m(e) {
+  typeof e.type == "string" && (e.type = o[e.type]);
+}
+export {
+  m as replaceTransitionType
+};

package/dist/node_modules/motion-dom/dist/es/animation/waapi/easing/cubic-bezier.js

@@ -0,0 +1,4 @@
+const $ = ([c, e, i, r]) => `cubic-bezier(${c}, ${e}, ${i}, ${r})`;
+export {
+  $ as cubicBezierAsString
+};

package/dist/node_modules/motion-dom/dist/es/animation/waapi/easing/map-easing.js

@@ -0,0 +1,12 @@
+import { supportsLinearEasing as o } from "../../../utils/supports/linear-easing.js";
+import { generateLinearEasing as f } from "../utils/linear.js";
+import { cubicBezierAsString as n } from "./cubic-bezier.js";
+import { supportedWaapiEasing as i } from "./supported.js";
+import { isBezierDefinition as p } from "../../../../../../motion-utils/dist/es/easing/utils/is-bezier-definition.js";
+function m(r, e) {
+  if (r)
+    return typeof r == "function" ? o() ? f(r, e) : "ease-out" : p(r) ? n(r) : Array.isArray(r) ? r.map((t) => m(t, e) || i.easeOut) : i[r];
+}
+export {
+  m as mapEasingToNativeEasing
+};

package/dist/node_modules/motion-dom/dist/es/animation/waapi/easing/supported.js

@@ -0,0 +1,15 @@
+import { cubicBezierAsString as e } from "./cubic-bezier.js";
+const i = {
+  linear: "linear",
+  ease: "ease",
+  easeIn: "ease-in",
+  easeOut: "ease-out",
+  easeInOut: "ease-in-out",
+  circIn: /* @__PURE__ */ e([0, 0.65, 0.55, 1]),
+  circOut: /* @__PURE__ */ e([0.55, 0, 1, 0.45]),
+  backIn: /* @__PURE__ */ e([0.31, 0.01, 0.66, -0.59]),
+  backOut: /* @__PURE__ */ e([0.33, 1.53, 0.69, 0.99])
+};
+export {
+  i as supportedWaapiEasing
+};

package/dist/node_modules/motion-dom/dist/es/animation/waapi/start-waapi-animation.js

@@ -0,0 +1,21 @@
+import { mapEasingToNativeEasing as g } from "./easing/map-easing.js";
+function u(r, s, f, { delay: m = 0, duration: n = 300, repeat: p = 0, repeatType: c = "loop", ease: l = "easeOut", times: t } = {}, e = void 0) {
+  const a = {
+    [s]: f
+  };
+  t && (a.offset = t);
+  const i = g(l, n);
+  Array.isArray(i) && (a.easing = i);
+  const o = {
+    delay: m,
+    duration: n,
+    easing: Array.isArray(i) ? "linear" : i,
+    fill: "both",
+    iterations: p + 1,
+    direction: c === "reverse" ? "alternate" : "normal"
+  };
+  return e && (o.pseudoElement = e), r.animate(a, o);
+}
+export {
+  u as startWaapiAnimation
+};

package/dist/node_modules/motion-dom/dist/es/animation/waapi/supports/waapi.js

@@ -0,0 +1,24 @@
+import { memo as m } from "../../../../../../motion-utils/dist/es/memo.js";
+const l = /* @__PURE__ */ new Set([
+  "opacity",
+  "clipPath",
+  "filter",
+  "transform"
+  // TODO: Could be re-enabled now we have support for linear() easing
+  // "background-color"
+]), f = /* @__PURE__ */ m(() => Object.hasOwnProperty.call(Element.prototype, "animate"));
+function w(n) {
+  var r;
+  const { motionValue: e, name: t, repeatDelay: a, repeatType: o, damping: s, type: p } = n;
+  if (!(((r = e == null ? void 0 : e.owner) == null ? void 0 : r.current) instanceof HTMLElement))
+    return !1;
+  const { onUpdate: c, transformTemplate: i } = e.owner.getProps();
+  return f() && t && l.has(t) && (t !== "transform" || !i) && /**
+   * 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.
+   */
+  !c && !a && o !== "mirror" && s !== 0 && p !== "inertia";
+}
+export {
+  w as supportsBrowserAnimation
+};

package/dist/node_modules/motion-dom/dist/es/animation/waapi/utils/apply-generator.js

@@ -0,0 +1,8 @@
+import { supportsLinearEasing as a } from "../../../utils/supports/linear-easing.js";
+import { isGenerator as t } from "../../generators/utils/is-generator.js";
+function i({ type: e, ...r }) {
+  return t(e) && a() ? e.applyToOptions(r) : (r.duration ?? (r.duration = 300), r.ease ?? (r.ease = "easeOut"), r);
+}
+export {
+  i as applyGeneratorOptions
+};