@nebula-spatial/viewer 0.4.2 → 0.4.4

package/dist/urdf-session-AP-cMuwd.js

@@ -0,0 +1,3001 @@
+var ni = Object.defineProperty;
+var ii = (n, t, e) => t in n ? ni(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e;
+var I = (n, t, e) => ii(n, typeof t != "symbol" ? t + "" : t, e);
+import { d as si, b as oi, c as ri, a as en, r as ai, S as nn, p as ci } from "./session-Cz6qHYMc.js";
+import { Matrix4 as W, Quaternion as J, Group as dt, MeshStandardMaterial as Oe, Euler as Ft, Mesh as H, BoxGeometry as Ve, SphereGeometry as We, CylinderGeometry as kn, CapsuleGeometry as In, LoadingManager as li, Vector3 as z, MathUtils as ui, Matrix3 as sn, Box3 as et, BufferAttribute as Un, Line3 as rt, Plane as Ln, Vector2 as pt, Triangle as Et, BackSide as fi, DoubleSide as di, REVISION as jn, Ray as pi, FrontSide as on, LineSegments as Ge, LineLoop as Dn, Line as Qe, Points as Nn, Sphere as hi, BatchedMesh as yi, AxesHelper as mi, ArrowHelper as rn, BufferGeometry as gi, LineBasicMaterial as an, MeshBasicMaterial as cn, EdgesGeometry as wi } from "three";
+import { GLTFLoader as bi } from "three/examples/jsm/loaders/GLTFLoader.js";
+import { OBJLoader as xi } from "three/examples/jsm/loaders/OBJLoader.js";
+import { STLLoader as Ai } from "three/examples/jsm/loaders/STLLoader.js";
+import { d as kt, S as Pi } from "./stage-D113SHD8.js";
+function Cn(n) {
+  const [t, e, i, s, c, r] = n;
+  if (![t, e, i, s, c, r].every(Number.isFinite)) return !1;
+  const u = t * e - s * s, o = t * (e * i - r * r) - s * (s * i - r * c) + c * (s * r - e * c);
+  return t > 0 && u > 0 && o > 0 ? t <= e + i + 1e-12 && e <= t + i + 1e-12 && i <= t + e + 1e-12 : !1;
+}
+function vi(n, t) {
+  if (!(t > 0) || !Number.isFinite(t) || n.length !== 6 || !n.every(Number.isFinite)) return null;
+  const e = [[n[0], n[3], n[4]], [n[3], n[1], n[5]], [n[4], n[5], n[2]]], i = [[1, 0, 0], [0, 1, 0], [0, 0, 1]], s = Math.max(...n.map(Math.abs));
+  for (let o = 0; o < 40; o++) {
+    let d = 0, f = 1;
+    for (const [y, m] of [[0, 1], [0, 2], [1, 2]]) Math.abs(e[y][m]) > Math.abs(e[d][f]) && (d = y, f = m);
+    if (Math.abs(e[d][f]) <= s * 1e-14) break;
+    const p = 0.5 * Math.atan2(2 * e[d][f], e[f][f] - e[d][d]), a = Math.cos(p), l = Math.sin(p), g = e[d][d], h = e[f][f], b = e[d][f];
+    for (let y = 0; y < 3; y++) {
+      if (y !== d && y !== f) {
+        const w = e[y][d], A = e[y][f];
+        e[y][d] = e[d][y] = a * w - l * A, e[y][f] = e[f][y] = l * w + a * A;
+      }
+      const m = i[y][d], x = i[y][f];
+      i[y][d] = a * m - l * x, i[y][f] = l * m + a * x;
+    }
+    e[d][d] = a * a * g - 2 * l * a * b + l * l * h, e[f][f] = l * l * g + 2 * l * a * b + a * a * h, e[d][f] = e[f][d] = 0;
+  }
+  const c = [e[0][0], e[1][1], e[2][2]], r = c.map((o, d) => 5 * (c[(d + 1) % 3] + c[(d + 2) % 3] - o) / (2 * t));
+  if (c.some((o) => o <= 0) || r.some((o) => o < -s * 1e-10 / t)) return null;
+  const u = new W().set(i[0][0], i[0][1], i[0][2], 0, i[1][0], i[1][1], i[1][2], 0, i[2][0], i[2][1], i[2][2], 0, 0, 0, 0, 1);
+  return { radii: r.map((o) => Math.sqrt(Math.max(0, o))), rotation: new J().setFromRotationMatrix(u) };
+}
+function Si(n, t) {
+  const e = vi(n, t);
+  return e ? { size: e.radii.map((i) => i * Math.sqrt(12 / 5)), rotation: e.rotation } : null;
+}
+function bt(n, t) {
+  if (!n) return [...t];
+  const e = n.trim().split(/\s+/).map(Number);
+  if (e.some((i) => !Number.isFinite(i))) throw X(`Invalid numeric value: ${n}`, "E_URDF_PARSE");
+  return e;
+}
+function le(n) {
+  const t = (n == null ? void 0 : n.querySelector("origin")) ?? null, e = bt((t == null ? void 0 : t.getAttribute("quat_xyzw")) ?? null, []);
+  if (e.length !== 0 && e.length !== 4) throw X("URDF origin quat_xyzw requires four values.", "E_URDF_PARSE");
+  if (e.length && (t != null && t.hasAttribute("rpy"))) throw X("URDF origin cannot declare both rpy and quat_xyzw.", "E_URDF_PARSE");
+  return {
+    position: bt((t == null ? void 0 : t.getAttribute("xyz")) ?? null, [0, 0, 0]),
+    rotationRpy: bt((t == null ? void 0 : t.getAttribute("rpy")) ?? null, [0, 0, 0]),
+    ...e.length ? { rotationQuaternion: e } : {}
+  };
+}
+function ln(n, t, e) {
+  const i = n.querySelector("geometry"), s = i == null ? void 0 : i.querySelector("box");
+  if (s) return { type: "box", size: Fi(s.getAttribute("size"), 3, "box size") };
+  const c = i == null ? void 0 : i.querySelector("sphere");
+  if (c) return { type: "sphere", radius: Ut(c.getAttribute("radius"), "sphere radius") };
+  const r = i == null ? void 0 : i.querySelector("cylinder");
+  if (r) return { type: "cylinder", radius: Ut(r.getAttribute("radius"), "cylinder radius"), length: Ut(r.getAttribute("length"), "cylinder length") };
+  const u = i == null ? void 0 : i.querySelector("capsule");
+  if (u) return { type: "capsule", radius: Ut(u.getAttribute("radius"), "capsule radius"), length: Ut(u.getAttribute("length"), "capsule length") };
+  const o = i == null ? void 0 : i.querySelector("mesh"), d = o == null ? void 0 : o.getAttribute("filename");
+  return d ? { type: "mesh", resourcePath: e.resolve(d, t), scale: bt(o.getAttribute("scale"), [1, 1, 1]) } : null;
+}
+function Mi(n, t, e) {
+  const s = $i(n, "URDF").querySelector("robot");
+  if (!s) throw X("URDF requires a robot root element.", "E_URDF_PARSE");
+  const c = oi(), r = [...s.querySelectorAll("link")].map((o) => ({
+    id: it(o, "name"),
+    name: it(o, "name"),
+    inertial: (() => {
+      const d = ki(o);
+      return d && (!(d.mass > 0) || !Number.isFinite(d.mass) || !Cn(d.tensor)) && c.errors.push({ code: "E_URDF_INERTIA", message: `连杆 ${o.getAttribute("name")} 的质量或惯性张量无效。`, source: o.getAttribute("name") ?? void 0 }), d;
+    })(),
+    visuals: [...o.querySelectorAll("visual")].map((d) => {
+      var a;
+      const f = ln(d, t, e), p = bt(((a = d.querySelector("color")) == null ? void 0 : a.getAttribute("rgba")) ?? null, [0.68, 0.72, 0.7, 1]);
+      return f ? { origin: le(d), geometry: f, color: p } : null;
+    }).filter((d) => !!d),
+    collisions: [...o.querySelectorAll("collision")].map((d) => {
+      const f = ln(d, t, e);
+      return f ? { origin: le(d), geometry: f } : null;
+    }).filter((d) => !!d)
+  })), u = [...s.querySelectorAll("joint")].map((o) => {
+    var g;
+    const d = o.querySelector("limit"), f = o.querySelector("dynamics"), p = f ? fn(f.getAttribute("damping"), 0) : 0, a = f ? fn(f.getAttribute("friction"), 0) : 0, l = f && (p > 0 || a > 0) ? { damping: p, friction: a } : void 0;
+    return {
+      id: it(o, "name"),
+      type: o.getAttribute("type") ?? "fixed",
+      parent: it(o.querySelector("parent"), "link"),
+      child: it(o.querySelector("child"), "link"),
+      origin: le(o),
+      axis: bt(((g = o.querySelector("axis")) == null ? void 0 : g.getAttribute("xyz")) ?? null, [1, 0, 0]),
+      ...d ? {
+        limits: { lower: $e(d.getAttribute("lower"), `Joint ${it(o, "name")} limit lower`), upper: $e(d.getAttribute("upper"), `Joint ${it(o, "name")} limit upper`) },
+        effort: dn(d.getAttribute("effort"), `Joint ${it(o, "name")} limit effort`),
+        velocity: dn(d.getAttribute("velocity"), `Joint ${it(o, "name")} limit velocity`)
+      } : {},
+      ...l ? { dynamics: l } : {}
+    };
+  });
+  return s.querySelector("transmission, gazebo") && c.droppedFeatures.push({ code: "UNSUPPORTED_URDF_EXTENSION", message: "URDF transmission/gazebo extensions are not compiled." }), si({ id: s.getAttribute("name") || t, name: s.getAttribute("name") || t, source: { format: "urdf", uri: t }, links: r, joints: u, diagnostics: c, extension: { files: e } }, { allowInvalidGraph: !0 });
+}
+function Je(n) {
+  return n.rotationQuaternion ? new J(n.rotationQuaternion[0], n.rotationQuaternion[1], n.rotationQuaternion[2], n.rotationQuaternion[3]).normalize() : new J().setFromEuler(new Ft(...n.rotationRpy, "XYZ"));
+}
+function Ti(n) {
+  if (n.rotationQuaternion) {
+    const [t, e, i, s] = n.rotationQuaternion;
+    return `quat="${s} ${t} ${e} ${i}"`;
+  }
+  return `euler="${n.rotationRpy.join(" ")}"`;
+}
+function Ee(n) {
+  const t = new W(), e = Je(n);
+  return t.compose(new z().fromArray(n.position), e, new z(1, 1, 1));
+}
+function ze(n) {
+  if (n.type === "continuous" || !n.limits) return 0;
+  const { lower: t, upper: e } = n.limits;
+  return !Number.isFinite(t) || !Number.isFinite(e) ? 0 : ui.clamp(0, t, e);
+}
+function Bi(n) {
+  let t;
+  if (n.type === "box")
+    t = [n.size[0] / 2, n.size[1] / 2, n.size[2] / 2];
+  else if (n.type === "sphere")
+    t = [n.radius, n.radius, n.radius];
+  else if (n.type === "cylinder")
+    t = [n.radius, n.radius, n.length / 2];
+  else
+    return null;
+  const e = [];
+  for (const i of [-t[0], t[0]])
+    for (const s of [-t[1], t[1]])
+      for (const c of [-t[2], t[2]])
+        e.push(new z(i, s, c));
+  return e;
+}
+function qn(n, t, e) {
+  let i = 0;
+  const s = new Map(n.links.map((d) => [d.id, d])), c = (d) => {
+    let f = 1 / 0;
+    const p = (a, l) => {
+      const g = s.get(a);
+      if (g) {
+        for (const h of g.collisions) {
+          const b = Bi(h.geometry);
+          if (!b) {
+            d && (i += 1);
+            continue;
+          }
+          const y = l.clone().multiply(Ee(h.origin));
+          for (const m of b)
+            f = Math.min(f, m.applyMatrix4(y).z);
+        }
+        for (const h of e.get(a) ?? []) {
+          const b = l.clone().multiply(Ee(h.origin)), y = d ? ze(h) : 0;
+          y && h.type === "revolute" ? b.multiply(new W().makeRotationAxis(new z().fromArray(h.axis).normalize(), y)) : y && h.type === "prismatic" && b.multiply(new W().makeTranslation(h.axis[0] * y, h.axis[1] * y, h.axis[2] * y)), p(h.child, b);
+        }
+      }
+    };
+    return p(t, new W()), f;
+  }, r = c(!0), u = c(!1), o = Math.min(r, u);
+  return i && n.diagnostics.warnings.push({
+    code: "GROUNDING_IGNORED_MESH_COLLIDERS",
+    message: `自动落地忽略了 ${i} 个网格碰撞体`
+  }), Number.isFinite(o) ? Math.max(0, 0.015 - o) : 0;
+}
+async function _i(n) {
+  const t = n.extension.files, e = /* @__PURE__ */ new Map(), i = new Set(n.joints.map((h) => h.child));
+  for (const h of n.joints) e.set(h.parent, [...e.get(h.parent) ?? [], h]);
+  const s = n.links.filter((h) => !i.has(h.id));
+  if (s.length !== 1) throw X(`URDF requires exactly one root link; found ${s.length}.`, "E_URDF_COMPILE");
+  const c = qn(n, s[0].id, e);
+  c > 0 && n.diagnostics.approximations.push({
+    code: "AUTO_GROUNDED_FREE_ROOT",
+    message: `自由根初始高度自动抬升 ${c.toFixed(4)} m`
+  });
+  const r = n.joints.filter((h) => ze(h) !== 0);
+  r.length && n.diagnostics.approximations.push({
+    code: "JOINT_REFERENCE_CLAMPED",
+    message: `${r.length} 个关节的默认参考值已夹到合法限位`
+  });
+  const u = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Map(), d = [], f = async (h) => {
+    var x;
+    if (h.type === "box") return `type="box" size="${h.size.map((w) => w / 2).join(" ")}"`;
+    if (h.type === "sphere") return `type="sphere" size="${h.radius}"`;
+    if (h.type === "cylinder") return `type="cylinder" size="${h.radius} ${h.length / 2}"`;
+    if (h.type === "capsule") return `type="capsule" size="${h.radius} ${h.length / 2}"`;
+    const b = (x = h.resourcePath.split(".").pop()) == null ? void 0 : x.toLowerCase();
+    if (b !== "stl" && b !== "obj") return null;
+    const y = `${h.resourcePath}|${h.scale.join(" ")}`;
+    let m = o.get(y);
+    if (!m) {
+      const w = { name: `mesh_${o.size}`, path: h.resourcePath, scale: h.scale };
+      o.set(y, w);
+      const A = await t.bytes(h.resourcePath);
+      u.set(`${w.name}.${b}`, A), m = w;
+    }
+    return `type="mesh" mesh="${m.name}"`;
+  }, p = async (h, b) => {
+    var A, S;
+    const y = n.links.find((P) => P.id === h), m = [...(b == null ? void 0 : b.origin.position) ?? [0, 0, 0]];
+    b || (m[2] += c);
+    const x = (b == null ? void 0 : b.origin) ?? { rotationRpy: [0, 0, 0] }, w = [`<body name="${we(h)}" pos="${m.join(" ")}" ${Ti(x)}>`];
+    if (y.inertial) {
+      const { origin: P, mass: T, tensor: _ } = y.inertial, M = new sn().setFromMatrix4(new W().makeRotationFromQuaternion(Je(P))), R = new sn().set(_[0], _[3], _[4], _[3], _[1], _[5], _[4], _[5], _[2]);
+      R.premultiply(M).multiply(M.clone().transpose());
+      const v = R.elements;
+      w.push(`<inertial pos="${P.position.join(" ")}" mass="${T}" fullinertia="${[v[0], v[4], v[8], v[3], v[6], v[7]].join(" ")}"/>`);
+    }
+    if (!b) w.push("<freejoint/>");
+    else if (["fixed", "planar", "floating"].includes(b.type))
+      (b == null ? void 0 : b.type) === "floating" && (w.push("<freejoint/>"), d.push(0, 0, 0, 1, 0, 0, 0));
+    else {
+      const P = b.type === "prismatic" ? "slide" : "hinge", T = b.type !== "continuous" && !!b.limits && Number.isFinite(b.limits.lower) && Number.isFinite(b.limits.upper), _ = ze(b);
+      d.push(_);
+      const M = ((A = b.dynamics) == null ? void 0 : A.damping) ?? 0, R = ((S = b.dynamics) == null ? void 0 : S.friction) ?? 0;
+      w.push(`<joint name="${we(b.id)}" type="${P}" axis="${b.axis.join(" ")}"${T ? ` limited="true" range="${b.limits.lower} ${b.limits.upper}" ref="0"` : ""} damping="${M}" frictionloss="${R}"/>`);
+    }
+    for (const P of y.collisions) {
+      const T = await f(P.geometry);
+      if (T) {
+        const _ = P.origin.rotationQuaternion ? ` quat="${[P.origin.rotationQuaternion[3], P.origin.rotationQuaternion[0], P.origin.rotationQuaternion[1], P.origin.rotationQuaternion[2]].join(" ")}"` : ` euler="${P.origin.rotationRpy.join(" ")}"`;
+        w.push(`<geom ${T} pos="${P.origin.position.join(" ")}"${_} rgba="0.55 0.62 0.59 1"/>`);
+      }
+    }
+    for (const P of e.get(h) ?? []) w.push(await p(P.child, P));
+    return w.push("</body>"), w.join("");
+  }, a = await p(s[0].id), l = [...o.values()].map((h) => {
+    var b;
+    return `<mesh name="${h.name}" file="${h.name}.${(b = h.path.split(".").pop()) == null ? void 0 : b.toLowerCase()}" scale="${h.scale.join(" ")}"/>`;
+  }).join(""), g = `<keyframe><key name="home" qpos="0 0 ${c} 1 0 0 0 ${d.join(" ")}"/></keyframe>`;
+  return {
+    format: "mjcf",
+    files: u,
+    xml: `<mujoco model="${we(n.name)}"><compiler angle="radian" autolimits="true"/><option gravity="0 0 -9.81"/><asset>${l}</asset><worldbody><geom name="__viewer_default_ground__" type="plane" size="5 5 0.1" contype="1" conaffinity="1" friction="0.8 0.01 0.0002"/>${a}</worldbody>${g}</mujoco>`
+  };
+}
+async function On(n) {
+  const t = n.extension.files, e = new dt();
+  e.name = "URDF authored collisions";
+  const i = /* @__PURE__ */ new Map(), s = ri();
+  let c = 0;
+  for (const r of n.links) {
+    const u = new dt();
+    u.name = r.id, u.userData.urdfEntityId = `link:${r.id}`, i.set(r.id, u), e.add(u);
+    for (const o of r.collisions) {
+      const d = new dt();
+      if (d.matrixAutoUpdate = !1, d.matrix.copy(Ee(o.origin)), u.add(d), o.geometry.type === "mesh") {
+        const f = await Vn(o.geometry, t, new Oe());
+        f.updateMatrixWorld(!0), f.traverse((p) => {
+          if (!(p instanceof H)) return;
+          const a = en(p.geometry, s, "mesh");
+          a.matrixAutoUpdate = !1, a.matrix.copy(p.matrixWorld), a.name = `Collision:${r.id}`, a.userData.urdfLink = r.id, d.add(a), c += 1;
+        }), kt(f);
+      } else {
+        const f = Ei(o.geometry);
+        if (!f) continue;
+        const p = en(f, s, "feature");
+        f.dispose(), p.name = `Collision:${r.id}`, p.userData.urdfLink = r.id, d.add(p), c += 1;
+      }
+    }
+  }
+  if (c === 0) {
+    s.dispose(), kt(e);
+    return;
+  }
+  return { root: e, bindings: i, expectedLinkCount: i.size };
+}
+async function Ri(n, t) {
+  const e = await On(n);
+  if (!e) return;
+  const i = () => {
+    t.root.updateMatrixWorld(!0);
+    for (const [s, c] of e.bindings) {
+      const r = t.bindings.get(s);
+      r && (c.matrixAutoUpdate = !1, c.matrix.copy(r.matrixWorld));
+    }
+    e.root.updateMatrixWorld(!0);
+  };
+  return i(), e.root.visible = !1, { root: e.root, sync: i, dispose() {
+    kt(e.root);
+  } };
+}
+function Ei(n) {
+  if (n.type === "box") return new Ve(...n.size);
+  if (n.type === "sphere") return new We(n.radius, 24, 16);
+  if (n.type === "cylinder") {
+    const t = new kn(n.radius, n.radius, n.length, 24);
+    return t.rotateX(Math.PI / 2), t;
+  }
+  if (n.type === "capsule") {
+    const t = new In(n.radius, n.length, 8, 24);
+    return t.rotateX(Math.PI / 2), t;
+  }
+  return null;
+}
+async function un(n) {
+  const t = n.extension.files, e = new dt();
+  e.name = n.name;
+  const i = /* @__PURE__ */ new Map();
+  for (const s of n.links) {
+    const c = new dt();
+    c.name = s.id, c.userData.urdfEntityId = `link:${s.id}`, i.set(s.id, c), e.add(c);
+    for (const r of s.visuals) {
+      const u = await zi(r, t), o = new dt();
+      o.position.fromArray(r.origin.position), o.quaternion.copy(Je(r.origin)), o.add(u), c.add(o);
+    }
+  }
+  return { root: e, bindings: i, expectedLinkCount: n.links.length };
+}
+async function zi(n, t) {
+  var i, s;
+  const e = new Oe({ color: n.color ? 16777215 : 11385011, opacity: ((i = n.color) == null ? void 0 : i[3]) ?? 1, transparent: (((s = n.color) == null ? void 0 : s[3]) ?? 1) < 1 });
+  return n.color && e.color.setRGB(n.color[0], n.color[1], n.color[2]), Vn(n.geometry, t, e);
+}
+async function Vn(n, t, e) {
+  var c;
+  if (n.type === "box") return new H(new Ve(...n.size), e);
+  if (n.type === "sphere") return new H(new We(n.radius, 24, 16), e);
+  if (n.type === "cylinder") {
+    const r = new H(new kn(n.radius, n.radius, n.length, 24), e);
+    return r.quaternion.copy(new J().setFromEuler(new Ft(Math.PI / 2, 0, 0))), r;
+  }
+  if (n.type === "capsule") {
+    const r = new H(new In(n.radius, n.length, 8, 24), e);
+    return r.quaternion.copy(new J().setFromEuler(new Ft(Math.PI / 2, 0, 0))), r;
+  }
+  const i = (c = n.resourcePath.split(".").pop()) == null ? void 0 : c.toLowerCase();
+  await t.ensure(n.resourcePath);
+  let s;
+  if (i === "stl") s = new H(new Ai().parse(await t.getBlob(n.resourcePath).arrayBuffer()), e);
+  else if (i === "obj")
+    s = new xi().parse(await t.getBlob(n.resourcePath).text()), s.traverse((r) => {
+      "material" in r && (r.material = e);
+    });
+  else if (i === "gltf" || i === "glb") {
+    const r = new li();
+    r.setURLModifier((u) => {
+      try {
+        return t.objectUrl(t.resolve(u, n.resourcePath));
+      } catch {
+        return u;
+      }
+    }), s = (await new bi(r).parseAsync(await t.getBlob(n.resourcePath).arrayBuffer(), "")).scene;
+  } else throw X(`Unsupported URDF visual mesh: .${i ?? ""}`, "E_URDF_VISUAL");
+  return s.scale.fromArray(n.scale), s;
+}
+function $i(n, t) {
+  const e = new DOMParser().parseFromString(n, "application/xml"), i = e.querySelector("parsererror");
+  if (i) throw X(`${t} XML parse failed: ${i.textContent ?? ""}`, `E_${t}_PARSE`);
+  return e;
+}
+function it(n, t) {
+  const e = n == null ? void 0 : n.getAttribute(t);
+  if (!e) throw X(`Missing ${t}.`, "E_URDF_PARSE");
+  return e;
+}
+function fn(n, t) {
+  const e = Number(n);
+  return Number.isFinite(e) ? e : t;
+}
+function $e(n, t) {
+  if (n === null || n.trim() === "") throw X(`${t} is required.`, "E_URDF_PARSE");
+  const e = Number(n);
+  if (!Number.isFinite(e)) throw X(`${t} must be finite.`, "E_URDF_PARSE");
+  return e;
+}
+function Ut(n, t) {
+  const e = $e(n, t);
+  if (!(e > 0)) throw X(`${t} must be greater than zero.`, "E_URDF_PARSE");
+  return e;
+}
+function Fi(n, t, e) {
+  if (n === null || n.trim() === "") throw X(`${e} is required.`, "E_URDF_PARSE");
+  const i = bt(n, []);
+  if (i.length !== t || i.some((s) => !(s > 0))) throw X(`${e} requires ${t} values greater than zero.`, "E_URDF_PARSE");
+  return i;
+}
+function dn(n, t) {
+  if (n === null || n.trim() === "") return;
+  const e = Number(n);
+  if (!Number.isFinite(e)) throw X(`${t} must be finite.`, "E_URDF_PARSE");
+  return e;
+}
+function we(n) {
+  return n.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function X(n, t) {
+  return Object.assign(new Error(n), { code: t });
+}
+function ki(n) {
+  var r;
+  const t = n.querySelector("inertial");
+  if (!t) return;
+  const e = t.querySelector("inertia"), i = (r = t.querySelector("mass")) == null ? void 0 : r.getAttribute("value"), s = i == null || i.trim() === "" ? Number.NaN : Number(i), c = ["ixx", "iyy", "izz", "ixy", "ixz", "iyz"].map((u) => {
+    const o = e == null ? void 0 : e.getAttribute(u);
+    return o == null || o.trim() === "" ? Number.NaN : Number(o);
+  });
+  return { origin: le(t), mass: s, tensor: c };
+}
+const Wn = 0, Ii = 1, Ui = 2, pn = 2, be = 1.25, hn = 1, O = 6 * 4 + 4 + 4, j = O / 4, Gn = 65535, ue = Math.pow(2, -24), Xe = Symbol("SKIP_GENERATION"), Qn = {
+  strategy: Wn,
+  maxDepth: 40,
+  maxLeafSize: 10,
+  useSharedArrayBuffer: !1,
+  setBoundingBox: !0,
+  onProgress: null,
+  indirect: !1,
+  verbose: !0,
+  range: null,
+  [Xe]: !1
+};
+function U(n, t, e) {
+  return e.min.x = t[n], e.min.y = t[n + 1], e.min.z = t[n + 2], e.max.x = t[n + 3], e.max.y = t[n + 4], e.max.z = t[n + 5], e;
+}
+function yn(n) {
+  let t = -1, e = -1 / 0;
+  for (let i = 0; i < 3; i++) {
+    const s = n[i + 3] - n[i];
+    s > e && (e = s, t = i);
+  }
+  return t;
+}
+function mn(n, t) {
+  t.set(n);
+}
+function gn(n, t, e) {
+  let i, s;
+  for (let c = 0; c < 3; c++) {
+    const r = c + 3;
+    i = n[c], s = t[c], e[c] = i < s ? i : s, i = n[r], s = t[r], e[r] = i > s ? i : s;
+  }
+}
+function Gt(n, t, e) {
+  for (let i = 0; i < 3; i++) {
+    const s = t[n + 2 * i], c = t[n + 2 * i + 1], r = s - c, u = s + c;
+    r < e[i] && (e[i] = r), u > e[i + 3] && (e[i + 3] = u);
+  }
+}
+function Lt(n) {
+  const t = n[3] - n[0], e = n[4] - n[1], i = n[5] - n[2];
+  return 2 * (t * e + e * i + i * t);
+}
+function D(n, t) {
+  return t[n + 15] === Gn;
+}
+function V(n, t) {
+  return t[n + 6];
+}
+function G(n, t) {
+  return t[n + 14];
+}
+function N(n) {
+  return n + j;
+}
+function C(n, t) {
+  const e = t[n + 6];
+  return n + e * j;
+}
+function He(n, t) {
+  return t[n + 7];
+}
+function xe(n, t, e, i, s) {
+  let c = 1 / 0, r = 1 / 0, u = 1 / 0, o = -1 / 0, d = -1 / 0, f = -1 / 0, p = 1 / 0, a = 1 / 0, l = 1 / 0, g = -1 / 0, h = -1 / 0, b = -1 / 0;
+  const y = n.offset || 0;
+  for (let m = (t - y) * 6, x = (t + e - y) * 6; m < x; m += 6) {
+    const w = n[m + 0], A = n[m + 1], S = w - A, P = w + A;
+    S < c && (c = S), P > o && (o = P), w < p && (p = w), w > g && (g = w);
+    const T = n[m + 2], _ = n[m + 3], M = T - _, R = T + _;
+    M < r && (r = M), R > d && (d = R), T < a && (a = T), T > h && (h = T);
+    const v = n[m + 4], B = n[m + 5], E = v - B, $ = v + B;
+    E < u && (u = E), $ > f && (f = $), v < l && (l = v), v > b && (b = v);
+  }
+  i[0] = c, i[1] = r, i[2] = u, i[3] = o, i[4] = d, i[5] = f, s[0] = p, s[1] = a, s[2] = l, s[3] = g, s[4] = h, s[5] = b;
+}
+const st = 32, Li = (n, t) => n.candidate - t.candidate, lt = /* @__PURE__ */ new Array(st).fill().map(() => ({
+  count: 0,
+  bounds: new Float32Array(6),
+  rightCacheBounds: new Float32Array(6),
+  leftCacheBounds: new Float32Array(6),
+  candidate: 0
+})), Qt = /* @__PURE__ */ new Float32Array(6);
+function ji(n, t, e, i, s, c) {
+  let r = -1, u = 0;
+  if (c === Wn)
+    r = yn(t), r !== -1 && (u = (t[r] + t[r + 3]) / 2);
+  else if (c === Ii)
+    r = yn(n), r !== -1 && (u = Di(e, i, s, r));
+  else if (c === Ui) {
+    const o = Lt(n);
+    let d = be * s;
+    const f = e.offset || 0, p = (i - f) * 6, a = (i + s - f) * 6;
+    for (let l = 0; l < 3; l++) {
+      const g = t[l], y = (t[l + 3] - g) / st;
+      if (s < st / 4) {
+        const m = [...lt];
+        m.length = s;
+        let x = 0;
+        for (let A = p; A < a; A += 6, x++) {
+          const S = m[x];
+          S.candidate = e[A + 2 * l], S.count = 0;
+          const {
+            bounds: P,
+            leftCacheBounds: T,
+            rightCacheBounds: _
+          } = S;
+          for (let M = 0; M < 3; M++)
+            _[M] = 1 / 0, _[M + 3] = -1 / 0, T[M] = 1 / 0, T[M + 3] = -1 / 0, P[M] = 1 / 0, P[M + 3] = -1 / 0;
+          Gt(A, e, P);
+        }
+        m.sort(Li);
+        let w = s;
+        for (let A = 0; A < w; A++) {
+          const S = m[A];
+          for (; A + 1 < w && m[A + 1].candidate === S.candidate; )
+            m.splice(A + 1, 1), w--;
+        }
+        for (let A = p; A < a; A += 6) {
+          const S = e[A + 2 * l];
+          for (let P = 0; P < w; P++) {
+            const T = m[P];
+            S >= T.candidate ? Gt(A, e, T.rightCacheBounds) : (Gt(A, e, T.leftCacheBounds), T.count++);
+          }
+        }
+        for (let A = 0; A < w; A++) {
+          const S = m[A], P = S.count, T = s - S.count, _ = S.leftCacheBounds, M = S.rightCacheBounds;
+          let R = 0;
+          P !== 0 && (R = Lt(_) / o);
+          let v = 0;
+          T !== 0 && (v = Lt(M) / o);
+          const B = hn + be * (R * P + v * T);
+          B < d && (r = l, d = B, u = S.candidate);
+        }
+      } else {
+        for (let w = 0; w < st; w++) {
+          const A = lt[w];
+          A.count = 0, A.candidate = g + y + w * y;
+          const S = A.bounds;
+          for (let P = 0; P < 3; P++)
+            S[P] = 1 / 0, S[P + 3] = -1 / 0;
+        }
+        for (let w = p; w < a; w += 6) {
+          let P = ~~((e[w + 2 * l] - g) / y);
+          P >= st && (P = st - 1);
+          const T = lt[P];
+          T.count++, Gt(w, e, T.bounds);
+        }
+        const m = lt[st - 1];
+        mn(m.bounds, m.rightCacheBounds);
+        for (let w = st - 2; w >= 0; w--) {
+          const A = lt[w], S = lt[w + 1];
+          gn(A.bounds, S.rightCacheBounds, A.rightCacheBounds);
+        }
+        let x = 0;
+        for (let w = 0; w < st - 1; w++) {
+          const A = lt[w], S = A.count, P = A.bounds, _ = lt[w + 1].rightCacheBounds;
+          S !== 0 && (x === 0 ? mn(P, Qt) : gn(P, Qt, Qt)), x += S;
+          let M = 0, R = 0;
+          x !== 0 && (M = Lt(Qt) / o);
+          const v = s - x;
+          v !== 0 && (R = Lt(_) / o);
+          const B = hn + be * (M * x + R * v);
+          B < d && (r = l, d = B, u = A.candidate);
+        }
+      }
+    }
+  } else
+    console.warn(`BVH: Invalid build strategy value ${c} used.`);
+  return { axis: r, pos: u };
+}
+function Di(n, t, e, i) {
+  let s = 0;
+  const c = n.offset;
+  for (let r = t, u = t + e; r < u; r++)
+    s += n[(r - c) * 6 + i * 2];
+  return s / e;
+}
+class Ae {
+  constructor() {
+    this.boundingData = new Float32Array(6);
+  }
+}
+function Ni(n, t, e, i, s, c) {
+  let r = i, u = i + s - 1;
+  const o = c.pos, d = c.axis * 2, f = e.offset || 0;
+  for (; ; ) {
+    for (; r <= u && e[(r - f) * 6 + d] < o; )
+      r++;
+    for (; r <= u && e[(u - f) * 6 + d] >= o; )
+      u--;
+    if (r < u) {
+      for (let p = 0; p < t; p++) {
+        let a = n[r * t + p];
+        n[r * t + p] = n[u * t + p], n[u * t + p] = a;
+      }
+      for (let p = 0; p < 6; p++) {
+        const a = r - f, l = u - f, g = e[a * 6 + p];
+        e[a * 6 + p] = e[l * 6 + p], e[l * 6 + p] = g;
+      }
+      r++, u--;
+    } else
+      return r;
+  }
+}
+let Jn, fe, Fe, Xn;
+const Ci = Math.pow(2, 32);
+function ke(n) {
+  return "count" in n ? 1 : 1 + ke(n.left) + ke(n.right);
+}
+function qi(n, t, e) {
+  return Jn = new Float32Array(e), fe = new Uint32Array(e), Fe = new Uint16Array(e), Xn = new Uint8Array(e), Ie(n, t);
+}
+function Ie(n, t) {
+  const e = n / 4, i = n / 2, s = "count" in t, c = t.boundingData;
+  for (let r = 0; r < 6; r++)
+    Jn[e + r] = c[r];
+  if (s)
+    return t.buffer ? (Xn.set(new Uint8Array(t.buffer), n), n + t.buffer.byteLength) : (fe[e + 6] = t.offset, Fe[i + 14] = t.count, Fe[i + 15] = Gn, n + O);
+  {
+    const { left: r, right: u, splitAxis: o } = t, d = n + O;
+    let f = Ie(d, r);
+    const p = n / O, l = f / O - p;
+    if (l > Ci)
+      throw new Error("MeshBVH: Cannot store relative child node offset greater than 32 bits.");
+    return fe[e + 6] = l, fe[e + 7] = o, Ie(f, u);
+  }
+}
+function Oi(n, t, e, i, s, c) {
+  const {
+    maxDepth: r,
+    verbose: u,
+    maxLeafSize: o,
+    strategy: d,
+    onProgress: f
+  } = s, p = n.primitiveBuffer, a = n.primitiveBufferStride, l = new Float32Array(6);
+  let g = !1;
+  const h = new Ae();
+  return xe(t, e, i, h.boundingData, l), y(h, e, i, l), h;
+  function b(m) {
+    f && f((m - c.offset) / c.count);
+  }
+  function y(m, x, w, A = null, S = 0) {
+    if (!g && S >= r && (g = !0, u && console.warn(`BVH: Max depth of ${r} reached when generating BVH. Consider increasing maxDepth.`)), w <= o || S >= r)
+      return b(x + w), m.offset = x, m.count = w, m;
+    const P = ji(m.boundingData, A, t, x, w, d);
+    if (P.axis === -1)
+      return b(x + w), m.offset = x, m.count = w, m;
+    const T = Ni(p, a, t, x, w, P);
+    if (T === x || T === x + w)
+      b(x + w), m.offset = x, m.count = w;
+    else {
+      m.splitAxis = P.axis;
+      const _ = new Ae(), M = x, R = T - x;
+      m.left = _, xe(t, M, R, _.boundingData, l), y(_, M, R, l, S + 1);
+      const v = new Ae(), B = T, E = w - R;
+      m.right = v, xe(t, B, E, v.boundingData, l), y(v, B, E, l, S + 1);
+    }
+    return m;
+  }
+}
+function Vi(n, t) {
+  const e = t.useSharedArrayBuffer ? SharedArrayBuffer : ArrayBuffer, i = n.getRootRanges(t.range), s = i[0], c = i[i.length - 1], r = {
+    offset: s.offset,
+    count: c.offset + c.count - s.offset
+  }, u = new Float32Array(6 * r.count);
+  u.offset = r.offset, n.computePrimitiveBounds(r.offset, r.count, u), n._roots = i.map((o) => {
+    const d = Oi(n, u, o.offset, o.count, t, r), f = ke(d), p = new e(O * f);
+    return qi(0, d, p), p;
+  });
+}
+class Ze {
+  constructor(t) {
+    this._getNewPrimitive = t, this._primitives = [];
+  }
+  getPrimitive() {
+    const t = this._primitives;
+    return t.length === 0 ? this._getNewPrimitive() : t.pop();
+  }
+  releasePrimitive(t) {
+    this._primitives.push(t);
+  }
+}
+class Wi {
+  constructor() {
+    this.float32Array = null, this.uint16Array = null, this.uint32Array = null;
+    const t = [];
+    let e = null;
+    this.setBuffer = (i) => {
+      e && t.push(e), e = i, this.float32Array = new Float32Array(i), this.uint16Array = new Uint16Array(i), this.uint32Array = new Uint32Array(i);
+    }, this.clearBuffer = () => {
+      e = null, this.float32Array = null, this.uint16Array = null, this.uint32Array = null, t.length !== 0 && this.setBuffer(t.pop());
+    };
+  }
+}
+const F = /* @__PURE__ */ new Wi();
+let ft, $t;
+const Pt = [], Jt = /* @__PURE__ */ new Ze(() => new et());
+function Gi(n, t, e, i, s, c) {
+  ft = Jt.getPrimitive(), $t = Jt.getPrimitive(), Pt.push(ft, $t), F.setBuffer(n._roots[t]);
+  const r = Ue(0, n.geometry, e, i, s, c);
+  F.clearBuffer(), Jt.releasePrimitive(ft), Jt.releasePrimitive($t), Pt.pop(), Pt.pop();
+  const u = Pt.length;
+  return u > 0 && ($t = Pt[u - 1], ft = Pt[u - 2]), r;
+}
+function Ue(n, t, e, i, s = null, c = 0, r = 0) {
+  const { float32Array: u, uint16Array: o, uint32Array: d } = F;
+  let f = n * 2;
+  if (D(f, o)) {
+    const a = V(n, d), l = G(f, o);
+    return U(n, u, ft), i(a, l, !1, r, c + n / j, ft);
+  } else {
+    let M = function(v) {
+      const { uint16Array: B, uint32Array: E } = F;
+      let $ = v * 2;
+      for (; !D($, B); )
+        v = N(v), $ = v * 2;
+      return V(v, E);
+    }, R = function(v) {
+      const { uint16Array: B, uint32Array: E } = F;
+      let $ = v * 2;
+      for (; !D($, B); )
+        v = C(v, E), $ = v * 2;
+      return V(v, E) + G($, B);
+    };
+    const a = N(n), l = C(n, d);
+    let g = a, h = l, b, y, m, x;
+    if (s && (m = ft, x = $t, U(g, u, m), U(h, u, x), b = s(m), y = s(x), y < b)) {
+      g = l, h = a;
+      const v = b;
+      b = y, y = v, m = x;
+    }
+    m || (m = ft, U(g, u, m));
+    const w = D(g * 2, o), A = e(m, w, b, r + 1, c + g / j);
+    let S;
+    if (A === pn) {
+      const v = M(g), E = R(g) - v;
+      S = i(v, E, !0, r + 1, c + g / j, m);
+    } else
+      S = A && Ue(
+        g,
+        t,
+        e,
+        i,
+        s,
+        c,
+        r + 1
+      );
+    if (S) return !0;
+    x = $t, U(h, u, x);
+    const P = D(h * 2, o), T = e(x, P, y, r + 1, c + h / j);
+    let _;
+    if (T === pn) {
+      const v = M(h), E = R(h) - v;
+      _ = i(v, E, !0, r + 1, c + h / j, x);
+    } else
+      _ = T && Ue(
+        h,
+        t,
+        e,
+        i,
+        s,
+        c,
+        r + 1
+      );
+    return !!_;
+  }
+}
+const Wt = /* @__PURE__ */ new F.constructor(), de = /* @__PURE__ */ new F.constructor(), ut = /* @__PURE__ */ new Ze(() => new et()), vt = /* @__PURE__ */ new et(), St = /* @__PURE__ */ new et(), Pe = /* @__PURE__ */ new et(), ve = /* @__PURE__ */ new et();
+let Se = !1;
+function Qi(n, t, e, i) {
+  if (Se)
+    throw new Error("MeshBVH: Recursive calls to bvhcast not supported.");
+  Se = !0;
+  const s = n._roots, c = t._roots;
+  let r, u = 0, o = 0;
+  const d = new W().copy(e).invert();
+  for (let f = 0, p = s.length; f < p; f++) {
+    Wt.setBuffer(s[f]), o = 0;
+    const a = ut.getPrimitive();
+    U(0, Wt.float32Array, a), a.applyMatrix4(d);
+    for (let l = 0, g = c.length; l < g && (de.setBuffer(c[l]), r = Y(
+      0,
+      0,
+      e,
+      d,
+      i,
+      u,
+      o,
+      0,
+      0,
+      a
+    ), de.clearBuffer(), o += c[l].byteLength / O, !r); l++)
+      ;
+    if (ut.releasePrimitive(a), Wt.clearBuffer(), u += s[f].byteLength / O, r)
+      break;
+  }
+  return Se = !1, r;
+}
+function Y(n, t, e, i, s, c = 0, r = 0, u = 0, o = 0, d = null, f = !1) {
+  let p, a;
+  f ? (p = de, a = Wt) : (p = Wt, a = de);
+  const l = p.float32Array, g = p.uint32Array, h = p.uint16Array, b = a.float32Array, y = a.uint32Array, m = a.uint16Array, x = n * 2, w = t * 2, A = D(x, h), S = D(w, m);
+  let P = !1;
+  if (S && A)
+    f ? P = s(
+      V(t, y),
+      G(t * 2, m),
+      V(n, g),
+      G(n * 2, h),
+      o,
+      r + t / j,
+      u,
+      c + n / j
+    ) : P = s(
+      V(n, g),
+      G(n * 2, h),
+      V(t, y),
+      G(t * 2, m),
+      u,
+      c + n / j,
+      o,
+      r + t / j
+    );
+  else if (S) {
+    const T = ut.getPrimitive();
+    U(t, b, T), T.applyMatrix4(e);
+    const _ = N(n), M = C(n, g);
+    U(_, l, vt), U(M, l, St);
+    const R = T.intersectsBox(vt), v = T.intersectsBox(St);
+    P = R && Y(
+      t,
+      _,
+      i,
+      e,
+      s,
+      r,
+      c,
+      o,
+      u + 1,
+      T,
+      !f
+    ) || v && Y(
+      t,
+      M,
+      i,
+      e,
+      s,
+      r,
+      c,
+      o,
+      u + 1,
+      T,
+      !f
+    ), ut.releasePrimitive(T);
+  } else {
+    const T = N(t), _ = C(t, y);
+    U(T, b, Pe), U(_, b, ve);
+    const M = d.intersectsBox(Pe), R = d.intersectsBox(ve);
+    if (M && R)
+      P = Y(
+        n,
+        T,
+        e,
+        i,
+        s,
+        c,
+        r,
+        u,
+        o + 1,
+        d,
+        f
+      ) || Y(
+        n,
+        _,
+        e,
+        i,
+        s,
+        c,
+        r,
+        u,
+        o + 1,
+        d,
+        f
+      );
+    else if (M)
+      if (A)
+        P = Y(
+          n,
+          T,
+          e,
+          i,
+          s,
+          c,
+          r,
+          u,
+          o + 1,
+          d,
+          f
+        );
+      else {
+        const v = ut.getPrimitive();
+        v.copy(Pe).applyMatrix4(e);
+        const B = N(n), E = C(n, g);
+        U(B, l, vt), U(E, l, St);
+        const $ = v.intersectsBox(vt), k = v.intersectsBox(St);
+        P = $ && Y(
+          T,
+          B,
+          i,
+          e,
+          s,
+          r,
+          c,
+          o,
+          u + 1,
+          v,
+          !f
+        ) || k && Y(
+          T,
+          E,
+          i,
+          e,
+          s,
+          r,
+          c,
+          o,
+          u + 1,
+          v,
+          !f
+        ), ut.releasePrimitive(v);
+      }
+    else if (R)
+      if (A)
+        P = Y(
+          n,
+          _,
+          e,
+          i,
+          s,
+          c,
+          r,
+          u,
+          o + 1,
+          d,
+          f
+        );
+      else {
+        const v = ut.getPrimitive();
+        v.copy(ve).applyMatrix4(e);
+        const B = N(n), E = C(n, g);
+        U(B, l, vt), U(E, l, St);
+        const $ = v.intersectsBox(vt), k = v.intersectsBox(St);
+        P = $ && Y(
+          _,
+          B,
+          i,
+          e,
+          s,
+          r,
+          c,
+          o,
+          u + 1,
+          v,
+          !f
+        ) || k && Y(
+          _,
+          E,
+          i,
+          e,
+          s,
+          r,
+          c,
+          o,
+          u + 1,
+          v,
+          !f
+        ), ut.releasePrimitive(v);
+      }
+  }
+  return P;
+}
+const wn = /* @__PURE__ */ new et(), Mt = /* @__PURE__ */ new Float32Array(6);
+class Ji {
+  constructor() {
+    this._roots = null, this.primitiveBuffer = null, this.primitiveBufferStride = null;
+  }
+  init(t) {
+    t = {
+      ...Qn,
+      ...t
+    }, Vi(this, t);
+  }
+  getRootRanges() {
+    throw new Error("BVH: getRootRanges() not implemented");
+  }
+  // write the i-th primitive bounds in a 6-value min / max format to the buffer
+  // starting at the given "writeOffset"
+  writePrimitiveBounds() {
+    throw new Error("BVH: writePrimitiveBounds() not implemented");
+  }
+  // writes the union bounds of all primitives in the given range in a min / max format
+  // to the buffer
+  writePrimitiveRangeBounds(t, e, i, s) {
+    let c = 1 / 0, r = 1 / 0, u = 1 / 0, o = -1 / 0, d = -1 / 0, f = -1 / 0;
+    for (let p = t, a = t + e; p < a; p++) {
+      this.writePrimitiveBounds(p, Mt, 0);
+      const [l, g, h, b, y, m] = Mt;
+      l < c && (c = l), b > o && (o = b), g < r && (r = g), y > d && (d = y), h < u && (u = h), m > f && (f = m);
+    }
+    return i[s + 0] = c, i[s + 1] = r, i[s + 2] = u, i[s + 3] = o, i[s + 4] = d, i[s + 5] = f, i;
+  }
+  computePrimitiveBounds(t, e, i) {
+    const s = i.offset || 0;
+    for (let c = t, r = t + e; c < r; c++) {
+      this.writePrimitiveBounds(c, Mt, 0);
+      const [u, o, d, f, p, a] = Mt, l = (u + f) / 2, g = (o + p) / 2, h = (d + a) / 2, b = (f - u) / 2, y = (p - o) / 2, m = (a - d) / 2, x = (c - s) * 6;
+      i[x + 0] = l, i[x + 1] = b + (Math.abs(l) + b) * ue, i[x + 2] = g, i[x + 3] = y + (Math.abs(g) + y) * ue, i[x + 4] = h, i[x + 5] = m + (Math.abs(h) + m) * ue;
+    }
+    return i;
+  }
+  shiftPrimitiveOffsets(t) {
+    const e = this._indirectBuffer;
+    if (e)
+      for (let i = 0, s = e.length; i < s; i++)
+        e[i] += t;
+    else {
+      const i = this._roots;
+      for (let s = 0; s < i.length; s++) {
+        const c = i[s], r = new Uint32Array(c), u = new Uint16Array(c), o = c.byteLength / O;
+        for (let d = 0; d < o; d++) {
+          const f = j * d, p = 2 * f;
+          D(p, u) && (r[f + 6] += t);
+        }
+      }
+    }
+  }
+  traverse(t, e = 0) {
+    const i = this._roots[e], s = new Uint32Array(i), c = new Uint16Array(i);
+    r(0);
+    function r(u, o = 0) {
+      const d = u * 2, f = D(d, c);
+      if (f) {
+        const p = s[u + 6], a = c[d + 14];
+        t(o, f, new Float32Array(i, u * 4, 6), p, a);
+      } else {
+        const p = N(u), a = C(u, s), l = He(u, s);
+        t(o, f, new Float32Array(i, u * 4, 6), l) || (r(p, o + 1), r(a, o + 1));
+      }
+    }
+  }
+  refit() {
+    const t = this._roots;
+    for (let e = 0, i = t.length; e < i; e++) {
+      const s = t[e], c = new Uint32Array(s), r = new Uint16Array(s), u = new Float32Array(s), o = s.byteLength / O;
+      for (let d = o - 1; d >= 0; d--) {
+        const f = d * j, p = f * 2;
+        if (D(p, r)) {
+          const l = V(f, c), g = G(p, r);
+          this.writePrimitiveRangeBounds(l, g, Mt, 0), u.set(Mt, f);
+        } else {
+          const l = N(f), g = C(f, c);
+          for (let h = 0; h < 3; h++) {
+            const b = u[l + h], y = u[l + h + 3], m = u[g + h], x = u[g + h + 3];
+            u[f + h] = b < m ? b : m, u[f + h + 3] = y > x ? y : x;
+          }
+        }
+      }
+    }
+  }
+  getBoundingBox(t) {
+    return t.makeEmpty(), this._roots.forEach((i) => {
+      U(0, new Float32Array(i), wn), t.union(wn);
+    }), t;
+  }
+  // Base shapecast implementation that can be used by subclasses
+  // TODO: see if we can get rid of "iterateFunc" here as well as the primitive so the function
+  // API aligns with the "shapecast" implementation
+  shapecast(t) {
+    let {
+      boundsTraverseOrder: e,
+      intersectsBounds: i,
+      intersectsRange: s,
+      intersectsPrimitive: c,
+      scratchPrimitive: r,
+      iterate: u
+    } = t;
+    if (s && c) {
+      const p = s;
+      s = (a, l, g, h, b) => p(a, l, g, h, b) ? !0 : u(a, l, this, c, g, h, r);
+    } else s || (c ? s = (p, a, l, g) => u(p, a, this, c, l, g, r) : s = (p, a, l) => l);
+    let o = !1, d = 0;
+    const f = this._roots;
+    for (let p = 0, a = f.length; p < a; p++) {
+      const l = f[p];
+      if (o = Gi(this, p, i, s, e, d), o)
+        break;
+      d += l.byteLength / O;
+    }
+    return o;
+  }
+  bvhcast(t, e, i) {
+    let { intersectsRanges: s } = i;
+    return Qi(this, t, e, s);
+  }
+}
+function Xi() {
+  return typeof SharedArrayBuffer < "u";
+}
+function Ke(n) {
+  return n.index ? n.index.count : n.attributes.position.count;
+}
+function he(n) {
+  return Ke(n) / 3;
+}
+function Hi(n, t = ArrayBuffer) {
+  return n > 65535 ? new Uint32Array(new t(4 * n)) : new Uint16Array(new t(2 * n));
+}
+function Zi(n, t) {
+  if (!n.index) {
+    const e = n.attributes.position.count, i = t.useSharedArrayBuffer ? SharedArrayBuffer : ArrayBuffer, s = Hi(e, i);
+    n.setIndex(new Un(s, 1));
+    for (let c = 0; c < e; c++)
+      s[c] = c;
+  }
+}
+function Ki(n, t, e) {
+  const i = Ke(n) / e, s = t || n.drawRange, c = s.start / e, r = (s.start + s.count) / e, u = Math.max(0, c), o = Math.min(i, r) - u;
+  return {
+    offset: Math.floor(u),
+    count: Math.floor(o)
+  };
+}
+function Yi(n, t) {
+  return n.groups.map((e) => ({
+    offset: e.start / t,
+    count: e.count / t
+  }));
+}
+function bn(n, t, e) {
+  const i = Ki(n, t, e), s = Yi(n, e);
+  if (!s.length)
+    return [i];
+  const c = [], r = i.offset, u = i.offset + i.count, o = Ke(n) / e, d = [];
+  for (const a of s) {
+    const { offset: l, count: g } = a, h = l, b = isFinite(g) ? g : o - l, y = l + b;
+    h < u && y > r && (d.push({ pos: Math.max(r, h), isStart: !0 }), d.push({ pos: Math.min(u, y), isStart: !1 }));
+  }
+  d.sort((a, l) => a.pos !== l.pos ? a.pos - l.pos : a.type === "end" ? -1 : 1);
+  let f = 0, p = null;
+  for (const a of d) {
+    const l = a.pos;
+    f !== 0 && l !== p && c.push({
+      offset: p,
+      count: l - p
+    }), f += a.isStart ? 1 : -1, p = l;
+  }
+  return c;
+}
+function ts(n, t) {
+  const e = n[n.length - 1], i = e.offset + e.count > 2 ** 16, s = n.reduce((d, f) => d + f.count, 0), c = i ? 4 : 2, r = t ? new SharedArrayBuffer(s * c) : new ArrayBuffer(s * c), u = i ? new Uint32Array(r) : new Uint16Array(r);
+  let o = 0;
+  for (let d = 0; d < n.length; d++) {
+    const { offset: f, count: p } = n[d];
+    for (let a = 0; a < p; a++)
+      u[o + a] = f + a;
+    o += p;
+  }
+  return u;
+}
+class es extends Ji {
+  get indirect() {
+    return !!this._indirectBuffer;
+  }
+  get primitiveStride() {
+    return null;
+  }
+  get primitiveBufferStride() {
+    return this.indirect ? 1 : this.primitiveStride;
+  }
+  set primitiveBufferStride(t) {
+  }
+  get primitiveBuffer() {
+    return this.indirect ? this._indirectBuffer : this.geometry.index.array;
+  }
+  set primitiveBuffer(t) {
+  }
+  constructor(t, e = {}) {
+    if (t.isBufferGeometry) {
+      if (t.index && t.index.isInterleavedBufferAttribute)
+        throw new Error("BVH: InterleavedBufferAttribute is not supported for the index attribute.");
+    } else throw new Error("BVH: Only BufferGeometries are supported.");
+    if (e.useSharedArrayBuffer && !Xi())
+      throw new Error("BVH: SharedArrayBuffer is not available.");
+    super(), this.geometry = t, this.resolvePrimitiveIndex = e.indirect ? (i) => this._indirectBuffer[i] : (i) => i, this.primitiveBuffer = null, this.primitiveBufferStride = null, this._indirectBuffer = null, e = {
+      ...Qn,
+      ...e
+    }, e[Xe] || this.init(e);
+  }
+  init(t) {
+    const { geometry: e, primitiveStride: i } = this;
+    if (t.indirect) {
+      const s = bn(e, t.range, i), c = ts(s, t.useSharedArrayBuffer);
+      this._indirectBuffer = c;
+    } else
+      Zi(e, t);
+    super.init(t), !e.boundingBox && t.setBoundingBox && (e.boundingBox = this.getBoundingBox(new et()));
+  }
+  // Abstract methods to be implemented by subclasses
+  getRootRanges(t) {
+    return this.indirect ? [{ offset: 0, count: this._indirectBuffer.length }] : bn(this.geometry, t, this.primitiveStride);
+  }
+  raycastObject3D() {
+    throw new Error("BVH: raycastObject3D() not implemented");
+  }
+}
+class at {
+  constructor() {
+    this.min = 1 / 0, this.max = -1 / 0;
+  }
+  setFromPointsField(t, e) {
+    let i = 1 / 0, s = -1 / 0;
+    for (let c = 0, r = t.length; c < r; c++) {
+      const o = t[c][e];
+      i = o < i ? o : i, s = o > s ? o : s;
+    }
+    this.min = i, this.max = s;
+  }
+  setFromPoints(t, e) {
+    let i = 1 / 0, s = -1 / 0;
+    for (let c = 0, r = e.length; c < r; c++) {
+      const u = e[c], o = t.dot(u);
+      i = o < i ? o : i, s = o > s ? o : s;
+    }
+    this.min = i, this.max = s;
+  }
+  isSeparated(t) {
+    return this.min > t.max || t.min > this.max;
+  }
+}
+at.prototype.setFromBox = /* @__PURE__ */ function() {
+  const n = /* @__PURE__ */ new z();
+  return function(e, i) {
+    const s = i.min, c = i.max;
+    let r = 1 / 0, u = -1 / 0;
+    for (let o = 0; o <= 1; o++)
+      for (let d = 0; d <= 1; d++)
+        for (let f = 0; f <= 1; f++) {
+          n.x = s.x * o + c.x * (1 - o), n.y = s.y * d + c.y * (1 - d), n.z = s.z * f + c.z * (1 - f);
+          const p = e.dot(n);
+          r = Math.min(p, r), u = Math.max(p, u);
+        }
+    this.min = r, this.max = u;
+  };
+}();
+const ns = /* @__PURE__ */ function() {
+  const n = /* @__PURE__ */ new z(), t = /* @__PURE__ */ new z(), e = /* @__PURE__ */ new z();
+  return function(s, c, r) {
+    const u = s.start, o = n, d = c.start, f = t;
+    e.subVectors(u, d), n.subVectors(s.end, s.start), t.subVectors(c.end, c.start);
+    const p = e.dot(f), a = f.dot(o), l = f.dot(f), g = e.dot(o), b = o.dot(o) * l - a * a;
+    let y, m;
+    b !== 0 ? y = (p * a - g * l) / b : y = 0, m = (p + y * a) / l, r.x = y, r.y = m;
+  };
+}(), Ye = /* @__PURE__ */ function() {
+  const n = /* @__PURE__ */ new pt(), t = /* @__PURE__ */ new z(), e = /* @__PURE__ */ new z();
+  return function(s, c, r, u) {
+    ns(s, c, n);
+    let o = n.x, d = n.y;
+    if (o >= 0 && o <= 1 && d >= 0 && d <= 1) {
+      s.at(o, r), c.at(d, u);
+      return;
+    } else if (o >= 0 && o <= 1) {
+      d < 0 ? c.at(0, u) : c.at(1, u), s.closestPointToPoint(u, !0, r);
+      return;
+    } else if (d >= 0 && d <= 1) {
+      o < 0 ? s.at(0, r) : s.at(1, r), c.closestPointToPoint(r, !0, u);
+      return;
+    } else {
+      let f;
+      o < 0 ? f = s.start : f = s.end;
+      let p;
+      d < 0 ? p = c.start : p = c.end;
+      const a = t, l = e;
+      if (s.closestPointToPoint(p, !0, t), c.closestPointToPoint(f, !0, e), a.distanceToSquared(p) <= l.distanceToSquared(f)) {
+        r.copy(a), u.copy(p);
+        return;
+      } else {
+        r.copy(f), u.copy(l);
+        return;
+      }
+    }
+  };
+}(), is = /* @__PURE__ */ function() {
+  const n = /* @__PURE__ */ new z(), t = /* @__PURE__ */ new z(), e = /* @__PURE__ */ new Ln(), i = /* @__PURE__ */ new rt();
+  return function(c, r) {
+    const { radius: u, center: o } = c, { a: d, b: f, c: p } = r;
+    if (i.start = d, i.end = f, i.closestPointToPoint(o, !0, n).distanceTo(o) <= u || (i.start = d, i.end = p, i.closestPointToPoint(o, !0, n).distanceTo(o) <= u) || (i.start = f, i.end = p, i.closestPointToPoint(o, !0, n).distanceTo(o) <= u)) return !0;
+    const h = r.getPlane(e);
+    if (Math.abs(h.distanceToPoint(o)) <= u) {
+      const y = h.projectPoint(o, t);
+      if (r.containsPoint(y)) return !0;
+    }
+    return !1;
+  };
+}(), ss = ["x", "y", "z"], ot = 1e-15, xn = ot * ot;
+function Z(n) {
+  return Math.abs(n) < ot;
+}
+class tt extends Et {
+  constructor(...t) {
+    super(...t), this.isExtendedTriangle = !0, this.satAxes = new Array(4).fill().map(() => new z()), this.satBounds = new Array(4).fill().map(() => new at()), this.points = [this.a, this.b, this.c], this.plane = new Ln(), this.isDegenerateIntoSegment = !1, this.isDegenerateIntoPoint = !1, this.degenerateSegment = new rt(), this.needsUpdate = !0;
+  }
+  intersectsSphere(t) {
+    return is(t, this);
+  }
+  update() {
+    const t = this.a, e = this.b, i = this.c, s = this.points, c = this.satAxes, r = this.satBounds, u = c[0], o = r[0];
+    this.getNormal(u), o.setFromPoints(u, s);
+    const d = c[1], f = r[1];
+    d.subVectors(t, e), f.setFromPoints(d, s);
+    const p = c[2], a = r[2];
+    p.subVectors(e, i), a.setFromPoints(p, s);
+    const l = c[3], g = r[3];
+    l.subVectors(i, t), g.setFromPoints(l, s);
+    const h = d.length(), b = p.length(), y = l.length();
+    this.isDegenerateIntoPoint = !1, this.isDegenerateIntoSegment = !1, h < ot ? b < ot || y < ot ? this.isDegenerateIntoPoint = !0 : (this.isDegenerateIntoSegment = !0, this.degenerateSegment.start.copy(t), this.degenerateSegment.end.copy(i)) : b < ot ? y < ot ? this.isDegenerateIntoPoint = !0 : (this.isDegenerateIntoSegment = !0, this.degenerateSegment.start.copy(e), this.degenerateSegment.end.copy(t)) : y < ot && (this.isDegenerateIntoSegment = !0, this.degenerateSegment.start.copy(i), this.degenerateSegment.end.copy(e)), this.plane.setFromNormalAndCoplanarPoint(u, t), this.needsUpdate = !1;
+  }
+}
+tt.prototype.closestPointToSegment = /* @__PURE__ */ function() {
+  const n = /* @__PURE__ */ new z(), t = /* @__PURE__ */ new z(), e = /* @__PURE__ */ new rt();
+  return function(s, c = null, r = null) {
+    const { start: u, end: o } = s, d = this.points;
+    let f, p = 1 / 0;
+    for (let a = 0; a < 3; a++) {
+      const l = (a + 1) % 3;
+      e.start.copy(d[a]), e.end.copy(d[l]), Ye(e, s, n, t), f = n.distanceToSquared(t), f < p && (p = f, c && c.copy(n), r && r.copy(t));
+    }
+    return this.closestPointToPoint(u, n), f = u.distanceToSquared(n), f < p && (p = f, c && c.copy(n), r && r.copy(u)), this.closestPointToPoint(o, n), f = o.distanceToSquared(n), f < p && (p = f, c && c.copy(n), r && r.copy(o)), Math.sqrt(p);
+  };
+}();
+tt.prototype.intersectsTriangle = /* @__PURE__ */ function() {
+  const n = /* @__PURE__ */ new tt(), t = /* @__PURE__ */ new at(), e = /* @__PURE__ */ new at(), i = /* @__PURE__ */ new z(), s = /* @__PURE__ */ new z(), c = /* @__PURE__ */ new z(), r = /* @__PURE__ */ new z(), u = /* @__PURE__ */ new rt(), o = /* @__PURE__ */ new rt(), d = /* @__PURE__ */ new z(), f = /* @__PURE__ */ new pt(), p = /* @__PURE__ */ new pt();
+  function a(x, w, A, S) {
+    const P = i;
+    !x.isDegenerateIntoPoint && !x.isDegenerateIntoSegment ? P.copy(x.plane.normal) : P.copy(w.plane.normal);
+    const T = x.satBounds, _ = x.satAxes;
+    for (let v = 1; v < 4; v++) {
+      const B = T[v], E = _[v];
+      if (t.setFromPoints(E, w.points), B.isSeparated(t) || (r.copy(P).cross(E), t.setFromPoints(r, x.points), e.setFromPoints(r, w.points), t.isSeparated(e))) return !1;
+    }
+    const M = w.satBounds, R = w.satAxes;
+    for (let v = 1; v < 4; v++) {
+      const B = M[v], E = R[v];
+      if (t.setFromPoints(E, x.points), B.isSeparated(t) || (r.crossVectors(P, E), t.setFromPoints(r, x.points), e.setFromPoints(r, w.points), t.isSeparated(e))) return !1;
+    }
+    return A && (S || console.warn("ExtendedTriangle.intersectsTriangle: Triangles are coplanar which does not support an output edge. Setting edge to 0, 0, 0."), A.start.set(0, 0, 0), A.end.set(0, 0, 0)), !0;
+  }
+  function l(x, w, A, S, P, T, _, M, R, v, B) {
+    let E = _ / (_ - M);
+    v.x = S + (P - S) * E, B.start.subVectors(w, x).multiplyScalar(E).add(x), E = _ / (_ - R), v.y = S + (T - S) * E, B.end.subVectors(A, x).multiplyScalar(E).add(x);
+  }
+  function g(x, w, A, S, P, T, _, M, R, v, B) {
+    if (P > 0)
+      l(x.c, x.a, x.b, S, w, A, R, _, M, v, B);
+    else if (T > 0)
+      l(x.b, x.a, x.c, A, w, S, M, _, R, v, B);
+    else if (M * R > 0 || _ != 0)
+      l(x.a, x.b, x.c, w, A, S, _, M, R, v, B);
+    else if (M != 0)
+      l(x.b, x.a, x.c, A, w, S, M, _, R, v, B);
+    else if (R != 0)
+      l(x.c, x.a, x.b, S, w, A, R, _, M, v, B);
+    else
+      return !0;
+    return !1;
+  }
+  function h(x, w, A, S) {
+    const P = w.degenerateSegment, T = x.plane.distanceToPoint(P.start), _ = x.plane.distanceToPoint(P.end);
+    return Z(T) ? Z(_) ? a(x, w, A, S) : (A && (A.start.copy(P.start), A.end.copy(P.start)), x.containsPoint(P.start)) : Z(_) ? (A && (A.start.copy(P.end), A.end.copy(P.end)), x.containsPoint(P.end)) : x.plane.intersectLine(P, i) != null ? (A && (A.start.copy(i), A.end.copy(i)), x.containsPoint(i)) : !1;
+  }
+  function b(x, w, A) {
+    const S = w.a;
+    return Z(x.plane.distanceToPoint(S)) && x.containsPoint(S) ? (A && (A.start.copy(S), A.end.copy(S)), !0) : !1;
+  }
+  function y(x, w, A) {
+    const S = x.degenerateSegment, P = w.a;
+    return S.closestPointToPoint(P, !0, i), P.distanceToSquared(i) < xn ? (A && (A.start.copy(P), A.end.copy(P)), !0) : !1;
+  }
+  function m(x, w, A, S) {
+    if (x.isDegenerateIntoSegment)
+      if (w.isDegenerateIntoSegment) {
+        const P = x.degenerateSegment, T = w.degenerateSegment, _ = s, M = c;
+        P.delta(_), T.delta(M);
+        const R = i.subVectors(T.start, P.start), v = _.x * M.y - _.y * M.x;
+        if (Z(v))
+          return !1;
+        const B = (R.x * M.y - R.y * M.x) / v, E = -(_.x * R.y - _.y * R.x) / v;
+        if (B < 0 || B > 1 || E < 0 || E > 1)
+          return !1;
+        const $ = P.start.z + _.z * B, k = T.start.z + M.z * E;
+        return Z($ - k) ? (A && (A.start.copy(P.start).addScaledVector(_, B), A.end.copy(P.start).addScaledVector(_, B)), !0) : !1;
+      } else return w.isDegenerateIntoPoint ? y(x, w, A) : h(w, x, A, S);
+    else {
+      if (x.isDegenerateIntoPoint)
+        return w.isDegenerateIntoPoint ? w.a.distanceToSquared(x.a) < xn ? (A && (A.start.copy(x.a), A.end.copy(x.a)), !0) : !1 : w.isDegenerateIntoSegment ? y(w, x, A) : b(w, x, A);
+      if (w.isDegenerateIntoPoint)
+        return b(x, w, A);
+      if (w.isDegenerateIntoSegment)
+        return h(x, w, A, S);
+    }
+  }
+  return function(w, A = null, S = !1) {
+    this.needsUpdate && this.update(), w.isExtendedTriangle ? w.needsUpdate && w.update() : (n.copy(w), n.update(), w = n);
+    const P = m(this, w, A, S);
+    if (P !== void 0)
+      return P;
+    const T = this.plane, _ = w.plane;
+    let M = _.distanceToPoint(this.a), R = _.distanceToPoint(this.b), v = _.distanceToPoint(this.c);
+    Z(M) && (M = 0), Z(R) && (R = 0), Z(v) && (v = 0);
+    const B = M * R, E = M * v;
+    if (B > 0 && E > 0)
+      return !1;
+    let $ = T.distanceToPoint(w.a), k = T.distanceToPoint(w.b), yt = T.distanceToPoint(w.c);
+    Z($) && ($ = 0), Z(k) && (k = 0), Z(yt) && (yt = 0);
+    const It = $ * k, nt = $ * yt;
+    if (It > 0 && nt > 0)
+      return !1;
+    s.copy(T.normal), c.copy(_.normal);
+    const ct = s.cross(c);
+    let xt = 0, me = Math.abs(ct.x);
+    const tn = Math.abs(ct.y);
+    tn > me && (me = tn, xt = 1), Math.abs(ct.z) > me && (xt = 2);
+    const At = ss[xt], Hn = this.a[At], Zn = this.b[At], Kn = this.c[At], Yn = w.a[At], ti = w.b[At], ei = w.c[At];
+    if (g(this, Hn, Zn, Kn, B, E, M, R, v, f, u))
+      return a(this, w, A, S);
+    if (g(w, Yn, ti, ei, It, nt, $, k, yt, p, o))
+      return a(this, w, A, S);
+    if (f.y < f.x) {
+      const ge = f.y;
+      f.y = f.x, f.x = ge, d.copy(u.start), u.start.copy(u.end), u.end.copy(d);
+    }
+    if (p.y < p.x) {
+      const ge = p.y;
+      p.y = p.x, p.x = ge, d.copy(o.start), o.start.copy(o.end), o.end.copy(d);
+    }
+    return f.y < p.x || p.y < f.x ? !1 : (A && (p.x > f.x ? A.start.copy(o.start) : A.start.copy(u.start), p.y < f.y ? A.end.copy(o.end) : A.end.copy(u.end)), !0);
+  };
+}();
+tt.prototype.distanceToPoint = /* @__PURE__ */ function() {
+  const n = /* @__PURE__ */ new z();
+  return function(e) {
+    return this.closestPointToPoint(e, n), e.distanceTo(n);
+  };
+}();
+tt.prototype.distanceToTriangle = /* @__PURE__ */ function() {
+  const n = /* @__PURE__ */ new z(), t = /* @__PURE__ */ new z(), e = ["a", "b", "c"], i = /* @__PURE__ */ new rt(), s = /* @__PURE__ */ new rt();
+  return function(r, u = null, o = null) {
+    const d = u || o ? i : null;
+    if (this.intersectsTriangle(r, d))
+      return (u || o) && (u && d.getCenter(u), o && d.getCenter(o)), 0;
+    let f = 1 / 0;
+    for (let p = 0; p < 3; p++) {
+      let a;
+      const l = e[p], g = r[l];
+      this.closestPointToPoint(g, n), a = g.distanceToSquared(n), a < f && (f = a, u && u.copy(n), o && o.copy(g));
+      const h = this[l];
+      r.closestPointToPoint(h, n), a = h.distanceToSquared(n), a < f && (f = a, u && u.copy(h), o && o.copy(n));
+    }
+    for (let p = 0; p < 3; p++) {
+      const a = e[p], l = e[(p + 1) % 3];
+      i.set(this[a], this[l]);
+      for (let g = 0; g < 3; g++) {
+        const h = e[g], b = e[(g + 1) % 3];
+        s.set(r[h], r[b]), Ye(i, s, n, t);
+        const y = n.distanceToSquared(t);
+        y < f && (f = y, u && u.copy(n), o && o.copy(t));
+      }
+    }
+    return Math.sqrt(f);
+  };
+}();
+class Q {
+  constructor(t, e, i) {
+    this.isOrientedBox = !0, this.min = new z(), this.max = new z(), this.matrix = new W(), this.invMatrix = new W(), this.points = new Array(8).fill().map(() => new z()), this.satAxes = new Array(3).fill().map(() => new z()), this.satBounds = new Array(3).fill().map(() => new at()), this.alignedSatBounds = new Array(3).fill().map(() => new at()), this.needsUpdate = !1, t && this.min.copy(t), e && this.max.copy(e), i && this.matrix.copy(i);
+  }
+  set(t, e, i) {
+    this.min.copy(t), this.max.copy(e), this.matrix.copy(i), this.needsUpdate = !0;
+  }
+  copy(t) {
+    this.min.copy(t.min), this.max.copy(t.max), this.matrix.copy(t.matrix), this.needsUpdate = !0;
+  }
+}
+Q.prototype.update = /* @__PURE__ */ function() {
+  return function() {
+    const t = this.matrix, e = this.min, i = this.max, s = this.points;
+    for (let d = 0; d <= 1; d++)
+      for (let f = 0; f <= 1; f++)
+        for (let p = 0; p <= 1; p++) {
+          const a = 1 * d | 2 * f | 4 * p, l = s[a];
+          l.x = d ? i.x : e.x, l.y = f ? i.y : e.y, l.z = p ? i.z : e.z, l.applyMatrix4(t);
+        }
+    const c = this.satBounds, r = this.satAxes, u = s[0];
+    for (let d = 0; d < 3; d++) {
+      const f = r[d], p = c[d], a = 1 << d, l = s[a];
+      f.subVectors(u, l), p.setFromPoints(f, s);
+    }
+    const o = this.alignedSatBounds;
+    o[0].setFromPointsField(s, "x"), o[1].setFromPointsField(s, "y"), o[2].setFromPointsField(s, "z"), this.invMatrix.copy(this.matrix).invert(), this.needsUpdate = !1;
+  };
+}();
+Q.prototype.intersectsBox = /* @__PURE__ */ function() {
+  const n = /* @__PURE__ */ new at();
+  return function(e) {
+    this.needsUpdate && this.update();
+    const i = e.min, s = e.max, c = this.satBounds, r = this.satAxes, u = this.alignedSatBounds;
+    if (n.min = i.x, n.max = s.x, u[0].isSeparated(n) || (n.min = i.y, n.max = s.y, u[1].isSeparated(n)) || (n.min = i.z, n.max = s.z, u[2].isSeparated(n))) return !1;
+    for (let o = 0; o < 3; o++) {
+      const d = r[o], f = c[o];
+      if (n.setFromBox(d, e), f.isSeparated(n)) return !1;
+    }
+    return !0;
+  };
+}();
+Q.prototype.intersectsTriangle = /* @__PURE__ */ function() {
+  const n = /* @__PURE__ */ new tt(), t = /* @__PURE__ */ new Array(3), e = /* @__PURE__ */ new at(), i = /* @__PURE__ */ new at(), s = /* @__PURE__ */ new z();
+  return function(r) {
+    this.needsUpdate && this.update(), r.isExtendedTriangle ? r.needsUpdate && r.update() : (n.copy(r), n.update(), r = n);
+    const u = this.satBounds, o = this.satAxes;
+    t[0] = r.a, t[1] = r.b, t[2] = r.c;
+    for (let a = 0; a < 3; a++) {
+      const l = u[a], g = o[a];
+      if (e.setFromPoints(g, t), l.isSeparated(e)) return !1;
+    }
+    const d = r.satBounds, f = r.satAxes, p = this.points;
+    for (let a = 0; a < 3; a++) {
+      const l = d[a], g = f[a];
+      if (e.setFromPoints(g, p), l.isSeparated(e)) return !1;
+    }
+    for (let a = 0; a < 3; a++) {
+      const l = o[a];
+      for (let g = 0; g < 4; g++) {
+        const h = f[g];
+        if (s.crossVectors(l, h), e.setFromPoints(s, t), i.setFromPoints(s, p), e.isSeparated(i)) return !1;
+      }
+    }
+    return !0;
+  };
+}();
+Q.prototype.closestPointToPoint = /* @__PURE__ */ function() {
+  return function(t, e) {
+    return this.needsUpdate && this.update(), e.copy(t).applyMatrix4(this.invMatrix).clamp(this.min, this.max).applyMatrix4(this.matrix), e;
+  };
+}();
+Q.prototype.distanceToPoint = function() {
+  const n = new z();
+  return function(e) {
+    return this.closestPointToPoint(e, n), e.distanceTo(n);
+  };
+}();
+Q.prototype.distanceToBox = /* @__PURE__ */ function() {
+  const n = ["x", "y", "z"], t = /* @__PURE__ */ new Array(12).fill().map(() => new rt()), e = /* @__PURE__ */ new Array(12).fill().map(() => new rt()), i = /* @__PURE__ */ new z(), s = /* @__PURE__ */ new z();
+  return function(r, u = 0, o = null, d = null) {
+    if (this.needsUpdate && this.update(), this.intersectsBox(r))
+      return (o || d) && (r.getCenter(s), this.closestPointToPoint(s, i), r.closestPointToPoint(i, s), o && o.copy(i), d && d.copy(s)), 0;
+    const f = u * u, p = r.min, a = r.max, l = this.points;
+    let g = 1 / 0;
+    for (let b = 0; b < 8; b++) {
+      const y = l[b];
+      s.copy(y).clamp(p, a);
+      const m = y.distanceToSquared(s);
+      if (m < g && (g = m, o && o.copy(y), d && d.copy(s), m < f))
+        return Math.sqrt(m);
+    }
+    let h = 0;
+    for (let b = 0; b < 3; b++)
+      for (let y = 0; y <= 1; y++)
+        for (let m = 0; m <= 1; m++) {
+          const x = (b + 1) % 3, w = (b + 2) % 3, A = y << x | m << w, S = 1 << b | y << x | m << w, P = l[A], T = l[S];
+          t[h].set(P, T);
+          const M = n[b], R = n[x], v = n[w], B = e[h], E = B.start, $ = B.end;
+          E[M] = p[M], E[R] = y ? p[R] : a[R], E[v] = m ? p[v] : a[R], $[M] = a[M], $[R] = y ? p[R] : a[R], $[v] = m ? p[v] : a[R], h++;
+        }
+    for (let b = 0; b <= 1; b++)
+      for (let y = 0; y <= 1; y++)
+        for (let m = 0; m <= 1; m++) {
+          s.x = b ? a.x : p.x, s.y = y ? a.y : p.y, s.z = m ? a.z : p.z, this.closestPointToPoint(s, i);
+          const x = s.distanceToSquared(i);
+          if (x < g && (g = x, o && o.copy(i), d && d.copy(s), x < f))
+            return Math.sqrt(x);
+        }
+    for (let b = 0; b < 12; b++) {
+      const y = t[b];
+      for (let m = 0; m < 12; m++) {
+        const x = e[m];
+        Ye(y, x, i, s);
+        const w = i.distanceToSquared(s);
+        if (w < g && (g = w, o && o.copy(i), d && d.copy(s), w < f))
+          return Math.sqrt(w);
+      }
+    }
+    return Math.sqrt(g);
+  };
+}();
+class os extends Ze {
+  constructor() {
+    super(() => new tt());
+  }
+}
+const K = /* @__PURE__ */ new os(), jt = /* @__PURE__ */ new z(), Me = /* @__PURE__ */ new z();
+function rs(n, t, e = {}, i = 0, s = 1 / 0) {
+  const c = i * i, r = s * s;
+  let u = 1 / 0, o = null;
+  if (n.shapecast(
+    {
+      boundsTraverseOrder: (f) => (jt.copy(t).clamp(f.min, f.max), jt.distanceToSquared(t)),
+      intersectsBounds: (f, p, a) => a < u && a < r,
+      intersectsTriangle: (f, p) => {
+        f.closestPointToPoint(t, jt);
+        const a = t.distanceToSquared(jt);
+        return a < u && (Me.copy(jt), u = a, o = p), a < c;
+      }
+    }
+  ), u === 1 / 0) return null;
+  const d = Math.sqrt(u);
+  return e.point ? e.point.copy(Me) : e.point = Me.clone(), e.distance = d, e.faceIndex = o, e;
+}
+const Xt = parseInt(jn) >= 169, as = parseInt(jn) <= 161, mt = /* @__PURE__ */ new z(), gt = /* @__PURE__ */ new z(), wt = /* @__PURE__ */ new z(), Ht = /* @__PURE__ */ new pt(), Zt = /* @__PURE__ */ new pt(), Kt = /* @__PURE__ */ new pt(), An = /* @__PURE__ */ new z(), Pn = /* @__PURE__ */ new z(), vn = /* @__PURE__ */ new z(), Dt = /* @__PURE__ */ new z();
+function cs(n, t, e, i, s, c, r, u) {
+  let o;
+  if (c === fi ? o = n.intersectTriangle(i, e, t, !0, s) : o = n.intersectTriangle(t, e, i, c !== di, s), o === null) return null;
+  const d = n.origin.distanceTo(s);
+  return d < r || d > u ? null : {
+    distance: d,
+    point: s.clone()
+  };
+}
+function Sn(n, t, e, i, s, c, r, u, o, d, f) {
+  mt.fromBufferAttribute(t, c), gt.fromBufferAttribute(t, r), wt.fromBufferAttribute(t, u);
+  const p = cs(n, mt, gt, wt, Dt, o, d, f);
+  if (p) {
+    if (i) {
+      Ht.fromBufferAttribute(i, c), Zt.fromBufferAttribute(i, r), Kt.fromBufferAttribute(i, u), p.uv = new pt();
+      const l = Et.getInterpolation(Dt, mt, gt, wt, Ht, Zt, Kt, p.uv);
+      Xt || (p.uv = l);
+    }
+    if (s) {
+      Ht.fromBufferAttribute(s, c), Zt.fromBufferAttribute(s, r), Kt.fromBufferAttribute(s, u), p.uv1 = new pt();
+      const l = Et.getInterpolation(Dt, mt, gt, wt, Ht, Zt, Kt, p.uv1);
+      Xt || (p.uv1 = l), as && (p.uv2 = p.uv1);
+    }
+    if (e) {
+      An.fromBufferAttribute(e, c), Pn.fromBufferAttribute(e, r), vn.fromBufferAttribute(e, u), p.normal = new z();
+      const l = Et.getInterpolation(Dt, mt, gt, wt, An, Pn, vn, p.normal);
+      p.normal.dot(n.direction) > 0 && p.normal.multiplyScalar(-1), Xt || (p.normal = l);
+    }
+    const a = {
+      a: c,
+      b: r,
+      c: u,
+      normal: new z(),
+      materialIndex: 0
+    };
+    if (Et.getNormal(mt, gt, wt, a.normal), p.face = a, p.faceIndex = c, Xt) {
+      const l = new z();
+      Et.getBarycoord(Dt, mt, gt, wt, l), p.barycoord = l;
+    }
+  }
+  return p;
+}
+function Mn(n) {
+  return n && n.isMaterial ? n.side : n;
+}
+function ye(n, t, e, i, s, c, r) {
+  const u = i * 3;
+  let o = u + 0, d = u + 1, f = u + 2;
+  const { index: p, groups: a } = n;
+  n.index && (o = p.getX(o), d = p.getX(d), f = p.getX(f));
+  const { position: l, normal: g, uv: h, uv1: b } = n.attributes;
+  if (Array.isArray(t)) {
+    const y = i * 3;
+    for (let m = 0, x = a.length; m < x; m++) {
+      const { start: w, count: A, materialIndex: S } = a[m];
+      if (y >= w && y < w + A) {
+        const P = Mn(t[S]), T = Sn(e, l, g, h, b, o, d, f, P, c, r);
+        if (T)
+          if (T.faceIndex = i, T.face.materialIndex = S, s)
+            s.push(T);
+          else
+            return T;
+      }
+    }
+  } else {
+    const y = Mn(t), m = Sn(e, l, g, h, b, o, d, f, y, c, r);
+    if (m)
+      if (m.faceIndex = i, m.face.materialIndex = 0, s)
+        s.push(m);
+      else
+        return m;
+  }
+  return null;
+}
+function L(n, t, e, i) {
+  const s = n.a, c = n.b, r = n.c;
+  let u = t, o = t + 1, d = t + 2;
+  e && (u = e.getX(u), o = e.getX(o), d = e.getX(d)), s.x = i.getX(u), s.y = i.getY(u), s.z = i.getZ(u), c.x = i.getX(o), c.y = i.getY(o), c.z = i.getZ(o), r.x = i.getX(d), r.y = i.getY(d), r.z = i.getZ(d);
+}
+function ls(n, t, e, i, s, c, r, u) {
+  const { geometry: o, _indirectBuffer: d } = n;
+  for (let f = i, p = i + s; f < p; f++)
+    ye(o, t, e, f, c, r, u);
+}
+function us(n, t, e, i, s, c, r) {
+  const { geometry: u, _indirectBuffer: o } = n;
+  let d = 1 / 0, f = null;
+  for (let p = i, a = i + s; p < a; p++) {
+    let l;
+    l = ye(u, t, e, p, null, c, r), l && l.distance < d && (f = l, d = l.distance);
+  }
+  return f;
+}
+function fs(n, t, e, i, s, c, r) {
+  const { geometry: u } = e, { index: o } = u, d = u.attributes.position;
+  for (let f = n, p = t + n; f < p; f++) {
+    let a;
+    if (a = f, L(r, a * 3, o, d), r.needsUpdate = !0, i(r, a, s, c))
+      return !0;
+  }
+  return !1;
+}
+function ds(n, t = null) {
+  t && Array.isArray(t) && (t = new Set(t));
+  const e = n.geometry, i = e.index ? e.index.array : null, s = e.attributes.position;
+  let c, r, u, o, d = 0;
+  const f = n._roots;
+  for (let a = 0, l = f.length; a < l; a++)
+    c = f[a], r = new Uint32Array(c), u = new Uint16Array(c), o = new Float32Array(c), p(0, d), d += c.byteLength;
+  function p(a, l, g = !1) {
+    const h = a * 2;
+    if (D(h, u)) {
+      const b = V(a, r), y = G(h, u);
+      let m = 1 / 0, x = 1 / 0, w = 1 / 0, A = -1 / 0, S = -1 / 0, P = -1 / 0;
+      for (let T = 3 * b, _ = 3 * (b + y); T < _; T++) {
+        let M = i[T];
+        const R = s.getX(M), v = s.getY(M), B = s.getZ(M);
+        R < m && (m = R), R > A && (A = R), v < x && (x = v), v > S && (S = v), B < w && (w = B), B > P && (P = B);
+      }
+      return o[a + 0] !== m || o[a + 1] !== x || o[a + 2] !== w || o[a + 3] !== A || o[a + 4] !== S || o[a + 5] !== P ? (o[a + 0] = m, o[a + 1] = x, o[a + 2] = w, o[a + 3] = A, o[a + 4] = S, o[a + 5] = P, !0) : !1;
+    } else {
+      const b = N(a), y = C(a, r);
+      let m = g, x = !1, w = !1;
+      if (t) {
+        if (!m) {
+          const M = b / j + l / O, R = y / j + l / O;
+          x = t.has(M), w = t.has(R), m = !x && !w;
+        }
+      } else
+        x = !0, w = !0;
+      const A = m || x, S = m || w;
+      let P = !1;
+      A && (P = p(b, l, m));
+      let T = !1;
+      S && (T = p(y, l, m));
+      const _ = P || T;
+      if (_)
+        for (let M = 0; M < 3; M++) {
+          const R = b + M, v = y + M, B = o[R], E = o[R + 3], $ = o[v], k = o[v + 3];
+          o[a + M] = B < $ ? B : $, o[a + M + 3] = E > k ? E : k;
+        }
+      return _;
+    }
+  }
+}
+function ht(n, t, e, i, s) {
+  let c, r, u, o, d, f;
+  const p = 1 / e.direction.x, a = 1 / e.direction.y, l = 1 / e.direction.z, g = e.origin.x, h = e.origin.y, b = e.origin.z;
+  let y = t[n], m = t[n + 3], x = t[n + 1], w = t[n + 3 + 1], A = t[n + 2], S = t[n + 3 + 2];
+  return p >= 0 ? (c = (y - g) * p, r = (m - g) * p) : (c = (m - g) * p, r = (y - g) * p), a >= 0 ? (u = (x - h) * a, o = (w - h) * a) : (u = (w - h) * a, o = (x - h) * a), c > o || u > r || ((u > c || isNaN(c)) && (c = u), (o < r || isNaN(r)) && (r = o), l >= 0 ? (d = (A - b) * l, f = (S - b) * l) : (d = (S - b) * l, f = (A - b) * l), c > f || d > r) ? !1 : ((d > c || c !== c) && (c = d), (f < r || r !== r) && (r = f), c <= s && r >= i);
+}
+function ps(n, t, e, i, s, c, r, u) {
+  const { geometry: o, _indirectBuffer: d } = n;
+  for (let f = i, p = i + s; f < p; f++) {
+    let a = d ? d[f] : f;
+    ye(o, t, e, a, c, r, u);
+  }
+}
+function hs(n, t, e, i, s, c, r) {
+  const { geometry: u, _indirectBuffer: o } = n;
+  let d = 1 / 0, f = null;
+  for (let p = i, a = i + s; p < a; p++) {
+    let l;
+    l = ye(u, t, e, o ? o[p] : p, null, c, r), l && l.distance < d && (f = l, d = l.distance);
+  }
+  return f;
+}
+function ys(n, t, e, i, s, c, r) {
+  const { geometry: u } = e, { index: o } = u, d = u.attributes.position;
+  for (let f = n, p = t + n; f < p; f++) {
+    let a;
+    if (a = e.resolveTriangleIndex(f), L(r, a * 3, o, d), r.needsUpdate = !0, i(r, a, s, c))
+      return !0;
+  }
+  return !1;
+}
+function ms(n, t, e, i, s, c, r) {
+  F.setBuffer(n._roots[t]), Le(0, n, e, i, s, c, r), F.clearBuffer();
+}
+function Le(n, t, e, i, s, c, r) {
+  const { float32Array: u, uint16Array: o, uint32Array: d } = F, f = n * 2;
+  if (D(f, o)) {
+    const a = V(n, d), l = G(f, o);
+    ls(t, e, i, a, l, s, c, r);
+  } else {
+    const a = N(n);
+    ht(a, u, i, c, r) && Le(a, t, e, i, s, c, r);
+    const l = C(n, d);
+    ht(l, u, i, c, r) && Le(l, t, e, i, s, c, r);
+  }
+}
+const gs = ["x", "y", "z"];
+function ws(n, t, e, i, s, c) {
+  F.setBuffer(n._roots[t]);
+  const r = je(0, n, e, i, s, c);
+  return F.clearBuffer(), r;
+}
+function je(n, t, e, i, s, c) {
+  const { float32Array: r, uint16Array: u, uint32Array: o } = F;
+  let d = n * 2;
+  if (D(d, u)) {
+    const p = V(n, o), a = G(d, u);
+    return us(t, e, i, p, a, s, c);
+  } else {
+    const p = He(n, o), a = gs[p], g = i.direction[a] >= 0;
+    let h, b;
+    g ? (h = N(n), b = C(n, o)) : (h = C(n, o), b = N(n));
+    const m = ht(h, r, i, s, c) ? je(h, t, e, i, s, c) : null;
+    if (m) {
+      const A = m.point[a];
+      if (g ? A <= r[b + p] : (
+        // min bounding data
+        A >= r[b + p + 3]
+      ))
+        return m;
+    }
+    const w = ht(b, r, i, s, c) ? je(b, t, e, i, s, c) : null;
+    return m && w ? m.distance <= w.distance ? m : w : m || w || null;
+  }
+}
+const Yt = /* @__PURE__ */ new et(), Tt = /* @__PURE__ */ new tt(), Bt = /* @__PURE__ */ new tt(), Nt = /* @__PURE__ */ new W(), Tn = /* @__PURE__ */ new Q(), te = /* @__PURE__ */ new Q();
+function bs(n, t, e, i) {
+  F.setBuffer(n._roots[t]);
+  const s = De(0, n, e, i);
+  return F.clearBuffer(), s;
+}
+function De(n, t, e, i, s = null) {
+  const { float32Array: c, uint16Array: r, uint32Array: u } = F;
+  let o = n * 2;
+  if (s === null && (e.boundingBox || e.computeBoundingBox(), Tn.set(e.boundingBox.min, e.boundingBox.max, i), s = Tn), D(o, r)) {
+    const f = t.geometry, p = f.index, a = f.attributes.position, l = e.index, g = e.attributes.position, h = V(n, u), b = G(o, r);
+    if (Nt.copy(i).invert(), e.boundsTree)
+      return U(n, c, te), te.matrix.copy(Nt), te.needsUpdate = !0, e.boundsTree.shapecast({
+        intersectsBounds: (m) => te.intersectsBox(m),
+        intersectsTriangle: (m) => {
+          m.a.applyMatrix4(i), m.b.applyMatrix4(i), m.c.applyMatrix4(i), m.needsUpdate = !0;
+          for (let x = h * 3, w = (b + h) * 3; x < w; x += 3)
+            if (L(Bt, x, p, a), Bt.needsUpdate = !0, m.intersectsTriangle(Bt))
+              return !0;
+          return !1;
+        }
+      });
+    {
+      const y = he(e);
+      for (let m = h * 3, x = (b + h) * 3; m < x; m += 3) {
+        L(Tt, m, p, a), Tt.a.applyMatrix4(Nt), Tt.b.applyMatrix4(Nt), Tt.c.applyMatrix4(Nt), Tt.needsUpdate = !0;
+        for (let w = 0, A = y * 3; w < A; w += 3)
+          if (L(Bt, w, l, g), Bt.needsUpdate = !0, Tt.intersectsTriangle(Bt))
+            return !0;
+      }
+    }
+  } else {
+    const f = N(n), p = C(n, u);
+    return U(f, c, Yt), !!(s.intersectsBox(Yt) && De(f, t, e, i, s) || (U(p, c, Yt), s.intersectsBox(Yt) && De(p, t, e, i, s)));
+  }
+}
+const ee = /* @__PURE__ */ new W(), Te = /* @__PURE__ */ new Q(), Ct = /* @__PURE__ */ new Q(), xs = /* @__PURE__ */ new z(), As = /* @__PURE__ */ new z(), Ps = /* @__PURE__ */ new z(), vs = /* @__PURE__ */ new z();
+function Ss(n, t, e, i = {}, s = {}, c = 0, r = 1 / 0) {
+  t.boundingBox || t.computeBoundingBox(), Te.set(t.boundingBox.min, t.boundingBox.max, e), Te.needsUpdate = !0;
+  const u = n.geometry, o = u.attributes.position, d = u.index, f = t.attributes.position, p = t.index, a = K.getPrimitive(), l = K.getPrimitive();
+  let g = xs, h = As, b = null, y = null;
+  s && (b = Ps, y = vs);
+  let m = 1 / 0, x = null, w = null;
+  return ee.copy(e).invert(), Ct.matrix.copy(ee), n.shapecast(
+    {
+      boundsTraverseOrder: (A) => Te.distanceToBox(A),
+      intersectsBounds: (A, S, P) => P < m && P < r ? (S && (Ct.min.copy(A.min), Ct.max.copy(A.max), Ct.needsUpdate = !0), !0) : !1,
+      intersectsRange: (A, S) => {
+        if (t.boundsTree)
+          return t.boundsTree.shapecast({
+            boundsTraverseOrder: (T) => Ct.distanceToBox(T),
+            intersectsBounds: (T, _, M) => M < m && M < r,
+            intersectsRange: (T, _) => {
+              for (let M = T, R = T + _; M < R; M++) {
+                L(l, 3 * M, p, f), l.a.applyMatrix4(e), l.b.applyMatrix4(e), l.c.applyMatrix4(e), l.needsUpdate = !0;
+                for (let v = A, B = A + S; v < B; v++) {
+                  L(a, 3 * v, d, o), a.needsUpdate = !0;
+                  const E = a.distanceToTriangle(l, g, b);
+                  if (E < m && (h.copy(g), y && y.copy(b), m = E, x = v, w = M), E < c)
+                    return !0;
+                }
+              }
+            }
+          });
+        {
+          const P = he(t);
+          for (let T = 0, _ = P; T < _; T++) {
+            L(l, 3 * T, p, f), l.a.applyMatrix4(e), l.b.applyMatrix4(e), l.c.applyMatrix4(e), l.needsUpdate = !0;
+            for (let M = A, R = A + S; M < R; M++) {
+              L(a, 3 * M, d, o), a.needsUpdate = !0;
+              const v = a.distanceToTriangle(l, g, b);
+              if (v < m && (h.copy(g), y && y.copy(b), m = v, x = M, w = T), v < c)
+                return !0;
+            }
+          }
+        }
+      }
+    }
+  ), K.releasePrimitive(a), K.releasePrimitive(l), m === 1 / 0 ? null : (i.point ? i.point.copy(h) : i.point = h.clone(), i.distance = m, i.faceIndex = x, s && (s.point ? s.point.copy(y) : s.point = y.clone(), s.point.applyMatrix4(ee), h.applyMatrix4(ee), s.distance = h.sub(s.point).length(), s.faceIndex = w), i);
+}
+function Ms(n, t = null) {
+  t && Array.isArray(t) && (t = new Set(t));
+  const e = n.geometry, i = e.index ? e.index.array : null, s = e.attributes.position;
+  let c, r, u, o, d = 0;
+  const f = n._roots;
+  for (let a = 0, l = f.length; a < l; a++)
+    c = f[a], r = new Uint32Array(c), u = new Uint16Array(c), o = new Float32Array(c), p(0, d), d += c.byteLength;
+  function p(a, l, g = !1) {
+    const h = a * 2;
+    if (D(h, u)) {
+      const b = V(a, r), y = G(h, u);
+      let m = 1 / 0, x = 1 / 0, w = 1 / 0, A = -1 / 0, S = -1 / 0, P = -1 / 0;
+      for (let T = b, _ = b + y; T < _; T++) {
+        const M = 3 * n.resolveTriangleIndex(T);
+        for (let R = 0; R < 3; R++) {
+          let v = M + R;
+          v = i ? i[v] : v;
+          const B = s.getX(v), E = s.getY(v), $ = s.getZ(v);
+          B < m && (m = B), B > A && (A = B), E < x && (x = E), E > S && (S = E), $ < w && (w = $), $ > P && (P = $);
+        }
+      }
+      return o[a + 0] !== m || o[a + 1] !== x || o[a + 2] !== w || o[a + 3] !== A || o[a + 4] !== S || o[a + 5] !== P ? (o[a + 0] = m, o[a + 1] = x, o[a + 2] = w, o[a + 3] = A, o[a + 4] = S, o[a + 5] = P, !0) : !1;
+    } else {
+      const b = N(a), y = C(a, r);
+      let m = g, x = !1, w = !1;
+      if (t) {
+        if (!m) {
+          const M = b / j + l / O, R = y / j + l / O;
+          x = t.has(M), w = t.has(R), m = !x && !w;
+        }
+      } else
+        x = !0, w = !0;
+      const A = m || x, S = m || w;
+      let P = !1;
+      A && (P = p(b, l, m));
+      let T = !1;
+      S && (T = p(y, l, m));
+      const _ = P || T;
+      if (_)
+        for (let M = 0; M < 3; M++) {
+          const R = b + M, v = y + M, B = o[R], E = o[R + 3], $ = o[v], k = o[v + 3];
+          o[a + M] = B < $ ? B : $, o[a + M + 3] = E > k ? E : k;
+        }
+      return _;
+    }
+  }
+}
+function Ts(n, t, e, i, s, c, r) {
+  F.setBuffer(n._roots[t]), Ne(0, n, e, i, s, c, r), F.clearBuffer();
+}
+function Ne(n, t, e, i, s, c, r) {
+  const { float32Array: u, uint16Array: o, uint32Array: d } = F, f = n * 2;
+  if (D(f, o)) {
+    const a = V(n, d), l = G(f, o);
+    ps(t, e, i, a, l, s, c, r);
+  } else {
+    const a = N(n);
+    ht(a, u, i, c, r) && Ne(a, t, e, i, s, c, r);
+    const l = C(n, d);
+    ht(l, u, i, c, r) && Ne(l, t, e, i, s, c, r);
+  }
+}
+const Bs = ["x", "y", "z"];
+function _s(n, t, e, i, s, c) {
+  F.setBuffer(n._roots[t]);
+  const r = Ce(0, n, e, i, s, c);
+  return F.clearBuffer(), r;
+}
+function Ce(n, t, e, i, s, c) {
+  const { float32Array: r, uint16Array: u, uint32Array: o } = F;
+  let d = n * 2;
+  if (D(d, u)) {
+    const p = V(n, o), a = G(d, u);
+    return hs(t, e, i, p, a, s, c);
+  } else {
+    const p = He(n, o), a = Bs[p], g = i.direction[a] >= 0;
+    let h, b;
+    g ? (h = N(n), b = C(n, o)) : (h = C(n, o), b = N(n));
+    const m = ht(h, r, i, s, c) ? Ce(h, t, e, i, s, c) : null;
+    if (m) {
+      const A = m.point[a];
+      if (g ? A <= r[b + p] : (
+        // min bounding data
+        A >= r[b + p + 3]
+      ))
+        return m;
+    }
+    const w = ht(b, r, i, s, c) ? Ce(b, t, e, i, s, c) : null;
+    return m && w ? m.distance <= w.distance ? m : w : m || w || null;
+  }
+}
+const ne = /* @__PURE__ */ new et(), _t = /* @__PURE__ */ new tt(), Rt = /* @__PURE__ */ new tt(), qt = /* @__PURE__ */ new W(), Bn = /* @__PURE__ */ new Q(), ie = /* @__PURE__ */ new Q();
+function Rs(n, t, e, i) {
+  F.setBuffer(n._roots[t]);
+  const s = qe(0, n, e, i);
+  return F.clearBuffer(), s;
+}
+function qe(n, t, e, i, s = null) {
+  const { float32Array: c, uint16Array: r, uint32Array: u } = F;
+  let o = n * 2;
+  if (s === null && (e.boundingBox || e.computeBoundingBox(), Bn.set(e.boundingBox.min, e.boundingBox.max, i), s = Bn), D(o, r)) {
+    const f = t.geometry, p = f.index, a = f.attributes.position, l = e.index, g = e.attributes.position, h = V(n, u), b = G(o, r);
+    if (qt.copy(i).invert(), e.boundsTree)
+      return U(n, c, ie), ie.matrix.copy(qt), ie.needsUpdate = !0, e.boundsTree.shapecast({
+        intersectsBounds: (m) => ie.intersectsBox(m),
+        intersectsTriangle: (m) => {
+          m.a.applyMatrix4(i), m.b.applyMatrix4(i), m.c.applyMatrix4(i), m.needsUpdate = !0;
+          for (let x = h, w = b + h; x < w; x++)
+            if (L(Rt, 3 * t.resolveTriangleIndex(x), p, a), Rt.needsUpdate = !0, m.intersectsTriangle(Rt))
+              return !0;
+          return !1;
+        }
+      });
+    {
+      const y = he(e);
+      for (let m = h, x = b + h; m < x; m++) {
+        const w = t.resolveTriangleIndex(m);
+        L(_t, 3 * w, p, a), _t.a.applyMatrix4(qt), _t.b.applyMatrix4(qt), _t.c.applyMatrix4(qt), _t.needsUpdate = !0;
+        for (let A = 0, S = y * 3; A < S; A += 3)
+          if (L(Rt, A, l, g), Rt.needsUpdate = !0, _t.intersectsTriangle(Rt))
+            return !0;
+      }
+    }
+  } else {
+    const f = N(n), p = C(n, u);
+    return U(f, c, ne), !!(s.intersectsBox(ne) && qe(f, t, e, i, s) || (U(p, c, ne), s.intersectsBox(ne) && qe(p, t, e, i, s)));
+  }
+}
+const se = /* @__PURE__ */ new W(), Be = /* @__PURE__ */ new Q(), Ot = /* @__PURE__ */ new Q(), Es = /* @__PURE__ */ new z(), zs = /* @__PURE__ */ new z(), $s = /* @__PURE__ */ new z(), Fs = /* @__PURE__ */ new z();
+function ks(n, t, e, i = {}, s = {}, c = 0, r = 1 / 0) {
+  t.boundingBox || t.computeBoundingBox(), Be.set(t.boundingBox.min, t.boundingBox.max, e), Be.needsUpdate = !0;
+  const u = n.geometry, o = u.attributes.position, d = u.index, f = t.attributes.position, p = t.index, a = K.getPrimitive(), l = K.getPrimitive();
+  let g = Es, h = zs, b = null, y = null;
+  s && (b = $s, y = Fs);
+  let m = 1 / 0, x = null, w = null;
+  return se.copy(e).invert(), Ot.matrix.copy(se), n.shapecast(
+    {
+      boundsTraverseOrder: (A) => Be.distanceToBox(A),
+      intersectsBounds: (A, S, P) => P < m && P < r ? (S && (Ot.min.copy(A.min), Ot.max.copy(A.max), Ot.needsUpdate = !0), !0) : !1,
+      intersectsRange: (A, S) => {
+        if (t.boundsTree) {
+          const P = t.boundsTree;
+          return P.shapecast({
+            boundsTraverseOrder: (T) => Ot.distanceToBox(T),
+            intersectsBounds: (T, _, M) => M < m && M < r,
+            intersectsRange: (T, _) => {
+              for (let M = T, R = T + _; M < R; M++) {
+                const v = P.resolveTriangleIndex(M);
+                L(l, 3 * v, p, f), l.a.applyMatrix4(e), l.b.applyMatrix4(e), l.c.applyMatrix4(e), l.needsUpdate = !0;
+                for (let B = A, E = A + S; B < E; B++) {
+                  const $ = n.resolveTriangleIndex(B);
+                  L(a, 3 * $, d, o), a.needsUpdate = !0;
+                  const k = a.distanceToTriangle(l, g, b);
+                  if (k < m && (h.copy(g), y && y.copy(b), m = k, x = B, w = M), k < c)
+                    return !0;
+                }
+              }
+            }
+          });
+        } else {
+          const P = he(t);
+          for (let T = 0, _ = P; T < _; T++) {
+            L(l, 3 * T, p, f), l.a.applyMatrix4(e), l.b.applyMatrix4(e), l.c.applyMatrix4(e), l.needsUpdate = !0;
+            for (let M = A, R = A + S; M < R; M++) {
+              const v = n.resolveTriangleIndex(M);
+              L(a, 3 * v, d, o), a.needsUpdate = !0;
+              const B = a.distanceToTriangle(l, g, b);
+              if (B < m && (h.copy(g), y && y.copy(b), m = B, x = M, w = T), B < c)
+                return !0;
+            }
+          }
+        }
+      }
+    }
+  ), K.releasePrimitive(a), K.releasePrimitive(l), m === 1 / 0 ? null : (i.point ? i.point.copy(h) : i.point = h.clone(), i.distance = m, i.faceIndex = x, s && (s.point ? s.point.copy(y) : s.point = y.clone(), s.point.applyMatrix4(se), h.applyMatrix4(se), s.distance = h.sub(s.point).length(), s.faceIndex = w), i);
+}
+function _n(n, t, e) {
+  return n === null ? null : (n.point.applyMatrix4(t.matrixWorld), n.distance = n.point.distanceTo(e.ray.origin), n.object = t, n);
+}
+const oe = /* @__PURE__ */ new Q(), re = /* @__PURE__ */ new pi(), Rn = /* @__PURE__ */ new z(), En = /* @__PURE__ */ new W(), zn = /* @__PURE__ */ new z(), _e = ["getX", "getY", "getZ"];
+class pe extends es {
+  static serialize(t, e = {}) {
+    e = {
+      cloneBuffers: !0,
+      ...e
+    };
+    const i = t.geometry, s = t._roots, c = t._indirectBuffer, r = i.getIndex(), u = {
+      version: 1,
+      roots: null,
+      index: null,
+      indirectBuffer: null
+    };
+    return e.cloneBuffers ? (u.roots = s.map((o) => o.slice()), u.index = r ? r.array.slice() : null, u.indirectBuffer = c ? c.slice() : null) : (u.roots = s, u.index = r ? r.array : null, u.indirectBuffer = c), u;
+  }
+  static deserialize(t, e, i = {}) {
+    i = {
+      setIndex: !0,
+      indirect: !!t.indirectBuffer,
+      ...i
+    };
+    const { index: s, roots: c, indirectBuffer: r } = t;
+    t.version || (console.warn(
+      "MeshBVH.deserialize: Serialization format has been changed and will be fixed up. It is recommended to regenerate any stored serialized data."
+    ), o(c));
+    const u = new pe(e, { ...i, [Xe]: !0 });
+    if (u._roots = c, u._indirectBuffer = r || null, i.setIndex) {
+      const d = e.getIndex();
+      if (d === null) {
+        const f = new Un(t.index, 1, !1);
+        e.setIndex(f);
+      } else d.array !== s && (d.array.set(s), d.needsUpdate = !0);
+    }
+    return u;
+    function o(d) {
+      for (let f = 0; f < d.length; f++) {
+        const p = d[f], a = new Uint32Array(p), l = new Uint16Array(p);
+        for (let g = 0, h = p.byteLength / O; g < h; g++) {
+          const b = j * g, y = 2 * b;
+          D(y, l) || (a[b + 6] = a[b + 6] / j - g);
+        }
+      }
+    }
+  }
+  get primitiveStride() {
+    return 3;
+  }
+  get resolveTriangleIndex() {
+    return this.resolvePrimitiveIndex;
+  }
+  constructor(t, e = {}) {
+    e.maxLeafTris && (console.warn('MeshBVH: "maxLeafTris" option has been deprecated. Use maxLeafSize, instead.'), e = {
+      ...e,
+      maxLeafSize: e.maxLeafTris
+    }), super(t, e);
+  }
+  // implement abstract methods from BVH base class
+  shiftTriangleOffsets(t) {
+    return super.shiftPrimitiveOffsets(t);
+  }
+  // write primitive bounds to the buffer - used only for validateBounds at the moment
+  writePrimitiveBounds(t, e, i) {
+    const s = this.geometry, c = this._indirectBuffer, r = s.attributes.position, u = s.index ? s.index.array : null, d = (c ? c[t] : t) * 3;
+    let f = d + 0, p = d + 1, a = d + 2;
+    u && (f = u[f], p = u[p], a = u[a]);
+    for (let l = 0; l < 3; l++) {
+      const g = r[_e[l]](f), h = r[_e[l]](p), b = r[_e[l]](a);
+      let y = g;
+      h < y && (y = h), b < y && (y = b);
+      let m = g;
+      h > m && (m = h), b > m && (m = b), e[i + l] = y, e[i + l + 3] = m;
+    }
+    return e;
+  }
+  // precomputes the bounding box for each triangle; required for quickly calculating tree splits.
+  // result is an array of size count * 6 where triangle i maps to a
+  // [x_center, x_delta, y_center, y_delta, z_center, z_delta] tuple starting at index (i - offset) * 6,
+  // representing the center and half-extent in each dimension of triangle i
+  computePrimitiveBounds(t, e, i) {
+    const s = this.geometry, c = this._indirectBuffer, r = s.attributes.position, u = s.index ? s.index.array : null, o = r.normalized;
+    if (t < 0 || e + t - i.offset > i.length / 6)
+      throw new Error("MeshBVH: compute triangle bounds range is invalid.");
+    const d = r.array, f = r.offset || 0;
+    let p = 3;
+    r.isInterleavedBufferAttribute && (p = r.data.stride);
+    const a = ["getX", "getY", "getZ"], l = i.offset;
+    for (let g = t, h = t + e; g < h; g++) {
+      const y = (c ? c[g] : g) * 3, m = (g - l) * 6;
+      let x = y + 0, w = y + 1, A = y + 2;
+      u && (x = u[x], w = u[w], A = u[A]), o || (x = x * p + f, w = w * p + f, A = A * p + f);
+      for (let S = 0; S < 3; S++) {
+        let P, T, _;
+        o ? (P = r[a[S]](x), T = r[a[S]](w), _ = r[a[S]](A)) : (P = d[x + S], T = d[w + S], _ = d[A + S]);
+        let M = P;
+        T < M && (M = T), _ < M && (M = _);
+        let R = P;
+        T > R && (R = T), _ > R && (R = _);
+        const v = (R - M) / 2, B = S * 2;
+        i[m + B + 0] = M + v, i[m + B + 1] = v + (Math.abs(M) + v) * ue;
+      }
+    }
+    return i;
+  }
+  raycastObject3D(t, e, i = []) {
+    const { material: s } = t;
+    if (s === void 0)
+      return;
+    En.copy(t.matrixWorld).invert(), re.copy(e.ray).applyMatrix4(En), zn.setFromMatrixScale(t.matrixWorld), Rn.copy(re.direction).multiply(zn);
+    const c = Rn.length(), r = e.near / c, u = e.far / c;
+    if (e.firstHitOnly === !0) {
+      let o = this.raycastFirst(re, s, r, u);
+      o = _n(o, t, e), o && i.push(o);
+    } else {
+      const o = this.raycast(re, s, r, u);
+      for (let d = 0, f = o.length; d < f; d++) {
+        const p = _n(o[d], t, e);
+        p && i.push(p);
+      }
+    }
+    return i;
+  }
+  refit(t = null) {
+    return (this.indirect ? Ms : ds)(this, t);
+  }
+  /* Core Cast Functions */
+  raycast(t, e = on, i = 0, s = 1 / 0) {
+    const c = this._roots, r = [], u = this.indirect ? Ts : ms;
+    for (let o = 0, d = c.length; o < d; o++)
+      u(this, o, e, t, r, i, s);
+    return r;
+  }
+  raycastFirst(t, e = on, i = 0, s = 1 / 0) {
+    const c = this._roots;
+    let r = null;
+    const u = this.indirect ? _s : ws;
+    for (let o = 0, d = c.length; o < d; o++) {
+      const f = u(this, o, e, t, i, s);
+      f != null && (r == null || f.distance < r.distance) && (r = f);
+    }
+    return r;
+  }
+  intersectsGeometry(t, e) {
+    let i = !1;
+    const s = this._roots, c = this.indirect ? Rs : bs;
+    for (let r = 0, u = s.length; r < u && (i = c(this, r, t, e), !i); r++)
+      ;
+    return i;
+  }
+  shapecast(t) {
+    const e = K.getPrimitive(), i = super.shapecast(
+      {
+        ...t,
+        intersectsPrimitive: t.intersectsTriangle,
+        scratchPrimitive: e,
+        // TODO: is the performance significant enough for the added complexity here?
+        // can we just use one function?
+        iterate: this.indirect ? ys : fs
+      }
+    );
+    return K.releasePrimitive(e), i;
+  }
+  bvhcast(t, e, i) {
+    let {
+      intersectsRanges: s,
+      intersectsTriangles: c
+    } = i;
+    const r = K.getPrimitive(), u = this.geometry.index, o = this.geometry.attributes.position, d = this.indirect ? (g) => {
+      const h = this.resolveTriangleIndex(g);
+      L(r, h * 3, u, o);
+    } : (g) => {
+      L(r, g * 3, u, o);
+    }, f = K.getPrimitive(), p = t.geometry.index, a = t.geometry.attributes.position, l = t.indirect ? (g) => {
+      const h = t.resolveTriangleIndex(g);
+      L(f, h * 3, p, a);
+    } : (g) => {
+      L(f, g * 3, p, a);
+    };
+    if (c) {
+      if (!(t instanceof pe))
+        throw new Error('MeshBVH: "intersectsTriangles" callback can only be used with another MeshBVH.');
+      const g = (h, b, y, m, x, w, A, S) => {
+        for (let P = y, T = y + m; P < T; P++) {
+          l(P), f.a.applyMatrix4(e), f.b.applyMatrix4(e), f.c.applyMatrix4(e), f.needsUpdate = !0;
+          for (let _ = h, M = h + b; _ < M; _++)
+            if (d(_), r.needsUpdate = !0, c(r, f, _, P, x, w, A, S))
+              return !0;
+        }
+        return !1;
+      };
+      if (s) {
+        const h = s;
+        s = function(b, y, m, x, w, A, S, P) {
+          return h(b, y, m, x, w, A, S, P) ? !0 : g(b, y, m, x, w, A, S, P);
+        };
+      } else
+        s = g;
+    }
+    return super.bvhcast(t, e, { intersectsRanges: s });
+  }
+  /* Derived Cast Functions */
+  intersectsBox(t, e) {
+    return oe.set(t.min, t.max, e), oe.needsUpdate = !0, this.shapecast(
+      {
+        intersectsBounds: (i) => oe.intersectsBox(i),
+        intersectsTriangle: (i) => oe.intersectsTriangle(i)
+      }
+    );
+  }
+  intersectsSphere(t) {
+    return this.shapecast(
+      {
+        intersectsBounds: (e) => t.intersectsBox(e),
+        intersectsTriangle: (e) => e.intersectsSphere(t)
+      }
+    );
+  }
+  closestPointToGeometry(t, e, i = {}, s = {}, c = 0, r = 1 / 0) {
+    return (this.indirect ? ks : Ss)(
+      this,
+      t,
+      e,
+      i,
+      s,
+      c,
+      r
+    );
+  }
+  closestPointToPoint(t, e = {}, i = 0, s = 1 / 0) {
+    return rs(
+      this,
+      t,
+      e,
+      i,
+      s
+    );
+  }
+}
+const zt = {
+  Mesh: H.prototype.raycast,
+  Line: Qe.prototype.raycast,
+  LineSegments: Ge.prototype.raycast,
+  LineLoop: Dn.prototype.raycast,
+  Points: Nn.prototype.raycast,
+  BatchedMesh: yi.prototype.raycast
+}, q = /* @__PURE__ */ new H(), ae = [];
+function Is(n, t) {
+  if (this.isBatchedMesh)
+    Us.call(this, n, t);
+  else {
+    const { geometry: e } = this;
+    if (e.boundsTree)
+      e.boundsTree.raycastObject3D(this, n, t);
+    else {
+      let i;
+      if (this instanceof H)
+        i = zt.Mesh;
+      else if (this instanceof Ge)
+        i = zt.LineSegments;
+      else if (this instanceof Dn)
+        i = zt.LineLoop;
+      else if (this instanceof Qe)
+        i = zt.Line;
+      else if (this instanceof Nn)
+        i = zt.Points;
+      else
+        throw new Error("BVH: Fallback raycast function not found.");
+      i.call(this, n, t);
+    }
+  }
+}
+function Us(n, t) {
+  if (this.boundsTrees) {
+    const e = this.boundsTrees, i = this._drawInfo || this._instanceInfo, s = this._drawRanges || this._geometryInfo, c = this.matrixWorld;
+    q.material = this.material, q.geometry = this.geometry;
+    const r = q.geometry.boundsTree, u = q.geometry.drawRange;
+    q.geometry.boundingSphere === null && (q.geometry.boundingSphere = new hi());
+    for (let o = 0, d = i.length; o < d; o++) {
+      if (!this.getVisibleAt(o))
+        continue;
+      const f = i[o].geometryIndex;
+      if (q.geometry.boundsTree = e[f], this.getMatrixAt(o, q.matrixWorld).premultiply(c), !q.geometry.boundsTree) {
+        this.getBoundingBoxAt(f, q.geometry.boundingBox), this.getBoundingSphereAt(f, q.geometry.boundingSphere);
+        const p = s[f];
+        q.geometry.setDrawRange(p.start, p.count);
+      }
+      q.raycast(n, ae);
+      for (let p = 0, a = ae.length; p < a; p++) {
+        const l = ae[p];
+        l.object = this, l.batchId = o, t.push(l);
+      }
+      ae.length = 0;
+    }
+    q.geometry.boundsTree = r, q.geometry.drawRange = u, q.material = null, q.geometry = null;
+  } else
+    zt.BatchedMesh.call(this, n, t);
+}
+function Ls(n) {
+  return n.rotationQuaternion ? new J(n.rotationQuaternion[0], n.rotationQuaternion[1], n.rotationQuaternion[2], n.rotationQuaternion[3]).normalize() : new J().setFromEuler(new Ft(...n.rotationRpy, "XYZ"));
+}
+function Re(n) {
+  return n.type === "continuous" || !n.limits ? 0 : Math.max(n.limits.lower, Math.min(n.limits.upper, 0));
+}
+class js {
+  constructor(t, e) {
+    I(this, "root");
+    I(this, "visual");
+    I(this, "joints", /* @__PURE__ */ new Map());
+    I(this, "values", /* @__PURE__ */ new Map());
+    I(this, "pickMeshes", []);
+    I(this, "disposed", !1);
+    I(this, "initialRoots", /* @__PURE__ */ new Map());
+    this.visual = e, this.root = e.root;
+    const i = new Set(t.links.map((l) => l.id)), s = t.joints.filter((l) => i.has(l.parent) && i.has(l.child) && l.parent !== l.child), c = new Set(s.map((l) => l.child)), r = t.links.filter((l) => !c.has(l.id)), u = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Set();
+    for (const l of s)
+      o.has(l.child) || (o.add(l.child), u.set(l.parent, [...u.get(l.parent) ?? [], l]));
+    const d = /* @__PURE__ */ new Set(), f = /* @__PURE__ */ new Set(), p = (l) => {
+      if (f.has(l)) return;
+      f.add(l), d.add(l);
+      const g = e.bindings.get(l);
+      if (!g) {
+        f.delete(l);
+        return;
+      }
+      for (const h of u.get(l) ?? []) {
+        if (f.has(h.child) || d.has(h.child)) continue;
+        const b = e.bindings.get(h.child);
+        if (!b) continue;
+        g.add(b);
+        const y = {
+          joint: h,
+          child: b,
+          originPosition: new z().fromArray(h.origin.position),
+          originQuaternion: Ls(h.origin),
+          axis: new z().fromArray(h.axis).normalize()
+        };
+        this.joints.set(h.id, y), this.values.set(h.id, Re(h)), this.apply(y, this.values.get(h.id)), p(h.child);
+      }
+      f.delete(l);
+    }, a = r.length ? r : t.links;
+    for (const l of a) {
+      if (d.has(l.id)) continue;
+      const g = e.bindings.get(l.id);
+      g && (this.root.add(g), p(l.id));
+    }
+    for (const l of t.links) {
+      if (d.has(l.id)) continue;
+      const g = e.bindings.get(l.id);
+      g && (this.root.add(g), p(l.id));
+    }
+    if (r.length === 1) {
+      const l = qn(t, r[0].id, u), g = e.bindings.get(r[0].id);
+      g && l > 0 && (g.position.z += l);
+    }
+    for (const l of e.bindings.values()) l.parent === this.root && this.initialRoots.set(l, { position: l.position.clone(), quaternion: l.quaternion.clone() });
+    this.preparePicking(), this.root.updateMatrixWorld(!0);
+  }
+  pickRoots() {
+    return this.pickMeshes;
+  }
+  value(t) {
+    return this.values.get(t);
+  }
+  valuesSnapshot() {
+    return Object.freeze(Object.fromEntries(this.values));
+  }
+  setJointValue(t, e) {
+    if (this.disposed) throw ce("URDF kinematic binding has been disposed.", "E_URDF_INACTIVE");
+    const i = this.joints.get(t);
+    if (!i) throw ce(`Unknown URDF joint: ${t}`, "E_URDF_JOINT_UNKNOWN");
+    if (!Number.isFinite(e)) throw ce(`Joint value must be finite: ${t}`, "E_URDF_JOINT_VALUE");
+    let s = e;
+    return i.joint.type !== "continuous" && i.joint.limits && (s = Math.max(i.joint.limits.lower, Math.min(i.joint.limits.upper, e))), ["revolute", "continuous", "prismatic"].includes(i.joint.type) || (s = 0), this.values.set(t, s), this.apply(i, s), this.root.updateMatrixWorld(!0), s;
+  }
+  resetJoint(t) {
+    const e = this.joints.get(t);
+    if (!e) throw ce(`Unknown URDF joint: ${t}`, "E_URDF_JOINT_UNKNOWN");
+    this.setJointValue(t, Re(e.joint));
+  }
+  syncPhysicsPose(t, e) {
+    for (const [i, s] of Object.entries(t)) {
+      const c = this.joints.get(i);
+      c && (this.values.set(i, s), this.apply(c, s));
+    }
+    for (const i of this.initialRoots.keys()) {
+      const s = e.get(i.name);
+      s && (i.position.copy(s.position), i.quaternion.copy(s.quaternion));
+    }
+    this.root.updateMatrixWorld(!0);
+  }
+  resetPose() {
+    for (const [t, e] of this.initialRoots)
+      t.position.copy(e.position), t.quaternion.copy(e.quaternion);
+    for (const t of this.joints.values()) {
+      const e = Re(t.joint);
+      this.values.set(t.joint.id, e), this.apply(t, e);
+    }
+    this.root.updateMatrixWorld(!0);
+  }
+  objectForEntity(t) {
+    var e;
+    return t.startsWith("link:") ? this.visual.bindings.get(t.slice(5)) ?? null : t.startsWith("joint:") ? ((e = this.joints.get(t.slice(6))) == null ? void 0 : e.child) ?? null : t.startsWith("robot:") ? this.root : null;
+  }
+  jointWorldFrame(t) {
+    const e = this.joints.get(t);
+    if (!e) return null;
+    const i = e.child.parent;
+    if (!i) return null;
+    i.updateMatrixWorld(!0);
+    const s = e.originPosition.clone().applyMatrix4(i.matrixWorld), c = i.getWorldQuaternion(new J()).multiply(e.originQuaternion);
+    return { position: s, quaternion: c, axis: e.axis.clone().applyQuaternion(c).normalize() };
+  }
+  dispose() {
+    if (!this.disposed) {
+      this.disposed = !0, this.joints.clear(), this.values.clear();
+      for (const t of this.pickMeshes) {
+        const e = t.geometry;
+        delete e.boundsTree;
+      }
+      this.pickMeshes.length = 0, kt(this.root);
+    }
+  }
+  preparePicking() {
+    const t = /* @__PURE__ */ new Set();
+    this.root.traverse((e) => {
+      if (!(e instanceof H) || !e.geometry) return;
+      const i = e.geometry;
+      !i.boundsTree && !t.has(i) && (i.boundsTree = new pe(i, { maxLeafSize: 20, indirect: !0, verbose: !1 }), t.add(i)), e.raycast = Is, this.pickMeshes.push(e);
+    });
+  }
+  apply(t, e) {
+    t.child.position.copy(t.originPosition), t.child.quaternion.copy(t.originQuaternion), t.joint.type === "revolute" || t.joint.type === "continuous" ? t.child.quaternion.multiply(new J().setFromAxisAngle(t.axis, e)) : t.joint.type === "prismatic" && t.child.position.addScaledVector(t.axis, e);
+  }
+}
+function ce(n, t) {
+  return Object.assign(new Error(n), { code: t });
+}
+function Ds(n, t) {
+  var b;
+  const e = Os(t, n.source.uri), i = new Set(n.links.map((y) => y.id)), s = n.joints.filter((y) => i.has(y.parent) && i.has(y.child) && y.parent !== y.child), c = /* @__PURE__ */ new Map();
+  for (const y of s) c.has(y.child) || c.set(y.child, y);
+  const r = n.links.filter((y) => !c.has(y.id)), u = /* @__PURE__ */ new Map();
+  for (const y of c.values()) u.set(y.parent, [...u.get(y.parent) ?? [], y]);
+  const o = [], d = /* @__PURE__ */ new Set(), f = (y) => {
+    if (!d.has(y)) {
+      d.add(y);
+      for (const m of u.get(y) ?? []) f(m.child);
+    }
+  };
+  for (const y of r)
+    o.push(y), f(y.id);
+  for (const y of n.links) d.has(y.id) || (o.push(y), f(y.id));
+  const p = new Set(o.map((y) => y.id)), a = `robot:${n.name}`, l = /* @__PURE__ */ new Map();
+  for (const y of n.joints) l.set(y.parent, [...l.get(y.parent) ?? [], `joint:${y.id}`]);
+  const g = [], h = Object.freeze({
+    id: a,
+    kind: "robot",
+    name: n.name,
+    childIds: o.map((y) => `link:${y.id}`),
+    rootLinkIds: o.map((y) => y.id),
+    source: e.robot
+  });
+  g.push(h);
+  for (const y of n.links) g.push(Ns(y, n, e.links.get(y.id), l, p, c));
+  for (const y of n.joints) g.push(Cs(y, e.joints.get(y.id), ((b = c.get(y.child)) == null ? void 0 : b.id) === y.id));
+  return Object.freeze({
+    robotName: n.name,
+    sourcePath: n.source.uri,
+    sourceText: t,
+    nodes: Object.freeze(g),
+    rootEntityId: a,
+    issues: Object.freeze(qs(n, e))
+  });
+}
+function Ns(n, t, e, i, s, c) {
+  var u, o, d, f;
+  const r = c.get(n.id);
+  return Object.freeze({
+    id: `link:${n.id}`,
+    kind: "link",
+    name: n.name,
+    parentId: r ? `joint:${r.id}` : `robot:${t.name}`,
+    childIds: Object.freeze(i.get(n.id) ?? []),
+    source: e,
+    mass: (u = n.inertial) == null ? void 0 : u.mass,
+    centerOfMass: (o = n.inertial) == null ? void 0 : o.origin.position,
+    inertiaTensor: (d = n.inertial) == null ? void 0 : d.tensor,
+    inertiaMass: (f = n.inertial) == null ? void 0 : f.mass,
+    visualCount: n.visuals.length,
+    collisionCount: n.collisions.length
+  });
+}
+function Cs(n, t, e) {
+  return Object.freeze({
+    id: `joint:${n.id}`,
+    kind: "joint",
+    name: n.id,
+    parentId: `link:${n.parent}`,
+    childIds: Object.freeze([`link:${n.child}`]),
+    source: t,
+    jointType: n.type,
+    parentLink: n.parent,
+    childLink: n.child,
+    axis: Object.freeze([...n.axis]),
+    originPosition: Object.freeze([...n.origin.position]),
+    originRotationRpy: Object.freeze([...n.origin.rotationRpy]),
+    limits: n.limits,
+    effort: n.effort,
+    velocity: n.velocity,
+    movable: ["revolute", "continuous", "prismatic"].includes(n.type)
+  });
+}
+function qs(n, t) {
+  const e = [], i = (a, l, g, h, b, y) => {
+    e.push(Object.freeze({ id: `${a}:${h}`, ruleId: a, severity: "error", title: l, message: g, entityId: h, source: b, values: y ? Object.freeze(y) : void 0 }));
+  }, s = new Set(n.links.map((a) => a.id));
+  for (const a of n.joints)
+    s.has(a.parent) || i("joint.parent.missing", "父连杆不存在", `${a.id} 引用了不存在的 parent link ${a.parent}。`, `joint:${a.id}`, t.joints.get(a.id), { parent: a.parent }), s.has(a.child) || i("joint.child.missing", "子连杆不存在", `${a.id} 引用了不存在的 child link ${a.child}。`, `joint:${a.id}`, t.joints.get(a.id), { child: a.child });
+  const c = n.links.filter((a) => !n.joints.some((l) => s.has(l.parent) && l.child === a.id));
+  c.length !== 1 && i("robot.root.count", "根连杆数量无效", `URDF 必须恰好有一个根连杆，当前为 ${c.length} 个。`, `robot:${n.name}`, t.robot, { roots: c.map((a) => a.id) });
+  const r = /* @__PURE__ */ new Map();
+  for (const a of n.joints) s.has(a.parent) && s.has(a.child) && r.set(a.parent, [...r.get(a.parent) ?? [], a.child]);
+  const u = /* @__PURE__ */ new Set(), o = /* @__PURE__ */ new Set();
+  let d = null;
+  const f = (a, l) => {
+    if (!d) {
+      if (o.has(a)) {
+        const g = l.indexOf(a);
+        d = [...l.slice(Math.max(0, g)), a];
+        return;
+      }
+      if (!u.has(a)) {
+        o.add(a);
+        for (const g of r.get(a) ?? []) f(g, [...l, a]);
+        o.delete(a), u.add(a);
+      }
+    }
+  };
+  for (const a of n.links) f(a.id, []);
+  d && i("robot.graph.cycle", "运动学结构存在环", `运动学链形成循环：${d.join(" → ")}。`, `robot:${n.name}`, t.robot, { cycle: d });
+  const p = /* @__PURE__ */ new Map();
+  for (const a of n.joints) {
+    if (p.set(a.child, [...p.get(a.child) ?? [], a.id]), a.parent === a.child && i("joint.self-reference", "关节父子连杆相同", `${a.id} 的 parent 和 child 都是 ${a.parent}。`, `joint:${a.id}`, t.joints.get(a.id)), ["revolute", "continuous", "prismatic"].includes(a.type)) {
+      const l = a.axis.reduce((g, h) => g + h * h, 0);
+      (!Number.isFinite(l) || l <= Number.EPSILON) && i("joint.axis.zero", "关节轴无效", `${a.id} 的 axis 是零向量。`, `joint:${a.id}`, t.joints.get(a.id), { axis: a.axis });
+    }
+    a.type !== "continuous" && a.limits && a.limits.lower > a.limits.upper && i("joint.limit.order", "关节限位上下界无效", `${a.id} 的 lower ${a.limits.lower} 大于 upper ${a.limits.upper}。`, `joint:${a.id}`, t.joints.get(a.id), { ...a.limits });
+  }
+  for (const [a, l] of p) l.length > 1 && i("link.multiple-parents", "连杆存在多个父关节", `${a} 同时被 ${l.join("、")} 作为 child。`, `link:${a}`, t.links.get(a), { joints: l });
+  for (const a of n.links) {
+    const l = a.inertial;
+    l && ((!(l.mass > 0) || !Number.isFinite(l.mass)) && i("inertial.mass.invalid", "质量无效", `${a.id} 的质量必须是大于零的有限数。`, `link:${a.id}`, t.links.get(a.id), { mass: l.mass }), Cn(l.tensor) || i("inertial.tensor.invalid", "惯性张量无效", `${a.id} 的惯性张量不是正定的物理惯性张量。`, `link:${a.id}`, t.links.get(a.id), { tensor: l.tensor }));
+  }
+  return e;
+}
+function Os(n, t) {
+  const e = { robot: void 0, links: /* @__PURE__ */ new Map(), joints: /* @__PURE__ */ new Map() };
+  e.robot = $n(n, "robot", void 0, t);
+  for (const i of ["link", "joint"]) {
+    const s = new RegExp(`<${i}\\b[^>]*\\bname\\s*=\\s*(["'])(.*?)\\1[^>]*>`, "gi");
+    for (const c of n.matchAll(s)) {
+      const r = c[2], u = $n(n, i, r, t, c.index);
+      u && e[i === "link" ? "links" : "joints"].set(r, u);
+    }
+  }
+  return e;
+}
+function $n(n, t, e, i, s) {
+  const c = s ?? n.search(new RegExp(`<${t}\\b`, "i"));
+  if (c < 0) return;
+  const r = n.indexOf(">", c);
+  if (r < 0) return;
+  const o = n.slice(c, r + 1).trimEnd().endsWith("/>") ? r + 1 : n.indexOf(`</${t}>`, r + 1), d = o < 0 ? r + 1 : o + t.length + 3, f = Fn(n, c), p = Fn(n, d);
+  return Object.freeze({ file: i, startOffset: c, endOffset: d, startLine: f.line, startColumn: f.column, endLine: p.line, endColumn: p.column });
+}
+function Fn(n, t) {
+  const i = n.slice(0, t).split(/\r?\n/);
+  return { line: i.length, column: i.at(-1).length + 1 };
+}
+class Vs {
+  constructor(t, e, i, s, c) {
+    I(this, "kind", "urdf");
+    I(this, "overlayRoot", new dt());
+    I(this, "listeners", /* @__PURE__ */ new Set());
+    I(this, "revision", 0);
+    I(this, "selectedEntityId");
+    I(this, "overlays", Object.freeze({ collision: !1, jointAxis: !1, centerOfMass: !1, inertia: !1 }));
+    I(this, "mode");
+    I(this, "dynamicsAvailable");
+    I(this, "dynamicsMessage");
+    I(this, "highlightedMaterials", /* @__PURE__ */ new Map());
+    I(this, "selectionMaterials", /* @__PURE__ */ new Map());
+    I(this, "guideBindings", []);
+    I(this, "guideMatrix", new W());
+    I(this, "overlayInverse", new W());
+    I(this, "disposed", !1);
+    var r, u;
+    this.asset = t, this.document = e, this.binding = i, this.options = s, this.selectedEntityId = ((r = e.nodes.find((o) => o.kind === "joint")) == null ? void 0 : r.id) ?? ((u = e.nodes.find((o) => o.kind === "link")) == null ? void 0 : u.id) ?? e.rootEntityId, this.mode = "kinematic", this.dynamicsAvailable = c, this.overlayRoot.name = "URDF review overlays", this.rebuildOverlay();
+  }
+  getSnapshot() {
+    return Object.freeze({
+      revision: this.revision,
+      kind: "urdf",
+      robotName: this.document.robotName,
+      sourcePath: this.document.sourcePath,
+      sourceText: this.document.sourceText,
+      nodes: this.document.nodes,
+      rootEntityId: this.document.rootEntityId,
+      selectedEntityId: this.selectedEntityId,
+      jointValues: this.binding.valuesSnapshot(),
+      overlays: this.overlays,
+      issues: this.document.issues,
+      mode: this.mode,
+      dynamicsAvailable: this.dynamicsAvailable,
+      ...this.dynamicsMessage ? { dynamicsMessage: this.dynamicsMessage } : {}
+    });
+  }
+  subscribe(t) {
+    return this.listeners.add(t), () => this.listeners.delete(t);
+  }
+  select(t) {
+    if (!(this.mode === "dynamics-running" || this.mode === "dynamics-initializing")) {
+      if (t !== null && !this.document.nodes.some((e) => e.id === t)) throw Ws(`Unknown URDF entity: ${t}`, "E_URDF_ENTITY_UNKNOWN");
+      this.selectedEntityId !== t && (this.selectedEntityId = t, this.rebuildOverlay(), this.publish());
+    }
+  }
+  setJointValue(t, e) {
+    this.mode === "dynamics-running" || this.mode === "dynamics-initializing" || (this.options.enterKinematicPreview(), this.binding.setJointValue(t, e), this.mode = "kinematic", this.rebuildGuides(), this.publish());
+  }
+  resetJoint(t) {
+    this.mode === "dynamics-running" || this.mode === "dynamics-initializing" || (this.options.enterKinematicPreview(), this.binding.resetJoint(t), this.mode = "kinematic", this.rebuildOverlay(), this.publish());
+  }
+  resetPose() {
+    this.options.enterKinematicPreview(), this.binding.resetPose(), this.mode = "kinematic", this.rebuildOverlay(), this.publish();
+  }
+  setOverlay(t, e) {
+    this.overlays[t] !== e && (this.overlays = Object.freeze({ ...this.overlays, [t]: e }), t === "collision" && this.options.setCollisionVisible(e), this.rebuildOverlay(), this.publish());
+  }
+  enterKinematicPreview() {
+    this.options.enterKinematicPreview(), this.mode = "kinematic", this.overlayRoot.visible = !0, this.publish();
+  }
+  setMode(t, e) {
+    t === "dynamics-unavailable" ? (this.mode = "kinematic", this.dynamicsAvailable = !1) : this.mode = t, this.overlayRoot.visible = this.mode !== "dynamics-initializing", (t === "dynamics-running" || t === "dynamics-initializing") && (this.selectedEntityId = null), this.dynamicsMessage = e, this.rebuildOverlay(), this.publish();
+  }
+  jointWorldFrame(t) {
+    return this.binding.jointWorldFrame(t);
+  }
+  pickRoots() {
+    var t, e;
+    return ((e = (t = this.options).pickRoots) == null ? void 0 : e.call(t)) ?? this.binding.pickRoots();
+  }
+  selectionObject() {
+    return this.selectedEntityId ? this.binding.objectForEntity(this.selectedEntityId) : null;
+  }
+  dispose() {
+    if (!this.disposed) {
+      this.disposed = !0, this.listeners.clear(), this.restoreSelectionMaterials();
+      for (const t of this.selectionMaterials.values()) t.dispose();
+      this.selectionMaterials.clear(), kt(this.overlayRoot), this.overlayRoot.removeFromParent();
+    }
+  }
+  publish() {
+    if (this.disposed) return;
+    this.revision += 1;
+    const t = this.getSnapshot();
+    for (const e of this.listeners) e(t);
+    this.options.requestRender();
+  }
+  rebuildOverlay() {
+    if (this.overlayRoot.visible = this.mode !== "dynamics-initializing", this.restoreSelectionMaterials(), this.clearGuides(), this.buildMassGuides(), this.buildJointGuides(), this.syncGuides(), !this.selectedEntityId) return;
+    const t = this.document.nodes.find((i) => i.id === this.selectedEntityId);
+    if (!t) return;
+    const e = this.binding.objectForEntity(t.id);
+    e && t.kind !== "robot" && this.applySelectionMaterials(e);
+  }
+  rebuildGuides() {
+    this.overlayRoot.visible = this.mode !== "dynamics-initializing", this.clearGuides(), this.buildMassGuides(), this.buildJointGuides(), this.syncGuides(), this.selectedEntityId && this.document.nodes.find((t) => t.id === this.selectedEntityId);
+  }
+  /** Update transforms only: physics ticks must not rebuild geometry or publish UI state. */
+  syncGuides() {
+    if (!(this.disposed || !this.overlayRoot.visible || !this.guideBindings.length)) {
+      this.overlayRoot.updateWorldMatrix(!0, !1), this.overlayInverse.copy(this.overlayRoot.matrixWorld).invert();
+      for (const { guide: t, source: e, local: i } of this.guideBindings)
+        e.updateWorldMatrix(!0, !1), this.guideMatrix.multiplyMatrices(this.overlayInverse, e.matrixWorld).multiply(i), this.guideMatrix.decompose(t.position, t.quaternion, t.scale), t.updateMatrixWorld(!0);
+    }
+  }
+  linkObject(t) {
+    var e, i;
+    return ((i = (e = this.options).linkObject) == null ? void 0 : i.call(e, t)) ?? this.binding.objectForEntity(`link:${t}`);
+  }
+  trackGuide(t, e) {
+    e.updateWorldMatrix(!0, !1), this.overlayRoot.updateWorldMatrix(!0, !1), t.updateWorldMatrix(!0, !1);
+    const i = e.matrixWorld.clone().invert().multiply(t.matrixWorld);
+    this.guideBindings.push({ guide: t, source: e, local: i });
+  }
+  clearGuides() {
+    this.guideBindings.length = 0, kt(this.overlayRoot), this.overlayRoot.clear();
+  }
+  buildJointGuides() {
+    const t = this.document.nodes.find((i) => i.id === this.selectedEntityId), e = (t == null ? void 0 : t.kind) === "joint" ? t : (t == null ? void 0 : t.kind) === "link" ? this.document.nodes.find((i) => i.kind === "joint" && i.childLink === t.name) : void 0;
+    for (const i of this.document.nodes) {
+      if (i.kind !== "joint" || !this.overlays.jointAxis && i.id !== (e == null ? void 0 : e.id)) continue;
+      const s = this.linkObject(i.parentLink), c = s ? (() => {
+        s.updateWorldMatrix(!0, !1);
+        const o = s.getWorldQuaternion(new J()).multiply(new J().setFromEuler(new Ft(...i.originRotationRpy, "XYZ")));
+        return { position: new z().fromArray(i.originPosition).applyMatrix4(s.matrixWorld), quaternion: o, axis: new z().fromArray(i.axis).applyQuaternion(o).normalize() };
+      })() : this.binding.jointWorldFrame(i.name);
+      if (!c) continue;
+      const r = new dt();
+      r.name = `Joint guide:${i.name}`;
+      const u = new mi(0.12);
+      if (u.name = `Joint frame:${i.name}`, u.position.copy(c.position), u.quaternion.copy(c.quaternion), r.add(u), ["revolute", "continuous", "prismatic"].includes(i.jointType)) {
+        const o = c.axis.clone().normalize(), d = new rn(o, c.position, 0.22, 5625523, 0.035, 0.018);
+        if (d.name = `Joint axis:${i.name}`, r.add(d), i.jointType !== "prismatic") {
+          const p = (Math.abs(o.z) < 0.9 ? new z(0, 0, 1) : new z(0, 1, 0)).cross(o).normalize(), a = o.clone().cross(p).normalize(), l = 0.075, g = Math.PI * 1.65, h = c.position.clone().addScaledVector(o, 0.07), b = Array.from({ length: 33 }, (w, A) => {
+            const S = g * A / 32;
+            return h.clone().addScaledVector(p, l * Math.cos(S)).addScaledVector(a, l * Math.sin(S));
+          }), y = new Qe(new gi().setFromPoints(b), new an({ color: 16761963 }));
+          y.name = `Positive rotation:${i.name}`;
+          const m = p.clone().multiplyScalar(-Math.sin(g)).addScaledVector(a, Math.cos(g)), x = new rn(m, b[32], 0.025, 16761963, 0.025, 0.018);
+          x.name = `Positive rotation arrow:${i.name}`, r.add(y, x);
+        }
+      }
+      r.traverse((o) => {
+        o.renderOrder = 1001;
+        const d = o.material;
+        for (const f of Array.isArray(d) ? d : d ? [d] : [])
+          f.depthTest = !1, f.depthWrite = !1, f.transparent = !0;
+      }), this.overlayRoot.add(r), s && this.trackGuide(r, s);
+    }
+  }
+  buildMassGuides() {
+    if (!this.overlays.centerOfMass && !this.overlays.inertia) return;
+    const t = this.document.nodes.find((i) => i.id === this.selectedEntityId), e = (t == null ? void 0 : t.kind) === "link" ? t.name : (t == null ? void 0 : t.kind) === "joint" ? t.childLink : void 0;
+    for (const i of this.asset.links) {
+      const s = i.inertial, c = this.linkObject(i.id);
+      if (!s || !c) continue;
+      c.updateWorldMatrix(!0, !1);
+      const r = new z().fromArray(s.origin.position).applyMatrix4(c.matrixWorld), u = i.id === e;
+      if (this.overlays.centerOfMass) {
+        const l = new H(new We(0.018, 16, 10), new cn({ color: u ? 16739210 : 15843173, depthTest: !1 }));
+        l.position.copy(r), l.renderOrder = 1002, l.name = `Center of mass:${i.id}`, this.overlayRoot.add(l), this.trackGuide(l, c);
+      }
+      const o = this.overlays.inertia ? Si(s.tensor, s.mass) : null;
+      if (!o) continue;
+      const d = new Ve(1, 1, 1), f = new Ge(new wi(d), new an({ color: u ? 16736135 : 2211300, transparent: !0, opacity: u ? 0.98 : 0.82, depthTest: !0, depthWrite: !1 })), p = new H(d, new cn({ color: u ? 16739210 : 3262699, transparent: !0, opacity: u ? 0.28 : 0.16, depthTest: !0, depthWrite: !1 }));
+      p.name = `Inertia fill:${i.id}`;
+      const a = s.origin.rotationQuaternion ? new J().fromArray(s.origin.rotationQuaternion) : new J().setFromEuler(new Ft(...s.origin.rotationRpy, "XYZ"));
+      f.position.copy(r), f.scale.fromArray(o.size), f.quaternion.copy(c.getWorldQuaternion(new J())).multiply(a).multiply(o.rotation), f.renderOrder = 1001, f.name = `Inertia:${i.id}`, p.position.copy(f.position), p.quaternion.copy(f.quaternion), p.scale.copy(f.scale), p.renderOrder = 1e3, this.overlayRoot.add(p, f), this.trackGuide(p, c), this.trackGuide(f, c);
+    }
+  }
+  applySelectionMaterials(t) {
+    const e = (i, s) => {
+      if (!(!s && typeof i.userData.urdfEntityId == "string")) {
+        i instanceof H && i.material && (this.highlightedMaterials.set(i, i.material), i.material = Array.isArray(i.material) ? i.material.map((c) => this.createSelectionMaterial(c)) : this.createSelectionMaterial(i.material));
+        for (const c of i.children) e(c, !1);
+      }
+    };
+    e(t, !0);
+  }
+  createSelectionMaterial(t) {
+    var c;
+    const e = this.selectionMaterials.get(t);
+    if (e) return e;
+    const i = t.clone(), s = i;
+    return (c = s.color) == null || c.set(9425919), s.emissive ? (s.emissive.set(2793430), s.emissiveIntensity = Math.max(s.emissiveIntensity ?? 0, 0.34)) : i instanceof Oe && (i.emissive.set(2793430), i.emissiveIntensity = 0.34), i.transparent = t.transparent, i.opacity = t.opacity, i.depthWrite = t.depthWrite, i.needsUpdate = !0, this.selectionMaterials.set(t, i), i;
+  }
+  restoreSelectionMaterials() {
+    for (const [t, e] of this.highlightedMaterials) t.material = e;
+    this.highlightedMaterials.clear();
+  }
+}
+function Ws(n, t) {
+  return Object.assign(new Error(n), { code: t });
+}
+async function to(n, t, e) {
+  var M, R, v;
+  const i = n.entryPath ?? n.filename ?? "asset.urdf";
+  (M = t.reportProgress) == null || M.call(t, "fetch", "正在读取模型描述与依赖资源...");
+  const s = await ai(n, e);
+  if (t.signal.aborted) throw Vt();
+  (R = t.reportProgress) == null || R.call(t, "parse", "正在解析 URDF 结构与连杆...");
+  const c = Mi(s, i, e);
+  (v = t.reportProgress) == null || v.call(t, "visual", "正在构建运动学预览...");
+  const r = await un(c), u = new js(c, r), o = await Ri(c, r), d = c.diagnostics.errors.find((B) => B.code === "E_URDF_INERTIA"), f = c.links.some((B) => B.inertial), p = f && !d, a = new Pi(u.root, t.options.simulationTheme, void 0);
+  o && (o.root.visible = !1, a.attachAuxiliary(o.root));
+  let l = null, g = null, h = null, b = d ? { code: d.code, message: d.message, stage: "physics-validation" } : null, y = d ? { status: "unavailable", issue: b } : f ? { status: "available" } : { status: "not-authored" }, m = !1, x = null, w = !1, A = !1;
+  const S = () => {
+    var E;
+    const B = m || !u.root.visible;
+    m = !1, a.setRuntime(void 0), g && (g.root.visible = !1), a.replaceModel(u.root, !1), u.root.visible = !0, o && o.sync(), o != null && o.root && (o.root.visible = P.getSnapshot().overlays.collision), h && (h.root.visible = !1), B && ((E = t.reportSessionState) == null || E.call(t)), t.requestRender();
+  }, P = new Vs(c, Ds(c, s), u, {
+    requestRender() {
+      u.root.visible && (o == null || o.sync()), t.requestRender();
+    },
+    setCollisionVisible(B) {
+      o && (o.root.visible = B && u.root.visible), h && (h.root.visible = B && (g == null ? void 0 : g.root.visible) === !0);
+    },
+    enterKinematicPreview: S,
+    linkObject: (B) => g != null && g.root.visible ? g.objectForLink(B) : u.objectForEntity(`link:${B}`),
+    pickRoots: () => m || y.status === "initializing" ? [] : u.pickRoots()
+  }, p);
+  d && P.setMode("dynamics-unavailable", d.message), a.attachAuxiliary(P.overlayRoot);
+  const T = () => !l || !g ? !1 : (l.setJointValues(P.getSnapshot().jointValues), g == null || g.sync(), a.replaceModel(g.root, !1), a.setRuntime(l), u.root.visible = !1, g.root.visible = !0, o && (o.root.visible = !1), h && (h.root.visible = P.getSnapshot().overlays.collision), !0), _ = async () => {
+    var k, yt, It;
+    if (l || w || !p) return;
+    P.setMode("dynamics-initializing"), y = { status: "initializing" }, (k = t.reportSessionState) == null || k.call(t);
+    let B = null, E = null, $ = null;
+    try {
+      const nt = await _i(c);
+      if (t.signal.aborted || w) throw Vt();
+      const ct = await import("./mujoco-runtime-C29PXDOl.js");
+      if (B = new ct.MujocoRuntime(), await B.initialize(nt, t.options.mujocoBaseUrl), t.signal.aborted || w || (E = new nn(B, await un(c)), t.signal.aborted || w)) throw Vt();
+      const xt = await On(c);
+      if ($ = xt ? new nn(B, xt) : null, t.signal.aborted || w) throw Vt();
+      l = B, B = null, g = E, E = null, g.root.visible = !1, h = $, $ = null, h && (h.root.visible = !1, a.attachAuxiliary(h.root)), y = { status: "ready" }, b = null, A && (T(), m = !0, P.setMode("dynamics-running")), (yt = t.reportSessionState) == null || yt.call(t), t.requestRender();
+    } catch (nt) {
+      if ($ == null || $.dispose(), E == null || E.dispose(), B == null || B.dispose(), w || t.signal.aborted || nt instanceof Error && nt.name === "AbortError") return;
+      const ct = ci(nt, t.signal, "urdf-physics");
+      a.setRuntime(void 0), l == null || l.dispose(), l = null, g == null || g.dispose(), g = null, h && (a.detachAuxiliary(h.root), h.dispose(), h = null), S(), b = { ...ct, stage: "physics-fallback" }, y = { status: "unavailable", issue: b }, P.setMode("dynamics-unavailable", b.message), (It = t.reportSessionState) == null || It.call(t), t.reportError(nt, { fatal: !1, stage: "physics-start", code: ct.code });
+    }
+  };
+  return {
+    asset: c,
+    stage: a,
+    inspection: P,
+    autoPlay: !1,
+    root: a.root,
+    get capabilities() {
+      const B = y.status === "initializing", E = y.status === "unavailable" || y.status === "not-authored";
+      return { canPlay: !B && !E, canPause: l !== null, canReset: !0, hasPhysics: l !== null, canToggleGround: !0, canToggleCollision: o !== void 0 || h !== null };
+    },
+    get physics() {
+      return y;
+    },
+    get warning() {
+      return b;
+    },
+    isPlaying: () => m,
+    play() {
+      var B;
+      if (!(w || y.status === "unavailable" || y.status === "not-authored")) {
+        if (A = !0, P.select(null), !l) {
+          x ?? (x = _().finally(() => {
+            x = null;
+          }));
+          return;
+        }
+        T() && (m = !0, P.setMode("dynamics-running"), (B = t.reportSessionState) == null || B.call(t));
+      }
+    },
+    pause() {
+      var B;
+      A = !1, m = !1, a.endGrab(), l && (u.syncPhysicsPose(l.getJointValues(c.joints.map((E) => E.id)), g.bodyPoses()), S(), P.setMode("dynamics-paused")), (B = t.reportSessionState) == null || B.call(t), t.requestRender();
+    },
+    reset() {
+      var B;
+      A = !1, a.endGrab(), l && (l.reset(), g == null || g.sync(), h == null || h.sync()), P.resetPose(), a.resetGround(), (B = t.reportSessionState) == null || B.call(t), t.requestRender();
+    },
+    step(B) {
+      if (!l || !m) return !1;
+      const E = l.step(B);
+      return E && (g == null || g.sync(), h == null || h.sync(), P.syncGuides(), a.updateForceLine()), E;
+    },
+    beginGrab(B, E, $) {
+      return !!(l && a.beginGrab(B, E, $));
+    },
+    moveGrab(B, E, $) {
+      l && a.moveGrab(B, E, $);
+    },
+    endGrab() {
+      a.endGrab();
+    },
+    setCollisionVisible(B) {
+      o && (o.root.visible = B && u.root.visible), h && (h.root.visible = B && (g == null ? void 0 : g.root.visible) === !0);
+    },
+    dispose() {
+      w || (w = !0, m = !1, P.dispose(), o && (a.detachAuxiliary(o.root), o.dispose()), h && (a.detachAuxiliary(h.root), h.dispose()), a.setRuntime(void 0), g == null || g.dispose(), u.dispose(), l == null || l.dispose(), a.dispose());
+    }
+  };
+}
+function Vt() {
+  return Object.assign(new Error("Simulation load aborted."), { name: "AbortError", code: "E_ABORTED" });
+}
+export {
+  to as loadUrdfSimulation
+};