@intlayer/design-system 2.0.10 → 2.0.11

package/dist/motion-minimal-BFpJTMRN.js

@@ -0,0 +1,788 @@
+"use client";
+import { j as $ } from "./jsx-runtime-Tw_Kw2GZ.js";
+import { createContext as S, useLayoutEffect as St, useEffect as K, useContext as y, useRef as O, useInsertionEffect as Pt, useCallback as xt, useMemo as T, forwardRef as Vt, Fragment as Ct, createElement as Mt } from "react";
+const Q = S({
+  transformPagePoint: (t) => t,
+  isStatic: !1,
+  reducedMotion: "never"
+}), A = S({}), J = S(null), tt = typeof document < "u", Tt = tt ? St : K, et = S({ strict: !1 }), nt = (t) => t.replace(/([a-z])([A-Z])/gu, "$1-$2").toLowerCase(), At = "framerAppearId", Lt = "data-" + nt(At);
+class N {
+  constructor() {
+    this.order = [], this.scheduled = /* @__PURE__ */ new Set();
+  }
+  add(e) {
+    if (!this.scheduled.has(e))
+      return this.scheduled.add(e), this.order.push(e), !0;
+  }
+  remove(e) {
+    const n = this.order.indexOf(e);
+    n !== -1 && (this.order.splice(n, 1), this.scheduled.delete(e));
+  }
+  clear() {
+    this.order.length = 0, this.scheduled.clear();
+  }
+}
+function kt(t) {
+  let e = new N(), n = new N(), o = 0, r = !1, s = !1;
+  const c = /* @__PURE__ */ new WeakSet(), l = {
+    /**
+     * Schedule a process to run on the next frame.
+     */
+    schedule: (d, m = !1, u = !1) => {
+      const a = u && r, f = a ? e : n;
+      return m && c.add(d), f.add(d) && a && r && (o = e.order.length), d;
+    },
+    /**
+     * Cancel the provided callback from running on the next frame.
+     */
+    cancel: (d) => {
+      n.remove(d), c.delete(d);
+    },
+    /**
+     * Execute all schedule callbacks.
+     */
+    process: (d) => {
+      if (r) {
+        s = !0;
+        return;
+      }
+      if (r = !0, [e, n] = [n, e], n.clear(), o = e.order.length, o)
+        for (let m = 0; m < o; m++) {
+          const u = e.order[m];
+          c.has(u) && (l.schedule(u), t()), u(d);
+        }
+      r = !1, s && (s = !1, l.process(d));
+    }
+  };
+  return l;
+}
+const x = [
+  "read",
+  // Read
+  "resolveKeyframes",
+  // Write/Read/Write/Read
+  "update",
+  // Compute
+  "preRender",
+  // Compute
+  "render",
+  // Write
+  "postRender"
+  // Compute
+], Rt = 40;
+function rt(t, e) {
+  let n = !1, o = !0;
+  const r = {
+    delta: 0,
+    timestamp: 0,
+    isProcessing: !1
+  }, s = x.reduce((a, f) => (a[f] = kt(() => n = !0), a), {}), c = (a) => {
+    s[a].process(r);
+  }, l = () => {
+    const a = performance.now();
+    n = !1, r.delta = o ? 1e3 / 60 : Math.max(Math.min(a - r.timestamp, Rt), 1), r.timestamp = a, r.isProcessing = !0, x.forEach(c), r.isProcessing = !1, n && e && (o = !1, t(l));
+  }, d = () => {
+    n = !0, o = !0, r.isProcessing || t(l);
+  };
+  return { schedule: x.reduce((a, f) => {
+    const g = s[f];
+    return a[f] = (h, p = !1, D = !1) => (n || d(), g.schedule(h, p, D)), a;
+  }, {}), cancel: (a) => x.forEach((f) => s[f].cancel(a)), state: r, steps: s };
+}
+const { schedule: Ot, cancel: We } = rt(queueMicrotask, !1);
+function ot(t) {
+  return t && typeof t == "object" && Object.prototype.hasOwnProperty.call(t, "current");
+}
+const jt = S({});
+let _ = !1;
+function Et(t, e, n, o, r) {
+  const { visualElement: s } = y(A), c = y(et), l = y(J), d = y(Q).reducedMotion, m = O();
+  o = o || c.renderer, !m.current && o && (m.current = o(t, {
+    visualState: e,
+    parent: s,
+    props: n,
+    presenceContext: l,
+    blockInitialAnimation: l ? l.initial === !1 : !1,
+    reducedMotionConfig: d
+  }));
+  const u = m.current, a = y(jt);
+  u && !u.projection && r && (u.type === "html" || u.type === "svg") && Bt(m.current, n, r, a), Pt(() => {
+    u && u.update(n, l);
+  });
+  const f = O(!!(n[Lt] && !window.HandoffComplete));
+  return Tt(() => {
+    u && (u.updateFeatures(), Ot.render(u.render), f.current && u.animationState && u.animationState.animateChanges());
+  }), K(() => {
+    u && (!f.current && u.animationState && u.animationState.animateChanges(), f.current && (f.current = !1, _ || (_ = !0, queueMicrotask(Ft))));
+  }), u;
+}
+function Ft() {
+  window.HandoffComplete = !0;
+}
+function Bt(t, e, n, o) {
+  const { layoutId: r, layout: s, drag: c, dragConstraints: l, layoutScroll: d, layoutRoot: m } = e;
+  t.projection = new n(t.latestValues, e["data-framer-portal-id"] ? void 0 : st(t.parent)), t.projection.setOptions({
+    layoutId: r,
+    layout: s,
+    alwaysMeasureLayout: !!c || l && ot(l),
+    visualElement: t,
+    scheduleRender: () => t.scheduleRender(),
+    /**
+     * TODO: Update options in an effect. This could be tricky as it'll be too late
+     * to update by the time layout animations run.
+     * We also need to fix this safeToRemove by linking it up to the one returned by usePresence,
+     * ensuring it gets called if there's no potential layout animations.
+     *
+     */
+    animationType: typeof s == "string" ? s : "both",
+    initialPromotionConfig: o,
+    layoutScroll: d,
+    layoutRoot: m
+  });
+}
+function st(t) {
+  if (t)
+    return t.options.allowProjection !== !1 ? t.projection : st(t.parent);
+}
+function Wt(t, e, n) {
+  return xt(
+    (o) => {
+      o && t.mount && t.mount(o), e && (o ? e.mount(o) : e.unmount()), n && (typeof n == "function" ? n(o) : ot(n) && (n.current = o));
+    },
+    /**
+     * Only pass a new ref callback to React if we've received a visual element
+     * factory. Otherwise we'll be mounting/remounting every time externalRef
+     * or other dependencies change.
+     */
+    [e]
+  );
+}
+function j(t) {
+  return typeof t == "string" || Array.isArray(t);
+}
+function at(t) {
+  return t !== null && typeof t == "object" && typeof t.start == "function";
+}
+const Ht = [
+  "animate",
+  "whileInView",
+  "whileFocus",
+  "whileHover",
+  "whileTap",
+  "whileDrag",
+  "exit"
+], Dt = ["initial", ...Ht];
+function E(t) {
+  return at(t.animate) || Dt.some((e) => j(t[e]));
+}
+function It(t) {
+  return !!(E(t) || t.variants);
+}
+function $t(t, e) {
+  if (E(t)) {
+    const { initial: n, animate: o } = t;
+    return {
+      initial: n === !1 || j(n) ? n : void 0,
+      animate: j(o) ? o : void 0
+    };
+  }
+  return t.inherit !== !1 ? e : {};
+}
+function Nt(t) {
+  const { initial: e, animate: n } = $t(t, y(A));
+  return T(() => ({ initial: e, animate: n }), [Y(e), Y(n)]);
+}
+function Y(t) {
+  return Array.isArray(t) ? t.join(" ") : t;
+}
+const z = {
+  animation: [
+    "animate",
+    "variants",
+    "whileHover",
+    "whileTap",
+    "exit",
+    "whileInView",
+    "whileFocus",
+    "whileDrag"
+  ],
+  exit: ["exit"],
+  drag: ["drag", "dragControls"],
+  focus: ["whileFocus"],
+  hover: ["whileHover", "onHoverStart", "onHoverEnd"],
+  tap: ["whileTap", "onTap", "onTapStart", "onTapCancel"],
+  pan: ["onPan", "onPanStart", "onPanSessionStart", "onPanEnd"],
+  inView: ["whileInView", "onViewportEnter", "onViewportLeave"],
+  layout: ["layout", "layoutId"]
+}, C = {};
+for (const t in z)
+  C[t] = {
+    isEnabled: (e) => z[t].some((n) => !!e[n])
+  };
+function _t(t) {
+  for (const e in t)
+    C[e] = {
+      ...C[e],
+      ...t[e]
+    };
+}
+const Yt = S({}), zt = Symbol.for("motionComponentSymbol"), F = (t) => t;
+var Gt = {};
+let it = F, ct = F;
+Gt.NODE_ENV !== "production" && (it = (t, e) => {
+  !t && typeof console < "u" && console.warn(e);
+}, ct = (t, e) => {
+  if (!t)
+    throw new Error(e);
+});
+var Xt = {};
+function Zt({ preloadedFeatures: t, createVisualElement: e, useRender: n, useVisualState: o, Component: r }) {
+  t && _t(t);
+  function s(l, d) {
+    let m;
+    const u = {
+      ...y(Q),
+      ...l,
+      layoutId: qt(l)
+    }, { isStatic: a } = u, f = Nt(l), g = o(l, a);
+    if (!a && tt) {
+      Ut(u, t);
+      const h = Kt(u);
+      m = h.MeasureLayout, f.visualElement = Et(r, g, u, e, h.ProjectionNode);
+    }
+    return $.jsxs(A.Provider, { value: f, children: [m && f.visualElement ? $.jsx(m, { visualElement: f.visualElement, ...u }) : null, n(r, l, Wt(g, f.visualElement, d), g, a, f.visualElement)] });
+  }
+  const c = Vt(s);
+  return c[zt] = r, c;
+}
+function qt({ layoutId: t }) {
+  const e = y(Yt).id;
+  return e && t !== void 0 ? e + "-" + t : t;
+}
+function Ut(t, e) {
+  const n = y(et).strict;
+  if (Xt.NODE_ENV !== "production" && e && n) {
+    const o = "You have rendered a `motion` component within a `LazyMotion` component. This will break tree shaking. Import and render a `m` component instead.";
+    t.ignoreStrict ? it(!1, o) : ct(!1, o);
+  }
+}
+function Kt(t) {
+  const { drag: e, layout: n } = C;
+  if (!e && !n)
+    return {};
+  const o = { ...e, ...n };
+  return {
+    MeasureLayout: e != null && e.isEnabled(t) || n != null && n.isEnabled(t) ? o.MeasureLayout : void 0,
+    ProjectionNode: o.ProjectionNode
+  };
+}
+function Qt(t) {
+  function e(o, r = {}) {
+    return Zt(t(o, r));
+  }
+  if (typeof Proxy > "u")
+    return e;
+  const n = /* @__PURE__ */ new Map();
+  return new Proxy(e, {
+    /**
+     * Called when `motion` is referenced with a prop: `motion.div`, `motion.input` etc.
+     * The prop name is passed through as `key` and we can use that to generate a `motion`
+     * DOM component with that name.
+     */
+    get: (o, r) => (n.has(r) || n.set(r, e(r)), n.get(r))
+  });
+}
+const Jt = [
+  "animate",
+  "circle",
+  "defs",
+  "desc",
+  "ellipse",
+  "g",
+  "image",
+  "line",
+  "filter",
+  "marker",
+  "mask",
+  "metadata",
+  "path",
+  "pattern",
+  "polygon",
+  "polyline",
+  "rect",
+  "stop",
+  "switch",
+  "symbol",
+  "svg",
+  "text",
+  "tspan",
+  "use",
+  "view"
+];
+function ut(t) {
+  return (
+    /**
+     * If it's not a string, it's a custom React component. Currently we only support
+     * HTML custom React components.
+     */
+    typeof t != "string" || /**
+     * If it contains a dash, the element is a custom HTML webcomponent.
+     */
+    t.includes("-") ? !1 : (
+      /**
+       * If it's in our list of lowercase SVG tags, it's an SVG component
+       */
+      !!(Jt.indexOf(t) > -1 || /**
+       * If it contains a capital letter, it's an SVG component
+       */
+      /[A-Z]/u.test(t))
+    )
+  );
+}
+const te = {}, L = [
+  "transformPerspective",
+  "x",
+  "y",
+  "z",
+  "translateX",
+  "translateY",
+  "translateZ",
+  "scale",
+  "scaleX",
+  "scaleY",
+  "rotate",
+  "rotateX",
+  "rotateY",
+  "rotateZ",
+  "skew",
+  "skewX",
+  "skewY"
+], lt = new Set(L);
+function ft(t, { layout: e, layoutId: n }) {
+  return lt.has(t) || t.startsWith("origin") || (e || n !== void 0) && (!!te[t] || t === "opacity");
+}
+const b = (t) => !!(t && t.getVelocity), ee = {
+  x: "translateX",
+  y: "translateY",
+  z: "translateZ",
+  transformPerspective: "perspective"
+}, ne = L.length;
+function re(t, { enableHardwareAcceleration: e = !0, allowTransformNone: n = !0 }, o, r) {
+  let s = "";
+  for (let c = 0; c < ne; c++) {
+    const l = L[c];
+    if (t[l] !== void 0) {
+      const d = ee[l] || l;
+      s += `${d}(${t[l]}) `;
+    }
+  }
+  return e && !t.z && (s += "translateZ(0)"), s = s.trim(), r ? s = r(t, o ? "" : s) : n && o && (s = "none"), s;
+}
+const oe = (t) => (e) => typeof e == "string" && e.startsWith(t), se = oe("--"), ae = (t, e) => e && typeof t == "number" ? e.transform(t) : t, ie = (t, e, n) => n > e ? e : n < t ? t : n, B = {
+  test: (t) => typeof t == "number",
+  parse: parseFloat,
+  transform: (t) => t
+}, k = {
+  ...B,
+  transform: (t) => ie(0, 1, t)
+}, V = {
+  ...B,
+  default: 1
+};
+function ce(t) {
+  return typeof t == "string";
+}
+const W = (t) => ({
+  test: (e) => ce(e) && e.endsWith(t) && e.split(" ").length === 1,
+  parse: parseFloat,
+  transform: (e) => `${e}${t}`
+}), w = W("deg"), R = W("%"), i = W("px"), G = {
+  ...R,
+  parse: (t) => R.parse(t) / 100,
+  transform: (t) => R.transform(t * 100)
+}, X = {
+  ...B,
+  transform: Math.round
+}, ue = {
+  // Border props
+  borderWidth: i,
+  borderTopWidth: i,
+  borderRightWidth: i,
+  borderBottomWidth: i,
+  borderLeftWidth: i,
+  borderRadius: i,
+  radius: i,
+  borderTopLeftRadius: i,
+  borderTopRightRadius: i,
+  borderBottomRightRadius: i,
+  borderBottomLeftRadius: i,
+  // Positioning props
+  width: i,
+  maxWidth: i,
+  height: i,
+  maxHeight: i,
+  size: i,
+  top: i,
+  right: i,
+  bottom: i,
+  left: i,
+  // Spacing props
+  padding: i,
+  paddingTop: i,
+  paddingRight: i,
+  paddingBottom: i,
+  paddingLeft: i,
+  margin: i,
+  marginTop: i,
+  marginRight: i,
+  marginBottom: i,
+  marginLeft: i,
+  // Transform props
+  rotate: w,
+  rotateX: w,
+  rotateY: w,
+  rotateZ: w,
+  scale: V,
+  scaleX: V,
+  scaleY: V,
+  scaleZ: V,
+  skew: w,
+  skewX: w,
+  skewY: w,
+  distance: i,
+  translateX: i,
+  translateY: i,
+  translateZ: i,
+  x: i,
+  y: i,
+  z: i,
+  perspective: i,
+  transformPerspective: i,
+  opacity: k,
+  originX: G,
+  originY: G,
+  originZ: i,
+  // Misc
+  zIndex: X,
+  backgroundPositionX: i,
+  backgroundPositionY: i,
+  // SVG
+  fillOpacity: k,
+  strokeOpacity: k,
+  numOctaves: X
+};
+function dt(t, e, n, o) {
+  const { style: r, vars: s, transform: c, transformOrigin: l } = t;
+  let d = !1, m = !1, u = !0;
+  for (const a in e) {
+    const f = e[a];
+    if (se(a)) {
+      s[a] = f;
+      continue;
+    }
+    const g = ue[a], h = ae(f, g);
+    if (lt.has(a)) {
+      if (d = !0, c[a] = h, !u)
+        continue;
+      f !== (g.default || 0) && (u = !1);
+    } else a.startsWith("origin") ? (m = !0, l[a] = h) : r[a] = h;
+  }
+  if (e.transform || (d || o ? r.transform = re(t.transform, n, u, o) : r.transform && (r.transform = "none")), m) {
+    const { originX: a = "50%", originY: f = "50%", originZ: g = 0 } = l;
+    r.transformOrigin = `${a} ${f} ${g}`;
+  }
+}
+const H = () => ({
+  style: {},
+  transform: {},
+  transformOrigin: {},
+  vars: {}
+});
+function mt(t, e, n) {
+  for (const o in e)
+    !b(e[o]) && !ft(o, n) && (t[o] = e[o]);
+}
+function le({ transformTemplate: t }, e, n) {
+  return T(() => {
+    const o = H();
+    return dt(o, e, { enableHardwareAcceleration: !n }, t), Object.assign({}, o.vars, o.style);
+  }, [e]);
+}
+function fe(t, e, n) {
+  const o = t.style || {}, r = {};
+  return mt(r, o, t), Object.assign(r, le(t, e, n)), r;
+}
+function de(t, e, n) {
+  const o = {}, r = fe(t, e, n);
+  return t.drag && t.dragListener !== !1 && (o.draggable = !1, r.userSelect = r.WebkitUserSelect = r.WebkitTouchCallout = "none", r.touchAction = t.drag === !0 ? "none" : `pan-${t.drag === "x" ? "y" : "x"}`), t.tabIndex === void 0 && (t.onTap || t.onTapStart || t.whileTap) && (o.tabIndex = 0), o.style = r, o;
+}
+const me = /* @__PURE__ */ new Set([
+  "animate",
+  "exit",
+  "variants",
+  "initial",
+  "style",
+  "values",
+  "variants",
+  "transition",
+  "transformTemplate",
+  "custom",
+  "inherit",
+  "onBeforeLayoutMeasure",
+  "onAnimationStart",
+  "onAnimationComplete",
+  "onUpdate",
+  "onDragStart",
+  "onDrag",
+  "onDragEnd",
+  "onMeasureDragConstraints",
+  "onDirectionLock",
+  "onDragTransitionEnd",
+  "_dragX",
+  "_dragY",
+  "onHoverStart",
+  "onHoverEnd",
+  "onViewportEnter",
+  "onViewportLeave",
+  "globalTapTarget",
+  "ignoreStrict",
+  "viewport"
+]);
+function M(t) {
+  return t.startsWith("while") || t.startsWith("drag") && t !== "draggable" || t.startsWith("layout") || t.startsWith("onTap") || t.startsWith("onPan") || t.startsWith("onLayout") || me.has(t);
+}
+let gt = (t) => !M(t);
+function ge(t) {
+  t && (gt = (e) => e.startsWith("on") ? !M(e) : t(e));
+}
+try {
+  ge(require("@emotion/is-prop-valid").default);
+} catch {
+}
+function he(t, e, n) {
+  const o = {};
+  for (const r in t)
+    r === "values" && typeof t.values == "object" || (gt(r) || n === !0 && M(r) || !e && !M(r) || // If trying to use native HTML drag events, forward drag listeners
+    t.draggable && r.startsWith("onDrag")) && (o[r] = t[r]);
+  return o;
+}
+function Z(t, e, n) {
+  return typeof t == "string" ? t : i.transform(e + n * t);
+}
+function ye(t, e, n) {
+  const o = Z(e, t.x, t.width), r = Z(n, t.y, t.height);
+  return `${o} ${r}`;
+}
+const pe = {
+  offset: "stroke-dashoffset",
+  array: "stroke-dasharray"
+}, we = {
+  offset: "strokeDashoffset",
+  array: "strokeDasharray"
+};
+function be(t, e, n = 1, o = 0, r = !0) {
+  t.pathLength = 1;
+  const s = r ? pe : we;
+  t[s.offset] = i.transform(-o);
+  const c = i.transform(e), l = i.transform(n);
+  t[s.array] = `${c} ${l}`;
+}
+function ht(t, {
+  attrX: e,
+  attrY: n,
+  attrScale: o,
+  originX: r,
+  originY: s,
+  pathLength: c,
+  pathSpacing: l = 1,
+  pathOffset: d = 0,
+  // This is object creation, which we try to avoid per-frame.
+  ...m
+}, u, a, f) {
+  if (dt(t, m, u, f), a) {
+    t.style.viewBox && (t.attrs.viewBox = t.style.viewBox);
+    return;
+  }
+  t.attrs = t.style, t.style = {};
+  const { attrs: g, style: h, dimensions: p } = t;
+  g.transform && (p && (h.transform = g.transform), delete g.transform), p && (r !== void 0 || s !== void 0 || h.transform) && (h.transformOrigin = ye(p, r !== void 0 ? r : 0.5, s !== void 0 ? s : 0.5)), e !== void 0 && (g.x = e), n !== void 0 && (g.y = n), o !== void 0 && (g.scale = o), c !== void 0 && be(g, c, l, d, !1);
+}
+const yt = () => ({
+  ...H(),
+  attrs: {}
+}), pt = (t) => typeof t == "string" && t.toLowerCase() === "svg";
+function ve(t, e, n, o) {
+  const r = T(() => {
+    const s = yt();
+    return ht(s, e, { enableHardwareAcceleration: !1 }, pt(o), t.transformTemplate), {
+      ...s.attrs,
+      style: { ...s.style }
+    };
+  }, [e]);
+  if (t.style) {
+    const s = {};
+    mt(s, t.style, t), r.style = { ...s, ...r.style };
+  }
+  return r;
+}
+function Se(t = !1) {
+  return (n, o, r, { latestValues: s }, c) => {
+    const d = (ut(n) ? ve : de)(o, s, c, n), m = he(o, typeof n == "string", t), u = n !== Ct ? { ...m, ...d, ref: r } : {}, { children: a } = o, f = T(() => b(a) ? a.get() : a, [a]);
+    return Mt(n, {
+      ...u,
+      children: f
+    });
+  };
+}
+function Pe(t, { style: e, vars: n }, o, r) {
+  Object.assign(t.style, e, r);
+  for (const s in n)
+    t.style.setProperty(s, n[s]);
+}
+const xe = /* @__PURE__ */ new Set([
+  "baseFrequency",
+  "diffuseConstant",
+  "kernelMatrix",
+  "kernelUnitLength",
+  "keySplines",
+  "keyTimes",
+  "limitingConeAngle",
+  "markerHeight",
+  "markerWidth",
+  "numOctaves",
+  "targetX",
+  "targetY",
+  "surfaceScale",
+  "specularConstant",
+  "specularExponent",
+  "stdDeviation",
+  "tableValues",
+  "viewBox",
+  "gradientTransform",
+  "pathLength",
+  "startOffset",
+  "textLength",
+  "lengthAdjust"
+]);
+function Ve(t, e, n, o) {
+  Pe(t, e, void 0, o);
+  for (const r in e.attrs)
+    t.setAttribute(xe.has(r) ? r : nt(r), e.attrs[r]);
+}
+function wt(t, e, n) {
+  var o;
+  const { style: r } = t, s = {};
+  for (const c in r)
+    (b(r[c]) || e.style && b(e.style[c]) || ft(c, t) || ((o = n == null ? void 0 : n.getValue(c)) === null || o === void 0 ? void 0 : o.liveStyle) !== void 0) && (s[c] = r[c]);
+  return s;
+}
+function Ce(t, e, n) {
+  const o = wt(t, e, n);
+  for (const r in t)
+    if (b(t[r]) || b(e[r])) {
+      const s = L.indexOf(r) !== -1 ? "attr" + r.charAt(0).toUpperCase() + r.substring(1) : r;
+      o[s] = t[r];
+    }
+  return o;
+}
+function q(t) {
+  return [{}, {}];
+}
+function Me(t, e, n, o) {
+  if (typeof e == "function") {
+    const [r, s] = q();
+    e = e(t.custom, r, s);
+  }
+  if (typeof e == "string" && (e = t.variants && t.variants[e]), typeof e == "function") {
+    const [r, s] = q();
+    e = e(t.custom, r, s);
+  }
+  return e;
+}
+function Te(t) {
+  const e = O(null);
+  return e.current === null && (e.current = t()), e.current;
+}
+const Ae = (t) => !!(t && typeof t == "object" && t.mix && t.toValue);
+function Le(t) {
+  const e = b(t) ? t.get() : t;
+  return Ae(e) ? e.toValue() : e;
+}
+function ke({ scrapeMotionValuesFromProps: t, createRenderState: e, onMount: n }, o, r, s) {
+  const c = {
+    latestValues: Re(o, r, s, t),
+    renderState: e()
+  };
+  return n && (c.mount = (l) => n(o, l, c)), c;
+}
+const bt = (t) => (e, n) => {
+  const o = y(A), r = y(J), s = () => ke(t, e, o, r);
+  return n ? s() : Te(s);
+};
+function Re(t, e, n, o) {
+  const r = {}, s = o(t, {});
+  for (const f in s)
+    r[f] = Le(s[f]);
+  let { initial: c, animate: l } = t;
+  const d = E(t), m = It(t);
+  e && m && !d && t.inherit !== !1 && (c === void 0 && (c = e.initial), l === void 0 && (l = e.animate));
+  let u = n ? n.initial === !1 : !1;
+  u = u || c === !1;
+  const a = u ? l : c;
+  return a && typeof a != "boolean" && !at(a) && (Array.isArray(a) ? a : [a]).forEach((g) => {
+    const h = Me(t, g);
+    if (!h)
+      return;
+    const { transitionEnd: p, transition: D, ...I } = h;
+    for (const P in I) {
+      let v = I[P];
+      if (Array.isArray(v)) {
+        const vt = u ? v.length - 1 : 0;
+        v = v[vt];
+      }
+      v !== null && (r[P] = v);
+    }
+    for (const P in p)
+      r[P] = p[P];
+  }), r;
+}
+const { schedule: U, cancel: He, state: De, steps: Ie } = rt(typeof requestAnimationFrame < "u" ? requestAnimationFrame : F, !0), Oe = {
+  useVisualState: bt({
+    scrapeMotionValuesFromProps: Ce,
+    createRenderState: yt,
+    onMount: (t, e, { renderState: n, latestValues: o }) => {
+      U.read(() => {
+        try {
+          n.dimensions = typeof e.getBBox == "function" ? e.getBBox() : e.getBoundingClientRect();
+        } catch {
+          n.dimensions = {
+            x: 0,
+            y: 0,
+            width: 0,
+            height: 0
+          };
+        }
+      }), U.render(() => {
+        ht(n, o, { enableHardwareAcceleration: !1 }, pt(e.tagName), t.transformTemplate), Ve(e, n);
+      });
+    }
+  })
+}, je = {
+  useVisualState: bt({
+    scrapeMotionValuesFromProps: wt,
+    createRenderState: H
+  })
+};
+function Ee(t, { forwardMotionProps: e = !1 }, n, o) {
+  return {
+    ...ut(t) ? Oe : je,
+    preloadedFeatures: n,
+    useRender: Se(e),
+    createVisualElement: o,
+    Component: t
+  };
+}
+const $e = Qt(Ee);
+export {
+  $e as m
+};