@vkzstudio/muza-ui 1.0.0 → 1.0.2

package/dist/node_modules/motion-dom/dist/es/render/dom/parse-transform.js

@@ -0,0 +1,65 @@
+const e = (t) => t * 180 / Math.PI, c = (t) => {
+  const a = e(Math.atan2(t[1], t[0]));
+  return l(a);
+}, f = {
+  x: 4,
+  y: 5,
+  translateX: 4,
+  translateY: 5,
+  scaleX: 0,
+  scaleY: 3,
+  scale: (t) => (Math.abs(t[0]) + Math.abs(t[3])) / 2,
+  rotate: c,
+  rotateZ: c,
+  skewX: (t) => e(Math.atan(t[1])),
+  skewY: (t) => e(Math.atan(t[2])),
+  skew: (t) => (Math.abs(t[1]) + Math.abs(t[2])) / 2
+}, l = (t) => (t = t % 360, t < 0 && (t += 360), t), h = c, M = (t) => Math.sqrt(t[0] * t[0] + t[1] * t[1]), i = (t) => Math.sqrt(t[4] * t[4] + t[5] * t[5]), x = {
+  x: 12,
+  y: 13,
+  z: 14,
+  translateX: 12,
+  translateY: 13,
+  translateZ: 14,
+  scaleX: M,
+  scaleY: i,
+  scale: (t) => (M(t) + i(t)) / 2,
+  rotateX: (t) => l(e(Math.atan2(t[6], t[5]))),
+  rotateY: (t) => l(e(Math.atan2(-t[2], t[0]))),
+  rotateZ: h,
+  rotate: h,
+  skewX: (t) => e(Math.atan(t[4])),
+  skewY: (t) => e(Math.atan(t[1])),
+  skew: (t) => (Math.abs(t[1]) + Math.abs(t[4])) / 2
+};
+function m(t) {
+  return t.includes("scale") ? 1 : 0;
+}
+function b(t, a) {
+  if (!t || t === "none")
+    return m(a);
+  const s = t.match(/^matrix3d\(([-\d.e\s,]+)\)$/u);
+  let n, r;
+  if (s)
+    n = x, r = s;
+  else {
+    const d = t.match(/^matrix\(([-\d.e\s,]+)\)$/u);
+    n = f, r = d;
+  }
+  if (!r)
+    return m(a);
+  const o = n[a], u = r[1].split(",").map(p);
+  return typeof o == "function" ? o(u) : u[o];
+}
+const X = (t, a) => {
+  const { transform: s = "none" } = getComputedStyle(t);
+  return b(s, a);
+};
+function p(t) {
+  return parseFloat(t.trim());
+}
+export {
+  m as defaultTransformValue,
+  b as parseValueFromTransform,
+  X as readTransformValue
+};

package/dist/node_modules/motion-dom/dist/es/render/dom/style-set.js

@@ -0,0 +1,7 @@
+import { isCSSVar as s } from "./is-css-var.js";
+function i(r, t, o) {
+  s(t) ? r.style.setProperty(t, o) : r.style[t] = o;
+}
+export {
+  i as setStyle
+};

package/dist/node_modules/motion-dom/dist/es/render/utils/keys-position.js

@@ -0,0 +1,13 @@
+import { transformPropOrder as t } from "./keys-transform.js";
+const r = /* @__PURE__ */ new Set([
+  "width",
+  "height",
+  "top",
+  "left",
+  "right",
+  "bottom",
+  ...t
+]);
+export {
+  r as positionalKeys
+};

package/dist/node_modules/motion-dom/dist/es/render/utils/keys-transform.js

@@ -0,0 +1,23 @@
+const t = [
+  "transformPerspective",
+  "x",
+  "y",
+  "z",
+  "translateX",
+  "translateY",
+  "translateZ",
+  "scale",
+  "scaleX",
+  "scaleY",
+  "rotate",
+  "rotateX",
+  "rotateY",
+  "rotateZ",
+  "skew",
+  "skewX",
+  "skewY"
+], e = new Set(t);
+export {
+  t as transformPropOrder,
+  e as transformProps
+};

package/dist/node_modules/motion-dom/dist/es/utils/interpolate.js

@@ -0,0 +1,42 @@
+import { mix as h } from "./mix/index.js";
+import { invariant as x } from "../../../../motion-utils/dist/es/errors.js";
+import { clamp as M } from "../../../../motion-utils/dist/es/clamp.js";
+import { MotionGlobalConfig as b } from "../../../../motion-utils/dist/es/global-config.js";
+import { noop as y } from "../../../../motion-utils/dist/es/noop.js";
+import { pipe as A } from "../../../../motion-utils/dist/es/pipe.js";
+import { progress as F } from "../../../../motion-utils/dist/es/progress.js";
+function R(r, e, f) {
+  const t = [], a = f || b.mix || h, n = r.length - 1;
+  for (let o = 0; o < n; o++) {
+    let i = a(r[o], r[o + 1]);
+    if (e) {
+      const c = Array.isArray(e) ? e[o] || y : e;
+      i = A(c, i);
+    }
+    t.push(i);
+  }
+  return t;
+}
+function I(r, e, { clamp: f = !0, ease: t, mixer: a } = {}) {
+  const n = r.length;
+  if (x(n === e.length, "Both input and output ranges must be the same length", "range-length"), n === 1)
+    return () => e[0];
+  if (n === 2 && e[0] === e[1])
+    return () => e[1];
+  const o = r[0] === r[1];
+  r[0] > r[n - 1] && (r = [...r].reverse(), e = [...e].reverse());
+  const i = R(e, t, a), c = i.length, l = (s) => {
+    if (o && s < r[0])
+      return e[0];
+    let m = 0;
+    if (c > 1)
+      for (; m < r.length - 2 && !(s < r[m + 1]); m++)
+        ;
+    const g = F(r[m], r[m + 1], s);
+    return i[m](g);
+  };
+  return f ? (s) => l(M(r[0], r[n - 1], s)) : l;
+}
+export {
+  I as interpolate
+};

package/dist/node_modules/motion-dom/dist/es/utils/is-html-element.js

@@ -0,0 +1,7 @@
+import { isObject as i } from "../../../../motion-utils/dist/es/is-object.js";
+function r(t) {
+  return i(t) && "offsetHeight" in t;
+}
+export {
+  r as isHTMLElement
+};

package/dist/node_modules/motion-dom/dist/es/utils/is-svg-element.js

@@ -0,0 +1,7 @@
+import { isObject as r } from "../../../../motion-utils/dist/es/is-object.js";
+function e(n) {
+  return r(n) && "ownerSVGElement" in n;
+}
+export {
+  e as isSVGElement
+};

package/dist/node_modules/motion-dom/dist/es/utils/is-svg-svg-element.js

@@ -0,0 +1,7 @@
+import { isSVGElement as r } from "./is-svg-element.js";
+function i(t) {
+  return r(t) && t.tagName === "svg";
+}
+export {
+  i as isSVGSVGElement
+};

package/dist/node_modules/motion-dom/dist/es/utils/mix/color.js

@@ -0,0 +1,29 @@
+import { hex as p } from "../../value/types/color/hex.js";
+import { hsla as l } from "../../value/types/color/hsla.js";
+import { hslaToRgba as c } from "../../value/types/color/hsla-to-rgba.js";
+import { rgba as s } from "../../value/types/color/rgba.js";
+import { mixImmediate as f } from "./immediate.js";
+import { mixNumber as u } from "./number.js";
+import { warning as d } from "../../../../../motion-utils/dist/es/errors.js";
+const m = (r, o, e) => {
+  const t = r * r, n = e * (o * o - t) + t;
+  return n < 0 ? 0 : Math.sqrt(n);
+}, b = [p, s, l], h = (r) => b.find((o) => o.test(r));
+function i(r) {
+  const o = h(r);
+  if (d(!!o, `'${r}' is not an animatable color. Use the equivalent color code instead.`, "color-not-animatable"), !o)
+    return !1;
+  let e = o.parse(r);
+  return o === l && (e = c(e)), e;
+}
+const G = (r, o) => {
+  const e = i(r), t = i(o);
+  if (!e || !t)
+    return f(r, o);
+  const n = { ...e };
+  return (a) => (n.red = m(e.red, t.red, a), n.green = m(e.green, t.green, a), n.blue = m(e.blue, t.blue, a), n.alpha = u(e.alpha, t.alpha, a), s.transform(n));
+};
+export {
+  G as mixColor,
+  m as mixLinearColor
+};

package/dist/node_modules/motion-dom/dist/es/utils/mix/complex.js

@@ -0,0 +1,51 @@
+import { isCSSVariableToken as d } from "../../animation/utils/is-css-variable.js";
+import { color as u } from "../../value/types/color/index.js";
+import { complex as h, analyseComplexValue as m } from "../../value/types/complex/index.js";
+import { mixColor as a } from "./color.js";
+import { mixImmediate as l } from "./immediate.js";
+import { mixNumber as b } from "./number.js";
+import { invisibleValues as c, mixVisibility as y } from "./visibility.js";
+import { pipe as v } from "../../../../../motion-utils/dist/es/pipe.js";
+import { warning as g } from "../../../../../motion-utils/dist/es/errors.js";
+function V(e, t) {
+  return (r) => b(e, t, r);
+}
+function f(e) {
+  return typeof e == "number" ? V : typeof e == "string" ? d(e) ? l : u.test(e) ? a : I : Array.isArray(e) ? p : typeof e == "object" ? u.test(e) ? a : C : l;
+}
+function p(e, t) {
+  const r = [...e], o = r.length, n = e.map((i, s) => f(i)(i, t[s]));
+  return (i) => {
+    for (let s = 0; s < o; s++)
+      r[s] = n[s](i);
+    return r;
+  };
+}
+function C(e, t) {
+  const r = { ...e, ...t }, o = {};
+  for (const n in r)
+    e[n] !== void 0 && t[n] !== void 0 && (o[n] = f(e[n])(e[n], t[n]));
+  return (n) => {
+    for (const i in o)
+      r[i] = o[i](n);
+    return r;
+  };
+}
+function k(e, t) {
+  const r = [], o = { color: 0, var: 0, number: 0 };
+  for (let n = 0; n < t.values.length; n++) {
+    const i = t.types[n], s = e.indexes[i][o[i]], x = e.values[s] ?? 0;
+    r[n] = x, o[i]++;
+  }
+  return r;
+}
+const I = (e, t) => {
+  const r = h.createTransformer(t), o = m(e), n = m(t);
+  return o.indexes.var.length === n.indexes.var.length && o.indexes.color.length === n.indexes.color.length && o.indexes.number.length >= n.indexes.number.length ? c.has(e) && !n.values.length || c.has(t) && !o.values.length ? y(e, t) : v(p(k(o, n), n.values), r) : (g(!0, `Complex values '${e}' and '${t}' too different to mix. Ensure all colors are of the same type, and that each contains the same quantity of number and color values. Falling back to instant transition.`, "complex-values-different"), l(e, t));
+};
+export {
+  f as getMixer,
+  p as mixArray,
+  I as mixComplex,
+  C as mixObject
+};

package/dist/node_modules/motion-dom/dist/es/utils/mix/immediate.js

@@ -0,0 +1,6 @@
+function m(e, t) {
+  return (i) => i > 0 ? t : e;
+}
+export {
+  m as mixImmediate
+};

package/dist/node_modules/motion-dom/dist/es/utils/mix/index.js

@@ -0,0 +1,8 @@
+import { getMixer as m } from "./complex.js";
+import { mixNumber as t } from "./number.js";
+function o(e, r, i) {
+  return typeof e == "number" && typeof r == "number" && typeof i == "number" ? t(e, r, i) : m(e)(e, r);
+}
+export {
+  o as mix
+};

package/dist/node_modules/motion-dom/dist/es/utils/mix/number.js

@@ -0,0 +1,4 @@
+const n = (e, r, t) => e + (r - e) * t;
+export {
+  n as mixNumber
+};

package/dist/node_modules/motion-dom/dist/es/utils/mix/visibility.js

@@ -0,0 +1,8 @@
+const s = /* @__PURE__ */ new Set(["none", "hidden"]);
+function t(e, i) {
+  return s.has(e) ? (n) => n <= 0 ? e : i : (n) => n >= 1 ? i : e;
+}
+export {
+  s as invisibleValues,
+  t as mixVisibility
+};

package/dist/node_modules/motion-dom/dist/es/utils/resolve-elements.js

@@ -0,0 +1,13 @@
+function o(n, r, f) {
+  if (n instanceof EventTarget)
+    return [n];
+  if (typeof n == "string") {
+    let i = document;
+    const u = (f == null ? void 0 : f[n]) ?? i.querySelectorAll(n);
+    return u ? Array.from(u) : [];
+  }
+  return Array.from(n);
+}
+export {
+  o as resolveElements
+};

package/dist/node_modules/motion-dom/dist/es/utils/supports/flags.js

@@ -0,0 +1,4 @@
+const s = {};
+export {
+  s as supportsFlags
+};

package/dist/node_modules/motion-dom/dist/es/utils/supports/linear-easing.js

@@ -0,0 +1,12 @@
+import { memoSupports as e } from "./memo.js";
+const a = /* @__PURE__ */ e(() => {
+  try {
+    document.createElement("div").animate({ opacity: 0 }, { easing: "linear(0, 1)" });
+  } catch {
+    return !1;
+  }
+  return !0;
+}, "linearEasing");
+export {
+  a as supportsLinearEasing
+};

package/dist/node_modules/motion-dom/dist/es/utils/supports/memo.js

@@ -0,0 +1,9 @@
+import { supportsFlags as t } from "./flags.js";
+import { memo as p } from "../../../../../motion-utils/dist/es/memo.js";
+function i(o, m) {
+  const r = p(o);
+  return () => t[m] ?? r();
+}
+export {
+  i as memoSupports
+};

package/dist/node_modules/motion-dom/dist/es/utils/supports/scroll-timeline.js

@@ -0,0 +1,5 @@
+import { memo as o } from "../../../../../motion-utils/dist/es/memo.js";
+const i = /* @__PURE__ */ o(() => window.ScrollTimeline !== void 0);
+export {
+  i as supportsScrollTimeline
+};

package/dist/node_modules/motion-dom/dist/es/utils/transform.js

@@ -0,0 +1,8 @@
+import { interpolate as s } from "./interpolate.js";
+function a(...t) {
+  const o = !Array.isArray(t[0]), n = o ? 0 : -1, r = t[0 + n], i = t[1 + n], c = t[2 + n], p = t[3 + n], e = s(i, c, p);
+  return o ? e(r) : e;
+}
+export {
+  a as transform
+};

package/dist/node_modules/motion-dom/dist/es/value/index.js

@@ -0,0 +1,218 @@
+import { time as n } from "../frameloop/sync-time.js";
+import { frame as d } from "../frameloop/frame.js";
+import { warnOnce as p } from "../../../../motion-utils/dist/es/warn-once.js";
+import { SubscriptionManager as u } from "../../../../motion-utils/dist/es/subscription-manager.js";
+import { velocityPerSecond as f } from "../../../../motion-utils/dist/es/velocity-per-second.js";
+const a = 30, l = (s) => !isNaN(parseFloat(s)), h = {
+  current: void 0
+};
+class m {
+  /**
+   * @param init - The initiating value
+   * @param config - Optional configuration options
+   *
+   * -  `transformer`: A function to transform incoming values with.
+   */
+  constructor(t, e = {}) {
+    this.canTrackVelocity = null, this.events = {}, this.updateAndNotify = (i) => {
+      var r;
+      const o = n.now();
+      if (this.updatedAt !== o && this.setPrevFrameValue(), this.prev = this.current, this.setCurrent(i), this.current !== this.prev && ((r = this.events.change) == null || r.notify(this.current), this.dependents))
+        for (const c of this.dependents)
+          c.dirty();
+    }, this.hasAnimated = !1, this.setCurrent(t), this.owner = e.owner;
+  }
+  setCurrent(t) {
+    this.current = t, this.updatedAt = n.now(), this.canTrackVelocity === null && t !== void 0 && (this.canTrackVelocity = l(this.current));
+  }
+  setPrevFrameValue(t = this.current) {
+    this.prevFrameValue = t, this.prevUpdatedAt = this.updatedAt;
+  }
+  /**
+   * Adds a function that will be notified when the `MotionValue` is updated.
+   *
+   * It returns a function that, when called, will cancel the subscription.
+   *
+   * When calling `onChange` inside a React component, it should be wrapped with the
+   * `useEffect` hook. As it returns an unsubscribe function, this should be returned
+   * from the `useEffect` function to ensure you don't add duplicate subscribers..
+   *
+   * ```jsx
+   * export const MyComponent = () => {
+   *   const x = useMotionValue(0)
+   *   const y = useMotionValue(0)
+   *   const opacity = useMotionValue(1)
+   *
+   *   useEffect(() => {
+   *     function updateOpacity() {
+   *       const maxXY = Math.max(x.get(), y.get())
+   *       const newOpacity = transform(maxXY, [0, 100], [1, 0])
+   *       opacity.set(newOpacity)
+   *     }
+   *
+   *     const unsubscribeX = x.on("change", updateOpacity)
+   *     const unsubscribeY = y.on("change", updateOpacity)
+   *
+   *     return () => {
+   *       unsubscribeX()
+   *       unsubscribeY()
+   *     }
+   *   }, [])
+   *
+   *   return <motion.div style={{ x }} />
+   * }
+   * ```
+   *
+   * @param subscriber - A function that receives the latest value.
+   * @returns A function that, when called, will cancel this subscription.
+   *
+   * @deprecated
+   */
+  onChange(t) {
+    return process.env.NODE_ENV !== "production" && p(!1, 'value.onChange(callback) is deprecated. Switch to value.on("change", callback).'), this.on("change", t);
+  }
+  on(t, e) {
+    this.events[t] || (this.events[t] = new u());
+    const i = this.events[t].add(e);
+    return t === "change" ? () => {
+      i(), d.read(() => {
+        this.events.change.getSize() || this.stop();
+      });
+    } : i;
+  }
+  clearListeners() {
+    for (const t in this.events)
+      this.events[t].clear();
+  }
+  /**
+   * Attaches a passive effect to the `MotionValue`.
+   */
+  attach(t, e) {
+    this.passiveEffect = t, this.stopPassiveEffect = e;
+  }
+  /**
+   * Sets the state of the `MotionValue`.
+   *
+   * @remarks
+   *
+   * ```jsx
+   * const x = useMotionValue(0)
+   * x.set(10)
+   * ```
+   *
+   * @param latest - Latest value to set.
+   * @param render - Whether to notify render subscribers. Defaults to `true`
+   *
+   * @public
+   */
+  set(t) {
+    this.passiveEffect ? this.passiveEffect(t, this.updateAndNotify) : this.updateAndNotify(t);
+  }
+  setWithVelocity(t, e, i) {
+    this.set(e), this.prev = void 0, this.prevFrameValue = t, this.prevUpdatedAt = this.updatedAt - i;
+  }
+  /**
+   * Set the state of the `MotionValue`, stopping any active animations,
+   * effects, and resets velocity to `0`.
+   */
+  jump(t, e = !0) {
+    this.updateAndNotify(t), this.prev = t, this.prevUpdatedAt = this.prevFrameValue = void 0, e && this.stop(), this.stopPassiveEffect && this.stopPassiveEffect();
+  }
+  dirty() {
+    var t;
+    (t = this.events.change) == null || t.notify(this.current);
+  }
+  addDependent(t) {
+    this.dependents || (this.dependents = /* @__PURE__ */ new Set()), this.dependents.add(t);
+  }
+  removeDependent(t) {
+    this.dependents && this.dependents.delete(t);
+  }
+  /**
+   * Returns the latest state of `MotionValue`
+   *
+   * @returns - The latest state of `MotionValue`
+   *
+   * @public
+   */
+  get() {
+    return h.current && h.current.push(this), this.current;
+  }
+  /**
+   * @public
+   */
+  getPrevious() {
+    return this.prev;
+  }
+  /**
+   * Returns the latest velocity of `MotionValue`
+   *
+   * @returns - The latest velocity of `MotionValue`. Returns `0` if the state is non-numerical.
+   *
+   * @public
+   */
+  getVelocity() {
+    const t = n.now();
+    if (!this.canTrackVelocity || this.prevFrameValue === void 0 || t - this.updatedAt > a)
+      return 0;
+    const e = Math.min(this.updatedAt - this.prevUpdatedAt, a);
+    return f(parseFloat(this.current) - parseFloat(this.prevFrameValue), e);
+  }
+  /**
+   * Registers a new animation to control this `MotionValue`. Only one
+   * animation can drive a `MotionValue` at one time.
+   *
+   * ```jsx
+   * value.start()
+   * ```
+   *
+   * @param animation - A function that starts the provided animation
+   */
+  start(t) {
+    return this.stop(), new Promise((e) => {
+      this.hasAnimated = !0, this.animation = t(e), this.events.animationStart && this.events.animationStart.notify();
+    }).then(() => {
+      this.events.animationComplete && this.events.animationComplete.notify(), this.clearAnimation();
+    });
+  }
+  /**
+   * Stop the currently active animation.
+   *
+   * @public
+   */
+  stop() {
+    this.animation && (this.animation.stop(), this.events.animationCancel && this.events.animationCancel.notify()), this.clearAnimation();
+  }
+  /**
+   * Returns `true` if this value is currently animating.
+   *
+   * @public
+   */
+  isAnimating() {
+    return !!this.animation;
+  }
+  clearAnimation() {
+    delete this.animation;
+  }
+  /**
+   * Destroy and clean up subscribers to this `MotionValue`.
+   *
+   * The `MotionValue` hooks like `useMotionValue` and `useTransform` automatically
+   * handle the lifecycle of the returned `MotionValue`, so this method is only necessary if you've manually
+   * created a `MotionValue` via the `motionValue` function.
+   *
+   * @public
+   */
+  destroy() {
+    var t, e;
+    (t = this.dependents) == null || t.clear(), (e = this.events.destroy) == null || e.notify(), this.clearListeners(), this.stop(), this.stopPassiveEffect && this.stopPassiveEffect();
+  }
+}
+function E(s, t) {
+  return new m(s, t);
+}
+export {
+  m as MotionValue,
+  h as collectMotionValues,
+  E as motionValue
+};

package/dist/node_modules/motion-dom/dist/es/value/types/auto.js

@@ -0,0 +1,7 @@
+const o = {
+  test: (t) => t === "auto",
+  parse: (t) => t
+};
+export {
+  o as auto
+};

package/dist/node_modules/motion-dom/dist/es/value/types/color/hex.js

@@ -0,0 +1,19 @@
+import { rgba as i } from "./rgba.js";
+import { isColorString as g } from "./utils.js";
+function a(r) {
+  let t = "", e = "", n = "", s = "";
+  return r.length > 5 ? (t = r.substring(1, 3), e = r.substring(3, 5), n = r.substring(5, 7), s = r.substring(7, 9)) : (t = r.substring(1, 2), e = r.substring(2, 3), n = r.substring(3, 4), s = r.substring(4, 5), t += t, e += e, n += n, s += s), {
+    red: parseInt(t, 16),
+    green: parseInt(e, 16),
+    blue: parseInt(n, 16),
+    alpha: s ? parseInt(s, 16) / 255 : 1
+  };
+}
+const u = {
+  test: /* @__PURE__ */ g("#"),
+  parse: a,
+  transform: i.transform
+};
+export {
+  u as hex
+};

package/dist/node_modules/motion-dom/dist/es/value/types/color/hsla-to-rgba.js

@@ -0,0 +1,22 @@
+function c(e, f, r) {
+  return r < 0 && (r += 1), r > 1 && (r -= 1), r < 1 / 6 ? e + (f - e) * 6 * r : r < 1 / 2 ? f : r < 2 / 3 ? e + (f - e) * (2 / 3 - r) * 6 : e;
+}
+function R({ hue: e, saturation: f, lightness: r, alpha: M }) {
+  e /= 360, f /= 100, r /= 100;
+  let o = 0, u = 0, d = 0;
+  if (!f)
+    o = u = d = r;
+  else {
+    const n = r < 0.5 ? r * (1 + f) : r + f - r * f, b = 2 * r - n;
+    o = c(b, n, e + 1 / 3), u = c(b, n, e), d = c(b, n, e - 1 / 3);
+  }
+  return {
+    red: Math.round(o * 255),
+    green: Math.round(u * 255),
+    blue: Math.round(d * 255),
+    alpha: M
+  };
+}
+export {
+  R as hslaToRgba
+};

package/dist/node_modules/motion-dom/dist/es/value/types/color/hsla.js

@@ -0,0 +1,12 @@
+import { alpha as n } from "../numbers/index.js";
+import { percent as t } from "../numbers/units.js";
+import { sanitize as r } from "../utils/sanitize.js";
+import { isColorString as i, splitColor as e } from "./utils.js";
+const u = {
+  test: /* @__PURE__ */ i("hsl", "hue"),
+  parse: /* @__PURE__ */ e("hue", "saturation", "lightness"),
+  transform: ({ hue: o, saturation: s, lightness: a, alpha: m = 1 }) => "hsla(" + Math.round(o) + ", " + t.transform(r(s)) + ", " + t.transform(r(a)) + ", " + r(n.transform(m)) + ")"
+};
+export {
+  u as hsla
+};

package/dist/node_modules/motion-dom/dist/es/value/types/color/index.js

@@ -0,0 +1,15 @@
+import { hex as o } from "./hex.js";
+import { hsla as t } from "./hsla.js";
+import { rgba as e } from "./rgba.js";
+const a = {
+  test: (r) => e.test(r) || o.test(r) || t.test(r),
+  parse: (r) => e.test(r) ? e.parse(r) : t.test(r) ? t.parse(r) : o.parse(r),
+  transform: (r) => typeof r == "string" ? r : r.hasOwnProperty("red") ? e.transform(r) : t.transform(r),
+  getAnimatableNone: (r) => {
+    const s = a.parse(r);
+    return s.alpha = 0, a.transform(s);
+  }
+};
+export {
+  a as color
+};