@devalok/shilp-sutra 0.17.2 → 0.18.1

package/dist/_chunks/framer.js

@@ -0,0 +1,1376 @@
+"use client";
+import { jsx as V, Fragment as le, jsxs as fe } from "react/jsx-runtime";
+import * as q from "react";
+import { createContext as I, useRef as x, useLayoutEffect as de, useEffect as ut, useId as lt, useContext as w, useInsertionEffect as ft, useMemo as b, useCallback as z, Children as he, isValidElement as me, useState as $, Fragment as Wt, createElement as pe, forwardRef as ge, Component as ve } from "react";
+import { i as tt, f as M, n as vt, g as ye, s as Ht, a as dt, r as Pe, b as Nt, c as yt, d as we, e as Ee, h as Ce, j as xe, k as Se, l as Me, m as Bt, o as Le, p as Ve, q as be, t as De, w as Ae, u as Ut, v as zt, S as Te, H as Ie, F as A, x as Re, y as ke, z as $t, A as _, B as Pt, C as _t, D as Fe, E as wt, G as je, I as Y, J as rt, K as Et, L as Oe, M as Ge, N as D, O as We, P as He, Q as Ne, R as Ct, T as Be, U as Ue, V as xt, W as ze, X as $e, Y as U, Z as _e, _ as Ye, $ as Yt, a0 as Xe, a1 as qe, a2 as Ke, a3 as Je, a4 as Ze } from "./vendor-utils.js";
+const O = I({});
+function K(e) {
+  const t = x(null);
+  return t.current === null && (t.current = e()), t.current;
+}
+const Qe = typeof window < "u", ht = Qe ? de : ut, J = /* @__PURE__ */ I(null), G = I({
+  transformPagePoint: (e) => e,
+  isStatic: !1,
+  reducedMotion: "never"
+});
+function St(e, t) {
+  if (typeof e == "function")
+    return e(t);
+  e != null && (e.current = t);
+}
+function tn(...e) {
+  return (t) => {
+    let n = !1;
+    const s = e.map((o) => {
+      const i = St(o, t);
+      return !n && typeof i == "function" && (n = !0), i;
+    });
+    if (n)
+      return () => {
+        for (let o = 0; o < s.length; o++) {
+          const i = s[o];
+          typeof i == "function" ? i() : St(e[o], null);
+        }
+      };
+  };
+}
+function en(...e) {
+  return q.useCallback(tn(...e), e);
+}
+class nn extends q.Component {
+  getSnapshotBeforeUpdate(t) {
+    const n = this.props.childRef.current;
+    if (tt(n) && t.isPresent && !this.props.isPresent && this.props.pop !== !1) {
+      const s = n.offsetParent, o = tt(s) && s.offsetWidth || 0, i = tt(s) && s.offsetHeight || 0, r = getComputedStyle(n), a = this.props.sizeRef.current;
+      a.height = parseFloat(r.height), a.width = parseFloat(r.width), a.top = n.offsetTop, a.left = n.offsetLeft, a.right = o - a.width - a.left, a.bottom = i - a.height - a.top;
+    }
+    return null;
+  }
+  /**
+   * Required with getSnapshotBeforeUpdate to stop React complaining.
+   */
+  componentDidUpdate() {
+  }
+  render() {
+    return this.props.children;
+  }
+}
+function sn({ children: e, isPresent: t, anchorX: n, anchorY: s, root: o, pop: i }) {
+  var c;
+  const r = lt(), a = x(null), f = x({
+    width: 0,
+    height: 0,
+    top: 0,
+    left: 0,
+    right: 0,
+    bottom: 0
+  }), { nonce: d } = w(G), m = ((c = e.props) == null ? void 0 : c.ref) ?? (e == null ? void 0 : e.ref), u = en(a, m);
+  return ft(() => {
+    const { width: h, height: l, top: p, left: g, right: v, bottom: y } = f.current;
+    if (t || i === !1 || !a.current || !h || !l)
+      return;
+    const P = n === "left" ? `left: ${g}` : `right: ${v}`, E = s === "bottom" ? `bottom: ${y}` : `top: ${p}`;
+    a.current.dataset.motionPopId = r;
+    const S = document.createElement("style");
+    d && (S.nonce = d);
+    const T = o ?? document.head;
+    return T.appendChild(S), S.sheet && S.sheet.insertRule(`
+          [data-motion-pop-id="${r}"] {
+            position: absolute !important;
+            width: ${h}px !important;
+            height: ${l}px !important;
+            ${P}px !important;
+            ${E}px !important;
+          }
+        `), () => {
+      var R;
+      (R = a.current) == null || R.removeAttribute("data-motion-pop-id"), T.contains(S) && T.removeChild(S);
+    };
+  }, [t]), V(nn, { isPresent: t, childRef: a, sizeRef: f, pop: i, children: i === !1 ? e : q.cloneElement(e, { ref: u }) });
+}
+const on = ({ children: e, initial: t, isPresent: n, onExitComplete: s, custom: o, presenceAffectsLayout: i, mode: r, anchorX: a, anchorY: f, root: d }) => {
+  const m = K(rn), u = lt();
+  let c = !0, h = b(() => (c = !1, {
+    id: u,
+    initial: t,
+    isPresent: n,
+    custom: o,
+    onExitComplete: (l) => {
+      m.set(l, !0);
+      for (const p of m.values())
+        if (!p)
+          return;
+      s && s();
+    },
+    register: (l) => (m.set(l, !1), () => m.delete(l))
+  }), [n, m, s]);
+  return i && c && (h = { ...h }), b(() => {
+    m.forEach((l, p) => m.set(p, !1));
+  }, [n]), q.useEffect(() => {
+    !n && !m.size && s && s();
+  }, [n]), e = V(sn, { pop: r === "popLayout", isPresent: n, anchorX: a, anchorY: f, root: d, children: e }), V(J.Provider, { value: h, children: e });
+};
+function rn() {
+  return /* @__PURE__ */ new Map();
+}
+function Xt(e = !0) {
+  const t = w(J);
+  if (t === null)
+    return [!0, null];
+  const { isPresent: n, onExitComplete: s, register: o } = t, i = lt();
+  ut(() => {
+    if (e)
+      return o(i);
+  }, [e]);
+  const r = z(() => e && s && s(i), [i, s, e]);
+  return !n && s ? [!1, r] : [!0];
+}
+const H = (e) => e.key || "";
+function Mt(e) {
+  const t = [];
+  return he.forEach(e, (n) => {
+    me(n) && t.push(n);
+  }), t;
+}
+const ws = ({ children: e, custom: t, initial: n = !0, onExitComplete: s, presenceAffectsLayout: o = !0, mode: i = "sync", propagate: r = !1, anchorX: a = "left", anchorY: f = "top", root: d }) => {
+  const [m, u] = Xt(r), c = b(() => Mt(e), [e]), h = r && !m ? [] : c.map(H), l = x(!0), p = x(c), g = K(() => /* @__PURE__ */ new Map()), v = x(/* @__PURE__ */ new Set()), [y, P] = $(c), [E, S] = $(c);
+  ht(() => {
+    l.current = !1, p.current = c;
+    for (let L = 0; L < E.length; L++) {
+      const C = H(E[L]);
+      h.includes(C) ? (g.delete(C), v.current.delete(C)) : g.get(C) !== !0 && g.set(C, !1);
+    }
+  }, [E, h.length, h.join("-")]);
+  const T = [];
+  if (c !== y) {
+    let L = [...c];
+    for (let C = 0; C < E.length; C++) {
+      const k = E[C], Q = H(k);
+      h.includes(Q) || (L.splice(C, 0, k), T.push(k));
+    }
+    return i === "wait" && T.length && (L = T), S(Mt(L)), P(c), null;
+  }
+  process.env.NODE_ENV !== "production" && i === "wait" && E.length > 1 && console.warn(`You're attempting to animate multiple children within AnimatePresence, but its mode is set to "wait". This will lead to odd visual behaviour.`);
+  const { forceRender: R } = w(O);
+  return V(le, { children: E.map((L) => {
+    const C = H(L), k = r && !m ? !1 : c === E || h.includes(C), Q = () => {
+      if (v.current.has(C))
+        return;
+      if (g.has(C))
+        v.current.add(C), g.set(C, !0);
+      else
+        return;
+      let gt = !0;
+      g.forEach((ue) => {
+        ue || (gt = !1);
+      }), gt && (R == null || R(), S(p.current), r && (u == null || u()), s && s());
+    };
+    return V(on, { isPresent: k, initial: !l.current || n ? void 0 : !1, custom: t, presenceAffectsLayout: o, mode: i, root: d, onExitComplete: k ? void 0 : Q, anchorX: a, anchorY: f, children: L }, C);
+  }) });
+}, an = I(null);
+function cn() {
+  const e = x(!1);
+  return ht(() => (e.current = !0, () => {
+    e.current = !1;
+  }), []), e;
+}
+function un() {
+  const e = cn(), [t, n] = $(0), s = z(() => {
+    e.current && n(t + 1);
+  }, [t]);
+  return [z(() => M.postRender(s), [s]), t];
+}
+const qt = (e) => e === !0, ln = (e) => qt(e === !0) || e === "id", Es = ({ children: e, id: t, inherit: n = !0 }) => {
+  const s = w(O), o = w(an), [i, r] = un(), a = x(null), f = s.id || o;
+  a.current === null && (ln(n) && f && (t = t ? f + "-" + t : f), a.current = {
+    id: t,
+    group: qt(n) ? s.group || vt() : vt()
+  });
+  const d = b(() => ({ ...a.current, forceRender: i }), [r]);
+  return V(O.Provider, { value: d, children: e });
+}, Kt = I({ strict: !1 }), Lt = {
+  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"]
+};
+let Vt = !1;
+function fn() {
+  if (Vt)
+    return;
+  const e = {};
+  for (const t in Lt)
+    e[t] = {
+      isEnabled: (n) => Lt[t].some((s) => !!n[s])
+    };
+  Ht(e), Vt = !0;
+}
+function Jt() {
+  return fn(), ye();
+}
+function dn(e) {
+  const t = Jt();
+  for (const n in e)
+    t[n] = {
+      ...t[n],
+      ...e[n]
+    };
+  Ht(t);
+}
+const hn = /* @__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",
+  "propagate",
+  "ignoreStrict",
+  "viewport"
+]);
+function X(e) {
+  return e.startsWith("while") || e.startsWith("drag") && e !== "draggable" || e.startsWith("layout") || e.startsWith("onTap") || e.startsWith("onPan") || e.startsWith("onLayout") || hn.has(e);
+}
+let Zt = (e) => !X(e);
+function Qt(e) {
+  typeof e == "function" && (Zt = (t) => t.startsWith("on") ? !X(t) : e(t));
+}
+try {
+  Qt(require("@emotion/is-prop-valid").default);
+} catch {
+}
+function mn(e, t, n) {
+  const s = {};
+  for (const o in e)
+    o === "values" && typeof e.values == "object" || dt(e[o]) || (Zt(o) || n === !0 && X(o) || !t && !X(o) || // If trying to use native HTML drag events, forward drag listeners
+    e.draggable && o.startsWith("onDrag")) && (s[o] = e[o]);
+  return s;
+}
+function Cs({ children: e, isValidProp: t, ...n }) {
+  t && Qt(t);
+  const s = w(G);
+  n = { ...s, ...n }, n.transition = Pe(n.transition, s.transition), n.isStatic = K(() => n.isStatic);
+  const o = b(() => n, [
+    JSON.stringify(n.transition),
+    n.transformPagePoint,
+    n.reducedMotion,
+    n.skipAnimations
+  ]);
+  return V(G.Provider, { value: o, children: e });
+}
+const Z = /* @__PURE__ */ I({});
+function pn(e, t) {
+  if (Nt(e)) {
+    const { initial: n, animate: s } = e;
+    return {
+      initial: n === !1 || yt(n) ? n : void 0,
+      animate: yt(s) ? s : void 0
+    };
+  }
+  return e.inherit !== !1 ? t : {};
+}
+function gn(e) {
+  const { initial: t, animate: n } = pn(e, w(Z));
+  return b(() => ({ initial: t, animate: n }), [bt(t), bt(n)]);
+}
+function bt(e) {
+  return Array.isArray(e) ? e.join(" ") : e;
+}
+const mt = () => ({
+  style: {},
+  transform: {},
+  transformOrigin: {},
+  vars: {}
+});
+function te(e, t, n) {
+  for (const s in t)
+    !dt(t[s]) && !we(s, n) && (e[s] = t[s]);
+}
+function vn({ transformTemplate: e }, t) {
+  return b(() => {
+    const n = mt();
+    return Ee(n, t, e), Object.assign({}, n.vars, n.style);
+  }, [t]);
+}
+function yn(e, t) {
+  const n = e.style || {}, s = {};
+  return te(s, n, e), Object.assign(s, vn(e, t)), s;
+}
+function Pn(e, t) {
+  const n = {}, s = yn(e, t);
+  return e.drag && e.dragListener !== !1 && (n.draggable = !1, s.userSelect = s.WebkitUserSelect = s.WebkitTouchCallout = "none", s.touchAction = e.drag === !0 ? "none" : `pan-${e.drag === "x" ? "y" : "x"}`), e.tabIndex === void 0 && (e.onTap || e.onTapStart || e.whileTap) && (n.tabIndex = 0), n.style = s, n;
+}
+const ee = () => ({
+  ...mt(),
+  attrs: {}
+});
+function wn(e, t, n, s) {
+  const o = b(() => {
+    const i = ee();
+    return Ce(i, t, xe(s), e.transformTemplate, e.style), {
+      ...i.attrs,
+      style: { ...i.style }
+    };
+  }, [t]);
+  if (e.style) {
+    const i = {};
+    te(i, e.style, e), o.style = { ...i, ...o.style };
+  }
+  return o;
+}
+const En = [
+  "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 pt(e) {
+  return (
+    /**
+     * If it's not a string, it's a custom React component. Currently we only support
+     * HTML custom React components.
+     */
+    typeof e != "string" || /**
+     * If it contains a dash, the element is a custom HTML webcomponent.
+     */
+    e.includes("-") ? !1 : (
+      /**
+       * If it's in our list of lowercase SVG tags, it's an SVG component
+       */
+      !!(En.indexOf(e) > -1 || /**
+       * If it contains a capital letter, it's an SVG component
+       */
+      /[A-Z]/u.test(e))
+    )
+  );
+}
+function Cn(e, t, n, { latestValues: s }, o, i = !1, r) {
+  const f = (r ?? pt(e) ? wn : Pn)(t, s, o, e), d = mn(t, typeof e == "string", i), m = e !== Wt ? { ...d, ...f, ref: n } : {}, { children: u } = t, c = b(() => dt(u) ? u.get() : u, [u]);
+  return pe(e, {
+    ...m,
+    children: c
+  });
+}
+function xn({ scrapeMotionValuesFromProps: e, createRenderState: t }, n, s, o) {
+  return {
+    latestValues: Sn(n, s, o, e),
+    renderState: t()
+  };
+}
+function Sn(e, t, n, s) {
+  const o = {}, i = s(e, {});
+  for (const c in i)
+    o[c] = Se(i[c]);
+  let { initial: r, animate: a } = e;
+  const f = Nt(e), d = Me(e);
+  t && d && !f && e.inherit !== !1 && (r === void 0 && (r = t.initial), a === void 0 && (a = t.animate));
+  let m = n ? n.initial === !1 : !1;
+  m = m || r === !1;
+  const u = m ? a : r;
+  if (u && typeof u != "boolean" && !Bt(u)) {
+    const c = Array.isArray(u) ? u : [u];
+    for (let h = 0; h < c.length; h++) {
+      const l = Le(e, c[h]);
+      if (l) {
+        const { transitionEnd: p, transition: g, ...v } = l;
+        for (const y in v) {
+          let P = v[y];
+          if (Array.isArray(P)) {
+            const E = m ? P.length - 1 : 0;
+            P = P[E];
+          }
+          P !== null && (o[y] = P);
+        }
+        for (const y in p)
+          o[y] = p[y];
+      }
+    }
+  }
+  return o;
+}
+const ne = (e) => (t, n) => {
+  const s = w(Z), o = w(J), i = () => xn(e, t, s, o);
+  return n ? i() : K(i);
+}, Mn = /* @__PURE__ */ ne({
+  scrapeMotionValuesFromProps: Ve,
+  createRenderState: mt
+}), Ln = /* @__PURE__ */ ne({
+  scrapeMotionValuesFromProps: be,
+  createRenderState: ee
+}), Vn = Symbol.for("motionComponentSymbol");
+function bn(e, t, n) {
+  const s = x(n);
+  ft(() => {
+    s.current = n;
+  });
+  const o = x(null);
+  return z((i) => {
+    var a;
+    i && ((a = e.onMount) == null || a.call(e, i));
+    const r = s.current;
+    if (typeof r == "function")
+      if (i) {
+        const f = r(i);
+        typeof f == "function" && (o.current = f);
+      } else o.current ? (o.current(), o.current = null) : r(i);
+    else r && (r.current = i);
+    t && (i ? t.mount(i) : t.unmount());
+  }, [t]);
+}
+const se = I({});
+function F(e) {
+  return e && typeof e == "object" && Object.prototype.hasOwnProperty.call(e, "current");
+}
+function Dn(e, t, n, s, o, i) {
+  var P, E;
+  const { visualElement: r } = w(Z), a = w(Kt), f = w(J), d = w(G), m = d.reducedMotion, u = d.skipAnimations, c = x(null), h = x(!1);
+  s = s || a.renderer, !c.current && s && (c.current = s(e, {
+    visualState: t,
+    parent: r,
+    props: n,
+    presenceContext: f,
+    blockInitialAnimation: f ? f.initial === !1 : !1,
+    reducedMotionConfig: m,
+    skipAnimations: u,
+    isSVG: i
+  }), h.current && c.current && (c.current.manuallyAnimateOnMount = !0));
+  const l = c.current, p = w(se);
+  l && !l.projection && o && (l.type === "html" || l.type === "svg") && An(c.current, n, o, p);
+  const g = x(!1);
+  ft(() => {
+    l && g.current && l.update(n, f);
+  });
+  const v = n[De], y = x(!!v && typeof window < "u" && !((P = window.MotionHandoffIsComplete) != null && P.call(window, v)) && ((E = window.MotionHasOptimisedAnimation) == null ? void 0 : E.call(window, v)));
+  return ht(() => {
+    h.current = !0, l && (g.current = !0, window.MotionIsMounted = !0, l.updateFeatures(), l.scheduleRenderMicrotask(), y.current && l.animationState && l.animationState.animateChanges());
+  }), ut(() => {
+    l && (!y.current && l.animationState && l.animationState.animateChanges(), y.current && (queueMicrotask(() => {
+      var S;
+      (S = window.MotionHandoffMarkAsComplete) == null || S.call(window, v);
+    }), y.current = !1), l.enteringChildren = void 0);
+  }), l;
+}
+function An(e, t, n, s) {
+  const { layoutId: o, layout: i, drag: r, dragConstraints: a, layoutScroll: f, layoutRoot: d, layoutCrossfade: m } = t;
+  e.projection = new n(e.latestValues, t["data-framer-portal-id"] ? void 0 : oe(e.parent)), e.projection.setOptions({
+    layoutId: o,
+    layout: i,
+    alwaysMeasureLayout: !!r || a && F(a),
+    visualElement: e,
+    /**
+     * 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 i == "string" ? i : "both",
+    initialPromotionConfig: s,
+    crossfade: m,
+    layoutScroll: f,
+    layoutRoot: d
+  });
+}
+function oe(e) {
+  if (e)
+    return e.options.allowProjection !== !1 ? e.projection : oe(e.parent);
+}
+function et(e, { forwardMotionProps: t = !1, type: n } = {}, s, o) {
+  s && dn(s);
+  const i = n ? n === "svg" : pt(e), r = i ? Ln : Mn;
+  function a(d, m) {
+    let u;
+    const c = {
+      ...w(G),
+      ...d,
+      layoutId: Tn(d)
+    }, { isStatic: h } = c, l = gn(d), p = r(d, h);
+    if (!h && typeof window < "u") {
+      In(c, s);
+      const g = Rn(c);
+      u = g.MeasureLayout, l.visualElement = Dn(e, p, c, o, g.ProjectionNode, i);
+    }
+    return fe(Z.Provider, { value: l, children: [u && l.visualElement ? V(u, { visualElement: l.visualElement, ...c }) : null, Cn(e, d, bn(p, l.visualElement, m), p, h, t, i)] });
+  }
+  a.displayName = `motion.${typeof e == "string" ? e : `create(${e.displayName ?? e.name ?? ""})`}`;
+  const f = ge(a);
+  return f[Vn] = e, f;
+}
+function Tn({ layoutId: e }) {
+  const t = w(O).id;
+  return t && e !== void 0 ? t + "-" + e : e;
+}
+function In(e, t) {
+  const n = w(Kt).strict;
+  if (process.env.NODE_ENV !== "production" && t && n) {
+    const s = "You have rendered a `motion` component within a `LazyMotion` component. This will break tree shaking. Import and render a `m` component instead.";
+    e.ignoreStrict ? Ae(!1, s, "lazy-strict-mode") : Ut(!1, s, "lazy-strict-mode");
+  }
+}
+function Rn(e) {
+  const t = Jt(), { drag: n, layout: s } = t;
+  if (!n && !s)
+    return {};
+  const o = { ...n, ...s };
+  return {
+    MeasureLayout: n != null && n.isEnabled(e) || s != null && s.isEnabled(e) ? o.MeasureLayout : void 0,
+    ProjectionNode: o.ProjectionNode
+  };
+}
+function kn(e, t) {
+  if (typeof Proxy > "u")
+    return et;
+  const n = /* @__PURE__ */ new Map(), s = (i, r) => et(i, r, e, t), o = (i, r) => (process.env.NODE_ENV !== "production" && zt(!1, "motion() is deprecated. Use motion.create() instead."), s(i, r));
+  return new Proxy(o, {
+    /**
+     * 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: (i, r) => r === "create" ? s : (n.has(r) || n.set(r, et(r, void 0, e, t)), n.get(r))
+  });
+}
+const Fn = (e, t) => t.isSVG ?? pt(e) ? new Te(t) : new Ie(t, {
+  allowProjection: e !== Wt
+});
+class jn extends A {
+  /**
+   * We dynamically generate the AnimationState manager as it contains a reference
+   * to the underlying animation library. We only want to load that if we load this,
+   * so people can optionally code split it out using the `m` component.
+   */
+  constructor(t) {
+    super(t), t.animationState || (t.animationState = Re(t));
+  }
+  updateAnimationControlsSubscription() {
+    const { animate: t } = this.node.getProps();
+    Bt(t) && (this.unmountControls = t.subscribe(this.node));
+  }
+  /**
+   * Subscribe any provided AnimationControls to the component's VisualElement
+   */
+  mount() {
+    this.updateAnimationControlsSubscription();
+  }
+  update() {
+    const { animate: t } = this.node.getProps(), { animate: n } = this.node.prevProps || {};
+    t !== n && this.updateAnimationControlsSubscription();
+  }
+  unmount() {
+    var t;
+    this.node.animationState.reset(), (t = this.unmountControls) == null || t.call(this);
+  }
+}
+let On = 0;
+class Gn extends A {
+  constructor() {
+    super(...arguments), this.id = On++, this.isExitComplete = !1;
+  }
+  update() {
+    var i;
+    if (!this.node.presenceContext)
+      return;
+    const { isPresent: t, onExitComplete: n } = this.node.presenceContext, { isPresent: s } = this.node.prevPresenceContext || {};
+    if (!this.node.animationState || t === s)
+      return;
+    if (t && s === !1) {
+      if (this.isExitComplete) {
+        const { initial: r, custom: a } = this.node.getProps();
+        if (typeof r == "string") {
+          const f = ke(this.node, r, a);
+          if (f) {
+            const { transition: d, transitionEnd: m, ...u } = f;
+            for (const c in u)
+              (i = this.node.getValue(c)) == null || i.jump(u[c]);
+          }
+        }
+        this.node.animationState.reset(), this.node.animationState.animateChanges();
+      } else
+        this.node.animationState.setActive("exit", !1);
+      this.isExitComplete = !1;
+      return;
+    }
+    const o = this.node.animationState.setActive("exit", !t);
+    n && !t && o.then(() => {
+      this.isExitComplete = !0, n(this.id);
+    });
+  }
+  mount() {
+    const { register: t, onExitComplete: n } = this.node.presenceContext || {};
+    n && n(this.id), t && (this.unmount = t(this.id));
+  }
+  unmount() {
+  }
+}
+const Wn = {
+  animation: {
+    Feature: jn
+  },
+  exit: {
+    Feature: Gn
+  }
+};
+function W(e) {
+  return {
+    point: {
+      x: e.pageX,
+      y: e.pageY
+    }
+  };
+}
+const Hn = (e) => (t) => $t(t) && e(t, W(t));
+function j(e, t, n, s) {
+  return _(e, t, Hn(n), s);
+}
+const ie = ({ current: e }) => e ? e.ownerDocument.defaultView : null, Dt = (e, t) => Math.abs(e - t);
+function Nn(e, t) {
+  const n = Dt(e.x, t.x), s = Dt(e.y, t.y);
+  return Math.sqrt(n ** 2 + s ** 2);
+}
+const At = /* @__PURE__ */ new Set(["auto", "scroll"]);
+class re {
+  constructor(t, n, { transformPagePoint: s, contextWindow: o = window, dragSnapToOrigin: i = !1, distanceThreshold: r = 3, element: a } = {}) {
+    if (this.startEvent = null, this.lastMoveEvent = null, this.lastMoveEventInfo = null, this.lastRawMoveEventInfo = null, this.handlers = {}, this.contextWindow = window, this.scrollPositions = /* @__PURE__ */ new Map(), this.removeScrollListeners = null, this.onElementScroll = (h) => {
+      this.handleScroll(h.target);
+    }, this.onWindowScroll = () => {
+      this.handleScroll(window);
+    }, this.updatePoint = () => {
+      if (!(this.lastMoveEvent && this.lastMoveEventInfo))
+        return;
+      this.lastRawMoveEventInfo && (this.lastMoveEventInfo = N(this.lastRawMoveEventInfo, this.transformPagePoint));
+      const h = nt(this.lastMoveEventInfo, this.history), l = this.startEvent !== null, p = Nn(h.offset, { x: 0, y: 0 }) >= this.distanceThreshold;
+      if (!l && !p)
+        return;
+      const { point: g } = h, { timestamp: v } = Pt;
+      this.history.push({ ...g, timestamp: v });
+      const { onStart: y, onMove: P } = this.handlers;
+      l || (y && y(this.lastMoveEvent, h), this.startEvent = this.lastMoveEvent), P && P(this.lastMoveEvent, h);
+    }, this.handlePointerMove = (h, l) => {
+      this.lastMoveEvent = h, this.lastRawMoveEventInfo = l, this.lastMoveEventInfo = N(l, this.transformPagePoint), M.update(this.updatePoint, !0);
+    }, this.handlePointerUp = (h, l) => {
+      this.end();
+      const { onEnd: p, onSessionEnd: g, resumeAnimation: v } = this.handlers;
+      if ((this.dragSnapToOrigin || !this.startEvent) && v && v(), !(this.lastMoveEvent && this.lastMoveEventInfo))
+        return;
+      const y = nt(h.type === "pointercancel" ? this.lastMoveEventInfo : N(l, this.transformPagePoint), this.history);
+      this.startEvent && p && p(h, y), g && g(h, y);
+    }, !$t(t))
+      return;
+    this.dragSnapToOrigin = i, this.handlers = n, this.transformPagePoint = s, this.distanceThreshold = r, this.contextWindow = o || window;
+    const f = W(t), d = N(f, this.transformPagePoint), { point: m } = d, { timestamp: u } = Pt;
+    this.history = [{ ...m, timestamp: u }];
+    const { onSessionStart: c } = n;
+    c && c(t, nt(d, this.history)), this.removeListeners = _t(j(this.contextWindow, "pointermove", this.handlePointerMove), j(this.contextWindow, "pointerup", this.handlePointerUp), j(this.contextWindow, "pointercancel", this.handlePointerUp)), a && this.startScrollTracking(a);
+  }
+  /**
+   * Start tracking scroll on ancestors and window.
+   */
+  startScrollTracking(t) {
+    let n = t.parentElement;
+    for (; n; ) {
+      const s = getComputedStyle(n);
+      (At.has(s.overflowX) || At.has(s.overflowY)) && this.scrollPositions.set(n, {
+        x: n.scrollLeft,
+        y: n.scrollTop
+      }), n = n.parentElement;
+    }
+    this.scrollPositions.set(window, {
+      x: window.scrollX,
+      y: window.scrollY
+    }), window.addEventListener("scroll", this.onElementScroll, {
+      capture: !0
+    }), window.addEventListener("scroll", this.onWindowScroll), this.removeScrollListeners = () => {
+      window.removeEventListener("scroll", this.onElementScroll, {
+        capture: !0
+      }), window.removeEventListener("scroll", this.onWindowScroll);
+    };
+  }
+  /**
+   * Handle scroll compensation during drag.
+   *
+   * For element scroll: adjusts history origin since pageX/pageY doesn't change.
+   * For window scroll: adjusts lastMoveEventInfo since pageX/pageY would change.
+   */
+  handleScroll(t) {
+    const n = this.scrollPositions.get(t);
+    if (!n)
+      return;
+    const s = t === window, o = s ? { x: window.scrollX, y: window.scrollY } : {
+      x: t.scrollLeft,
+      y: t.scrollTop
+    }, i = { x: o.x - n.x, y: o.y - n.y };
+    i.x === 0 && i.y === 0 || (s ? this.lastMoveEventInfo && (this.lastMoveEventInfo.point.x += i.x, this.lastMoveEventInfo.point.y += i.y) : this.history.length > 0 && (this.history[0].x -= i.x, this.history[0].y -= i.y), this.scrollPositions.set(t, o), M.update(this.updatePoint, !0));
+  }
+  updateHandlers(t) {
+    this.handlers = t;
+  }
+  end() {
+    this.removeListeners && this.removeListeners(), this.removeScrollListeners && this.removeScrollListeners(), this.scrollPositions.clear(), Fe(this.updatePoint);
+  }
+}
+function N(e, t) {
+  return t ? { point: t(e.point) } : e;
+}
+function Tt(e, t) {
+  return { x: e.x - t.x, y: e.y - t.y };
+}
+function nt({ point: e }, t) {
+  return {
+    point: e,
+    delta: Tt(e, ae(t)),
+    offset: Tt(e, Bn(t)),
+    velocity: Un(t, 0.1)
+  };
+}
+function Bn(e) {
+  return e[0];
+}
+function ae(e) {
+  return e[e.length - 1];
+}
+function Un(e, t) {
+  if (e.length < 2)
+    return { x: 0, y: 0 };
+  let n = e.length - 1, s = null;
+  const o = ae(e);
+  for (; n >= 0 && (s = e[n], !(o.timestamp - s.timestamp > wt(t))); )
+    n--;
+  if (!s)
+    return { x: 0, y: 0 };
+  s === e[0] && e.length > 2 && o.timestamp - s.timestamp > wt(t) * 2 && (s = e[1]);
+  const i = je(o.timestamp - s.timestamp);
+  if (i === 0)
+    return { x: 0, y: 0 };
+  const r = {
+    x: (o.x - s.x) / i,
+    y: (o.y - s.y) / i
+  };
+  return r.x === 1 / 0 && (r.x = 0), r.y === 1 / 0 && (r.y = 0), r;
+}
+function zn(e, { min: t, max: n }, s) {
+  return t !== void 0 && e < t ? e = s ? Y(t, e, s.min) : Math.max(e, t) : n !== void 0 && e > n && (e = s ? Y(n, e, s.max) : Math.min(e, n)), e;
+}
+function It(e, t, n) {
+  return {
+    min: t !== void 0 ? e.min + t : void 0,
+    max: n !== void 0 ? e.max + n - (e.max - e.min) : void 0
+  };
+}
+function $n(e, { top: t, left: n, bottom: s, right: o }) {
+  return {
+    x: It(e.x, n, o),
+    y: It(e.y, t, s)
+  };
+}
+function Rt(e, t) {
+  let n = t.min - e.min, s = t.max - e.max;
+  return t.max - t.min < e.max - e.min && ([n, s] = [s, n]), { min: n, max: s };
+}
+function _n(e, t) {
+  return {
+    x: Rt(e.x, t.x),
+    y: Rt(e.y, t.y)
+  };
+}
+function Yn(e, t) {
+  let n = 0.5;
+  const s = rt(e), o = rt(t);
+  return o > s ? n = Et(t.min, t.max - s, e.min) : s > o && (n = Et(e.min, e.max - o, t.min)), Oe(0, 1, n);
+}
+function Xn(e, t) {
+  const n = {};
+  return t.min !== void 0 && (n.min = t.min - e.min), t.max !== void 0 && (n.max = t.max - e.min), n;
+}
+const at = 0.35;
+function qn(e = at) {
+  return e === !1 ? e = 0 : e === !0 && (e = at), {
+    x: kt(e, "left", "right"),
+    y: kt(e, "top", "bottom")
+  };
+}
+function kt(e, t, n) {
+  return {
+    min: Ft(e, t),
+    max: Ft(e, n)
+  };
+}
+function Ft(e, t) {
+  return typeof e == "number" ? e : e[t] || 0;
+}
+const Kn = /* @__PURE__ */ new WeakMap();
+class Jn {
+  constructor(t) {
+    this.openDragLock = null, this.isDragging = !1, this.currentDirection = null, this.originPoint = { x: 0, y: 0 }, this.constraints = !1, this.hasMutatedConstraints = !1, this.elastic = Ge(), this.latestPointerEvent = null, this.latestPanInfo = null, this.visualElement = t;
+  }
+  start(t, { snapToCursor: n = !1, distanceThreshold: s } = {}) {
+    const { presenceContext: o } = this.visualElement;
+    if (o && o.isPresent === !1)
+      return;
+    const i = (u) => {
+      n && this.snapToCursor(W(u).point), this.stopAnimation();
+    }, r = (u, c) => {
+      const { drag: h, dragPropagation: l, onDragStart: p } = this.getProps();
+      if (h && !l && (this.openDragLock && this.openDragLock(), this.openDragLock = Ue(h), !this.openDragLock))
+        return;
+      this.latestPointerEvent = u, this.latestPanInfo = c, this.isDragging = !0, this.currentDirection = null, this.resolveConstraints(), this.visualElement.projection && (this.visualElement.projection.isAnimationBlocked = !0, this.visualElement.projection.target = void 0), D((v) => {
+        let y = this.getAxisMotionValue(v).get() || 0;
+        if (ze.test(y)) {
+          const { projection: P } = this.visualElement;
+          if (P && P.layout) {
+            const E = P.layout.layoutBox[v];
+            E && (y = rt(E) * (parseFloat(y) / 100));
+          }
+        }
+        this.originPoint[v] = y;
+      }), p && M.update(() => p(u, c), !1, !0), Ct(this.visualElement, "transform");
+      const { animationState: g } = this.visualElement;
+      g && g.setActive("whileDrag", !0);
+    }, a = (u, c) => {
+      this.latestPointerEvent = u, this.latestPanInfo = c;
+      const { dragPropagation: h, dragDirectionLock: l, onDirectionLock: p, onDrag: g } = this.getProps();
+      if (!h && !this.openDragLock)
+        return;
+      const { offset: v } = c;
+      if (l && this.currentDirection === null) {
+        this.currentDirection = Qn(v), this.currentDirection !== null && p && p(this.currentDirection);
+        return;
+      }
+      this.updateAxis("x", c.point, v), this.updateAxis("y", c.point, v), this.visualElement.render(), g && M.update(() => g(u, c), !1, !0);
+    }, f = (u, c) => {
+      this.latestPointerEvent = u, this.latestPanInfo = c, this.stop(u, c), this.latestPointerEvent = null, this.latestPanInfo = null;
+    }, d = () => {
+      const { dragSnapToOrigin: u } = this.getProps();
+      (u || this.constraints) && this.startAnimation({ x: 0, y: 0 });
+    }, { dragSnapToOrigin: m } = this.getProps();
+    this.panSession = new re(t, {
+      onSessionStart: i,
+      onStart: r,
+      onMove: a,
+      onSessionEnd: f,
+      resumeAnimation: d
+    }, {
+      transformPagePoint: this.visualElement.getTransformPagePoint(),
+      dragSnapToOrigin: m,
+      distanceThreshold: s,
+      contextWindow: ie(this.visualElement),
+      element: this.visualElement.current
+    });
+  }
+  /**
+   * @internal
+   */
+  stop(t, n) {
+    const s = t || this.latestPointerEvent, o = n || this.latestPanInfo, i = this.isDragging;
+    if (this.cancel(), !i || !o || !s)
+      return;
+    const { velocity: r } = o;
+    this.startAnimation(r);
+    const { onDragEnd: a } = this.getProps();
+    a && M.postRender(() => a(s, o));
+  }
+  /**
+   * @internal
+   */
+  cancel() {
+    this.isDragging = !1;
+    const { projection: t, animationState: n } = this.visualElement;
+    t && (t.isAnimationBlocked = !1), this.endPanSession();
+    const { dragPropagation: s } = this.getProps();
+    !s && this.openDragLock && (this.openDragLock(), this.openDragLock = null), n && n.setActive("whileDrag", !1);
+  }
+  /**
+   * Clean up the pan session without modifying other drag state.
+   * This is used during unmount to ensure event listeners are removed
+   * without affecting projection animations or drag locks.
+   * @internal
+   */
+  endPanSession() {
+    this.panSession && this.panSession.end(), this.panSession = void 0;
+  }
+  updateAxis(t, n, s) {
+    const { drag: o } = this.getProps();
+    if (!s || !B(t, o, this.currentDirection))
+      return;
+    const i = this.getAxisMotionValue(t);
+    let r = this.originPoint[t] + s[t];
+    this.constraints && this.constraints[t] && (r = zn(r, this.constraints[t], this.elastic[t])), i.set(r);
+  }
+  resolveConstraints() {
+    var i;
+    const { dragConstraints: t, dragElastic: n } = this.getProps(), s = this.visualElement.projection && !this.visualElement.projection.layout ? this.visualElement.projection.measure(!1) : (i = this.visualElement.projection) == null ? void 0 : i.layout, o = this.constraints;
+    t && F(t) ? this.constraints || (this.constraints = this.resolveRefConstraints()) : t && s ? this.constraints = $n(s.layoutBox, t) : this.constraints = !1, this.elastic = qn(n), o !== this.constraints && !F(t) && s && this.constraints && !this.hasMutatedConstraints && D((r) => {
+      this.constraints !== !1 && this.getAxisMotionValue(r) && (this.constraints[r] = Xn(s.layoutBox[r], this.constraints[r]));
+    });
+  }
+  resolveRefConstraints() {
+    const { dragConstraints: t, onMeasureDragConstraints: n } = this.getProps();
+    if (!t || !F(t))
+      return !1;
+    const s = t.current;
+    Ut(s !== null, "If `dragConstraints` is set as a React ref, that ref must be passed to another component's `ref` prop.", "drag-constraints-ref");
+    const { projection: o } = this.visualElement;
+    if (!o || !o.layout)
+      return !1;
+    const i = We(s, o.root, this.visualElement.getTransformPagePoint());
+    let r = _n(o.layout.layoutBox, i);
+    if (n) {
+      const a = n(He(r));
+      this.hasMutatedConstraints = !!a, a && (r = Ne(a));
+    }
+    return r;
+  }
+  startAnimation(t) {
+    const { drag: n, dragMomentum: s, dragElastic: o, dragTransition: i, dragSnapToOrigin: r, onDragTransitionEnd: a } = this.getProps(), f = this.constraints || {}, d = D((m) => {
+      if (!B(m, n, this.currentDirection))
+        return;
+      let u = f && f[m] || {};
+      (r === !0 || r === m) && (u = { min: 0, max: 0 });
+      const c = o ? 200 : 1e6, h = o ? 40 : 1e7, l = {
+        type: "inertia",
+        velocity: s ? t[m] : 0,
+        bounceStiffness: c,
+        bounceDamping: h,
+        timeConstant: 750,
+        restDelta: 1,
+        restSpeed: 10,
+        ...i,
+        ...u
+      };
+      return this.startAxisValueAnimation(m, l);
+    });
+    return Promise.all(d).then(a);
+  }
+  startAxisValueAnimation(t, n) {
+    const s = this.getAxisMotionValue(t);
+    return Ct(this.visualElement, t), s.start(Be(t, s, 0, n, this.visualElement, !1));
+  }
+  stopAnimation() {
+    D((t) => this.getAxisMotionValue(t).stop());
+  }
+  /**
+   * Drag works differently depending on which props are provided.
+   *
+   * - If _dragX and _dragY are provided, we output the gesture delta directly to those motion values.
+   * - Otherwise, we apply the delta to the x/y motion values.
+   */
+  getAxisMotionValue(t) {
+    const n = `_drag${t.toUpperCase()}`, s = this.visualElement.getProps(), o = s[n];
+    return o || this.visualElement.getValue(t, (s.initial ? s.initial[t] : void 0) || 0);
+  }
+  snapToCursor(t) {
+    D((n) => {
+      const { drag: s } = this.getProps();
+      if (!B(n, s, this.currentDirection))
+        return;
+      const { projection: o } = this.visualElement, i = this.getAxisMotionValue(n);
+      if (o && o.layout) {
+        const { min: r, max: a } = o.layout.layoutBox[n], f = i.get() || 0;
+        i.set(t[n] - Y(r, a, 0.5) + f);
+      }
+    });
+  }
+  /**
+   * When the viewport resizes we want to check if the measured constraints
+   * have changed and, if so, reposition the element within those new constraints
+   * relative to where it was before the resize.
+   */
+  scalePositionWithinConstraints() {
+    if (!this.visualElement.current)
+      return;
+    const { drag: t, dragConstraints: n } = this.getProps(), { projection: s } = this.visualElement;
+    if (!F(n) || !s || !this.constraints)
+      return;
+    this.stopAnimation();
+    const o = { x: 0, y: 0 };
+    D((r) => {
+      const a = this.getAxisMotionValue(r);
+      if (a && this.constraints !== !1) {
+        const f = a.get();
+        o[r] = Yn({ min: f, max: f }, this.constraints[r]);
+      }
+    });
+    const { transformTemplate: i } = this.visualElement.getProps();
+    this.visualElement.current.style.transform = i ? i({}, "") : "none", s.root && s.root.updateScroll(), s.updateLayout(), this.constraints = !1, this.resolveConstraints(), D((r) => {
+      if (!B(r, t, null))
+        return;
+      const a = this.getAxisMotionValue(r), { min: f, max: d } = this.constraints[r];
+      a.set(Y(f, d, o[r]));
+    }), this.visualElement.render();
+  }
+  addListeners() {
+    if (!this.visualElement.current)
+      return;
+    Kn.set(this.visualElement, this);
+    const t = this.visualElement.current, n = j(t, "pointerdown", (d) => {
+      const { drag: m, dragListener: u = !0 } = this.getProps(), c = d.target, h = c !== t && $e(c);
+      m && u && !h && this.start(d);
+    });
+    let s;
+    const o = () => {
+      const { dragConstraints: d } = this.getProps();
+      F(d) && d.current && (this.constraints = this.resolveRefConstraints(), s || (s = Zn(t, d.current, () => this.scalePositionWithinConstraints())));
+    }, { projection: i } = this.visualElement, r = i.addEventListener("measure", o);
+    i && !i.layout && (i.root && i.root.updateScroll(), i.updateLayout()), M.read(o);
+    const a = _(window, "resize", () => this.scalePositionWithinConstraints()), f = i.addEventListener("didUpdate", ({ delta: d, hasLayoutChanged: m }) => {
+      this.isDragging && m && (D((u) => {
+        const c = this.getAxisMotionValue(u);
+        c && (this.originPoint[u] += d[u].translate, c.set(c.get() + d[u].translate));
+      }), this.visualElement.render());
+    });
+    return () => {
+      a(), n(), r(), f && f(), s && s();
+    };
+  }
+  getProps() {
+    const t = this.visualElement.getProps(), { drag: n = !1, dragDirectionLock: s = !1, dragPropagation: o = !1, dragConstraints: i = !1, dragElastic: r = at, dragMomentum: a = !0 } = t;
+    return {
+      ...t,
+      drag: n,
+      dragDirectionLock: s,
+      dragPropagation: o,
+      dragConstraints: i,
+      dragElastic: r,
+      dragMomentum: a
+    };
+  }
+}
+function jt(e) {
+  let t = !0;
+  return () => {
+    if (t) {
+      t = !1;
+      return;
+    }
+    e();
+  };
+}
+function Zn(e, t, n) {
+  const s = xt(e, jt(n)), o = xt(t, jt(n));
+  return () => {
+    s(), o();
+  };
+}
+function B(e, t, n) {
+  return (t === !0 || t === e) && (n === null || n === e);
+}
+function Qn(e, t = 10) {
+  let n = null;
+  return Math.abs(e.y) > t ? n = "y" : Math.abs(e.x) > t && (n = "x"), n;
+}
+class ts extends A {
+  constructor(t) {
+    super(t), this.removeGroupControls = U, this.removeListeners = U, this.controls = new Jn(t);
+  }
+  mount() {
+    const { dragControls: t } = this.node.getProps();
+    t && (this.removeGroupControls = t.subscribe(this.controls)), this.removeListeners = this.controls.addListeners() || U;
+  }
+  update() {
+    const { dragControls: t } = this.node.getProps(), { dragControls: n } = this.node.prevProps || {};
+    t !== n && (this.removeGroupControls(), t && (this.removeGroupControls = t.subscribe(this.controls)));
+  }
+  unmount() {
+    this.removeGroupControls(), this.removeListeners(), this.controls.isDragging || this.controls.endPanSession();
+  }
+}
+const st = (e) => (t, n) => {
+  e && M.update(() => e(t, n), !1, !0);
+};
+class es extends A {
+  constructor() {
+    super(...arguments), this.removePointerDownListener = U;
+  }
+  onPointerDown(t) {
+    this.session = new re(t, this.createPanHandlers(), {
+      transformPagePoint: this.node.getTransformPagePoint(),
+      contextWindow: ie(this.node)
+    });
+  }
+  createPanHandlers() {
+    const { onPanSessionStart: t, onPanStart: n, onPan: s, onPanEnd: o } = this.node.getProps();
+    return {
+      onSessionStart: st(t),
+      onStart: st(n),
+      onMove: st(s),
+      onEnd: (i, r) => {
+        delete this.session, o && M.postRender(() => o(i, r));
+      }
+    };
+  }
+  mount() {
+    this.removePointerDownListener = j(this.node.current, "pointerdown", (t) => this.onPointerDown(t));
+  }
+  update() {
+    this.session && this.session.updateHandlers(this.createPanHandlers());
+  }
+  unmount() {
+    this.removePointerDownListener(), this.session && this.session.end();
+  }
+}
+let ot = !1;
+class ns extends ve {
+  /**
+   * This only mounts projection nodes for components that
+   * need measuring, we might want to do it for all components
+   * in order to incorporate transforms
+   */
+  componentDidMount() {
+    const { visualElement: t, layoutGroup: n, switchLayoutGroup: s, layoutId: o } = this.props, { projection: i } = t;
+    i && (n.group && n.group.add(i), s && s.register && o && s.register(i), ot && i.root.didUpdate(), i.addEventListener("animationComplete", () => {
+      this.safeToRemove();
+    }), i.setOptions({
+      ...i.options,
+      layoutDependency: this.props.layoutDependency,
+      onExitComplete: () => this.safeToRemove()
+    })), Ye.hasEverUpdated = !0;
+  }
+  getSnapshotBeforeUpdate(t) {
+    const { layoutDependency: n, visualElement: s, drag: o, isPresent: i } = this.props, { projection: r } = s;
+    return r && (r.isPresent = i, t.layoutDependency !== n && r.setOptions({
+      ...r.options,
+      layoutDependency: n
+    }), ot = !0, o || t.layoutDependency !== n || n === void 0 || t.isPresent !== i ? r.willUpdate() : this.safeToRemove(), t.isPresent !== i && (i ? r.promote() : r.relegate() || M.postRender(() => {
+      const a = r.getStack();
+      (!a || !a.members.length) && this.safeToRemove();
+    }))), null;
+  }
+  componentDidUpdate() {
+    const { projection: t } = this.props.visualElement;
+    t && (t.root.didUpdate(), _e.postRender(() => {
+      !t.currentAnimation && t.isLead() && this.safeToRemove();
+    }));
+  }
+  componentWillUnmount() {
+    const { visualElement: t, layoutGroup: n, switchLayoutGroup: s } = this.props, { projection: o } = t;
+    ot = !0, o && (o.scheduleCheckAfterUnmount(), n && n.group && n.group.remove(o), s && s.deregister && s.deregister(o));
+  }
+  safeToRemove() {
+    const { safeToRemove: t } = this.props;
+    t && t();
+  }
+  render() {
+    return null;
+  }
+}
+function ce(e) {
+  const [t, n] = Xt(), s = w(O);
+  return V(ns, { ...e, layoutGroup: s, switchLayoutGroup: w(se), isPresent: t, safeToRemove: n });
+}
+const ss = {
+  pan: {
+    Feature: es
+  },
+  drag: {
+    Feature: ts,
+    ProjectionNode: Yt,
+    MeasureLayout: ce
+  }
+};
+function Ot(e, t, n) {
+  const { props: s } = e;
+  e.animationState && s.whileHover && e.animationState.setActive("whileHover", n === "Start");
+  const o = "onHover" + n, i = s[o];
+  i && M.postRender(() => i(t, W(t)));
+}
+class os extends A {
+  mount() {
+    const { current: t } = this.node;
+    t && (this.unmount = Xe(t, (n, s) => (Ot(this.node, s, "Start"), (o) => Ot(this.node, o, "End"))));
+  }
+  unmount() {
+  }
+}
+class is extends A {
+  constructor() {
+    super(...arguments), this.isActive = !1;
+  }
+  onFocus() {
+    let t = !1;
+    try {
+      t = this.node.current.matches(":focus-visible");
+    } catch {
+      t = !0;
+    }
+    !t || !this.node.animationState || (this.node.animationState.setActive("whileFocus", !0), this.isActive = !0);
+  }
+  onBlur() {
+    !this.isActive || !this.node.animationState || (this.node.animationState.setActive("whileFocus", !1), this.isActive = !1);
+  }
+  mount() {
+    this.unmount = _t(_(this.node.current, "focus", () => this.onFocus()), _(this.node.current, "blur", () => this.onBlur()));
+  }
+  unmount() {
+  }
+}
+function Gt(e, t, n) {
+  const { props: s } = e;
+  if (e.current instanceof HTMLButtonElement && e.current.disabled)
+    return;
+  e.animationState && s.whileTap && e.animationState.setActive("whileTap", n === "Start");
+  const o = "onTap" + (n === "End" ? "" : n), i = s[o];
+  i && M.postRender(() => i(t, W(t)));
+}
+class rs extends A {
+  mount() {
+    const { current: t } = this.node;
+    if (!t)
+      return;
+    const { globalTapTarget: n, propagate: s } = this.node.props;
+    this.unmount = qe(t, (o, i) => (Gt(this.node, i, "Start"), (r, { success: a }) => Gt(this.node, r, a ? "End" : "Cancel")), {
+      useGlobalTarget: n,
+      stopPropagation: (s == null ? void 0 : s.tap) === !1
+    });
+  }
+  unmount() {
+  }
+}
+const ct = /* @__PURE__ */ new WeakMap(), it = /* @__PURE__ */ new WeakMap(), as = (e) => {
+  const t = ct.get(e.target);
+  t && t(e);
+}, cs = (e) => {
+  e.forEach(as);
+};
+function us({ root: e, ...t }) {
+  const n = e || document;
+  it.has(n) || it.set(n, {});
+  const s = it.get(n), o = JSON.stringify(t);
+  return s[o] || (s[o] = new IntersectionObserver(cs, { root: e, ...t })), s[o];
+}
+function ls(e, t, n) {
+  const s = us(t);
+  return ct.set(e, n), s.observe(e), () => {
+    ct.delete(e), s.unobserve(e);
+  };
+}
+const fs = {
+  some: 0,
+  all: 1
+};
+class ds extends A {
+  constructor() {
+    super(...arguments), this.hasEnteredView = !1, this.isInView = !1;
+  }
+  startObserver() {
+    this.unmount();
+    const { viewport: t = {} } = this.node.getProps(), { root: n, margin: s, amount: o = "some", once: i } = t, r = {
+      root: n ? n.current : void 0,
+      rootMargin: s,
+      threshold: typeof o == "number" ? o : fs[o]
+    }, a = (f) => {
+      const { isIntersecting: d } = f;
+      if (this.isInView === d || (this.isInView = d, i && !d && this.hasEnteredView))
+        return;
+      d && (this.hasEnteredView = !0), this.node.animationState && this.node.animationState.setActive("whileInView", d);
+      const { onViewportEnter: m, onViewportLeave: u } = this.node.getProps(), c = d ? m : u;
+      c && c(f);
+    };
+    return ls(this.node.current, r, a);
+  }
+  mount() {
+    this.startObserver();
+  }
+  update() {
+    if (typeof IntersectionObserver > "u")
+      return;
+    const { props: t, prevProps: n } = this.node;
+    ["amount", "margin", "root"].some(hs(t, n)) && this.startObserver();
+  }
+  unmount() {
+  }
+}
+function hs({ viewport: e = {} }, { viewport: t = {} } = {}) {
+  return (n) => e[n] !== t[n];
+}
+const ms = {
+  inView: {
+    Feature: ds
+  },
+  tap: {
+    Feature: rs
+  },
+  focus: {
+    Feature: is
+  },
+  hover: {
+    Feature: os
+  }
+}, ps = {
+  layout: {
+    ProjectionNode: Yt,
+    MeasureLayout: ce
+  }
+}, gs = {
+  ...Wn,
+  ...ms,
+  ...ss,
+  ...ps
+}, xs = /* @__PURE__ */ kn(gs, Fn);
+function Ss() {
+  !Ke.current && Je();
+  const [e] = $(Ze.current);
+  return process.env.NODE_ENV !== "production" && zt(e !== !0, "You have Reduced Motion enabled on your device. Animations may not appear as expected.", "reduced-motion-disabled"), e;
+}
+export {
+  ws as A,
+  Es as L,
+  Cs as M,
+  xs as m,
+  Ss as u
+};