@nebula-spatial/viewer 0.4.4 → 0.4.5

package/dist/urdf-session-CuIZOiCF.js

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