ss-component-new 1.3.665 → 1.3.666

package/dist/URDFLoader-PUxvYFDe.js

@@ -0,0 +1,2304 @@
+import { S as Ln } from "./MTLLoader-DI0avKtj.js";
+import { b7 as vn, az as Rn, R as lt, an as At, U as In, V as pe, n as he, aJ as dt, S as Mn, aw as Tt, C as ut, p as Le, aQ as ft, b8 as Sn, k as ve, aZ as Se, c as me, ap as On, l as Gn, a4 as Fn, P as ht, aO as Pn, i as qn, ar as jn, j as Un, D as zn, s as pt, at as Et, aW as mt, aY as Hn, u as Bn, Y as we, aR as Dn, a2 as bt, aL as Vn, h as Ce, w as Jn, aM as Wn, aP as Kn, aF as Oe, aH as gt, b9 as Yn, ba as Xn, bb as yt, bc as $n, bd as Zn, be as Qn, bf as ei, a0 as ti, bg as ni, bh as ii, E as si } from "./index.vue_vue_type_style_index_0_scoped_39e1db95_lang-CG9X8aa2.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(f) {
+      switch (f.image_type) {
+        // check indexed type
+        case Ae:
+        case ee:
+          if (f.colormap_length > 256 || f.colormap_size !== 24 || f.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 ye:
+          if (f.colormap_type)
+            throw new Error("THREE.TGALoader: Invalid type colormap data for colormap type.");
+          break;
+        // What the need of a file without data ?
+        case Ne:
+          throw new Error("THREE.TGALoader: No data.");
+        // Invalid type ?
+        default:
+          throw new Error("THREE.TGALoader: Invalid type " + f.image_type);
+      }
+      if (f.width <= 0 || f.height <= 0)
+        throw new Error("THREE.TGALoader: Invalid image size.");
+      if (f.pixel_size !== 8 && f.pixel_size !== 16 && f.pixel_size !== 24 && f.pixel_size !== 32)
+        throw new Error("THREE.TGALoader: Invalid pixel size " + f.pixel_size);
+    }
+    function R(f, K, V, H, X) {
+      let j, B;
+      const v = V.pixel_size >> 3, _ = V.width * V.height * v;
+      if (K && (B = X.subarray(H, H += V.colormap_length * (V.colormap_size >> 3))), f) {
+        j = new Uint8Array(_);
+        let A, h, T, J = 0;
+        const le = new Uint8Array(v);
+        for (; J < _; )
+          if (A = X[H++], h = (A & 127) + 1, A & 128) {
+            for (T = 0; T < v; ++T)
+              le[T] = X[H++];
+            for (T = 0; T < h; ++T)
+              j.set(le, J + T * v);
+            J += v * h;
+          } else {
+            for (h *= v, T = 0; T < h; ++T)
+              j[J + T] = X[H++];
+            J += h;
+          }
+      } else
+        j = X.subarray(
+          H,
+          H += K ? V.width * V.height : _
+        );
+      return {
+        pixel_data: j,
+        palettes: B
+      };
+    }
+    function se(f, K, V, H, X, j, B, v, _) {
+      const A = _;
+      let h, T = 0, J, le;
+      const Te = L.width;
+      for (le = K; le !== H; le += V)
+        for (J = X; J !== B; J += j, T++)
+          h = v[T], f[(J + Te * le) * 4 + 3] = 255, f[(J + Te * le) * 4 + 2] = A[h * 3 + 0], f[(J + Te * le) * 4 + 1] = A[h * 3 + 1], f[(J + Te * le) * 4 + 0] = A[h * 3 + 2];
+      return f;
+    }
+    function C(f, K, V, H, X, j, B, v) {
+      let _, A = 0, h, T;
+      const J = L.width;
+      for (T = K; T !== H; T += V)
+        for (h = X; h !== B; h += j, A += 2)
+          _ = v[A + 0] + (v[A + 1] << 8), f[(h + J * T) * 4 + 0] = (_ & 31744) >> 7, f[(h + J * T) * 4 + 1] = (_ & 992) >> 2, f[(h + J * T) * 4 + 2] = (_ & 31) << 3, f[(h + J * T) * 4 + 3] = _ & 32768 ? 0 : 255;
+      return f;
+    }
+    function oe(f, K, V, H, X, j, B, v) {
+      let _ = 0, A, h;
+      const T = L.width;
+      for (h = K; h !== H; h += V)
+        for (A = X; A !== B; A += j, _ += 3)
+          f[(A + T * h) * 4 + 3] = 255, f[(A + T * h) * 4 + 2] = v[_ + 0], f[(A + T * h) * 4 + 1] = v[_ + 1], f[(A + T * h) * 4 + 0] = v[_ + 2];
+      return f;
+    }
+    function I(f, K, V, H, X, j, B, v) {
+      let _ = 0, A, h;
+      const T = L.width;
+      for (h = K; h !== H; h += V)
+        for (A = X; A !== B; A += j, _ += 4)
+          f[(A + T * h) * 4 + 2] = v[_ + 0], f[(A + T * h) * 4 + 1] = v[_ + 1], f[(A + T * h) * 4 + 0] = v[_ + 2], f[(A + T * h) * 4 + 3] = v[_ + 3];
+      return f;
+    }
+    function Y(f, K, V, H, X, j, B, v) {
+      let _, A = 0, h, T;
+      const J = L.width;
+      for (T = K; T !== H; T += V)
+        for (h = X; h !== B; h += j, A++)
+          _ = v[A], f[(h + J * T) * 4 + 0] = _, f[(h + J * T) * 4 + 1] = _, f[(h + J * T) * 4 + 2] = _, f[(h + J * T) * 4 + 3] = 255;
+      return f;
+    }
+    function ne(f, K, V, H, X, j, B, v) {
+      let _ = 0, A, h;
+      const T = L.width;
+      for (h = K; h !== H; h += V)
+        for (A = X; A !== B; A += j, _ += 2)
+          f[(A + T * h) * 4 + 0] = v[_ + 0], f[(A + T * h) * 4 + 1] = v[_ + 0], f[(A + T * h) * 4 + 2] = v[_ + 0], f[(A + T * h) * 4 + 3] = v[_ + 1];
+      return f;
+    }
+    function ke(f, K, V, H, X) {
+      let j, B, v, _, A, h;
+      switch ((L.flags & M) >> P) {
+        default:
+        case D:
+          j = 0, v = 1, A = K, B = 0, _ = 1, h = V;
+          break;
+        case U:
+          j = 0, v = 1, A = K, B = V - 1, _ = -1, h = -1;
+          break;
+        case S:
+          j = K - 1, v = -1, A = -1, B = 0, _ = 1, h = V;
+          break;
+        case b:
+          j = K - 1, v = -1, A = -1, B = V - 1, _ = -1, h = -1;
+          break;
+      }
+      if (q)
+        switch (L.pixel_size) {
+          case 8:
+            Y(f, B, _, h, j, v, A, H);
+            break;
+          case 16:
+            ne(f, B, _, h, j, v, A, H);
+            break;
+          default:
+            throw new Error("THREE.TGALoader: Format not supported.");
+        }
+      else
+        switch (L.pixel_size) {
+          case 8:
+            se(f, B, _, h, j, v, A, H, X);
+            break;
+          case 16:
+            C(f, B, _, h, j, v, A, H);
+            break;
+          case 24:
+            oe(f, B, _, h, j, v, A, H);
+            break;
+          case 32:
+            I(f, B, _, h, j, v, A, H);
+            break;
+          default:
+            throw new Error("THREE.TGALoader: Format not supported.");
+        }
+      return f;
+    }
+    const Ne = 0, Ae = 1, $ = 2, ie = 3, ee = 9, be = 10, ye = 11, M = 48, P = 4, U = 0, b = 1, D = 2, S = 3;
+    if (O.length < 19) throw new Error("THREE.TGALoader: Not enough data to contain header.");
+    let p = 0;
+    const d = new Uint8Array(O), L = {
+      id_length: d[p++],
+      colormap_type: d[p++],
+      image_type: d[p++],
+      colormap_index: d[p++] | d[p++] << 8,
+      colormap_length: d[p++] | d[p++] << 8,
+      colormap_size: d[p++],
+      origin: [
+        d[p++] | d[p++] << 8,
+        d[p++] | d[p++] << 8
+      ],
+      width: d[p++] | d[p++] << 8,
+      height: d[p++] | d[p++] << 8,
+      pixel_size: d[p++],
+      flags: d[p++]
+    };
+    if (Q(L), L.id_length + p > O.length)
+      throw new Error("THREE.TGALoader: No data.");
+    p += L.id_length;
+    let x = !1, k = !1, q = !1;
+    switch (L.image_type) {
+      case ee:
+        x = !0, k = !0;
+        break;
+      case Ae:
+        k = !0;
+        break;
+      case be:
+        x = !0;
+        break;
+      case $:
+        break;
+      case ye:
+        x = !0, q = !0;
+        break;
+      case ie:
+        q = !0;
+        break;
+    }
+    const ae = new Uint8Array(L.width * L.height * 4), te = R(x, k, L, p, d);
+    return ke(ae, L.width, L.height, te.pixel_data, te.palettes), {
+      data: ae,
+      width: L.width,
+      height: L.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 C = this, oe = C.path === "" ? At.extractUrlBase(O) : C.path, I = new In(C.manager);
+    I.setPath(C.path), I.setRequestHeader(C.requestHeader), I.setWithCredentials(C.withCredentials), I.load(O, function(Y) {
+      try {
+        Q(C.parse(Y, oe));
+      } catch (ne) {
+        se ? se(ne) : console.error(ne), C.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 C(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 ke(t) {
+      return {
+        unit: Ne(R(t, "unit")[0]),
+        upAxis: Ae(R(t, "up_axis")[0])
+      };
+    }
+    function Ne(t) {
+      return t !== void 0 && t.hasAttribute("meter") === !0 ? parseFloat(t.getAttribute("meter")) : 1;
+    }
+    function Ae(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] = ye(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 && (E.animations[t.getAttribute("id") || Le.generateUUID()] = e);
+    }
+    function ye(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, u = o.indexOf(".") !== -1;
+      if (u)
+        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 = u, 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], u = n[r.sampler], c = u.inputs.INPUT, l = u.inputs.OUTPUT, y = s[c], a = s[l], g = b(r, y, a);
+          L(g, e);
+        }
+      return e;
+    }
+    function U(t) {
+      return ee(E.animations[t], P);
+    }
+    function b(t, e, i) {
+      const n = E.nodes[t.id], s = xe(n.id), o = n.transforms[t.sid], r = n.matrix.clone().transpose();
+      let u, c, l, y, a, g;
+      const m = {};
+      switch (o) {
+        case "matrix":
+          for (l = 0, y = e.array.length; l < y; l++)
+            if (u = e.array[l], c = l * i.stride, m[u] === void 0 && (m[u] = {}), t.arraySyntax === !0) {
+              const W = i.array[c], z = t.indices[0] + 4 * t.indices[1];
+              m[u][z] = W;
+            } else
+              for (a = 0, g = i.stride; a < g; a++)
+                m[u][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 N = D(m, r);
+      return {
+        name: s.uuid,
+        keyframes: N
+      };
+    }
+    function D(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++)
+        x(i, s, e.elements[s]);
+      return i;
+      function n(s, o) {
+        return s.time - o.time;
+      }
+    }
+    const S = new pe(), p = new pe(), d = new Et();
+    function L(t, e) {
+      const i = t.keyframes, n = t.name, s = [], o = [], r = [], u = [];
+      for (let c = 0, l = i.length; c < l; c++) {
+        const y = i[c], a = y.time, g = y.value;
+        ce.fromArray(g).transpose(), ce.decompose(S, d, p), s.push(a), o.push(S.x, S.y, S.z), r.push(d.x, d.y, d.z, d.w), u.push(p.x, p.y, p.z);
+      }
+      return o.length > 0 && e.push(new mt(n + ".position", s, o)), r.length > 0 && e.push(new Hn(n + ".quaternion", s, r)), u.length > 0 && e.push(new mt(n + ".scale", s, u)), e;
+    }
+    function x(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 = q(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 q(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 f(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;
+          }
+      }
+      E.clips[t.getAttribute("id")] = e;
+    }
+    function K(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 u = U(s[o]);
+        for (let c = 0, l = u.length; c < l; c++)
+          e.push(u[c]);
+      }
+      return new ft(i, n, e);
+    }
+    function V(t) {
+      return ee(E.clips[t], K);
+    }
+    function H(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;
+          }
+      }
+      E.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 = C(s.textContent);
+              break;
+            case "source":
+              const o = s.getAttribute("id");
+              e.sources[o] = Ge(s);
+              break;
+            case "joints":
+              e.joints = j(s);
+              break;
+            case "vertex_weights":
+              e.vertexWeights = B(s);
+              break;
+          }
+      }
+      return e;
+    }
+    function j(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 B(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")), u = parseInt(s.getAttribute("offset"));
+              e.inputs[o] = { id: r, offset: u };
+              break;
+            case "vcount":
+              e.vcount = oe(s.textContent);
+              break;
+            case "v":
+              e.v = oe(s.textContent);
+              break;
+          }
+      }
+      return e;
+    }
+    function v(t) {
+      const e = {
+        id: t.id
+      }, i = E.geometries[e.id];
+      return t.skin !== void 0 && (e.skin = _(t.skin), i.sources.skinIndices = e.skin.indices, i.sources.skinWeights = e.skin.weights), e;
+    }
+    function _(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, u = s.inputs.JOINT.offset, c = s.inputs.WEIGHT.offset, l = t.sources[t.joints.inputs.JOINT], y = t.sources[t.joints.inputs.INV_BIND_MATRIX], a = n[s.inputs.WEIGHT.id].array;
+      let g = 0, m, N, w;
+      for (m = 0, w = o.length; m < w; m++) {
+        const z = o[m], G = [];
+        for (N = 0; N < z; N++) {
+          const F = r[g + u], fe = r[g + c], re = a[fe];
+          G.push({ index: F, weight: re }), g += 2;
+        }
+        for (G.sort(W), N = 0; N < 4; N++) {
+          const F = G[N];
+          F !== void 0 ? (i.indices.array.push(F.index), i.weights.array.push(F.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(), m = 0, w = l.array.length; m < w; m++) {
+        const z = l.array[m], G = new he().fromArray(y.array, m * y.stride).transpose();
+        i.joints.push({ name: z, boneInverse: G });
+      }
+      return i;
+      function W(z, G) {
+        return G.weight - z.weight;
+      }
+    }
+    function A(t) {
+      return ee(E.controllers[t], v);
+    }
+    function h(t) {
+      const e = {
+        init_from: R(t, "init_from")[0].textContent
+      };
+      E.images[t.getAttribute("id")] = e;
+    }
+    function T(t) {
+      return t.build !== void 0 ? t.build : t.init_from;
+    }
+    function J(t) {
+      const e = E.images[t];
+      return e !== void 0 ? ee(e, T) : (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 = Te(s);
+              break;
+          }
+      }
+      E.effects[t.getAttribute("id")] = e;
+    }
+    function Te(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 = He(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 = He(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] = Ue(s);
+              break;
+            case "transparent":
+              e[s.nodeName] = {
+                opaque: s.hasAttribute("opaque") ? s.getAttribute("opaque") : "A_ONE",
+                data: Ue(s)
+              };
+              break;
+          }
+      }
+      return e;
+    }
+    function Ue(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] = C(s.textContent);
+              break;
+            case "float":
+              e[s.nodeName] = parseFloat(s.textContent);
+              break;
+            case "texture":
+              e[s.nodeName] = { id: s.getAttribute("texture"), extra: ze(s) };
+              break;
+          }
+      }
+      return e;
+    }
+    function ze(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] = Be(s);
+              break;
+          }
+      }
+    }
+    function He(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] = Be(s);
+              break;
+          }
+      }
+      return e;
+    }
+    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 "texture":
+              e[s.nodeName] = { id: s.getAttribute("texture"), texcoord: s.getAttribute("texcoord"), extra: ze(s) };
+              break;
+          }
+      }
+      return e;
+    }
+    function De(t) {
+      return t;
+    }
+    function St(t) {
+      return ee(E.effects[t], De);
+    }
+    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;
+          }
+      }
+      E.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 = qe;
+          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 y = e.profile.samplers[c.id];
+        let a = null;
+        if (y !== void 0) {
+          const g = e.profile.surfaces[y.source];
+          a = J(g.init_from);
+        } else
+          console.warn("THREE.ColladaLoader: Undefined sampler. Access image directly (see #12530)."), a = J(c.id);
+        if (a !== null) {
+          const g = Gt(a);
+          if (g !== void 0) {
+            const m = g.load(a), N = c.extra;
+            if (N !== void 0 && N.technique !== void 0 && ne(N.technique) === !1) {
+              const w = N.technique;
+              m.wrapS = w.wrapU ? Oe : gt, m.wrapT = w.wrapV ? Oe : gt, m.offset.set(w.offsetU || 0, w.offsetV || 0), m.repeat.set(w.repeatU || 1, w.repeatV || 1);
+            } else
+              m.wrapS = Oe, m.wrapT = Oe;
+            return l !== null && (m.colorSpace = l), m;
+          } 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, u = o.transparency;
+      if (u === void 0 && r && (u = {
+        float: 1
+      }), r === void 0 && u && (r = {
+        opaque: "A_ONE",
+        data: {
+          color: [1, 1, 1, 1]
+        }
+      }), r && u)
+        if (r.data.texture)
+          n.transparent = !0;
+        else {
+          const c = r.data.color;
+          switch (r.opaque) {
+            case "A_ONE":
+              n.opacity = c[3] * u.float;
+              break;
+            case "RGB_ZERO":
+              n.opacity = 1 - c[0] * u.float;
+              break;
+            case "A_ZERO":
+              n.opacity = 1 - c[3] * u.float;
+              break;
+            case "RGB_ONE":
+              n.opacity = c[0] * u.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 y = c[l];
+          switch (l) {
+            case "double_sided":
+              n.side = y === 1 ? Gn : Fn;
+              break;
+            case "bump":
+              n.normalMap = s(y.texture), n.normalScale = new On(1, 1);
+              break;
+          }
+        }
+      }
+      return n;
+    }
+    function Ft(t) {
+      return ee(E.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 = qt(s);
+              break;
+          }
+      }
+      E.cameras[t.getAttribute("id")] = e;
+    }
+    function qt(t) {
+      for (let e = 0; e < t.childNodes.length; e++) {
+        const i = t.childNodes[e];
+        switch (i.nodeName) {
+          case "technique_common":
+            return jt(i);
+        }
+      }
+      return {};
+    }
+    function jt(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 = Ut(n);
+            break;
+        }
+      }
+      return e;
+    }
+    function Ut(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 zt(t) {
+      const e = E.cameras[t];
+      return e !== void 0 ? ee(e, Je) : (console.warn("THREE.ColladaLoader: Couldn't find camera with ID:", t), null);
+    }
+    function Ht(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 = Bt(s);
+              break;
+          }
+      }
+      E.lights[t.getAttribute("id")] = e;
+    }
+    function Bt(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 = Dt(s);
+          }
+      }
+      return 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 "color":
+              const o = C(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 We(t) {
+      let e;
+      switch (t.technique) {
+        case "directional":
+          e = new zn();
+          break;
+        case "point":
+          e = new Un();
+          break;
+        case "spot":
+          e = new jn();
+          break;
+        case "ambient":
+          e = new qn();
+          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 = E.lights[t];
+      return e !== void 0 ? ee(e, We) : (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 = Wt(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(Kt(s));
+              break;
+            default:
+              console.log(s);
+          }
+        }
+        E.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 = C(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 Wt(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 Kt(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"), u = parseInt(s.getAttribute("offset")), c = parseInt(s.getAttribute("set")), l = c > 0 ? r + c : r;
+              e.inputs[l] = { id: o, offset: u }, e.stride = Math.max(e.stride, u + 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 Ke(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 u = o[r];
+        Xt(u), e[r] = $t(u, i, n);
+      }
+      return e;
+    }
+    function $t(t, e, i) {
+      const n = {}, s = { array: [], stride: 0 }, o = { array: [], stride: 0 }, r = { array: [], stride: 0 }, u = { array: [], stride: 0 }, c = { array: [], stride: 0 }, l = { array: [], stride: 4 }, y = { array: [], stride: 4 }, a = new Bn(), g = [];
+      let m = 0;
+      for (let N = 0; N < t.length; N++) {
+        const w = t[N], W = w.inputs;
+        let z = 0;
+        switch (w.type) {
+          case "lines":
+          case "linestrips":
+            z = w.count * 2;
+            break;
+          case "triangles":
+            z = w.count * 3;
+            break;
+          case "polylist":
+            for (let G = 0; G < w.count; G++) {
+              const F = w.vcount[G];
+              switch (F) {
+                case 3:
+                  z += 3;
+                  break;
+                case 4:
+                  z += 6;
+                  break;
+                default:
+                  z += (F - 2) * 3;
+                  break;
+              }
+            }
+            break;
+          default:
+            console.warn("THREE.ColladaLoader: Unknown primitive type:", w.type);
+        }
+        a.addGroup(m, z, N), m += z, w.material && g.push(w.material);
+        for (const G in W) {
+          const F = W[G];
+          switch (G) {
+            case "VERTEX":
+              for (const fe in i) {
+                const re = i[fe];
+                switch (fe) {
+                  case "POSITION":
+                    const _e = s.array.length;
+                    if (de(w, e[re], F.offset, s.array), s.stride = e[re].stride, e.skinWeights && e.skinIndices && (de(w, e.skinIndices, F.offset, l.array), de(w, e.skinWeights, F.offset, y.array)), w.hasUV === !1 && t.uvsNeedsFix === !0) {
+                      const Cn = (s.array.length - _e) / s.stride;
+                      for (let ct = 0; ct < Cn; ct++)
+                        r.array.push(0, 0);
+                    }
+                    break;
+                  case "NORMAL":
+                    de(w, e[re], F.offset, o.array), o.stride = e[re].stride;
+                    break;
+                  case "COLOR":
+                    de(w, e[re], F.offset, c.array), c.stride = e[re].stride;
+                    break;
+                  case "TEXCOORD":
+                    de(w, e[re], F.offset, r.array), r.stride = e[re].stride;
+                    break;
+                  case "TEXCOORD1":
+                    de(w, e[re], F.offset, u.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(w, e[F.id], F.offset, o.array), o.stride = e[F.id].stride;
+              break;
+            case "COLOR":
+              de(w, e[F.id], F.offset, c.array, !0), c.stride = e[F.id].stride;
+              break;
+            case "TEXCOORD":
+              de(w, e[F.id], F.offset, r.array), r.stride = e[F.id].stride;
+              break;
+            case "TEXCOORD1":
+              de(w, e[F.id], F.offset, u.array), u.stride = e[F.id].stride;
+              break;
+          }
+        }
+      }
+      return s.array.length > 0 && a.setAttribute("position", new we(s.array, s.stride)), o.array.length > 0 && a.setAttribute("normal", new we(o.array, o.stride)), c.array.length > 0 && a.setAttribute("color", new we(c.array, c.stride)), r.array.length > 0 && a.setAttribute("uv", new we(r.array, r.stride)), u.array.length > 0 && a.setAttribute("uv1", new we(u.array, u.stride)), l.array.length > 0 && a.setAttribute("skinIndex", new we(l.array, l.stride)), y.array.length > 0 && a.setAttribute("skinWeight", new we(y.array, y.stride)), n.data = a, n.type = t[0].type, n.materialKeys = g, n;
+    }
+    function de(t, e, i, n, s = !1) {
+      const o = t.p, r = t.stride, u = t.vcount;
+      function c(a) {
+        let g = o[a + i] * y;
+        const m = g + y;
+        for (; g < m; g++)
+          n.push(l[g]);
+        if (s) {
+          const N = n.length - y - 1;
+          Re.setRGB(
+            n[N + 0],
+            n[N + 1],
+            n[N + 2],
+            me
+          ), n[N + 0] = Re.r, n[N + 1] = Re.g, n[N + 2] = Re.b;
+        }
+      }
+      const l = e.array, y = e.stride;
+      if (t.vcount !== void 0) {
+        let a = 0;
+        for (let g = 0, m = u.length; g < m; g++) {
+          const N = u[g];
+          if (N === 4) {
+            const w = a + r * 0, W = a + r * 1, z = a + r * 2, G = a + r * 3;
+            c(w), c(W), c(G), c(W), c(z), c(G);
+          } else if (N === 3) {
+            const w = a + r * 0, W = a + r * 1, z = a + r * 2;
+            c(w), c(W), c(z);
+          } else if (N > 4)
+            for (let w = 1, W = N - 2; w <= W; w++) {
+              const z = a + r * 0, G = a + r * w, F = a + r * (w + 1);
+              c(z), c(G), c(F);
+            }
+          a += r * N;
+        }
+      } else
+        for (let a = 0, g = o.length; a < g; a += r)
+          c(a);
+    }
+    function Ye(t) {
+      return ee(E.geometries[t], Ke);
+    }
+    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;
+          }
+      }
+      E.kinematicsModels[t.getAttribute("id")] = e;
+    }
+    function Qt(t) {
+      return t.build !== void 0 ? t.build : t;
+    }
+    function en(t) {
+      return ee(E.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 = C(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 = C(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;
+          }
+      }
+      E.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 = C(n.textContent);
+              break;
+            case "mass":
+              e.mass = C(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;
+          }
+      }
+      E.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(E.kinematicsScenes[t], un);
+    }
+    function hn() {
+      const t = Object.keys(E.kinematicsModels)[0], e = Object.keys(E.kinematicsScenes)[0], i = Object.keys(E.visualScenes)[0];
+      if (t === void 0 || e === void 0) return;
+      const n = en(t), s = fn(e), o = it(i), r = s.bindJointAxis, u = {};
+      for (let y = 0, a = r.length; y < a; y++) {
+        const g = r[y], m = Z.querySelector('[sid="' + g.target + '"]');
+        if (m) {
+          const N = m.parentElement;
+          c(g.jointIndex, N);
+        }
+      }
+      function c(y, a) {
+        const g = a.getAttribute("name"), m = n.joints[y];
+        o.traverse(function(N) {
+          N.name === g && (u[y] = {
+            object: N,
+            transforms: pn(a),
+            joint: m,
+            position: m.zeroPosition
+          });
+        });
+      }
+      const l = new he();
+      at = {
+        joints: n && n.joints,
+        getJointValue: function(y) {
+          const a = u[y];
+          if (a)
+            return a.position;
+          console.warn("THREE.ColladaLoader: Joint " + y + " doesn't exist.");
+        },
+        setJointValue: function(y, a) {
+          const g = u[y];
+          if (g) {
+            const m = g.joint;
+            if (a > m.limits.max || a < m.limits.min)
+              console.warn("THREE.ColladaLoader: Joint " + y + " value " + a + " outside of limits (min: " + m.limits.min + ", max: " + m.limits.max + ").");
+            else if (m.static)
+              console.warn("THREE.ColladaLoader: Joint " + y + " is static.");
+            else {
+              const N = g.object, w = m.axis, W = g.transforms;
+              ce.identity();
+              for (let z = 0; z < W.length; z++) {
+                const G = W[z];
+                if (G.sid && G.sid.indexOf(y) !== -1)
+                  switch (m.type) {
+                    case "revolute":
+                      ce.multiply(l.makeRotationAxis(w, Le.degToRad(a)));
+                      break;
+                    case "prismatic":
+                      ce.multiply(l.makeTranslation(w.x * a, w.y * a, w.z * a));
+                      break;
+                    default:
+                      console.warn("THREE.ColladaLoader: Unknown joint type: " + m.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;
+                  }
+              }
+              N.matrix.copy(ce), N.matrix.decompose(N.position, N.quaternion, N.scale), u[y].position = a;
+            }
+          } else
+            console.log("THREE.ColladaLoader: " + y + " 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 = C(s.textContent);
+            const u = new he().fromArray(o).transpose();
+            e.push({
+              sid: s.getAttribute("sid"),
+              type: s.nodeName,
+              obj: u
+            });
+            break;
+          case "translate":
+          case "scale":
+            o = C(s.textContent), r = new pe().fromArray(o), e.push({
+              sid: s.getAttribute("sid"),
+              type: s.nodeName,
+              obj: r
+            });
+            break;
+          case "rotate":
+            o = C(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(), Ee = new pe();
+    function Fe(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")), Fe(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 = C(n.textContent), e.matrix.multiply(ce.fromArray(s).transpose()), e.transforms[n.getAttribute("sid")] = n.nodeName;
+            break;
+          case "translate":
+            s = C(n.textContent), Ee.fromArray(s), e.matrix.multiply(ce.makeTranslation(Ee.x, Ee.y, Ee.z)), e.transforms[n.getAttribute("sid")] = n.nodeName;
+            break;
+          case "rotate":
+            s = C(n.textContent);
+            const o = Le.degToRad(s[3]);
+            e.matrix.multiply(ce.makeRotationAxis(Ee.fromArray(s), o)), e.transforms[n.getAttribute("sid")] = n.nodeName;
+            break;
+          case "scale":
+            s = C(n.textContent), e.matrix.scale(Ee.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) : E.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], u = r.getAttribute("symbol"), c = r.getAttribute("target");
+              e.materials[u] = 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 y;
+        if (tt(l))
+          y = xe(l), Qe(y, e, i);
+        else if (Nn(l)) {
+          const g = E.visualScenes[l].children;
+          for (let m = 0; m < g.length; m++) {
+            const N = g[m];
+            if (N.type === "JOINT") {
+              const w = xe(N.id);
+              Qe(w, 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 u = [], c = [];
+      for (s = 0; s < n.length; s++)
+        r = n[s], u.push(r.bone), c.push(r.boneInverse);
+      return new Kn(u, 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, u = t.instanceLights, c = t.instanceGeometries, l = t.instanceNodes;
+      for (let a = 0, g = n.length; a < g; a++)
+        e.push(xe(n[a]));
+      for (let a = 0, g = o.length; a < g; a++) {
+        const m = zt(o[a]);
+        m !== null && e.push(m.clone());
+      }
+      for (let a = 0, g = r.length; a < g; a++) {
+        const m = r[a], N = A(m.id), w = Ye(N.id), W = et(w, m.materials), z = m.skeletons, G = N.skin.joints, F = bn(z, G);
+        for (let fe = 0, re = W.length; fe < re; fe++) {
+          const _e = W[fe];
+          _e.isSkinnedMesh && (_e.bind(F, N.skin.bindMatrix), _e.normalizeSkinWeights()), e.push(_e);
+        }
+      }
+      for (let a = 0, g = u.length; a < g; a++) {
+        const m = Vt(u[a]);
+        m !== null && e.push(m.clone());
+      }
+      for (let a = 0, g = c.length; a < g; a++) {
+        const m = c[a], N = Ye(m.id), w = et(N, m.materials);
+        for (let W = 0, z = w.length; W < z; W++)
+          e.push(w[W]);
+      }
+      for (let a = 0, g = l.length; a < g; a++)
+        e.push(xe(l[a]).clone());
+      let y;
+      if (n.length === 0 && e.length === 1)
+        y = e[0];
+      else {
+        y = s === "JOINT" ? new Dn() : new pt();
+        for (let a = 0; a < e.length; a++)
+          y.add(e[a]);
+      }
+      return y.name = s === "JOINT" ? t.sid : t.name, y.matrix.copy(i), y.matrix.decompose(y.position, y.quaternion, y.scale), y;
+    }
+    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(Ft(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, y = o.length; l < y; l++) {
+            const a = o[l];
+            if (a.isMeshPhongMaterial === !0 || a.isMeshLambertMaterial === !0) {
+              const g = new bt();
+              g.color.copy(a.color), g.opacity = a.opacity, g.transparent = a.transparent, o[l] = g;
+            }
+          }
+        const r = s.data.attributes.skinIndex !== void 0, u = o.length === 1 ? o[0] : o;
+        let c;
+        switch (n) {
+          case "lines":
+            c = new Wn(s.data, u);
+            break;
+          case "linestrips":
+            c = new Jn(s.data, u);
+            break;
+          case "triangles":
+          case "polylist":
+            r ? c = new Vn(s.data, u) : c = new Ce(s.data, u);
+            break;
+        }
+        i.push(c);
+      }
+      return i;
+    }
+    function tt(t) {
+      return E.nodes[t] !== void 0;
+    }
+    function xe(t) {
+      return ee(E.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(Fe(i[n]));
+      E.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(xe(s.id));
+      }
+      return e;
+    }
+    function Nn(t) {
+      return E.visualScenes[t] !== void 0;
+    }
+    function it(t) {
+      return ee(E.visualScenes[t], nt);
+    }
+    function An(t) {
+      const e = R(t, "instance_visual_scene")[0];
+      return it(I(e.getAttribute("url")));
+    }
+    function Tn() {
+      const t = E.clips;
+      if (ne(t) === !0) {
+        if (ne(E.animations) === !1) {
+          const e = [];
+          for (const i in E.animations) {
+            const n = U(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(V(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 = ke(R(Z, "asset")[0]), rt = new Tt(this.manager);
+    rt.setPath(this.resourcePath || Q).setCrossOrigin(this.crossOrigin);
+    let qe;
+    wt && (qe = new wt(this.manager), qe.setPath(this.resourcePath || Q));
+    const Re = new ut(), Ie = [];
+    let at = {}, _n = 0;
+    const E = {
+      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", f), $(Z, "library_controllers", "controller", H), $(Z, "library_images", "image", h), $(Z, "library_effects", "effect", le), $(Z, "library_materials", "material", Ot), $(Z, "library_cameras", "camera", Pt), $(Z, "library_lights", "light", Ht), $(Z, "library_geometries", "geometry", Jt), $(Z, "library_nodes", "node", Fe), $(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(E.animations, P), ie(E.clips, K), ie(E.controllers, v), ie(E.images, T), ie(E.effects, De), ie(E.materials, Ve), ie(E.cameras, Je), ie(E.lights, We), ie(E.geometries, Ke), ie(E.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: E,
+      scene: Me
+    };
+  }
+}
+const je = new Et(), kt = new si();
+function ge(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"), je.setFromEuler(kt), je.multiply(ue.quaternion), ue.quaternion.copy(je);
+}
+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 C = this.manager, oe = At.extractUrlBase(O), I = this.manager.resolveURL(O);
+    C.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), C.itemEnd(I);
+    }).catch((Y) => {
+      se ? se(Y) : console.error("URDFLoader: Error loading file.", Y), C.itemError(I), C.itemEnd(I);
+    });
+  }
+  parse(O, Q = this.workingPath) {
+    const R = this.packages, se = this.loadMeshCb, C = this.parseVisual, oe = this.parseCollision, I = this.manager, Y = {}, ne = {}, ke = {};
+    function Ne(M) {
+      if (!/^package:\/\//.test(M))
+        return Q ? Q + M : M;
+      const [P, U] = M.replace(/^package:\/\//, "").split(/\/(.+)/);
+      if (typeof R == "string")
+        return R.endsWith(P) ? R + "/" + U : R + "/" + P + "/" + U;
+      if (typeof R == "function")
+        return R(P) + "/" + U;
+      if (typeof R == "object")
+        return P in R ? R[P] + "/" + U : (console.error(`URDFLoader : ${P} not found in provided package list.`), null);
+    }
+    function Ae(M) {
+      let P;
+      M instanceof Document ? P = [...M.children] : M instanceof Element ? P = [M] : P = [...new DOMParser().parseFromString(M, "text/xml").children];
+      const U = P.filter((b) => b.nodeName === "robot").pop();
+      return $(U);
+    }
+    function $(M) {
+      const P = [...M.children], U = P.filter((x) => x.nodeName.toLowerCase() === "link"), b = P.filter((x) => x.nodeName.toLowerCase() === "joint"), D = P.filter((x) => x.nodeName.toLowerCase() === "material"), S = new Xn();
+      S.robotName = M.getAttribute("name"), S.urdfRobotNode = M, D.forEach((x) => {
+        const k = x.getAttribute("name");
+        ke[k] = be(x);
+      });
+      const p = {}, d = {};
+      U.forEach((x) => {
+        const k = x.getAttribute("name"), q = M.querySelector(`child[link="${k}"]`) === null;
+        Y[k] = ee(x, p, d, q ? S : null);
+      }), b.forEach((x) => {
+        const k = x.getAttribute("name");
+        ne[k] = ie(x);
+      }), S.joints = ne, S.links = Y, S.colliders = d, S.visual = p;
+      const L = Object.values(ne);
+      return L.forEach((x) => {
+        x instanceof yt && ne[x.mimicJoint].mimicJoints.push(x);
+      }), L.forEach((x) => {
+        const k = /* @__PURE__ */ new Set(), q = (ae) => {
+          if (k.has(ae))
+            throw new Error("URDFLoader: Detected an infinite loop of mimic joints.");
+          k.add(ae), ae.mimicJoints.forEach((te) => {
+            q(te);
+          });
+        };
+        q(x);
+      }), S.frames = {
+        ...d,
+        ...p,
+        ...Y,
+        ...ne
+      }, S;
+    }
+    function ie(M) {
+      const P = [...M.children], U = M.getAttribute("type");
+      let b;
+      const D = P.find((k) => k.nodeName.toLowerCase() === "mimic");
+      D ? (b = new yt(), b.mimicJoint = D.getAttribute("joint"), b.multiplier = parseFloat(D.getAttribute("multiplier") || 1), b.offset = parseFloat(D.getAttribute("offset") || 0)) : b = new $n(), b.urdfNode = M, b.name = M.getAttribute("name"), b.urdfName = b.name, b.jointType = U;
+      let S = null, p = null, d = [0, 0, 0], L = [0, 0, 0];
+      P.forEach((k) => {
+        const q = k.nodeName.toLowerCase();
+        q === "origin" ? (d = ge(k.getAttribute("xyz")), L = ge(k.getAttribute("rpy"))) : q === "child" ? p = Y[k.getAttribute("link")] : q === "parent" ? S = Y[k.getAttribute("link")] : q === "limit" && (b.limit.lower = parseFloat(k.getAttribute("lower") || b.limit.lower), b.limit.upper = parseFloat(k.getAttribute("upper") || b.limit.upper), b.limit.effort = parseFloat(k.getAttribute("effort") || b.limit.effort), b.limit.velocity = parseFloat(k.getAttribute("velocity") || b.limit.velocity));
+      }), S.add(b), b.add(p), Nt(b, L), b.position.set(d[0], d[1], d[2]);
+      const x = P.filter((k) => k.nodeName.toLowerCase() === "axis")[0];
+      if (x) {
+        const k = x.getAttribute("xyz").split(/\s+/g).map((q) => parseFloat(q));
+        b.axis = new pe(k[0], k[1], k[2]), b.axis.normalize();
+      }
+      return b;
+    }
+    function ee(M, P, U, b = null) {
+      b === null && (b = new Zn());
+      const D = [...M.children];
+      b.name = M.getAttribute("name"), b.urdfName = b.name, b.urdfNode = M;
+      const S = D.find((p) => p.nodeName.toLowerCase() === "inertial");
+      return S && [...S.children].forEach((p) => {
+        const d = p.nodeName.toLowerCase();
+        d === "origin" ? (b.inertial.origin.xyz = ge(p.getAttribute("xyz")), b.inertial.origin.rpy = ge(p.getAttribute("rpy"))) : d === "mass" ? b.inertial.mass = parseFloat(p.getAttribute("value")) || 0 : d === "inertia" && (b.inertial.inertia.ixx = parseFloat(p.getAttribute("ixx")) || 0, b.inertial.inertia.ixy = parseFloat(p.getAttribute("ixy")) || 0, b.inertial.inertia.ixz = parseFloat(p.getAttribute("ixz")) || 0, b.inertial.inertia.iyy = parseFloat(p.getAttribute("iyy")) || 0, b.inertial.inertia.iyz = parseFloat(p.getAttribute("iyz")) || 0, b.inertial.inertia.izz = parseFloat(p.getAttribute("izz")) || 0);
+      }), C && D.filter((d) => d.nodeName.toLowerCase() === "visual").forEach((d) => {
+        const L = ye(d, ke);
+        if (b.add(L), d.hasAttribute("name")) {
+          const x = d.getAttribute("name");
+          L.name = x, L.urdfName = x, P[x] = L;
+        }
+      }), oe && D.filter((d) => d.nodeName.toLowerCase() === "collision").forEach((d) => {
+        const L = ye(d);
+        if (b.add(L), d.hasAttribute("name")) {
+          const x = d.getAttribute("name");
+          L.name = x, L.urdfName = x, U[x] = L;
+        }
+      }), b;
+    }
+    function be(M) {
+      const P = [...M.children], U = new ve();
+      return U.name = M.getAttribute("name") || "", P.forEach((b) => {
+        const D = b.nodeName.toLowerCase();
+        if (D === "color") {
+          const S = b.getAttribute("rgba").split(/\s/g).map((p) => parseFloat(p));
+          U.color.setRGB(S[0], S[1], S[2]), U.opacity = S[3], U.transparent = S[3] < 1, U.depthWrite = !U.transparent;
+        } else if (D === "texture") {
+          const S = b.getAttribute("filename");
+          if (S) {
+            const p = new Tt(I), d = Ne(S);
+            U.map = p.load(d), U.map.colorSpace = me;
+          }
+        }
+      }), U;
+    }
+    function ye(M, P = {}) {
+      const U = M.nodeName.toLowerCase() === "collision", b = [...M.children];
+      let D = null;
+      const S = b.filter((d) => d.nodeName.toLowerCase() === "material")[0];
+      if (S) {
+        const d = S.getAttribute("name");
+        d && d in P ? D = P[d] : D = be(S);
+      } else
+        D = new ve();
+      const p = U ? new Qn() : new ei();
+      return p.urdfNode = M, b.forEach((d) => {
+        const L = d.nodeName.toLowerCase();
+        if (L === "geometry") {
+          const x = d.children[0].nodeName.toLowerCase();
+          if (x === "mesh") {
+            const k = d.children[0].getAttribute("filename"), q = Ne(k);
+            if (q !== null) {
+              const ae = d.children[0].getAttribute("scale");
+              if (ae) {
+                const te = ge(ae);
+                p.scale.set(te[0], te[1], te[2]);
+              }
+              se(q, I, (te, f) => {
+                f ? console.error("URDFLoader: Error loading mesh.", f) : te && (te instanceof Ce && (te.material = D), te.position.set(0, 0, 0), te.quaternion.identity(), p.add(te));
+              });
+            }
+          } else if (x === "box") {
+            const k = new Ce();
+            k.geometry = new ti(1, 1, 1), k.material = D;
+            const q = ge(d.children[0].getAttribute("size"));
+            k.scale.set(q[0], q[1], q[2]), p.add(k);
+          } else if (x === "sphere") {
+            const k = new Ce();
+            k.geometry = new ni(1, 30, 30), k.material = D;
+            const q = parseFloat(d.children[0].getAttribute("radius")) || 0;
+            k.scale.set(q, q, q), p.add(k);
+          } else if (x === "cylinder") {
+            const k = new Ce();
+            k.geometry = new ii(1, 1, 1, 30), k.material = D;
+            const q = parseFloat(d.children[0].getAttribute("radius")) || 0, ae = parseFloat(d.children[0].getAttribute("length")) || 0;
+            k.scale.set(q, ae, q), k.rotation.set(Math.PI / 2, 0, 0), p.add(k);
+          }
+        } else if (L === "origin") {
+          const x = ge(d.getAttribute("xyz")), k = ge(d.getAttribute("rpy"));
+          p.position.set(x[0], x[1], x[2]), p.rotation.set(0, 0, 0), Nt(p, k);
+        }
+      }), p;
+    }
+    return Ae(O);
+  }
+  // Default mesh loading function
+  defaultMeshLoader(O, Q, R) {
+    /\.stl$/i.test(O) ? new Ln(Q).load(O, (C) => {
+      const oe = new Ce(C, new ve());
+      R(oe);
+    }, null, (C) => R(null, C)) : /\.dae$/i.test(O) ? new oi(Q).load(O, (C) => R(C.scene), null, (C) => R(null, C)) : console.warn(`URDFLoader: Could not load model at ${O}.
+No loader available`);
+  }
+}
+export {
+  ci as U
+};