motioncss-ui 0.1.5 → 0.1.6

package/dist/motioncss-ui.js

@@ -0,0 +1,1242 @@
+import Ne, { useRef as O, useState as oe, useEffect as z, useCallback as Rr, createContext as Be, useContext as qe } from "react";
+var ae = { exports: {} }, Z = {};
+/**
+ * @license React
+ * react-jsx-runtime.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var Ye;
+function xr() {
+  if (Ye) return Z;
+  Ye = 1;
+  var l = Ne, n = Symbol.for("react.element"), s = Symbol.for("react.fragment"), o = Object.prototype.hasOwnProperty, v = l.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner, c = { key: !0, ref: !0, __self: !0, __source: !0 };
+  function u(p, a, f) {
+    var i, h = {}, y = null, E = null;
+    f !== void 0 && (y = "" + f), a.key !== void 0 && (y = "" + a.key), a.ref !== void 0 && (E = a.ref);
+    for (i in a) o.call(a, i) && !c.hasOwnProperty(i) && (h[i] = a[i]);
+    if (p && p.defaultProps) for (i in a = p.defaultProps, a) h[i] === void 0 && (h[i] = a[i]);
+    return { $$typeof: n, type: p, key: y, ref: E, props: h, _owner: v.current };
+  }
+  return Z.Fragment = s, Z.jsx = u, Z.jsxs = u, Z;
+}
+var Q = {};
+/**
+ * @license React
+ * react-jsx-runtime.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var We;
+function _r() {
+  return We || (We = 1, process.env.NODE_ENV !== "production" && (function() {
+    var l = Ne, n = Symbol.for("react.element"), s = Symbol.for("react.portal"), o = Symbol.for("react.fragment"), v = Symbol.for("react.strict_mode"), c = Symbol.for("react.profiler"), u = Symbol.for("react.provider"), p = Symbol.for("react.context"), a = Symbol.for("react.forward_ref"), f = Symbol.for("react.suspense"), i = Symbol.for("react.suspense_list"), h = Symbol.for("react.memo"), y = Symbol.for("react.lazy"), E = Symbol.for("react.offscreen"), R = Symbol.iterator, _ = "@@iterator";
+    function k(e) {
+      if (e === null || typeof e != "object")
+        return null;
+      var r = R && e[R] || e[_];
+      return typeof r == "function" ? r : null;
+    }
+    var P = l.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+    function w(e) {
+      {
+        for (var r = arguments.length, t = new Array(r > 1 ? r - 1 : 0), d = 1; d < r; d++)
+          t[d - 1] = arguments[d];
+        F("error", e, t);
+      }
+    }
+    function F(e, r, t) {
+      {
+        var d = P.ReactDebugCurrentFrame, b = d.getStackAddendum();
+        b !== "" && (r += "%s", t = t.concat([b]));
+        var x = t.map(function(g) {
+          return String(g);
+        });
+        x.unshift("Warning: " + r), Function.prototype.apply.call(console[e], console, x);
+      }
+    }
+    var M = !1, Y = !1, I = !1, D = !1, W = !1, q;
+    q = Symbol.for("react.module.reference");
+    function V(e) {
+      return !!(typeof e == "string" || typeof e == "function" || e === o || e === c || W || e === v || e === f || e === i || D || e === E || M || Y || I || typeof e == "object" && e !== null && (e.$$typeof === y || e.$$typeof === h || e.$$typeof === u || e.$$typeof === p || e.$$typeof === a || // This needs to include all possible module reference object
+      // types supported by any Flight configuration anywhere since
+      // we don't know which Flight build this will end up being used
+      // with.
+      e.$$typeof === q || e.getModuleId !== void 0));
+    }
+    function G(e, r, t) {
+      var d = e.displayName;
+      if (d)
+        return d;
+      var b = r.displayName || r.name || "";
+      return b !== "" ? t + "(" + b + ")" : t;
+    }
+    function ye(e) {
+      return e.displayName || "Context";
+    }
+    function L(e) {
+      if (e == null)
+        return null;
+      if (typeof e.tag == "number" && w("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), typeof e == "function")
+        return e.displayName || e.name || null;
+      if (typeof e == "string")
+        return e;
+      switch (e) {
+        case o:
+          return "Fragment";
+        case s:
+          return "Portal";
+        case c:
+          return "Profiler";
+        case v:
+          return "StrictMode";
+        case f:
+          return "Suspense";
+        case i:
+          return "SuspenseList";
+      }
+      if (typeof e == "object")
+        switch (e.$$typeof) {
+          case p:
+            var r = e;
+            return ye(r) + ".Consumer";
+          case u:
+            var t = e;
+            return ye(t._context) + ".Provider";
+          case a:
+            return G(e, e.render, "ForwardRef");
+          case h:
+            var d = e.displayName || null;
+            return d !== null ? d : L(e.type) || "Memo";
+          case y: {
+            var b = e, x = b._payload, g = b._init;
+            try {
+              return L(g(x));
+            } catch {
+              return null;
+            }
+          }
+        }
+      return null;
+    }
+    var N = Object.assign, K = 0, he, me, ge, be, Ee, Re, xe;
+    function _e() {
+    }
+    _e.__reactDisabledLog = !0;
+    function ze() {
+      {
+        if (K === 0) {
+          he = console.log, me = console.info, ge = console.warn, be = console.error, Ee = console.group, Re = console.groupCollapsed, xe = console.groupEnd;
+          var e = {
+            configurable: !0,
+            enumerable: !0,
+            value: _e,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            info: e,
+            log: e,
+            warn: e,
+            error: e,
+            group: e,
+            groupCollapsed: e,
+            groupEnd: e
+          });
+        }
+        K++;
+      }
+    }
+    function Ge() {
+      {
+        if (K--, K === 0) {
+          var e = {
+            configurable: !0,
+            enumerable: !0,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            log: N({}, e, {
+              value: he
+            }),
+            info: N({}, e, {
+              value: me
+            }),
+            warn: N({}, e, {
+              value: ge
+            }),
+            error: N({}, e, {
+              value: be
+            }),
+            group: N({}, e, {
+              value: Ee
+            }),
+            groupCollapsed: N({}, e, {
+              value: Re
+            }),
+            groupEnd: N({}, e, {
+              value: xe
+            })
+          });
+        }
+        K < 0 && w("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
+      }
+    }
+    var ie = P.ReactCurrentDispatcher, se;
+    function ee(e, r, t) {
+      {
+        if (se === void 0)
+          try {
+            throw Error();
+          } catch (b) {
+            var d = b.stack.trim().match(/\n( *(at )?)/);
+            se = d && d[1] || "";
+          }
+        return `
+` + se + e;
+      }
+    }
+    var ce = !1, re;
+    {
+      var Ke = typeof WeakMap == "function" ? WeakMap : Map;
+      re = new Ke();
+    }
+    function we(e, r) {
+      if (!e || ce)
+        return "";
+      {
+        var t = re.get(e);
+        if (t !== void 0)
+          return t;
+      }
+      var d;
+      ce = !0;
+      var b = Error.prepareStackTrace;
+      Error.prepareStackTrace = void 0;
+      var x;
+      x = ie.current, ie.current = null, ze();
+      try {
+        if (r) {
+          var g = function() {
+            throw Error();
+          };
+          if (Object.defineProperty(g.prototype, "props", {
+            set: function() {
+              throw Error();
+            }
+          }), typeof Reflect == "object" && Reflect.construct) {
+            try {
+              Reflect.construct(g, []);
+            } catch (C) {
+              d = C;
+            }
+            Reflect.construct(e, [], g);
+          } else {
+            try {
+              g.call();
+            } catch (C) {
+              d = C;
+            }
+            e.call(g.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (C) {
+            d = C;
+          }
+          e();
+        }
+      } catch (C) {
+        if (C && d && typeof C.stack == "string") {
+          for (var m = C.stack.split(`
+`), j = d.stack.split(`
+`), $ = m.length - 1, S = j.length - 1; $ >= 1 && S >= 0 && m[$] !== j[S]; )
+            S--;
+          for (; $ >= 1 && S >= 0; $--, S--)
+            if (m[$] !== j[S]) {
+              if ($ !== 1 || S !== 1)
+                do
+                  if ($--, S--, S < 0 || m[$] !== j[S]) {
+                    var A = `
+` + m[$].replace(" at new ", " at ");
+                    return e.displayName && A.includes("<anonymous>") && (A = A.replace("<anonymous>", e.displayName)), typeof e == "function" && re.set(e, A), A;
+                  }
+                while ($ >= 1 && S >= 0);
+              break;
+            }
+        }
+      } finally {
+        ce = !1, ie.current = x, Ge(), Error.prepareStackTrace = b;
+      }
+      var X = e ? e.displayName || e.name : "", B = X ? ee(X) : "";
+      return typeof e == "function" && re.set(e, B), B;
+    }
+    function He(e, r, t) {
+      return we(e, !1);
+    }
+    function Ze(e) {
+      var r = e.prototype;
+      return !!(r && r.isReactComponent);
+    }
+    function te(e, r, t) {
+      if (e == null)
+        return "";
+      if (typeof e == "function")
+        return we(e, Ze(e));
+      if (typeof e == "string")
+        return ee(e);
+      switch (e) {
+        case f:
+          return ee("Suspense");
+        case i:
+          return ee("SuspenseList");
+      }
+      if (typeof e == "object")
+        switch (e.$$typeof) {
+          case a:
+            return He(e.render);
+          case h:
+            return te(e.type, r, t);
+          case y: {
+            var d = e, b = d._payload, x = d._init;
+            try {
+              return te(x(b), r, t);
+            } catch {
+            }
+          }
+        }
+      return "";
+    }
+    var H = Object.prototype.hasOwnProperty, $e = {}, Se = P.ReactDebugCurrentFrame;
+    function ne(e) {
+      if (e) {
+        var r = e._owner, t = te(e.type, e._source, r ? r.type : null);
+        Se.setExtraStackFrame(t);
+      } else
+        Se.setExtraStackFrame(null);
+    }
+    function Qe(e, r, t, d, b) {
+      {
+        var x = Function.call.bind(H);
+        for (var g in e)
+          if (x(e, g)) {
+            var m = void 0;
+            try {
+              if (typeof e[g] != "function") {
+                var j = Error((d || "React class") + ": " + t + " type `" + g + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof e[g] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
+                throw j.name = "Invariant Violation", j;
+              }
+              m = e[g](r, g, d, t, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
+            } catch ($) {
+              m = $;
+            }
+            m && !(m instanceof Error) && (ne(b), w("%s: type specification of %s `%s` is invalid; the type checker function must return `null` or an `Error` but returned a %s. You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument).", d || "React class", t, g, typeof m), ne(null)), m instanceof Error && !(m.message in $e) && ($e[m.message] = !0, ne(b), w("Failed %s type: %s", t, m.message), ne(null));
+          }
+      }
+    }
+    var er = Array.isArray;
+    function le(e) {
+      return er(e);
+    }
+    function rr(e) {
+      {
+        var r = typeof Symbol == "function" && Symbol.toStringTag, t = r && e[Symbol.toStringTag] || e.constructor.name || "Object";
+        return t;
+      }
+    }
+    function tr(e) {
+      try {
+        return Pe(e), !1;
+      } catch {
+        return !0;
+      }
+    }
+    function Pe(e) {
+      return "" + e;
+    }
+    function Te(e) {
+      if (tr(e))
+        return w("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", rr(e)), Pe(e);
+    }
+    var je = P.ReactCurrentOwner, nr = {
+      key: !0,
+      ref: !0,
+      __self: !0,
+      __source: !0
+    }, Ce, Oe;
+    function ar(e) {
+      if (H.call(e, "ref")) {
+        var r = Object.getOwnPropertyDescriptor(e, "ref").get;
+        if (r && r.isReactWarning)
+          return !1;
+      }
+      return e.ref !== void 0;
+    }
+    function or(e) {
+      if (H.call(e, "key")) {
+        var r = Object.getOwnPropertyDescriptor(e, "key").get;
+        if (r && r.isReactWarning)
+          return !1;
+      }
+      return e.key !== void 0;
+    }
+    function ir(e, r) {
+      typeof e.ref == "string" && je.current;
+    }
+    function sr(e, r) {
+      {
+        var t = function() {
+          Ce || (Ce = !0, w("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", r));
+        };
+        t.isReactWarning = !0, Object.defineProperty(e, "key", {
+          get: t,
+          configurable: !0
+        });
+      }
+    }
+    function cr(e, r) {
+      {
+        var t = function() {
+          Oe || (Oe = !0, w("%s: `ref` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", r));
+        };
+        t.isReactWarning = !0, Object.defineProperty(e, "ref", {
+          get: t,
+          configurable: !0
+        });
+      }
+    }
+    var lr = function(e, r, t, d, b, x, g) {
+      var m = {
+        // This tag allows us to uniquely identify this as a React Element
+        $$typeof: n,
+        // Built-in properties that belong on the element
+        type: e,
+        key: r,
+        ref: t,
+        props: g,
+        // Record the component responsible for creating this element.
+        _owner: x
+      };
+      return m._store = {}, Object.defineProperty(m._store, "validated", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: !1
+      }), Object.defineProperty(m, "_self", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: d
+      }), Object.defineProperty(m, "_source", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: b
+      }), Object.freeze && (Object.freeze(m.props), Object.freeze(m)), m;
+    };
+    function ur(e, r, t, d, b) {
+      {
+        var x, g = {}, m = null, j = null;
+        t !== void 0 && (Te(t), m = "" + t), or(r) && (Te(r.key), m = "" + r.key), ar(r) && (j = r.ref, ir(r, b));
+        for (x in r)
+          H.call(r, x) && !nr.hasOwnProperty(x) && (g[x] = r[x]);
+        if (e && e.defaultProps) {
+          var $ = e.defaultProps;
+          for (x in $)
+            g[x] === void 0 && (g[x] = $[x]);
+        }
+        if (m || j) {
+          var S = typeof e == "function" ? e.displayName || e.name || "Unknown" : e;
+          m && sr(g, S), j && cr(g, S);
+        }
+        return lr(e, m, j, b, d, je.current, g);
+      }
+    }
+    var ue = P.ReactCurrentOwner, ke = P.ReactDebugCurrentFrame;
+    function U(e) {
+      if (e) {
+        var r = e._owner, t = te(e.type, e._source, r ? r.type : null);
+        ke.setExtraStackFrame(t);
+      } else
+        ke.setExtraStackFrame(null);
+    }
+    var fe;
+    fe = !1;
+    function de(e) {
+      return typeof e == "object" && e !== null && e.$$typeof === n;
+    }
+    function Fe() {
+      {
+        if (ue.current) {
+          var e = L(ue.current.type);
+          if (e)
+            return `
+
+Check the render method of \`` + e + "`.";
+        }
+        return "";
+      }
+    }
+    function fr(e) {
+      return "";
+    }
+    var Me = {};
+    function dr(e) {
+      {
+        var r = Fe();
+        if (!r) {
+          var t = typeof e == "string" ? e : e.displayName || e.name;
+          t && (r = `
+
+Check the top-level render call using <` + t + ">.");
+        }
+        return r;
+      }
+    }
+    function Ae(e, r) {
+      {
+        if (!e._store || e._store.validated || e.key != null)
+          return;
+        e._store.validated = !0;
+        var t = dr(r);
+        if (Me[t])
+          return;
+        Me[t] = !0;
+        var d = "";
+        e && e._owner && e._owner !== ue.current && (d = " It was passed a child from " + L(e._owner.type) + "."), U(e), w('Each child in a list should have a unique "key" prop.%s%s See https://reactjs.org/link/warning-keys for more information.', t, d), U(null);
+      }
+    }
+    function Ie(e, r) {
+      {
+        if (typeof e != "object")
+          return;
+        if (le(e))
+          for (var t = 0; t < e.length; t++) {
+            var d = e[t];
+            de(d) && Ae(d, r);
+          }
+        else if (de(e))
+          e._store && (e._store.validated = !0);
+        else if (e) {
+          var b = k(e);
+          if (typeof b == "function" && b !== e.entries)
+            for (var x = b.call(e), g; !(g = x.next()).done; )
+              de(g.value) && Ae(g.value, r);
+        }
+      }
+    }
+    function vr(e) {
+      {
+        var r = e.type;
+        if (r == null || typeof r == "string")
+          return;
+        var t;
+        if (typeof r == "function")
+          t = r.propTypes;
+        else if (typeof r == "object" && (r.$$typeof === a || // Note: Memo only checks outer props here.
+        // Inner props are checked in the reconciler.
+        r.$$typeof === h))
+          t = r.propTypes;
+        else
+          return;
+        if (t) {
+          var d = L(r);
+          Qe(t, e.props, "prop", d, e);
+        } else if (r.PropTypes !== void 0 && !fe) {
+          fe = !0;
+          var b = L(r);
+          w("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", b || "Unknown");
+        }
+        typeof r.getDefaultProps == "function" && !r.getDefaultProps.isReactClassApproved && w("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
+      }
+    }
+    function pr(e) {
+      {
+        for (var r = Object.keys(e.props), t = 0; t < r.length; t++) {
+          var d = r[t];
+          if (d !== "children" && d !== "key") {
+            U(e), w("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", d), U(null);
+            break;
+          }
+        }
+        e.ref !== null && (U(e), w("Invalid attribute `ref` supplied to `React.Fragment`."), U(null));
+      }
+    }
+    var De = {};
+    function Le(e, r, t, d, b, x) {
+      {
+        var g = V(e);
+        if (!g) {
+          var m = "";
+          (e === void 0 || typeof e == "object" && e !== null && Object.keys(e).length === 0) && (m += " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.");
+          var j = fr();
+          j ? m += j : m += Fe();
+          var $;
+          e === null ? $ = "null" : le(e) ? $ = "array" : e !== void 0 && e.$$typeof === n ? ($ = "<" + (L(e.type) || "Unknown") + " />", m = " Did you accidentally export a JSX literal instead of a component?") : $ = typeof e, w("React.jsx: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", $, m);
+        }
+        var S = ur(e, r, t, b, x);
+        if (S == null)
+          return S;
+        if (g) {
+          var A = r.children;
+          if (A !== void 0)
+            if (d)
+              if (le(A)) {
+                for (var X = 0; X < A.length; X++)
+                  Ie(A[X], e);
+                Object.freeze && Object.freeze(A);
+              } else
+                w("React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead.");
+            else
+              Ie(A, e);
+        }
+        if (H.call(r, "key")) {
+          var B = L(e), C = Object.keys(r).filter(function(Er) {
+            return Er !== "key";
+          }), ve = C.length > 0 ? "{key: someKey, " + C.join(": ..., ") + ": ...}" : "{key: someKey}";
+          if (!De[B + ve]) {
+            var br = C.length > 0 ? "{" + C.join(": ..., ") + ": ...}" : "{}";
+            w(`A props object containing a "key" prop is being spread into JSX:
+  let props = %s;
+  <%s {...props} />
+React keys must be passed directly to JSX without using spread:
+  let props = %s;
+  <%s key={someKey} {...props} />`, ve, B, br, B), De[B + ve] = !0;
+          }
+        }
+        return e === o ? pr(S) : vr(S), S;
+      }
+    }
+    function yr(e, r, t) {
+      return Le(e, r, t, !0);
+    }
+    function hr(e, r, t) {
+      return Le(e, r, t, !1);
+    }
+    var mr = hr, gr = yr;
+    Q.Fragment = o, Q.jsx = mr, Q.jsxs = gr;
+  })()), Q;
+}
+var Ve;
+function wr() {
+  return Ve || (Ve = 1, process.env.NODE_ENV === "production" ? ae.exports = xr() : ae.exports = _r()), ae.exports;
+}
+var T = wr();
+function Or({
+  children: l,
+  strength: n = 0.3,
+  speed: s = 0.25,
+  scale: o = 1,
+  className: v = ""
+}) {
+  const c = O(null), u = (a) => {
+    const f = c.current;
+    if (!f) return;
+    const i = f.getBoundingClientRect(), h = a.clientX - (i.left + i.width / 2), y = a.clientY - (i.top + i.height / 2);
+    f.style.transform = `
+      translate(${h * n}px, ${y * n}px)
+      scale(${o})
+    `;
+  }, p = () => {
+    const a = c.current;
+    a && (a.style.transform = "translate(0, 0) scale(1)");
+  };
+  return /* @__PURE__ */ T.jsx(
+    "div",
+    {
+      ref: c,
+      className: v,
+      onMouseMove: u,
+      onMouseLeave: p,
+      style: {
+        display: "inline-block",
+        transition: `transform ${s}s ease-out`,
+        willChange: "transform"
+      },
+      children: l
+    }
+  );
+}
+function pe() {
+  const [l, n] = oe(!1);
+  return z(() => {
+    if (typeof window > "u" || !window.matchMedia) return;
+    const s = window.matchMedia("(prefers-reduced-motion: reduce)");
+    n(s.matches);
+    const o = (v) => n(v.matches);
+    return s.addEventListener("change", o), () => s.removeEventListener("change", o);
+  }, []), l;
+}
+function kr({
+  children: l,
+  tilt: n = 15,
+  scale: s = 1.03,
+  glare: o = !0,
+  perspective: v = 1e3,
+  className: c = "",
+  style: u
+}) {
+  const p = O(null), a = O(null), f = pe(), i = (y) => {
+    const E = p.current;
+    if (!E || f) return;
+    const R = E.getBoundingClientRect(), _ = (y.clientX - R.left) / R.width, k = (y.clientY - R.top) / R.height, P = (_ - 0.5) * 2 * n, w = (0.5 - k) * 2 * n;
+    E.style.transition = "transform 0.08s linear", E.style.transform = `perspective(${v}px) rotateX(${w}deg) rotateY(${P}deg) scale(${s})`;
+    const F = a.current;
+    F && (F.style.opacity = "1", F.style.background = `radial-gradient(circle at ${_ * 100}% ${k * 100}%, rgba(255,255,255,0.35), transparent 55%)`);
+  }, h = () => {
+    const y = p.current;
+    y && (y.style.transition = "transform 0.4s ease-out", y.style.transform = `perspective(${v}px) rotateX(0deg) rotateY(0deg) scale(1)`, a.current && (a.current.style.opacity = "0"));
+  };
+  return /* @__PURE__ */ T.jsxs(
+    "div",
+    {
+      ref: p,
+      className: c,
+      onMouseMove: i,
+      onMouseLeave: h,
+      style: {
+        position: "relative",
+        transformStyle: "preserve-3d",
+        willChange: "transform",
+        ...u
+      },
+      children: [
+        l,
+        o && /* @__PURE__ */ T.jsx(
+          "div",
+          {
+            ref: a,
+            "aria-hidden": "true",
+            style: {
+              position: "absolute",
+              inset: 0,
+              borderRadius: "inherit",
+              pointerEvents: "none",
+              opacity: 0,
+              transition: "opacity 0.3s ease-out"
+            }
+          }
+        )
+      ]
+    }
+  );
+}
+const $r = {
+  radial: { opacity: 1, blurScale: 1, gradient: "radial" },
+  glow: { opacity: 0.9, blurScale: 1.5, gradient: "radial" },
+  soft: { opacity: 0.7, blurScale: 2, gradient: "radial" },
+  sharp: { opacity: 1, blurScale: 0.3, gradient: "radial" },
+  neon: { opacity: 1, blurScale: 1.2, gradient: "radial" }
+};
+function Fr({
+  children: l,
+  size: n = 320,
+  intensity: s = 0.85,
+  color: o = "#ffffff",
+  blur: v = 60,
+  mode: c = "radial",
+  enabled: u = !0,
+  className: p = "",
+  style: a
+}) {
+  const f = O(null), i = O(null), h = O(!1), y = $r[c], E = Rr(
+    (R, _) => (n / 2 * y.blurScale, v * y.blurScale, c === "neon" ? `radial-gradient(${n * y.blurScale}px circle at ${R}px ${_}px,
+          ${o}33 0%,
+          ${o}22 25%,
+          ${o}11 50%,
+          transparent 75%)` : c === "sharp" ? `radial-gradient(${n * 0.4}px circle at ${R}px ${_}px,
+          ${o}dd 0%,
+          ${o}99 30%,
+          transparent 100%)` : `radial-gradient(${n * y.blurScale}px circle at ${R}px ${_}px,
+        ${o}${Math.round(s * 255).toString(16).padStart(2, "0")} 0%,
+        ${o}${Math.round(s * 0.5 * 255).toString(16).padStart(2, "0")} 40%,
+        transparent 100%)`),
+    [n, s, o, v, c, y]
+  );
+  return z(() => {
+    if (!u) return;
+    const R = f.current, _ = i.current;
+    if (!R || !_) return;
+    const k = (F) => {
+      const M = R.getBoundingClientRect(), Y = F.clientX - M.left, I = F.clientY - M.top;
+      _.style.background = E(Y, I), _.style.opacity = String(y.opacity);
+    }, P = () => {
+      h.current = !0, _.style.transition = "opacity 300ms ease", _.style.opacity = String(y.opacity);
+    }, w = () => {
+      h.current = !1, _.style.transition = "opacity 600ms ease", _.style.opacity = "0";
+    };
+    return R.addEventListener("mousemove", k), R.addEventListener("mouseenter", P), R.addEventListener("mouseleave", w), () => {
+      R.removeEventListener("mousemove", k), R.removeEventListener("mouseenter", P), R.removeEventListener("mouseleave", w);
+    };
+  }, [u, E, y]), /* @__PURE__ */ T.jsxs(
+    "div",
+    {
+      ref: f,
+      className: `motioncss-spotlight ${p}`,
+      style: {
+        position: "relative",
+        overflow: "hidden",
+        ...a
+      },
+      children: [
+        l,
+        /* @__PURE__ */ T.jsx(
+          "div",
+          {
+            ref: i,
+            "aria-hidden": "true",
+            style: {
+              position: "absolute",
+              inset: 0,
+              pointerEvents: "none",
+              opacity: 0,
+              zIndex: 10,
+              filter: v > 0 ? `blur(${v * 0.15}px)` : void 0,
+              mixBlendMode: c === "neon" ? "screen" : "normal"
+            }
+          }
+        )
+      ]
+    }
+  );
+}
+function Ue({
+  threshold: l = 0.2,
+  rootMargin: n = "0px",
+  once: s = !0
+} = {}) {
+  const o = O(null), [v, c] = oe(!1);
+  return z(() => {
+    const u = o.current;
+    if (!u) return;
+    if (typeof IntersectionObserver > "u") {
+      c(!0);
+      return;
+    }
+    const p = new IntersectionObserver(
+      ([a]) => {
+        a.isIntersecting ? (c(!0), s && p.disconnect()) : s || c(!1);
+      },
+      { threshold: l, rootMargin: n }
+    );
+    return p.observe(u), () => p.disconnect();
+  }, [l, n, s]), { ref: o, inView: v };
+}
+function Mr({
+  children: l,
+  stagger: n = 70,
+  duration: s = 700,
+  delay: o = 0,
+  once: v = !0,
+  as: c = "div",
+  className: u = "",
+  style: p
+}) {
+  const { ref: a, inView: f } = Ue({ once: v }), i = pe(), h = c, y = l.split(/\s+/).filter(Boolean), E = f || i;
+  return /* @__PURE__ */ T.jsx(h, { ref: a, className: u, style: p, "aria-label": l, children: y.map((R, _) => /* @__PURE__ */ T.jsx(
+    "span",
+    {
+      "aria-hidden": "true",
+      style: {
+        display: "inline-block",
+        overflow: "hidden",
+        verticalAlign: "top",
+        paddingBottom: "0.15em",
+        marginRight: "0.25em"
+      },
+      children: /* @__PURE__ */ T.jsx(
+        "span",
+        {
+          style: {
+            display: "inline-block",
+            transform: E ? "translateY(0)" : "translateY(110%)",
+            opacity: E ? 1 : 0,
+            transition: i ? "none" : `transform ${s}ms cubic-bezier(0.22, 1, 0.36, 1) ${o + _ * n}ms, opacity ${s}ms ease ${o + _ * n}ms`
+          },
+          children: R
+        }
+      )
+    },
+    _
+  )) });
+}
+function Sr(l, n) {
+  switch (l) {
+    case "fade-up":
+      return `translateY(${n}px)`;
+    case "fade-down":
+      return `translateY(${-n}px)`;
+    case "fade-left":
+      return `translateX(${n}px)`;
+    case "fade-right":
+      return `translateX(${-n}px)`;
+    case "zoom":
+      return "scale(0.92)";
+    default:
+      return "none";
+  }
+}
+function Ar({
+  children: l,
+  animation: n = "fade-up",
+  duration: s = 700,
+  delay: o = 0,
+  distance: v = 32,
+  threshold: c = 0.2,
+  once: u = !0,
+  className: p = "",
+  style: a
+}) {
+  const { ref: f, inView: i } = Ue({ threshold: c, once: u }), h = pe(), y = i || h;
+  return /* @__PURE__ */ T.jsx(
+    "div",
+    {
+      ref: f,
+      className: p,
+      style: {
+        opacity: y ? 1 : 0,
+        transform: y ? "none" : Sr(n, v),
+        transition: h ? "none" : `opacity ${s}ms ease ${o}ms, transform ${s}ms cubic-bezier(0.22, 1, 0.36, 1) ${o}ms`,
+        willChange: "opacity, transform",
+        ...a
+      },
+      children: l
+    }
+  );
+}
+function Ir({
+  children: l,
+  colors: n = ["#6366f1", "#ec4899", "#f59e0b", "#06b6d4"],
+  angle: s = 120,
+  duration: o = 12,
+  className: v = "",
+  style: c
+}) {
+  const u = [...n, n[0]].join(", ");
+  return /* @__PURE__ */ T.jsx(
+    "div",
+    {
+      className: `mcss-gradient-flow ${v}`.trim(),
+      style: {
+        backgroundImage: `linear-gradient(${s}deg, ${u})`,
+        animationDuration: `${o}s`,
+        ...c
+      },
+      children: l
+    }
+  );
+}
+function Pr(l, n, s, o) {
+  const v = [], c = s;
+  if (l === "left" || l === "right") {
+    const u = l === "left", p = u ? n * 100 : 100 - n * 100, a = u ? p - 100 : p + 100;
+    v.push(`${a}% 0%`), v.push(`${a}% 100%`);
+    for (let f = o; f >= 0; f--) {
+      const i = f / o, h = i * 100, y = Math.sin(i * Math.PI) * c, E = p + (u ? y : -y);
+      v.push(`${E}% ${h}%`);
+    }
+  } else {
+    const u = l === "top", p = u ? n * 100 : 100 - n * 100, a = u ? p - 100 : p + 100;
+    v.push(`0% ${a}%`), v.push(`100% ${a}%`);
+    for (let f = o; f >= 0; f--) {
+      const i = f / o, h = i * 100, y = Math.sin(i * Math.PI) * c, E = p + (u ? y : -y);
+      v.push(`${h}% ${E}%`);
+    }
+  }
+  return `polygon(${v.join(", ")})`;
+}
+function Dr({
+  origin: l = "left",
+  duration: n = 900,
+  color: s = "#111111",
+  curve: o = 8,
+  resolution: v = 20,
+  blur: c = 0,
+  onComplete: u,
+  style: p
+}) {
+  const a = O(null), f = O(null), i = O(null);
+  return z(() => {
+    const h = a.current;
+    if (!h) return;
+    const y = (E) => {
+      i.current || (i.current = E);
+      const R = E - i.current, _ = Math.min(R / n, 1) * 2;
+      h.style.clipPath = Pr(l, _, o, v), _ < 2 ? f.current = requestAnimationFrame(y) : (h.style.clipPath = "polygon(200% 0%, 200% 100%, 100% 100%, 100% 0%)", u == null || u());
+    };
+    return f.current = requestAnimationFrame(y), () => {
+      f.current && cancelAnimationFrame(f.current);
+    };
+  }, [l, n, o, v, u]), /* @__PURE__ */ T.jsx(
+    "div",
+    {
+      ref: a,
+      "aria-hidden": "true",
+      style: {
+        position: "fixed",
+        inset: 0,
+        zIndex: 9999,
+        pointerEvents: "none",
+        background: s,
+        backdropFilter: c > 0 ? `blur(${c}px)` : void 0,
+        WebkitBackdropFilter: c > 0 ? `blur(${c}px)` : void 0,
+        ...p
+      }
+    }
+  );
+}
+function Lr({
+  children: l,
+  origin: n = "left",
+  duration: s = 900,
+  color: o = "#111111",
+  curve: v = 8,
+  blur: c = 0,
+  className: u = "",
+  style: p
+}) {
+  const a = O(null), f = O(null), i = O(null), [h, y] = oe(!1);
+  return z(() => {
+    const E = a.current;
+    if (!E) return;
+    const R = (_) => {
+      i.current || (i.current = _);
+      const k = Math.min((_ - i.current) / s, 1), P = [], w = v, F = 20;
+      if (n === "left" || n === "right") {
+        const M = n === "left", Y = M ? k * 100 : 100 - k * 100, I = M ? 150 : -50;
+        for (let D = 0; D <= F; D++) {
+          const W = D / F, q = W * 100, V = Math.sin(W * Math.PI) * w, G = Y + (M ? V : -V);
+          P.push(`${G}% ${q}%`);
+        }
+        P.push(`${I}% 100%`), P.push(`${I}% 0%`);
+      } else {
+        const M = n === "top", Y = M ? k * 100 : 100 - k * 100, I = M ? 150 : -50;
+        for (let D = 0; D <= F; D++) {
+          const W = D / F, q = W * 100, V = Math.sin(W * Math.PI) * w, G = Y + (M ? V : -V);
+          P.push(`${q}% ${G}%`);
+        }
+        P.push(`100% ${I}%`), P.push(`0% ${I}%`);
+      }
+      E.style.clipPath = `polygon(${P.join(", ")})`, k < 1 ? f.current = requestAnimationFrame(R) : (E.style.clipPath = "none", E.style.display = "none", y(!0));
+    };
+    return f.current = requestAnimationFrame(R), () => {
+      f.current && cancelAnimationFrame(f.current);
+    };
+  }, [n, s, o, v]), /* @__PURE__ */ T.jsxs(
+    "div",
+    {
+      className: `motioncss-wave-reveal ${u}`,
+      style: { position: "relative", overflow: "hidden", ...p },
+      children: [
+        l,
+        !h && /* @__PURE__ */ T.jsx(
+          "div",
+          {
+            ref: a,
+            "aria-hidden": "true",
+            style: {
+              position: "absolute",
+              inset: 0,
+              background: o,
+              backdropFilter: c > 0 ? `blur(${c}px)` : void 0,
+              WebkitBackdropFilter: c > 0 ? `blur(${c}px)` : void 0,
+              zIndex: 10,
+              pointerEvents: "none"
+            }
+          }
+        )
+      ]
+    }
+  );
+}
+const Xe = Be(null);
+function Tr() {
+  const l = qe(Xe);
+  if (!l)
+    throw new Error(
+      "useScrollytelling must be used inside <Scrollytelling>"
+    );
+  return l;
+}
+function Yr({
+  children: l,
+  height: n = "400vh",
+  className: s = "",
+  style: o
+}) {
+  const v = O(null), [c, u] = oe(0);
+  return z(() => {
+    let p = 0;
+    const a = () => {
+      p || (p = requestAnimationFrame(() => {
+        p = 0;
+        const f = v.current;
+        if (!f) return;
+        const i = f.getBoundingClientRect(), h = i.height - window.innerHeight;
+        if (h <= 0) {
+          u(0);
+          return;
+        }
+        const y = -i.top / h, E = Math.min(
+          1,
+          Math.max(0, y)
+        );
+        u(E);
+      }));
+    };
+    return a(), window.addEventListener("scroll", a, {
+      passive: !0
+    }), window.addEventListener("resize", a), () => {
+      window.removeEventListener("scroll", a), window.removeEventListener("resize", a), p && cancelAnimationFrame(p);
+    };
+  }, []), /* @__PURE__ */ T.jsx(Xe.Provider, { value: { progress: c }, children: /* @__PURE__ */ T.jsx(
+    "section",
+    {
+      ref: v,
+      className: `motioncss-scrollytelling ${s}`,
+      style: {
+        height: n,
+        position: "relative",
+        ...o
+      },
+      children: /* @__PURE__ */ T.jsx(
+        "div",
+        {
+          className: "motioncss-scrollytelling__stage",
+          style: {
+            position: "sticky",
+            top: 0,
+            width: "100%",
+            height: "100vh",
+            overflow: "hidden"
+          },
+          children: l
+        }
+      )
+    }
+  ) });
+}
+const Je = Be(null);
+function jr() {
+  const l = qe(Je);
+  if (!l)
+    throw new Error(
+      "useSceneProgress must be used inside <Scene>"
+    );
+  return l;
+}
+function Wr({
+  children: l,
+  start: n,
+  end: s,
+  fadeOutRange: o = 0.05,
+  className: v = "",
+  style: c
+}) {
+  const { progress: u } = Tr(), p = Math.max(s - n, 1e-4), a = (u - n) / p, f = Math.min(
+    1,
+    Math.max(0, a)
+  );
+  let i = 1;
+  if (o > 0 && u > s) {
+    const h = u - s;
+    i = 1 - Math.min(1, h / o);
+  } else o === 0 && u > s && (i = 0);
+  return /* @__PURE__ */ T.jsx(
+    Je.Provider,
+    {
+      value: {
+        progress: f
+      },
+      children: /* @__PURE__ */ T.jsx(
+        "div",
+        {
+          className: `motioncss-scene ${v}`,
+          style: {
+            position: "absolute",
+            inset: 0,
+            opacity: i,
+            pointerEvents: f > 0 && f < 1 ? "auto" : "none",
+            ...c
+          },
+          children: l
+        }
+      )
+    }
+  );
+}
+function J(l = 0, n = 0, s) {
+  return l + (n - l) * s;
+}
+function Vr({
+  children: l,
+  from: n = {},
+  to: s = {},
+  className: o = "",
+  style: v
+}) {
+  const { progress: c } = jr(), u = J(
+    n.opacity ?? 1,
+    s.opacity ?? 1,
+    c
+  ), p = J(
+    n.scale ?? 1,
+    s.scale ?? 1,
+    c
+  ), a = J(
+    n.x ?? 0,
+    s.x ?? 0,
+    c
+  ), f = J(
+    n.y ?? 0,
+    s.y ?? 0,
+    c
+  ), i = J(
+    n.rotate ?? 0,
+    s.rotate ?? 0,
+    c
+  ), h = J(
+    n.blur ?? 0,
+    s.blur ?? 0,
+    c
+  );
+  return /* @__PURE__ */ T.jsx(
+    "div",
+    {
+      className: `motioncss-scroll-layer ${o}`,
+      style: {
+        opacity: u,
+        transform: `
+          translate3d(${a}px, ${f}px, 0)
+          scale(${p})
+          rotate(${i}deg)
+        `,
+        filter: h > 0 ? `blur(${h}px)` : "none",
+        willChange: "transform, opacity, filter",
+        ...v
+      },
+      children: l
+    }
+  );
+}
+export {
+  Dr as EdgeWave,
+  Ir as GradientFlow,
+  Or as Magnetic,
+  Mr as RevealText,
+  Wr as Scene,
+  Vr as ScrollLayer,
+  Ar as ScrollReveal,
+  Yr as Scrollytelling,
+  Fr as Spotlight,
+  kr as TiltCard,
+  Lr as WaveReveal,
+  jr as useSceneProgress,
+  Tr as useScrollytelling
+};