ss-component-new 1.3.699 → 1.3.701

package/dist/URDFLoader-BqfNCQLH.js

@@ -0,0 +1,2299 @@
+import { S as Ln } from "./MTLLoader-DC5Di-ql.js";
+import { bg as vn, aI as Rn, R as lt, aw as At, U as In, V as pe, n as he, aS as dt, S as Mn, aF as Tt, C as ut, o as Le, aZ as ft, bh as Sn, k as ve, b6 as Se, c as me, ay as On, l as Gn, a4 as qn, P as ht, aX as Pn, i as jn, aA as Un, j as Fn, D as Hn, s as pt, aC as Et, b3 as mt, b5 as Bn, u as Dn, Y as ye, a_ as zn, a2 as bt, aU as Vn, h as Ce, w as Jn, aV as Kn, aY as Wn, aO as Oe, aQ as gt, bi as Yn, bj as Xn, bk as yt, bl as $n, bm as Zn, bn as Qn, bo as ei, a0 as ti, bp as ni, bq as ii, E as si } from "./index.vue_vue_type_style_index_0_scoped_05e3a1d8_lang-D9DRZPyb.js";
+class wt extends vn {
+  /**
+   * Constructs a new TGA loader.
+   *
+   * @param {LoadingManager} [manager] - The loading manager.
+   */
+  constructor(O) {
+    super(O);
+  }
+  /**
+   * Parses the given TGA texture data.
+   *
+   * @param {ArrayBuffer} buffer - The raw texture data.
+   * @return {DataTextureLoader~TexData} An object representing the parsed texture data.
+   */
+  parse(O) {
+    function Q(u) {
+      switch (u.image_type) {
+        // check indexed type
+        case Ne:
+        case ee:
+          if (u.colormap_length > 256 || u.colormap_size !== 24 || u.colormap_type !== 1)
+            throw new Error("THREE.TGALoader: Invalid type colormap data for indexed type.");
+          break;
+        // check colormap type
+        case $:
+        case ie:
+        case be:
+        case ge:
+          if (u.colormap_type)
+            throw new Error("THREE.TGALoader: Invalid type colormap data for colormap type.");
+          break;
+        // What the need of a file without data ?
+        case ke:
+          throw new Error("THREE.TGALoader: No data.");
+        // Invalid type ?
+        default:
+          throw new Error("THREE.TGALoader: Invalid type " + u.image_type);
+      }
+      if (u.width <= 0 || u.height <= 0)
+        throw new Error("THREE.TGALoader: Invalid image size.");
+      if (u.pixel_size !== 8 && u.pixel_size !== 16 && u.pixel_size !== 24 && u.pixel_size !== 32)
+        throw new Error("THREE.TGALoader: Invalid pixel size " + u.pixel_size);
+    }
+    function R(u, W, z, B, X) {
+      let U, D;
+      const _ = z.pixel_size >> 3, x = z.width * z.height * _;
+      if (W && (D = X.subarray(B, B += z.colormap_length * (z.colormap_size >> 3))), u) {
+        U = new Uint8Array(x);
+        let N, f, A, V = 0;
+        const le = new Uint8Array(_);
+        for (; V < x; )
+          if (N = X[B++], f = (N & 127) + 1, N & 128) {
+            for (A = 0; A < _; ++A)
+              le[A] = X[B++];
+            for (A = 0; A < f; ++A)
+              U.set(le, V + A * _);
+            V += _ * f;
+          } else {
+            for (f *= _, A = 0; A < f; ++A)
+              U[V + A] = X[B++];
+            V += f;
+          }
+      } else
+        U = X.subarray(
+          B,
+          B += W ? z.width * z.height : x
+        );
+      return {
+        pixel_data: U,
+        palettes: D
+      };
+    }
+    function se(u, W, z, B, X, U, D, _, x) {
+      const N = x;
+      let f, A = 0, V, le;
+      const Ae = C.width;
+      for (le = W; le !== B; le += z)
+        for (V = X; V !== D; V += U, A++)
+          f = _[A], u[(V + Ae * le) * 4 + 3] = 255, u[(V + Ae * le) * 4 + 2] = N[f * 3 + 0], u[(V + Ae * le) * 4 + 1] = N[f * 3 + 1], u[(V + Ae * le) * 4 + 0] = N[f * 3 + 2];
+      return u;
+    }
+    function v(u, W, z, B, X, U, D, _) {
+      let x, N = 0, f, A;
+      const V = C.width;
+      for (A = W; A !== B; A += z)
+        for (f = X; f !== D; f += U, N += 2)
+          x = _[N + 0] + (_[N + 1] << 8), u[(f + V * A) * 4 + 0] = (x & 31744) >> 7, u[(f + V * A) * 4 + 1] = (x & 992) >> 2, u[(f + V * A) * 4 + 2] = (x & 31) << 3, u[(f + V * A) * 4 + 3] = x & 32768 ? 0 : 255;
+      return u;
+    }
+    function oe(u, W, z, B, X, U, D, _) {
+      let x = 0, N, f;
+      const A = C.width;
+      for (f = W; f !== B; f += z)
+        for (N = X; N !== D; N += U, x += 3)
+          u[(N + A * f) * 4 + 3] = 255, u[(N + A * f) * 4 + 2] = _[x + 0], u[(N + A * f) * 4 + 1] = _[x + 1], u[(N + A * f) * 4 + 0] = _[x + 2];
+      return u;
+    }
+    function I(u, W, z, B, X, U, D, _) {
+      let x = 0, N, f;
+      const A = C.width;
+      for (f = W; f !== B; f += z)
+        for (N = X; N !== D; N += U, x += 4)
+          u[(N + A * f) * 4 + 2] = _[x + 0], u[(N + A * f) * 4 + 1] = _[x + 1], u[(N + A * f) * 4 + 0] = _[x + 2], u[(N + A * f) * 4 + 3] = _[x + 3];
+      return u;
+    }
+    function Y(u, W, z, B, X, U, D, _) {
+      let x, N = 0, f, A;
+      const V = C.width;
+      for (A = W; A !== B; A += z)
+        for (f = X; f !== D; f += U, N++)
+          x = _[N], u[(f + V * A) * 4 + 0] = x, u[(f + V * A) * 4 + 1] = x, u[(f + V * A) * 4 + 2] = x, u[(f + V * A) * 4 + 3] = 255;
+      return u;
+    }
+    function ne(u, W, z, B, X, U, D, _) {
+      let x = 0, N, f;
+      const A = C.width;
+      for (f = W; f !== B; f += z)
+        for (N = X; N !== D; N += U, x += 2)
+          u[(N + A * f) * 4 + 0] = _[x + 0], u[(N + A * f) * 4 + 1] = _[x + 0], u[(N + A * f) * 4 + 2] = _[x + 0], u[(N + A * f) * 4 + 3] = _[x + 1];
+      return u;
+    }
+    function we(u, W, z, B, X) {
+      let U, D, _, x, N, f;
+      switch ((C.flags & M) >> P) {
+        default:
+        case J:
+          U = 0, _ = 1, N = W, D = 0, x = 1, f = z;
+          break;
+        case F:
+          U = 0, _ = 1, N = W, D = z - 1, x = -1, f = -1;
+          break;
+        case S:
+          U = W - 1, _ = -1, N = -1, D = 0, x = 1, f = z;
+          break;
+        case E:
+          U = W - 1, _ = -1, N = -1, D = z - 1, x = -1, f = -1;
+          break;
+      }
+      if (j)
+        switch (C.pixel_size) {
+          case 8:
+            Y(u, D, x, f, U, _, N, B);
+            break;
+          case 16:
+            ne(u, D, x, f, U, _, N, B);
+            break;
+          default:
+            throw new Error("THREE.TGALoader: Format not supported.");
+        }
+      else
+        switch (C.pixel_size) {
+          case 8:
+            se(u, D, x, f, U, _, N, B, X);
+            break;
+          case 16:
+            v(u, D, x, f, U, _, N, B);
+            break;
+          case 24:
+            oe(u, D, x, f, U, _, N, B);
+            break;
+          case 32:
+            I(u, D, x, f, U, _, N, B);
+            break;
+          default:
+            throw new Error("THREE.TGALoader: Format not supported.");
+        }
+      return u;
+    }
+    const ke = 0, Ne = 1, $ = 2, ie = 3, ee = 9, be = 10, ge = 11, M = 48, P = 4, F = 0, E = 1, J = 2, S = 3;
+    if (O.length < 19) throw new Error("THREE.TGALoader: Not enough data to contain header.");
+    let m = 0;
+    const h = new Uint8Array(O), C = {
+      id_length: h[m++],
+      colormap_type: h[m++],
+      image_type: h[m++],
+      colormap_index: h[m++] | h[m++] << 8,
+      colormap_length: h[m++] | h[m++] << 8,
+      colormap_size: h[m++],
+      origin: [
+        h[m++] | h[m++] << 8,
+        h[m++] | h[m++] << 8
+      ],
+      width: h[m++] | h[m++] << 8,
+      height: h[m++] | h[m++] << 8,
+      pixel_size: h[m++],
+      flags: h[m++]
+    };
+    if (Q(C), C.id_length + m > O.length)
+      throw new Error("THREE.TGALoader: No data.");
+    m += C.id_length;
+    let L = !1, k = !1, j = !1;
+    switch (C.image_type) {
+      case ee:
+        L = !0, k = !0;
+        break;
+      case Ne:
+        k = !0;
+        break;
+      case be:
+        L = !0;
+        break;
+      case $:
+        break;
+      case ge:
+        L = !0, j = !0;
+        break;
+      case ie:
+        j = !0;
+        break;
+    }
+    const ae = new Uint8Array(C.width * C.height * 4), te = R(L, k, C, m, h);
+    return we(ae, C.width, C.height, te.pixel_data, te.palettes), {
+      data: ae,
+      width: C.width,
+      height: C.height,
+      flipY: !0,
+      generateMipmaps: !0,
+      minFilter: Rn
+    };
+  }
+}
+class oi extends lt {
+  /**
+   * Starts loading from the given URL and passes the loaded Collada asset
+   * to the `onLoad()` callback.
+   *
+   * @param {string} url - The path/URL of the file to be loaded. This can also be a data URI.
+   * @param {function({scene:Group,animations:Array<AnimationClip>,kinematics:Object})} onLoad - Executed when the loading process has been finished.
+   * @param {onProgressCallback} onProgress - Executed while the loading is in progress.
+   * @param {onErrorCallback} onError - Executed when errors occur.
+   */
+  load(O, Q, R, se) {
+    const v = this, oe = v.path === "" ? At.extractUrlBase(O) : v.path, I = new In(v.manager);
+    I.setPath(v.path), I.setRequestHeader(v.requestHeader), I.setWithCredentials(v.withCredentials), I.load(O, function(Y) {
+      try {
+        Q(v.parse(Y, oe));
+      } catch (ne) {
+        se ? se(ne) : console.error(ne), v.manager.itemError(O);
+      }
+    }, R, se);
+  }
+  /**
+   * Parses the given Collada data and returns a result oject holding the parsed scene,
+   * an array of animation clips and kinematics.
+   *
+   * @param {string} text - The raw Collada data as a string.
+   * @param {string} path - The asset path.
+   * @return {{scene:Group,animations:Array<AnimationClip>,kinematics:Object}} An object representing the parsed asset.
+   */
+  parse(O, Q) {
+    function R(t, e) {
+      const i = [], n = t.childNodes;
+      for (let s = 0, o = n.length; s < o; s++) {
+        const r = n[s];
+        r.nodeName === e && i.push(r);
+      }
+      return i;
+    }
+    function se(t) {
+      if (t.length === 0) return [];
+      const e = t.trim().split(/\s+/), i = new Array(e.length);
+      for (let n = 0, s = e.length; n < s; n++)
+        i[n] = e[n];
+      return i;
+    }
+    function v(t) {
+      if (t.length === 0) return [];
+      const e = t.trim().split(/\s+/), i = new Array(e.length);
+      for (let n = 0, s = e.length; n < s; n++)
+        i[n] = parseFloat(e[n]);
+      return i;
+    }
+    function oe(t) {
+      if (t.length === 0) return [];
+      const e = t.trim().split(/\s+/), i = new Array(e.length);
+      for (let n = 0, s = e.length; n < s; n++)
+        i[n] = parseInt(e[n]);
+      return i;
+    }
+    function I(t) {
+      return t.substring(1);
+    }
+    function Y() {
+      return "three_default_" + _n++;
+    }
+    function ne(t) {
+      return Object.keys(t).length === 0;
+    }
+    function we(t) {
+      return {
+        unit: ke(R(t, "unit")[0]),
+        upAxis: Ne(R(t, "up_axis")[0])
+      };
+    }
+    function ke(t) {
+      return t !== void 0 && t.hasAttribute("meter") === !0 ? parseFloat(t.getAttribute("meter")) : 1;
+    }
+    function Ne(t) {
+      return t !== void 0 ? t.textContent : "Y_UP";
+    }
+    function $(t, e, i, n) {
+      const s = R(t, e)[0];
+      if (s !== void 0) {
+        const o = R(s, i);
+        for (let r = 0; r < o.length; r++)
+          n(o[r]);
+      }
+    }
+    function ie(t, e) {
+      for (const i in t) {
+        const n = t[i];
+        n.build = e(t[i]);
+      }
+    }
+    function ee(t, e) {
+      return t.build !== void 0 || (t.build = e(t)), t.build;
+    }
+    function be(t) {
+      const e = {
+        sources: {},
+        samplers: {},
+        channels: {}
+      };
+      let i = !1;
+      for (let n = 0, s = t.childNodes.length; n < s; n++) {
+        const o = t.childNodes[n];
+        if (o.nodeType !== 1) continue;
+        let r;
+        switch (o.nodeName) {
+          case "source":
+            r = o.getAttribute("id"), e.sources[r] = Ge(o);
+            break;
+          case "sampler":
+            r = o.getAttribute("id"), e.samplers[r] = ge(o);
+            break;
+          case "channel":
+            r = o.getAttribute("target"), e.channels[r] = M(o);
+            break;
+          case "animation":
+            be(o), i = !0;
+            break;
+          default:
+            console.log(o);
+        }
+      }
+      i === !1 && (T.animations[t.getAttribute("id") || Le.generateUUID()] = e);
+    }
+    function ge(t) {
+      const e = {
+        inputs: {}
+      };
+      for (let i = 0, n = t.childNodes.length; i < n; i++) {
+        const s = t.childNodes[i];
+        if (s.nodeType === 1)
+          switch (s.nodeName) {
+            case "input":
+              const o = I(s.getAttribute("source")), r = s.getAttribute("semantic");
+              e.inputs[r] = o;
+              break;
+          }
+      }
+      return e;
+    }
+    function M(t) {
+      const e = {};
+      let n = t.getAttribute("target").split("/");
+      const s = n.shift();
+      let o = n.shift();
+      const r = o.indexOf("(") !== -1, d = o.indexOf(".") !== -1;
+      if (d)
+        n = o.split("."), o = n.shift(), e.member = n.shift();
+      else if (r) {
+        const c = o.split("(");
+        o = c.shift();
+        for (let l = 0; l < c.length; l++)
+          c[l] = parseInt(c[l].replace(/\)/, ""));
+        e.indices = c;
+      }
+      return e.id = s, e.sid = o, e.arraySyntax = r, e.memberSyntax = d, e.sampler = I(t.getAttribute("source")), e;
+    }
+    function P(t) {
+      const e = [], i = t.channels, n = t.samplers, s = t.sources;
+      for (const o in i)
+        if (i.hasOwnProperty(o)) {
+          const r = i[o], d = n[r.sampler], c = d.inputs.INPUT, l = d.inputs.OUTPUT, g = s[c], a = s[l], b = E(r, g, a);
+          C(b, e);
+        }
+      return e;
+    }
+    function F(t) {
+      return ee(T.animations[t], P);
+    }
+    function E(t, e, i) {
+      const n = T.nodes[t.id], s = Ee(n.id), o = n.transforms[t.sid], r = n.matrix.clone().transpose();
+      let d, c, l, g, a, b;
+      const p = {};
+      switch (o) {
+        case "matrix":
+          for (l = 0, g = e.array.length; l < g; l++)
+            if (d = e.array[l], c = l * i.stride, p[d] === void 0 && (p[d] = {}), t.arraySyntax === !0) {
+              const K = i.array[c], H = t.indices[0] + 4 * t.indices[1];
+              p[d][H] = K;
+            } else
+              for (a = 0, b = i.stride; a < b; a++)
+                p[d][a] = i.array[c + a];
+          break;
+        case "translate":
+          console.warn('THREE.ColladaLoader: Animation transform type "%s" not yet implemented.', o);
+          break;
+        case "rotate":
+          console.warn('THREE.ColladaLoader: Animation transform type "%s" not yet implemented.', o);
+          break;
+        case "scale":
+          console.warn('THREE.ColladaLoader: Animation transform type "%s" not yet implemented.', o);
+          break;
+      }
+      const w = J(p, r);
+      return {
+        name: s.uuid,
+        keyframes: w
+      };
+    }
+    function J(t, e) {
+      const i = [];
+      for (const s in t)
+        i.push({ time: parseFloat(s), value: t[s] });
+      i.sort(n);
+      for (let s = 0; s < 16; s++)
+        L(i, s, e.elements[s]);
+      return i;
+      function n(s, o) {
+        return s.time - o.time;
+      }
+    }
+    const S = new pe(), m = new pe(), h = new Et();
+    function C(t, e) {
+      const i = t.keyframes, n = t.name, s = [], o = [], r = [], d = [];
+      for (let c = 0, l = i.length; c < l; c++) {
+        const g = i[c], a = g.time, b = g.value;
+        ce.fromArray(b).transpose(), ce.decompose(S, h, m), s.push(a), o.push(S.x, S.y, S.z), r.push(h.x, h.y, h.z, h.w), d.push(m.x, m.y, m.z);
+      }
+      return o.length > 0 && e.push(new mt(n + ".position", s, o)), r.length > 0 && e.push(new Bn(n + ".quaternion", s, r)), d.length > 0 && e.push(new mt(n + ".scale", s, d)), e;
+    }
+    function L(t, e, i) {
+      let n, s = !0, o, r;
+      for (o = 0, r = t.length; o < r; o++)
+        n = t[o], n.value[e] === void 0 ? n.value[e] = null : s = !1;
+      if (s === !0)
+        for (o = 0, r = t.length; o < r; o++)
+          n = t[o], n.value[e] = i;
+      else
+        k(t, e);
+    }
+    function k(t, e) {
+      let i, n;
+      for (let s = 0, o = t.length; s < o; s++) {
+        const r = t[s];
+        if (r.value[e] === null) {
+          if (i = j(t, s, e), n = ae(t, s, e), i === null) {
+            r.value[e] = n.value[e];
+            continue;
+          }
+          if (n === null) {
+            r.value[e] = i.value[e];
+            continue;
+          }
+          te(r, i, n, e);
+        }
+      }
+    }
+    function j(t, e, i) {
+      for (; e >= 0; ) {
+        const n = t[e];
+        if (n.value[i] !== null) return n;
+        e--;
+      }
+      return null;
+    }
+    function ae(t, e, i) {
+      for (; e < t.length; ) {
+        const n = t[e];
+        if (n.value[i] !== null) return n;
+        e++;
+      }
+      return null;
+    }
+    function te(t, e, i, n) {
+      if (i.time - e.time === 0) {
+        t.value[n] = e.value[n];
+        return;
+      }
+      t.value[n] = (t.time - e.time) * (i.value[n] - e.value[n]) / (i.time - e.time) + e.value[n];
+    }
+    function u(t) {
+      const e = {
+        name: t.getAttribute("id") || "default",
+        start: parseFloat(t.getAttribute("start") || 0),
+        end: parseFloat(t.getAttribute("end") || 0),
+        animations: []
+      };
+      for (let i = 0, n = t.childNodes.length; i < n; i++) {
+        const s = t.childNodes[i];
+        if (s.nodeType === 1)
+          switch (s.nodeName) {
+            case "instance_animation":
+              e.animations.push(I(s.getAttribute("url")));
+              break;
+          }
+      }
+      T.clips[t.getAttribute("id")] = e;
+    }
+    function W(t) {
+      const e = [], i = t.name, n = t.end - t.start || -1, s = t.animations;
+      for (let o = 0, r = s.length; o < r; o++) {
+        const d = F(s[o]);
+        for (let c = 0, l = d.length; c < l; c++)
+          e.push(d[c]);
+      }
+      return new ft(i, n, e);
+    }
+    function z(t) {
+      return ee(T.clips[t], W);
+    }
+    function B(t) {
+      const e = {};
+      for (let i = 0, n = t.childNodes.length; i < n; i++) {
+        const s = t.childNodes[i];
+        if (s.nodeType === 1)
+          switch (s.nodeName) {
+            case "skin":
+              e.id = I(s.getAttribute("source")), e.skin = X(s);
+              break;
+            case "morph":
+              e.id = I(s.getAttribute("source")), console.warn("THREE.ColladaLoader: Morph target animation not supported yet.");
+              break;
+          }
+      }
+      T.controllers[t.getAttribute("id")] = e;
+    }
+    function X(t) {
+      const e = {
+        sources: {}
+      };
+      for (let i = 0, n = t.childNodes.length; i < n; i++) {
+        const s = t.childNodes[i];
+        if (s.nodeType === 1)
+          switch (s.nodeName) {
+            case "bind_shape_matrix":
+              e.bindShapeMatrix = v(s.textContent);
+              break;
+            case "source":
+              const o = s.getAttribute("id");
+              e.sources[o] = Ge(s);
+              break;
+            case "joints":
+              e.joints = U(s);
+              break;
+            case "vertex_weights":
+              e.vertexWeights = D(s);
+              break;
+          }
+      }
+      return e;
+    }
+    function U(t) {
+      const e = {
+        inputs: {}
+      };
+      for (let i = 0, n = t.childNodes.length; i < n; i++) {
+        const s = t.childNodes[i];
+        if (s.nodeType === 1)
+          switch (s.nodeName) {
+            case "input":
+              const o = s.getAttribute("semantic"), r = I(s.getAttribute("source"));
+              e.inputs[o] = r;
+              break;
+          }
+      }
+      return e;
+    }
+    function D(t) {
+      const e = {
+        inputs: {}
+      };
+      for (let i = 0, n = t.childNodes.length; i < n; i++) {
+        const s = t.childNodes[i];
+        if (s.nodeType === 1)
+          switch (s.nodeName) {
+            case "input":
+              const o = s.getAttribute("semantic"), r = I(s.getAttribute("source")), d = parseInt(s.getAttribute("offset"));
+              e.inputs[o] = { id: r, offset: d };
+              break;
+            case "vcount":
+              e.vcount = oe(s.textContent);
+              break;
+            case "v":
+              e.v = oe(s.textContent);
+              break;
+          }
+      }
+      return e;
+    }
+    function _(t) {
+      const e = {
+        id: t.id
+      }, i = T.geometries[e.id];
+      return t.skin !== void 0 && (e.skin = x(t.skin), i.sources.skinIndices = e.skin.indices, i.sources.skinWeights = e.skin.weights), e;
+    }
+    function x(t) {
+      const i = {
+        joints: [],
+        // this must be an array to preserve the joint order
+        indices: {
+          array: [],
+          stride: 4
+        },
+        weights: {
+          array: [],
+          stride: 4
+        }
+      }, n = t.sources, s = t.vertexWeights, o = s.vcount, r = s.v, d = s.inputs.JOINT.offset, c = s.inputs.WEIGHT.offset, l = t.sources[t.joints.inputs.JOINT], g = t.sources[t.joints.inputs.INV_BIND_MATRIX], a = n[s.inputs.WEIGHT.id].array;
+      let b = 0, p, w, y;
+      for (p = 0, y = o.length; p < y; p++) {
+        const H = o[p], G = [];
+        for (w = 0; w < H; w++) {
+          const q = r[b + d], fe = r[b + c], re = a[fe];
+          G.push({ index: q, weight: re }), b += 2;
+        }
+        for (G.sort(K), w = 0; w < 4; w++) {
+          const q = G[w];
+          q !== void 0 ? (i.indices.array.push(q.index), i.weights.array.push(q.weight)) : (i.indices.array.push(0), i.weights.array.push(0));
+        }
+      }
+      for (t.bindShapeMatrix ? i.bindMatrix = new he().fromArray(t.bindShapeMatrix).transpose() : i.bindMatrix = new he().identity(), p = 0, y = l.array.length; p < y; p++) {
+        const H = l.array[p], G = new he().fromArray(g.array, p * g.stride).transpose();
+        i.joints.push({ name: H, boneInverse: G });
+      }
+      return i;
+      function K(H, G) {
+        return G.weight - H.weight;
+      }
+    }
+    function N(t) {
+      return ee(T.controllers[t], _);
+    }
+    function f(t) {
+      const e = {
+        init_from: R(t, "init_from")[0].textContent
+      };
+      T.images[t.getAttribute("id")] = e;
+    }
+    function A(t) {
+      return t.build !== void 0 ? t.build : t.init_from;
+    }
+    function V(t) {
+      const e = T.images[t];
+      return e !== void 0 ? ee(e, A) : (console.warn("THREE.ColladaLoader: Couldn't find image with ID:", t), null);
+    }
+    function le(t) {
+      const e = {};
+      for (let i = 0, n = t.childNodes.length; i < n; i++) {
+        const s = t.childNodes[i];
+        if (s.nodeType === 1)
+          switch (s.nodeName) {
+            case "profile_COMMON":
+              e.profile = Ae(s);
+              break;
+          }
+      }
+      T.effects[t.getAttribute("id")] = e;
+    }
+    function Ae(t) {
+      const e = {
+        surfaces: {},
+        samplers: {}
+      };
+      for (let i = 0, n = t.childNodes.length; i < n; i++) {
+        const s = t.childNodes[i];
+        if (s.nodeType === 1)
+          switch (s.nodeName) {
+            case "newparam":
+              xt(s, e);
+              break;
+            case "technique":
+              e.technique = Lt(s);
+              break;
+            case "extra":
+              e.extra = Be(s);
+              break;
+          }
+      }
+      return e;
+    }
+    function xt(t, e) {
+      const i = t.getAttribute("sid");
+      for (let n = 0, s = t.childNodes.length; n < s; n++) {
+        const o = t.childNodes[n];
+        if (o.nodeType === 1)
+          switch (o.nodeName) {
+            case "surface":
+              e.surfaces[i] = _t(o);
+              break;
+            case "sampler2D":
+              e.samplers[i] = Ct(o);
+              break;
+          }
+      }
+    }
+    function _t(t) {
+      const e = {};
+      for (let i = 0, n = t.childNodes.length; i < n; i++) {
+        const s = t.childNodes[i];
+        if (s.nodeType === 1)
+          switch (s.nodeName) {
+            case "init_from":
+              e.init_from = s.textContent;
+              break;
+          }
+      }
+      return e;
+    }
+    function Ct(t) {
+      const e = {};
+      for (let i = 0, n = t.childNodes.length; i < n; i++) {
+        const s = t.childNodes[i];
+        if (s.nodeType === 1)
+          switch (s.nodeName) {
+            case "source":
+              e.source = s.textContent;
+              break;
+          }
+      }
+      return e;
+    }
+    function Lt(t) {
+      const e = {};
+      for (let i = 0, n = t.childNodes.length; i < n; i++) {
+        const s = t.childNodes[i];
+        if (s.nodeType === 1)
+          switch (s.nodeName) {
+            case "constant":
+            case "lambert":
+            case "blinn":
+            case "phong":
+              e.type = s.nodeName, e.parameters = vt(s);
+              break;
+            case "extra":
+              e.extra = Be(s);
+              break;
+          }
+      }
+      return e;
+    }
+    function vt(t) {
+      const e = {};
+      for (let i = 0, n = t.childNodes.length; i < n; i++) {
+        const s = t.childNodes[i];
+        if (s.nodeType === 1)
+          switch (s.nodeName) {
+            case "emission":
+            case "diffuse":
+            case "specular":
+            case "bump":
+            case "ambient":
+            case "shininess":
+            case "transparency":
+              e[s.nodeName] = Fe(s);
+              break;
+            case "transparent":
+              e[s.nodeName] = {
+                opaque: s.hasAttribute("opaque") ? s.getAttribute("opaque") : "A_ONE",
+                data: Fe(s)
+              };
+              break;
+          }
+      }
+      return e;
+    }
+    function Fe(t) {
+      const e = {};
+      for (let i = 0, n = t.childNodes.length; i < n; i++) {
+        const s = t.childNodes[i];
+        if (s.nodeType === 1)
+          switch (s.nodeName) {
+            case "color":
+              e[s.nodeName] = v(s.textContent);
+              break;
+            case "float":
+              e[s.nodeName] = parseFloat(s.textContent);
+              break;
+            case "texture":
+              e[s.nodeName] = { id: s.getAttribute("texture"), extra: He(s) };
+              break;
+          }
+      }
+      return e;
+    }
+    function He(t) {
+      const e = {
+        technique: {}
+      };
+      for (let i = 0, n = t.childNodes.length; i < n; i++) {
+        const s = t.childNodes[i];
+        if (s.nodeType === 1)
+          switch (s.nodeName) {
+            case "extra":
+              Rt(s, e);
+              break;
+          }
+      }
+      return e;
+    }
+    function Rt(t, e) {
+      for (let i = 0, n = t.childNodes.length; i < n; i++) {
+        const s = t.childNodes[i];
+        if (s.nodeType === 1)
+          switch (s.nodeName) {
+            case "technique":
+              It(s, e);
+              break;
+          }
+      }
+    }
+    function It(t, e) {
+      for (let i = 0, n = t.childNodes.length; i < n; i++) {
+        const s = t.childNodes[i];
+        if (s.nodeType === 1)
+          switch (s.nodeName) {
+            case "repeatU":
+            case "repeatV":
+            case "offsetU":
+            case "offsetV":
+              e.technique[s.nodeName] = parseFloat(s.textContent);
+              break;
+            case "wrapU":
+            case "wrapV":
+              s.textContent.toUpperCase() === "TRUE" ? e.technique[s.nodeName] = 1 : s.textContent.toUpperCase() === "FALSE" ? e.technique[s.nodeName] = 0 : e.technique[s.nodeName] = parseInt(s.textContent);
+              break;
+            case "bump":
+              e[s.nodeName] = De(s);
+              break;
+          }
+      }
+    }
+    function Be(t) {
+      const e = {};
+      for (let i = 0, n = t.childNodes.length; i < n; i++) {
+        const s = t.childNodes[i];
+        if (s.nodeType === 1)
+          switch (s.nodeName) {
+            case "technique":
+              e.technique = Mt(s);
+              break;
+          }
+      }
+      return e;
+    }
+    function Mt(t) {
+      const e = {};
+      for (let i = 0, n = t.childNodes.length; i < n; i++) {
+        const s = t.childNodes[i];
+        if (s.nodeType === 1)
+          switch (s.nodeName) {
+            case "double_sided":
+              e[s.nodeName] = parseInt(s.textContent);
+              break;
+            case "bump":
+              e[s.nodeName] = De(s);
+              break;
+          }
+      }
+      return e;
+    }
+    function De(t) {
+      const e = {};
+      for (let i = 0, n = t.childNodes.length; i < n; i++) {
+        const s = t.childNodes[i];
+        if (s.nodeType === 1)
+          switch (s.nodeName) {
+            case "texture":
+              e[s.nodeName] = { id: s.getAttribute("texture"), texcoord: s.getAttribute("texcoord"), extra: He(s) };
+              break;
+          }
+      }
+      return e;
+    }
+    function ze(t) {
+      return t;
+    }
+    function St(t) {
+      return ee(T.effects[t], ze);
+    }
+    function Ot(t) {
+      const e = {
+        name: t.getAttribute("name")
+      };
+      for (let i = 0, n = t.childNodes.length; i < n; i++) {
+        const s = t.childNodes[i];
+        if (s.nodeType === 1)
+          switch (s.nodeName) {
+            case "instance_effect":
+              e.url = I(s.getAttribute("url"));
+              break;
+          }
+      }
+      T.materials[t.getAttribute("id")] = e;
+    }
+    function Gt(t) {
+      let e, i = t.slice((t.lastIndexOf(".") - 1 >>> 0) + 2);
+      switch (i = i.toLowerCase(), i) {
+        case "tga":
+          e = je;
+          break;
+        default:
+          e = rt;
+      }
+      return e;
+    }
+    function Ve(t) {
+      const e = St(t.url), i = e.profile.technique;
+      let n;
+      switch (i.type) {
+        case "phong":
+        case "blinn":
+          n = new ve();
+          break;
+        case "lambert":
+          n = new Sn();
+          break;
+        default:
+          n = new dt();
+          break;
+      }
+      n.name = t.name || "";
+      function s(c, l = null) {
+        const g = e.profile.samplers[c.id];
+        let a = null;
+        if (g !== void 0) {
+          const b = e.profile.surfaces[g.source];
+          a = V(b.init_from);
+        } else
+          console.warn("THREE.ColladaLoader: Undefined sampler. Access image directly (see #12530)."), a = V(c.id);
+        if (a !== null) {
+          const b = Gt(a);
+          if (b !== void 0) {
+            const p = b.load(a), w = c.extra;
+            if (w !== void 0 && w.technique !== void 0 && ne(w.technique) === !1) {
+              const y = w.technique;
+              p.wrapS = y.wrapU ? Oe : gt, p.wrapT = y.wrapV ? Oe : gt, p.offset.set(y.offsetU || 0, y.offsetV || 0), p.repeat.set(y.repeatU || 1, y.repeatV || 1);
+            } else
+              p.wrapS = Oe, p.wrapT = Oe;
+            return l !== null && (p.colorSpace = l), p;
+          } else
+            return console.warn("THREE.ColladaLoader: Loader for texture %s not found.", a), null;
+        } else
+          return console.warn("THREE.ColladaLoader: Couldn't create texture with ID:", c.id), null;
+      }
+      const o = i.parameters;
+      for (const c in o) {
+        const l = o[c];
+        switch (c) {
+          case "diffuse":
+            l.color && n.color.fromArray(l.color), l.texture && (n.map = s(l.texture, me));
+            break;
+          case "specular":
+            l.color && n.specular && n.specular.fromArray(l.color), l.texture && (n.specularMap = s(l.texture));
+            break;
+          case "bump":
+            l.texture && (n.normalMap = s(l.texture));
+            break;
+          case "ambient":
+            l.texture && (n.lightMap = s(l.texture, me));
+            break;
+          case "shininess":
+            l.float && n.shininess && (n.shininess = l.float);
+            break;
+          case "emission":
+            l.color && n.emissive && n.emissive.fromArray(l.color), l.texture && (n.emissiveMap = s(l.texture, me));
+            break;
+        }
+      }
+      Se.colorSpaceToWorking(n.color, me), n.specular && Se.colorSpaceToWorking(n.specular, me), n.emissive && Se.colorSpaceToWorking(n.emissive, me);
+      let r = o.transparent, d = o.transparency;
+      if (d === void 0 && r && (d = {
+        float: 1
+      }), r === void 0 && d && (r = {
+        opaque: "A_ONE",
+        data: {
+          color: [1, 1, 1, 1]
+        }
+      }), r && d)
+        if (r.data.texture)
+          n.transparent = !0;
+        else {
+          const c = r.data.color;
+          switch (r.opaque) {
+            case "A_ONE":
+              n.opacity = c[3] * d.float;
+              break;
+            case "RGB_ZERO":
+              n.opacity = 1 - c[0] * d.float;
+              break;
+            case "A_ZERO":
+              n.opacity = 1 - c[3] * d.float;
+              break;
+            case "RGB_ONE":
+              n.opacity = c[0] * d.float;
+              break;
+            default:
+              console.warn('THREE.ColladaLoader: Invalid opaque type "%s" of transparent tag.', r.opaque);
+          }
+          n.opacity < 1 && (n.transparent = !0);
+        }
+      if (i.extra !== void 0 && i.extra.technique !== void 0) {
+        const c = i.extra.technique;
+        for (const l in c) {
+          const g = c[l];
+          switch (l) {
+            case "double_sided":
+              n.side = g === 1 ? Gn : qn;
+              break;
+            case "bump":
+              n.normalMap = s(g.texture), n.normalScale = new On(1, 1);
+              break;
+          }
+        }
+      }
+      return n;
+    }
+    function qt(t) {
+      return ee(T.materials[t], Ve);
+    }
+    function Pt(t) {
+      const e = {
+        name: t.getAttribute("name")
+      };
+      for (let i = 0, n = t.childNodes.length; i < n; i++) {
+        const s = t.childNodes[i];
+        if (s.nodeType === 1)
+          switch (s.nodeName) {
+            case "optics":
+              e.optics = jt(s);
+              break;
+          }
+      }
+      T.cameras[t.getAttribute("id")] = e;
+    }
+    function jt(t) {
+      for (let e = 0; e < t.childNodes.length; e++) {
+        const i = t.childNodes[e];
+        switch (i.nodeName) {
+          case "technique_common":
+            return Ut(i);
+        }
+      }
+      return {};
+    }
+    function Ut(t) {
+      const e = {};
+      for (let i = 0; i < t.childNodes.length; i++) {
+        const n = t.childNodes[i];
+        switch (n.nodeName) {
+          case "perspective":
+          case "orthographic":
+            e.technique = n.nodeName, e.parameters = Ft(n);
+            break;
+        }
+      }
+      return e;
+    }
+    function Ft(t) {
+      const e = {};
+      for (let i = 0; i < t.childNodes.length; i++) {
+        const n = t.childNodes[i];
+        switch (n.nodeName) {
+          case "xfov":
+          case "yfov":
+          case "xmag":
+          case "ymag":
+          case "znear":
+          case "zfar":
+          case "aspect_ratio":
+            e[n.nodeName] = parseFloat(n.textContent);
+            break;
+        }
+      }
+      return e;
+    }
+    function Je(t) {
+      let e;
+      switch (t.optics.technique) {
+        case "perspective":
+          e = new ht(
+            t.optics.parameters.yfov,
+            t.optics.parameters.aspect_ratio,
+            t.optics.parameters.znear,
+            t.optics.parameters.zfar
+          );
+          break;
+        case "orthographic":
+          let i = t.optics.parameters.ymag, n = t.optics.parameters.xmag;
+          const s = t.optics.parameters.aspect_ratio;
+          n = n === void 0 ? i * s : n, i = i === void 0 ? n / s : i, n *= 0.5, i *= 0.5, e = new Pn(
+            -n,
+            n,
+            i,
+            -i,
+            // left, right, top, bottom
+            t.optics.parameters.znear,
+            t.optics.parameters.zfar
+          );
+          break;
+        default:
+          e = new ht();
+          break;
+      }
+      return e.name = t.name || "", e;
+    }
+    function Ht(t) {
+      const e = T.cameras[t];
+      return e !== void 0 ? ee(e, Je) : (console.warn("THREE.ColladaLoader: Couldn't find camera with ID:", t), null);
+    }
+    function Bt(t) {
+      let e = {};
+      for (let i = 0, n = t.childNodes.length; i < n; i++) {
+        const s = t.childNodes[i];
+        if (s.nodeType === 1)
+          switch (s.nodeName) {
+            case "technique_common":
+              e = Dt(s);
+              break;
+          }
+      }
+      T.lights[t.getAttribute("id")] = e;
+    }
+    function Dt(t) {
+      const e = {};
+      for (let i = 0, n = t.childNodes.length; i < n; i++) {
+        const s = t.childNodes[i];
+        if (s.nodeType === 1)
+          switch (s.nodeName) {
+            case "directional":
+            case "point":
+            case "spot":
+            case "ambient":
+              e.technique = s.nodeName, e.parameters = zt(s);
+          }
+      }
+      return e;
+    }
+    function zt(t) {
+      const e = {};
+      for (let i = 0, n = t.childNodes.length; i < n; i++) {
+        const s = t.childNodes[i];
+        if (s.nodeType === 1)
+          switch (s.nodeName) {
+            case "color":
+              const o = v(s.textContent);
+              e.color = new ut().fromArray(o), Se.colorSpaceToWorking(e.color, me);
+              break;
+            case "falloff_angle":
+              e.falloffAngle = parseFloat(s.textContent);
+              break;
+            case "quadratic_attenuation":
+              const r = parseFloat(s.textContent);
+              e.distance = r ? Math.sqrt(1 / r) : 0;
+              break;
+          }
+      }
+      return e;
+    }
+    function Ke(t) {
+      let e;
+      switch (t.technique) {
+        case "directional":
+          e = new Hn();
+          break;
+        case "point":
+          e = new Fn();
+          break;
+        case "spot":
+          e = new Un();
+          break;
+        case "ambient":
+          e = new jn();
+          break;
+      }
+      return t.parameters.color && e.color.copy(t.parameters.color), t.parameters.distance && (e.distance = t.parameters.distance), e;
+    }
+    function Vt(t) {
+      const e = T.lights[t];
+      return e !== void 0 ? ee(e, Ke) : (console.warn("THREE.ColladaLoader: Couldn't find light with ID:", t), null);
+    }
+    function Jt(t) {
+      const e = {
+        name: t.getAttribute("name"),
+        sources: {},
+        vertices: {},
+        primitives: []
+      }, i = R(t, "mesh")[0];
+      if (i !== void 0) {
+        for (let n = 0; n < i.childNodes.length; n++) {
+          const s = i.childNodes[n];
+          if (s.nodeType !== 1) continue;
+          const o = s.getAttribute("id");
+          switch (s.nodeName) {
+            case "source":
+              e.sources[o] = Ge(s);
+              break;
+            case "vertices":
+              e.vertices = Kt(s);
+              break;
+            case "polygons":
+              console.warn("THREE.ColladaLoader: Unsupported primitive type: ", s.nodeName);
+              break;
+            case "lines":
+            case "linestrips":
+            case "polylist":
+            case "triangles":
+              e.primitives.push(Wt(s));
+              break;
+            default:
+              console.log(s);
+          }
+        }
+        T.geometries[t.getAttribute("id")] = e;
+      }
+    }
+    function Ge(t) {
+      const e = {
+        array: [],
+        stride: 3
+      };
+      for (let i = 0; i < t.childNodes.length; i++) {
+        const n = t.childNodes[i];
+        if (n.nodeType === 1)
+          switch (n.nodeName) {
+            case "float_array":
+              e.array = v(n.textContent);
+              break;
+            case "Name_array":
+              e.array = se(n.textContent);
+              break;
+            case "technique_common":
+              const s = R(n, "accessor")[0];
+              s !== void 0 && (e.stride = parseInt(s.getAttribute("stride")));
+              break;
+          }
+      }
+      return e;
+    }
+    function Kt(t) {
+      const e = {};
+      for (let i = 0; i < t.childNodes.length; i++) {
+        const n = t.childNodes[i];
+        n.nodeType === 1 && (e[n.getAttribute("semantic")] = I(n.getAttribute("source")));
+      }
+      return e;
+    }
+    function Wt(t) {
+      const e = {
+        type: t.nodeName,
+        material: t.getAttribute("material"),
+        count: parseInt(t.getAttribute("count")),
+        inputs: {},
+        stride: 0,
+        hasUV: !1
+      };
+      for (let i = 0, n = t.childNodes.length; i < n; i++) {
+        const s = t.childNodes[i];
+        if (s.nodeType === 1)
+          switch (s.nodeName) {
+            case "input":
+              const o = I(s.getAttribute("source")), r = s.getAttribute("semantic"), d = parseInt(s.getAttribute("offset")), c = parseInt(s.getAttribute("set")), l = c > 0 ? r + c : r;
+              e.inputs[l] = { id: o, offset: d }, e.stride = Math.max(e.stride, d + 1), r === "TEXCOORD" && (e.hasUV = !0);
+              break;
+            case "vcount":
+              e.vcount = oe(s.textContent);
+              break;
+            case "p":
+              e.p = oe(s.textContent);
+              break;
+          }
+      }
+      return e;
+    }
+    function Yt(t) {
+      const e = {};
+      for (let i = 0; i < t.length; i++) {
+        const n = t[i];
+        e[n.type] === void 0 && (e[n.type] = []), e[n.type].push(n);
+      }
+      return e;
+    }
+    function Xt(t) {
+      let e = 0;
+      for (let i = 0, n = t.length; i < n; i++)
+        t[i].hasUV === !0 && e++;
+      e > 0 && e < t.length && (t.uvsNeedsFix = !0);
+    }
+    function We(t) {
+      const e = {}, i = t.sources, n = t.vertices, s = t.primitives;
+      if (s.length === 0) return {};
+      const o = Yt(s);
+      for (const r in o) {
+        const d = o[r];
+        Xt(d), e[r] = $t(d, i, n);
+      }
+      return e;
+    }
+    function $t(t, e, i) {
+      const n = {}, s = { array: [], stride: 0 }, o = { array: [], stride: 0 }, r = { array: [], stride: 0 }, d = { array: [], stride: 0 }, c = { array: [], stride: 0 }, l = { array: [], stride: 4 }, g = { array: [], stride: 4 }, a = new Dn(), b = [];
+      let p = 0;
+      for (let w = 0; w < t.length; w++) {
+        const y = t[w], K = y.inputs;
+        let H = 0;
+        switch (y.type) {
+          case "lines":
+          case "linestrips":
+            H = y.count * 2;
+            break;
+          case "triangles":
+            H = y.count * 3;
+            break;
+          case "polylist":
+            for (let G = 0; G < y.count; G++) {
+              const q = y.vcount[G];
+              switch (q) {
+                case 3:
+                  H += 3;
+                  break;
+                case 4:
+                  H += 6;
+                  break;
+                default:
+                  H += (q - 2) * 3;
+                  break;
+              }
+            }
+            break;
+          default:
+            console.warn("THREE.ColladaLoader: Unknown primitive type:", y.type);
+        }
+        a.addGroup(p, H, w), p += H, y.material && b.push(y.material);
+        for (const G in K) {
+          const q = K[G];
+          switch (G) {
+            case "VERTEX":
+              for (const fe in i) {
+                const re = i[fe];
+                switch (fe) {
+                  case "POSITION":
+                    const xe = s.array.length;
+                    if (de(y, e[re], q.offset, s.array), s.stride = e[re].stride, e.skinWeights && e.skinIndices && (de(y, e.skinIndices, q.offset, l.array), de(y, e.skinWeights, q.offset, g.array)), y.hasUV === !1 && t.uvsNeedsFix === !0) {
+                      const Cn = (s.array.length - xe) / s.stride;
+                      for (let ct = 0; ct < Cn; ct++)
+                        r.array.push(0, 0);
+                    }
+                    break;
+                  case "NORMAL":
+                    de(y, e[re], q.offset, o.array), o.stride = e[re].stride;
+                    break;
+                  case "COLOR":
+                    de(y, e[re], q.offset, c.array), c.stride = e[re].stride;
+                    break;
+                  case "TEXCOORD":
+                    de(y, e[re], q.offset, r.array), r.stride = e[re].stride;
+                    break;
+                  case "TEXCOORD1":
+                    de(y, e[re], q.offset, d.array), r.stride = e[re].stride;
+                    break;
+                  default:
+                    console.warn('THREE.ColladaLoader: Semantic "%s" not handled in geometry build process.', fe);
+                }
+              }
+              break;
+            case "NORMAL":
+              de(y, e[q.id], q.offset, o.array), o.stride = e[q.id].stride;
+              break;
+            case "COLOR":
+              de(y, e[q.id], q.offset, c.array, !0), c.stride = e[q.id].stride;
+              break;
+            case "TEXCOORD":
+              de(y, e[q.id], q.offset, r.array), r.stride = e[q.id].stride;
+              break;
+            case "TEXCOORD1":
+              de(y, e[q.id], q.offset, d.array), d.stride = e[q.id].stride;
+              break;
+          }
+        }
+      }
+      return s.array.length > 0 && a.setAttribute("position", new ye(s.array, s.stride)), o.array.length > 0 && a.setAttribute("normal", new ye(o.array, o.stride)), c.array.length > 0 && a.setAttribute("color", new ye(c.array, c.stride)), r.array.length > 0 && a.setAttribute("uv", new ye(r.array, r.stride)), d.array.length > 0 && a.setAttribute("uv1", new ye(d.array, d.stride)), l.array.length > 0 && a.setAttribute("skinIndex", new ye(l.array, l.stride)), g.array.length > 0 && a.setAttribute("skinWeight", new ye(g.array, g.stride)), n.data = a, n.type = t[0].type, n.materialKeys = b, n;
+    }
+    function de(t, e, i, n, s = !1) {
+      const o = t.p, r = t.stride, d = t.vcount;
+      function c(a) {
+        let b = o[a + i] * g;
+        const p = b + g;
+        for (; b < p; b++)
+          n.push(l[b]);
+        if (s) {
+          const w = n.length - g - 1;
+          Re.setRGB(
+            n[w + 0],
+            n[w + 1],
+            n[w + 2],
+            me
+          ), n[w + 0] = Re.r, n[w + 1] = Re.g, n[w + 2] = Re.b;
+        }
+      }
+      const l = e.array, g = e.stride;
+      if (t.vcount !== void 0) {
+        let a = 0;
+        for (let b = 0, p = d.length; b < p; b++) {
+          const w = d[b];
+          if (w === 4) {
+            const y = a + r * 0, K = a + r * 1, H = a + r * 2, G = a + r * 3;
+            c(y), c(K), c(G), c(K), c(H), c(G);
+          } else if (w === 3) {
+            const y = a + r * 0, K = a + r * 1, H = a + r * 2;
+            c(y), c(K), c(H);
+          } else if (w > 4)
+            for (let y = 1, K = w - 2; y <= K; y++) {
+              const H = a + r * 0, G = a + r * y, q = a + r * (y + 1);
+              c(H), c(G), c(q);
+            }
+          a += r * w;
+        }
+      } else
+        for (let a = 0, b = o.length; a < b; a += r)
+          c(a);
+    }
+    function Ye(t) {
+      return ee(T.geometries[t], We);
+    }
+    function Zt(t) {
+      const e = {
+        name: t.getAttribute("name") || "",
+        joints: {},
+        links: []
+      };
+      for (let i = 0; i < t.childNodes.length; i++) {
+        const n = t.childNodes[i];
+        if (n.nodeType === 1)
+          switch (n.nodeName) {
+            case "technique_common":
+              tn(n, e);
+              break;
+          }
+      }
+      T.kinematicsModels[t.getAttribute("id")] = e;
+    }
+    function Qt(t) {
+      return t.build !== void 0 ? t.build : t;
+    }
+    function en(t) {
+      return ee(T.kinematicsModels[t], Qt);
+    }
+    function tn(t, e) {
+      for (let i = 0; i < t.childNodes.length; i++) {
+        const n = t.childNodes[i];
+        if (n.nodeType === 1)
+          switch (n.nodeName) {
+            case "joint":
+              e.joints[n.getAttribute("sid")] = nn(n);
+              break;
+            case "link":
+              e.links.push(Xe(n));
+              break;
+          }
+      }
+    }
+    function nn(t) {
+      let e;
+      for (let i = 0; i < t.childNodes.length; i++) {
+        const n = t.childNodes[i];
+        if (n.nodeType === 1)
+          switch (n.nodeName) {
+            case "prismatic":
+            case "revolute":
+              e = sn(n);
+              break;
+          }
+      }
+      return e;
+    }
+    function sn(t) {
+      const e = {
+        sid: t.getAttribute("sid"),
+        name: t.getAttribute("name") || "",
+        axis: new pe(),
+        limits: {
+          min: 0,
+          max: 0
+        },
+        type: t.nodeName,
+        static: !1,
+        zeroPosition: 0,
+        middlePosition: 0
+      };
+      for (let i = 0; i < t.childNodes.length; i++) {
+        const n = t.childNodes[i];
+        if (n.nodeType === 1)
+          switch (n.nodeName) {
+            case "axis":
+              const s = v(n.textContent);
+              e.axis.fromArray(s);
+              break;
+            case "limits":
+              const o = n.getElementsByTagName("max")[0], r = n.getElementsByTagName("min")[0];
+              e.limits.max = parseFloat(o.textContent), e.limits.min = parseFloat(r.textContent);
+              break;
+          }
+      }
+      return e.limits.min >= e.limits.max && (e.static = !0), e.middlePosition = (e.limits.min + e.limits.max) / 2, e;
+    }
+    function Xe(t) {
+      const e = {
+        sid: t.getAttribute("sid"),
+        name: t.getAttribute("name") || "",
+        attachments: [],
+        transforms: []
+      };
+      for (let i = 0; i < t.childNodes.length; i++) {
+        const n = t.childNodes[i];
+        if (n.nodeType === 1)
+          switch (n.nodeName) {
+            case "attachment_full":
+              e.attachments.push(on(n));
+              break;
+            case "matrix":
+            case "translate":
+            case "rotate":
+              e.transforms.push($e(n));
+              break;
+          }
+      }
+      return e;
+    }
+    function on(t) {
+      const e = {
+        joint: t.getAttribute("joint").split("/").pop(),
+        transforms: [],
+        links: []
+      };
+      for (let i = 0; i < t.childNodes.length; i++) {
+        const n = t.childNodes[i];
+        if (n.nodeType === 1)
+          switch (n.nodeName) {
+            case "link":
+              e.links.push(Xe(n));
+              break;
+            case "matrix":
+            case "translate":
+            case "rotate":
+              e.transforms.push($e(n));
+              break;
+          }
+      }
+      return e;
+    }
+    function $e(t) {
+      const e = {
+        type: t.nodeName
+      }, i = v(t.textContent);
+      switch (e.type) {
+        case "matrix":
+          e.obj = new he(), e.obj.fromArray(i).transpose();
+          break;
+        case "translate":
+          e.obj = new pe(), e.obj.fromArray(i);
+          break;
+        case "rotate":
+          e.obj = new pe(), e.obj.fromArray(i), e.angle = Le.degToRad(i[3]);
+          break;
+      }
+      return e;
+    }
+    function rn(t) {
+      const e = {
+        name: t.getAttribute("name") || "",
+        rigidBodies: {}
+      };
+      for (let i = 0; i < t.childNodes.length; i++) {
+        const n = t.childNodes[i];
+        if (n.nodeType === 1)
+          switch (n.nodeName) {
+            case "rigid_body":
+              e.rigidBodies[n.getAttribute("name")] = {}, an(n, e.rigidBodies[n.getAttribute("name")]);
+              break;
+          }
+      }
+      T.physicsModels[t.getAttribute("id")] = e;
+    }
+    function an(t, e) {
+      for (let i = 0; i < t.childNodes.length; i++) {
+        const n = t.childNodes[i];
+        if (n.nodeType === 1)
+          switch (n.nodeName) {
+            case "technique_common":
+              cn(n, e);
+              break;
+          }
+      }
+    }
+    function cn(t, e) {
+      for (let i = 0; i < t.childNodes.length; i++) {
+        const n = t.childNodes[i];
+        if (n.nodeType === 1)
+          switch (n.nodeName) {
+            case "inertia":
+              e.inertia = v(n.textContent);
+              break;
+            case "mass":
+              e.mass = v(n.textContent)[0];
+              break;
+          }
+      }
+    }
+    function ln(t) {
+      const e = {
+        bindJointAxis: []
+      };
+      for (let i = 0; i < t.childNodes.length; i++) {
+        const n = t.childNodes[i];
+        if (n.nodeType === 1)
+          switch (n.nodeName) {
+            case "bind_joint_axis":
+              e.bindJointAxis.push(dn(n));
+              break;
+          }
+      }
+      T.kinematicsScenes[I(t.getAttribute("url"))] = e;
+    }
+    function dn(t) {
+      const e = {
+        target: t.getAttribute("target").split("/").pop()
+      };
+      for (let i = 0; i < t.childNodes.length; i++) {
+        const n = t.childNodes[i];
+        if (n.nodeType === 1)
+          switch (n.nodeName) {
+            case "axis":
+              const s = n.getElementsByTagName("param")[0];
+              e.axis = s.textContent;
+              const o = e.axis.split("inst_").pop().split("axis")[0];
+              e.jointIndex = o.substring(0, o.length - 1);
+              break;
+          }
+      }
+      return e;
+    }
+    function un(t) {
+      return t.build !== void 0 ? t.build : t;
+    }
+    function fn(t) {
+      return ee(T.kinematicsScenes[t], un);
+    }
+    function hn() {
+      const t = Object.keys(T.kinematicsModels)[0], e = Object.keys(T.kinematicsScenes)[0], i = Object.keys(T.visualScenes)[0];
+      if (t === void 0 || e === void 0) return;
+      const n = en(t), s = fn(e), o = it(i), r = s.bindJointAxis, d = {};
+      for (let g = 0, a = r.length; g < a; g++) {
+        const b = r[g], p = Z.querySelector('[sid="' + b.target + '"]');
+        if (p) {
+          const w = p.parentElement;
+          c(b.jointIndex, w);
+        }
+      }
+      function c(g, a) {
+        const b = a.getAttribute("name"), p = n.joints[g];
+        o.traverse(function(w) {
+          w.name === b && (d[g] = {
+            object: w,
+            transforms: pn(a),
+            joint: p,
+            position: p.zeroPosition
+          });
+        });
+      }
+      const l = new he();
+      at = {
+        joints: n && n.joints,
+        getJointValue: function(g) {
+          const a = d[g];
+          if (a)
+            return a.position;
+          console.warn("THREE.ColladaLoader: Joint " + g + " doesn't exist.");
+        },
+        setJointValue: function(g, a) {
+          const b = d[g];
+          if (b) {
+            const p = b.joint;
+            if (a > p.limits.max || a < p.limits.min)
+              console.warn("THREE.ColladaLoader: Joint " + g + " value " + a + " outside of limits (min: " + p.limits.min + ", max: " + p.limits.max + ").");
+            else if (p.static)
+              console.warn("THREE.ColladaLoader: Joint " + g + " is static.");
+            else {
+              const w = b.object, y = p.axis, K = b.transforms;
+              ce.identity();
+              for (let H = 0; H < K.length; H++) {
+                const G = K[H];
+                if (G.sid && G.sid.indexOf(g) !== -1)
+                  switch (p.type) {
+                    case "revolute":
+                      ce.multiply(l.makeRotationAxis(y, Le.degToRad(a)));
+                      break;
+                    case "prismatic":
+                      ce.multiply(l.makeTranslation(y.x * a, y.y * a, y.z * a));
+                      break;
+                    default:
+                      console.warn("THREE.ColladaLoader: Unknown joint type: " + p.type);
+                      break;
+                  }
+                else
+                  switch (G.type) {
+                    case "matrix":
+                      ce.multiply(G.obj);
+                      break;
+                    case "translate":
+                      ce.multiply(l.makeTranslation(G.obj.x, G.obj.y, G.obj.z));
+                      break;
+                    case "scale":
+                      ce.scale(G.obj);
+                      break;
+                    case "rotate":
+                      ce.multiply(l.makeRotationAxis(G.obj, G.angle));
+                      break;
+                  }
+              }
+              w.matrix.copy(ce), w.matrix.decompose(w.position, w.quaternion, w.scale), d[g].position = a;
+            }
+          } else
+            console.log("THREE.ColladaLoader: " + g + " does not exist.");
+        }
+      };
+    }
+    function pn(t) {
+      const e = [], i = Z.querySelector('[id="' + t.id + '"]');
+      for (let n = 0; n < i.childNodes.length; n++) {
+        const s = i.childNodes[n];
+        if (s.nodeType !== 1) continue;
+        let o, r;
+        switch (s.nodeName) {
+          case "matrix":
+            o = v(s.textContent);
+            const d = new he().fromArray(o).transpose();
+            e.push({
+              sid: s.getAttribute("sid"),
+              type: s.nodeName,
+              obj: d
+            });
+            break;
+          case "translate":
+          case "scale":
+            o = v(s.textContent), r = new pe().fromArray(o), e.push({
+              sid: s.getAttribute("sid"),
+              type: s.nodeName,
+              obj: r
+            });
+            break;
+          case "rotate":
+            o = v(s.textContent), r = new pe().fromArray(o);
+            const c = Le.degToRad(o[3]);
+            e.push({
+              sid: s.getAttribute("sid"),
+              type: s.nodeName,
+              obj: r,
+              angle: c
+            });
+            break;
+        }
+      }
+      return e;
+    }
+    function mn(t) {
+      const e = t.getElementsByTagName("node");
+      for (let i = 0; i < e.length; i++) {
+        const n = e[i];
+        n.hasAttribute("id") === !1 && n.setAttribute("id", Y());
+      }
+    }
+    const ce = new he(), Te = new pe();
+    function qe(t) {
+      const e = {
+        name: t.getAttribute("name") || "",
+        type: t.getAttribute("type"),
+        id: t.getAttribute("id"),
+        sid: t.getAttribute("sid"),
+        matrix: new he(),
+        nodes: [],
+        instanceCameras: [],
+        instanceControllers: [],
+        instanceLights: [],
+        instanceGeometries: [],
+        instanceNodes: [],
+        transforms: {}
+      };
+      for (let i = 0; i < t.childNodes.length; i++) {
+        const n = t.childNodes[i];
+        if (n.nodeType !== 1) continue;
+        let s;
+        switch (n.nodeName) {
+          case "node":
+            e.nodes.push(n.getAttribute("id")), qe(n);
+            break;
+          case "instance_camera":
+            e.instanceCameras.push(I(n.getAttribute("url")));
+            break;
+          case "instance_controller":
+            e.instanceControllers.push(Ze(n));
+            break;
+          case "instance_light":
+            e.instanceLights.push(I(n.getAttribute("url")));
+            break;
+          case "instance_geometry":
+            e.instanceGeometries.push(Ze(n));
+            break;
+          case "instance_node":
+            e.instanceNodes.push(I(n.getAttribute("url")));
+            break;
+          case "matrix":
+            s = v(n.textContent), e.matrix.multiply(ce.fromArray(s).transpose()), e.transforms[n.getAttribute("sid")] = n.nodeName;
+            break;
+          case "translate":
+            s = v(n.textContent), Te.fromArray(s), e.matrix.multiply(ce.makeTranslation(Te.x, Te.y, Te.z)), e.transforms[n.getAttribute("sid")] = n.nodeName;
+            break;
+          case "rotate":
+            s = v(n.textContent);
+            const o = Le.degToRad(s[3]);
+            e.matrix.multiply(ce.makeRotationAxis(Te.fromArray(s), o)), e.transforms[n.getAttribute("sid")] = n.nodeName;
+            break;
+          case "scale":
+            s = v(n.textContent), e.matrix.scale(Te.fromArray(s)), e.transforms[n.getAttribute("sid")] = n.nodeName;
+            break;
+          case "extra":
+            break;
+          default:
+            console.log(n);
+        }
+      }
+      return tt(e.id) ? console.warn("THREE.ColladaLoader: There is already a node with ID %s. Exclude current node from further processing.", e.id) : T.nodes[e.id] = e, e;
+    }
+    function Ze(t) {
+      const e = {
+        id: I(t.getAttribute("url")),
+        materials: {},
+        skeletons: []
+      };
+      for (let i = 0; i < t.childNodes.length; i++) {
+        const n = t.childNodes[i];
+        switch (n.nodeName) {
+          case "bind_material":
+            const s = n.getElementsByTagName("instance_material");
+            for (let o = 0; o < s.length; o++) {
+              const r = s[o], d = r.getAttribute("symbol"), c = r.getAttribute("target");
+              e.materials[d] = I(c);
+            }
+            break;
+          case "skeleton":
+            e.skeletons.push(I(n.textContent));
+            break;
+        }
+      }
+      return e;
+    }
+    function bn(t, e) {
+      const i = [], n = [];
+      let s, o, r;
+      for (s = 0; s < t.length; s++) {
+        const l = t[s];
+        let g;
+        if (tt(l))
+          g = Ee(l), Qe(g, e, i);
+        else if (Nn(l)) {
+          const b = T.visualScenes[l].children;
+          for (let p = 0; p < b.length; p++) {
+            const w = b[p];
+            if (w.type === "JOINT") {
+              const y = Ee(w.id);
+              Qe(y, e, i);
+            }
+          }
+        } else
+          console.error("THREE.ColladaLoader: Unable to find root bone of skeleton with ID:", l);
+      }
+      for (s = 0; s < e.length; s++)
+        for (o = 0; o < i.length; o++)
+          if (r = i[o], r.bone.name === e[s].name) {
+            n[s] = r, r.processed = !0;
+            break;
+          }
+      for (s = 0; s < i.length; s++)
+        r = i[s], r.processed === !1 && (n.push(r), r.processed = !0);
+      const d = [], c = [];
+      for (s = 0; s < n.length; s++)
+        r = n[s], d.push(r.bone), c.push(r.boneInverse);
+      return new Wn(d, c);
+    }
+    function Qe(t, e, i) {
+      t.traverse(function(n) {
+        if (n.isBone === !0) {
+          let s;
+          for (let o = 0; o < e.length; o++) {
+            const r = e[o];
+            if (r.name === n.name) {
+              s = r.boneInverse;
+              break;
+            }
+          }
+          s === void 0 && (s = new he()), i.push({ bone: n, boneInverse: s, processed: !1 });
+        }
+      });
+    }
+    function gn(t) {
+      const e = [], i = t.matrix, n = t.nodes, s = t.type, o = t.instanceCameras, r = t.instanceControllers, d = t.instanceLights, c = t.instanceGeometries, l = t.instanceNodes;
+      for (let a = 0, b = n.length; a < b; a++)
+        e.push(Ee(n[a]));
+      for (let a = 0, b = o.length; a < b; a++) {
+        const p = Ht(o[a]);
+        p !== null && e.push(p.clone());
+      }
+      for (let a = 0, b = r.length; a < b; a++) {
+        const p = r[a], w = N(p.id), y = Ye(w.id), K = et(y, p.materials), H = p.skeletons, G = w.skin.joints, q = bn(H, G);
+        for (let fe = 0, re = K.length; fe < re; fe++) {
+          const xe = K[fe];
+          xe.isSkinnedMesh && (xe.bind(q, w.skin.bindMatrix), xe.normalizeSkinWeights()), e.push(xe);
+        }
+      }
+      for (let a = 0, b = d.length; a < b; a++) {
+        const p = Vt(d[a]);
+        p !== null && e.push(p.clone());
+      }
+      for (let a = 0, b = c.length; a < b; a++) {
+        const p = c[a], w = Ye(p.id), y = et(w, p.materials);
+        for (let K = 0, H = y.length; K < H; K++)
+          e.push(y[K]);
+      }
+      for (let a = 0, b = l.length; a < b; a++)
+        e.push(Ee(l[a]).clone());
+      let g;
+      if (n.length === 0 && e.length === 1)
+        g = e[0];
+      else {
+        g = s === "JOINT" ? new zn() : new pt();
+        for (let a = 0; a < e.length; a++)
+          g.add(e[a]);
+      }
+      return g.name = s === "JOINT" ? t.sid : t.name, g.matrix.copy(i), g.matrix.decompose(g.position, g.quaternion, g.scale), g;
+    }
+    const yn = new dt({
+      name: lt.DEFAULT_MATERIAL_NAME,
+      color: 16711935
+    });
+    function wn(t, e) {
+      const i = [];
+      for (let n = 0, s = t.length; n < s; n++) {
+        const o = e[t[n]];
+        o === void 0 ? (console.warn("THREE.ColladaLoader: Material with key %s not found. Apply fallback material.", t[n]), i.push(yn)) : i.push(qt(o));
+      }
+      return i;
+    }
+    function et(t, e) {
+      const i = [];
+      for (const n in t) {
+        const s = t[n], o = wn(s.materialKeys, e);
+        if (o.length === 0 && (n === "lines" || n === "linestrips" ? o.push(new bt()) : o.push(new ve())), n === "lines" || n === "linestrips")
+          for (let l = 0, g = o.length; l < g; l++) {
+            const a = o[l];
+            if (a.isMeshPhongMaterial === !0 || a.isMeshLambertMaterial === !0) {
+              const b = new bt();
+              b.color.copy(a.color), b.opacity = a.opacity, b.transparent = a.transparent, o[l] = b;
+            }
+          }
+        const r = s.data.attributes.skinIndex !== void 0, d = o.length === 1 ? o[0] : o;
+        let c;
+        switch (n) {
+          case "lines":
+            c = new Kn(s.data, d);
+            break;
+          case "linestrips":
+            c = new Jn(s.data, d);
+            break;
+          case "triangles":
+          case "polylist":
+            r ? c = new Vn(s.data, d) : c = new Ce(s.data, d);
+            break;
+        }
+        i.push(c);
+      }
+      return i;
+    }
+    function tt(t) {
+      return T.nodes[t] !== void 0;
+    }
+    function Ee(t) {
+      return ee(T.nodes[t], gn);
+    }
+    function kn(t) {
+      const e = {
+        name: t.getAttribute("name"),
+        children: []
+      };
+      mn(t);
+      const i = R(t, "node");
+      for (let n = 0; n < i.length; n++)
+        e.children.push(qe(i[n]));
+      T.visualScenes[t.getAttribute("id")] = e;
+    }
+    function nt(t) {
+      const e = new pt();
+      e.name = t.name;
+      const i = t.children;
+      for (let n = 0; n < i.length; n++) {
+        const s = i[n];
+        e.add(Ee(s.id));
+      }
+      return e;
+    }
+    function Nn(t) {
+      return T.visualScenes[t] !== void 0;
+    }
+    function it(t) {
+      return ee(T.visualScenes[t], nt);
+    }
+    function An(t) {
+      const e = R(t, "instance_visual_scene")[0];
+      return it(I(e.getAttribute("url")));
+    }
+    function Tn() {
+      const t = T.clips;
+      if (ne(t) === !0) {
+        if (ne(T.animations) === !1) {
+          const e = [];
+          for (const i in T.animations) {
+            const n = F(i);
+            for (let s = 0, o = n.length; s < o; s++)
+              e.push(n[s]);
+          }
+          Ie.push(new ft("default", -1, e));
+        }
+      } else
+        for (const e in t)
+          Ie.push(z(e));
+    }
+    function En(t) {
+      let e = "";
+      const i = [t];
+      for (; i.length; ) {
+        const n = i.shift();
+        n.nodeType === Node.TEXT_NODE ? e += n.textContent : (e += `
+`, i.push(...n.childNodes));
+      }
+      return e.trim();
+    }
+    if (O.length === 0)
+      return { scene: new Mn() };
+    const st = new DOMParser().parseFromString(O, "application/xml"), Z = R(st, "COLLADA")[0], Pe = st.getElementsByTagName("parsererror")[0];
+    if (Pe !== void 0) {
+      const t = R(Pe, "div")[0];
+      let e;
+      return t ? e = t.textContent : e = En(Pe), console.error(`THREE.ColladaLoader: Failed to parse collada file.
+`, e), null;
+    }
+    const xn = Z.getAttribute("version");
+    console.debug("THREE.ColladaLoader: File version", xn);
+    const ot = we(R(Z, "asset")[0]), rt = new Tt(this.manager);
+    rt.setPath(this.resourcePath || Q).setCrossOrigin(this.crossOrigin);
+    let je;
+    wt && (je = new wt(this.manager), je.setPath(this.resourcePath || Q));
+    const Re = new ut(), Ie = [];
+    let at = {}, _n = 0;
+    const T = {
+      animations: {},
+      clips: {},
+      controllers: {},
+      images: {},
+      effects: {},
+      materials: {},
+      cameras: {},
+      lights: {},
+      geometries: {},
+      nodes: {},
+      visualScenes: {},
+      kinematicsModels: {},
+      physicsModels: {},
+      kinematicsScenes: {}
+    };
+    $(Z, "library_animations", "animation", be), $(Z, "library_animation_clips", "animation_clip", u), $(Z, "library_controllers", "controller", B), $(Z, "library_images", "image", f), $(Z, "library_effects", "effect", le), $(Z, "library_materials", "material", Ot), $(Z, "library_cameras", "camera", Pt), $(Z, "library_lights", "light", Bt), $(Z, "library_geometries", "geometry", Jt), $(Z, "library_nodes", "node", qe), $(Z, "library_visual_scenes", "visual_scene", kn), $(Z, "library_kinematics_models", "kinematics_model", Zt), $(Z, "library_physics_models", "physics_model", rn), $(Z, "scene", "instance_kinematics_scene", ln), ie(T.animations, P), ie(T.clips, W), ie(T.controllers, _), ie(T.images, A), ie(T.effects, ze), ie(T.materials, Ve), ie(T.cameras, Je), ie(T.lights, Ke), ie(T.geometries, We), ie(T.visualScenes, nt), Tn(), hn();
+    const Me = An(R(Z, "scene")[0]);
+    return Me.animations = Ie, ot.upAxis === "Z_UP" && (console.warn("THREE.ColladaLoader: You are loading an asset with a Z-UP coordinate system. The loader just rotates the asset to transform it into Y-UP. The vertex data are not converted, see #24289."), Me.rotation.set(-Math.PI / 2, 0, 0)), Me.scale.multiplyScalar(ot.unit), {
+      get animations() {
+        return console.warn("THREE.ColladaLoader: Please access animations over scene.animations now."), Ie;
+      },
+      kinematics: at,
+      library: T,
+      scene: Me
+    };
+  }
+}
+const Ue = new Et(), kt = new si();
+function _e(ue) {
+  return ue ? ue.trim().split(/\s+/g).map((O) => parseFloat(O)) : [0, 0, 0];
+}
+function Nt(ue, O, Q = !1) {
+  Q || ue.rotation.set(0, 0, 0), kt.set(O[0], O[1], O[2], "ZYX"), Ue.setFromEuler(kt), Ue.multiply(ue.quaternion), ue.quaternion.copy(Ue);
+}
+class ci {
+  constructor(O) {
+    this.manager = O || Yn, this.loadMeshCb = this.defaultMeshLoader.bind(this), this.parseVisual = !0, this.parseCollision = !1, this.packages = "", this.workingPath = "", this.fetchOptions = {};
+  }
+  /* Public API */
+  loadAsync(O) {
+    return new Promise((Q, R) => {
+      this.load(O, Q, null, R);
+    });
+  }
+  // urdf:    The path to the URDF within the package OR absolute
+  // onComplete:      Callback that is passed the model once loaded
+  load(O, Q, R, se) {
+    const v = this.manager, oe = At.extractUrlBase(O), I = this.manager.resolveURL(O);
+    v.itemStart(I), fetch(I, this.fetchOptions).then((Y) => {
+      if (Y.ok)
+        return R && R(null), Y.text();
+      throw new Error(`URDFLoader: Failed to load url '${I}' with error code ${Y.status} : ${Y.statusText}.`);
+    }).then((Y) => {
+      const ne = this.parse(Y, this.workingPath || oe);
+      Q(ne), v.itemEnd(I);
+    }).catch((Y) => {
+      se ? se(Y) : console.error("URDFLoader: Error loading file.", Y), v.itemError(I), v.itemEnd(I);
+    });
+  }
+  parse(O, Q = this.workingPath) {
+    const R = this.packages, se = this.loadMeshCb, v = this.parseVisual, oe = this.parseCollision, I = this.manager, Y = {}, ne = {}, we = {};
+    function ke(M) {
+      if (!/^package:\/\//.test(M))
+        return Q ? Q + M : M;
+      const [P, F] = M.replace(/^package:\/\//, "").split(/\/(.+)/);
+      if (typeof R == "string")
+        return R.endsWith(P) ? R + "/" + F : R + "/" + P + "/" + F;
+      if (R instanceof Function)
+        return R(P) + "/" + F;
+      if (typeof R == "object")
+        return P in R ? R[P] + "/" + F : (console.error(`URDFLoader : ${P} not found in provided package list.`), null);
+    }
+    function Ne(M) {
+      let P;
+      M instanceof Document ? P = [...M.children] : M instanceof Element ? P = [M] : P = [...new DOMParser().parseFromString(M, "text/xml").children];
+      const F = P.filter((E) => E.nodeName === "robot").pop();
+      return $(F);
+    }
+    function $(M) {
+      const P = [...M.children], F = P.filter((L) => L.nodeName.toLowerCase() === "link"), E = P.filter((L) => L.nodeName.toLowerCase() === "joint"), J = P.filter((L) => L.nodeName.toLowerCase() === "material"), S = new Xn();
+      S.robotName = M.getAttribute("name"), S.urdfRobotNode = M, J.forEach((L) => {
+        const k = L.getAttribute("name");
+        we[k] = be(L);
+      });
+      const m = {}, h = {};
+      F.forEach((L) => {
+        const k = L.getAttribute("name"), j = M.querySelector(`child[link="${k}"]`) === null;
+        Y[k] = ee(L, m, h, j ? S : null);
+      }), E.forEach((L) => {
+        const k = L.getAttribute("name");
+        ne[k] = ie(L);
+      }), S.joints = ne, S.links = Y, S.colliders = h, S.visual = m;
+      const C = Object.values(ne);
+      return C.forEach((L) => {
+        L instanceof yt && ne[L.mimicJoint].mimicJoints.push(L);
+      }), C.forEach((L) => {
+        const k = /* @__PURE__ */ new Set(), j = (ae) => {
+          if (k.has(ae))
+            throw new Error("URDFLoader: Detected an infinite loop of mimic joints.");
+          k.add(ae), ae.mimicJoints.forEach((te) => {
+            j(te);
+          });
+        };
+        j(L);
+      }), S.frames = {
+        ...h,
+        ...m,
+        ...Y,
+        ...ne
+      }, S;
+    }
+    function ie(M) {
+      const P = [...M.children], F = M.getAttribute("type");
+      let E;
+      const J = P.find((k) => k.nodeName.toLowerCase() === "mimic");
+      J ? (E = new yt(), E.mimicJoint = J.getAttribute("joint"), E.multiplier = parseFloat(J.getAttribute("multiplier") || 1), E.offset = parseFloat(J.getAttribute("offset") || 0)) : E = new $n(), E.urdfNode = M, E.name = M.getAttribute("name"), E.urdfName = E.name, E.jointType = F;
+      let S = null, m = null, h = [0, 0, 0], C = [0, 0, 0];
+      P.forEach((k) => {
+        const j = k.nodeName.toLowerCase();
+        j === "origin" ? (h = _e(k.getAttribute("xyz")), C = _e(k.getAttribute("rpy"))) : j === "child" ? m = Y[k.getAttribute("link")] : j === "parent" ? S = Y[k.getAttribute("link")] : j === "limit" && (E.limit.lower = parseFloat(k.getAttribute("lower") || E.limit.lower), E.limit.upper = parseFloat(k.getAttribute("upper") || E.limit.upper));
+      }), S.add(E), E.add(m), Nt(E, C), E.position.set(h[0], h[1], h[2]);
+      const L = P.filter((k) => k.nodeName.toLowerCase() === "axis")[0];
+      if (L) {
+        const k = L.getAttribute("xyz").split(/\s+/g).map((j) => parseFloat(j));
+        E.axis = new pe(k[0], k[1], k[2]), E.axis.normalize();
+      }
+      return E;
+    }
+    function ee(M, P, F, E = null) {
+      E === null && (E = new Zn());
+      const J = [...M.children];
+      return E.name = M.getAttribute("name"), E.urdfName = E.name, E.urdfNode = M, v && J.filter((m) => m.nodeName.toLowerCase() === "visual").forEach((m) => {
+        const h = ge(m, we);
+        if (E.add(h), m.hasAttribute("name")) {
+          const C = m.getAttribute("name");
+          h.name = C, h.urdfName = C, P[C] = h;
+        }
+      }), oe && J.filter((m) => m.nodeName.toLowerCase() === "collision").forEach((m) => {
+        const h = ge(m);
+        if (E.add(h), m.hasAttribute("name")) {
+          const C = m.getAttribute("name");
+          h.name = C, h.urdfName = C, F[C] = h;
+        }
+      }), E;
+    }
+    function be(M) {
+      const P = [...M.children], F = new ve();
+      return F.name = M.getAttribute("name") || "", P.forEach((E) => {
+        const J = E.nodeName.toLowerCase();
+        if (J === "color") {
+          const S = E.getAttribute("rgba").split(/\s/g).map((m) => parseFloat(m));
+          F.color.setRGB(S[0], S[1], S[2]), F.opacity = S[3], F.transparent = S[3] < 1, F.depthWrite = !F.transparent;
+        } else if (J === "texture") {
+          const S = E.getAttribute("filename");
+          if (S) {
+            const m = new Tt(I), h = ke(S);
+            F.map = m.load(h), F.map.colorSpace = me;
+          }
+        }
+      }), F;
+    }
+    function ge(M, P = {}) {
+      const F = M.nodeName.toLowerCase() === "collision", E = [...M.children];
+      let J = null;
+      const S = E.filter((h) => h.nodeName.toLowerCase() === "material")[0];
+      if (S) {
+        const h = S.getAttribute("name");
+        h && h in P ? J = P[h] : J = be(S);
+      } else
+        J = new ve();
+      const m = F ? new Qn() : new ei();
+      return m.urdfNode = M, E.forEach((h) => {
+        const C = h.nodeName.toLowerCase();
+        if (C === "geometry") {
+          const L = h.children[0].nodeName.toLowerCase();
+          if (L === "mesh") {
+            const k = h.children[0].getAttribute("filename"), j = ke(k);
+            if (j !== null) {
+              const ae = h.children[0].getAttribute("scale");
+              if (ae) {
+                const te = _e(ae);
+                m.scale.set(te[0], te[1], te[2]);
+              }
+              se(j, I, (te, u) => {
+                u ? console.error("URDFLoader: Error loading mesh.", u) : te && (te instanceof Ce && (te.material = J), te.position.set(0, 0, 0), te.quaternion.identity(), m.add(te));
+              });
+            }
+          } else if (L === "box") {
+            const k = new Ce();
+            k.geometry = new ti(1, 1, 1), k.material = J;
+            const j = _e(h.children[0].getAttribute("size"));
+            k.scale.set(j[0], j[1], j[2]), m.add(k);
+          } else if (L === "sphere") {
+            const k = new Ce();
+            k.geometry = new ni(1, 30, 30), k.material = J;
+            const j = parseFloat(h.children[0].getAttribute("radius")) || 0;
+            k.scale.set(j, j, j), m.add(k);
+          } else if (L === "cylinder") {
+            const k = new Ce();
+            k.geometry = new ii(1, 1, 1, 30), k.material = J;
+            const j = parseFloat(h.children[0].getAttribute("radius")) || 0, ae = parseFloat(h.children[0].getAttribute("length")) || 0;
+            k.scale.set(j, ae, j), k.rotation.set(Math.PI / 2, 0, 0), m.add(k);
+          }
+        } else if (C === "origin") {
+          const L = _e(h.getAttribute("xyz")), k = _e(h.getAttribute("rpy"));
+          m.position.set(L[0], L[1], L[2]), m.rotation.set(0, 0, 0), Nt(m, k);
+        }
+      }), m;
+    }
+    return Ne(O);
+  }
+  // Default mesh loading function
+  defaultMeshLoader(O, Q, R) {
+    /\.stl$/i.test(O) ? new Ln(Q).load(O, (v) => {
+      const oe = new Ce(v, new ve());
+      R(oe);
+    }) : /\.dae$/i.test(O) ? new oi(Q).load(O, (v) => R(v.scene)) : console.warn(`URDFLoader: Could not load model at ${O}.
+No loader available`);
+  }
+}
+export {
+  ci as U
+};