motion-v 0.3.0 → 0.4.0

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/utils/progress.mjs

@@ -1,7 +1,7 @@
-const n = (e, o, t) => {
-  const r = o - e;
-  return r === 0 ? 1 : (t - e) / r;
+const progress = (from, to, value) => {
+  const toFromDifference = to - from;
+  return toFromDifference === 0 ? 1 : (value - from) / toFromDifference;
 };
 export {
-  n as progress
+  progress
 };

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/utils/reduced-motion/index.mjs

@@ -1,13 +1,18 @@
-import { isBrowser as o } from "../is-browser.mjs";
-import { hasReducedMotionListener as i, prefersReducedMotion as t } from "./state.mjs";
-function c() {
-  if (i.current = !0, !!o)
-    if (window.matchMedia) {
-      const e = window.matchMedia("(prefers-reduced-motion)"), r = () => t.current = e.matches;
-      e.addListener(r), r();
-    } else
-      t.current = !1;
+import { isBrowser } from "../is-browser.mjs";
+import { hasReducedMotionListener, prefersReducedMotion } from "./state.mjs";
+function initPrefersReducedMotion() {
+  hasReducedMotionListener.current = true;
+  if (!isBrowser)
+    return;
+  if (window.matchMedia) {
+    const motionMediaQuery = window.matchMedia("(prefers-reduced-motion)");
+    const setReducedMotionPreferences = () => prefersReducedMotion.current = motionMediaQuery.matches;
+    motionMediaQuery.addListener(setReducedMotionPreferences);
+    setReducedMotionPreferences();
+  } else {
+    prefersReducedMotion.current = false;
+  }
 }
 export {
-  c as initPrefersReducedMotion
+  initPrefersReducedMotion
 };

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/utils/reduced-motion/state.mjs

@@ -1,5 +1,6 @@
-const e = { current: null }, n = { current: !1 };
+const prefersReducedMotion = { current: null };
+const hasReducedMotionListener = { current: false };
 export {
-  n as hasReducedMotionListener,
-  e as prefersReducedMotion
+  hasReducedMotionListener,
+  prefersReducedMotion
 };

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/utils/resolve-value.mjs

@@ -1,5 +1,11 @@
-import { isKeyframesTarget as r } from "../animation/utils/is-keyframes-target.mjs";
-const a = (e) => r(e) ? e[e.length - 1] || 0 : e;
+import { isKeyframesTarget } from "../animation/utils/is-keyframes-target.mjs";
+const isCustomValue = (v) => {
+  return Boolean(v && typeof v === "object" && v.mix && v.toValue);
+};
+const resolveFinalValueInKeyframes = (v) => {
+  return isKeyframesTarget(v) ? v[v.length - 1] || 0 : v;
+};
 export {
-  a as resolveFinalValueInKeyframes
+  isCustomValue,
+  resolveFinalValueInKeyframes
 };

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/utils/subscription-manager.mjs

@@ -1,21 +1,24 @@
-import { addUniqueItem as e, removeItem as u } from "./array.mjs";
-class h {
+import { addUniqueItem, removeItem } from "./array.mjs";
+class SubscriptionManager {
   constructor() {
     this.subscriptions = [];
   }
-  add(s) {
-    return e(this.subscriptions, s), () => u(this.subscriptions, s);
+  add(handler) {
+    addUniqueItem(this.subscriptions, handler);
+    return () => removeItem(this.subscriptions, handler);
   }
-  notify(s, r, n) {
-    const i = this.subscriptions.length;
-    if (i)
-      if (i === 1)
-        this.subscriptions[0](s, r, n);
-      else
-        for (let t = 0; t < i; t++) {
-          const o = this.subscriptions[t];
-          o && o(s, r, n);
-        }
+  notify(a, b, c) {
+    const numSubscriptions = this.subscriptions.length;
+    if (!numSubscriptions)
+      return;
+    if (numSubscriptions === 1) {
+      this.subscriptions[0](a, b, c);
+    } else {
+      for (let i = 0; i < numSubscriptions; i++) {
+        const handler = this.subscriptions[i];
+        handler && handler(a, b, c);
+      }
+    }
   }
   getSize() {
     return this.subscriptions.length;
@@ -25,5 +28,5 @@ class h {
   }
 }
 export {
-  h as SubscriptionManager
+  SubscriptionManager
 };

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/utils/time-conversion.mjs

@@ -1,5 +1,6 @@
-const s = (o) => o * 1e3, c = (o) => o / 1e3;
+const secondsToMilliseconds = (seconds) => seconds * 1e3;
+const millisecondsToSeconds = (milliseconds) => milliseconds / 1e3;
 export {
-  c as millisecondsToSeconds,
-  s as secondsToMilliseconds
+  millisecondsToSeconds,
+  secondsToMilliseconds
 };

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/utils/transform.mjs

@@ -1,12 +1,21 @@
-import { interpolate as c } from "./interpolate.mjs";
-const p = (t) => t && typeof t == "object" && t.mix, m = (t) => p(t) ? t.mix : void 0;
-function f(...t) {
-  const o = !Array.isArray(t[0]), n = o ? 0 : -1, r = t[0 + n], s = t[1 + n], e = t[2 + n], u = t[3 + n], i = c(s, e, {
-    mixer: m(e[0]),
-    ...u
+import { interpolate } from "./interpolate.mjs";
+const isCustomValueType = (v) => {
+  return v && typeof v === "object" && v.mix;
+};
+const getMixer = (v) => isCustomValueType(v) ? v.mix : void 0;
+function transform(...args) {
+  const useImmediate = !Array.isArray(args[0]);
+  const argOffset = useImmediate ? 0 : -1;
+  const inputValue = args[0 + argOffset];
+  const inputRange = args[1 + argOffset];
+  const outputRange = args[2 + argOffset];
+  const options = args[3 + argOffset];
+  const interpolator = interpolate(inputRange, outputRange, {
+    mixer: getMixer(outputRange[0]),
+    ...options
   });
-  return o ? i(r) : i;
+  return useImmediate ? interpolator(inputValue) : interpolator;
 }
 export {
-  f as transform
+  transform
 };

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/utils/velocity-per-second.mjs

@@ -1,6 +1,6 @@
-function n(c, e) {
-  return e ? c * (1e3 / e) : 0;
+function velocityPerSecond(velocity, frameDuration) {
+  return frameDuration ? velocity * (1e3 / frameDuration) : 0;
 }
 export {
-  n as velocityPerSecond
+  velocityPerSecond
 };

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/utils/warn-once.mjs

@@ -1,7 +1,10 @@
-const e = /* @__PURE__ */ new Set();
-function o(r, n, t) {
-  r || e.has(n) || (console.warn(n), e.add(n));
+const warned = /* @__PURE__ */ new Set();
+function warnOnce(condition, message, element) {
+  if (condition || warned.has(message))
+    return;
+  console.warn(message);
+  warned.add(message);
 }
 export {
-  o as warnOnce
+  warnOnce
 };

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/utils/wrap.mjs

@@ -1,7 +1,7 @@
-const a = (r, t, o) => {
-  const e = t - r;
-  return ((o - r) % e + e) % e + r;
+const wrap = (min, max, v) => {
+  const rangeSize = max - min;
+  return ((v - min) % rangeSize + rangeSize) % rangeSize + min;
 };
 export {
-  a as wrap
+  wrap
 };

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/value/index.mjs

@@ -1,12 +1,16 @@
-import { SubscriptionManager as c } from "../utils/subscription-manager.mjs";
-import { velocityPerSecond as u } from "../utils/velocity-per-second.mjs";
-import { warnOnce as p } from "../utils/warn-once.mjs";
-import { time as n } from "../frameloop/sync-time.mjs";
-import { frame as f } from "../frameloop/frame.mjs";
-const r = 30, d = (s) => !isNaN(parseFloat(s)), a = {
+import { SubscriptionManager } from "../utils/subscription-manager.mjs";
+import { velocityPerSecond } from "../utils/velocity-per-second.mjs";
+import { warnOnce } from "../utils/warn-once.mjs";
+import { time } from "../frameloop/sync-time.mjs";
+import { frame } from "../frameloop/frame.mjs";
+const MAX_VELOCITY_DELTA = 30;
+const isFloat = (value) => {
+  return !isNaN(parseFloat(value));
+};
+const collectMotionValues = {
   current: void 0
 };
-class l {
+class MotionValue {
   /**
    * @param init - The initiating value
    * @param config - Optional configuration options
@@ -15,17 +19,38 @@ class l {
    *
    * @internal
    */
-  constructor(t, e = {}) {
-    this.version = "11.11.11", this.canTrackVelocity = null, this.events = {}, this.updateAndNotify = (i, h = !0) => {
-      const o = n.now();
-      this.updatedAt !== o && this.setPrevFrameValue(), this.prev = this.current, this.setCurrent(i), this.current !== this.prev && this.events.change && this.events.change.notify(this.current), h && this.events.renderRequest && this.events.renderRequest.notify(this.current);
-    }, this.hasAnimated = !1, this.setCurrent(t), this.owner = e.owner;
+  constructor(init, options = {}) {
+    this.version = "11.11.11";
+    this.canTrackVelocity = null;
+    this.events = {};
+    this.updateAndNotify = (v, render = true) => {
+      const currentTime = time.now();
+      if (this.updatedAt !== currentTime) {
+        this.setPrevFrameValue();
+      }
+      this.prev = this.current;
+      this.setCurrent(v);
+      if (this.current !== this.prev && this.events.change) {
+        this.events.change.notify(this.current);
+      }
+      if (render && this.events.renderRequest) {
+        this.events.renderRequest.notify(this.current);
+      }
+    };
+    this.hasAnimated = false;
+    this.setCurrent(init);
+    this.owner = options.owner;
   }
-  setCurrent(t) {
-    this.current = t, this.updatedAt = n.now(), this.canTrackVelocity === null && t !== void 0 && (this.canTrackVelocity = d(this.current));
+  setCurrent(current) {
+    this.current = current;
+    this.updatedAt = time.now();
+    if (this.canTrackVelocity === null && current !== void 0) {
+      this.canTrackVelocity = isFloat(this.current);
+    }
   }
-  setPrevFrameValue(t = this.current) {
-    this.prevFrameValue = t, this.prevUpdatedAt = this.updatedAt;
+  setPrevFrameValue(prevFrameValue = this.current) {
+    this.prevFrameValue = prevFrameValue;
+    this.prevUpdatedAt = this.updatedAt;
   }
   /**
    * Adds a function that will be notified when the `MotionValue` is updated.
@@ -67,29 +92,42 @@ class l {
    *
    * @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 c());
-    const i = this.events[t].add(e);
-    return t === "change" ? () => {
-      i(), f.read(() => {
-        this.events.change.getSize() || this.stop();
-      });
-    } : i;
+  onChange(subscription) {
+    if (process.env.NODE_ENV !== "production") {
+      warnOnce(false, `value.onChange(callback) is deprecated. Switch to value.on("change", callback).`);
+    }
+    return this.on("change", subscription);
+  }
+  on(eventName, callback) {
+    if (!this.events[eventName]) {
+      this.events[eventName] = new SubscriptionManager();
+    }
+    const unsubscribe = this.events[eventName].add(callback);
+    if (eventName === "change") {
+      return () => {
+        unsubscribe();
+        frame.read(() => {
+          if (!this.events.change.getSize()) {
+            this.stop();
+          }
+        });
+      };
+    }
+    return unsubscribe;
   }
   clearListeners() {
-    for (const t in this.events)
-      this.events[t].clear();
+    for (const eventManagers in this.events) {
+      this.events[eventManagers].clear();
+    }
   }
   /**
    * Attaches a passive effect to the `MotionValue`.
    *
    * @internal
    */
-  attach(t, e) {
-    this.passiveEffect = t, this.stopPassiveEffect = e;
+  attach(passiveEffect, stopPassiveEffect) {
+    this.passiveEffect = passiveEffect;
+    this.stopPassiveEffect = stopPassiveEffect;
   }
   /**
    * Sets the state of the `MotionValue`.
@@ -106,18 +144,30 @@ class l {
    *
    * @public
    */
-  set(t, e = !0) {
-    !e || !this.passiveEffect ? this.updateAndNotify(t, e) : this.passiveEffect(t, this.updateAndNotify);
+  set(v, render = true) {
+    if (!render || !this.passiveEffect) {
+      this.updateAndNotify(v, render);
+    } else {
+      this.passiveEffect(v, this.updateAndNotify);
+    }
   }
-  setWithVelocity(t, e, i) {
-    this.set(e), this.prev = void 0, this.prevFrameValue = t, this.prevUpdatedAt = this.updatedAt - i;
+  setWithVelocity(prev, current, delta) {
+    this.set(current);
+    this.prev = void 0;
+    this.prevFrameValue = prev;
+    this.prevUpdatedAt = this.updatedAt - delta;
   }
   /**
    * 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();
+  jump(v, endAnimation = true) {
+    this.updateAndNotify(v);
+    this.prev = v;
+    this.prevUpdatedAt = this.prevFrameValue = void 0;
+    endAnimation && this.stop();
+    if (this.stopPassiveEffect)
+      this.stopPassiveEffect();
   }
   /**
    * Returns the latest state of `MotionValue`
@@ -127,7 +177,10 @@ class l {
    * @public
    */
   get() {
-    return a.current && a.current.push(this), this.current;
+    if (collectMotionValues.current) {
+      collectMotionValues.current.push(this);
+    }
+    return this.current;
   }
   /**
    * @public
@@ -143,11 +196,12 @@ class l {
    * @public
    */
   getVelocity() {
-    const t = n.now();
-    if (!this.canTrackVelocity || this.prevFrameValue === void 0 || t - this.updatedAt > r)
+    const currentTime = time.now();
+    if (!this.canTrackVelocity || this.prevFrameValue === void 0 || currentTime - this.updatedAt > MAX_VELOCITY_DELTA) {
       return 0;
-    const e = Math.min(this.updatedAt - this.prevUpdatedAt, r);
-    return u(parseFloat(this.current) - parseFloat(this.prevFrameValue), e);
+    }
+    const delta = Math.min(this.updatedAt - this.prevUpdatedAt, MAX_VELOCITY_DELTA);
+    return velocityPerSecond(parseFloat(this.current) - parseFloat(this.prevFrameValue), delta);
   }
   /**
    * Registers a new animation to control this `MotionValue`. Only one
@@ -161,11 +215,19 @@ class l {
    *
    * @internal
    */
-  start(t) {
-    return this.stop(), new Promise((e) => {
-      this.hasAnimated = !0, this.animation = t(e), this.events.animationStart && this.events.animationStart.notify();
+  start(startAnimation) {
+    this.stop();
+    return new Promise((resolve) => {
+      this.hasAnimated = true;
+      this.animation = startAnimation(resolve);
+      if (this.events.animationStart) {
+        this.events.animationStart.notify();
+      }
     }).then(() => {
-      this.events.animationComplete && this.events.animationComplete.notify(), this.clearAnimation();
+      if (this.events.animationComplete) {
+        this.events.animationComplete.notify();
+      }
+      this.clearAnimation();
     });
   }
   /**
@@ -174,7 +236,13 @@ class l {
    * @public
    */
   stop() {
-    this.animation && (this.animation.stop(), this.events.animationCancel && this.events.animationCancel.notify()), this.clearAnimation();
+    if (this.animation) {
+      this.animation.stop();
+      if (this.events.animationCancel) {
+        this.events.animationCancel.notify();
+      }
+    }
+    this.clearAnimation();
   }
   /**
    * Returns `true` if this value is currently animating.
@@ -197,14 +265,18 @@ class l {
    * @public
    */
   destroy() {
-    this.clearListeners(), this.stop(), this.stopPassiveEffect && this.stopPassiveEffect();
+    this.clearListeners();
+    this.stop();
+    if (this.stopPassiveEffect) {
+      this.stopPassiveEffect();
+    }
   }
 }
-function g(s, t) {
-  return new l(s, t);
+function motionValue(init, options) {
+  return new MotionValue(init, options);
 }
 export {
-  l as MotionValue,
-  a as collectMotionValues,
-  g as motionValue
+  MotionValue,
+  collectMotionValues,
+  motionValue
 };

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/value/types/color/hex.mjs

@@ -1,19 +1,37 @@
-import { rgba as i } from "./rgba.mjs";
-import { isColorString as g } from "./utils.mjs";
-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
+import { rgba } from "./rgba.mjs";
+import { isColorString } from "./utils.mjs";
+function parseHex(v) {
+  let r = "";
+  let g = "";
+  let b = "";
+  let a = "";
+  if (v.length > 5) {
+    r = v.substring(1, 3);
+    g = v.substring(3, 5);
+    b = v.substring(5, 7);
+    a = v.substring(7, 9);
+  } else {
+    r = v.substring(1, 2);
+    g = v.substring(2, 3);
+    b = v.substring(3, 4);
+    a = v.substring(4, 5);
+    r += r;
+    g += g;
+    b += b;
+    a += a;
+  }
+  return {
+    red: parseInt(r, 16),
+    green: parseInt(g, 16),
+    blue: parseInt(b, 16),
+    alpha: a ? parseInt(a, 16) / 255 : 1
   };
 }
-const u = {
-  test: /* @__PURE__ */ g("#"),
-  parse: a,
-  transform: i.transform
+const hex = {
+  test: /* @__PURE__ */ isColorString("#"),
+  parse: parseHex,
+  transform: rgba.transform
 };
 export {
-  u as hex
+  hex
 };

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/value/types/color/hsla.mjs

@@ -1,12 +1,14 @@
-import { alpha as n } from "../numbers/index.mjs";
-import { percent as t } from "../numbers/units.mjs";
-import { sanitize as r } from "../utils/sanitize.mjs";
-import { isColorString as i, splitColor as e } from "./utils.mjs";
-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)) + ")"
+import { alpha } from "../numbers/index.mjs";
+import { percent } from "../numbers/units.mjs";
+import { sanitize } from "../utils/sanitize.mjs";
+import { isColorString, splitColor } from "./utils.mjs";
+const hsla = {
+  test: /* @__PURE__ */ isColorString("hsl", "hue"),
+  parse: /* @__PURE__ */ splitColor("hue", "saturation", "lightness"),
+  transform: ({ hue, saturation, lightness, alpha: alpha$1 = 1 }) => {
+    return "hsla(" + Math.round(hue) + ", " + percent.transform(sanitize(saturation)) + ", " + percent.transform(sanitize(lightness)) + ", " + sanitize(alpha.transform(alpha$1)) + ")";
+  }
 };
 export {
-  u as hsla
+  hsla
 };

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/value/types/color/index.mjs

@@ -1,11 +1,21 @@
-import { hex as s } from "./hex.mjs";
-import { hsla as t } from "./hsla.mjs";
-import { rgba as e } from "./rgba.mjs";
-const p = {
-  test: (r) => e.test(r) || s.test(r) || t.test(r),
-  parse: (r) => e.test(r) ? e.parse(r) : t.test(r) ? t.parse(r) : s.parse(r),
-  transform: (r) => typeof r == "string" ? r : r.hasOwnProperty("red") ? e.transform(r) : t.transform(r)
+import { hex } from "./hex.mjs";
+import { hsla } from "./hsla.mjs";
+import { rgba } from "./rgba.mjs";
+const color = {
+  test: (v) => rgba.test(v) || hex.test(v) || hsla.test(v),
+  parse: (v) => {
+    if (rgba.test(v)) {
+      return rgba.parse(v);
+    } else if (hsla.test(v)) {
+      return hsla.parse(v);
+    } else {
+      return hex.parse(v);
+    }
+  },
+  transform: (v) => {
+    return typeof v === "string" ? v : v.hasOwnProperty("red") ? rgba.transform(v) : hsla.transform(v);
+  }
 };
 export {
-  p as color
+  color
 };

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/value/types/color/rgba.mjs

@@ -1,16 +1,18 @@
-import { clamp as n } from "../../../utils/clamp.mjs";
-import { number as s, alpha as i } from "../numbers/index.mjs";
-import { sanitize as p } from "../utils/sanitize.mjs";
-import { isColorString as e, splitColor as f } from "./utils.mjs";
-const l = (r) => n(0, 255, r), o = {
-  ...s,
-  transform: (r) => Math.round(l(r))
-}, h = {
-  test: /* @__PURE__ */ e("rgb", "red"),
-  parse: /* @__PURE__ */ f("red", "green", "blue"),
-  transform: ({ red: r, green: t, blue: a, alpha: m = 1 }) => "rgba(" + o.transform(r) + ", " + o.transform(t) + ", " + o.transform(a) + ", " + p(i.transform(m)) + ")"
+import { clamp } from "../../../utils/clamp.mjs";
+import { number, alpha } from "../numbers/index.mjs";
+import { sanitize } from "../utils/sanitize.mjs";
+import { isColorString, splitColor } from "./utils.mjs";
+const clampRgbUnit = (v) => clamp(0, 255, v);
+const rgbUnit = {
+  ...number,
+  transform: (v) => Math.round(clampRgbUnit(v))
+};
+const rgba = {
+  test: /* @__PURE__ */ isColorString("rgb", "red"),
+  parse: /* @__PURE__ */ splitColor("red", "green", "blue"),
+  transform: ({ red, green, blue, alpha: alpha$1 = 1 }) => "rgba(" + rgbUnit.transform(red) + ", " + rgbUnit.transform(green) + ", " + rgbUnit.transform(blue) + ", " + sanitize(alpha.transform(alpha$1)) + ")"
 };
 export {
-  o as rgbUnit,
-  h as rgba
+  rgbUnit,
+  rgba
 };

package/dist/es/node_modules/.pnpm/framer-motion@11.11.11/node_modules/framer-motion/dist/es/value/types/color/utils.mjs

@@ -1,18 +1,21 @@
-import { floatRegex as i } from "../utils/float-regex.mjs";
-import { isNullish as n } from "../utils/is-nullish.mjs";
-import { singleColorRegex as f } from "../utils/single-color-regex.mjs";
-const h = (r, o) => (t) => !!(typeof t == "string" && f.test(t) && t.startsWith(r) || o && !n(t) && Object.prototype.hasOwnProperty.call(t, o)), u = (r, o, t) => (e) => {
-  if (typeof e != "string")
-    return e;
-  const [l, s, p, a] = e.match(i);
+import { floatRegex } from "../utils/float-regex.mjs";
+import { isNullish } from "../utils/is-nullish.mjs";
+import { singleColorRegex } from "../utils/single-color-regex.mjs";
+const isColorString = (type, testProp) => (v) => {
+  return Boolean(typeof v === "string" && singleColorRegex.test(v) && v.startsWith(type) || testProp && !isNullish(v) && Object.prototype.hasOwnProperty.call(v, testProp));
+};
+const splitColor = (aName, bName, cName) => (v) => {
+  if (typeof v !== "string")
+    return v;
+  const [a, b, c, alpha] = v.match(floatRegex);
   return {
-    [r]: parseFloat(l),
-    [o]: parseFloat(s),
-    [t]: parseFloat(p),
-    alpha: a !== void 0 ? parseFloat(a) : 1
+    [aName]: parseFloat(a),
+    [bName]: parseFloat(b),
+    [cName]: parseFloat(c),
+    alpha: alpha !== void 0 ? parseFloat(alpha) : 1
   };
 };
 export {
-  h as isColorString,
-  u as splitColor
+  isColorString,
+  splitColor
 };