pptx-svelte-viewer 0.1.1 → 0.1.2

package/dist/GLTFLoader-CAjQhVgN.js

@@ -0,0 +1,1413 @@
+import { AnimationClip as Te, Bone as Re, Box3 as Ee, BufferAttribute as j, BufferGeometry as Ae, ClampToEdgeWrapping as _e, Color as O, ColorManagement as J, DirectionalLight as ve, FileLoader as ce, Group as V, ImageBitmapLoader as Le, InstancedBufferAttribute as Me, InstancedMesh as xe, InterleavedBuffer as Se, InterleavedBufferAttribute as ye, Interpolant as we, InterpolateDiscrete as be, InterpolateLinear as le, Line as Ne, LineBasicMaterial as Ie, LineLoop as Oe, LineSegments as Ce, LinearFilter as Fe, LinearMipmapLinearFilter as Pe, LinearMipmapNearestFilter as ke, LinearSRGBColorSpace as b, Loader as He, LoaderUtils as D, Material as X, MathUtils as De, Matrix4 as U, Mesh as Ge, MeshBasicMaterial as H, MeshPhysicalMaterial as x, MeshStandardMaterial as ue, MirroredRepeatWrapping as Ue, NearestFilter as Be, NearestMipmapLinearFilter as Ke, NearestMipmapNearestFilter as je, NumberKeyframeTrack as Z, Object3D as he, OrthographicCamera as Ve, PerspectiveCamera as Xe, PointLight as ze, Points as qe, PointsMaterial as We, PropertyBinding as Ye, Quaternion as fe, QuaternionKeyframeTrack as $, RepeatWrapping as Qe, SRGBColorSpace as G, Skeleton as Je, SkinnedMesh as Ze, Sphere as $e, SpotLight as et, Texture as ee, TextureLoader as tt, Vector2 as de, Vector3 as I, VectorKeyframeTrack as te } from "./three.module-BLwnGxzY.js";
+function se(e, t) {
+  if (t === 0)
+    return console.warn("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Geometry already defined as triangles."), e;
+  if (t === 2 || t === 1) {
+    let n = e.getIndex();
+    if (n === null) {
+      const o = [], a = e.getAttribute("position");
+      if (a !== void 0) {
+        for (let c = 0; c < a.count; c++) o.push(c);
+        e.setIndex(o), n = e.getIndex();
+      } else
+        return console.error("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Undefined position attribute. Processing not possible."), e;
+    }
+    const s = n.count - 2, r = [];
+    if (t === 2) for (let o = 1; o <= s; o++)
+      r.push(n.getX(0)), r.push(n.getX(o)), r.push(n.getX(o + 1));
+    else for (let o = 0; o < s; o++) o % 2 === 0 ? (r.push(n.getX(o)), r.push(n.getX(o + 1)), r.push(n.getX(o + 2))) : (r.push(n.getX(o + 2)), r.push(n.getX(o + 1)), r.push(n.getX(o)));
+    r.length / 3 !== s && console.error("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Unable to generate correct amount of triangles.");
+    const i = e.clone();
+    return i.setIndex(r), i.clearGroups(), i;
+  } else
+    return console.error("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Unknown draw mode:", t), e;
+}
+function st(e) {
+  const t = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map(), s = e.clone();
+  return pe(e, s, function(r, i) {
+    t.set(i, r), n.set(r, i);
+  }), s.traverse(function(r) {
+    if (!r.isSkinnedMesh) return;
+    const i = r, o = t.get(r), a = o.skeleton.bones;
+    i.skeleton = o.skeleton.clone(), i.bindMatrix.copy(o.bindMatrix), i.skeleton.bones = a.map(function(c) {
+      return n.get(c);
+    }), i.bind(i.skeleton, i.bindMatrix);
+  }), s;
+}
+function pe(e, t, n) {
+  n(e, t);
+  for (let s = 0; s < e.children.length; s++) pe(e.children[s], t.children[s], n);
+}
+var Kt = class extends He {
+  constructor(e) {
+    super(e), this.dracoLoader = null, this.ktx2Loader = null, this.meshoptDecoder = null, this.pluginCallbacks = [], this.register(function(t) {
+      return new at(t);
+    }), this.register(function(t) {
+      return new ct(t);
+    }), this.register(function(t) {
+      return new Tt(t);
+    }), this.register(function(t) {
+      return new Rt(t);
+    }), this.register(function(t) {
+      return new Et(t);
+    }), this.register(function(t) {
+      return new ut(t);
+    }), this.register(function(t) {
+      return new ht(t);
+    }), this.register(function(t) {
+      return new ft(t);
+    }), this.register(function(t) {
+      return new dt(t);
+    }), this.register(function(t) {
+      return new ot(t);
+    }), this.register(function(t) {
+      return new pt(t);
+    }), this.register(function(t) {
+      return new lt(t);
+    }), this.register(function(t) {
+      return new gt(t);
+    }), this.register(function(t) {
+      return new mt(t);
+    }), this.register(function(t) {
+      return new rt(t);
+    }), this.register(function(t) {
+      return new ne(t, m.EXT_MESHOPT_COMPRESSION);
+    }), this.register(function(t) {
+      return new ne(t, m.KHR_MESHOPT_COMPRESSION);
+    }), this.register(function(t) {
+      return new At(t);
+    });
+  }
+  load(e, t, n, s) {
+    const r = this;
+    let i;
+    if (this.resourcePath !== "") i = this.resourcePath;
+    else if (this.path !== "") {
+      const c = D.extractUrlBase(e);
+      i = D.resolveURL(c, this.path);
+    } else i = D.extractUrlBase(e);
+    this.manager.itemStart(e);
+    const o = function(c) {
+      s ? s(c) : console.error(c), r.manager.itemError(e), r.manager.itemEnd(e);
+    }, a = new ce(this.manager);
+    a.setPath(this.path), a.setResponseType("arraybuffer"), a.setRequestHeader(this.requestHeader), a.setWithCredentials(this.withCredentials), a.load(e, function(c) {
+      try {
+        r.parse(c, i, function(l) {
+          t(l), r.manager.itemEnd(e);
+        }, o);
+      } catch (l) {
+        o(l);
+      }
+    }, n, o);
+  }
+  setDRACOLoader(e) {
+    return this.dracoLoader = e, this;
+  }
+  setKTX2Loader(e) {
+    return this.ktx2Loader = e, this;
+  }
+  setMeshoptDecoder(e) {
+    return this.meshoptDecoder = e, this;
+  }
+  register(e) {
+    return this.pluginCallbacks.indexOf(e) === -1 && this.pluginCallbacks.push(e), this;
+  }
+  unregister(e) {
+    return this.pluginCallbacks.indexOf(e) !== -1 && this.pluginCallbacks.splice(this.pluginCallbacks.indexOf(e), 1), this;
+  }
+  parse(e, t, n, s) {
+    let r;
+    const i = {}, o = {}, a = new TextDecoder();
+    if (typeof e == "string") r = JSON.parse(e);
+    else if (e instanceof ArrayBuffer) if (a.decode(new Uint8Array(e, 0, 4)) === me) {
+      try {
+        i[m.KHR_BINARY_GLTF] = new _t(e);
+      } catch (l) {
+        s && s(l);
+        return;
+      }
+      r = JSON.parse(i[m.KHR_BINARY_GLTF].content);
+    } else r = JSON.parse(a.decode(e));
+    else r = e;
+    if (r.asset === void 0 || r.asset.version[0] < 2) {
+      s && s(/* @__PURE__ */ new Error("THREE.GLTFLoader: Unsupported asset. glTF versions >=2.0 are supported."));
+      return;
+    }
+    const c = new Ft(r, {
+      path: t || this.resourcePath || "",
+      crossOrigin: this.crossOrigin,
+      requestHeader: this.requestHeader,
+      manager: this.manager,
+      ktx2Loader: this.ktx2Loader,
+      meshoptDecoder: this.meshoptDecoder
+    });
+    c.fileLoader.setRequestHeader(this.requestHeader);
+    for (let l = 0; l < this.pluginCallbacks.length; l++) {
+      const u = this.pluginCallbacks[l](c);
+      u.name || console.error("THREE.GLTFLoader: Invalid plugin found: missing name"), o[u.name] = u, i[u.name] = !0;
+    }
+    if (r.extensionsUsed) for (let l = 0; l < r.extensionsUsed.length; ++l) {
+      const u = r.extensionsUsed[l], h = r.extensionsRequired || [];
+      switch (u) {
+        case m.KHR_MATERIALS_UNLIT:
+          i[u] = new it();
+          break;
+        case m.KHR_DRACO_MESH_COMPRESSION:
+          i[u] = new vt(r, this.dracoLoader);
+          break;
+        case m.KHR_TEXTURE_TRANSFORM:
+          i[u] = new Lt();
+          break;
+        case m.KHR_MESH_QUANTIZATION:
+          i[u] = new Mt();
+          break;
+        default:
+          h.indexOf(u) >= 0 && o[u] === void 0 && console.warn('THREE.GLTFLoader: Unknown extension "' + u + '".');
+      }
+    }
+    c.setExtensions(i), c.setPlugins(o), c.parse(n, s);
+  }
+  parseAsync(e, t) {
+    const n = this;
+    return new Promise(function(s, r) {
+      n.parse(e, t, s, r);
+    });
+  }
+};
+function nt() {
+  let e = {};
+  return {
+    get: function(t) {
+      return e[t];
+    },
+    add: function(t, n) {
+      e[t] = n;
+    },
+    remove: function(t) {
+      delete e[t];
+    },
+    removeAll: function() {
+      e = {};
+    }
+  };
+}
+function A(e, t, n) {
+  const s = e.json.materials[t];
+  return s.extensions && s.extensions[n] ? s.extensions[n] : null;
+}
+var m = {
+  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_DISPERSION: "KHR_materials_dispersion",
+  KHR_MATERIALS_IOR: "KHR_materials_ior",
+  KHR_MATERIALS_SHEEN: "KHR_materials_sheen",
+  KHR_MATERIALS_SPECULAR: "KHR_materials_specular",
+  KHR_MATERIALS_TRANSMISSION: "KHR_materials_transmission",
+  KHR_MATERIALS_IRIDESCENCE: "KHR_materials_iridescence",
+  KHR_MATERIALS_ANISOTROPY: "KHR_materials_anisotropy",
+  KHR_MATERIALS_UNLIT: "KHR_materials_unlit",
+  KHR_MATERIALS_VOLUME: "KHR_materials_volume",
+  KHR_TEXTURE_BASISU: "KHR_texture_basisu",
+  KHR_TEXTURE_TRANSFORM: "KHR_texture_transform",
+  KHR_MESH_QUANTIZATION: "KHR_mesh_quantization",
+  KHR_MATERIALS_EMISSIVE_STRENGTH: "KHR_materials_emissive_strength",
+  EXT_MATERIALS_BUMP: "EXT_materials_bump",
+  EXT_TEXTURE_WEBP: "EXT_texture_webp",
+  EXT_TEXTURE_AVIF: "EXT_texture_avif",
+  EXT_MESHOPT_COMPRESSION: "EXT_meshopt_compression",
+  KHR_MESHOPT_COMPRESSION: "KHR_meshopt_compression",
+  EXT_MESH_GPU_INSTANCING: "EXT_mesh_gpu_instancing"
+}, rt = class {
+  constructor(e) {
+    this.parser = e, this.name = m.KHR_LIGHTS_PUNCTUAL, this.cache = {
+      refs: {},
+      uses: {}
+    };
+  }
+  _markDefs() {
+    const e = this.parser, t = this.parser.json.nodes || [];
+    for (let n = 0, s = t.length; n < s; n++) {
+      const r = t[n];
+      r.extensions && r.extensions[this.name] && r.extensions[this.name].light !== void 0 && e._addNodeRef(this.cache, r.extensions[this.name].light);
+    }
+  }
+  _loadLight(e) {
+    const t = this.parser, n = "light:" + e;
+    let s = t.cache.get(n);
+    if (s) return s;
+    const r = t.json, i = ((r.extensions && r.extensions[this.name] || {}).lights || [])[e];
+    let o;
+    const a = new O(16777215);
+    i.color !== void 0 && a.setRGB(i.color[0], i.color[1], i.color[2], b);
+    const c = i.range !== void 0 ? i.range : 0;
+    switch (i.type) {
+      case "directional":
+        o = new ve(a), o.target.position.set(0, 0, -1), o.add(o.target);
+        break;
+      case "point":
+        o = new ze(a), o.distance = c;
+        break;
+      case "spot":
+        o = new et(a), o.distance = c, i.spot = i.spot || {}, i.spot.innerConeAngle = i.spot.innerConeAngle !== void 0 ? i.spot.innerConeAngle : 0, i.spot.outerConeAngle = i.spot.outerConeAngle !== void 0 ? i.spot.outerConeAngle : Math.PI / 4, o.angle = i.spot.outerConeAngle, o.penumbra = 1 - i.spot.innerConeAngle / i.spot.outerConeAngle, o.target.position.set(0, 0, -1), o.add(o.target);
+        break;
+      default:
+        throw new Error("THREE.GLTFLoader: Unexpected light type: " + i.type);
+    }
+    return o.position.set(0, 0, 0), M(o, i), i.intensity !== void 0 && (o.intensity = i.intensity), o.name = t.createUniqueName(i.name || "light_" + e), s = Promise.resolve(o), t.cache.add(n, s), s;
+  }
+  getDependency(e, t) {
+    if (e === "light")
+      return this._loadLight(t);
+  }
+  createNodeAttachment(e) {
+    const t = this, n = this.parser, s = n.json.nodes[e], r = (s.extensions && s.extensions[this.name] || {}).light;
+    return r === void 0 ? null : this._loadLight(r).then(function(i) {
+      return n._getNodeRef(t.cache, r, i);
+    });
+  }
+}, it = class {
+  constructor() {
+    this.name = m.KHR_MATERIALS_UNLIT;
+  }
+  getMaterialType() {
+    return H;
+  }
+  extendParams(e, t, n) {
+    const s = [];
+    e.color = new O(1, 1, 1), e.opacity = 1;
+    const r = t.pbrMetallicRoughness;
+    if (r) {
+      if (Array.isArray(r.baseColorFactor)) {
+        const i = r.baseColorFactor;
+        e.color.setRGB(i[0], i[1], i[2], b), e.opacity = i[3];
+      }
+      r.baseColorTexture !== void 0 && s.push(n.assignTexture(e, "map", r.baseColorTexture, G));
+    }
+    return Promise.all(s);
+  }
+}, ot = class {
+  constructor(e) {
+    this.parser = e, this.name = m.KHR_MATERIALS_EMISSIVE_STRENGTH;
+  }
+  extendMaterialParams(e, t) {
+    const n = A(this.parser, e, this.name);
+    return n === null || n.emissiveStrength !== void 0 && (t.emissiveIntensity = n.emissiveStrength), Promise.resolve();
+  }
+}, at = class {
+  constructor(e) {
+    this.parser = e, this.name = m.KHR_MATERIALS_CLEARCOAT;
+  }
+  getMaterialType(e) {
+    return A(this.parser, e, this.name) !== null ? x : null;
+  }
+  extendMaterialParams(e, t) {
+    const n = A(this.parser, e, this.name);
+    if (n === null) return Promise.resolve();
+    const s = [];
+    if (n.clearcoatFactor !== void 0 && (t.clearcoat = n.clearcoatFactor), n.clearcoatTexture !== void 0 && s.push(this.parser.assignTexture(t, "clearcoatMap", n.clearcoatTexture)), n.clearcoatRoughnessFactor !== void 0 && (t.clearcoatRoughness = n.clearcoatRoughnessFactor), n.clearcoatRoughnessTexture !== void 0 && s.push(this.parser.assignTexture(t, "clearcoatRoughnessMap", n.clearcoatRoughnessTexture)), n.clearcoatNormalTexture !== void 0 && (s.push(this.parser.assignTexture(t, "clearcoatNormalMap", n.clearcoatNormalTexture)), n.clearcoatNormalTexture.scale !== void 0)) {
+      const r = n.clearcoatNormalTexture.scale;
+      t.clearcoatNormalScale = new de(r, r);
+    }
+    return Promise.all(s);
+  }
+}, ct = class {
+  constructor(e) {
+    this.parser = e, this.name = m.KHR_MATERIALS_DISPERSION;
+  }
+  getMaterialType(e) {
+    return A(this.parser, e, this.name) !== null ? x : null;
+  }
+  extendMaterialParams(e, t) {
+    const n = A(this.parser, e, this.name);
+    return n === null || (t.dispersion = n.dispersion !== void 0 ? n.dispersion : 0), Promise.resolve();
+  }
+}, lt = class {
+  constructor(e) {
+    this.parser = e, this.name = m.KHR_MATERIALS_IRIDESCENCE;
+  }
+  getMaterialType(e) {
+    return A(this.parser, e, this.name) !== null ? x : null;
+  }
+  extendMaterialParams(e, t) {
+    const n = A(this.parser, e, this.name);
+    if (n === null) return Promise.resolve();
+    const s = [];
+    return n.iridescenceFactor !== void 0 && (t.iridescence = n.iridescenceFactor), n.iridescenceTexture !== void 0 && s.push(this.parser.assignTexture(t, "iridescenceMap", n.iridescenceTexture)), n.iridescenceIor !== void 0 && (t.iridescenceIOR = n.iridescenceIor), t.iridescenceThicknessRange === void 0 && (t.iridescenceThicknessRange = [100, 400]), n.iridescenceThicknessMinimum !== void 0 && (t.iridescenceThicknessRange[0] = n.iridescenceThicknessMinimum), n.iridescenceThicknessMaximum !== void 0 && (t.iridescenceThicknessRange[1] = n.iridescenceThicknessMaximum), n.iridescenceThicknessTexture !== void 0 && s.push(this.parser.assignTexture(t, "iridescenceThicknessMap", n.iridescenceThicknessTexture)), Promise.all(s);
+  }
+}, ut = class {
+  constructor(e) {
+    this.parser = e, this.name = m.KHR_MATERIALS_SHEEN;
+  }
+  getMaterialType(e) {
+    return A(this.parser, e, this.name) !== null ? x : null;
+  }
+  extendMaterialParams(e, t) {
+    const n = A(this.parser, e, this.name);
+    if (n === null) return Promise.resolve();
+    const s = [];
+    if (t.sheenColor = new O(0, 0, 0), t.sheenRoughness = 0, t.sheen = 1, n.sheenColorFactor !== void 0) {
+      const r = n.sheenColorFactor;
+      t.sheenColor.setRGB(r[0], r[1], r[2], b);
+    }
+    return n.sheenRoughnessFactor !== void 0 && (t.sheenRoughness = n.sheenRoughnessFactor), n.sheenColorTexture !== void 0 && s.push(this.parser.assignTexture(t, "sheenColorMap", n.sheenColorTexture, G)), n.sheenRoughnessTexture !== void 0 && s.push(this.parser.assignTexture(t, "sheenRoughnessMap", n.sheenRoughnessTexture)), Promise.all(s);
+  }
+}, ht = class {
+  constructor(e) {
+    this.parser = e, this.name = m.KHR_MATERIALS_TRANSMISSION;
+  }
+  getMaterialType(e) {
+    return A(this.parser, e, this.name) !== null ? x : null;
+  }
+  extendMaterialParams(e, t) {
+    const n = A(this.parser, e, this.name);
+    if (n === null) return Promise.resolve();
+    const s = [];
+    return n.transmissionFactor !== void 0 && (t.transmission = n.transmissionFactor), n.transmissionTexture !== void 0 && s.push(this.parser.assignTexture(t, "transmissionMap", n.transmissionTexture)), Promise.all(s);
+  }
+}, ft = class {
+  constructor(e) {
+    this.parser = e, this.name = m.KHR_MATERIALS_VOLUME;
+  }
+  getMaterialType(e) {
+    return A(this.parser, e, this.name) !== null ? x : null;
+  }
+  extendMaterialParams(e, t) {
+    const n = A(this.parser, e, this.name);
+    if (n === null) return Promise.resolve();
+    const s = [];
+    t.thickness = n.thicknessFactor !== void 0 ? n.thicknessFactor : 0, n.thicknessTexture !== void 0 && s.push(this.parser.assignTexture(t, "thicknessMap", n.thicknessTexture)), t.attenuationDistance = n.attenuationDistance || 1 / 0;
+    const r = n.attenuationColor || [
+      1,
+      1,
+      1
+    ];
+    return t.attenuationColor = new O().setRGB(r[0], r[1], r[2], b), Promise.all(s);
+  }
+}, dt = class {
+  constructor(e) {
+    this.parser = e, this.name = m.KHR_MATERIALS_IOR;
+  }
+  getMaterialType(e) {
+    return A(this.parser, e, this.name) !== null ? x : null;
+  }
+  extendMaterialParams(e, t) {
+    const n = A(this.parser, e, this.name);
+    return n === null || (t.ior = n.ior !== void 0 ? n.ior : 1.5, t.ior === 0 && (t.ior = 1e3)), Promise.resolve();
+  }
+}, pt = class {
+  constructor(e) {
+    this.parser = e, this.name = m.KHR_MATERIALS_SPECULAR;
+  }
+  getMaterialType(e) {
+    return A(this.parser, e, this.name) !== null ? x : null;
+  }
+  extendMaterialParams(e, t) {
+    const n = A(this.parser, e, this.name);
+    if (n === null) return Promise.resolve();
+    const s = [];
+    t.specularIntensity = n.specularFactor !== void 0 ? n.specularFactor : 1, n.specularTexture !== void 0 && s.push(this.parser.assignTexture(t, "specularIntensityMap", n.specularTexture));
+    const r = n.specularColorFactor || [
+      1,
+      1,
+      1
+    ];
+    return t.specularColor = new O().setRGB(r[0], r[1], r[2], b), n.specularColorTexture !== void 0 && s.push(this.parser.assignTexture(t, "specularColorMap", n.specularColorTexture, G)), Promise.all(s);
+  }
+}, mt = class {
+  constructor(e) {
+    this.parser = e, this.name = m.EXT_MATERIALS_BUMP;
+  }
+  getMaterialType(e) {
+    return A(this.parser, e, this.name) !== null ? x : null;
+  }
+  extendMaterialParams(e, t) {
+    const n = A(this.parser, e, this.name);
+    if (n === null) return Promise.resolve();
+    const s = [];
+    return t.bumpScale = n.bumpFactor !== void 0 ? n.bumpFactor : 1, n.bumpTexture !== void 0 && s.push(this.parser.assignTexture(t, "bumpMap", n.bumpTexture)), Promise.all(s);
+  }
+}, gt = class {
+  constructor(e) {
+    this.parser = e, this.name = m.KHR_MATERIALS_ANISOTROPY;
+  }
+  getMaterialType(e) {
+    return A(this.parser, e, this.name) !== null ? x : null;
+  }
+  extendMaterialParams(e, t) {
+    const n = A(this.parser, e, this.name);
+    if (n === null) return Promise.resolve();
+    const s = [];
+    return n.anisotropyStrength !== void 0 && (t.anisotropy = n.anisotropyStrength), n.anisotropyRotation !== void 0 && (t.anisotropyRotation = n.anisotropyRotation), n.anisotropyTexture !== void 0 && s.push(this.parser.assignTexture(t, "anisotropyMap", n.anisotropyTexture)), Promise.all(s);
+  }
+}, Tt = class {
+  constructor(e) {
+    this.parser = e, this.name = m.KHR_TEXTURE_BASISU;
+  }
+  loadTexture(e) {
+    const t = this.parser, n = t.json, s = n.textures[e];
+    if (!s.extensions || !s.extensions[this.name]) return null;
+    const r = s.extensions[this.name], i = t.options.ktx2Loader;
+    if (!i) {
+      if (n.extensionsRequired && n.extensionsRequired.indexOf(this.name) >= 0) throw new Error("THREE.GLTFLoader: setKTX2Loader must be called before loading KTX2 textures");
+      return null;
+    }
+    return t.loadTextureImage(e, r.source, i);
+  }
+}, Rt = class {
+  constructor(e) {
+    this.parser = e, this.name = m.EXT_TEXTURE_WEBP;
+  }
+  loadTexture(e) {
+    const t = this.name, n = this.parser, s = n.json, r = s.textures[e];
+    if (!r.extensions || !r.extensions[t]) return null;
+    const i = r.extensions[t], o = s.images[i.source];
+    let a = n.textureLoader;
+    if (o.uri) {
+      const c = n.options.manager.getHandler(o.uri);
+      c !== null && (a = c);
+    }
+    return n.loadTextureImage(e, i.source, a);
+  }
+}, Et = class {
+  constructor(e) {
+    this.parser = e, this.name = m.EXT_TEXTURE_AVIF;
+  }
+  loadTexture(e) {
+    const t = this.name, n = this.parser, s = n.json, r = s.textures[e];
+    if (!r.extensions || !r.extensions[t]) return null;
+    const i = r.extensions[t], o = s.images[i.source];
+    let a = n.textureLoader;
+    if (o.uri) {
+      const c = n.options.manager.getHandler(o.uri);
+      c !== null && (a = c);
+    }
+    return n.loadTextureImage(e, i.source, a);
+  }
+}, ne = class {
+  constructor(e, t) {
+    this.name = t, this.parser = e;
+  }
+  loadBufferView(e) {
+    const t = this.parser.json, n = t.bufferViews[e];
+    if (n.extensions && n.extensions[this.name]) {
+      const s = n.extensions[this.name], r = this.parser.getDependency("buffer", s.buffer), i = this.parser.options.meshoptDecoder;
+      if (!i || !i.supported) {
+        if (t.extensionsRequired && t.extensionsRequired.indexOf(this.name) >= 0) throw new Error("THREE.GLTFLoader: setMeshoptDecoder must be called before loading compressed files");
+        return null;
+      }
+      return r.then(function(o) {
+        const a = s.byteOffset || 0, c = s.byteLength || 0, l = s.count, u = s.byteStride, h = new Uint8Array(o, a, c);
+        return i.decodeGltfBufferAsync ? i.decodeGltfBufferAsync(l, u, h, s.mode, s.filter).then(function(f) {
+          return f.buffer;
+        }) : i.ready.then(function() {
+          const f = new ArrayBuffer(l * u);
+          return i.decodeGltfBuffer(new Uint8Array(f), l, u, h, s.mode, s.filter), f;
+        });
+      });
+    } else return null;
+  }
+}, At = class {
+  constructor(e) {
+    this.name = m.EXT_MESH_GPU_INSTANCING, this.parser = e;
+  }
+  createNodeMesh(e) {
+    const t = this.parser.json, n = t.nodes[e];
+    if (!n.extensions || !n.extensions[this.name] || n.mesh === void 0) return null;
+    const s = t.meshes[n.mesh];
+    for (const a of s.primitives) if (a.mode !== v.TRIANGLES && a.mode !== v.TRIANGLE_STRIP && a.mode !== v.TRIANGLE_FAN && a.mode !== void 0) return null;
+    const r = n.extensions[this.name].attributes, i = [], o = {};
+    for (const a in r) i.push(this.parser.getDependency("accessor", r[a]).then((c) => (o[a] = c, o[a])));
+    return i.length < 1 ? null : (i.push(this.parser.createNodeMesh(e)), Promise.all(i).then((a) => {
+      const c = a.pop(), l = c.isGroup ? c.children : [c], u = a[0].count, h = [];
+      for (const f of l) {
+        const p = new U(), g = new I(), d = new fe(), T = new I(1, 1, 1), E = new xe(f.geometry, f.material, u);
+        for (let R = 0; R < u; R++)
+          o.TRANSLATION && g.fromBufferAttribute(o.TRANSLATION, R), o.ROTATION && d.fromBufferAttribute(o.ROTATION, R), o.SCALE && T.fromBufferAttribute(o.SCALE, R), E.setMatrixAt(R, p.compose(g, d, T));
+        for (const R in o) if (R === "_COLOR_0") {
+          const _ = o[R];
+          E.instanceColor = new Me(_.array, _.itemSize, _.normalized);
+        } else R !== "TRANSLATION" && R !== "ROTATION" && R !== "SCALE" && f.geometry.setAttribute(R, o[R]);
+        he.prototype.copy.call(E, f), this.parser.assignFinalMaterial(E), h.push(E);
+      }
+      return c.isGroup ? (c.clear(), c.add(...h), c) : h[0];
+    }));
+  }
+}, me = "glTF", k = 12, re = {
+  JSON: 1313821514,
+  BIN: 5130562
+}, _t = class {
+  constructor(e) {
+    this.name = m.KHR_BINARY_GLTF, this.content = null, this.body = null;
+    const t = new DataView(e, 0, k), n = new TextDecoder();
+    if (this.header = {
+      magic: n.decode(new Uint8Array(e.slice(0, 4))),
+      version: t.getUint32(4, !0),
+      length: t.getUint32(8, !0)
+    }, this.header.magic !== me) throw new Error("THREE.GLTFLoader: Unsupported glTF-Binary header.");
+    if (this.header.version < 2) throw new Error("THREE.GLTFLoader: Legacy binary file detected.");
+    const s = this.header.length - k, r = new DataView(e, k);
+    let i = 0;
+    for (; i < s; ) {
+      const o = r.getUint32(i, !0);
+      i += 4;
+      const a = r.getUint32(i, !0);
+      if (i += 4, a === re.JSON) {
+        const c = new Uint8Array(e, k + i, o);
+        this.content = n.decode(c);
+      } else if (a === re.BIN) {
+        const c = k + i;
+        this.body = e.slice(c, c + o);
+      }
+      i += o;
+    }
+    if (this.content === null) throw new Error("THREE.GLTFLoader: JSON content not found.");
+  }
+}, vt = class {
+  constructor(e, t) {
+    if (!t) throw new Error("THREE.GLTFLoader: No DRACOLoader instance provided.");
+    this.name = m.KHR_DRACO_MESH_COMPRESSION, this.json = e, this.dracoLoader = t, this.dracoLoader.preload();
+  }
+  decodePrimitive(e, t) {
+    const n = this.json, s = this.dracoLoader, r = e.extensions[this.name].bufferView, i = e.extensions[this.name].attributes, o = {}, a = {}, c = {};
+    for (const l in i) {
+      const u = Y[l] || l.toLowerCase();
+      o[u] = i[l];
+    }
+    for (const l in e.attributes) {
+      const u = Y[l] || l.toLowerCase();
+      if (i[l] !== void 0) {
+        const h = n.accessors[e.attributes[l]];
+        c[u] = F[h.componentType].name, a[u] = h.normalized === !0;
+      }
+    }
+    return t.getDependency("bufferView", r).then(function(l) {
+      return new Promise(function(u, h) {
+        s.decodeDracoFile(l, function(f) {
+          for (const p in f.attributes) {
+            const g = f.attributes[p], d = a[p];
+            d !== void 0 && (g.normalized = d);
+          }
+          u(f);
+        }, o, c, b, h);
+      });
+    });
+  }
+}, Lt = class {
+  constructor() {
+    this.name = m.KHR_TEXTURE_TRANSFORM;
+  }
+  extendTexture(e, t) {
+    return (t.texCoord === void 0 || t.texCoord === e.channel) && t.offset === void 0 && t.rotation === void 0 && t.scale === void 0 || (e = e.clone(), t.texCoord !== void 0 && (e.channel = t.texCoord), t.offset !== void 0 && e.offset.fromArray(t.offset), t.rotation !== void 0 && (e.rotation = t.rotation), t.scale !== void 0 && e.repeat.fromArray(t.scale), e.needsUpdate = !0), e;
+  }
+}, Mt = class {
+  constructor() {
+    this.name = m.KHR_MESH_QUANTIZATION;
+  }
+}, ge = class extends we {
+  constructor(e, t, n, s) {
+    super(e, t, n, s);
+  }
+  copySampleValue_(e) {
+    const t = this.resultBuffer, n = this.sampleValues, s = this.valueSize, r = e * s * 3 + s;
+    for (let i = 0; i !== s; i++) t[i] = n[r + i];
+    return t;
+  }
+  interpolate_(e, t, n, s) {
+    const r = this.resultBuffer, i = this.sampleValues, o = this.valueSize, a = o * 2, c = o * 3, l = s - t, u = (n - t) / l, h = u * u, f = h * u, p = e * c, g = p - c, d = -2 * f + 3 * h, T = f - h, E = 1 - d, R = T - h + u;
+    for (let _ = 0; _ !== o; _++) {
+      const S = i[g + _ + o], y = i[g + _ + a] * l, L = i[p + _ + o], P = i[p + _] * l;
+      r[_] = E * S + R * y + d * L + T * P;
+    }
+    return r;
+  }
+}, xt = new fe(), St = class extends ge {
+  interpolate_(e, t, n, s) {
+    const r = super.interpolate_(e, t, n, s);
+    return xt.fromArray(r).normalize().toArray(r), r;
+  }
+}, v = {
+  FLOAT: 5126,
+  FLOAT_MAT3: 35675,
+  FLOAT_MAT4: 35676,
+  FLOAT_VEC2: 35664,
+  FLOAT_VEC3: 35665,
+  FLOAT_VEC4: 35666,
+  LINEAR: 9729,
+  REPEAT: 10497,
+  SAMPLER_2D: 35678,
+  POINTS: 0,
+  LINES: 1,
+  LINE_LOOP: 2,
+  LINE_STRIP: 3,
+  TRIANGLES: 4,
+  TRIANGLE_STRIP: 5,
+  TRIANGLE_FAN: 6,
+  UNSIGNED_BYTE: 5121,
+  UNSIGNED_SHORT: 5123
+}, F = {
+  5120: Int8Array,
+  5121: Uint8Array,
+  5122: Int16Array,
+  5123: Uint16Array,
+  5125: Uint32Array,
+  5126: Float32Array
+}, ie = {
+  9728: Be,
+  9729: Fe,
+  9984: je,
+  9985: ke,
+  9986: Ke,
+  9987: Pe
+}, oe = {
+  33071: _e,
+  33648: Ue,
+  10497: Qe
+}, z = {
+  SCALAR: 1,
+  VEC2: 2,
+  VEC3: 3,
+  VEC4: 4,
+  MAT2: 4,
+  MAT3: 9,
+  MAT4: 16
+}, Y = {
+  POSITION: "position",
+  NORMAL: "normal",
+  TANGENT: "tangent",
+  TEXCOORD_0: "uv",
+  TEXCOORD_1: "uv1",
+  TEXCOORD_2: "uv2",
+  TEXCOORD_3: "uv3",
+  COLOR_0: "color",
+  WEIGHTS_0: "skinWeight",
+  JOINTS_0: "skinIndex"
+}, w = {
+  scale: "scale",
+  translation: "position",
+  rotation: "quaternion",
+  weights: "morphTargetInfluences"
+}, yt = {
+  CUBICSPLINE: void 0,
+  LINEAR: le,
+  STEP: be
+}, q = {
+  OPAQUE: "OPAQUE",
+  MASK: "MASK",
+  BLEND: "BLEND"
+};
+function wt(e) {
+  return e.DefaultMaterial === void 0 && (e.DefaultMaterial = new ue({
+    color: 16777215,
+    emissive: 0,
+    metalness: 1,
+    roughness: 1,
+    transparent: !1,
+    depthTest: !0,
+    side: 0
+  })), e.DefaultMaterial;
+}
+function N(e, t, n) {
+  for (const s in n.extensions) e[s] === void 0 && (t.userData.gltfExtensions = t.userData.gltfExtensions || {}, t.userData.gltfExtensions[s] = n.extensions[s]);
+}
+function M(e, t) {
+  t.extras !== void 0 && (typeof t.extras == "object" ? Object.assign(e.userData, t.extras) : console.warn("THREE.GLTFLoader: Ignoring primitive type .extras, " + t.extras));
+}
+function bt(e, t, n) {
+  let s = !1, r = !1, i = !1;
+  for (let l = 0, u = t.length; l < u; l++) {
+    const h = t[l];
+    if (h.POSITION !== void 0 && (s = !0), h.NORMAL !== void 0 && (r = !0), h.COLOR_0 !== void 0 && (i = !0), s && r && i) break;
+  }
+  if (!s && !r && !i) return Promise.resolve(e);
+  const o = [], a = [], c = [];
+  for (let l = 0, u = t.length; l < u; l++) {
+    const h = t[l];
+    if (s) {
+      const f = h.POSITION !== void 0 ? n.getDependency("accessor", h.POSITION) : e.attributes.position;
+      o.push(f);
+    }
+    if (r) {
+      const f = h.NORMAL !== void 0 ? n.getDependency("accessor", h.NORMAL) : e.attributes.normal;
+      a.push(f);
+    }
+    if (i) {
+      const f = h.COLOR_0 !== void 0 ? n.getDependency("accessor", h.COLOR_0) : e.attributes.color;
+      c.push(f);
+    }
+  }
+  return Promise.all([
+    Promise.all(o),
+    Promise.all(a),
+    Promise.all(c)
+  ]).then(function(l) {
+    const u = l[0], h = l[1], f = l[2];
+    return s && (e.morphAttributes.position = u), r && (e.morphAttributes.normal = h), i && (e.morphAttributes.color = f), e.morphTargetsRelative = !0, e;
+  });
+}
+function Nt(e, t) {
+  if (e.updateMorphTargets(), t.weights !== void 0) for (let n = 0, s = t.weights.length; n < s; n++) e.morphTargetInfluences[n] = t.weights[n];
+  if (t.extras && Array.isArray(t.extras.targetNames)) {
+    const n = t.extras.targetNames;
+    if (e.morphTargetInfluences.length === n.length) {
+      e.morphTargetDictionary = {};
+      for (let s = 0, r = n.length; s < r; s++) e.morphTargetDictionary[n[s]] = s;
+    } else console.warn("THREE.GLTFLoader: Invalid extras.targetNames length. Ignoring names.");
+  }
+}
+function It(e) {
+  let t;
+  const n = e.extensions && e.extensions[m.KHR_DRACO_MESH_COMPRESSION];
+  if (n ? t = "draco:" + n.bufferView + ":" + n.indices + ":" + W(n.attributes) : t = e.indices + ":" + W(e.attributes) + ":" + e.mode, e.targets !== void 0) for (let s = 0, r = e.targets.length; s < r; s++) t += ":" + W(e.targets[s]);
+  return t;
+}
+function W(e) {
+  let t = "";
+  const n = Object.keys(e).sort();
+  for (let s = 0, r = n.length; s < r; s++) t += n[s] + ":" + e[n[s]] + ";";
+  return t;
+}
+function Q(e) {
+  switch (e) {
+    case Int8Array:
+      return 1 / 127;
+    case Uint8Array:
+      return 1 / 255;
+    case Int16Array:
+      return 1 / 32767;
+    case Uint16Array:
+      return 1 / 65535;
+    default:
+      throw new Error("THREE.GLTFLoader: Unsupported normalized accessor component type.");
+  }
+}
+function Ot(e) {
+  return e.search(/\.jpe?g($|\?)/i) > 0 || e.search(/^data\:image\/jpeg/) === 0 ? "image/jpeg" : e.search(/\.webp($|\?)/i) > 0 || e.search(/^data\:image\/webp/) === 0 ? "image/webp" : e.search(/\.ktx2($|\?)/i) > 0 || e.search(/^data\:image\/ktx2/) === 0 ? "image/ktx2" : "image/png";
+}
+var Ct = new U(), Ft = class {
+  constructor(e = {}, t = {}) {
+    this.json = e, this.extensions = {}, this.plugins = {}, this.options = t, this.cache = new nt(), this.associations = /* @__PURE__ */ new Map(), this.primitiveCache = {}, this.nodeCache = {}, this.meshCache = {
+      refs: {},
+      uses: {}
+    }, this.cameraCache = {
+      refs: {},
+      uses: {}
+    }, this.lightCache = {
+      refs: {},
+      uses: {}
+    }, this.sourceCache = {}, this.textureCache = {}, this.nodeNamesUsed = {};
+    let n = !1, s = -1, r = !1, i = -1;
+    if (typeof navigator < "u" && typeof navigator.userAgent < "u") {
+      const o = navigator.userAgent;
+      n = /^((?!chrome|android).)*safari/i.test(o) === !0;
+      const a = o.match(/Version\/(\d+)/);
+      s = n && a ? parseInt(a[1], 10) : -1, r = o.indexOf("Firefox") > -1, i = r ? o.match(/Firefox\/([0-9]+)\./)[1] : -1;
+    }
+    typeof createImageBitmap > "u" || n && s < 17 || r && i < 98 ? this.textureLoader = new tt(this.options.manager) : this.textureLoader = new Le(this.options.manager), this.textureLoader.setCrossOrigin(this.options.crossOrigin), this.textureLoader.setRequestHeader(this.options.requestHeader), this.fileLoader = new ce(this.options.manager), this.fileLoader.setResponseType("arraybuffer"), this.options.crossOrigin === "use-credentials" && this.fileLoader.setWithCredentials(!0);
+  }
+  setExtensions(e) {
+    this.extensions = e;
+  }
+  setPlugins(e) {
+    this.plugins = e;
+  }
+  parse(e, t) {
+    const n = this, s = this.json, r = this.extensions;
+    this.cache.removeAll(), this.nodeCache = {}, this._invokeAll(function(i) {
+      return i._markDefs && i._markDefs();
+    }), Promise.all(this._invokeAll(function(i) {
+      return i.beforeRoot && i.beforeRoot();
+    })).then(function() {
+      return Promise.all([
+        n.getDependencies("scene"),
+        n.getDependencies("animation"),
+        n.getDependencies("camera")
+      ]);
+    }).then(function(i) {
+      const o = {
+        scene: i[0][s.scene || 0],
+        scenes: i[0],
+        animations: i[1],
+        cameras: i[2],
+        asset: s.asset,
+        parser: n,
+        userData: {}
+      };
+      return N(r, o, s), M(o, s), Promise.all(n._invokeAll(function(a) {
+        return a.afterRoot && a.afterRoot(o);
+      })).then(function() {
+        for (const a of o.scenes) a.updateMatrixWorld();
+        e(o);
+      });
+    }).catch(t);
+  }
+  _markDefs() {
+    const e = this.json.nodes || [], t = this.json.skins || [], n = this.json.meshes || [];
+    for (let s = 0, r = t.length; s < r; s++) {
+      const i = t[s].joints;
+      for (let o = 0, a = i.length; o < a; o++) e[i[o]].isBone = !0;
+    }
+    for (let s = 0, r = e.length; s < r; s++) {
+      const i = e[s];
+      i.mesh !== void 0 && (this._addNodeRef(this.meshCache, i.mesh), i.skin !== void 0 && (n[i.mesh].isSkinnedMesh = !0)), i.camera !== void 0 && this._addNodeRef(this.cameraCache, i.camera);
+    }
+  }
+  _addNodeRef(e, t) {
+    t !== void 0 && (e.refs[t] === void 0 && (e.refs[t] = e.uses[t] = 0), e.refs[t]++);
+  }
+  _getNodeRef(e, t, n) {
+    if (e.refs[t] <= 1) return n;
+    const s = n.clone(), r = (i, o) => {
+      const a = this.associations.get(i);
+      a != null && this.associations.set(o, a);
+      for (const [c, l] of i.children.entries()) r(l, o.children[c]);
+    };
+    return r(n, s), s.name += "_instance_" + e.uses[t]++, s;
+  }
+  _invokeOne(e) {
+    const t = Object.values(this.plugins);
+    t.push(this);
+    for (let n = 0; n < t.length; n++) {
+      const s = e(t[n]);
+      if (s) return s;
+    }
+    return null;
+  }
+  _invokeAll(e) {
+    const t = Object.values(this.plugins);
+    t.unshift(this);
+    const n = [];
+    for (let s = 0; s < t.length; s++) {
+      const r = e(t[s]);
+      r && n.push(r);
+    }
+    return n;
+  }
+  getDependency(e, t) {
+    const n = e + ":" + t;
+    let s = this.cache.get(n);
+    if (!s) {
+      switch (e) {
+        case "scene":
+          s = this.loadScene(t);
+          break;
+        case "node":
+          s = this._invokeOne(function(r) {
+            return r.loadNode && r.loadNode(t);
+          });
+          break;
+        case "mesh":
+          s = this._invokeOne(function(r) {
+            return r.loadMesh && r.loadMesh(t);
+          });
+          break;
+        case "accessor":
+          s = this.loadAccessor(t);
+          break;
+        case "bufferView":
+          s = this._invokeOne(function(r) {
+            return r.loadBufferView && r.loadBufferView(t);
+          });
+          break;
+        case "buffer":
+          s = this.loadBuffer(t);
+          break;
+        case "material":
+          s = this._invokeOne(function(r) {
+            return r.loadMaterial && r.loadMaterial(t);
+          });
+          break;
+        case "texture":
+          s = this._invokeOne(function(r) {
+            return r.loadTexture && r.loadTexture(t);
+          });
+          break;
+        case "skin":
+          s = this.loadSkin(t);
+          break;
+        case "animation":
+          s = this._invokeOne(function(r) {
+            return r.loadAnimation && r.loadAnimation(t);
+          });
+          break;
+        case "camera":
+          s = this.loadCamera(t);
+          break;
+        default:
+          if (s = this._invokeOne(function(r) {
+            return r != this && r.getDependency && r.getDependency(e, t);
+          }), !s) throw new Error("Unknown type: " + e);
+          break;
+      }
+      this.cache.add(n, s);
+    }
+    return s;
+  }
+  getDependencies(e) {
+    let t = this.cache.get(e);
+    if (!t) {
+      const n = this, s = this.json[e + (e === "mesh" ? "es" : "s")] || [];
+      t = Promise.all(s.map(function(r, i) {
+        return n.getDependency(e, i);
+      })), this.cache.add(e, t);
+    }
+    return t;
+  }
+  loadBuffer(e) {
+    const t = this.json.buffers[e], n = this.fileLoader;
+    if (t.type && t.type !== "arraybuffer") throw new Error("THREE.GLTFLoader: " + t.type + " buffer type is not supported.");
+    if (t.uri === void 0 && e === 0) return Promise.resolve(this.extensions[m.KHR_BINARY_GLTF].body);
+    const s = this.options;
+    return new Promise(function(r, i) {
+      n.load(D.resolveURL(t.uri, s.path), r, void 0, function() {
+        i(/* @__PURE__ */ new Error('THREE.GLTFLoader: Failed to load buffer "' + t.uri + '".'));
+      });
+    });
+  }
+  loadBufferView(e) {
+    const t = this.json.bufferViews[e];
+    return this.getDependency("buffer", t.buffer).then(function(n) {
+      const s = t.byteLength || 0, r = t.byteOffset || 0;
+      return n.slice(r, r + s);
+    });
+  }
+  loadAccessor(e) {
+    const t = this, n = this.json, s = this.json.accessors[e];
+    if (s.bufferView === void 0 && s.sparse === void 0) {
+      const i = z[s.type], o = F[s.componentType], a = s.normalized === !0, c = new o(s.count * i);
+      return Promise.resolve(new j(c, i, a));
+    }
+    const r = [];
+    return s.bufferView !== void 0 ? r.push(this.getDependency("bufferView", s.bufferView)) : r.push(null), s.sparse !== void 0 && (r.push(this.getDependency("bufferView", s.sparse.indices.bufferView)), r.push(this.getDependency("bufferView", s.sparse.values.bufferView))), Promise.all(r).then(function(i) {
+      const o = i[0], a = z[s.type], c = F[s.componentType], l = c.BYTES_PER_ELEMENT, u = l * a, h = s.byteOffset || 0, f = s.bufferView !== void 0 ? n.bufferViews[s.bufferView].byteStride : void 0, p = s.normalized === !0;
+      let g, d;
+      if (f && f !== u) {
+        const T = Math.floor(h / f), E = "InterleavedBuffer:" + s.bufferView + ":" + s.componentType + ":" + T + ":" + s.count;
+        let R = t.cache.get(E);
+        R || (g = new c(o, T * f, s.count * f / l), R = new Se(g, f / l), t.cache.add(E, R)), d = new ye(R, a, h % f / l, p);
+      } else
+        o === null ? g = new c(s.count * a) : g = new c(o, h, s.count * a), d = new j(g, a, p);
+      if (s.sparse !== void 0) {
+        const T = z.SCALAR, E = F[s.sparse.indices.componentType], R = s.sparse.indices.byteOffset || 0, _ = s.sparse.values.byteOffset || 0, S = new E(i[1], R, s.sparse.count * T), y = new c(i[2], _, s.sparse.count * a);
+        o !== null && (d = new j(d.array.slice(), d.itemSize, d.normalized)), d.normalized = !1;
+        for (let L = 0, P = S.length; L < P; L++) {
+          const C = S[L];
+          if (d.setX(C, y[L * a]), a >= 2 && d.setY(C, y[L * a + 1]), a >= 3 && d.setZ(C, y[L * a + 2]), a >= 4 && d.setW(C, y[L * a + 3]), a >= 5) throw new Error("THREE.GLTFLoader: Unsupported itemSize in sparse BufferAttribute.");
+        }
+        d.normalized = p;
+      }
+      return d;
+    });
+  }
+  loadTexture(e) {
+    const t = this.json, n = this.options, s = t.textures[e].source, r = t.images[s];
+    let i = this.textureLoader;
+    if (r.uri) {
+      const o = n.manager.getHandler(r.uri);
+      o !== null && (i = o);
+    }
+    return this.loadTextureImage(e, s, i);
+  }
+  loadTextureImage(e, t, n) {
+    const s = this, r = this.json, i = r.textures[e], o = r.images[t], a = (o.uri || o.bufferView) + ":" + i.sampler;
+    if (this.textureCache[a]) return this.textureCache[a];
+    const c = this.loadImageSource(t, n).then(function(l) {
+      l.flipY = !1, l.name = i.name || o.name || "", l.name === "" && typeof o.uri == "string" && o.uri.startsWith("data:image/") === !1 && (l.name = o.uri);
+      const u = (r.samplers || {})[i.sampler] || {};
+      return l.magFilter = ie[u.magFilter] || 1006, l.minFilter = ie[u.minFilter] || 1008, l.wrapS = oe[u.wrapS] || 1e3, l.wrapT = oe[u.wrapT] || 1e3, l.generateMipmaps = !l.isCompressedTexture && l.minFilter !== 1003 && l.minFilter !== 1006, s.associations.set(l, { textures: e }), l;
+    }).catch(function() {
+      return null;
+    });
+    return this.textureCache[a] = c, c;
+  }
+  loadImageSource(e, t) {
+    const n = this, s = this.json, r = this.options;
+    if (this.sourceCache[e] !== void 0) return this.sourceCache[e].then((u) => u.clone());
+    const i = s.images[e], o = self.URL || self.webkitURL;
+    let a = i.uri || "", c = !1;
+    if (i.bufferView !== void 0) a = n.getDependency("bufferView", i.bufferView).then(function(u) {
+      c = !0;
+      const h = new Blob([u], { type: i.mimeType });
+      return a = o.createObjectURL(h), a;
+    });
+    else if (i.uri === void 0) throw new Error("THREE.GLTFLoader: Image " + e + " is missing URI and bufferView");
+    const l = Promise.resolve(a).then(function(u) {
+      return new Promise(function(h, f) {
+        let p = h;
+        t.isImageBitmapLoader === !0 && (p = function(g) {
+          const d = new ee(g);
+          d.needsUpdate = !0, h(d);
+        }), t.load(D.resolveURL(u, r.path), p, void 0, f);
+      });
+    }).then(function(u) {
+      return c === !0 && o.revokeObjectURL(a), M(u, i), u.userData.mimeType = i.mimeType || Ot(i.uri), u;
+    }).catch(function(u) {
+      throw console.error("THREE.GLTFLoader: Couldn't load texture", a), u;
+    });
+    return this.sourceCache[e] = l, l;
+  }
+  assignTexture(e, t, n, s) {
+    const r = this;
+    return this.getDependency("texture", n.index).then(function(i) {
+      if (!i) return null;
+      if (n.texCoord !== void 0 && n.texCoord > 0 && (i = i.clone(), i.channel = n.texCoord), r.extensions[m.KHR_TEXTURE_TRANSFORM]) {
+        const o = n.extensions !== void 0 ? n.extensions[m.KHR_TEXTURE_TRANSFORM] : void 0;
+        if (o) {
+          const a = r.associations.get(i);
+          i = r.extensions[m.KHR_TEXTURE_TRANSFORM].extendTexture(i, o), r.associations.set(i, a);
+        }
+      }
+      return s !== void 0 && (i.colorSpace = s), e[t] = i, i;
+    });
+  }
+  assignFinalMaterial(e) {
+    const t = e.geometry;
+    let n = e.material;
+    const s = t.attributes.tangent === void 0, r = t.attributes.color !== void 0, i = t.attributes.normal === void 0;
+    if (e.isPoints) {
+      const o = "PointsMaterial:" + n.uuid;
+      let a = this.cache.get(o);
+      a || (a = new We(), X.prototype.copy.call(a, n), a.color.copy(n.color), a.map = n.map, a.sizeAttenuation = !1, this.cache.add(o, a)), n = a;
+    } else if (e.isLine) {
+      const o = "LineBasicMaterial:" + n.uuid;
+      let a = this.cache.get(o);
+      a || (a = new Ie(), X.prototype.copy.call(a, n), a.color.copy(n.color), a.map = n.map, this.cache.add(o, a)), n = a;
+    }
+    if (s || r || i) {
+      let o = "ClonedMaterial:" + n.uuid + ":";
+      s && (o += "derivative-tangents:"), r && (o += "vertex-colors:"), i && (o += "flat-shading:");
+      let a = this.cache.get(o);
+      a || (a = n.clone(), r && (a.vertexColors = !0), i && (a.flatShading = !0), s && (a.normalScale && (a.normalScale.y *= -1), a.clearcoatNormalScale && (a.clearcoatNormalScale.y *= -1)), this.cache.add(o, a), this.associations.set(a, this.associations.get(n))), n = a;
+    }
+    e.material = n;
+  }
+  getMaterialType() {
+    return ue;
+  }
+  loadMaterial(e) {
+    const t = this, n = this.json, s = this.extensions, r = n.materials[e];
+    let i;
+    const o = {}, a = r.extensions || {}, c = [];
+    if (a[m.KHR_MATERIALS_UNLIT]) {
+      const u = s[m.KHR_MATERIALS_UNLIT];
+      i = u.getMaterialType(), c.push(u.extendParams(o, r, t));
+    } else {
+      const u = r.pbrMetallicRoughness || {};
+      if (o.color = new O(1, 1, 1), o.opacity = 1, Array.isArray(u.baseColorFactor)) {
+        const h = u.baseColorFactor;
+        o.color.setRGB(h[0], h[1], h[2], b), o.opacity = h[3];
+      }
+      u.baseColorTexture !== void 0 && c.push(t.assignTexture(o, "map", u.baseColorTexture, G)), o.metalness = u.metallicFactor !== void 0 ? u.metallicFactor : 1, o.roughness = u.roughnessFactor !== void 0 ? u.roughnessFactor : 1, u.metallicRoughnessTexture !== void 0 && (c.push(t.assignTexture(o, "metalnessMap", u.metallicRoughnessTexture)), c.push(t.assignTexture(o, "roughnessMap", u.metallicRoughnessTexture))), i = this._invokeOne(function(h) {
+        return h.getMaterialType && h.getMaterialType(e);
+      }), c.push(Promise.all(this._invokeAll(function(h) {
+        return h.extendMaterialParams && h.extendMaterialParams(e, o);
+      })));
+    }
+    r.doubleSided === !0 && (o.side = 2);
+    const l = r.alphaMode || q.OPAQUE;
+    if (l === q.BLEND ? (o.transparent = !0, o.depthWrite = !1) : (o.transparent = !1, l === q.MASK && (o.alphaTest = r.alphaCutoff !== void 0 ? r.alphaCutoff : 0.5)), r.normalTexture !== void 0 && i !== H && (c.push(t.assignTexture(o, "normalMap", r.normalTexture)), o.normalScale = new de(1, 1), r.normalTexture.scale !== void 0)) {
+      const u = r.normalTexture.scale;
+      o.normalScale.set(u, u);
+    }
+    if (r.occlusionTexture !== void 0 && i !== H && (c.push(t.assignTexture(o, "aoMap", r.occlusionTexture)), r.occlusionTexture.strength !== void 0 && (o.aoMapIntensity = r.occlusionTexture.strength)), r.emissiveFactor !== void 0 && i !== H) {
+      const u = r.emissiveFactor;
+      o.emissive = new O().setRGB(u[0], u[1], u[2], b);
+    }
+    return r.emissiveTexture !== void 0 && i !== H && c.push(t.assignTexture(o, "emissiveMap", r.emissiveTexture, G)), Promise.all(c).then(function() {
+      const u = new i(o);
+      return r.name && (u.name = r.name), M(u, r), t.associations.set(u, { materials: e }), r.extensions && N(s, u, r), u;
+    });
+  }
+  createUniqueName(e) {
+    const t = Ye.sanitizeNodeName(e || "");
+    return t in this.nodeNamesUsed ? t + "_" + ++this.nodeNamesUsed[t] : (this.nodeNamesUsed[t] = 0, t);
+  }
+  loadGeometries(e) {
+    const t = this, n = this.extensions, s = this.primitiveCache;
+    function r(o) {
+      return n[m.KHR_DRACO_MESH_COMPRESSION].decodePrimitive(o, t).then(function(a) {
+        return ae(a, o, t);
+      });
+    }
+    const i = [];
+    for (let o = 0, a = e.length; o < a; o++) {
+      const c = e[o], l = It(c), u = s[l];
+      if (u) i.push(u.promise);
+      else {
+        let h;
+        c.extensions && c.extensions[m.KHR_DRACO_MESH_COMPRESSION] ? h = r(c) : h = ae(new Ae(), c, t), s[l] = {
+          primitive: c,
+          promise: h
+        }, i.push(h);
+      }
+    }
+    return Promise.all(i);
+  }
+  loadMesh(e) {
+    const t = this, n = this.json, s = this.extensions, r = n.meshes[e], i = r.primitives, o = [];
+    for (let a = 0, c = i.length; a < c; a++) {
+      const l = i[a].material === void 0 ? wt(this.cache) : this.getDependency("material", i[a].material);
+      o.push(l);
+    }
+    return o.push(t.loadGeometries(i)), Promise.all(o).then(function(a) {
+      const c = a.slice(0, a.length - 1), l = a[a.length - 1], u = [];
+      for (let f = 0, p = l.length; f < p; f++) {
+        const g = l[f], d = i[f];
+        let T;
+        const E = c[f];
+        if (d.mode === v.TRIANGLES || d.mode === v.TRIANGLE_STRIP || d.mode === v.TRIANGLE_FAN || d.mode === void 0)
+          T = r.isSkinnedMesh === !0 ? new Ze(g, E) : new Ge(g, E), T.isSkinnedMesh === !0 && T.normalizeSkinWeights(), d.mode === v.TRIANGLE_STRIP ? T.geometry = se(T.geometry, 1) : d.mode === v.TRIANGLE_FAN && (T.geometry = se(T.geometry, 2));
+        else if (d.mode === v.LINES) T = new Ce(g, E);
+        else if (d.mode === v.LINE_STRIP) T = new Ne(g, E);
+        else if (d.mode === v.LINE_LOOP) T = new Oe(g, E);
+        else if (d.mode === v.POINTS) T = new qe(g, E);
+        else throw new Error("THREE.GLTFLoader: Primitive mode unsupported: " + d.mode);
+        Object.keys(T.geometry.morphAttributes).length > 0 && Nt(T, r), T.name = t.createUniqueName(r.name || "mesh_" + e), M(T, r), d.extensions && N(s, T, d), t.assignFinalMaterial(T), u.push(T);
+      }
+      for (let f = 0, p = u.length; f < p; f++) t.associations.set(u[f], {
+        meshes: e,
+        primitives: f
+      });
+      if (u.length === 1)
+        return r.extensions && N(s, u[0], r), u[0];
+      const h = new V();
+      r.extensions && N(s, h, r), t.associations.set(h, { meshes: e });
+      for (let f = 0, p = u.length; f < p; f++) h.add(u[f]);
+      return h;
+    });
+  }
+  loadCamera(e) {
+    let t;
+    const n = this.json.cameras[e], s = n[n.type];
+    if (!s) {
+      console.warn("THREE.GLTFLoader: Missing camera parameters.");
+      return;
+    }
+    return n.type === "perspective" ? t = new Xe(De.radToDeg(s.yfov), s.aspectRatio || 1, s.znear || 1, s.zfar || 2e6) : n.type === "orthographic" && (t = new Ve(-s.xmag, s.xmag, s.ymag, -s.ymag, s.znear, s.zfar)), n.name && (t.name = this.createUniqueName(n.name)), M(t, n), Promise.resolve(t);
+  }
+  loadSkin(e) {
+    const t = this.json.skins[e], n = [];
+    for (let s = 0, r = t.joints.length; s < r; s++) n.push(this._loadNodeShallow(t.joints[s]));
+    return t.inverseBindMatrices !== void 0 ? n.push(this.getDependency("accessor", t.inverseBindMatrices)) : n.push(null), Promise.all(n).then(function(s) {
+      const r = s.pop(), i = s, o = [], a = [];
+      for (let c = 0, l = i.length; c < l; c++) {
+        const u = i[c];
+        if (u) {
+          o.push(u);
+          const h = new U();
+          r !== null && h.fromArray(r.array, c * 16), a.push(h);
+        } else console.warn('THREE.GLTFLoader: Joint "%s" could not be found.', t.joints[c]);
+      }
+      return new Je(o, a);
+    });
+  }
+  loadAnimation(e) {
+    const t = this.json, n = this, s = t.animations[e], r = s.name ? s.name : "animation_" + e, i = [], o = [], a = [], c = [], l = [];
+    for (let u = 0, h = s.channels.length; u < h; u++) {
+      const f = s.channels[u], p = s.samplers[f.sampler], g = f.target, d = g.node, T = s.parameters !== void 0 ? s.parameters[p.input] : p.input, E = s.parameters !== void 0 ? s.parameters[p.output] : p.output;
+      g.node !== void 0 && (i.push(this.getDependency("node", d)), o.push(this.getDependency("accessor", T)), a.push(this.getDependency("accessor", E)), c.push(p), l.push(g));
+    }
+    return Promise.all([
+      Promise.all(i),
+      Promise.all(o),
+      Promise.all(a),
+      Promise.all(c),
+      Promise.all(l)
+    ]).then(function(u) {
+      const h = u[0], f = u[1], p = u[2], g = u[3], d = u[4], T = [];
+      for (let R = 0, _ = h.length; R < _; R++) {
+        const S = h[R], y = f[R], L = p[R], P = g[R], C = d[R];
+        if (S === void 0) continue;
+        S.updateMatrix && S.updateMatrix();
+        const B = n._createAnimationTracks(S, y, L, P, C);
+        if (B) for (let K = 0; K < B.length; K++) T.push(B[K]);
+      }
+      const E = new Te(r, void 0, T);
+      return M(E, s), E;
+    });
+  }
+  createNodeMesh(e) {
+    const t = this.json, n = this, s = t.nodes[e];
+    return s.mesh === void 0 ? null : n.getDependency("mesh", s.mesh).then(function(r) {
+      const i = n._getNodeRef(n.meshCache, s.mesh, r);
+      return s.weights !== void 0 && i.traverse(function(o) {
+        if (o.isMesh)
+          for (let a = 0, c = s.weights.length; a < c; a++) o.morphTargetInfluences[a] = s.weights[a];
+      }), i;
+    });
+  }
+  loadNode(e) {
+    const t = this.json, n = this, s = t.nodes[e], r = n._loadNodeShallow(e), i = [], o = s.children || [];
+    for (let c = 0, l = o.length; c < l; c++) i.push(n.getDependency("node", o[c]));
+    const a = s.skin === void 0 ? Promise.resolve(null) : n.getDependency("skin", s.skin);
+    return Promise.all([
+      r,
+      Promise.all(i),
+      a
+    ]).then(function(c) {
+      const l = c[0], u = c[1], h = c[2];
+      h !== null && l.traverse(function(f) {
+        f.isSkinnedMesh && f.bind(h, Ct);
+      });
+      for (let f = 0, p = u.length; f < p; f++) l.add(u[f]);
+      if (l.userData.pivot !== void 0 && u.length > 0) {
+        const f = l.userData.pivot, p = u[0];
+        l.pivot = new I().fromArray(f), l.position.x -= f[0], l.position.y -= f[1], l.position.z -= f[2], p.position.set(0, 0, 0), delete l.userData.pivot;
+      }
+      return l;
+    });
+  }
+  _loadNodeShallow(e) {
+    const t = this.json, n = this.extensions, s = this;
+    if (this.nodeCache[e] !== void 0) return this.nodeCache[e];
+    const r = t.nodes[e], i = r.name ? s.createUniqueName(r.name) : "", o = [], a = s._invokeOne(function(c) {
+      return c.createNodeMesh && c.createNodeMesh(e);
+    });
+    return a && o.push(a), r.camera !== void 0 && o.push(s.getDependency("camera", r.camera).then(function(c) {
+      return s._getNodeRef(s.cameraCache, r.camera, c);
+    })), s._invokeAll(function(c) {
+      return c.createNodeAttachment && c.createNodeAttachment(e);
+    }).forEach(function(c) {
+      o.push(c);
+    }), this.nodeCache[e] = Promise.all(o).then(function(c) {
+      let l;
+      if (r.isBone === !0 ? l = new Re() : c.length > 1 ? l = new V() : c.length === 1 ? l = c[0] : l = new he(), l !== c[0]) for (let u = 0, h = c.length; u < h; u++) l.add(c[u]);
+      if (r.name && (l.userData.name = r.name, l.name = i), M(l, r), r.extensions && N(n, l, r), r.matrix !== void 0) {
+        const u = new U();
+        u.fromArray(r.matrix), l.applyMatrix4(u);
+      } else
+        r.translation !== void 0 && l.position.fromArray(r.translation), r.rotation !== void 0 && l.quaternion.fromArray(r.rotation), r.scale !== void 0 && l.scale.fromArray(r.scale);
+      if (!s.associations.has(l)) s.associations.set(l, {});
+      else if (r.mesh !== void 0 && s.meshCache.refs[r.mesh] > 1) {
+        const u = s.associations.get(l);
+        s.associations.set(l, { ...u });
+      }
+      return s.associations.get(l).nodes = e, l;
+    }), this.nodeCache[e];
+  }
+  loadScene(e) {
+    const t = this.extensions, n = this.json.scenes[e], s = this, r = new V();
+    n.name && (r.name = s.createUniqueName(n.name)), M(r, n), n.extensions && N(t, r, n);
+    const i = n.nodes || [], o = [];
+    for (let a = 0, c = i.length; a < c; a++) o.push(s.getDependency("node", i[a]));
+    return Promise.all(o).then(function(a) {
+      for (let l = 0, u = a.length; l < u; l++) {
+        const h = a[l];
+        h.parent !== null ? r.add(st(h)) : r.add(h);
+      }
+      const c = (l) => {
+        const u = /* @__PURE__ */ new Map();
+        for (const [h, f] of s.associations) (h instanceof X || h instanceof ee) && u.set(h, f);
+        return l.traverse((h) => {
+          const f = s.associations.get(h);
+          f != null && u.set(h, f);
+        }), u;
+      };
+      return s.associations = c(r), r;
+    });
+  }
+  _createAnimationTracks(e, t, n, s, r) {
+    const i = [], o = e.name ? e.name : e.uuid, a = [];
+    function c(f) {
+      f.morphTargetInfluences && a.push(f.name ? f.name : f.uuid);
+    }
+    w[r.path] === w.weights ? (c(e), e.isGroup && e.children.forEach(c)) : a.push(o);
+    let l;
+    switch (w[r.path]) {
+      case w.weights:
+        l = Z;
+        break;
+      case w.rotation:
+        l = $;
+        break;
+      case w.translation:
+      case w.scale:
+        l = te;
+        break;
+      default:
+        n.itemSize === 1 ? l = Z : l = te;
+        break;
+    }
+    const u = s.interpolation !== void 0 ? yt[s.interpolation] : le, h = this._getArrayFromAccessor(n);
+    for (let f = 0, p = a.length; f < p; f++) {
+      const g = new l(a[f] + "." + w[r.path], t.array, h, u);
+      s.interpolation === "CUBICSPLINE" && this._createCubicSplineTrackInterpolant(g), i.push(g);
+    }
+    return i;
+  }
+  _getArrayFromAccessor(e) {
+    let t = e.array;
+    if (e.normalized) {
+      const n = Q(t.constructor), s = new Float32Array(t.length);
+      for (let r = 0, i = t.length; r < i; r++) s[r] = t[r] * n;
+      t = s;
+    }
+    return t;
+  }
+  _createCubicSplineTrackInterpolant(e) {
+    e.createInterpolant = function(n) {
+      return new (this instanceof $ ? St : ge)(this.times, this.values, this.getValueSize() / 3, n);
+    }, e.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline = !0;
+  }
+};
+function Pt(e, t, n) {
+  const s = t.attributes, r = new Ee();
+  if (s.POSITION !== void 0) {
+    const a = n.json.accessors[s.POSITION], c = a.min, l = a.max;
+    if (c !== void 0 && l !== void 0) {
+      if (r.set(new I(c[0], c[1], c[2]), new I(l[0], l[1], l[2])), a.normalized) {
+        const u = Q(F[a.componentType]);
+        r.min.multiplyScalar(u), r.max.multiplyScalar(u);
+      }
+    } else {
+      console.warn("THREE.GLTFLoader: Missing min/max properties for accessor POSITION.");
+      return;
+    }
+  } else return;
+  const i = t.targets;
+  if (i !== void 0) {
+    const a = new I(), c = new I();
+    for (let l = 0, u = i.length; l < u; l++) {
+      const h = i[l];
+      if (h.POSITION !== void 0) {
+        const f = n.json.accessors[h.POSITION], p = f.min, g = f.max;
+        if (p !== void 0 && g !== void 0) {
+          if (c.setX(Math.max(Math.abs(p[0]), Math.abs(g[0]))), c.setY(Math.max(Math.abs(p[1]), Math.abs(g[1]))), c.setZ(Math.max(Math.abs(p[2]), Math.abs(g[2]))), f.normalized) {
+            const d = Q(F[f.componentType]);
+            c.multiplyScalar(d);
+          }
+          a.max(c);
+        } else console.warn("THREE.GLTFLoader: Missing min/max properties for accessor POSITION.");
+      }
+    }
+    r.expandByVector(a);
+  }
+  e.boundingBox = r;
+  const o = new $e();
+  r.getCenter(o.center), o.radius = r.min.distanceTo(r.max) / 2, e.boundingSphere = o;
+}
+function ae(e, t, n) {
+  const s = t.attributes, r = [];
+  function i(o, a) {
+    return n.getDependency("accessor", o).then(function(c) {
+      e.setAttribute(a, c);
+    });
+  }
+  for (const o in s) {
+    const a = Y[o] || o.toLowerCase();
+    a in e.attributes || r.push(i(s[o], a));
+  }
+  if (t.indices !== void 0 && !e.index) {
+    const o = n.getDependency("accessor", t.indices).then(function(a) {
+      e.setIndex(a);
+    });
+    r.push(o);
+  }
+  return J.workingColorSpace !== "srgb-linear" && "COLOR_0" in s && console.warn(`THREE.GLTFLoader: Converting vertex colors from "srgb-linear" to "${J.workingColorSpace}" not supported.`), M(e, t), Pt(e, t, n), Promise.all(r).then(function() {
+    return t.targets !== void 0 ? bt(e, t.targets, n) : e;
+  });
+}
+export {
+  Kt as GLTFLoader
+};