@realsee/dnalogel 2.1.0-alpha.9 → 2.1.0

package/libs/Object3DHelperPlugin/mocks/addObject3D.js

@@ -1,22 +1,1377 @@
-import * as THREE from 'three';
-import { GLTFLoader } from '@realsee/five/gltf-loader';
-export default function addObject3D(item, scene) {
-    const modelPosition = new THREE.Vector3(3.8058113175002797, -1.4285810796152072, -4.748098691966687);
-    const modelUrl = item.modelUrl;
-    const gltfLoader = new GLTFLoader();
-    return new Promise((res, rej) => {
-        gltfLoader.load(modelUrl, function onLoad(gltf) {
-            const model = gltf.scene;
-            model.traverse((obj) => {
-                if (obj.material) {
-                    obj.material.envMapIntensity = 0.5;
+import * as je from "three";
+import Be from "three";
+var De = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {}, Te = {}, Ie = { exports: {} };
+(function(y) {
+  var M, l, S, R, O, N, B, U, C, E, K, V, I, z, Z, q, W, te, re, he, le, ce, ue, Q, ae;
+  (function(D) {
+    var se = typeof De == "object" ? De : typeof self == "object" ? self : typeof this == "object" ? this : {};
+    D(ne(se, ne(y.exports)));
+    function ne(s, c) {
+      return s !== se && (typeof Object.create == "function" ? Object.defineProperty(s, "__esModule", { value: !0 }) : s.__esModule = !0), function(p, m) {
+        return s[p] = c ? c(p, m) : m;
+      };
+    }
+  })(function(D) {
+    var se = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(s, c) {
+      s.__proto__ = c;
+    } || function(s, c) {
+      for (var p in c)
+        Object.prototype.hasOwnProperty.call(c, p) && (s[p] = c[p]);
+    };
+    M = function(s, c) {
+      if (typeof c != "function" && c !== null)
+        throw new TypeError("Class extends value " + String(c) + " is not a constructor or null");
+      se(s, c);
+      function p() {
+        this.constructor = s;
+      }
+      s.prototype = c === null ? Object.create(c) : (p.prototype = c.prototype, new p());
+    }, l = Object.assign || function(s) {
+      for (var c, p = 1, m = arguments.length; p < m; p++) {
+        c = arguments[p];
+        for (var T in c)
+          Object.prototype.hasOwnProperty.call(c, T) && (s[T] = c[T]);
+      }
+      return s;
+    }, S = function(s, c) {
+      var p = {};
+      for (var m in s)
+        Object.prototype.hasOwnProperty.call(s, m) && c.indexOf(m) < 0 && (p[m] = s[m]);
+      if (s != null && typeof Object.getOwnPropertySymbols == "function")
+        for (var T = 0, m = Object.getOwnPropertySymbols(s); T < m.length; T++)
+          c.indexOf(m[T]) < 0 && Object.prototype.propertyIsEnumerable.call(s, m[T]) && (p[m[T]] = s[m[T]]);
+      return p;
+    }, R = function(s, c, p, m) {
+      var T = arguments.length, g = T < 3 ? c : m === null ? m = Object.getOwnPropertyDescriptor(c, p) : m, x;
+      if (typeof Reflect == "object" && typeof Reflect.decorate == "function")
+        g = Reflect.decorate(s, c, p, m);
+      else
+        for (var H = s.length - 1; H >= 0; H--)
+          (x = s[H]) && (g = (T < 3 ? x(g) : T > 3 ? x(c, p, g) : x(c, p)) || g);
+      return T > 3 && g && Object.defineProperty(c, p, g), g;
+    }, O = function(s, c) {
+      return function(p, m) {
+        c(p, m, s);
+      };
+    }, N = function(s, c) {
+      if (typeof Reflect == "object" && typeof Reflect.metadata == "function")
+        return Reflect.metadata(s, c);
+    }, B = function(s, c, p, m) {
+      function T(g) {
+        return g instanceof p ? g : new p(function(x) {
+          x(g);
+        });
+      }
+      return new (p || (p = Promise))(function(g, x) {
+        function H($) {
+          try {
+            P(m.next($));
+          } catch (G) {
+            x(G);
+          }
+        }
+        function Y($) {
+          try {
+            P(m.throw($));
+          } catch (G) {
+            x(G);
+          }
+        }
+        function P($) {
+          $.done ? g($.value) : T($.value).then(H, Y);
+        }
+        P((m = m.apply(s, c || [])).next());
+      });
+    }, U = function(s, c) {
+      var p = { label: 0, sent: function() {
+        if (g[0] & 1)
+          throw g[1];
+        return g[1];
+      }, trys: [], ops: [] }, m, T, g, x;
+      return x = { next: H(0), throw: H(1), return: H(2) }, typeof Symbol == "function" && (x[Symbol.iterator] = function() {
+        return this;
+      }), x;
+      function H(P) {
+        return function($) {
+          return Y([P, $]);
+        };
+      }
+      function Y(P) {
+        if (m)
+          throw new TypeError("Generator is already executing.");
+        for (; p; )
+          try {
+            if (m = 1, T && (g = P[0] & 2 ? T.return : P[0] ? T.throw || ((g = T.return) && g.call(T), 0) : T.next) && !(g = g.call(T, P[1])).done)
+              return g;
+            switch (T = 0, g && (P = [P[0] & 2, g.value]), P[0]) {
+              case 0:
+              case 1:
+                g = P;
+                break;
+              case 4:
+                return p.label++, { value: P[1], done: !1 };
+              case 5:
+                p.label++, T = P[1], P = [0];
+                continue;
+              case 7:
+                P = p.ops.pop(), p.trys.pop();
+                continue;
+              default:
+                if (g = p.trys, !(g = g.length > 0 && g[g.length - 1]) && (P[0] === 6 || P[0] === 2)) {
+                  p = 0;
+                  continue;
+                }
+                if (P[0] === 3 && (!g || P[1] > g[0] && P[1] < g[3])) {
+                  p.label = P[1];
+                  break;
+                }
+                if (P[0] === 6 && p.label < g[1]) {
+                  p.label = g[1], g = P;
+                  break;
+                }
+                if (g && p.label < g[2]) {
+                  p.label = g[2], p.ops.push(P);
+                  break;
+                }
+                g[2] && p.ops.pop(), p.trys.pop();
+                continue;
+            }
+            P = c.call(s, p);
+          } catch ($) {
+            P = [6, $], T = 0;
+          } finally {
+            m = g = 0;
+          }
+        if (P[0] & 5)
+          throw P[1];
+        return { value: P[0] ? P[1] : void 0, done: !0 };
+      }
+    }, C = function(s, c) {
+      for (var p in s)
+        p !== "default" && !Object.prototype.hasOwnProperty.call(c, p) && ae(c, s, p);
+    }, ae = Object.create ? function(s, c, p, m) {
+      m === void 0 && (m = p);
+      var T = Object.getOwnPropertyDescriptor(c, p);
+      (!T || ("get" in T ? !c.__esModule : T.writable || T.configurable)) && (T = { enumerable: !0, get: function() {
+        return c[p];
+      } }), Object.defineProperty(s, m, T);
+    } : function(s, c, p, m) {
+      m === void 0 && (m = p), s[m] = c[p];
+    }, E = function(s) {
+      var c = typeof Symbol == "function" && Symbol.iterator, p = c && s[c], m = 0;
+      if (p)
+        return p.call(s);
+      if (s && typeof s.length == "number")
+        return {
+          next: function() {
+            return s && m >= s.length && (s = void 0), { value: s && s[m++], done: !s };
+          }
+        };
+      throw new TypeError(c ? "Object is not iterable." : "Symbol.iterator is not defined.");
+    }, K = function(s, c) {
+      var p = typeof Symbol == "function" && s[Symbol.iterator];
+      if (!p)
+        return s;
+      var m = p.call(s), T, g = [], x;
+      try {
+        for (; (c === void 0 || c-- > 0) && !(T = m.next()).done; )
+          g.push(T.value);
+      } catch (H) {
+        x = { error: H };
+      } finally {
+        try {
+          T && !T.done && (p = m.return) && p.call(m);
+        } finally {
+          if (x)
+            throw x.error;
+        }
+      }
+      return g;
+    }, V = function() {
+      for (var s = [], c = 0; c < arguments.length; c++)
+        s = s.concat(K(arguments[c]));
+      return s;
+    }, I = function() {
+      for (var s = 0, c = 0, p = arguments.length; c < p; c++)
+        s += arguments[c].length;
+      for (var m = Array(s), T = 0, c = 0; c < p; c++)
+        for (var g = arguments[c], x = 0, H = g.length; x < H; x++, T++)
+          m[T] = g[x];
+      return m;
+    }, z = function(s, c, p) {
+      if (p || arguments.length === 2)
+        for (var m = 0, T = c.length, g; m < T; m++)
+          (g || !(m in c)) && (g || (g = Array.prototype.slice.call(c, 0, m)), g[m] = c[m]);
+      return s.concat(g || Array.prototype.slice.call(c));
+    }, Z = function(s) {
+      return this instanceof Z ? (this.v = s, this) : new Z(s);
+    }, q = function(s, c, p) {
+      if (!Symbol.asyncIterator)
+        throw new TypeError("Symbol.asyncIterator is not defined.");
+      var m = p.apply(s, c || []), T, g = [];
+      return T = {}, x("next"), x("throw"), x("return"), T[Symbol.asyncIterator] = function() {
+        return this;
+      }, T;
+      function x(J) {
+        m[J] && (T[J] = function(me) {
+          return new Promise(function(t, e) {
+            g.push([J, me, t, e]) > 1 || H(J, me);
+          });
+        });
+      }
+      function H(J, me) {
+        try {
+          Y(m[J](me));
+        } catch (t) {
+          G(g[0][3], t);
+        }
+      }
+      function Y(J) {
+        J.value instanceof Z ? Promise.resolve(J.value.v).then(P, $) : G(g[0][2], J);
+      }
+      function P(J) {
+        H("next", J);
+      }
+      function $(J) {
+        H("throw", J);
+      }
+      function G(J, me) {
+        J(me), g.shift(), g.length && H(g[0][0], g[0][1]);
+      }
+    }, W = function(s) {
+      var c, p;
+      return c = {}, m("next"), m("throw", function(T) {
+        throw T;
+      }), m("return"), c[Symbol.iterator] = function() {
+        return this;
+      }, c;
+      function m(T, g) {
+        c[T] = s[T] ? function(x) {
+          return (p = !p) ? { value: Z(s[T](x)), done: T === "return" } : g ? g(x) : x;
+        } : g;
+      }
+    }, te = function(s) {
+      if (!Symbol.asyncIterator)
+        throw new TypeError("Symbol.asyncIterator is not defined.");
+      var c = s[Symbol.asyncIterator], p;
+      return c ? c.call(s) : (s = typeof E == "function" ? E(s) : s[Symbol.iterator](), p = {}, m("next"), m("throw"), m("return"), p[Symbol.asyncIterator] = function() {
+        return this;
+      }, p);
+      function m(g) {
+        p[g] = s[g] && function(x) {
+          return new Promise(function(H, Y) {
+            x = s[g](x), T(H, Y, x.done, x.value);
+          });
+        };
+      }
+      function T(g, x, H, Y) {
+        Promise.resolve(Y).then(function(P) {
+          g({ value: P, done: H });
+        }, x);
+      }
+    }, re = function(s, c) {
+      return Object.defineProperty ? Object.defineProperty(s, "raw", { value: c }) : s.raw = c, s;
+    };
+    var ne = Object.create ? function(s, c) {
+      Object.defineProperty(s, "default", { enumerable: !0, value: c });
+    } : function(s, c) {
+      s.default = c;
+    };
+    he = function(s) {
+      if (s && s.__esModule)
+        return s;
+      var c = {};
+      if (s != null)
+        for (var p in s)
+          p !== "default" && Object.prototype.hasOwnProperty.call(s, p) && ae(c, s, p);
+      return ne(c, s), c;
+    }, le = function(s) {
+      return s && s.__esModule ? s : { default: s };
+    }, ce = function(s, c, p, m) {
+      if (p === "a" && !m)
+        throw new TypeError("Private accessor was defined without a getter");
+      if (typeof c == "function" ? s !== c || !m : !c.has(s))
+        throw new TypeError("Cannot read private member from an object whose class did not declare it");
+      return p === "m" ? m : p === "a" ? m.call(s) : m ? m.value : c.get(s);
+    }, ue = function(s, c, p, m, T) {
+      if (m === "m")
+        throw new TypeError("Private method is not writable");
+      if (m === "a" && !T)
+        throw new TypeError("Private accessor was defined without a setter");
+      if (typeof c == "function" ? s !== c || !T : !c.has(s))
+        throw new TypeError("Cannot write private member to an object whose class did not declare it");
+      return m === "a" ? T.call(s, p) : T ? T.value = p : c.set(s, p), p;
+    }, Q = function(s, c) {
+      if (c === null || typeof c != "object" && typeof c != "function")
+        throw new TypeError("Cannot use 'in' operator on non-object");
+      return typeof s == "function" ? c === s : s.has(c);
+    }, D("__extends", M), D("__assign", l), D("__rest", S), D("__decorate", R), D("__param", O), D("__metadata", N), D("__awaiter", B), D("__generator", U), D("__exportStar", C), D("__createBinding", ae), D("__values", E), D("__read", K), D("__spread", V), D("__spreadArrays", I), D("__spreadArray", z), D("__await", Z), D("__asyncGenerator", q), D("__asyncDelegator", W), D("__asyncValues", te), D("__makeTemplateObject", re), D("__importStar", he), D("__importDefault", le), D("__classPrivateFieldGet", ce), D("__classPrivateFieldSet", ue), D("__classPrivateFieldIn", Q);
+  });
+})(Ie);
+var Fe;
+Object.defineProperty(Te, "__esModule", { value: !0 });
+var Ue = Ie.exports, f = Be;
+function Ke(y) {
+  if (y && y.__esModule)
+    return y;
+  var M = /* @__PURE__ */ Object.create(null);
+  return y && Object.keys(y).forEach(function(l) {
+    if (l !== "default") {
+      var S = Object.getOwnPropertyDescriptor(y, l);
+      Object.defineProperty(M, l, S.get ? S : { enumerable: !0, get: function() {
+        return y[l];
+      } });
+    }
+  }), M.default = y, Object.freeze(M);
+}
+var Oe = Ke(f), He = function() {
+  function y(t) {
+    f.Loader.call(this, t), this.dracoLoader = null, this.ddsLoader = null;
+  }
+  function M() {
+    var t = {};
+    return { get: function(e) {
+      return t[e];
+    }, add: function(e, a) {
+      t[e] = a;
+    }, remove: function(e) {
+      delete t[e];
+    }, removeAll: function() {
+      t = {};
+    } };
+  }
+  y.prototype = Object.assign(Object.create(f.Loader.prototype), { constructor: y, load: function(t, e, a, r) {
+    var i, n = this;
+    i = this.resourcePath !== "" ? this.resourcePath : this.path !== "" ? this.path : f.LoaderUtils.extractUrlBase(t), n.manager.itemStart(t);
+    var u = function(h) {
+      r ? r(h) : console.error(h), n.manager.itemError(t), n.manager.itemEnd(t);
+    }, o = new f.FileLoader(n.manager);
+    o.setPath(this.path), o.setResponseType("arraybuffer"), o.setRequestHeader(this.requestHeader), n.crossOrigin === "use-credentials" && o.setWithCredentials(!0), o.load(t, function(h) {
+      try {
+        n.parse(h, i, function(d) {
+          e(d), n.manager.itemEnd(t);
+        }, u);
+      } catch (d) {
+        u(d);
+      }
+    }, a, u);
+  }, setDRACOLoader: function(t) {
+    return this.dracoLoader = t, this;
+  }, setDDSLoader: function(t) {
+    return this.ddsLoader = t, this;
+  }, parse: function(t, e, a, r) {
+    var i, n = {};
+    if (typeof t == "string")
+      i = t;
+    else if (f.LoaderUtils.decodeText(new Uint8Array(t, 0, 4)) === B) {
+      try {
+        n[l.KHR_BINARY_GLTF] = new E(t);
+      } catch (v) {
+        return void (r && r(v));
+      }
+      i = n[l.KHR_BINARY_GLTF].content;
+    } else
+      i = f.LoaderUtils.decodeText(new Uint8Array(t));
+    var u = JSON.parse(i);
+    if (u.asset === void 0 || u.asset.version[0] < 2)
+      r && r(new Error("THREE.GLTFLoader: Unsupported asset. glTF versions >=2.0 are supported."));
+    else {
+      if (u.extensionsUsed)
+        for (var o = 0; o < u.extensionsUsed.length; ++o) {
+          var h = u.extensionsUsed[o], d = u.extensionsRequired || [];
+          switch (h) {
+            case l.KHR_LIGHTS_PUNCTUAL:
+              n[h] = new R(u);
+              break;
+            case l.KHR_MATERIALS_CLEARCOAT:
+              n[h] = new N();
+              break;
+            case l.KHR_MATERIALS_UNLIT:
+              n[h] = new O();
+              break;
+            case l.KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS:
+              n[h] = new z();
+              break;
+            case l.KHR_DRACO_MESH_COMPRESSION:
+              n[h] = new K(u, this.dracoLoader);
+              break;
+            case l.MSFT_TEXTURE_DDS:
+              n[h] = new S(this.ddsLoader);
+              break;
+            case l.KHR_TEXTURE_TRANSFORM:
+              n[h] = new V();
+              break;
+            case l.KHR_MESH_QUANTIZATION:
+              n[h] = new Z();
+              break;
+            default:
+              d.indexOf(h) >= 0 && console.warn('THREE.GLTFLoader: Unknown extension "' + h + '".');
+          }
+        }
+      var _ = new G(u, n, { path: e || this.resourcePath || "", crossOrigin: this.crossOrigin, manager: this.manager });
+      _.fileLoader.setRequestHeader(this.requestHeader), _.parse(a, r);
+    }
+  } });
+  var l = { KHR_BINARY_GLTF: "KHR_binary_glTF", KHR_DRACO_MESH_COMPRESSION: "KHR_draco_mesh_compression", KHR_LIGHTS_PUNCTUAL: "KHR_lights_punctual", KHR_MATERIALS_CLEARCOAT: "KHR_materials_clearcoat", KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS: "KHR_materials_pbrSpecularGlossiness", KHR_MATERIALS_UNLIT: "KHR_materials_unlit", KHR_TEXTURE_TRANSFORM: "KHR_texture_transform", KHR_MESH_QUANTIZATION: "KHR_mesh_quantization", MSFT_TEXTURE_DDS: "MSFT_texture_dds" };
+  function S(t) {
+    if (!t)
+      throw new Error("THREE.GLTFLoader: Attempting to load .dds texture without importing DDSLoader");
+    this.name = l.MSFT_TEXTURE_DDS, this.ddsLoader = t;
+  }
+  function R(t) {
+    this.name = l.KHR_LIGHTS_PUNCTUAL;
+    var e = t.extensions && t.extensions[l.KHR_LIGHTS_PUNCTUAL] || {};
+    this.lightDefs = e.lights || [];
+  }
+  function O() {
+    this.name = l.KHR_MATERIALS_UNLIT;
+  }
+  function N() {
+    this.name = l.KHR_MATERIALS_CLEARCOAT;
+  }
+  R.prototype.loadLight = function(t) {
+    var e, a = this.lightDefs[t], r = new f.Color(16777215);
+    a.color !== void 0 && r.fromArray(a.color);
+    var i = a.range !== void 0 ? a.range : 0;
+    switch (a.type) {
+      case "directional":
+        (e = new f.DirectionalLight(r)).target.position.set(0, 0, -1), e.add(e.target);
+        break;
+      case "point":
+        (e = new f.PointLight(r)).distance = i;
+        break;
+      case "spot":
+        (e = new f.SpotLight(r)).distance = i, a.spot = a.spot || {}, a.spot.innerConeAngle = a.spot.innerConeAngle !== void 0 ? a.spot.innerConeAngle : 0, a.spot.outerConeAngle = a.spot.outerConeAngle !== void 0 ? a.spot.outerConeAngle : Math.PI / 4, e.angle = a.spot.outerConeAngle, e.penumbra = 1 - a.spot.innerConeAngle / a.spot.outerConeAngle, e.target.position.set(0, 0, -1), e.add(e.target);
+        break;
+      default:
+        throw new Error('THREE.GLTFLoader: Unexpected light type, "' + a.type + '".');
+    }
+    return e.position.set(0, 0, 0), e.decay = 2, a.intensity !== void 0 && (e.intensity = a.intensity), e.name = a.name || "light_" + t, Promise.resolve(e);
+  }, O.prototype.getMaterialType = function() {
+    return f.MeshBasicMaterial;
+  }, O.prototype.extendParams = function(t, e, a) {
+    var r = [];
+    t.color = new f.Color(1, 1, 1), t.opacity = 1;
+    var i = e.pbrMetallicRoughness;
+    if (i) {
+      if (Array.isArray(i.baseColorFactor)) {
+        var n = i.baseColorFactor;
+        t.color.fromArray(n), t.opacity = n[3];
+      }
+      i.baseColorTexture !== void 0 && r.push(a.assignTexture(t, "map", i.baseColorTexture));
+    }
+    return Promise.all(r);
+  }, N.prototype.getMaterialType = function() {
+    return f.MeshPhysicalMaterial;
+  }, N.prototype.extendParams = function(t, e, a) {
+    var r = [], i = e.extensions[this.name];
+    if (i.clearcoatFactor !== void 0 && (t.clearcoat = i.clearcoatFactor), i.clearcoatTexture !== void 0 && r.push(a.assignTexture(t, "clearcoatMap", i.clearcoatTexture)), i.clearcoatRoughnessFactor !== void 0 && (t.clearcoatRoughness = i.clearcoatRoughnessFactor), i.clearcoatRoughnessTexture !== void 0 && r.push(a.assignTexture(t, "clearcoatRoughnessMap", i.clearcoatRoughnessTexture)), i.clearcoatNormalTexture !== void 0 && (r.push(a.assignTexture(t, "clearcoatNormalMap", i.clearcoatNormalTexture)), i.clearcoatNormalTexture.scale !== void 0)) {
+      var n = i.clearcoatNormalTexture.scale;
+      t.clearcoatNormalScale = new f.Vector2(n, n);
+    }
+    return Promise.all(r);
+  };
+  var B = "glTF", U = 1313821514, C = 5130562;
+  function E(t) {
+    this.name = l.KHR_BINARY_GLTF, this.content = null, this.body = null;
+    var e = new DataView(t, 0, 12);
+    if (this.header = { magic: f.LoaderUtils.decodeText(new Uint8Array(t.slice(0, 4))), version: e.getUint32(4, !0), length: e.getUint32(8, !0) }, this.header.magic !== B)
+      throw new Error("THREE.GLTFLoader: Unsupported glTF-Binary header.");
+    if (this.header.version < 2)
+      throw new Error("THREE.GLTFLoader: Legacy binary file detected.");
+    for (var a = new DataView(t, 12), r = 0; r < a.byteLength; ) {
+      var i = a.getUint32(r, !0);
+      r += 4;
+      var n = a.getUint32(r, !0);
+      if (r += 4, n === U) {
+        var u = new Uint8Array(t, 12 + r, i);
+        this.content = f.LoaderUtils.decodeText(u);
+      } else if (n === C) {
+        var o = 12 + r;
+        this.body = t.slice(o, o + i);
+      }
+      r += i;
+    }
+    if (this.content === null)
+      throw new Error("THREE.GLTFLoader: JSON content not found.");
+  }
+  function K(t, e) {
+    if (!e)
+      throw new Error("THREE.GLTFLoader: No DRACOLoader instance provided.");
+    this.name = l.KHR_DRACO_MESH_COMPRESSION, this.json = t, this.dracoLoader = e, this.dracoLoader.preload();
+  }
+  function V() {
+    this.name = l.KHR_TEXTURE_TRANSFORM;
+  }
+  function I(t) {
+    f.MeshStandardMaterial.call(this), this.isGLTFSpecularGlossinessMaterial = !0;
+    var e = ["#ifdef USE_SPECULARMAP", "	uniform sampler2D specularMap;", "#endif"].join(`
+`), a = ["#ifdef USE_GLOSSINESSMAP", "	uniform sampler2D glossinessMap;", "#endif"].join(`
+`), r = ["vec3 specularFactor = specular;", "#ifdef USE_SPECULARMAP", "	vec4 texelSpecular = texture2D( specularMap, vUv );", "	texelSpecular = sRGBToLinear( texelSpecular );", "	// reads channel RGB, compatible with a glTF Specular-Glossiness (RGBA) texture", "	specularFactor *= texelSpecular.rgb;", "#endif"].join(`
+`), i = ["float glossinessFactor = glossiness;", "#ifdef USE_GLOSSINESSMAP", "	vec4 texelGlossiness = texture2D( glossinessMap, vUv );", "	// reads channel A, compatible with a glTF Specular-Glossiness (RGBA) texture", "	glossinessFactor *= texelGlossiness.a;", "#endif"].join(`
+`), n = ["PhysicalMaterial material;", "material.diffuseColor = diffuseColor.rgb;", "vec3 dxy = max( abs( dFdx( geometryNormal ) ), abs( dFdy( geometryNormal ) ) );", "float geometryRoughness = max( max( dxy.x, dxy.y ), dxy.z );", "material.specularRoughness = max( 1.0 - glossinessFactor, 0.0525 );// 0.0525 corresponds to the base mip of a 256 cubemap.", "material.specularRoughness += geometryRoughness;", "material.specularRoughness = min( material.specularRoughness, 1.0 );", "material.specularColor = specularFactor.rgb;"].join(`
+`), u = { specular: { value: new f.Color().setHex(16777215) }, glossiness: { value: 1 }, specularMap: { value: null }, glossinessMap: { value: null } };
+    this._extraUniforms = u, this.onBeforeCompile = function(o) {
+      for (var h in u)
+        o.uniforms[h] = u[h];
+      o.fragmentShader = o.fragmentShader.replace("uniform float roughness;", "uniform vec3 specular;"), o.fragmentShader = o.fragmentShader.replace("uniform float metalness;", "uniform float glossiness;"), o.fragmentShader = o.fragmentShader.replace("#include <roughnessmap_pars_fragment>", e), o.fragmentShader = o.fragmentShader.replace("#include <metalnessmap_pars_fragment>", a), o.fragmentShader = o.fragmentShader.replace("#include <roughnessmap_fragment>", r), o.fragmentShader = o.fragmentShader.replace("#include <metalnessmap_fragment>", i), o.fragmentShader = o.fragmentShader.replace("#include <lights_physical_fragment>", n);
+    }, Object.defineProperties(this, { specular: { get: function() {
+      return u.specular.value;
+    }, set: function(o) {
+      u.specular.value = o;
+    } }, specularMap: { get: function() {
+      return u.specularMap.value;
+    }, set: function(o) {
+      u.specularMap.value = o;
+    } }, glossiness: { get: function() {
+      return u.glossiness.value;
+    }, set: function(o) {
+      u.glossiness.value = o;
+    } }, glossinessMap: { get: function() {
+      return u.glossinessMap.value;
+    }, set: function(o) {
+      u.glossinessMap.value = o, o ? (this.defines.USE_GLOSSINESSMAP = "", this.defines.USE_ROUGHNESSMAP = "") : (delete this.defines.USE_ROUGHNESSMAP, delete this.defines.USE_GLOSSINESSMAP);
+    } } }), delete this.metalness, delete this.roughness, delete this.metalnessMap, delete this.roughnessMap, this.setValues(t);
+  }
+  function z() {
+    return { name: l.KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS, specularGlossinessParams: ["color", "map", "lightMap", "lightMapIntensity", "aoMap", "aoMapIntensity", "emissive", "emissiveIntensity", "emissiveMap", "bumpMap", "bumpScale", "normalMap", "normalMapType", "displacementMap", "displacementScale", "displacementBias", "specularMap", "specular", "glossinessMap", "glossiness", "alphaMap", "envMap", "envMapIntensity", "refractionRatio"], getMaterialType: function() {
+      return I;
+    }, extendParams: function(t, e, a) {
+      var r = e.extensions[this.name];
+      t.color = new f.Color(1, 1, 1), t.opacity = 1;
+      var i = [];
+      if (Array.isArray(r.diffuseFactor)) {
+        var n = r.diffuseFactor;
+        t.color.fromArray(n), t.opacity = n[3];
+      }
+      if (r.diffuseTexture !== void 0 && i.push(a.assignTexture(t, "map", r.diffuseTexture)), t.emissive = new f.Color(0, 0, 0), t.glossiness = r.glossinessFactor !== void 0 ? r.glossinessFactor : 1, t.specular = new f.Color(1, 1, 1), Array.isArray(r.specularFactor) && t.specular.fromArray(r.specularFactor), r.specularGlossinessTexture !== void 0) {
+        var u = r.specularGlossinessTexture;
+        i.push(a.assignTexture(t, "glossinessMap", u)), i.push(a.assignTexture(t, "specularMap", u));
+      }
+      return Promise.all(i);
+    }, createMaterial: function(t) {
+      var e = new I(t);
+      return e.fog = !0, e.color = t.color, e.map = t.map === void 0 ? null : t.map, e.lightMap = null, e.lightMapIntensity = 1, e.aoMap = t.aoMap === void 0 ? null : t.aoMap, e.aoMapIntensity = 1, e.emissive = t.emissive, e.emissiveIntensity = 1, e.emissiveMap = t.emissiveMap === void 0 ? null : t.emissiveMap, e.bumpMap = t.bumpMap === void 0 ? null : t.bumpMap, e.bumpScale = 1, e.normalMap = t.normalMap === void 0 ? null : t.normalMap, e.normalMapType = f.TangentSpaceNormalMap, t.normalScale && (e.normalScale = t.normalScale), e.displacementMap = null, e.displacementScale = 1, e.displacementBias = 0, e.specularMap = t.specularMap === void 0 ? null : t.specularMap, e.specular = t.specular, e.glossinessMap = t.glossinessMap === void 0 ? null : t.glossinessMap, e.glossiness = t.glossiness, e.alphaMap = null, e.envMap = t.envMap === void 0 ? null : t.envMap, e.envMapIntensity = 1, e.refractionRatio = 0.98, e;
+    } };
+  }
+  function Z() {
+    this.name = l.KHR_MESH_QUANTIZATION;
+  }
+  function q(t, e, a, r) {
+    f.Interpolant.call(this, t, e, a, r);
+  }
+  K.prototype.decodePrimitive = function(t, e) {
+    var a = this.json, r = this.dracoLoader, i = t.extensions[this.name].bufferView, n = t.extensions[this.name].attributes, u = {}, o = {}, h = {};
+    for (var d in n) {
+      var _ = ne[d] || d.toLowerCase();
+      u[_] = n[d];
+    }
+    for (d in t.attributes)
+      if (_ = ne[d] || d.toLowerCase(), n[d] !== void 0) {
+        var v = a.accessors[t.attributes[d]], b = Q[v.componentType];
+        h[_] = b, o[_] = v.normalized === !0;
+      }
+    return e.getDependency("bufferView", i).then(function(A) {
+      return new Promise(function(L) {
+        r.decodeDracoFile(A, function(w) {
+          for (var j in w.attributes) {
+            var k = w.attributes[j], F = o[j];
+            F !== void 0 && (k.normalized = F);
+          }
+          L(w);
+        }, u, h);
+      });
+    });
+  }, V.prototype.extendTexture = function(t, e) {
+    return t = t.clone(), e.offset !== void 0 && t.offset.fromArray(e.offset), e.rotation !== void 0 && (t.rotation = e.rotation), e.scale !== void 0 && t.repeat.fromArray(e.scale), e.texCoord !== void 0 && console.warn('THREE.GLTFLoader: Custom UV sets in "' + this.name + '" extension not yet supported.'), t.needsUpdate = !0, t;
+  }, I.prototype = Object.create(f.MeshStandardMaterial.prototype), I.prototype.constructor = I, I.prototype.copy = function(t) {
+    return f.MeshStandardMaterial.prototype.copy.call(this, t), this.specularMap = t.specularMap, this.specular.copy(t.specular), this.glossinessMap = t.glossinessMap, this.glossiness = t.glossiness, delete this.metalness, delete this.roughness, delete this.metalnessMap, delete this.roughnessMap, this;
+  }, q.prototype = Object.create(f.Interpolant.prototype), q.prototype.constructor = q, q.prototype.copySampleValue_ = function(t) {
+    for (var e = this.resultBuffer, a = this.sampleValues, r = this.valueSize, i = t * r * 3 + r, n = 0; n !== r; n++)
+      e[n] = a[i + n];
+    return e;
+  }, q.prototype.beforeStart_ = q.prototype.copySampleValue_, q.prototype.afterEnd_ = q.prototype.copySampleValue_, q.prototype.interpolate_ = function(t, e, a, r) {
+    for (var i = this.resultBuffer, n = this.sampleValues, u = this.valueSize, o = 2 * u, h = 3 * u, d = r - e, _ = (a - e) / d, v = _ * _, b = v * _, A = t * h, L = A - h, w = -2 * b + 3 * v, j = b - v, k = 1 - w, F = j - v + _, X = 0; X !== u; X++) {
+      var fe = n[L + X + u], ie = n[L + X + o] * d, ee = n[A + X + u], pe = n[A + X] * d;
+      i[X] = k * fe + F * ie + w * ee + j * pe;
+    }
+    return i;
+  };
+  var W = 0, te = 1, re = 2, he = 3, le = 4, ce = 5, ue = 6, Q = { 5120: Int8Array, 5121: Uint8Array, 5122: Int16Array, 5123: Uint16Array, 5125: Uint32Array, 5126: Float32Array }, ae = { 9728: f.NearestFilter, 9729: f.LinearFilter, 9984: f.NearestMipmapNearestFilter, 9985: f.LinearMipmapNearestFilter, 9986: f.NearestMipmapLinearFilter, 9987: f.LinearMipmapLinearFilter }, D = { 33071: f.ClampToEdgeWrapping, 33648: f.MirroredRepeatWrapping, 10497: f.RepeatWrapping }, se = { SCALAR: 1, VEC2: 2, VEC3: 3, VEC4: 4, MAT2: 4, MAT3: 9, MAT4: 16 }, ne = { POSITION: "position", NORMAL: "normal", TANGENT: "tangent", TEXCOORD_0: "uv", TEXCOORD_1: "uv2", COLOR_0: "color", WEIGHTS_0: "skinWeight", JOINTS_0: "skinIndex" }, s = { scale: "scale", translation: "position", rotation: "quaternion", weights: "morphTargetInfluences" }, c = { CUBICSPLINE: void 0, LINEAR: f.InterpolateLinear, STEP: f.InterpolateDiscrete }, p = "OPAQUE", m = "MASK", T = "BLEND", g = { "image/png": f.RGBAFormat, "image/jpeg": f.RGBFormat };
+  function x(t, e) {
+    return typeof t != "string" || t === "" ? "" : (/^https?:\/\//i.test(e) && /^\//.test(t) && (e = e.replace(/(^https?:\/\/[^\/]+).*/i, "$1")), /^(https?:)?\/\//i.test(t) || /^data:.*,.*$/i.test(t) || /^blob:.*$/i.test(t) ? t : e + t);
+  }
+  function H(t, e, a) {
+    for (var r in a.extensions)
+      t[r] === void 0 && (e.userData.gltfExtensions = e.userData.gltfExtensions || {}, e.userData.gltfExtensions[r] = a.extensions[r]);
+  }
+  function Y(t, e) {
+    e.extras !== void 0 && (typeof e.extras == "object" ? Object.assign(t.userData, e.extras) : console.warn("THREE.GLTFLoader: Ignoring primitive type .extras, " + e.extras));
+  }
+  function P(t, e) {
+    if (t.updateMorphTargets(), e.weights !== void 0)
+      for (var a = 0, r = e.weights.length; a < r; a++)
+        t.morphTargetInfluences[a] = e.weights[a];
+    if (e.extras && Array.isArray(e.extras.targetNames)) {
+      var i = e.extras.targetNames;
+      if (t.morphTargetInfluences.length === i.length)
+        for (t.morphTargetDictionary = {}, a = 0, r = i.length; a < r; a++)
+          t.morphTargetDictionary[i[a]] = a;
+      else
+        console.warn("THREE.GLTFLoader: Invalid extras.targetNames length. Ignoring names.");
+    }
+  }
+  function $(t) {
+    for (var e = "", a = Object.keys(t).sort(), r = 0, i = a.length; r < i; r++)
+      e += a[r] + ":" + t[a[r]] + ";";
+    return e;
+  }
+  function G(t, e, a) {
+    this.json = t || {}, this.extensions = e || {}, this.options = a || {}, this.cache = new M(), this.associations = /* @__PURE__ */ new Map(), this.primitiveCache = {}, this.textureLoader = new f.TextureLoader(this.options.manager), this.textureLoader.setCrossOrigin(this.options.crossOrigin), this.fileLoader = new f.FileLoader(this.options.manager), this.fileLoader.setResponseType("arraybuffer"), this.options.crossOrigin === "use-credentials" && this.fileLoader.setWithCredentials(!0);
+  }
+  function J(t, e, a) {
+    var r = e.attributes, i = [];
+    function n(d, _) {
+      return a.getDependency("accessor", d).then(function(v) {
+        t.setAttribute(_, v);
+      });
+    }
+    for (var u in r) {
+      var o = ne[u] || u.toLowerCase();
+      o in t.attributes || i.push(n(r[u], o));
+    }
+    if (e.indices !== void 0 && !t.index) {
+      var h = a.getDependency("accessor", e.indices).then(function(d) {
+        t.setIndex(d);
+      });
+      i.push(h);
+    }
+    return Y(t, e), function(d, _, v) {
+      var b = _.attributes, A = new f.Box3();
+      if (b.POSITION !== void 0) {
+        var L = (ie = v.json.accessors[b.POSITION]).min, w = ie.max;
+        if (L !== void 0 && w !== void 0) {
+          A.set(new f.Vector3(L[0], L[1], L[2]), new f.Vector3(w[0], w[1], w[2]));
+          var j = _.targets;
+          if (j !== void 0) {
+            for (var k = new f.Vector3(), F = new f.Vector3(), X = 0, fe = j.length; X < fe; X++) {
+              var ie, ee = j[X];
+              ee.POSITION !== void 0 && (L = (ie = v.json.accessors[ee.POSITION]).min, w = ie.max, L !== void 0 && w !== void 0 ? (F.setX(Math.max(Math.abs(L[0]), Math.abs(w[0]))), F.setY(Math.max(Math.abs(L[1]), Math.abs(w[1]))), F.setZ(Math.max(Math.abs(L[2]), Math.abs(w[2]))), k.max(F)) : console.warn("THREE.GLTFLoader: Missing min/max properties for accessor POSITION."));
+            }
+            A.expandByVector(k);
+          }
+          d.boundingBox = A;
+          var pe = new f.Sphere();
+          A.getCenter(pe.center), pe.radius = A.min.distanceTo(A.max) / 2, d.boundingSphere = pe;
+        } else
+          console.warn("THREE.GLTFLoader: Missing min/max properties for accessor POSITION.");
+      }
+    }(t, e, a), Promise.all(i).then(function() {
+      return e.targets !== void 0 ? function(d, _, v) {
+        for (var b = !1, A = !1, L = 0, w = _.length; L < w && ((F = _[L]).POSITION !== void 0 && (b = !0), F.NORMAL !== void 0 && (A = !0), !b || !A); L++)
+          ;
+        if (!b && !A)
+          return Promise.resolve(d);
+        var j = [], k = [];
+        for (L = 0, w = _.length; L < w; L++) {
+          var F = _[L];
+          if (b) {
+            var X = F.POSITION !== void 0 ? v.getDependency("accessor", F.POSITION) : d.attributes.position;
+            j.push(X);
+          }
+          A && (X = F.NORMAL !== void 0 ? v.getDependency("accessor", F.NORMAL) : d.attributes.normal, k.push(X));
+        }
+        return Promise.all([Promise.all(j), Promise.all(k)]).then(function(fe) {
+          var ie = fe[0], ee = fe[1];
+          return b && (d.morphAttributes.position = ie), A && (d.morphAttributes.normal = ee), d.morphTargetsRelative = !0, d;
+        });
+      }(t, e.targets, a) : t;
+    });
+  }
+  function me(t, e) {
+    var a = t.getIndex();
+    if (a === null) {
+      var r = [], i = t.getAttribute("position");
+      if (i === void 0)
+        return console.error("THREE.GLTFLoader.toTrianglesDrawMode(): Undefined position attribute. Processing not possible."), t;
+      for (var n = 0; n < i.count; n++)
+        r.push(n);
+      t.setIndex(r), a = t.getIndex();
+    }
+    var u = a.count - 2, o = [];
+    if (e === f.TriangleFanDrawMode)
+      for (n = 1; n <= u; n++)
+        o.push(a.getX(0)), o.push(a.getX(n)), o.push(a.getX(n + 1));
+    else
+      for (n = 0; n < u; n++)
+        n % 2 == 0 ? (o.push(a.getX(n)), o.push(a.getX(n + 1)), o.push(a.getX(n + 2))) : (o.push(a.getX(n + 2)), o.push(a.getX(n + 1)), o.push(a.getX(n)));
+    o.length / 3 !== u && console.error("THREE.GLTFLoader.toTrianglesDrawMode(): Unable to generate correct amount of triangles.");
+    var h = t.clone();
+    return h.setIndex(o), h;
+  }
+  return G.prototype.parse = function(t, e) {
+    var a = this, r = this.json, i = this.extensions;
+    this.cache.removeAll(), this.markDefs(), Promise.all([this.getDependencies("scene"), this.getDependencies("animation"), this.getDependencies("camera")]).then(function(n) {
+      var u = { scene: n[0][r.scene || 0], scenes: n[0], animations: n[1], cameras: n[2], asset: r.asset, parser: a, userData: {} };
+      H(i, u, r), Y(u, r), t(u);
+    }).catch(e);
+  }, G.prototype.markDefs = function() {
+    for (var t = this.json.nodes || [], e = this.json.skins || [], a = this.json.meshes || [], r = {}, i = {}, n = 0, u = e.length; n < u; n++)
+      for (var o = e[n].joints, h = 0, d = o.length; h < d; h++)
+        t[o[h]].isBone = !0;
+    for (var _ = 0, v = t.length; _ < v; _++) {
+      var b = t[_];
+      b.mesh !== void 0 && (r[b.mesh] === void 0 && (r[b.mesh] = i[b.mesh] = 0), r[b.mesh]++, b.skin !== void 0 && (a[b.mesh].isSkinnedMesh = !0));
+    }
+    this.json.meshReferences = r, this.json.meshUses = i;
+  }, G.prototype.getDependency = function(t, e) {
+    var a = t + ":" + e, r = this.cache.get(a);
+    if (!r) {
+      switch (t) {
+        case "scene":
+          r = this.loadScene(e);
+          break;
+        case "node":
+          r = this.loadNode(e);
+          break;
+        case "mesh":
+          r = this.loadMesh(e);
+          break;
+        case "accessor":
+          r = this.loadAccessor(e);
+          break;
+        case "bufferView":
+          r = this.loadBufferView(e);
+          break;
+        case "buffer":
+          r = this.loadBuffer(e);
+          break;
+        case "material":
+          r = this.loadMaterial(e);
+          break;
+        case "texture":
+          r = this.loadTexture(e);
+          break;
+        case "skin":
+          r = this.loadSkin(e);
+          break;
+        case "animation":
+          r = this.loadAnimation(e);
+          break;
+        case "camera":
+          r = this.loadCamera(e);
+          break;
+        case "light":
+          r = this.extensions[l.KHR_LIGHTS_PUNCTUAL].loadLight(e);
+          break;
+        default:
+          throw new Error("Unknown type: " + t);
+      }
+      this.cache.add(a, r);
+    }
+    return r;
+  }, G.prototype.getDependencies = function(t) {
+    var e = this.cache.get(t);
+    if (!e) {
+      var a = this, r = this.json[t + (t === "mesh" ? "es" : "s")] || [];
+      e = Promise.all(r.map(function(i, n) {
+        return a.getDependency(t, n);
+      })), this.cache.add(t, e);
+    }
+    return e;
+  }, G.prototype.loadBuffer = function(t) {
+    var e = this.json.buffers[t], a = this.fileLoader;
+    if (e.type && e.type !== "arraybuffer")
+      throw new Error("THREE.GLTFLoader: " + e.type + " buffer type is not supported.");
+    if (e.uri === void 0 && t === 0)
+      return Promise.resolve(this.extensions[l.KHR_BINARY_GLTF].body);
+    var r = this.options;
+    return new Promise(function(i, n) {
+      a.load(x(e.uri, r.path), i, void 0, function() {
+        n(new Error('THREE.GLTFLoader: Failed to load buffer "' + e.uri + '".'));
+      });
+    });
+  }, G.prototype.loadBufferView = function(t) {
+    var e = this.json.bufferViews[t];
+    return this.getDependency("buffer", e.buffer).then(function(a) {
+      var r = e.byteLength || 0, i = e.byteOffset || 0;
+      return a.slice(i, i + r);
+    });
+  }, G.prototype.loadAccessor = function(t) {
+    var e = this, a = this.json, r = this.json.accessors[t];
+    if (r.bufferView === void 0 && r.sparse === void 0)
+      return Promise.resolve(null);
+    var i = [];
+    return r.bufferView !== void 0 ? i.push(this.getDependency("bufferView", r.bufferView)) : i.push(null), r.sparse !== void 0 && (i.push(this.getDependency("bufferView", r.sparse.indices.bufferView)), i.push(this.getDependency("bufferView", r.sparse.values.bufferView))), Promise.all(i).then(function(n) {
+      var u, o, h = n[0], d = se[r.type], _ = Q[r.componentType], v = _.BYTES_PER_ELEMENT, b = v * d, A = r.byteOffset || 0, L = r.bufferView !== void 0 ? a.bufferViews[r.bufferView].byteStride : void 0, w = r.normalized === !0;
+      if (L && L !== b) {
+        var j = Math.floor(A / L), k = "InterleavedBuffer:" + r.bufferView + ":" + r.componentType + ":" + j + ":" + r.count, F = e.cache.get(k);
+        F || (u = new _(h, j * L, r.count * L / v), F = new f.InterleavedBuffer(u, L / v), e.cache.add(k, F)), o = new f.InterleavedBufferAttribute(F, d, A % L / v, w);
+      } else
+        u = h === null ? new _(r.count * d) : new _(h, A, r.count * d), o = new f.BufferAttribute(u, d, w);
+      if (r.sparse !== void 0) {
+        var X = se.SCALAR, fe = Q[r.sparse.indices.componentType], ie = r.sparse.indices.byteOffset || 0, ee = r.sparse.values.byteOffset || 0, pe = new fe(n[1], ie, r.sparse.count * X), de = new _(n[2], ee, r.sparse.count * d);
+        h !== null && (o = new f.BufferAttribute(o.array.slice(), o.itemSize, o.normalized));
+        for (var ve = 0, Se = pe.length; ve < Se; ve++) {
+          var ye = pe[ve];
+          if (o.setX(ye, de[ve * d]), d >= 2 && o.setY(ye, de[ve * d + 1]), d >= 3 && o.setZ(ye, de[ve * d + 2]), d >= 4 && o.setW(ye, de[ve * d + 3]), d >= 5)
+            throw new Error("THREE.GLTFLoader: Unsupported itemSize in sparse BufferAttribute.");
+        }
+      }
+      return o;
+    });
+  }, G.prototype.loadTexture = function(t) {
+    var e, a = this, r = this.json, i = this.options, n = this.textureLoader, u = self.URL || self.webkitURL, o = r.textures[t], h = o.extensions || {}, d = (e = h[l.MSFT_TEXTURE_DDS] ? r.images[h[l.MSFT_TEXTURE_DDS].source] : r.images[o.source]).uri, _ = !1;
+    return e.bufferView !== void 0 && (d = a.getDependency("bufferView", e.bufferView).then(function(v) {
+      _ = !0;
+      var b = new Blob([v], { type: e.mimeType });
+      return d = u.createObjectURL(b);
+    })), Promise.resolve(d).then(function(v) {
+      var b = i.manager.getHandler(v);
+      return b || (b = h[l.MSFT_TEXTURE_DDS] ? a.extensions[l.MSFT_TEXTURE_DDS].ddsLoader : n), new Promise(function(A, L) {
+        b.load(x(v, i.path), A, void 0, L);
+      });
+    }).then(function(v) {
+      _ === !0 && u.revokeObjectURL(d), v.flipY = !1, o.name && (v.name = o.name), e.mimeType in g && (v.format = g[e.mimeType]);
+      var b = (r.samplers || {})[o.sampler] || {};
+      return v.magFilter = ae[b.magFilter] || f.LinearFilter, v.minFilter = ae[b.minFilter] || f.LinearMipmapLinearFilter, v.wrapS = D[b.wrapS] || f.RepeatWrapping, v.wrapT = D[b.wrapT] || f.RepeatWrapping, a.associations.set(v, { type: "textures", index: t }), v;
+    });
+  }, G.prototype.assignTexture = function(t, e, a) {
+    var r = this;
+    return this.getDependency("texture", a.index).then(function(i) {
+      if (!i.isCompressedTexture)
+        switch (e) {
+          case "aoMap":
+          case "emissiveMap":
+          case "metalnessMap":
+          case "normalMap":
+          case "roughnessMap":
+            i.format = f.RGBFormat;
+        }
+      if (a.texCoord === void 0 || a.texCoord == 0 || e === "aoMap" && a.texCoord == 1 || console.warn("THREE.GLTFLoader: Custom UV set " + a.texCoord + " for texture " + e + " not yet supported."), r.extensions[l.KHR_TEXTURE_TRANSFORM]) {
+        var n = a.extensions !== void 0 ? a.extensions[l.KHR_TEXTURE_TRANSFORM] : void 0;
+        if (n) {
+          var u = this.associations.get(i);
+          i = r.extensions[l.KHR_TEXTURE_TRANSFORM].extendTexture(i, n), this.associations.set(i, u);
+        }
+      }
+      t[e] = i;
+    });
+  }, G.prototype.assignFinalMaterial = function(t) {
+    var e = t.geometry, a = t.material, r = e.attributes.tangent !== void 0, i = e.attributes.color !== void 0, n = e.attributes.normal === void 0, u = t.isSkinnedMesh === !0, o = Object.keys(e.morphAttributes).length > 0, h = o && e.morphAttributes.normal !== void 0;
+    if (t.isPoints) {
+      var d = "PointsMaterial:" + a.uuid, _ = this.cache.get(d);
+      _ || (_ = new f.PointsMaterial(), f.Material.prototype.copy.call(_, a), _.color.copy(a.color), _.map = a.map, _.sizeAttenuation = !1, this.cache.add(d, _)), a = _;
+    } else if (t.isLine) {
+      d = "LineBasicMaterial:" + a.uuid;
+      var v = this.cache.get(d);
+      v || (v = new f.LineBasicMaterial(), f.Material.prototype.copy.call(v, a), v.color.copy(a.color), this.cache.add(d, v)), a = v;
+    }
+    if (r || i || n || u || o) {
+      d = "ClonedMaterial:" + a.uuid + ":", a.isGLTFSpecularGlossinessMaterial && (d += "specular-glossiness:"), u && (d += "skinning:"), r && (d += "vertex-tangents:"), i && (d += "vertex-colors:"), n && (d += "flat-shading:"), o && (d += "morph-targets:"), h && (d += "morph-normals:");
+      var b = this.cache.get(d);
+      b || (b = a.clone(), u && (b.skinning = !0), r && (b.vertexTangents = !0), i && (b.vertexColors = !0), n && (b.flatShading = !0), o && (b.morphTargets = !0), h && (b.morphNormals = !0), this.cache.add(d, b), this.associations.set(b, this.associations.get(a))), a = b;
+    }
+    a.aoMap && e.attributes.uv2 === void 0 && e.attributes.uv !== void 0 && e.setAttribute("uv2", e.attributes.uv), a.normalScale && !r && (a.normalScale.y = -a.normalScale.y), a.clearcoatNormalScale && !r && (a.clearcoatNormalScale.y = -a.clearcoatNormalScale.y), t.material = a;
+  }, G.prototype.loadMaterial = function(t) {
+    var e, a = this, r = this.json, i = this.extensions, n = r.materials[t], u = {}, o = n.extensions || {}, h = [];
+    if (o[l.KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS]) {
+      var d = i[l.KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS];
+      e = d.getMaterialType(), h.push(d.extendParams(u, n, a));
+    } else if (o[l.KHR_MATERIALS_UNLIT]) {
+      var _ = i[l.KHR_MATERIALS_UNLIT];
+      e = _.getMaterialType(), h.push(_.extendParams(u, n, a));
+    } else {
+      e = f.MeshStandardMaterial;
+      var v = n.pbrMetallicRoughness || {};
+      if (u.color = new f.Color(1, 1, 1), u.opacity = 1, Array.isArray(v.baseColorFactor)) {
+        var b = v.baseColorFactor;
+        u.color.fromArray(b), u.opacity = b[3];
+      }
+      v.baseColorTexture !== void 0 && h.push(a.assignTexture(u, "map", v.baseColorTexture)), u.metalness = v.metallicFactor !== void 0 ? v.metallicFactor : 1, u.roughness = v.roughnessFactor !== void 0 ? v.roughnessFactor : 1, v.metallicRoughnessTexture !== void 0 && (h.push(a.assignTexture(u, "metalnessMap", v.metallicRoughnessTexture)), h.push(a.assignTexture(u, "roughnessMap", v.metallicRoughnessTexture)));
+    }
+    n.doubleSided === !0 && (u.side = f.DoubleSide);
+    var A = n.alphaMode || p;
+    if (A === T ? (u.transparent = !0, u.depthWrite = !1) : (u.transparent = !1, A === m && (u.alphaTest = n.alphaCutoff !== void 0 ? n.alphaCutoff : 0.5)), n.normalTexture !== void 0 && e !== f.MeshBasicMaterial && (h.push(a.assignTexture(u, "normalMap", n.normalTexture)), u.normalScale = new f.Vector2(1, 1), n.normalTexture.scale !== void 0 && u.normalScale.set(n.normalTexture.scale, n.normalTexture.scale)), n.occlusionTexture !== void 0 && e !== f.MeshBasicMaterial && (h.push(a.assignTexture(u, "aoMap", n.occlusionTexture)), n.occlusionTexture.strength !== void 0 && (u.aoMapIntensity = n.occlusionTexture.strength)), n.emissiveFactor !== void 0 && e !== f.MeshBasicMaterial && (u.emissive = new f.Color().fromArray(n.emissiveFactor)), n.emissiveTexture !== void 0 && e !== f.MeshBasicMaterial && h.push(a.assignTexture(u, "emissiveMap", n.emissiveTexture)), o[l.KHR_MATERIALS_CLEARCOAT]) {
+      var L = i[l.KHR_MATERIALS_CLEARCOAT];
+      e = L.getMaterialType(), h.push(L.extendParams(u, { extensions: o }, a));
+    }
+    return Promise.all(h).then(function() {
+      var w;
+      return w = e === I ? i[l.KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS].createMaterial(u) : new e(u), n.name && (w.name = n.name), w.map && (w.map.encoding = f.sRGBEncoding), w.emissiveMap && (w.emissiveMap.encoding = f.sRGBEncoding), Y(w, n), a.associations.set(w, { type: "materials", index: t }), n.extensions && H(i, w, n), w;
+    });
+  }, G.prototype.loadGeometries = function(t) {
+    var e = this, a = this.extensions, r = this.primitiveCache;
+    function i(L) {
+      return a[l.KHR_DRACO_MESH_COMPRESSION].decodePrimitive(L, e).then(function(w) {
+        return J(w, L, e);
+      });
+    }
+    for (var n, u, o = [], h = 0, d = t.length; h < d; h++) {
+      var _, v = t[h], b = (u = void 0, (u = (n = v).extensions && n.extensions[l.KHR_DRACO_MESH_COMPRESSION]) ? "draco:" + u.bufferView + ":" + u.indices + ":" + $(u.attributes) : n.indices + ":" + $(n.attributes) + ":" + n.mode), A = r[b];
+      A ? o.push(A.promise) : (_ = v.extensions && v.extensions[l.KHR_DRACO_MESH_COMPRESSION] ? i(v) : J(new f.BufferGeometry(), v, e), r[b] = { primitive: v, promise: _ }, o.push(_));
+    }
+    return Promise.all(o);
+  }, G.prototype.loadMesh = function(t) {
+    for (var e, a = this, r = this.json.meshes[t], i = r.primitives, n = [], u = 0, o = i.length; u < o; u++) {
+      var h = i[u].material === void 0 ? ((e = this.cache).DefaultMaterial === void 0 && (e.DefaultMaterial = new f.MeshStandardMaterial({ color: 16777215, emissive: 0, metalness: 1, roughness: 1, transparent: !1, depthTest: !0, side: f.FrontSide })), e.DefaultMaterial) : this.getDependency("material", i[u].material);
+      n.push(h);
+    }
+    return n.push(a.loadGeometries(i)), Promise.all(n).then(function(d) {
+      for (var _ = d.slice(0, d.length - 1), v = d[d.length - 1], b = [], A = 0, L = v.length; A < L; A++) {
+        var w, j = v[A], k = i[A], F = _[A];
+        if (k.mode === le || k.mode === ce || k.mode === ue || k.mode === void 0)
+          (w = r.isSkinnedMesh === !0 ? new f.SkinnedMesh(j, F) : new f.Mesh(j, F)).isSkinnedMesh !== !0 || w.geometry.attributes.skinWeight.normalized || w.normalizeSkinWeights(), k.mode === ce ? w.geometry = me(w.geometry, f.TriangleStripDrawMode) : k.mode === ue && (w.geometry = me(w.geometry, f.TriangleFanDrawMode));
+        else if (k.mode === te)
+          w = new f.LineSegments(j, F);
+        else if (k.mode === he)
+          w = new f.Line(j, F);
+        else if (k.mode === re)
+          w = new f.LineLoop(j, F);
+        else {
+          if (k.mode !== W)
+            throw new Error("THREE.GLTFLoader: Primitive mode unsupported: " + k.mode);
+          w = new f.Points(j, F);
+        }
+        Object.keys(w.geometry.morphAttributes).length > 0 && P(w, r), w.name = r.name || "mesh_" + t, v.length > 1 && (w.name += "_" + A), Y(w, r), a.assignFinalMaterial(w), b.push(w);
+      }
+      if (b.length === 1)
+        return b[0];
+      var X = new f.Group();
+      for (A = 0, L = b.length; A < L; A++)
+        X.add(b[A]);
+      return X;
+    });
+  }, G.prototype.loadCamera = function(t) {
+    var e, a = this.json.cameras[t], r = a[a.type];
+    if (r)
+      return a.type === "perspective" ? e = new f.PerspectiveCamera(f.MathUtils.radToDeg(r.yfov), r.aspectRatio || 1, r.znear || 1, r.zfar || 2e6) : a.type === "orthographic" && (e = new f.OrthographicCamera(-r.xmag, r.xmag, r.ymag, -r.ymag, r.znear, r.zfar)), a.name && (e.name = a.name), Y(e, a), Promise.resolve(e);
+    console.warn("THREE.GLTFLoader: Missing camera parameters.");
+  }, G.prototype.loadSkin = function(t) {
+    var e = this.json.skins[t], a = { joints: e.joints };
+    return e.inverseBindMatrices === void 0 ? Promise.resolve(a) : this.getDependency("accessor", e.inverseBindMatrices).then(function(r) {
+      return a.inverseBindMatrices = r, a;
+    });
+  }, G.prototype.loadAnimation = function(t) {
+    for (var e = this.json.animations[t], a = [], r = [], i = [], n = [], u = [], o = 0, h = e.channels.length; o < h; o++) {
+      var d = e.channels[o], _ = e.samplers[d.sampler], v = d.target, b = v.node !== void 0 ? v.node : v.id, A = e.parameters !== void 0 ? e.parameters[_.input] : _.input, L = e.parameters !== void 0 ? e.parameters[_.output] : _.output;
+      a.push(this.getDependency("node", b)), r.push(this.getDependency("accessor", A)), i.push(this.getDependency("accessor", L)), n.push(_), u.push(v);
+    }
+    return Promise.all([Promise.all(a), Promise.all(r), Promise.all(i), Promise.all(n), Promise.all(u)]).then(function(w) {
+      for (var j = w[0], k = w[1], F = w[2], X = w[3], fe = w[4], ie = [], ee = 0, pe = j.length; ee < pe; ee++) {
+        var de = j[ee], ve = k[ee], Se = F[ee], ye = X[ee], Le = fe[ee];
+        if (de !== void 0) {
+          var Re;
+          switch (de.updateMatrix(), de.matrixAutoUpdate = !0, s[Le.path]) {
+            case s.weights:
+              Re = f.NumberKeyframeTrack;
+              break;
+            case s.rotation:
+              Re = f.QuaternionKeyframeTrack;
+              break;
+            case s.position:
+            case s.scale:
+            default:
+              Re = f.VectorKeyframeTrack;
+          }
+          var Ge = de.name ? de.name : de.uuid, ke = ye.interpolation !== void 0 ? c[ye.interpolation] : f.InterpolateLinear, Me = [];
+          s[Le.path] === s.weights ? de.traverse(function(be) {
+            be.isMesh === !0 && be.morphTargetInfluences && Me.push(be.name ? be.name : be.uuid);
+          }) : Me.push(Ge);
+          var ge = Se.array;
+          if (Se.normalized) {
+            var we;
+            if (ge.constructor === Int8Array)
+              we = 1 / 127;
+            else if (ge.constructor === Uint8Array)
+              we = 1 / 255;
+            else if (ge.constructor == Int16Array)
+              we = 1 / 32767;
+            else {
+              if (ge.constructor !== Uint16Array)
+                throw new Error("THREE.GLTFLoader: Unsupported output accessor component type.");
+              we = 1 / 65535;
+            }
+            for (var Ce = new Float32Array(ge.length), _e = 0, Ee = ge.length; _e < Ee; _e++)
+              Ce[_e] = ge[_e] * we;
+            ge = Ce;
+          }
+          for (_e = 0, Ee = Me.length; _e < Ee; _e++) {
+            var xe = new Re(Me[_e] + "." + s[Le.path], ve.array, ge, ke);
+            ye.interpolation === "CUBICSPLINE" && (xe.createInterpolant = function(be) {
+              return new q(this.times, this.values, this.getValueSize() / 3, be);
+            }, xe.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline = !0), ie.push(xe);
+          }
+        }
+      }
+      var Ne = e.name ? e.name : "animation_" + t;
+      return new f.AnimationClip(Ne, void 0, ie);
+    });
+  }, G.prototype.loadNode = function(t) {
+    var e, a = this.json, r = this.extensions, i = this, n = a.meshReferences, u = a.meshUses, o = a.nodes[t];
+    return (e = [], o.mesh !== void 0 && e.push(i.getDependency("mesh", o.mesh).then(function(h) {
+      var d;
+      if (n[o.mesh] > 1) {
+        var _ = u[o.mesh]++;
+        (d = h.clone()).name += "_instance_" + _;
+      } else
+        d = h;
+      return o.weights !== void 0 && d.traverse(function(v) {
+        if (v.isMesh)
+          for (var b = 0, A = o.weights.length; b < A; b++)
+            v.morphTargetInfluences[b] = o.weights[b];
+      }), d;
+    })), o.camera !== void 0 && e.push(i.getDependency("camera", o.camera)), o.extensions && o.extensions[l.KHR_LIGHTS_PUNCTUAL] && o.extensions[l.KHR_LIGHTS_PUNCTUAL].light !== void 0 && e.push(i.getDependency("light", o.extensions[l.KHR_LIGHTS_PUNCTUAL].light)), Promise.all(e)).then(function(h) {
+      var d;
+      if ((d = o.isBone === !0 ? new f.Bone() : h.length > 1 ? new f.Group() : h.length === 1 ? h[0] : new f.Object3D()) !== h[0])
+        for (var _ = 0, v = h.length; _ < v; _++)
+          d.add(h[_]);
+      if (o.name && (d.userData.name = o.name, d.name = f.PropertyBinding.sanitizeNodeName(o.name)), Y(d, o), o.extensions && H(r, d, o), o.matrix !== void 0) {
+        var b = new f.Matrix4();
+        b.fromArray(o.matrix), d.applyMatrix4(b);
+      } else
+        o.translation !== void 0 && d.position.fromArray(o.translation), o.rotation !== void 0 && d.quaternion.fromArray(o.rotation), o.scale !== void 0 && d.scale.fromArray(o.scale);
+      return i.associations.set(d, { type: "nodes", index: t }), d;
+    });
+  }, G.prototype.loadScene = function() {
+    function t(e, a, r, i) {
+      var n = r.nodes[e];
+      return i.getDependency("node", e).then(function(u) {
+        return n.skin === void 0 ? u : i.getDependency("skin", n.skin).then(function(h) {
+          for (var d = [], _ = 0, v = (o = h).joints.length; _ < v; _++)
+            d.push(i.getDependency("node", o.joints[_]));
+          return Promise.all(d);
+        }).then(function(h) {
+          return u.traverse(function(d) {
+            if (d.isMesh) {
+              for (var _ = [], v = [], b = 0, A = h.length; b < A; b++) {
+                var L = h[b];
+                if (L) {
+                  _.push(L);
+                  var w = new f.Matrix4();
+                  o.inverseBindMatrices !== void 0 && w.fromArray(o.inverseBindMatrices.array, 16 * b), v.push(w);
+                } else
+                  console.warn('THREE.GLTFLoader: Joint "%s" could not be found.', o.joints[b]);
+              }
+              d.bind(new f.Skeleton(_, v), d.matrixWorld);
+            }
+          }), u;
+        });
+        var o;
+      }).then(function(u) {
+        a.add(u);
+        var o = [];
+        if (n.children)
+          for (var h = n.children, d = 0, _ = h.length; d < _; d++) {
+            var v = h[d];
+            o.push(t(v, u, r, i));
+          }
+        return Promise.all(o);
+      });
+    }
+    return function(e) {
+      var a = this.json, r = this.extensions, i = this.json.scenes[e], n = new f.Group();
+      i.name && (n.name = i.name), Y(n, i), i.extensions && H(r, n, i);
+      for (var u = i.nodes || [], o = [], h = 0, d = u.length; h < d; h++)
+        o.push(t(u[h], n, a, this));
+      return Promise.all(o).then(function() {
+        return n;
+      });
+    };
+  }(), y;
+}(), oe = function(y) {
+  f.Loader.call(this, y), this.decoderPath = "", this.decoderConfig = {}, this.decoderBinary = null, this.decoderPending = null, this.workerLimit = 4, this.workerPool = [], this.workerNextTaskID = 1, this.workerSourceURL = "", this.defaultAttributeIDs = { position: "POSITION", normal: "NORMAL", color: "COLOR", uv: "TEX_COORD" }, this.defaultAttributeTypes = { position: "Float32Array", normal: "Float32Array", color: "Float32Array", uv: "Float32Array" };
+};
+oe.prototype = Object.assign(Object.create(f.Loader.prototype), { constructor: oe, setDecoderPath: function(y) {
+  return this.decoderPath = y, this;
+}, setDecoderConfig: function(y) {
+  return this.decoderConfig = y, this;
+}, setWorkerLimit: function(y) {
+  return this.workerLimit = y, this;
+}, setVerbosity: function() {
+  console.warn("THREE.DRACOLoader: The .setVerbosity() method has been removed.");
+}, setDrawMode: function() {
+  console.warn("THREE.DRACOLoader: The .setDrawMode() method has been removed.");
+}, setSkipDequantization: function() {
+  console.warn("THREE.DRACOLoader: The .setSkipDequantization() method has been removed.");
+}, load: function(y, M, l, S) {
+  var R = new f.FileLoader(this.manager);
+  R.setPath(this.path), R.setResponseType("arraybuffer"), this.crossOrigin === "use-credentials" && R.setWithCredentials(!0), R.load(y, (O) => {
+    var N = { attributeIDs: this.defaultAttributeIDs, attributeTypes: this.defaultAttributeTypes, useUniqueIDs: !1 };
+    this.decodeGeometry(O, N).then(M).catch(S);
+  }, l, S);
+}, decodeDracoFile: function(y, M, l, S) {
+  var R = { attributeIDs: l || this.defaultAttributeIDs, attributeTypes: S || this.defaultAttributeTypes, useUniqueIDs: !!l };
+  this.decodeGeometry(y, R).then(M);
+}, decodeGeometry: function(y, M) {
+  for (var l in M.attributeTypes) {
+    var S = M.attributeTypes[l];
+    S.BYTES_PER_ELEMENT !== void 0 && (M.attributeTypes[l] = S.name);
+  }
+  var R, O = JSON.stringify(M);
+  if (oe.taskCache.has(y)) {
+    var N = oe.taskCache.get(y);
+    if (N.key === O)
+      return N.promise;
+    if (y.byteLength === 0)
+      throw new Error("THREE.DRACOLoader: Unable to re-decode a buffer with different settings. Buffer has already been transferred.");
+  }
+  var B = this.workerNextTaskID++, U = y.byteLength, C = this._getWorker(B, U).then((E) => (R = E, new Promise((K, V) => {
+    R._callbacks[B] = { resolve: K, reject: V }, R.postMessage({ type: "decode", id: B, taskConfig: M, buffer: y }, [y]);
+  }))).then((E) => this._createGeometry(E.geometry));
+  return C.catch(() => !0).then(() => {
+    R && B && this._releaseTask(R, B);
+  }), oe.taskCache.set(y, { key: O, promise: C }), C;
+}, _createGeometry: function(y) {
+  var M = new f.BufferGeometry();
+  y.index && M.setIndex(new f.BufferAttribute(y.index.array, 1));
+  for (var l = 0; l < y.attributes.length; l++) {
+    var S = y.attributes[l], R = S.name, O = S.array, N = S.itemSize;
+    M.setAttribute(R, new f.BufferAttribute(O, N));
+  }
+  return M;
+}, _loadLibrary: function(y, M) {
+  var l = new f.FileLoader(this.manager);
+  return l.setPath(this.decoderPath), l.setResponseType(M), new Promise((S, R) => {
+    l.load(y, S, void 0, R);
+  });
+}, preload: function() {
+  return this._initDecoder(), this;
+}, _initDecoder: function() {
+  if (this.decoderPending)
+    return this.decoderPending;
+  var y = typeof WebAssembly != "object" || this.decoderConfig.type === "js", M = [];
+  return y ? M.push(this._loadLibrary("draco_decoder.js", "text")) : (M.push(this._loadLibrary("draco_wasm_wrapper.js", "text")), M.push(this._loadLibrary("draco_decoder.wasm", "arraybuffer"))), this.decoderPending = Promise.all(M).then((l) => {
+    var S = l[0];
+    y || (this.decoderConfig.wasmBinary = l[1]);
+    var R = oe.DRACOWorker.toString(), O = ["/* draco decoder */", S, "", "/* worker */", R.substring(R.indexOf("{") + 1, R.lastIndexOf("}"))].join(`
+`);
+    this.workerSourceURL = URL.createObjectURL(new Blob([O]));
+  }), this.decoderPending;
+}, _getWorker: function(y, M) {
+  return this._initDecoder().then(() => {
+    var l;
+    return this.workerPool.length < this.workerLimit ? ((l = new Worker(this.workerSourceURL))._callbacks = {}, l._taskCosts = {}, l._taskLoad = 0, l.postMessage({ type: "init", decoderConfig: this.decoderConfig }), l.onmessage = function(S) {
+      var R = S.data;
+      switch (R.type) {
+        case "decode":
+          l._callbacks[R.id].resolve(R);
+          break;
+        case "error":
+          l._callbacks[R.id].reject(R);
+          break;
+        default:
+          console.error('THREE.DRACOLoader: Unexpected message, "' + R.type + '"');
+      }
+    }, this.workerPool.push(l)) : this.workerPool.sort(function(S, R) {
+      return S._taskLoad > R._taskLoad ? -1 : 1;
+    }), (l = this.workerPool[this.workerPool.length - 1])._taskCosts[y] = M, l._taskLoad += M, l;
+  });
+}, _releaseTask: function(y, M) {
+  y._taskLoad -= y._taskCosts[M], delete y._callbacks[M], delete y._taskCosts[M];
+}, debug: function() {
+  console.log("Task load: ", this.workerPool.map((y) => y._taskLoad));
+}, dispose: function() {
+  for (var y = 0; y < this.workerPool.length; ++y)
+    this.workerPool[y].terminate();
+  return this.workerPool.length = 0, this;
+} }), oe.DRACOWorker = function() {
+  var y, M;
+  function l(S, R, O, N, B, U) {
+    var C, E, K = U.num_components(), V = O.num_points() * K;
+    switch (B) {
+      case Float32Array:
+        C = new S.DracoFloat32Array(), R.GetAttributeFloatForAllPoints(O, U, C), E = new Float32Array(V);
+        break;
+      case Int8Array:
+        C = new S.DracoInt8Array(), R.GetAttributeInt8ForAllPoints(O, U, C), E = new Int8Array(V);
+        break;
+      case Int16Array:
+        C = new S.DracoInt16Array(), R.GetAttributeInt16ForAllPoints(O, U, C), E = new Int16Array(V);
+        break;
+      case Int32Array:
+        C = new S.DracoInt32Array(), R.GetAttributeInt32ForAllPoints(O, U, C), E = new Int32Array(V);
+        break;
+      case Uint8Array:
+        C = new S.DracoUInt8Array(), R.GetAttributeUInt8ForAllPoints(O, U, C), E = new Uint8Array(V);
+        break;
+      case Uint16Array:
+        C = new S.DracoUInt16Array(), R.GetAttributeUInt16ForAllPoints(O, U, C), E = new Uint16Array(V);
+        break;
+      case Uint32Array:
+        C = new S.DracoUInt32Array(), R.GetAttributeUInt32ForAllPoints(O, U, C), E = new Uint32Array(V);
+        break;
+      default:
+        throw new Error("THREE.DRACOLoader: Unexpected attribute type.");
+    }
+    for (var I = 0; I < V; I++)
+      E[I] = C.GetValue(I);
+    return S.destroy(C), { name: N, array: E, itemSize: K };
+  }
+  onmessage = function(S) {
+    var R = S.data;
+    switch (R.type) {
+      case "init":
+        y = R.decoderConfig, M = new Promise(function(B) {
+          y.onModuleLoaded = function(U) {
+            B({ draco: U });
+          }, DracoDecoderModule(y);
+        });
+        break;
+      case "decode":
+        var O = R.buffer, N = R.taskConfig;
+        M.then((B) => {
+          var U = B.draco, C = new U.Decoder(), E = new U.DecoderBuffer();
+          E.Init(new Int8Array(O), O.byteLength);
+          try {
+            var K = function(I, z, Z, q) {
+              var W, te, re = q.attributeIDs, he = q.attributeTypes, le = z.GetEncodedGeometryType(Z);
+              if (le === I.TRIANGULAR_MESH)
+                W = new I.Mesh(), te = z.DecodeBufferToMesh(Z, W);
+              else {
+                if (le !== I.POINT_CLOUD)
+                  throw new Error("THREE.DRACOLoader: Unexpected geometry type.");
+                W = new I.PointCloud(), te = z.DecodeBufferToPointCloud(Z, W);
+              }
+              if (!te.ok() || W.ptr === 0)
+                throw new Error("THREE.DRACOLoader: Decoding failed: " + te.error_msg());
+              var ce = { index: null, attributes: [] };
+              for (var ue in re) {
+                var Q, ae, D = self[he[ue]];
+                if (q.useUniqueIDs)
+                  ae = re[ue], Q = z.GetAttributeByUniqueId(W, ae);
+                else {
+                  if ((ae = z.GetAttributeId(W, I[re[ue]])) === -1)
+                    continue;
+                  Q = z.GetAttribute(W, ae);
+                }
+                ce.attributes.push(l(I, z, W, ue, D, Q));
+              }
+              if (le === I.TRIANGULAR_MESH) {
+                for (var se = W.num_faces(), ne = new Uint32Array(3 * se), s = new I.DracoInt32Array(), c = 0; c < se; ++c) {
+                  z.GetFaceFromMesh(W, c, s);
+                  for (var p = 0; p < 3; ++p)
+                    ne[3 * c + p] = s.GetValue(p);
                 }
-            });
-            scene.add(model);
-            model.position.copy(modelPosition);
-            model.needsRender = true;
-            res(model);
-            // object3DHelper.add(model)
+                ce.index = { array: ne, itemSize: 1 }, I.destroy(s);
+              }
+              return I.destroy(W), ce;
+            }(U, C, E, N), V = K.attributes.map((I) => I.array.buffer);
+            K.index && V.push(K.index.array.buffer), self.postMessage({ type: "decode", id: R.id, geometry: K }, V);
+          } catch (I) {
+            console.error(I), self.postMessage({ type: "error", id: R.id, error: I.message });
+          } finally {
+            U.destroy(E), U.destroy(C);
+          }
         });
+    }
+  };
+}, oe.taskCache = /* @__PURE__ */ new WeakMap(), oe.setDecoderPath = function() {
+  console.warn("THREE.DRACOLoader: The .setDecoderPath() method has been removed. Use instance methods.");
+}, oe.setDecoderConfig = function() {
+  console.warn("THREE.DRACOLoader: The .setDecoderConfig() method has been removed. Use instance methods.");
+}, oe.releaseDecoderModule = function() {
+  console.warn("THREE.DRACOLoader: The .releaseDecoderModule() method has been removed. Use instance methods.");
+}, oe.getDecoderModule = function() {
+  console.warn("THREE.DRACOLoader: The .getDecoderModule() method has been removed. Use instance methods.");
+};
+var Ae = function(y) {
+  f.CompressedTextureLoader.call(this, y);
+};
+Ae.prototype = Object.assign(Object.create(f.CompressedTextureLoader.prototype), { constructor: Ae, parse: function(y, M) {
+  var l = { mipmaps: [], width: 0, height: 0, format: null, mipmapCount: 1 };
+  function S(Q) {
+    return Q.charCodeAt(0) + (Q.charCodeAt(1) << 8) + (Q.charCodeAt(2) << 16) + (Q.charCodeAt(3) << 24);
+  }
+  function R(Q, ae, D, se) {
+    for (var ne = D * se * 4, s = new Uint8Array(Q, ae, ne), c = new Uint8Array(ne), p = 0, m = 0, T = 0; T < se; T++)
+      for (var g = 0; g < D; g++) {
+        var x = s[m], H = s[++m], Y = s[++m], P = s[++m];
+        m++, c[p] = Y, c[++p] = H, c[++p] = x, c[++p] = P, p++;
+      }
+    return c;
+  }
+  var O, N = S("DXT1"), B = S("DXT3"), U = S("DXT5"), C = S("ETC1"), E = new Int32Array(y, 0, 31);
+  if (E[0] !== 542327876)
+    return console.error("THREE.DDSLoader.parse: Invalid magic number in DDS header."), l;
+  if (4 & !E[20])
+    return console.error("THREE.DDSLoader.parse: Unsupported format, must contain a FourCC code."), l;
+  var K, V = E[21], I = !1;
+  switch (V) {
+    case N:
+      O = 8, l.format = f.RGB_S3TC_DXT1_Format;
+      break;
+    case B:
+      O = 16, l.format = f.RGBA_S3TC_DXT3_Format;
+      break;
+    case U:
+      O = 16, l.format = f.RGBA_S3TC_DXT5_Format;
+      break;
+    case C:
+      O = 8, l.format = f.RGB_ETC1_Format;
+      break;
+    default:
+      if (!(E[22] === 32 && 16711680 & E[23] && 65280 & E[24] && 255 & E[25] && 4278190080 & E[26]))
+        return console.error("THREE.DDSLoader.parse: Unsupported FourCC code ", (K = V, String.fromCharCode(255 & K, K >> 8 & 255, K >> 16 & 255, K >> 24 & 255))), l;
+      I = !0, O = 64, l.format = f.RGBAFormat;
+  }
+  l.mipmapCount = 1, 131072 & E[2] && M !== !1 && (l.mipmapCount = Math.max(1, E[7]));
+  var z = E[28];
+  if (l.isCubemap = !!(512 & z), l.isCubemap && (!(1024 & z) || !(2048 & z) || !(4096 & z) || !(8192 & z) || !(16384 & z) || !(32768 & z)))
+    return console.error("THREE.DDSLoader.parse: Incomplete cubemap faces"), l;
+  l.width = E[4], l.height = E[3];
+  for (var Z = E[1] + 4, q = l.isCubemap ? 6 : 1, W = 0; W < q; W++)
+    for (var te = l.width, re = l.height, he = 0; he < l.mipmapCount; he++) {
+      if (I)
+        var le = (ce = R(y, Z, te, re)).length;
+      else {
+        le = Math.max(4, te) / 4 * Math.max(4, re) / 4 * O;
+        var ce = new Uint8Array(y, Z, le);
+      }
+      var ue = { data: ce, width: te, height: re };
+      l.mipmaps.push(ue), Z += le, te = Math.max(te >> 1, 1), re = Math.max(re >> 1, 1);
+    }
+  return l;
+} });
+var Pe = function(y) {
+  function M(l) {
+    var S = y.call(this) || this;
+    return S.needsRender = !0, l && l.children.length && S.add.apply(S, l.children), S.mixer = new Oe.AnimationMixer(S), S;
+  }
+  return Ue.__extends(M, y), M.prototype.clone = function() {
+    var l = y.prototype.clone.call(this, !0), S = new Oe.AnimationMixer(l);
+    return l.mixer = S, l.needsRender = !0, l;
+  }, M;
+}(Oe.Group), Ve = function(y) {
+  function M(l) {
+    var S = y.call(this, l) || this;
+    return S.ddsLoader = new Ae(l), S.dracoLoader = new oe(l), S.dracoLoader.setDecoderPath("https://vr-public.realsee-cdn.cn/release/static/image/release/five/gltf/"), S;
+  }
+  return Ue.__extends(M, y), Object.defineProperty(M, "version", { get: function() {
+    return "5.0.0-alpha.149";
+  }, enumerable: !1, configurable: !0 }), M.prototype.load = function(l, S, R, O) {
+    return y.prototype.load.call(this, l, S, R, O);
+  }, M.prototype.parse = function(l, S, R, O) {
+    return y.prototype.parse.call(this, l, S, function(N) {
+      var B = new Pe(N.scene), U = N.scenes.map(function(C) {
+        return C === N.scene ? B : new Pe(C);
+      });
+      R(Object.assign(N, { scene: B, scenes: U }));
+    }, O);
+  }, M;
+}(He);
+Te.DDSLoader = Ae, Te.DRACOLoader = oe, Fe = Te.GLTFLoader = Ve, Te.GLTFObject = Pe, Te.THREEGLTFLoader = He;
+function ze(y, M) {
+  const l = new je.Vector3(3.8058113175002797, -1.4285810796152072, -4.748098691966687), S = y.modelUrl, R = new Fe();
+  return new Promise((O, N) => {
+    R.load(S, function(U) {
+      const C = U.scene;
+      C.traverse((E) => {
+        E.material && (E.material.envMapIntensity = 0.5);
+      }), M.add(C), C.position.copy(l), C.needsRender = !0, O(C);
     });
+  });
 }
+export {
+  ze as default
+};