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

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,15 @@
+function s(n, r, f) {
+  if (n == null)
+    return [];
+  if (n instanceof EventTarget)
+    return [n];
+  if (typeof n == "string") {
+    let u = document;
+    const i = (f == null ? void 0 : f[n]) ?? u.querySelectorAll(n);
+    return i ? Array.from(i) : [];
+  }
+  return Array.from(n).filter((u) => u != null);
+}
+export {
+  s 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/value/index.js

@@ -0,0 +1,215 @@
+import { time as n } from "../frameloop/sync-time.js";
+import { frame as d } from "../frameloop/frame.js";
+import { warnOnce as c } from "../../../../motion-utils/dist/es/warn-once.js";
+import { SubscriptionManager as p } from "../../../../motion-utils/dist/es/subscription-manager.js";
+import { velocityPerSecond as u } from "../../../../motion-utils/dist/es/velocity-per-second.js";
+const a = 30, f = (s) => !isNaN(parseFloat(s));
+class l {
+  /**
+   * @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 h = n.now();
+      if (this.updatedAt !== h && 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 o of this.dependents)
+          o.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 = f(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" && c(!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 p());
+    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 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 u(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 g(s, t) {
+  return new l(s, t);
+}
+export {
+  l as MotionValue,
+  g 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
+};

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

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

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

@@ -0,0 +1,18 @@
+import { floatRegex as i } from "../utils/float-regex.js";
+import { isNullish as n } from "../utils/is-nullish.js";
+import { singleColorRegex as f } from "../utils/single-color-regex.js";
+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);
+  return {
+    [r]: parseFloat(l),
+    [o]: parseFloat(s),
+    [t]: parseFloat(p),
+    alpha: a !== void 0 ? parseFloat(a) : 1
+  };
+};
+export {
+  h as isColorString,
+  u as splitColor
+};

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

@@ -0,0 +1,24 @@
+import { complex as c } from "./index.js";
+import { floatRegex as i } from "../utils/float-regex.js";
+const s = /* @__PURE__ */ new Set(["brightness", "contrast", "saturate", "opacity"]);
+function u(t) {
+  const [e, n] = t.slice(0, -1).split("(");
+  if (e === "drop-shadow")
+    return t;
+  const [o] = n.match(i) || [];
+  if (!o)
+    return t;
+  const r = n.replace(o, "");
+  let a = s.has(e) ? 1 : 0;
+  return o !== n && (a *= 100), e + "(" + a + r + ")";
+}
+const l = /\b([a-z-]*)\(.*?\)/gu, p = {
+  ...c,
+  getAnimatableNone: (t) => {
+    const e = t.match(l);
+    return e ? e.map(u).join(" ") : t;
+  }
+};
+export {
+  p as filter
+};

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

@@ -0,0 +1,49 @@
+import { color as u } from "../color/index.js";
+import { colorRegex as N } from "../utils/color-regex.js";
+import { floatRegex as d } from "../utils/float-regex.js";
+import { sanitize as b } from "../utils/sanitize.js";
+function x(t) {
+  var o, e;
+  return isNaN(t) && typeof t == "string" && (((o = t.match(d)) == null ? void 0 : o.length) || 0) + (((e = t.match(N)) == null ? void 0 : e.length) || 0) > 0;
+}
+const p = "number", m = "color", T = "var", O = "var(", a = "${}", R = /var\s*\(\s*--(?:[\w-]+\s*|[\w-]+\s*,(?:\s*[^)(\s]|\s*\((?:[^)(]|\([^)(]*\))*\))+\s*)\)|#[\da-f]{3,8}|(?:rgb|hsl)a?\((?:-?[\d.]+%?[,\s]+){2}-?[\d.]+%?\s*(?:[,/]\s*)?(?:\b\d+(?:\.\d+)?|\.\d+)?%?\)|-?(?:\d+(?:\.\d+)?|\.\d+)/giu;
+function f(t) {
+  const o = t.toString(), e = [], c = {
+    color: [],
+    number: [],
+    var: []
+  }, n = [];
+  let s = 0;
+  const l = o.replace(R, (i) => (u.test(i) ? (c.color.push(s), n.push(m), e.push(u.parse(i))) : i.startsWith(O) ? (c.var.push(s), n.push(T), e.push(i)) : (c.number.push(s), n.push(p), e.push(parseFloat(i))), ++s, a)).split(a);
+  return { values: e, split: l, indexes: c, types: n };
+}
+function h(t) {
+  return f(t).values;
+}
+function g(t) {
+  const { split: o, types: e } = f(t), c = o.length;
+  return (n) => {
+    let s = "";
+    for (let r = 0; r < c; r++)
+      if (s += o[r], n[r] !== void 0) {
+        const l = e[r];
+        l === p ? s += b(n[r]) : l === m ? s += u.transform(n[r]) : s += n[r];
+      }
+    return s;
+  };
+}
+const y = (t) => typeof t == "number" ? 0 : u.test(t) ? u.getAnimatableNone(t) : t;
+function E(t) {
+  const o = h(t);
+  return g(t)(o.map(y));
+}
+const S = {
+  test: x,
+  parse: h,
+  createTransformer: g,
+  getAnimatableNone: E
+};
+export {
+  f as analyseComplexValue,
+  S as complex
+};

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

@@ -0,0 +1,9 @@
+import { auto as o } from "./auto.js";
+import { number as r } from "./numbers/index.js";
+import { px as m, percent as t, degrees as i, vw as n, vh as p } from "./numbers/units.js";
+import { testValueType as s } from "./test.js";
+const f = [r, m, t, i, n, p, o], l = (e) => f.find(s(e));
+export {
+  f as dimensionValueTypes,
+  l as findDimensionValueType
+};

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

@@ -0,0 +1,8 @@
+import { number as r } from "./numbers/index.js";
+const t = {
+  ...r,
+  transform: Math.round
+};
+export {
+  t as int
+};

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

@@ -0,0 +1,24 @@
+import { color as o } from "../color/index.js";
+import { filter as r } from "../complex/filter.js";
+import { numberValueTypes as l } from "./number.js";
+const t = {
+  ...l,
+  // Color props
+  color: o,
+  backgroundColor: o,
+  outlineColor: o,
+  fill: o,
+  stroke: o,
+  // Border props
+  borderColor: o,
+  borderTopColor: o,
+  borderRightColor: o,
+  borderBottomColor: o,
+  borderLeftColor: o,
+  filter: r,
+  WebkitFilter: r
+}, m = (e) => t[e];
+export {
+  t as defaultValueTypes,
+  m as getDefaultValueType
+};