@t-headless-ui/react 1.1.2 → 1.1.3

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/projection/styles/scale-border-radius.mjs

@@ -0,0 +1,21 @@
+import { px as c } from "../../value/types/numbers/units.mjs";
+function e(r, n) {
+  return n.max === n.min ? 0 : r / (n.max - n.min) * 100;
+}
+const f = {
+  correct: (r, n) => {
+    if (!n.target)
+      return r;
+    if (typeof r == "string")
+      if (c.test(r))
+        r = parseFloat(r);
+      else
+        return r;
+    const o = e(r, n.target.x), t = e(r, n.target.y);
+    return `${o}% ${t}%`;
+  }
+};
+export {
+  f as correctBorderRadius,
+  e as pixelsToPercent
+};

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/projection/styles/scale-box-shadow.mjs

@@ -0,0 +1,16 @@
+import { complex as f } from "../../value/types/complex/index.mjs";
+import { mixNumber as i } from "../../utils/mix/number.mjs";
+const y = {
+  correct: (e, { treeScale: c, projectionDelta: t }) => {
+    const a = e, o = f.parse(e);
+    if (o.length > 5)
+      return a;
+    const p = f.createTransformer(e), r = typeof o[0] != "number" ? 1 : 0, n = t.x.scale * c.x, m = t.y.scale * c.y;
+    o[0 + r] /= n, o[1 + r] /= m;
+    const s = i(n, m, 0.5);
+    return typeof o[2 + r] == "number" && (o[2 + r] /= s), typeof o[3 + r] == "number" && (o[3 + r] /= s), p(o);
+  }
+};
+export {
+  y as correctBoxShadow
+};

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/projection/styles/scale-correction.mjs

@@ -0,0 +1,21 @@
+import { correctBorderRadius as o } from "./scale-border-radius.mjs";
+import { correctBoxShadow as r } from "./scale-box-shadow.mjs";
+const e = {
+  borderRadius: {
+    ...o,
+    applyTo: [
+      "borderTopLeftRadius",
+      "borderTopRightRadius",
+      "borderBottomLeftRadius",
+      "borderBottomRightRadius"
+    ]
+  },
+  borderTopLeftRadius: o,
+  borderTopRightRadius: o,
+  borderBottomLeftRadius: o,
+  borderBottomRightRadius: o,
+  boxShadow: r
+};
+export {
+  e as scaleCorrectors
+};

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/projection/utils/flat-tree.mjs

@@ -0,0 +1,19 @@
+import { compareByDepth as t } from "./compare-by-depth.mjs";
+import { addUniqueItem as r, removeItem as e } from "../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/array.mjs";
+class c {
+  constructor() {
+    this.children = [], this.isDirty = !1;
+  }
+  add(i) {
+    r(this.children, i), this.isDirty = !0;
+  }
+  remove(i) {
+    e(this.children, i), this.isDirty = !0;
+  }
+  forEach(i) {
+    this.isDirty && this.children.sort(t), this.isDirty = !1, this.children.forEach(i);
+  }
+}
+export {
+  c as FlatTree
+};

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/render/VisualElement.mjs

@@ -0,0 +1,247 @@
+import { microtask as C } from "../frameloop/microtask.mjs";
+import { time as M } from "../frameloop/sync-time.mjs";
+import { motionValue as S } from "../value/index.mjs";
+import { isMotionValue as h } from "../value/utils/is-motion-value.mjs";
+import { KeyframeResolver as b } from "../animation/keyframes/KeyframesResolver.mjs";
+import { transformProps as T } from "./utils/keys-transform.mjs";
+import { complex as w } from "../value/types/complex/index.mjs";
+import { findValueType as P } from "../value/types/utils/find.mjs";
+import { getAnimatableNone as F } from "../value/types/utils/animatable-none.mjs";
+import { createBox as A } from "../projection/geometry/models.mjs";
+import { initPrefersReducedMotion as R } from "./utils/reduced-motion/index.mjs";
+import { visualElementStore as B } from "./store.mjs";
+import { isControllingVariants as N, isVariantNode as E } from "./utils/is-controlling-variants.mjs";
+import { updateMotionValuesFromProps as x } from "./utils/motion-values.mjs";
+import { resolveVariantFromProps as j } from "./utils/resolve-variants.mjs";
+import { hasReducedMotionListener as y, prefersReducedMotion as I } from "./utils/reduced-motion/state.mjs";
+import { frame as f, cancelFrame as c } from "../frameloop/frame.mjs";
+import { warnOnce as D } from "../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/warn-once.mjs";
+import { isNumericalString as U } from "../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/is-numerical-string.mjs";
+import { isZeroValueString as L } from "../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/is-zero-value-string.mjs";
+import { SubscriptionManager as O } from "../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/subscription-manager.mjs";
+const m = [
+  "AnimationStart",
+  "AnimationComplete",
+  "Update",
+  "BeforeLayoutMeasure",
+  "LayoutMeasure",
+  "LayoutAnimationStart",
+  "LayoutAnimationComplete"
+];
+let u = {};
+function ht(l) {
+  u = l;
+}
+function ut() {
+  return u;
+}
+class lt {
+  /**
+   * This method takes React props and returns found MotionValues. For example, HTML
+   * MotionValues will be found within the style prop, whereas for Three.js within attribute arrays.
+   *
+   * This isn't an abstract method as it needs calling in the constructor, but it is
+   * intended to be one.
+   */
+  scrapeMotionValuesFromProps(t, e, i) {
+    return {};
+  }
+  constructor({ parent: t, props: e, presenceContext: i, reducedMotionConfig: s, skipAnimations: r, blockInitialAnimation: n, visualState: V }, v = {}) {
+    this.current = null, this.children = /* @__PURE__ */ new Set(), this.isVariantNode = !1, this.isControllingVariants = !1, this.shouldReduceMotion = null, this.shouldSkipAnimations = !1, this.values = /* @__PURE__ */ new Map(), this.KeyframeResolver = b, this.features = {}, this.valueSubscriptions = /* @__PURE__ */ new Map(), this.prevMotionValues = {}, this.events = {}, this.propEventSubscriptions = {}, this.notifyUpdate = () => this.notify("Update", this.latestValues), this.render = () => {
+      this.current && (this.triggerBuild(), this.renderInstance(this.current, this.renderState, this.props.style, this.projection));
+    }, this.renderScheduledAt = 0, this.scheduleRender = () => {
+      const o = M.now();
+      this.renderScheduledAt < o && (this.renderScheduledAt = o, f.render(this.render, !1, !0));
+    };
+    const { latestValues: a, renderState: g } = V;
+    this.latestValues = a, this.baseTarget = { ...a }, this.initialValues = e.initial ? { ...a } : {}, this.renderState = g, this.parent = t, this.props = e, this.presenceContext = i, this.depth = t ? t.depth + 1 : 0, this.reducedMotionConfig = s, this.skipAnimationsConfig = r, this.options = v, this.blockInitialAnimation = !!n, this.isControllingVariants = N(e), this.isVariantNode = E(e), this.isVariantNode && (this.variantChildren = /* @__PURE__ */ new Set()), this.manuallyAnimateOnMount = !!(t && t.current);
+    const { willChange: _, ...d } = this.scrapeMotionValuesFromProps(e, {}, this);
+    for (const o in d) {
+      const p = d[o];
+      a[o] !== void 0 && h(p) && p.set(a[o]);
+    }
+  }
+  mount(t) {
+    var e;
+    this.current = t, B.set(t, this), this.projection && !this.projection.instance && this.projection.mount(t), this.parent && this.isVariantNode && !this.isControllingVariants && (this.removeFromVariantTree = this.parent.addVariantChild(this)), this.values.forEach((i, s) => this.bindToMotionValue(s, i)), this.reducedMotionConfig === "never" ? this.shouldReduceMotion = !1 : this.reducedMotionConfig === "always" ? this.shouldReduceMotion = !0 : (y.current || R(), this.shouldReduceMotion = I.current), process.env.NODE_ENV !== "production" && D(this.shouldReduceMotion !== !0, "You have Reduced Motion enabled on your device. Animations may not appear as expected.", "reduced-motion-disabled"), this.shouldSkipAnimations = this.skipAnimationsConfig ?? !1, (e = this.parent) == null || e.addChild(this), this.update(this.props, this.presenceContext);
+  }
+  unmount() {
+    var t;
+    this.projection && this.projection.unmount(), c(this.notifyUpdate), c(this.render), this.valueSubscriptions.forEach((e) => e()), this.valueSubscriptions.clear(), this.removeFromVariantTree && this.removeFromVariantTree(), (t = this.parent) == null || t.removeChild(this);
+    for (const e in this.events)
+      this.events[e].clear();
+    for (const e in this.features) {
+      const i = this.features[e];
+      i && (i.unmount(), i.isMounted = !1);
+    }
+    this.current = null;
+  }
+  addChild(t) {
+    this.children.add(t), this.enteringChildren ?? (this.enteringChildren = /* @__PURE__ */ new Set()), this.enteringChildren.add(t);
+  }
+  removeChild(t) {
+    this.children.delete(t), this.enteringChildren && this.enteringChildren.delete(t);
+  }
+  bindToMotionValue(t, e) {
+    this.valueSubscriptions.has(t) && this.valueSubscriptions.get(t)();
+    const i = T.has(t);
+    i && this.onBindTransform && this.onBindTransform();
+    const s = e.on("change", (n) => {
+      this.latestValues[t] = n, this.props.onUpdate && f.preRender(this.notifyUpdate), i && this.projection && (this.projection.isTransformDirty = !0), this.scheduleRender();
+    });
+    let r;
+    typeof window < "u" && window.MotionCheckAppearSync && (r = window.MotionCheckAppearSync(this, t, e)), this.valueSubscriptions.set(t, () => {
+      s(), r && r(), e.owner && e.stop();
+    });
+  }
+  sortNodePosition(t) {
+    return !this.current || !this.sortInstanceNodePosition || this.type !== t.type ? 0 : this.sortInstanceNodePosition(this.current, t.current);
+  }
+  updateFeatures() {
+    let t = "animation";
+    for (t in u) {
+      const e = u[t];
+      if (!e)
+        continue;
+      const { isEnabled: i, Feature: s } = e;
+      if (!this.features[t] && s && i(this.props) && (this.features[t] = new s(this)), this.features[t]) {
+        const r = this.features[t];
+        r.isMounted ? r.update() : (r.mount(), r.isMounted = !0);
+      }
+    }
+  }
+  triggerBuild() {
+    this.build(this.renderState, this.latestValues, this.props);
+  }
+  /**
+   * Measure the current viewport box with or without transforms.
+   * Only measures axis-aligned boxes, rotate and skew must be manually
+   * removed with a re-render to work.
+   */
+  measureViewportBox() {
+    return this.current ? this.measureInstanceViewportBox(this.current, this.props) : A();
+  }
+  getStaticValue(t) {
+    return this.latestValues[t];
+  }
+  setStaticValue(t, e) {
+    this.latestValues[t] = e;
+  }
+  /**
+   * Update the provided props. Ensure any newly-added motion values are
+   * added to our map, old ones removed, and listeners updated.
+   */
+  update(t, e) {
+    (t.transformTemplate || this.props.transformTemplate) && this.scheduleRender(), this.prevProps = this.props, this.props = t, this.prevPresenceContext = this.presenceContext, this.presenceContext = e;
+    for (let i = 0; i < m.length; i++) {
+      const s = m[i];
+      this.propEventSubscriptions[s] && (this.propEventSubscriptions[s](), delete this.propEventSubscriptions[s]);
+      const r = "on" + s, n = t[r];
+      n && (this.propEventSubscriptions[s] = this.on(s, n));
+    }
+    this.prevMotionValues = x(this, this.scrapeMotionValuesFromProps(t, this.prevProps || {}, this), this.prevMotionValues), this.handleChildMotionValue && this.handleChildMotionValue();
+  }
+  getProps() {
+    return this.props;
+  }
+  /**
+   * Returns the variant definition with a given name.
+   */
+  getVariant(t) {
+    return this.props.variants ? this.props.variants[t] : void 0;
+  }
+  /**
+   * Returns the defined default transition on this component.
+   */
+  getDefaultTransition() {
+    return this.props.transition;
+  }
+  getTransformPagePoint() {
+    return this.props.transformPagePoint;
+  }
+  getClosestVariantNode() {
+    return this.isVariantNode ? this : this.parent ? this.parent.getClosestVariantNode() : void 0;
+  }
+  /**
+   * Add a child visual element to our set of children.
+   */
+  addVariantChild(t) {
+    const e = this.getClosestVariantNode();
+    if (e)
+      return e.variantChildren && e.variantChildren.add(t), () => e.variantChildren.delete(t);
+  }
+  /**
+   * Add a motion value and bind it to this visual element.
+   */
+  addValue(t, e) {
+    const i = this.values.get(t);
+    e !== i && (i && this.removeValue(t), this.bindToMotionValue(t, e), this.values.set(t, e), this.latestValues[t] = e.get());
+  }
+  /**
+   * Remove a motion value and unbind any active subscriptions.
+   */
+  removeValue(t) {
+    this.values.delete(t);
+    const e = this.valueSubscriptions.get(t);
+    e && (e(), this.valueSubscriptions.delete(t)), delete this.latestValues[t], this.removeValueFromRenderState(t, this.renderState);
+  }
+  /**
+   * Check whether we have a motion value for this key
+   */
+  hasValue(t) {
+    return this.values.has(t);
+  }
+  getValue(t, e) {
+    if (this.props.values && this.props.values[t])
+      return this.props.values[t];
+    let i = this.values.get(t);
+    return i === void 0 && e !== void 0 && (i = S(e === null ? void 0 : e, { owner: this }), this.addValue(t, i)), i;
+  }
+  /**
+   * If we're trying to animate to a previously unencountered value,
+   * we need to check for it in our state and as a last resort read it
+   * directly from the instance (which might have performance implications).
+   */
+  readValue(t, e) {
+    let i = this.latestValues[t] !== void 0 || !this.current ? this.latestValues[t] : this.getBaseTargetFromProps(this.props, t) ?? this.readValueFromInstance(this.current, t, this.options);
+    return i != null && (typeof i == "string" && (U(i) || L(i)) ? i = parseFloat(i) : !P(i) && w.test(e) && (i = F(t, e)), this.setBaseTarget(t, h(i) ? i.get() : i)), h(i) ? i.get() : i;
+  }
+  /**
+   * Set the base target to later animate back to. This is currently
+   * only hydrated on creation and when we first read a value.
+   */
+  setBaseTarget(t, e) {
+    this.baseTarget[t] = e;
+  }
+  /**
+   * Find the base target for a value thats been removed from all animation
+   * props.
+   */
+  getBaseTarget(t) {
+    var r;
+    const { initial: e } = this.props;
+    let i;
+    if (typeof e == "string" || typeof e == "object") {
+      const n = j(this.props, e, (r = this.presenceContext) == null ? void 0 : r.custom);
+      n && (i = n[t]);
+    }
+    if (e && i !== void 0)
+      return i;
+    const s = this.getBaseTargetFromProps(this.props, t);
+    return s !== void 0 && !h(s) ? s : this.initialValues[t] !== void 0 && i === void 0 ? void 0 : this.baseTarget[t];
+  }
+  on(t, e) {
+    return this.events[t] || (this.events[t] = new O()), this.events[t].add(e);
+  }
+  notify(t, ...e) {
+    this.events[t] && this.events[t].notify(...e);
+  }
+  scheduleRenderMicrotask() {
+    C.render(this.render);
+  }
+}
+export {
+  lt as VisualElement,
+  ut as getFeatureDefinitions,
+  ht as setFeatureDefinitions
+};

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/render/dom/DOMVisualElement.mjs

@@ -0,0 +1,28 @@
+import { isMotionValue as r } from "../../value/utils/is-motion-value.mjs";
+import { DOMKeyframesResolver as o } from "../../animation/keyframes/DOMKeyframesResolver.mjs";
+import { VisualElement as s } from "../VisualElement.mjs";
+class a extends s {
+  constructor() {
+    super(...arguments), this.KeyframeResolver = o;
+  }
+  sortInstanceNodePosition(e, t) {
+    return e.compareDocumentPosition(t) & 2 ? 1 : -1;
+  }
+  getBaseTargetFromProps(e, t) {
+    const i = e.style;
+    return i ? i[t] : void 0;
+  }
+  removeValueFromRenderState(e, { vars: t, style: i }) {
+    delete t[e], delete i[e];
+  }
+  handleChildMotionValue() {
+    this.childSubscription && (this.childSubscription(), delete this.childSubscription);
+    const { children: e } = this.props;
+    r(e) && (this.childSubscription = e.on("change", (t) => {
+      this.current && (this.current.textContent = `${t}`);
+    }));
+  }
+}
+export {
+  a as DOMVisualElement
+};

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/render/dom/parse-transform.mjs

@@ -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/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/render/dom/utils/camel-to-dash.mjs

@@ -0,0 +1,6 @@
+function r(e) {
+  return e.replace(/([A-Z])/g, (o) => `-${o.toLowerCase()}`);
+}
+export {
+  r as camelToDash
+};

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/render/html/HTMLVisualElement.mjs

@@ -0,0 +1,38 @@
+import { isCSSVariableName as n } from "../../animation/utils/is-css-variable.mjs";
+import { transformProps as a } from "../utils/keys-transform.mjs";
+import { defaultTransformValue as i, readTransformValue as u } from "../dom/parse-transform.mjs";
+import { measureViewportBox as p } from "../../projection/utils/measure.mjs";
+import { DOMVisualElement as l } from "../dom/DOMVisualElement.mjs";
+import { buildHTMLStyles as f } from "./utils/build-styles.mjs";
+import { renderHTML as c } from "./utils/render.mjs";
+import { scrapeMotionValuesFromProps as d } from "./utils/scrape-motion-values.mjs";
+function V(m) {
+  return window.getComputedStyle(m);
+}
+class b extends l {
+  constructor() {
+    super(...arguments), this.type = "html", this.renderInstance = c;
+  }
+  readValueFromInstance(e, r) {
+    var t;
+    if (a.has(r))
+      return (t = this.projection) != null && t.isProjecting ? i(r) : u(e, r);
+    {
+      const s = V(e), o = (n(r) ? s.getPropertyValue(r) : s[r]) || 0;
+      return typeof o == "string" ? o.trim() : o;
+    }
+  }
+  measureInstanceViewportBox(e, { transformPagePoint: r }) {
+    return p(e, r);
+  }
+  build(e, r, t) {
+    f(e, r, t.transformTemplate);
+  }
+  scrapeMotionValuesFromProps(e, r, t) {
+    return d(e, r, t);
+  }
+}
+export {
+  b as HTMLVisualElement,
+  V as getComputedStyle
+};

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/render/html/utils/build-styles.mjs

@@ -0,0 +1,29 @@
+import { getValueAsType as p } from "../../../value/types/utils/get-as-type.mjs";
+import { numberValueTypes as u } from "../../../value/types/maps/number.mjs";
+import { transformProps as c } from "../../utils/keys-transform.mjs";
+import { isCSSVariableName as g } from "../../../animation/utils/is-css-variable.mjs";
+import { buildTransform as y } from "./build-transform.mjs";
+function S(f, i, e) {
+  const { style: o, vars: l, transformOrigin: t } = f;
+  let m = !1, a = !1;
+  for (const r in i) {
+    const n = i[r];
+    if (c.has(r)) {
+      m = !0;
+      continue;
+    } else if (g(r)) {
+      l[r] = n;
+      continue;
+    } else {
+      const s = p(n, u[r]);
+      r.startsWith("origin") ? (a = !0, t[r] = s) : o[r] = s;
+    }
+  }
+  if (i.transform || (m || e ? o.transform = y(i, f.transform, e) : o.transform && (o.transform = "none")), a) {
+    const { originX: r = "50%", originY: n = "50%", originZ: s = 0 } = t;
+    o.transformOrigin = `${r} ${n} ${s}`;
+  }
+}
+export {
+  S as buildHTMLStyles
+};

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/render/html/utils/build-transform.mjs

@@ -0,0 +1,37 @@
+import { getValueAsType as m } from "../../../value/types/utils/get-as-type.mjs";
+import { numberValueTypes as p } from "../../../value/types/maps/number.mjs";
+import { transformPropOrder as f } from "../../utils/keys-transform.mjs";
+const y = {
+  x: "translateX",
+  y: "translateY",
+  z: "translateZ",
+  transformPerspective: "perspective"
+}, d = f.length;
+function h(u, l, n) {
+  let e = "", o = !0;
+  for (let i = 0; i < d; i++) {
+    const t = f[i], r = u[t];
+    if (r === void 0)
+      continue;
+    let a = !0;
+    if (typeof r == "number")
+      a = r === (t.startsWith("scale") ? 1 : 0);
+    else {
+      const s = parseFloat(r);
+      a = t.startsWith("scale") ? s === 1 : s === 0;
+    }
+    if (!a || n) {
+      const s = m(r, p[t]);
+      if (!a) {
+        o = !1;
+        const c = y[t] || t;
+        e += `${c}(${s}) `;
+      }
+      n && (l[t] = s);
+    }
+  }
+  return e = e.trim(), n ? e = n(l, o ? "" : e) : o && (e = "none"), e;
+}
+export {
+  h as buildTransform
+};

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/render/html/utils/render.mjs

@@ -0,0 +1,12 @@
+function s(f, { style: y, vars: n }, r, t) {
+  const l = f.style;
+  let e;
+  for (e in y)
+    l[e] = y[e];
+  t == null || t.applyProjectionStyles(l, r);
+  for (e in n)
+    l.setProperty(e, n[e]);
+}
+export {
+  s as renderHTML
+};

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/render/html/utils/scrape-motion-values.mjs

@@ -0,0 +1,14 @@
+import { isMotionValue as y } from "../../../value/utils/is-motion-value.mjs";
+import { isForcedMotionValue as u } from "../../utils/is-forced-motion-value.mjs";
+function d(c, n, e) {
+  var r;
+  const t = c.style, f = n == null ? void 0 : n.style, i = {};
+  if (!t)
+    return i;
+  for (const o in t)
+    (y(t[o]) || f && y(f[o]) || u(o, c) || ((r = e == null ? void 0 : e.getValue(o)) == null ? void 0 : r.liveStyle) !== void 0) && (i[o] = t[o]);
+  return i;
+}
+export {
+  d as scrapeMotionValuesFromProps
+};

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/render/svg/SVGVisualElement.mjs

@@ -0,0 +1,40 @@
+import { transformProps as s } from "../utils/keys-transform.mjs";
+import { getDefaultValueType as a } from "../../value/types/maps/defaults.mjs";
+import { createBox as m } from "../../projection/geometry/models.mjs";
+import { DOMVisualElement as i } from "../dom/DOMVisualElement.mjs";
+import { camelToDash as u } from "../dom/utils/camel-to-dash.mjs";
+import { buildSVGAttrs as n } from "./utils/build-attrs.mjs";
+import { camelCaseAttributes as p } from "./utils/camel-case-attrs.mjs";
+import { isSVGTag as l } from "./utils/is-svg-tag.mjs";
+import { renderSVG as f } from "./utils/render.mjs";
+import { scrapeMotionValuesFromProps as V } from "./utils/scrape-motion-values.mjs";
+class A extends i {
+  constructor() {
+    super(...arguments), this.type = "svg", this.isSVGTag = !1, this.measureInstanceViewportBox = m;
+  }
+  getBaseTargetFromProps(t, r) {
+    return t[r];
+  }
+  readValueFromInstance(t, r) {
+    if (s.has(r)) {
+      const e = a(r);
+      return e && e.default || 0;
+    }
+    return r = p.has(r) ? r : u(r), t.getAttribute(r);
+  }
+  scrapeMotionValuesFromProps(t, r, e) {
+    return V(t, r, e);
+  }
+  build(t, r, e) {
+    n(t, r, this.isSVGTag, e.transformTemplate, e.style);
+  }
+  renderInstance(t, r, e, o) {
+    f(t, r, e, o);
+  }
+  mount(t) {
+    this.isSVGTag = l(t.tagName), super.mount(t);
+  }
+}
+export {
+  A as SVGVisualElement
+};

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/render/svg/utils/build-attrs.mjs

@@ -0,0 +1,32 @@
+import { buildHTMLStyles as c } from "../../html/utils/build-styles.mjs";
+import { buildSVGPath as B } from "./path.mjs";
+const b = [
+  "offsetDistance",
+  "offsetPath",
+  "offsetRotate",
+  "offsetAnchor"
+];
+function g(r, {
+  attrX: e,
+  attrY: s,
+  attrScale: t,
+  pathLength: d,
+  pathSpacing: m = 1,
+  pathOffset: l = 0,
+  // This is object creation, which we try to avoid per-frame.
+  ...a
+}, u, x, n) {
+  if (c(r, a, x), u) {
+    r.style.viewBox && (r.attrs.viewBox = r.style.viewBox);
+    return;
+  }
+  r.attrs = r.style, r.style = {};
+  const { attrs: f, style: i } = r;
+  f.transform && (i.transform = f.transform, delete f.transform), (i.transform || f.transformOrigin) && (i.transformOrigin = f.transformOrigin ?? "50% 50%", delete f.transformOrigin), i.transform && (i.transformBox = (n == null ? void 0 : n.transformBox) ?? "fill-box", delete f.transformBox);
+  for (const o of b)
+    f[o] !== void 0 && (i[o] = f[o], delete f[o]);
+  e !== void 0 && (f.x = e), s !== void 0 && (f.y = s), t !== void 0 && (f.scale = t), d !== void 0 && B(f, d, m, l, !1);
+}
+export {
+  g as buildSVGAttrs
+};

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/render/svg/utils/path.mjs

@@ -0,0 +1,15 @@
+const f = {
+  offset: "stroke-dashoffset",
+  array: "stroke-dasharray"
+}, h = {
+  offset: "strokeDashoffset",
+  array: "strokeDasharray"
+};
+function y(s, e, o = 1, r = 0, t = !0) {
+  s.pathLength = 1;
+  const a = t ? f : h;
+  s[a.offset] = `${-r}`, s[a.array] = `${e} ${o}`;
+}
+export {
+  y as buildSVGPath
+};

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/render/svg/utils/scrape-motion-values.mjs

@@ -0,0 +1,15 @@
+import { isMotionValue as n } from "../../../value/utils/is-motion-value.mjs";
+import { transformPropOrder as i } from "../../utils/keys-transform.mjs";
+import { scrapeMotionValuesFromProps as m } from "../../html/utils/scrape-motion-values.mjs";
+function l(r, t, s) {
+  const e = m(r, t, s);
+  for (const o in r)
+    if (n(r[o]) || n(t[o])) {
+      const a = i.indexOf(o) !== -1 ? "attr" + o.charAt(0).toUpperCase() + o.substring(1) : o;
+      e[a] = r[o];
+    }
+  return e;
+}
+export {
+  l as scrapeMotionValuesFromProps
+};