react-three-rapier-unified 1.0.0

package/dist/index.esm.js

@@ -0,0 +1,1667 @@
+import { Vector3 as Qe, Quaternion as at, ActiveEvents as Je, ColliderDesc as kt, EventQueue as It, RigidBodyDesc as Wt } from "@dimforge/rapier3d-compat";
+import { CoefficientCombineRule as bo, Collider as xo, RigidBody as Co } from "@dimforge/rapier3d-compat";
+import ne, { useRef as D, useEffect as N, memo as he, useMemo as ve, useContext as Ct, useState as vt, createContext as Et, useCallback as Ge, Fragment as zt } from "react";
+import { useFrame as Ze, useThree as ht } from "@react-three/fiber";
+import { Quaternion as qe, Euler as Ue, Vector3 as G, Object3D as Dt, Matrix4 as Vt, BufferGeometry as Jt, BufferAttribute as lt, MathUtils as Ht, DynamicDrawUsage as Yt, Mesh as Gt, SphereGeometry as qt, MeshBasicMaterial as Ut } from "three";
+import { suspend as $t } from "suspend-react";
+import { mergeVertices as Lt, VertexNormalsHelper as Qt } from "three-stdlib";
+var He = { exports: {} }, Oe = {};
+/**
+ * @license React
+ * react-jsx-runtime.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var ut;
+function Xt() {
+  if (ut) return Oe;
+  ut = 1;
+  var e = Symbol.for("react.transitional.element"), t = Symbol.for("react.fragment");
+  function o(n, i, s) {
+    var c = null;
+    if (s !== void 0 && (c = "" + s), i.key !== void 0 && (c = "" + i.key), "key" in i) {
+      s = {};
+      for (var a in i)
+        a !== "key" && (s[a] = i[a]);
+    } else s = i;
+    return i = s.ref, {
+      $$typeof: e,
+      type: n,
+      key: c,
+      ref: i !== void 0 ? i : null,
+      props: s
+    };
+  }
+  return Oe.Fragment = t, Oe.jsx = o, Oe.jsxs = o, Oe;
+}
+var _e = {};
+/**
+ * @license React
+ * react-jsx-runtime.development.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var dt;
+function Zt() {
+  return dt || (dt = 1, process.env.NODE_ENV !== "production" && (function() {
+    function e(r) {
+      if (r == null) return null;
+      if (typeof r == "function")
+        return r.$$typeof === ue ? null : r.displayName || r.name || null;
+      if (typeof r == "string") return r;
+      switch (r) {
+        case V:
+          return "Fragment";
+        case _:
+          return "Portal";
+        case we:
+          return "Profiler";
+        case Te:
+          return "StrictMode";
+        case je:
+          return "Suspense";
+        case Pe:
+          return "SuspenseList";
+      }
+      if (typeof r == "object")
+        switch (typeof r.tag == "number" && console.error(
+          "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
+        ), r.$$typeof) {
+          case Re:
+            return (r.displayName || "Context") + ".Provider";
+          case Se:
+            return (r._context.displayName || "Context") + ".Consumer";
+          case Me:
+            var u = r.render;
+            return r = r.displayName, r || (r = u.displayName || u.name || "", r = r !== "" ? "ForwardRef(" + r + ")" : "ForwardRef"), r;
+          case A:
+            return u = r.displayName || null, u !== null ? u : e(r.type) || "Memo";
+          case Fe:
+            u = r._payload, r = r._init;
+            try {
+              return e(r(u));
+            } catch {
+            }
+        }
+      return null;
+    }
+    function t(r) {
+      return "" + r;
+    }
+    function o(r) {
+      try {
+        t(r);
+        var u = !1;
+      } catch {
+        u = !0;
+      }
+      if (u) {
+        u = console;
+        var l = u.error, C = typeof Symbol == "function" && Symbol.toStringTag && r[Symbol.toStringTag] || r.constructor.name || "Object";
+        return l.call(
+          u,
+          "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
+          C
+        ), t(r);
+      }
+    }
+    function n() {
+    }
+    function i() {
+      if (U === 0) {
+        xe = console.log, K = console.info, fe = console.warn, d = console.error, T = console.group, E = console.groupCollapsed, y = console.groupEnd;
+        var r = {
+          configurable: !0,
+          enumerable: !0,
+          value: n,
+          writable: !0
+        };
+        Object.defineProperties(console, {
+          info: r,
+          log: r,
+          warn: r,
+          error: r,
+          group: r,
+          groupCollapsed: r,
+          groupEnd: r
+        });
+      }
+      U++;
+    }
+    function s() {
+      if (U--, U === 0) {
+        var r = { configurable: !0, enumerable: !0, writable: !0 };
+        Object.defineProperties(console, {
+          log: de({}, r, { value: xe }),
+          info: de({}, r, { value: K }),
+          warn: de({}, r, { value: fe }),
+          error: de({}, r, { value: d }),
+          group: de({}, r, { value: T }),
+          groupCollapsed: de({}, r, { value: E }),
+          groupEnd: de({}, r, { value: y })
+        });
+      }
+      0 > U && console.error(
+        "disabledDepth fell below zero. This is a bug in React. Please file an issue."
+      );
+    }
+    function c(r) {
+      if (w === void 0)
+        try {
+          throw Error();
+        } catch (l) {
+          var u = l.stack.trim().match(/\n( *(at )?)/);
+          w = u && u[1] || "", k = -1 < l.stack.indexOf(`
+    at`) ? " (<anonymous>)" : -1 < l.stack.indexOf("@") ? "@unknown:0:0" : "";
+        }
+      return `
+` + w + r + k;
+    }
+    function a(r, u) {
+      if (!r || B) return "";
+      var l = J.get(r);
+      if (l !== void 0) return l;
+      B = !0, l = Error.prepareStackTrace, Error.prepareStackTrace = void 0;
+      var C = null;
+      C = Z.H, Z.H = null, i();
+      try {
+        var j = {
+          DetermineComponentFrameRoot: function() {
+            try {
+              if (u) {
+                var X = function() {
+                  throw Error();
+                };
+                if (Object.defineProperty(X.prototype, "props", {
+                  set: function() {
+                    throw Error();
+                  }
+                }), typeof Reflect == "object" && Reflect.construct) {
+                  try {
+                    Reflect.construct(X, []);
+                  } catch ($) {
+                    var Ce = $;
+                  }
+                  Reflect.construct(r, [], X);
+                } else {
+                  try {
+                    X.call();
+                  } catch ($) {
+                    Ce = $;
+                  }
+                  r.call(X.prototype);
+                }
+              } else {
+                try {
+                  throw Error();
+                } catch ($) {
+                  Ce = $;
+                }
+                (X = r()) && typeof X.catch == "function" && X.catch(function() {
+                });
+              }
+            } catch ($) {
+              if ($ && Ce && typeof $.stack == "string")
+                return [$.stack, Ce.stack];
+            }
+            return [null, null];
+          }
+        };
+        j.DetermineComponentFrameRoot.displayName = "DetermineComponentFrameRoot";
+        var h = Object.getOwnPropertyDescriptor(
+          j.DetermineComponentFrameRoot,
+          "name"
+        );
+        h && h.configurable && Object.defineProperty(
+          j.DetermineComponentFrameRoot,
+          "name",
+          { value: "DetermineComponentFrameRoot" }
+        );
+        var m = j.DetermineComponentFrameRoot(), re = m[0], ie = m[1];
+        if (re && ie) {
+          var I = re.split(`
+`), oe = ie.split(`
+`);
+          for (m = h = 0; h < I.length && !I[h].includes(
+            "DetermineComponentFrameRoot"
+          ); )
+            h++;
+          for (; m < oe.length && !oe[m].includes(
+            "DetermineComponentFrameRoot"
+          ); )
+            m++;
+          if (h === I.length || m === oe.length)
+            for (h = I.length - 1, m = oe.length - 1; 1 <= h && 0 <= m && I[h] !== oe[m]; )
+              m--;
+          for (; 1 <= h && 0 <= m; h--, m--)
+            if (I[h] !== oe[m]) {
+              if (h !== 1 || m !== 1)
+                do
+                  if (h--, m--, 0 > m || I[h] !== oe[m]) {
+                    var pe = `
+` + I[h].replace(
+                      " at new ",
+                      " at "
+                    );
+                    return r.displayName && pe.includes("<anonymous>") && (pe = pe.replace("<anonymous>", r.displayName)), typeof r == "function" && J.set(r, pe), pe;
+                  }
+                while (1 <= h && 0 <= m);
+              break;
+            }
+        }
+      } finally {
+        B = !1, Z.H = C, s(), Error.prepareStackTrace = l;
+      }
+      return I = (I = r ? r.displayName || r.name : "") ? c(I) : "", typeof r == "function" && J.set(r, I), I;
+    }
+    function x(r) {
+      if (r == null) return "";
+      if (typeof r == "function") {
+        var u = r.prototype;
+        return a(
+          r,
+          !(!u || !u.isReactComponent)
+        );
+      }
+      if (typeof r == "string") return c(r);
+      switch (r) {
+        case je:
+          return c("Suspense");
+        case Pe:
+          return c("SuspenseList");
+      }
+      if (typeof r == "object")
+        switch (r.$$typeof) {
+          case Me:
+            return r = a(r.render, !1), r;
+          case A:
+            return x(r.type);
+          case Fe:
+            u = r._payload, r = r._init;
+            try {
+              return x(r(u));
+            } catch {
+            }
+        }
+      return "";
+    }
+    function g() {
+      var r = Z.A;
+      return r === null ? null : r.getOwner();
+    }
+    function f(r) {
+      if (Be.call(r, "key")) {
+        var u = Object.getOwnPropertyDescriptor(r, "key").get;
+        if (u && u.isReactWarning) return !1;
+      }
+      return r.key !== void 0;
+    }
+    function R(r, u) {
+      function l() {
+        ee || (ee = !0, console.error(
+          "%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://react.dev/link/special-props)",
+          u
+        ));
+      }
+      l.isReactWarning = !0, Object.defineProperty(r, "key", {
+        get: l,
+        configurable: !0
+      });
+    }
+    function v() {
+      var r = e(this.type);
+      return me[r] || (me[r] = !0, console.error(
+        "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
+      )), r = this.props.ref, r !== void 0 ? r : null;
+    }
+    function M(r, u, l, C, j, h) {
+      return l = h.ref, r = {
+        $$typeof: le,
+        type: r,
+        key: u,
+        props: h,
+        _owner: j
+      }, (l !== void 0 ? l : null) !== null ? Object.defineProperty(r, "ref", {
+        enumerable: !1,
+        get: v
+      }) : Object.defineProperty(r, "ref", { enumerable: !1, value: null }), r._store = {}, Object.defineProperty(r._store, "validated", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: 0
+      }), Object.defineProperty(r, "_debugInfo", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: null
+      }), Object.freeze && (Object.freeze(r.props), Object.freeze(r)), r;
+    }
+    function P(r, u, l, C, j, h) {
+      if (typeof r == "string" || typeof r == "function" || r === V || r === we || r === Te || r === je || r === Pe || r === Le || typeof r == "object" && r !== null && (r.$$typeof === Fe || r.$$typeof === A || r.$$typeof === Re || r.$$typeof === Se || r.$$typeof === Me || r.$$typeof === Y || r.getModuleId !== void 0)) {
+        var m = u.children;
+        if (m !== void 0)
+          if (C)
+            if (S(m)) {
+              for (C = 0; C < m.length; C++)
+                Q(m[C], r);
+              Object.freeze && Object.freeze(m);
+            } else
+              console.error(
+                "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 Q(m, r);
+      } else
+        m = "", (r === void 0 || typeof r == "object" && r !== null && Object.keys(r).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."), r === null ? C = "null" : S(r) ? C = "array" : r !== void 0 && r.$$typeof === le ? (C = "<" + (e(r.type) || "Unknown") + " />", m = " Did you accidentally export a JSX literal instead of a component?") : C = typeof r, console.error(
+          "React.jsx: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s",
+          C,
+          m
+        );
+      if (Be.call(u, "key")) {
+        m = e(r);
+        var re = Object.keys(u).filter(function(I) {
+          return I !== "key";
+        });
+        C = 0 < re.length ? "{key: someKey, " + re.join(": ..., ") + ": ...}" : "{key: someKey}", te[m + C] || (re = 0 < re.length ? "{" + re.join(": ..., ") + ": ...}" : "{}", console.error(
+          `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} />`,
+          C,
+          m,
+          re,
+          m
+        ), te[m + C] = !0);
+      }
+      if (m = null, l !== void 0 && (o(l), m = "" + l), f(u) && (o(u.key), m = "" + u.key), "key" in u) {
+        l = {};
+        for (var ie in u)
+          ie !== "key" && (l[ie] = u[ie]);
+      } else l = u;
+      return m && R(
+        l,
+        typeof r == "function" ? r.displayName || r.name || "Unknown" : r
+      ), M(r, m, h, j, g(), l);
+    }
+    function Q(r, u) {
+      if (typeof r == "object" && r && r.$$typeof !== ae) {
+        if (S(r))
+          for (var l = 0; l < r.length; l++) {
+            var C = r[l];
+            p(C) && W(C, u);
+          }
+        else if (p(r))
+          r._store && (r._store.validated = 1);
+        else if (r === null || typeof r != "object" ? l = null : (l = be && r[be] || r["@@iterator"], l = typeof l == "function" ? l : null), typeof l == "function" && l !== r.entries && (l = l.call(r), l !== r))
+          for (; !(r = l.next()).done; )
+            p(r.value) && W(r.value, u);
+      }
+    }
+    function p(r) {
+      return typeof r == "object" && r !== null && r.$$typeof === le;
+    }
+    function W(r, u) {
+      if (r._store && !r._store.validated && r.key == null && (r._store.validated = 1, u = F(u), !ge[u])) {
+        ge[u] = !0;
+        var l = "";
+        r && r._owner != null && r._owner !== g() && (l = null, typeof r._owner.tag == "number" ? l = e(r._owner.type) : typeof r._owner.name == "string" && (l = r._owner.name), l = " It was passed a child from " + l + ".");
+        var C = Z.getCurrentStack;
+        Z.getCurrentStack = function() {
+          var j = x(r.type);
+          return C && (j += C() || ""), j;
+        }, console.error(
+          'Each child in a list should have a unique "key" prop.%s%s See https://react.dev/link/warning-keys for more information.',
+          u,
+          l
+        ), Z.getCurrentStack = C;
+      }
+    }
+    function F(r) {
+      var u = "", l = g();
+      return l && (l = e(l.type)) && (u = `
+
+Check the render method of \`` + l + "`."), u || (r = e(r)) && (u = `
+
+Check the top-level render call using <` + r + ">."), u;
+    }
+    var O = ne, le = Symbol.for("react.transitional.element"), _ = Symbol.for("react.portal"), V = Symbol.for("react.fragment"), Te = Symbol.for("react.strict_mode"), we = Symbol.for("react.profiler"), Se = Symbol.for("react.consumer"), Re = Symbol.for("react.context"), Me = Symbol.for("react.forward_ref"), je = Symbol.for("react.suspense"), Pe = Symbol.for("react.suspense_list"), A = Symbol.for("react.memo"), Fe = Symbol.for("react.lazy"), Le = Symbol.for("react.offscreen"), be = Symbol.iterator, ue = Symbol.for("react.client.reference"), Z = O.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, Be = Object.prototype.hasOwnProperty, de = Object.assign, Y = Symbol.for("react.client.reference"), S = Array.isArray, U = 0, xe, K, fe, d, T, E, y;
+    n.__reactDisabledLog = !0;
+    var w, k, B = !1, J = new (typeof WeakMap == "function" ? WeakMap : Map)(), ae = Symbol.for("react.client.reference"), ee, me = {}, te = {}, ge = {};
+    _e.Fragment = V, _e.jsx = function(r, u, l, C, j) {
+      return P(r, u, l, !1, C, j);
+    }, _e.jsxs = function(r, u, l, C, j) {
+      return P(r, u, l, !0, C, j);
+    };
+  })()), _e;
+}
+var ft;
+function Kt() {
+  return ft || (ft = 1, process.env.NODE_ENV === "production" ? He.exports = Xt() : He.exports = Zt()), He.exports;
+}
+var b = Kt();
+const er = new qe();
+new Ue();
+const tr = new G();
+new Dt();
+const ye = new Vt(), z = new G(), ce = new qe(), Ee = new G(), rr = (e) => {
+  const [t, o, n] = e;
+  return new G(t, o, n);
+}, mt = ({
+  x: e,
+  y: t,
+  z: o,
+  w: n
+}) => er.set(e, t, o, n), q = (e) => {
+  if (Array.isArray(e))
+    return new Qe(e[0], e[1], e[2]);
+  if (typeof e == "number")
+    return new Qe(e, e, e);
+  {
+    const t = e;
+    return new Qe(t.x, t.y, t.z);
+  }
+}, gt = (e) => Array.isArray(e) ? new at(e[0], e[1], e[2], e[3]) : new at(e.x, e.y, e.z, e.w), or = {
+  fixed: 1,
+  dynamic: 0,
+  kinematicPosition: 2,
+  kinematicVelocity: 3
+}, wt = (e) => or[e], nr = (e, t) => {
+  const o = Array.from(e);
+  for (let n = 0; n < e.length / 3; n++)
+    o[n * 3] *= t.x, o[n * 3 + 1] *= t.y, o[n * 3 + 2] *= t.z;
+  return o;
+}, St = (e) => e ? e instanceof qe ? [e.x, e.y, e.z, e.w] : e instanceof G || e instanceof Ue ? [e.x, e.y, e.z] : Array.isArray(e) ? e : [e] : [0];
+function se(e) {
+  const t = D(void 0);
+  return t.current === void 0 && (t.current = {
+    value: typeof e == "function" ? e() : e
+  }), t.current.value;
+}
+const ir = (e) => {
+  const t = D(e), o = D(0), n = D(0);
+  N(() => {
+    t.current = e;
+  }, [e]), N(() => {
+    const i = () => {
+      const s = performance.now(), c = s - n.current;
+      o.current = requestAnimationFrame(i), t.current(c / 1e3), n.current = s;
+    };
+    return o.current = requestAnimationFrame(i), () => cancelAnimationFrame(o.current);
+  }, []);
+}, sr = ({ onStep: e, updatePriority: t }) => (Ze((o, n) => {
+  e(n);
+}, t), null), cr = ({ onStep: e }) => (ir((t) => {
+  e(t);
+}), null), ar = ({ onStep: e, type: t, updatePriority: o }) => t === "independent" ? /* @__PURE__ */ b.jsx(cr, { onStep: e }) : /* @__PURE__ */ b.jsx(sr, { onStep: e, updatePriority: o }), lr = he(ar), ur = (e, t, o) => {
+  const n = t.slice();
+  if (e === "heightfield") {
+    const s = n[3];
+    return s.x *= o.x, s.x *= o.y, s.x *= o.z, n;
+  }
+  if (e === "trimesh" || e === "convexHull")
+    return n[0] = nr(n[0], o), n;
+  const i = [o.x, o.y, o.z, o.x, o.x];
+  return n.map((s, c) => i[c] * s);
+}, dr = (e, t, o, n) => {
+  const i = ur(e.shape, e.args, o), s = kt[e.shape](...i);
+  return t.createCollider(s, n == null ? void 0 : n());
+}, fr = [
+  "shape",
+  "args"
+], pt = "Please pick ONLY ONE of the `density`, `mass` and `massProperties` options.", mr = (e, t) => {
+  if (t.density !== void 0) {
+    if (t.mass !== void 0 || t.massProperties !== void 0)
+      throw new Error(pt);
+    e.setDensity(t.density);
+    return;
+  }
+  if (t.mass !== void 0) {
+    if (t.massProperties !== void 0)
+      throw new Error(pt);
+    e.setMass(t.mass);
+    return;
+  }
+  t.massProperties !== void 0 && e.setMassProperties(
+    t.massProperties.mass,
+    t.massProperties.centerOfMass,
+    t.massProperties.principalAngularInertia,
+    t.massProperties.angularInertiaLocalFrame
+  );
+}, Rt = {
+  sensor: (e, t) => {
+    e.setSensor(t);
+  },
+  collisionGroups: (e, t) => {
+    e.setCollisionGroups(t);
+  },
+  solverGroups: (e, t) => {
+    e.setSolverGroups(t);
+  },
+  friction: (e, t) => {
+    e.setFriction(t);
+  },
+  frictionCombineRule: (e, t) => {
+    e.setFrictionCombineRule(t);
+  },
+  restitution: (e, t) => {
+    e.setRestitution(t);
+  },
+  restitutionCombineRule: (e, t) => {
+    e.setRestitutionCombineRule(t);
+  },
+  activeCollisionTypes: (e, t) => {
+    e.setActiveCollisionTypes(t);
+  },
+  contactSkin: (e, t) => {
+    e.setContactSkin(t);
+  },
+  // To make sure the options all mutable options are listed
+  quaternion: () => {
+  },
+  position: () => {
+  },
+  rotation: () => {
+  },
+  scale: () => {
+  }
+}, jt = Object.keys(
+  Rt
+), gr = (e, t, o) => {
+  var i;
+  const n = o.get(e.handle);
+  if (n) {
+    const s = n.object.parent.getWorldScale(tr), c = (i = n.worldParent) == null ? void 0 : i.matrixWorld.clone().invert();
+    n.object.updateWorldMatrix(!0, !1), ye.copy(n.object.matrixWorld), c && ye.premultiply(c), ye.decompose(z, ce, Ee), e.parent() ? (e.setTranslationWrtParent({
+      x: z.x * s.x,
+      y: z.y * s.y,
+      z: z.z * s.z
+    }), e.setRotationWrtParent(ce)) : (e.setTranslation({
+      x: z.x * s.x,
+      y: z.y * s.y,
+      z: z.z * s.z
+    }), e.setRotation(ce)), jt.forEach((a) => {
+      if (a in t) {
+        const x = t[a];
+        Rt[a](
+          e,
+          // @ts-ignore Option does not want to fit into the function, but it will
+          x,
+          t
+        );
+      }
+    }), mr(e, t);
+  }
+}, pr = (e, t, o) => {
+  const n = ve(
+    () => jt.flatMap((i) => St(t[i])),
+    [t]
+  );
+  N(() => {
+    const i = e();
+    gr(i, t, o);
+  }, [...n, e]);
+}, yr = (e) => {
+  let t = !1;
+  return e.traverseAncestors((o) => {
+    o.userData.r3RapierType === "MeshCollider" && (t = !0);
+  }), t;
+}, br = (e, t, o) => ({
+  collider: e,
+  worldParent: o || void 0,
+  object: t
+}), xr = {
+  cuboid: "cuboid",
+  ball: "ball",
+  hull: "convexHull",
+  trimesh: "trimesh"
+}, Cr = ({ object: e, ignoreMeshColliders: t = !0, options: o }) => {
+  const n = [];
+  e.updateWorldMatrix(!0, !1);
+  const i = e.matrixWorld.clone().invert(), s = (c) => {
+    if ("isMesh" in c) {
+      if (t && yr(c)) return;
+      const a = c.getWorldScale(Ee), x = xr[o.colliders || "cuboid"];
+      c.updateWorldMatrix(!0, !1), ye.copy(c.matrixWorld).premultiply(i).decompose(z, ce, Ee);
+      const g = new Ue().setFromQuaternion(ce, "XYZ"), { geometry: f } = c, { args: R, offset: v } = vr(
+        f,
+        o.colliders || "cuboid"
+      ), M = {
+        ...At(o),
+        args: R,
+        shape: x,
+        rotation: [g.x, g.y, g.z],
+        position: [
+          z.x + v.x * a.x,
+          z.y + v.y * a.y,
+          z.z + v.z * a.z
+        ],
+        scale: [a.x, a.y, a.z]
+      };
+      n.push(M);
+    }
+  };
+  return o.includeInvisible ? e.traverse(s) : e.traverseVisible(s), n;
+}, vr = (e, t) => {
+  var o;
+  switch (t) {
+    case "cuboid": {
+      e.computeBoundingBox();
+      const { boundingBox: n } = e, i = n.getSize(new G());
+      return {
+        args: [i.x / 2, i.y / 2, i.z / 2],
+        offset: n.getCenter(new G())
+      };
+    }
+    case "ball": {
+      e.computeBoundingSphere();
+      const { boundingSphere: n } = e;
+      return {
+        args: [n.radius],
+        offset: n.center
+      };
+    }
+    case "trimesh": {
+      const n = e.index ? e.clone() : Lt(e);
+      return {
+        args: [
+          n.attributes.position.array,
+          (o = n.index) == null ? void 0 : o.array
+        ],
+        offset: new G()
+      };
+    }
+    case "hull":
+      return {
+        args: [e.clone().attributes.position.array],
+        offset: new G()
+      };
+  }
+  return { args: [], offset: new G() };
+}, Pt = (e) => ({
+  collision: !!(e != null && e.onCollisionEnter || e != null && e.onCollisionExit || e != null && e.onIntersectionEnter || e != null && e.onIntersectionExit),
+  contactForce: !!(e != null && e.onContactForce)
+}), Er = (e, t, o, n = {}) => {
+  const {
+    onCollisionEnter: i,
+    onCollisionExit: s,
+    onIntersectionEnter: c,
+    onIntersectionExit: a,
+    onContactForce: x
+  } = t;
+  N(() => {
+    const g = e();
+    if (g) {
+      const {
+        collision: f,
+        contactForce: R
+      } = Pt(t), v = f || n.collision, M = R || n.contactForce;
+      v && M ? g.setActiveEvents(
+        Je.COLLISION_EVENTS | Je.CONTACT_FORCE_EVENTS
+      ) : v ? g.setActiveEvents(Je.COLLISION_EVENTS) : M && g.setActiveEvents(Je.CONTACT_FORCE_EVENTS), o.set(g.handle, {
+        onCollisionEnter: i,
+        onCollisionExit: s,
+        onIntersectionEnter: c,
+        onIntersectionExit: a,
+        onContactForce: x
+      });
+    }
+    return () => {
+      g && o.delete(g.handle);
+    };
+  }, [
+    i,
+    s,
+    c,
+    a,
+    x,
+    n
+  ]);
+}, At = (e = {}) => {
+  const {
+    mass: t,
+    linearDamping: o,
+    angularDamping: n,
+    type: i,
+    onCollisionEnter: s,
+    onCollisionExit: c,
+    onIntersectionEnter: a,
+    onIntersectionExit: x,
+    onContactForce: g,
+    children: f,
+    canSleep: R,
+    ccd: v,
+    gravityScale: M,
+    softCcdPrediction: P,
+    ref: Q,
+    ...p
+  } = e;
+  return p;
+}, $e = (e) => {
+  const t = D(e);
+  return N(() => {
+    t.current = e;
+  }, [e]), t;
+}, H = () => {
+  const e = Ct(Tt);
+  if (!e)
+    throw new Error(
+      "react-three-rapier: useRapier must be used within <Physics />!"
+    );
+  return e;
+}, hr = (e) => {
+  const { beforeStepCallbacks: t } = H(), o = $e(e);
+  N(() => (t.add(o), () => {
+    t.delete(o);
+  }), []);
+}, Kr = (e) => {
+  const { afterStepCallbacks: t } = H(), o = $e(e);
+  N(() => (t.add(o), () => {
+    t.delete(o);
+  }), []);
+}, eo = (e) => {
+  const { filterContactPairHooks: t } = H(), o = $e(e);
+  N(() => (t.add(o), () => {
+    t.delete(o);
+  }), []);
+}, to = (e) => {
+  const { filterIntersectionPairHooks: t } = H(), o = $e(e);
+  N(() => (t.add(o), () => {
+    t.delete(o);
+  }), []);
+}, Ke = (e, t, o = !0) => {
+  const [n, i] = vt([]);
+  return N(() => {
+    e.current && t.colliders !== !1 && i(
+      Cr({
+        object: e.current,
+        options: t,
+        ignoreMeshColliders: o
+      })
+    );
+  }, [t.colliders]), n;
+}, wr = he(() => {
+  const { world: e } = H(), t = D(null);
+  return Ze(() => {
+    const o = t.current;
+    if (!o) return;
+    const n = e.debugRender(), i = new Jt();
+    i.setAttribute("position", new lt(n.vertices, 3)), i.setAttribute("color", new lt(n.colors, 4)), o.geometry.dispose(), o.geometry = i;
+  }), /* @__PURE__ */ b.jsx("group", { children: /* @__PURE__ */ b.jsxs("lineSegments", { ref: t, frustumCulled: !1, children: [
+    /* @__PURE__ */ b.jsx("lineBasicMaterial", { color: 16777215, vertexColors: !0 }),
+    /* @__PURE__ */ b.jsx("bufferGeometry", {})
+  ] }) });
+}), Sr = (e) => {
+  let t;
+  const o = {
+    get(c, a) {
+      return t || (t = e()), Reflect.get(t, a);
+    },
+    set(c, a, x) {
+      return t || (t = e()), Reflect.set(t, a, x);
+    }
+  };
+  return { proxy: new Proxy({}, o), reset: () => {
+    t = void 0;
+  }, set: (c) => {
+    t = c;
+  } };
+}, Tt = Et(
+  void 0
+), Ye = (e, t) => {
+  var o, n, i, s, c, a;
+  return {
+    target: {
+      rigidBody: e.rigidBody.object,
+      collider: e.collider.object,
+      colliderObject: (o = e.collider.state) == null ? void 0 : o.object,
+      rigidBodyObject: (n = e.rigidBody.state) == null ? void 0 : n.object
+    },
+    other: {
+      rigidBody: t.rigidBody.object,
+      collider: t.collider.object,
+      colliderObject: (i = t.collider.state) == null ? void 0 : i.object,
+      rigidBodyObject: (s = t.rigidBody.state) == null ? void 0 : s.object
+    },
+    rigidBody: t.rigidBody.object,
+    collider: t.collider.object,
+    colliderObject: (c = t.collider.state) == null ? void 0 : c.object,
+    rigidBodyObject: (a = t.rigidBody.state) == null ? void 0 : a.object
+  };
+}, yt = async () => {
+  let e = await import("@dimforge/rapier3d-compat");
+  return await e.init(), e;
+}, ro = (e) => {
+  const {
+    colliders: t = "cuboid",
+    children: o,
+    timeStep: n = 1 / 60,
+    paused: i = !1,
+    interpolate: s = !0,
+    updatePriority: c,
+    updateLoop: a = "follow",
+    debug: x = !1,
+    gravity: g = [0, -9.81, 0],
+    allowedLinearError: f = 1e-3,
+    predictionDistance: R = 2e-3,
+    numSolverIterations: v = 4,
+    numInternalPgsIterations: M = 1,
+    minIslandSize: P = 128,
+    maxCcdSubsteps: Q = 1,
+    contactNaturalFrequency: p = 30,
+    lengthUnit: W = 1
+  } = e, F = $t(yt, ["@react-thee/rapier", yt]), { invalidate: O } = ht(), le = se(() => /* @__PURE__ */ new Map()), _ = se(() => /* @__PURE__ */ new Map()), V = se(() => /* @__PURE__ */ new Map()), Te = se(() => /* @__PURE__ */ new Map()), we = se(() => new It(!1)), Se = se(
+    () => /* @__PURE__ */ new Set()
+  ), Re = se(() => /* @__PURE__ */ new Set()), Me = se(() => ({
+    filterContactPair: (...Y) => {
+      for (const S of Se) {
+        const U = S.current(...Y);
+        if (U !== null) return U;
+      }
+      return null;
+    },
+    filterIntersectionPair: (...Y) => {
+      for (const S of Re)
+        if (S.current(...Y) === !1) return !1;
+      return !0;
+    }
+  })), je = se(() => /* @__PURE__ */ new Set()), Pe = se(() => /* @__PURE__ */ new Set()), {
+    proxy: A,
+    reset: Fe,
+    set: Le
+  } = se(
+    () => Sr(
+      () => new F.World(rr(g))
+    )
+  );
+  N(() => () => {
+    A.free(), Fe();
+  }, []), N(() => {
+    A.gravity = q(g), A.integrationParameters.numSolverIterations = v, A.integrationParameters.numInternalPgsIterations = M, A.integrationParameters.normalizedAllowedLinearError = f, A.integrationParameters.minIslandSize = P, A.integrationParameters.maxCcdSubsteps = Q, A.integrationParameters.normalizedPredictionDistance = R, A.lengthUnit = W, A.integrationParameters.contact_natural_frequency = p;
+  }, [
+    A,
+    ...g,
+    v,
+    M,
+    f,
+    P,
+    Q,
+    R,
+    W,
+    p
+  ]);
+  const be = Ge((Y) => {
+    var y;
+    const S = A.getCollider(Y), U = Te.get(Y), xe = _.get(Y), K = (y = S == null ? void 0 : S.parent()) == null ? void 0 : y.handle, fe = K !== void 0 ? A.getRigidBody(K) : void 0, d = fe && K !== void 0 ? V.get(K) : void 0, T = K !== void 0 ? le.get(K) : void 0;
+    return {
+      collider: {
+        object: S,
+        events: U,
+        state: xe
+      },
+      rigidBody: {
+        object: fe,
+        events: d,
+        state: T
+      }
+    };
+  }, []), [ue] = vt({
+    previousState: {},
+    accumulator: 0
+  }), Z = Ge(
+    (Y) => {
+      const S = A, U = n === "vary", xe = Ht.clamp(Y, 0, 0.5), K = (d) => {
+        je.forEach((E) => {
+          E.current(S);
+        }), S.timestep = d;
+        const T = Se.size > 0 || Re.size > 0;
+        S.step(we, T ? Me : void 0), Pe.forEach((E) => {
+          E.current(S);
+        });
+      };
+      if (U)
+        K(xe);
+      else
+        for (ue.accumulator += xe; ue.accumulator >= n; )
+          s && (ue.previousState = {}, S.forEachRigidBody((d) => {
+            ue.previousState[d.handle] = {
+              position: d.translation(),
+              rotation: d.rotation()
+            };
+          })), K(n), ue.accumulator -= n;
+      const fe = U || !s || i ? 1 : ue.accumulator / n;
+      le.forEach((d, T) => {
+        var J, ae;
+        const E = S.getRigidBody(T), y = V.get(T);
+        if ((y != null && y.onSleep || y != null && y.onWake) && (E.isSleeping() && !d.isSleeping && ((J = y == null ? void 0 : y.onSleep) == null || J.call(y)), !E.isSleeping() && d.isSleeping && ((ae = y == null ? void 0 : y.onWake) == null || ae.call(y)), d.isSleeping = E.isSleeping()), !E || E.isSleeping() && !("isInstancedMesh" in d.object) || !d.setMatrix)
+          return;
+        let w = E.translation(), k = E.rotation(), B = ue.previousState[T];
+        B && (ye.compose(
+          B.position,
+          mt(B.rotation),
+          d.scale
+        ).premultiply(d.invertedWorldMatrix).decompose(z, ce, Ee), d.meshType == "mesh" && (d.object.position.copy(z), d.object.quaternion.copy(ce))), ye.compose(w, mt(k), d.scale).premultiply(d.invertedWorldMatrix).decompose(z, ce, Ee), d.meshType == "instancedMesh" ? d.setMatrix(ye) : (d.object.position.lerp(z, fe), d.object.quaternion.slerp(ce, fe));
+      }), we.drainCollisionEvents((d, T, E) => {
+        var J, ae, ee, me, te, ge, r, u, l, C, j, h, m, re, ie, I, oe, pe, X, Ce, $, rt, Ne, ot;
+        const y = be(d), w = be(T);
+        if (!(y != null && y.collider.object) || !(w != null && w.collider.object))
+          return;
+        const k = Ye(
+          y,
+          w
+        ), B = Ye(
+          w,
+          y
+        );
+        E ? S.contactPair(
+          y.collider.object,
+          w.collider.object,
+          (ke, Ie) => {
+            var We, nt, ze, it, De, st, Ve, ct;
+            (nt = (We = y.rigidBody.events) == null ? void 0 : We.onCollisionEnter) == null || nt.call(We, {
+              ...k,
+              manifold: ke,
+              flipped: Ie
+            }), (it = (ze = w.rigidBody.events) == null ? void 0 : ze.onCollisionEnter) == null || it.call(ze, {
+              ...B,
+              manifold: ke,
+              flipped: Ie
+            }), (st = (De = y.collider.events) == null ? void 0 : De.onCollisionEnter) == null || st.call(De, {
+              ...k,
+              manifold: ke,
+              flipped: Ie
+            }), (ct = (Ve = w.collider.events) == null ? void 0 : Ve.onCollisionEnter) == null || ct.call(Ve, {
+              ...B,
+              manifold: ke,
+              flipped: Ie
+            });
+          }
+        ) : ((ae = (J = y.rigidBody.events) == null ? void 0 : J.onCollisionExit) == null || ae.call(J, k), (me = (ee = w.rigidBody.events) == null ? void 0 : ee.onCollisionExit) == null || me.call(ee, B), (ge = (te = y.collider.events) == null ? void 0 : te.onCollisionExit) == null || ge.call(te, k), (u = (r = w.collider.events) == null ? void 0 : r.onCollisionExit) == null || u.call(r, B)), E ? S.intersectionPair(
+          y.collider.object,
+          w.collider.object
+        ) && ((C = (l = y.rigidBody.events) == null ? void 0 : l.onIntersectionEnter) == null || C.call(l, k), (h = (j = w.rigidBody.events) == null ? void 0 : j.onIntersectionEnter) == null || h.call(j, B), (re = (m = y.collider.events) == null ? void 0 : m.onIntersectionEnter) == null || re.call(m, k), (I = (ie = w.collider.events) == null ? void 0 : ie.onIntersectionEnter) == null || I.call(ie, B)) : ((pe = (oe = y.rigidBody.events) == null ? void 0 : oe.onIntersectionExit) == null || pe.call(oe, k), (Ce = (X = w.rigidBody.events) == null ? void 0 : X.onIntersectionExit) == null || Ce.call(X, B), (rt = ($ = y.collider.events) == null ? void 0 : $.onIntersectionExit) == null || rt.call($, k), (ot = (Ne = w.collider.events) == null ? void 0 : Ne.onIntersectionExit) == null || ot.call(Ne, B));
+      }), we.drainContactForceEvents((d) => {
+        var k, B, J, ae, ee, me, te, ge;
+        const T = be(d.collider1()), E = be(d.collider2());
+        if (!(T != null && T.collider.object) || !(E != null && E.collider.object))
+          return;
+        const y = Ye(
+          T,
+          E
+        ), w = Ye(
+          E,
+          T
+        );
+        (B = (k = T.rigidBody.events) == null ? void 0 : k.onContactForce) == null || B.call(k, {
+          ...y,
+          totalForce: d.totalForce(),
+          totalForceMagnitude: d.totalForceMagnitude(),
+          maxForceDirection: d.maxForceDirection(),
+          maxForceMagnitude: d.maxForceMagnitude()
+        }), (ae = (J = E.rigidBody.events) == null ? void 0 : J.onContactForce) == null || ae.call(J, {
+          ...w,
+          totalForce: d.totalForce(),
+          totalForceMagnitude: d.totalForceMagnitude(),
+          maxForceDirection: d.maxForceDirection(),
+          maxForceMagnitude: d.maxForceMagnitude()
+        }), (me = (ee = T.collider.events) == null ? void 0 : ee.onContactForce) == null || me.call(ee, {
+          ...y,
+          totalForce: d.totalForce(),
+          totalForceMagnitude: d.totalForceMagnitude(),
+          maxForceDirection: d.maxForceDirection(),
+          maxForceMagnitude: d.maxForceMagnitude()
+        }), (ge = (te = E.collider.events) == null ? void 0 : te.onContactForce) == null || ge.call(te, {
+          ...w,
+          totalForce: d.totalForce(),
+          totalForceMagnitude: d.totalForceMagnitude(),
+          maxForceDirection: d.maxForceDirection(),
+          maxForceMagnitude: d.maxForceMagnitude()
+        });
+      }), S.forEachActiveRigidBody(() => {
+        O();
+      });
+    },
+    [i, n, s, A]
+  ), Be = ve(
+    () => ({
+      rapier: F,
+      world: A,
+      setWorld: (Y) => {
+        Le(Y);
+      },
+      physicsOptions: {
+        colliders: t,
+        gravity: g
+      },
+      rigidBodyStates: le,
+      colliderStates: _,
+      rigidBodyEvents: V,
+      colliderEvents: Te,
+      beforeStepCallbacks: je,
+      afterStepCallbacks: Pe,
+      isPaused: i,
+      isDebug: x,
+      step: Z,
+      filterContactPairHooks: Se,
+      filterIntersectionPairHooks: Re
+    }),
+    [i, Z, x, t, g]
+  ), de = Ge(
+    (Y) => {
+      i || Z(Y);
+    },
+    [i, Z]
+  );
+  return /* @__PURE__ */ b.jsxs(Tt.Provider, { value: Be, children: [
+    /* @__PURE__ */ b.jsx(
+      lr,
+      {
+        onStep: de,
+        type: a,
+        updatePriority: c
+      }
+    ),
+    x && /* @__PURE__ */ b.jsx(wr, {}),
+    o
+  ] });
+}, et = (e, t = null) => {
+  const o = D(t);
+  return e && typeof e != "function" ? (e.current || (e.current = o.current), e) : o;
+}, tt = (e, t, o) => {
+  const n = D(void 0), i = Ge(() => (n.current || (n.current = e()), n.current), o);
+  return N(() => {
+    const s = i(), c = () => t(s);
+    return () => {
+      c(), n.current = void 0;
+    };
+  }, [i]), i;
+}, Rr = (e) => {
+  const t = wt((e == null ? void 0 : e.type) || "dynamic"), o = new Wt(t);
+  return o.canSleep = (e == null ? void 0 : e.canSleep) ?? !0, o;
+}, jr = ({
+  rigidBody: e,
+  object: t,
+  setMatrix: o,
+  getMatrix: n,
+  worldScale: i,
+  meshType: s = "mesh"
+}) => {
+  t.updateWorldMatrix(!0, !1);
+  const c = t.parent.matrixWorld.clone().invert();
+  return {
+    object: t,
+    rigidBody: e,
+    invertedWorldMatrix: c,
+    setMatrix: o || ((a) => {
+      t.matrix.copy(a);
+    }),
+    getMatrix: n || ((a) => a.copy(t.matrix)),
+    scale: i || t.getWorldScale(Ee).clone(),
+    isSleeping: !1,
+    meshType: s
+  };
+}, Pr = [
+  "args",
+  "colliders",
+  "canSleep"
+], Mt = {
+  gravityScale: (e, t) => {
+    e.setGravityScale(t, !0);
+  },
+  additionalSolverIterations(e, t) {
+    e.setAdditionalSolverIterations(t);
+  },
+  linearDamping: (e, t) => {
+    e.setLinearDamping(t);
+  },
+  angularDamping: (e, t) => {
+    e.setAngularDamping(t);
+  },
+  dominanceGroup: (e, t) => {
+    e.setDominanceGroup(t);
+  },
+  enabledRotations: (e, [t, o, n]) => {
+    e.setEnabledRotations(t, o, n, !0);
+  },
+  enabledTranslations: (e, [t, o, n]) => {
+    e.setEnabledTranslations(t, o, n, !0);
+  },
+  lockRotations: (e, t) => {
+    e.lockRotations(t, !0);
+  },
+  lockTranslations: (e, t) => {
+    e.lockTranslations(t, !0);
+  },
+  angularVelocity: (e, [t, o, n]) => {
+    e.setAngvel({ x: t, y: o, z: n }, !0);
+  },
+  linearVelocity: (e, [t, o, n]) => {
+    e.setLinvel({ x: t, y: o, z: n }, !0);
+  },
+  ccd: (e, t) => {
+    e.enableCcd(t);
+  },
+  softCcdPrediction: (e, t) => {
+    e.setSoftCcdPrediction(t);
+  },
+  userData: (e, t) => {
+    e.userData = t;
+  },
+  type(e, t) {
+    e.setBodyType(wt(t), !0);
+  },
+  position: () => {
+  },
+  rotation: () => {
+  },
+  quaternion: () => {
+  },
+  scale: () => {
+  }
+}, Ft = Object.keys(Mt), Ar = (e, t, o, n = !0) => {
+  if (!e)
+    return;
+  const i = o.get(e.handle);
+  i && (n && (i.object.updateWorldMatrix(!0, !1), ye.copy(i.object.matrixWorld).decompose(z, ce, Ee), e.setTranslation(z, !1), e.setRotation(ce, !1)), Ft.forEach((s) => {
+    s in t && Mt[s](
+      e,
+      t[s]
+    );
+  }));
+}, Tr = (e, t, o, n = !0) => {
+  const i = ve(
+    () => Ft.flatMap((s) => St(t[s])),
+    [t]
+  );
+  N(() => {
+    const s = e();
+    Ar(s, t, o, n);
+  }, i);
+}, Mr = (e, t, o) => {
+  const {
+    onWake: n,
+    onSleep: i,
+    onCollisionEnter: s,
+    onCollisionExit: c,
+    onIntersectionEnter: a,
+    onIntersectionExit: x,
+    onContactForce: g
+  } = t, f = {
+    onWake: n,
+    onSleep: i,
+    onCollisionEnter: s,
+    onCollisionExit: c,
+    onIntersectionEnter: a,
+    onIntersectionExit: x,
+    onContactForce: g
+  };
+  N(() => {
+    const R = e();
+    return o.set(R.handle, f), () => {
+      o.delete(R.handle);
+    };
+  }, [
+    n,
+    i,
+    s,
+    c,
+    a,
+    x,
+    g
+  ]);
+}, Fr = ({ x: e, y: t, z: o } = { x: 0, y: 0, z: 0 }) => new G(e, t, o), oo = ({ x: e, y: t, z: o, w: n } = { x: 0, y: 0, z: 0, w: 1 }) => new qe(e, t, o, n), no = ({ x: e, y: t, z: o } = { x: 0, y: 0, z: 0 }) => new Ue(e, t, o), L = he((e) => {
+  const { children: t, position: o, rotation: n, quaternion: i, scale: s, name: c } = e, { world: a, colliderEvents: x, colliderStates: g } = H(), f = Bt(), R = et(e.ref), v = D(null), M = fr.flatMap(
+    (p) => (
+      // Array.isArray(props[key]) ? [...props[key]] : props[key]
+      Array.isArray(e[p]) ? e[p] : [e[p]]
+    )
+  ), P = tt(
+    () => {
+      const p = v.current.getWorldScale(Fr()), W = dr(
+        e,
+        a,
+        p,
+        f == null ? void 0 : f.getRigidBody
+      );
+      return typeof e.ref == "function" && e.ref(W), R.current = W, W;
+    },
+    (p) => {
+      a.getCollider(p.handle) && a.removeCollider(p, !0);
+    },
+    [...M, f]
+  );
+  N(() => {
+    const p = P();
+    return g.set(
+      p.handle,
+      br(
+        p,
+        v.current,
+        f == null ? void 0 : f.ref.current
+      )
+    ), () => {
+      g.delete(p.handle);
+    };
+  }, [P]);
+  const Q = ve(() => ({
+    ...At(f == null ? void 0 : f.options),
+    ...e
+  }), [e, f == null ? void 0 : f.options]);
+  return pr(P, Q, g), Er(
+    P,
+    Q,
+    x,
+    Pt(f == null ? void 0 : f.options)
+  ), /* @__PURE__ */ b.jsx(
+    "object3D",
+    {
+      position: o,
+      rotation: n,
+      quaternion: i,
+      scale: s,
+      ref: v,
+      name: c,
+      children: t
+    }
+  );
+}), Or = ne.forwardRef(
+  (e, t) => /* @__PURE__ */ b.jsx(L, { ...e, shape: "cuboid", ref: t })
+);
+Or.displayName = "CuboidCollider";
+const _r = ne.forwardRef(
+  (e, t) => /* @__PURE__ */ b.jsx(L, { ...e, shape: "roundCuboid", ref: t })
+);
+_r.displayName = "RoundCuboidCollider";
+const Br = ne.forwardRef(
+  (e, t) => /* @__PURE__ */ b.jsx(L, { ...e, shape: "ball", ref: t })
+);
+Br.displayName = "BallCollider";
+const Nr = ne.forwardRef(
+  (e, t) => /* @__PURE__ */ b.jsx(L, { ...e, shape: "capsule", ref: t })
+);
+Nr.displayName = "CapsuleCollider";
+const kr = ne.forwardRef(
+  (e, t) => /* @__PURE__ */ b.jsx(L, { ...e, shape: "heightfield", ref: t })
+);
+kr.displayName = "HeightfieldCollider";
+const Ir = ne.forwardRef(
+  (e, t) => /* @__PURE__ */ b.jsx(L, { ...e, shape: "trimesh", ref: t })
+);
+Ir.displayName = "TrimeshCollider";
+const Wr = ne.forwardRef(
+  (e, t) => /* @__PURE__ */ b.jsx(L, { ...e, shape: "cone", ref: t })
+);
+Wr.displayName = "ConeCollider";
+const zr = ne.forwardRef(
+  (e, t) => /* @__PURE__ */ b.jsx(L, { ...e, shape: "roundCone", ref: t })
+);
+zr.displayName = "RoundConeCollider";
+const Ot = ne.forwardRef(
+  (e, t) => /* @__PURE__ */ b.jsx(L, { ...e, shape: "cylinder", ref: t })
+);
+Ot.displayName = "CylinderCollider";
+const io = ne.forwardRef(
+  (e, t) => /* @__PURE__ */ b.jsx(L, { ...e, shape: "roundCylinder", ref: t })
+);
+Ot.displayName = "RoundCylinderCollider";
+const Dr = ne.forwardRef(
+  (e, t) => /* @__PURE__ */ b.jsx(L, { ...e, shape: "convexHull", ref: t })
+);
+Dr.displayName = "ConvexHullCollider";
+const _t = Et(void 0), Bt = () => Ct(_t), Nt = he((e) => {
+  const {
+    ref: t,
+    children: o,
+    type: n,
+    position: i,
+    rotation: s,
+    scale: c,
+    quaternion: a,
+    transformState: x,
+    ...g
+  } = e, f = D(null), R = et(t), { world: v, rigidBodyStates: M, physicsOptions: P, rigidBodyEvents: Q } = H(), p = ve(() => ({
+    ...P,
+    ...e,
+    children: void 0
+  }), [P, e]), W = Pr.flatMap((_) => Array.isArray(p[_]) ? [...p[_]] : p[_]), F = Ke(f, p), O = tt(
+    () => {
+      const _ = Rr(p), V = v.createRigidBody(_);
+      return typeof t == "function" && t(V), R.current = V, V;
+    },
+    (_) => {
+      v.getRigidBody(_.handle) && v.removeRigidBody(_);
+    },
+    W
+  );
+  N(() => {
+    const _ = O(), V = jr({
+      rigidBody: _,
+      object: f.current
+    });
+    return M.set(
+      _.handle,
+      e.transformState ? e.transformState(V) : V
+    ), () => {
+      M.delete(_.handle);
+    };
+  }, [O]), Tr(O, p, M), Mr(O, p, Q);
+  const le = ve(() => ({
+    ref: f,
+    getRigidBody: O,
+    options: p
+  }), [O]);
+  return /* @__PURE__ */ b.jsx(_t.Provider, { value: le, children: /* @__PURE__ */ b.jsxs(
+    "object3D",
+    {
+      ref: f,
+      ...g,
+      position: i,
+      rotation: s,
+      quaternion: a,
+      scale: c,
+      children: [
+        o,
+        F.map((_, V) => /* @__PURE__ */ b.jsx(L, { ..._ }, V))
+      ]
+    }
+  ) });
+});
+Nt.displayName = "RigidBody";
+const Vr = he((e) => {
+  const { children: t, type: o } = e, { physicsOptions: n } = H(), i = D(null), { options: s } = Bt(), c = ve(() => ({
+    ...n,
+    ...s,
+    children: void 0,
+    colliders: o
+  }), [n, s]), a = Ke(
+    i,
+    c,
+    !1
+  );
+  return /* @__PURE__ */ b.jsxs(
+    "object3D",
+    {
+      ref: i,
+      userData: {
+        r3RapierType: "MeshCollider"
+      },
+      children: [
+        t,
+        a.map((x, g) => /* @__PURE__ */ b.jsx(L, { ...x }, g))
+      ]
+    }
+  );
+});
+Vr.displayName = "MeshCollider";
+const Jr = he(
+  ({ ref: e, ...t }) => {
+    const o = et(e, []), n = D(null), i = D(null), {
+      // instanced props
+      children: s,
+      instances: c,
+      colliderNodes: a = [],
+      // wrapper object props
+      position: x,
+      rotation: g,
+      quaternion: f,
+      scale: R,
+      // rigid body specific props, and r3f-object props
+      ...v
+    } = t, M = Ke(n, {
+      ...t,
+      children: void 0
+    }), P = () => {
+      const p = i.current.children[0];
+      if (p && "isInstancedMesh" in p)
+        return p;
+    };
+    N(() => {
+      const p = P();
+      p ? p.instanceMatrix.setUsage(Yt) : console.warn(
+        "InstancedRigidBodies expects exactly one child, which must be an InstancedMesh"
+      );
+    }, []);
+    const Q = (p, W) => {
+      const F = P();
+      return F ? {
+        ...p,
+        getMatrix: (O) => (F.getMatrixAt(W, O), O),
+        setMatrix: (O) => {
+          F.setMatrixAt(W, O), F.instanceMatrix.needsUpdate = !0;
+        },
+        meshType: "instancedMesh"
+      } : p;
+    };
+    return /* @__PURE__ */ b.jsxs(
+      "object3D",
+      {
+        ref: n,
+        ...v,
+        position: x,
+        rotation: g,
+        quaternion: f,
+        scale: R,
+        children: [
+          /* @__PURE__ */ b.jsx("object3D", { ref: i, children: s }),
+          c == null ? void 0 : c.map((p, W) => /* @__PURE__ */ b.jsx(
+            Nt,
+            {
+              ...v,
+              ...p,
+              ref: (F) => {
+                o.current[W] = F;
+              },
+              transformState: (F) => Q(F, W),
+              children: /* @__PURE__ */ b.jsxs(b.Fragment, { children: [
+                a.map((F, O) => /* @__PURE__ */ b.jsx(zt, { children: F }, O)),
+                M.map((F, O) => /* @__PURE__ */ b.jsx(L, { ...F }, O))
+              ] })
+            }
+          ))
+        ]
+      }
+    );
+  }
+);
+Jr.displayName = "InstancedRigidBodies";
+const Ae = (e, t, o) => {
+  const { world: n } = H(), i = D(void 0);
+  return tt(
+    () => {
+      if (e.current && t.current) {
+        const s = n.createImpulseJoint(
+          o,
+          e.current,
+          t.current,
+          !0
+        );
+        return i.current = s, s;
+      }
+    },
+    (s) => {
+      s && (i.current = void 0, n.getImpulseJoint(s.handle) && n.removeImpulseJoint(s, !0));
+    },
+    []
+  ), i;
+}, so = (e, t, [o, n, i, s]) => {
+  const { rapier: c } = H();
+  return Ae(
+    e,
+    t,
+    c.JointData.fixed(
+      q(o),
+      gt(n),
+      q(i),
+      gt(s)
+    )
+  );
+}, co = (e, t, [o, n]) => {
+  const { rapier: i } = H();
+  return Ae(
+    e,
+    t,
+    i.JointData.spherical(
+      q(o),
+      q(n)
+    )
+  );
+}, ao = (e, t, [o, n, i, s]) => {
+  const { rapier: c } = H(), a = c.JointData.revolute(
+    q(o),
+    q(n),
+    q(i)
+  );
+  return s && (a.limitsEnabled = !0, a.limits = s), Ae(e, t, a);
+}, lo = (e, t, [o, n, i, s]) => {
+  const { rapier: c } = H(), a = c.JointData.prismatic(
+    q(o),
+    q(n),
+    q(i)
+  );
+  return s && (a.limitsEnabled = !0, a.limits = s), Ae(e, t, a);
+}, uo = (e, t, [o, n, i]) => {
+  const { rapier: s } = H(), c = q(o), a = q(n), x = s.JointData.rope(i, c, a);
+  return Ae(e, t, x);
+}, fo = (e, t, [o, n, i, s, c]) => {
+  const { rapier: a } = H(), x = q(o), g = q(n), f = a.JointData.spring(
+    i,
+    s,
+    c,
+    x,
+    g
+  );
+  return Ae(e, t, f);
+}, mo = (e, t) => (bt(e) << 16) + (t !== void 0 ? bt(t) : 65535), bt = (e) => [e].flat().reduce((t, o) => t | 1 << o, 0), Hr = new G(), Yr = (e) => {
+  const { scene: t } = ht(), o = D(null), n = D(null), i = e.strength > 0 ? 255 : 16711680;
+  return N(() => (o.current = new Gt(
+    new qt(0.2, 6, 6),
+    new Ut({ color: i, wireframe: !0 })
+  ), n.current = new Qt(
+    o.current,
+    e.range,
+    i
+  ), n.current.frustumCulled = !1, t.add(o.current), t.add(n.current), () => {
+    n.current && o.current && (t.remove(n.current), t.remove(o.current));
+  }), [e, i]), Ze(() => {
+    var s;
+    if (o.current && e.object.current) {
+      const c = e.object.current.getWorldPosition(Hr);
+      o.current.position.copy(c), (s = n.current) == null || s.update();
+    }
+  }), null;
+}, Gr = {
+  static: (e, t, o, n, i) => e,
+  linear: (e, t, o, n, i) => e * (n / o),
+  newtonian: (e, t, o, n, i) => i * e * t / Math.pow(n, 2)
+}, Xe = new G(), xt = new G(), qr = (e, {
+  object: t,
+  strength: o,
+  range: n,
+  gravitationalConstant: i,
+  collisionGroups: s,
+  type: c
+}) => {
+  const a = e.translation();
+  Xe.set(a.x, a.y, a.z);
+  const x = t.getWorldPosition(new G()), g = x.distanceTo(Xe);
+  if (g < n) {
+    let f = Gr[c](
+      o,
+      e.mass(),
+      n,
+      g,
+      i
+    );
+    f = f === 1 / 0 ? o : f;
+    let R = s === void 0;
+    if (s !== void 0)
+      for (let v = 0; v < e.numColliders(); v++) {
+        const P = e.collider(v).collisionGroups();
+        if ((s >> 16 & P) != 0 && (P >> 16 & s) != 0) {
+          R = !0;
+          break;
+        }
+      }
+    R && (xt.set(0, 0, 0).subVectors(x, Xe).normalize().multiplyScalar(f), e.applyImpulse(xt, !0));
+  }
+}, go = he((e) => {
+  const {
+    position: t = [0, 0, 0],
+    strength: o = 1,
+    range: n = 10,
+    type: i = "static",
+    gravitationalConstant: s = 6673e-14,
+    collisionGroups: c
+  } = e, a = D(null), { isDebug: x } = H();
+  return hr((g) => {
+    a.current && g.bodies.forEach((f) => {
+      f.isDynamic() && qr(f, {
+        object: a.current,
+        strength: o,
+        range: n,
+        type: i,
+        gravitationalConstant: s,
+        collisionGroups: c
+      });
+    });
+  }), /* @__PURE__ */ b.jsxs(b.Fragment, { children: [
+    /* @__PURE__ */ b.jsx("object3D", { ref: a, position: t }),
+    x && /* @__PURE__ */ b.jsx(
+      Yr,
+      {
+        strength: o,
+        gravitationalConstant: s,
+        range: n,
+        type: i,
+        collisionGroups: c,
+        object: a
+      }
+    )
+  ] });
+});
+export {
+  L as AnyCollider,
+  go as Attractor,
+  Yr as AttractorDebugHelper,
+  Br as BallCollider,
+  Nr as CapsuleCollider,
+  bo as CoefficientCombineRule,
+  Wr as ConeCollider,
+  Dr as ConvexHullCollider,
+  Or as CuboidCollider,
+  Ot as CylinderCollider,
+  kr as HeightfieldCollider,
+  Jr as InstancedRigidBodies,
+  Vr as MeshCollider,
+  ro as Physics,
+  xo as RapierCollider,
+  Co as RapierRigidBody,
+  Nt as RigidBody,
+  zr as RoundConeCollider,
+  _r as RoundCuboidCollider,
+  io as RoundCylinderCollider,
+  Ir as TrimeshCollider,
+  qr as applyAttractorForceOnRigidBody,
+  no as euler,
+  mo as interactionGroups,
+  oo as quat,
+  Kr as useAfterPhysicsStep,
+  hr as useBeforePhysicsStep,
+  eo as useFilterContactPair,
+  to as useFilterIntersectionPair,
+  so as useFixedJoint,
+  Ae as useImpulseJoint,
+  lo as usePrismaticJoint,
+  H as useRapier,
+  ao as useRevoluteJoint,
+  uo as useRopeJoint,
+  co as useSphericalJoint,
+  fo as useSpringJoint,
+  Fr as vec3
+};