@scenoco-three/create 0.0.0-stage → 0.7.0

package/template/node_modules/.vite/deps/three_addons_loaders_GLTFLoader__js.js

@@ -0,0 +1,2512 @@
+import { $r as MathUtils, B as Bone, Bi as NumberKeyframeTrack, Br as LinearSRGBColorSpace, Bs as Vector3, Ci as NearestMipmapLinearFilter, Er as Line, Fo as Skeleton, Hs as VectorKeyframeTrack, J as BufferGeometry, Lo as SkinnedMesh, Mr as LineLoop, Nr as LineSegments, Or as LineBasicMaterial, Pr as LinearFilter, Qi as OrthographicCamera, Qn as InstancedMesh, Rn as Group, Rr as LinearMipmapLinearFilter, To as SRGBColorSpace, U as Box3, Ur as Loader, Vi as Object3D, Wn as ImageBitmapLoader, Wo as SpotLight, Wr as LoaderUtils, Xr as Material, Yn as InstancedBufferAttribute, Zt as DirectionalLight, _a as Quaternion, _o as RepeatWrapping, ai as MeshBasicMaterial, ar as Interpolant, at as ClampToEdgeWrapping, b as AnimationClip, bi as NearestFilter, ca as Points, cr as InterpolateLinear, ds as TextureLoader, fi as MeshPhysicalMaterial, gi as MirroredRepeatWrapping, ii as Mesh, ir as InterleavedBufferAttribute, la as PointsMaterial, lt as ColorManagement, na as PerspectiveCamera, ni as Matrix4, oa as PointLight, pa as PropertyBinding, pi as MeshStandardMaterial, q as BufferAttribute, rr as InterleavedBuffer, sr as InterpolateDiscrete, st as Color, us as Texture, va as QuaternionKeyframeTrack, vn as FileLoader, wi as NearestMipmapNearestFilter, zo as Sphere, zr as LinearMipmapNearestFilter, zs as Vector2 } from "./three.module-Dhi4sXJn.js";
+import { clone } from "./three_addons_utils_SkeletonUtils__js.js";
+//#region node_modules/three/examples/jsm/utils/BufferGeometryUtils.js
+/**
+* Returns a new indexed geometry based on `TrianglesDrawMode` draw mode.
+* This mode corresponds to the `gl.TRIANGLES` primitive in WebGL.
+*
+* @param {BufferGeometry} geometry - The geometry to convert.
+* @param {number} drawMode - The current draw mode.
+* @return {BufferGeometry} The new geometry using `TrianglesDrawMode`.
+*/
+function toTrianglesDrawMode(geometry, drawMode) {
+	if (drawMode === 0) {
+		console.warn("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Geometry already defined as triangles.");
+		return geometry;
+	}
+	if (drawMode === 2 || drawMode === 1) {
+		let index = geometry.getIndex();
+		if (index === null) {
+			const indices = [];
+			const position = geometry.getAttribute("position");
+			if (position !== void 0) {
+				for (let i = 0; i < position.count; i++) indices.push(i);
+				geometry.setIndex(indices);
+				index = geometry.getIndex();
+			} else {
+				console.error("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Undefined position attribute. Processing not possible.");
+				return geometry;
+			}
+		}
+		const numberOfTriangles = index.count - 2;
+		const newIndices = [];
+		if (drawMode === 2) for (let i = 1; i <= numberOfTriangles; i++) {
+			newIndices.push(index.getX(0));
+			newIndices.push(index.getX(i));
+			newIndices.push(index.getX(i + 1));
+		}
+		else for (let i = 0; i < numberOfTriangles; i++) if (i % 2 === 0) {
+			newIndices.push(index.getX(i));
+			newIndices.push(index.getX(i + 1));
+			newIndices.push(index.getX(i + 2));
+		} else {
+			newIndices.push(index.getX(i + 2));
+			newIndices.push(index.getX(i + 1));
+			newIndices.push(index.getX(i));
+		}
+		if (newIndices.length / 3 !== numberOfTriangles) console.error("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Unable to generate correct amount of triangles.");
+		const newGeometry = geometry.clone();
+		newGeometry.setIndex(newIndices);
+		newGeometry.clearGroups();
+		return newGeometry;
+	} else {
+		console.error("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Unknown draw mode:", drawMode);
+		return geometry;
+	}
+}
+//#endregion
+//#region node_modules/three/examples/jsm/loaders/GLTFLoader.js
+/**
+* A loader for the glTF 2.0 format.
+*
+* [glTF](https://www.khronos.org/gltf/) (GL Transmission Format) is an [open format specification]{@link https://github.com/KhronosGroup/glTF/tree/main/specification/2.0)
+* for efficient delivery and loading of 3D content. Assets may be provided either in JSON (.gltf) or binary (.glb)
+* format. External files store textures (.jpg, .png) and additional binary data (.bin). A glTF asset may deliver
+* one or more scenes, including meshes, materials, textures, skins, skeletons, morph targets, animations, lights,
+* and/or cameras.
+*
+* `GLTFLoader` uses {@link ImageBitmapLoader} whenever possible. Be advised that image bitmaps are not
+* automatically GC-collected when they are no longer referenced, and they require special handling during
+* the disposal process.
+*
+* `GLTFLoader` supports the following glTF 2.0 extensions:
+* - KHR_draco_mesh_compression
+* - KHR_lights_punctual
+* - KHR_materials_anisotropy
+* - KHR_materials_clearcoat
+* - KHR_materials_dispersion
+* - KHR_materials_emissive_strength
+* - KHR_materials_ior
+* - KHR_materials_specular
+* - KHR_materials_transmission
+* - KHR_materials_iridescence
+* - KHR_materials_unlit
+* - KHR_materials_volume
+* - KHR_mesh_quantization
+* - KHR_meshopt_compression
+* - KHR_texture_basisu
+* - KHR_texture_transform
+* - EXT_materials_bump
+* - EXT_meshopt_compression
+* - EXT_mesh_gpu_instancing
+* - EXT_texture_avif
+* - EXT_texture_webp
+*
+* The following glTF 2.0 extension is supported by an external user plugin:
+* - [KHR_materials_variants](https://github.com/takahirox/three-gltf-extensions)
+* - [MSFT_texture_dds](https://github.com/takahirox/three-gltf-extensions)
+* - [KHR_animation_pointer](https://github.com/needle-tools/three-animation-pointer)
+* - [NEEDLE_progressive](https://github.com/needle-tools/gltf-progressive)
+*
+* ```js
+* const loader = new GLTFLoader();
+*
+* // Optional: Provide a DRACOLoader instance to decode compressed mesh data
+* const dracoLoader = new DRACOLoader();
+* dracoLoader.setDecoderPath( '/examples/jsm/libs/draco/' );
+* loader.setDRACOLoader( dracoLoader );
+*
+* const gltf = await loader.loadAsync( 'models/gltf/duck/duck.gltf' );
+* scene.add( gltf.scene );
+* ```
+*
+* @augments Loader
+* @three_import import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';
+*/
+var GLTFLoader = class extends Loader {
+	/**
+	* Constructs a new glTF loader.
+	*
+	* @param {LoadingManager} [manager] - The loading manager.
+	*/
+	constructor(manager) {
+		super(manager);
+		this.dracoLoader = null;
+		this.ktx2Loader = null;
+		this.meshoptDecoder = null;
+		this.pluginCallbacks = [];
+		this.register(function(parser) {
+			return new GLTFMaterialsClearcoatExtension(parser);
+		});
+		this.register(function(parser) {
+			return new GLTFMaterialsDispersionExtension(parser);
+		});
+		this.register(function(parser) {
+			return new GLTFTextureBasisUExtension(parser);
+		});
+		this.register(function(parser) {
+			return new GLTFTextureWebPExtension(parser);
+		});
+		this.register(function(parser) {
+			return new GLTFTextureAVIFExtension(parser);
+		});
+		this.register(function(parser) {
+			return new GLTFMaterialsSheenExtension(parser);
+		});
+		this.register(function(parser) {
+			return new GLTFMaterialsTransmissionExtension(parser);
+		});
+		this.register(function(parser) {
+			return new GLTFMaterialsVolumeExtension(parser);
+		});
+		this.register(function(parser) {
+			return new GLTFMaterialsIorExtension(parser);
+		});
+		this.register(function(parser) {
+			return new GLTFMaterialsEmissiveStrengthExtension(parser);
+		});
+		this.register(function(parser) {
+			return new GLTFMaterialsSpecularExtension(parser);
+		});
+		this.register(function(parser) {
+			return new GLTFMaterialsIridescenceExtension(parser);
+		});
+		this.register(function(parser) {
+			return new GLTFMaterialsAnisotropyExtension(parser);
+		});
+		this.register(function(parser) {
+			return new GLTFMaterialsBumpExtension(parser);
+		});
+		this.register(function(parser) {
+			return new GLTFLightsExtension(parser);
+		});
+		this.register(function(parser) {
+			return new GLTFMeshoptCompression(parser, EXTENSIONS.EXT_MESHOPT_COMPRESSION);
+		});
+		this.register(function(parser) {
+			return new GLTFMeshoptCompression(parser, EXTENSIONS.KHR_MESHOPT_COMPRESSION);
+		});
+		this.register(function(parser) {
+			return new GLTFMeshGpuInstancing(parser);
+		});
+	}
+	/**
+	* Starts loading from the given URL and passes the loaded glTF asset
+	* to the `onLoad()` callback.
+	*
+	* @param {string} url - The path/URL of the file to be loaded. This can also be a data URI.
+	* @param {function(GLTFLoader~LoadObject)} onLoad - Executed when the loading process has been finished.
+	* @param {onProgressCallback} onProgress - Executed while the loading is in progress.
+	* @param {onErrorCallback} onError - Executed when errors occur.
+	*/
+	load(url, onLoad, onProgress, onError) {
+		const scope = this;
+		let resourcePath;
+		if (this.resourcePath !== "") resourcePath = this.resourcePath;
+		else if (this.path !== "") {
+			const relativeUrl = LoaderUtils.extractUrlBase(url);
+			resourcePath = LoaderUtils.resolveURL(relativeUrl, this.path);
+		} else resourcePath = LoaderUtils.extractUrlBase(url);
+		this.manager.itemStart(url);
+		const _onError = function(e) {
+			if (onError) onError(e);
+			else console.error(e);
+			scope.manager.itemError(url);
+			scope.manager.itemEnd(url);
+		};
+		const loader = new FileLoader(this.manager);
+		loader.setPath(this.path);
+		loader.setResponseType("arraybuffer");
+		loader.setRequestHeader(this.requestHeader);
+		loader.setWithCredentials(this.withCredentials);
+		loader.load(url, function(data) {
+			try {
+				scope.parse(data, resourcePath, function(gltf) {
+					onLoad(gltf);
+					scope.manager.itemEnd(url);
+				}, _onError);
+			} catch (e) {
+				_onError(e);
+			}
+		}, onProgress, _onError);
+	}
+	/**
+	* Sets the given Draco loader to this loader. Required for decoding assets
+	* compressed with the `KHR_draco_mesh_compression` extension.
+	*
+	* @param {DRACOLoader} dracoLoader - The Draco loader to set.
+	* @return {GLTFLoader} A reference to this loader.
+	*/
+	setDRACOLoader(dracoLoader) {
+		this.dracoLoader = dracoLoader;
+		return this;
+	}
+	/**
+	* Sets the given KTX2 loader to this loader. Required for loading KTX2
+	* compressed textures.
+	*
+	* @param {KTX2Loader} ktx2Loader - The KTX2 loader to set.
+	* @return {GLTFLoader} A reference to this loader.
+	*/
+	setKTX2Loader(ktx2Loader) {
+		this.ktx2Loader = ktx2Loader;
+		return this;
+	}
+	/**
+	* Sets the given meshopt decoder. Required for decoding assets
+	* compressed with the `EXT_meshopt_compression` extension.
+	*
+	* @param {Object} meshoptDecoder - The meshopt decoder to set.
+	* @return {GLTFLoader} A reference to this loader.
+	*/
+	setMeshoptDecoder(meshoptDecoder) {
+		this.meshoptDecoder = meshoptDecoder;
+		return this;
+	}
+	/**
+	* Registers a plugin callback. This API is internally used to implement the various
+	* glTF extensions but can also used by third-party code to add additional logic
+	* to the loader.
+	*
+	* @param {function(parser:GLTFParser)} callback - The callback function to register.
+	* @return {GLTFLoader} A reference to this loader.
+	*/
+	register(callback) {
+		if (this.pluginCallbacks.indexOf(callback) === -1) this.pluginCallbacks.push(callback);
+		return this;
+	}
+	/**
+	* Unregisters a plugin callback.
+	*
+	* @param {Function} callback - The callback function to unregister.
+	* @return {GLTFLoader} A reference to this loader.
+	*/
+	unregister(callback) {
+		if (this.pluginCallbacks.indexOf(callback) !== -1) this.pluginCallbacks.splice(this.pluginCallbacks.indexOf(callback), 1);
+		return this;
+	}
+	/**
+	* Parses the given glTF data and returns the resulting group.
+	*
+	* @param {string|ArrayBuffer} data - The raw glTF data.
+	* @param {string} path - The URL base path.
+	* @param {function(GLTFLoader~LoadObject)} onLoad - Executed when the loading process has been finished.
+	* @param {onErrorCallback} onError - Executed when errors occur.
+	*/
+	parse(data, path, onLoad, onError) {
+		let json;
+		const extensions = {};
+		const plugins = {};
+		const textDecoder = new TextDecoder();
+		if (typeof data === "string") json = JSON.parse(data);
+		else if (data instanceof ArrayBuffer) if (textDecoder.decode(new Uint8Array(data, 0, 4)) === BINARY_EXTENSION_HEADER_MAGIC) {
+			try {
+				extensions[EXTENSIONS.KHR_BINARY_GLTF] = new GLTFBinaryExtension(data);
+			} catch (error) {
+				if (onError) onError(error);
+				return;
+			}
+			json = JSON.parse(extensions[EXTENSIONS.KHR_BINARY_GLTF].content);
+		} else json = JSON.parse(textDecoder.decode(data));
+		else json = data;
+		if (json.asset === void 0 || json.asset.version[0] < 2) {
+			if (onError) onError(/* @__PURE__ */ new Error("THREE.GLTFLoader: Unsupported asset. glTF versions >=2.0 are supported."));
+			return;
+		}
+		const parser = new GLTFParser(json, {
+			path: path || this.resourcePath || "",
+			crossOrigin: this.crossOrigin,
+			requestHeader: this.requestHeader,
+			manager: this.manager,
+			ktx2Loader: this.ktx2Loader,
+			meshoptDecoder: this.meshoptDecoder
+		});
+		parser.fileLoader.setRequestHeader(this.requestHeader);
+		for (let i = 0; i < this.pluginCallbacks.length; i++) {
+			const plugin = this.pluginCallbacks[i](parser);
+			if (!plugin.name) console.error("THREE.GLTFLoader: Invalid plugin found: missing name");
+			plugins[plugin.name] = plugin;
+			extensions[plugin.name] = true;
+		}
+		if (json.extensionsUsed) for (let i = 0; i < json.extensionsUsed.length; ++i) {
+			const extensionName = json.extensionsUsed[i];
+			const extensionsRequired = json.extensionsRequired || [];
+			switch (extensionName) {
+				case EXTENSIONS.KHR_MATERIALS_UNLIT:
+					extensions[extensionName] = new GLTFMaterialsUnlitExtension();
+					break;
+				case EXTENSIONS.KHR_DRACO_MESH_COMPRESSION:
+					extensions[extensionName] = new GLTFDracoMeshCompressionExtension(json, this.dracoLoader);
+					break;
+				case EXTENSIONS.KHR_TEXTURE_TRANSFORM:
+					extensions[extensionName] = new GLTFTextureTransformExtension();
+					break;
+				case EXTENSIONS.KHR_MESH_QUANTIZATION:
+					extensions[extensionName] = new GLTFMeshQuantizationExtension();
+					break;
+				default: if (extensionsRequired.indexOf(extensionName) >= 0 && plugins[extensionName] === void 0) console.warn("THREE.GLTFLoader: Unknown extension \"" + extensionName + "\".");
+			}
+		}
+		parser.setExtensions(extensions);
+		parser.setPlugins(plugins);
+		parser.parse(onLoad, onError);
+	}
+	/**
+	* Async version of {@link GLTFLoader#parse}.
+	*
+	* @async
+	* @param {string|ArrayBuffer} data - The raw glTF data.
+	* @param {string} path - The URL base path.
+	* @return {Promise<GLTFLoader~LoadObject>} A Promise that resolves with the loaded glTF when the parsing has been finished.
+	*/
+	parseAsync(data, path) {
+		const scope = this;
+		return new Promise(function(resolve, reject) {
+			scope.parse(data, path, resolve, reject);
+		});
+	}
+};
+function GLTFRegistry() {
+	let objects = {};
+	return {
+		get: function(key) {
+			return objects[key];
+		},
+		add: function(key, object) {
+			objects[key] = object;
+		},
+		remove: function(key) {
+			delete objects[key];
+		},
+		removeAll: function() {
+			objects = {};
+		}
+	};
+}
+/********** EXTENSIONS ***********/
+function getMaterialExtension(parser, materialIndex, extensionName) {
+	const materialDef = parser.json.materials[materialIndex];
+	if (materialDef.extensions && materialDef.extensions[extensionName]) return materialDef.extensions[extensionName];
+	return null;
+}
+var EXTENSIONS = {
+	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"
+};
+/**
+* Punctual Lights Extension
+*
+* Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_lights_punctual
+*
+* @private
+*/
+var GLTFLightsExtension = class {
+	constructor(parser) {
+		this.parser = parser;
+		this.name = EXTENSIONS.KHR_LIGHTS_PUNCTUAL;
+		this.cache = {
+			refs: {},
+			uses: {}
+		};
+	}
+	_markDefs() {
+		const parser = this.parser;
+		const nodeDefs = this.parser.json.nodes || [];
+		for (let nodeIndex = 0, nodeLength = nodeDefs.length; nodeIndex < nodeLength; nodeIndex++) {
+			const nodeDef = nodeDefs[nodeIndex];
+			if (nodeDef.extensions && nodeDef.extensions[this.name] && nodeDef.extensions[this.name].light !== void 0) parser._addNodeRef(this.cache, nodeDef.extensions[this.name].light);
+		}
+	}
+	_loadLight(lightIndex) {
+		const parser = this.parser;
+		const cacheKey = "light:" + lightIndex;
+		let dependency = parser.cache.get(cacheKey);
+		if (dependency) return dependency;
+		const json = parser.json;
+		const lightDef = ((json.extensions && json.extensions[this.name] || {}).lights || [])[lightIndex];
+		let lightNode;
+		const color = new Color(16777215);
+		if (lightDef.color !== void 0) color.setRGB(lightDef.color[0], lightDef.color[1], lightDef.color[2], LinearSRGBColorSpace);
+		const range = lightDef.range !== void 0 ? lightDef.range : 0;
+		switch (lightDef.type) {
+			case "directional":
+				lightNode = new DirectionalLight(color);
+				lightNode.target.position.set(0, 0, -1);
+				lightNode.add(lightNode.target);
+				break;
+			case "point":
+				lightNode = new PointLight(color);
+				lightNode.distance = range;
+				break;
+			case "spot":
+				lightNode = new SpotLight(color);
+				lightNode.distance = range;
+				lightDef.spot = lightDef.spot || {};
+				lightDef.spot.innerConeAngle = lightDef.spot.innerConeAngle !== void 0 ? lightDef.spot.innerConeAngle : 0;
+				lightDef.spot.outerConeAngle = lightDef.spot.outerConeAngle !== void 0 ? lightDef.spot.outerConeAngle : Math.PI / 4;
+				lightNode.angle = lightDef.spot.outerConeAngle;
+				lightNode.penumbra = 1 - lightDef.spot.innerConeAngle / lightDef.spot.outerConeAngle;
+				lightNode.target.position.set(0, 0, -1);
+				lightNode.add(lightNode.target);
+				break;
+			default: throw new Error("THREE.GLTFLoader: Unexpected light type: " + lightDef.type);
+		}
+		lightNode.position.set(0, 0, 0);
+		assignExtrasToUserData(lightNode, lightDef);
+		if (lightDef.intensity !== void 0) lightNode.intensity = lightDef.intensity;
+		lightNode.name = parser.createUniqueName(lightDef.name || "light_" + lightIndex);
+		dependency = Promise.resolve(lightNode);
+		parser.cache.add(cacheKey, dependency);
+		return dependency;
+	}
+	getDependency(type, index) {
+		if (type !== "light") return;
+		return this._loadLight(index);
+	}
+	createNodeAttachment(nodeIndex) {
+		const self = this;
+		const parser = this.parser;
+		const nodeDef = parser.json.nodes[nodeIndex];
+		const lightIndex = (nodeDef.extensions && nodeDef.extensions[this.name] || {}).light;
+		if (lightIndex === void 0) return null;
+		return this._loadLight(lightIndex).then(function(light) {
+			return parser._getNodeRef(self.cache, lightIndex, light);
+		});
+	}
+};
+/**
+* Unlit Materials Extension
+*
+* Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_unlit
+*
+* @private
+*/
+var GLTFMaterialsUnlitExtension = class {
+	constructor() {
+		this.name = EXTENSIONS.KHR_MATERIALS_UNLIT;
+	}
+	getMaterialType() {
+		return MeshBasicMaterial;
+	}
+	extendParams(materialParams, materialDef, parser) {
+		const pending = [];
+		materialParams.color = new Color(1, 1, 1);
+		materialParams.opacity = 1;
+		const metallicRoughness = materialDef.pbrMetallicRoughness;
+		if (metallicRoughness) {
+			if (Array.isArray(metallicRoughness.baseColorFactor)) {
+				const array = metallicRoughness.baseColorFactor;
+				materialParams.color.setRGB(array[0], array[1], array[2], LinearSRGBColorSpace);
+				materialParams.opacity = array[3];
+			}
+			if (metallicRoughness.baseColorTexture !== void 0) pending.push(parser.assignTexture(materialParams, "map", metallicRoughness.baseColorTexture, SRGBColorSpace));
+		}
+		return Promise.all(pending);
+	}
+};
+/**
+* Materials Emissive Strength Extension
+*
+* Specification: https://github.com/KhronosGroup/glTF/blob/5768b3ce0ef32bc39cdf1bef10b948586635ead3/extensions/2.0/Khronos/KHR_materials_emissive_strength/README.md
+*
+* @private
+*/
+var GLTFMaterialsEmissiveStrengthExtension = class {
+	constructor(parser) {
+		this.parser = parser;
+		this.name = EXTENSIONS.KHR_MATERIALS_EMISSIVE_STRENGTH;
+	}
+	extendMaterialParams(materialIndex, materialParams) {
+		const extension = getMaterialExtension(this.parser, materialIndex, this.name);
+		if (extension === null) return Promise.resolve();
+		if (extension.emissiveStrength !== void 0) materialParams.emissiveIntensity = extension.emissiveStrength;
+		return Promise.resolve();
+	}
+};
+/**
+* Clearcoat Materials Extension
+*
+* Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_clearcoat
+*
+* @private
+*/
+var GLTFMaterialsClearcoatExtension = class {
+	constructor(parser) {
+		this.parser = parser;
+		this.name = EXTENSIONS.KHR_MATERIALS_CLEARCOAT;
+	}
+	getMaterialType(materialIndex) {
+		return getMaterialExtension(this.parser, materialIndex, this.name) !== null ? MeshPhysicalMaterial : null;
+	}
+	extendMaterialParams(materialIndex, materialParams) {
+		const extension = getMaterialExtension(this.parser, materialIndex, this.name);
+		if (extension === null) return Promise.resolve();
+		const pending = [];
+		if (extension.clearcoatFactor !== void 0) materialParams.clearcoat = extension.clearcoatFactor;
+		if (extension.clearcoatTexture !== void 0) pending.push(this.parser.assignTexture(materialParams, "clearcoatMap", extension.clearcoatTexture));
+		if (extension.clearcoatRoughnessFactor !== void 0) materialParams.clearcoatRoughness = extension.clearcoatRoughnessFactor;
+		if (extension.clearcoatRoughnessTexture !== void 0) pending.push(this.parser.assignTexture(materialParams, "clearcoatRoughnessMap", extension.clearcoatRoughnessTexture));
+		if (extension.clearcoatNormalTexture !== void 0) {
+			pending.push(this.parser.assignTexture(materialParams, "clearcoatNormalMap", extension.clearcoatNormalTexture));
+			if (extension.clearcoatNormalTexture.scale !== void 0) {
+				const scale = extension.clearcoatNormalTexture.scale;
+				materialParams.clearcoatNormalScale = new Vector2(scale, scale);
+			}
+		}
+		return Promise.all(pending);
+	}
+};
+/**
+* Materials dispersion Extension
+*
+* Specification: https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_materials_dispersion
+*
+* @private
+*/
+var GLTFMaterialsDispersionExtension = class {
+	constructor(parser) {
+		this.parser = parser;
+		this.name = EXTENSIONS.KHR_MATERIALS_DISPERSION;
+	}
+	getMaterialType(materialIndex) {
+		return getMaterialExtension(this.parser, materialIndex, this.name) !== null ? MeshPhysicalMaterial : null;
+	}
+	extendMaterialParams(materialIndex, materialParams) {
+		const extension = getMaterialExtension(this.parser, materialIndex, this.name);
+		if (extension === null) return Promise.resolve();
+		materialParams.dispersion = extension.dispersion !== void 0 ? extension.dispersion : 0;
+		return Promise.resolve();
+	}
+};
+/**
+* Iridescence Materials Extension
+*
+* Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_iridescence
+*
+* @private
+*/
+var GLTFMaterialsIridescenceExtension = class {
+	constructor(parser) {
+		this.parser = parser;
+		this.name = EXTENSIONS.KHR_MATERIALS_IRIDESCENCE;
+	}
+	getMaterialType(materialIndex) {
+		return getMaterialExtension(this.parser, materialIndex, this.name) !== null ? MeshPhysicalMaterial : null;
+	}
+	extendMaterialParams(materialIndex, materialParams) {
+		const extension = getMaterialExtension(this.parser, materialIndex, this.name);
+		if (extension === null) return Promise.resolve();
+		const pending = [];
+		if (extension.iridescenceFactor !== void 0) materialParams.iridescence = extension.iridescenceFactor;
+		if (extension.iridescenceTexture !== void 0) pending.push(this.parser.assignTexture(materialParams, "iridescenceMap", extension.iridescenceTexture));
+		if (extension.iridescenceIor !== void 0) materialParams.iridescenceIOR = extension.iridescenceIor;
+		if (materialParams.iridescenceThicknessRange === void 0) materialParams.iridescenceThicknessRange = [100, 400];
+		if (extension.iridescenceThicknessMinimum !== void 0) materialParams.iridescenceThicknessRange[0] = extension.iridescenceThicknessMinimum;
+		if (extension.iridescenceThicknessMaximum !== void 0) materialParams.iridescenceThicknessRange[1] = extension.iridescenceThicknessMaximum;
+		if (extension.iridescenceThicknessTexture !== void 0) pending.push(this.parser.assignTexture(materialParams, "iridescenceThicknessMap", extension.iridescenceThicknessTexture));
+		return Promise.all(pending);
+	}
+};
+/**
+* Sheen Materials Extension
+*
+* Specification: https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_materials_sheen
+*
+* @private
+*/
+var GLTFMaterialsSheenExtension = class {
+	constructor(parser) {
+		this.parser = parser;
+		this.name = EXTENSIONS.KHR_MATERIALS_SHEEN;
+	}
+	getMaterialType(materialIndex) {
+		return getMaterialExtension(this.parser, materialIndex, this.name) !== null ? MeshPhysicalMaterial : null;
+	}
+	extendMaterialParams(materialIndex, materialParams) {
+		const extension = getMaterialExtension(this.parser, materialIndex, this.name);
+		if (extension === null) return Promise.resolve();
+		const pending = [];
+		materialParams.sheenColor = new Color(0, 0, 0);
+		materialParams.sheenRoughness = 0;
+		materialParams.sheen = 1;
+		if (extension.sheenColorFactor !== void 0) {
+			const colorFactor = extension.sheenColorFactor;
+			materialParams.sheenColor.setRGB(colorFactor[0], colorFactor[1], colorFactor[2], LinearSRGBColorSpace);
+		}
+		if (extension.sheenRoughnessFactor !== void 0) materialParams.sheenRoughness = extension.sheenRoughnessFactor;
+		if (extension.sheenColorTexture !== void 0) pending.push(this.parser.assignTexture(materialParams, "sheenColorMap", extension.sheenColorTexture, SRGBColorSpace));
+		if (extension.sheenRoughnessTexture !== void 0) pending.push(this.parser.assignTexture(materialParams, "sheenRoughnessMap", extension.sheenRoughnessTexture));
+		return Promise.all(pending);
+	}
+};
+/**
+* Transmission Materials Extension
+*
+* Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_transmission
+* Draft: https://github.com/KhronosGroup/glTF/pull/1698
+*
+* @private
+*/
+var GLTFMaterialsTransmissionExtension = class {
+	constructor(parser) {
+		this.parser = parser;
+		this.name = EXTENSIONS.KHR_MATERIALS_TRANSMISSION;
+	}
+	getMaterialType(materialIndex) {
+		return getMaterialExtension(this.parser, materialIndex, this.name) !== null ? MeshPhysicalMaterial : null;
+	}
+	extendMaterialParams(materialIndex, materialParams) {
+		const extension = getMaterialExtension(this.parser, materialIndex, this.name);
+		if (extension === null) return Promise.resolve();
+		const pending = [];
+		if (extension.transmissionFactor !== void 0) materialParams.transmission = extension.transmissionFactor;
+		if (extension.transmissionTexture !== void 0) pending.push(this.parser.assignTexture(materialParams, "transmissionMap", extension.transmissionTexture));
+		return Promise.all(pending);
+	}
+};
+/**
+* Materials Volume Extension
+*
+* Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_volume
+*
+* @private
+*/
+var GLTFMaterialsVolumeExtension = class {
+	constructor(parser) {
+		this.parser = parser;
+		this.name = EXTENSIONS.KHR_MATERIALS_VOLUME;
+	}
+	getMaterialType(materialIndex) {
+		return getMaterialExtension(this.parser, materialIndex, this.name) !== null ? MeshPhysicalMaterial : null;
+	}
+	extendMaterialParams(materialIndex, materialParams) {
+		const extension = getMaterialExtension(this.parser, materialIndex, this.name);
+		if (extension === null) return Promise.resolve();
+		const pending = [];
+		materialParams.thickness = extension.thicknessFactor !== void 0 ? extension.thicknessFactor : 0;
+		if (extension.thicknessTexture !== void 0) pending.push(this.parser.assignTexture(materialParams, "thicknessMap", extension.thicknessTexture));
+		materialParams.attenuationDistance = extension.attenuationDistance || Infinity;
+		const colorArray = extension.attenuationColor || [
+			1,
+			1,
+			1
+		];
+		materialParams.attenuationColor = new Color().setRGB(colorArray[0], colorArray[1], colorArray[2], LinearSRGBColorSpace);
+		return Promise.all(pending);
+	}
+};
+/**
+* Materials ior Extension
+*
+* Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_ior
+*
+* @private
+*/
+var GLTFMaterialsIorExtension = class {
+	constructor(parser) {
+		this.parser = parser;
+		this.name = EXTENSIONS.KHR_MATERIALS_IOR;
+	}
+	getMaterialType(materialIndex) {
+		return getMaterialExtension(this.parser, materialIndex, this.name) !== null ? MeshPhysicalMaterial : null;
+	}
+	extendMaterialParams(materialIndex, materialParams) {
+		const extension = getMaterialExtension(this.parser, materialIndex, this.name);
+		if (extension === null) return Promise.resolve();
+		materialParams.ior = extension.ior !== void 0 ? extension.ior : 1.5;
+		if (materialParams.ior === 0) materialParams.ior = 1e3;
+		return Promise.resolve();
+	}
+};
+/**
+* Materials specular Extension
+*
+* Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_specular
+*
+* @private
+*/
+var GLTFMaterialsSpecularExtension = class {
+	constructor(parser) {
+		this.parser = parser;
+		this.name = EXTENSIONS.KHR_MATERIALS_SPECULAR;
+	}
+	getMaterialType(materialIndex) {
+		return getMaterialExtension(this.parser, materialIndex, this.name) !== null ? MeshPhysicalMaterial : null;
+	}
+	extendMaterialParams(materialIndex, materialParams) {
+		const extension = getMaterialExtension(this.parser, materialIndex, this.name);
+		if (extension === null) return Promise.resolve();
+		const pending = [];
+		materialParams.specularIntensity = extension.specularFactor !== void 0 ? extension.specularFactor : 1;
+		if (extension.specularTexture !== void 0) pending.push(this.parser.assignTexture(materialParams, "specularIntensityMap", extension.specularTexture));
+		const colorArray = extension.specularColorFactor || [
+			1,
+			1,
+			1
+		];
+		materialParams.specularColor = new Color().setRGB(colorArray[0], colorArray[1], colorArray[2], LinearSRGBColorSpace);
+		if (extension.specularColorTexture !== void 0) pending.push(this.parser.assignTexture(materialParams, "specularColorMap", extension.specularColorTexture, SRGBColorSpace));
+		return Promise.all(pending);
+	}
+};
+/**
+* Materials bump Extension
+*
+* Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/EXT_materials_bump
+*
+* @private
+*/
+var GLTFMaterialsBumpExtension = class {
+	constructor(parser) {
+		this.parser = parser;
+		this.name = EXTENSIONS.EXT_MATERIALS_BUMP;
+	}
+	getMaterialType(materialIndex) {
+		return getMaterialExtension(this.parser, materialIndex, this.name) !== null ? MeshPhysicalMaterial : null;
+	}
+	extendMaterialParams(materialIndex, materialParams) {
+		const extension = getMaterialExtension(this.parser, materialIndex, this.name);
+		if (extension === null) return Promise.resolve();
+		const pending = [];
+		materialParams.bumpScale = extension.bumpFactor !== void 0 ? extension.bumpFactor : 1;
+		if (extension.bumpTexture !== void 0) pending.push(this.parser.assignTexture(materialParams, "bumpMap", extension.bumpTexture));
+		return Promise.all(pending);
+	}
+};
+/**
+* Materials anisotropy Extension
+*
+* Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_anisotropy
+*
+* @private
+*/
+var GLTFMaterialsAnisotropyExtension = class {
+	constructor(parser) {
+		this.parser = parser;
+		this.name = EXTENSIONS.KHR_MATERIALS_ANISOTROPY;
+	}
+	getMaterialType(materialIndex) {
+		return getMaterialExtension(this.parser, materialIndex, this.name) !== null ? MeshPhysicalMaterial : null;
+	}
+	extendMaterialParams(materialIndex, materialParams) {
+		const extension = getMaterialExtension(this.parser, materialIndex, this.name);
+		if (extension === null) return Promise.resolve();
+		const pending = [];
+		if (extension.anisotropyStrength !== void 0) materialParams.anisotropy = extension.anisotropyStrength;
+		if (extension.anisotropyRotation !== void 0) materialParams.anisotropyRotation = extension.anisotropyRotation;
+		if (extension.anisotropyTexture !== void 0) pending.push(this.parser.assignTexture(materialParams, "anisotropyMap", extension.anisotropyTexture));
+		return Promise.all(pending);
+	}
+};
+/**
+* BasisU Texture Extension
+*
+* Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_texture_basisu
+*
+* @private
+*/
+var GLTFTextureBasisUExtension = class {
+	constructor(parser) {
+		this.parser = parser;
+		this.name = EXTENSIONS.KHR_TEXTURE_BASISU;
+	}
+	loadTexture(textureIndex) {
+		const parser = this.parser;
+		const json = parser.json;
+		const textureDef = json.textures[textureIndex];
+		if (!textureDef.extensions || !textureDef.extensions[this.name]) return null;
+		const extension = textureDef.extensions[this.name];
+		const loader = parser.options.ktx2Loader;
+		if (!loader) if (json.extensionsRequired && json.extensionsRequired.indexOf(this.name) >= 0) throw new Error("THREE.GLTFLoader: setKTX2Loader must be called before loading KTX2 textures");
+		else return null;
+		return parser.loadTextureImage(textureIndex, extension.source, loader);
+	}
+};
+/**
+* WebP Texture Extension
+*
+* Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/EXT_texture_webp
+*
+* @private
+*/
+var GLTFTextureWebPExtension = class {
+	constructor(parser) {
+		this.parser = parser;
+		this.name = EXTENSIONS.EXT_TEXTURE_WEBP;
+	}
+	loadTexture(textureIndex) {
+		const name = this.name;
+		const parser = this.parser;
+		const json = parser.json;
+		const textureDef = json.textures[textureIndex];
+		if (!textureDef.extensions || !textureDef.extensions[name]) return null;
+		const extension = textureDef.extensions[name];
+		const source = json.images[extension.source];
+		let loader = parser.textureLoader;
+		if (source.uri) {
+			const handler = parser.options.manager.getHandler(source.uri);
+			if (handler !== null) loader = handler;
+		}
+		return parser.loadTextureImage(textureIndex, extension.source, loader);
+	}
+};
+/**
+* AVIF Texture Extension
+*
+* Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/EXT_texture_avif
+*
+* @private
+*/
+var GLTFTextureAVIFExtension = class {
+	constructor(parser) {
+		this.parser = parser;
+		this.name = EXTENSIONS.EXT_TEXTURE_AVIF;
+	}
+	loadTexture(textureIndex) {
+		const name = this.name;
+		const parser = this.parser;
+		const json = parser.json;
+		const textureDef = json.textures[textureIndex];
+		if (!textureDef.extensions || !textureDef.extensions[name]) return null;
+		const extension = textureDef.extensions[name];
+		const source = json.images[extension.source];
+		let loader = parser.textureLoader;
+		if (source.uri) {
+			const handler = parser.options.manager.getHandler(source.uri);
+			if (handler !== null) loader = handler;
+		}
+		return parser.loadTextureImage(textureIndex, extension.source, loader);
+	}
+};
+/**
+* meshopt BufferView Compression Extension
+*
+* Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/EXT_meshopt_compression
+*
+* @private
+*/
+var GLTFMeshoptCompression = class {
+	constructor(parser, name) {
+		this.name = name;
+		this.parser = parser;
+	}
+	loadBufferView(index) {
+		const json = this.parser.json;
+		const bufferView = json.bufferViews[index];
+		if (bufferView.extensions && bufferView.extensions[this.name]) {
+			const extensionDef = bufferView.extensions[this.name];
+			const buffer = this.parser.getDependency("buffer", extensionDef.buffer);
+			const decoder = this.parser.options.meshoptDecoder;
+			if (!decoder || !decoder.supported) if (json.extensionsRequired && json.extensionsRequired.indexOf(this.name) >= 0) throw new Error("THREE.GLTFLoader: setMeshoptDecoder must be called before loading compressed files");
+			else return null;
+			return buffer.then(function(res) {
+				const byteOffset = extensionDef.byteOffset || 0;
+				const byteLength = extensionDef.byteLength || 0;
+				const count = extensionDef.count;
+				const stride = extensionDef.byteStride;
+				const source = new Uint8Array(res, byteOffset, byteLength);
+				if (decoder.decodeGltfBufferAsync) return decoder.decodeGltfBufferAsync(count, stride, source, extensionDef.mode, extensionDef.filter).then(function(res) {
+					return res.buffer;
+				});
+				else return decoder.ready.then(function() {
+					const result = new ArrayBuffer(count * stride);
+					decoder.decodeGltfBuffer(new Uint8Array(result), count, stride, source, extensionDef.mode, extensionDef.filter);
+					return result;
+				});
+			});
+		} else return null;
+	}
+};
+/**
+* GPU Instancing Extension
+*
+* Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/EXT_mesh_gpu_instancing
+*
+* @private
+*/
+var GLTFMeshGpuInstancing = class {
+	constructor(parser) {
+		this.name = EXTENSIONS.EXT_MESH_GPU_INSTANCING;
+		this.parser = parser;
+	}
+	createNodeMesh(nodeIndex) {
+		const json = this.parser.json;
+		const nodeDef = json.nodes[nodeIndex];
+		if (!nodeDef.extensions || !nodeDef.extensions[this.name] || nodeDef.mesh === void 0) return null;
+		const meshDef = json.meshes[nodeDef.mesh];
+		for (const primitive of meshDef.primitives) if (primitive.mode !== WEBGL_CONSTANTS.TRIANGLES && primitive.mode !== WEBGL_CONSTANTS.TRIANGLE_STRIP && primitive.mode !== WEBGL_CONSTANTS.TRIANGLE_FAN && primitive.mode !== void 0) return null;
+		const attributesDef = nodeDef.extensions[this.name].attributes;
+		const pending = [];
+		const attributes = {};
+		for (const key in attributesDef) pending.push(this.parser.getDependency("accessor", attributesDef[key]).then((accessor) => {
+			attributes[key] = accessor;
+			return attributes[key];
+		}));
+		if (pending.length < 1) return null;
+		pending.push(this.parser.createNodeMesh(nodeIndex));
+		return Promise.all(pending).then((results) => {
+			const nodeObject = results.pop();
+			const meshes = nodeObject.isGroup ? nodeObject.children : [nodeObject];
+			const count = results[0].count;
+			const instancedMeshes = [];
+			for (const mesh of meshes) {
+				const m = new Matrix4();
+				const p = new Vector3();
+				const q = new Quaternion();
+				const s = new Vector3(1, 1, 1);
+				const instancedMesh = new InstancedMesh(mesh.geometry, mesh.material, count);
+				for (let i = 0; i < count; i++) {
+					if (attributes.TRANSLATION) p.fromBufferAttribute(attributes.TRANSLATION, i);
+					if (attributes.ROTATION) q.fromBufferAttribute(attributes.ROTATION, i);
+					if (attributes.SCALE) s.fromBufferAttribute(attributes.SCALE, i);
+					instancedMesh.setMatrixAt(i, m.compose(p, q, s));
+				}
+				for (const attributeName in attributes) if (attributeName === "_COLOR_0") {
+					const attr = attributes[attributeName];
+					instancedMesh.instanceColor = new InstancedBufferAttribute(attr.array, attr.itemSize, attr.normalized);
+				} else if (attributeName !== "TRANSLATION" && attributeName !== "ROTATION" && attributeName !== "SCALE") mesh.geometry.setAttribute(attributeName, attributes[attributeName]);
+				Object3D.prototype.copy.call(instancedMesh, mesh);
+				this.parser.assignFinalMaterial(instancedMesh);
+				instancedMeshes.push(instancedMesh);
+			}
+			if (nodeObject.isGroup) {
+				nodeObject.clear();
+				nodeObject.add(...instancedMeshes);
+				return nodeObject;
+			}
+			return instancedMeshes[0];
+		});
+	}
+};
+var BINARY_EXTENSION_HEADER_MAGIC = "glTF";
+var BINARY_EXTENSION_HEADER_LENGTH = 12;
+var BINARY_EXTENSION_CHUNK_TYPES = {
+	JSON: 1313821514,
+	BIN: 5130562
+};
+var GLTFBinaryExtension = class {
+	constructor(data) {
+		this.name = EXTENSIONS.KHR_BINARY_GLTF;
+		this.content = null;
+		this.body = null;
+		const headerView = new DataView(data, 0, BINARY_EXTENSION_HEADER_LENGTH);
+		const textDecoder = new TextDecoder();
+		this.header = {
+			magic: textDecoder.decode(new Uint8Array(data.slice(0, 4))),
+			version: headerView.getUint32(4, true),
+			length: headerView.getUint32(8, true)
+		};
+		if (this.header.magic !== BINARY_EXTENSION_HEADER_MAGIC) throw new Error("THREE.GLTFLoader: Unsupported glTF-Binary header.");
+		else if (this.header.version < 2) throw new Error("THREE.GLTFLoader: Legacy binary file detected.");
+		const chunkContentsLength = this.header.length - BINARY_EXTENSION_HEADER_LENGTH;
+		const chunkView = new DataView(data, BINARY_EXTENSION_HEADER_LENGTH);
+		let chunkIndex = 0;
+		while (chunkIndex < chunkContentsLength) {
+			const chunkLength = chunkView.getUint32(chunkIndex, true);
+			chunkIndex += 4;
+			const chunkType = chunkView.getUint32(chunkIndex, true);
+			chunkIndex += 4;
+			if (chunkType === BINARY_EXTENSION_CHUNK_TYPES.JSON) {
+				const contentArray = new Uint8Array(data, BINARY_EXTENSION_HEADER_LENGTH + chunkIndex, chunkLength);
+				this.content = textDecoder.decode(contentArray);
+			} else if (chunkType === BINARY_EXTENSION_CHUNK_TYPES.BIN) {
+				const byteOffset = BINARY_EXTENSION_HEADER_LENGTH + chunkIndex;
+				this.body = data.slice(byteOffset, byteOffset + chunkLength);
+			}
+			chunkIndex += chunkLength;
+		}
+		if (this.content === null) throw new Error("THREE.GLTFLoader: JSON content not found.");
+	}
+};
+/**
+* DRACO Mesh Compression Extension
+*
+* Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_draco_mesh_compression
+*
+* @private
+*/
+var GLTFDracoMeshCompressionExtension = class {
+	constructor(json, dracoLoader) {
+		if (!dracoLoader) throw new Error("THREE.GLTFLoader: No DRACOLoader instance provided.");
+		this.name = EXTENSIONS.KHR_DRACO_MESH_COMPRESSION;
+		this.json = json;
+		this.dracoLoader = dracoLoader;
+		this.dracoLoader.preload();
+	}
+	decodePrimitive(primitive, parser) {
+		const json = this.json;
+		const dracoLoader = this.dracoLoader;
+		const bufferViewIndex = primitive.extensions[this.name].bufferView;
+		const gltfAttributeMap = primitive.extensions[this.name].attributes;
+		const threeAttributeMap = {};
+		const attributeNormalizedMap = {};
+		const attributeTypeMap = {};
+		for (const attributeName in gltfAttributeMap) {
+			const threeAttributeName = ATTRIBUTES[attributeName] || attributeName.toLowerCase();
+			threeAttributeMap[threeAttributeName] = gltfAttributeMap[attributeName];
+		}
+		for (const attributeName in primitive.attributes) {
+			const threeAttributeName = ATTRIBUTES[attributeName] || attributeName.toLowerCase();
+			if (gltfAttributeMap[attributeName] !== void 0) {
+				const accessorDef = json.accessors[primitive.attributes[attributeName]];
+				attributeTypeMap[threeAttributeName] = WEBGL_COMPONENT_TYPES[accessorDef.componentType].name;
+				attributeNormalizedMap[threeAttributeName] = accessorDef.normalized === true;
+			}
+		}
+		return parser.getDependency("bufferView", bufferViewIndex).then(function(bufferView) {
+			return new Promise(function(resolve, reject) {
+				dracoLoader.decodeDracoFile(bufferView, function(geometry) {
+					for (const attributeName in geometry.attributes) {
+						const attribute = geometry.attributes[attributeName];
+						const normalized = attributeNormalizedMap[attributeName];
+						if (normalized !== void 0) attribute.normalized = normalized;
+					}
+					resolve(geometry);
+				}, threeAttributeMap, attributeTypeMap, LinearSRGBColorSpace, reject);
+			});
+		});
+	}
+};
+/**
+* Texture Transform Extension
+*
+* Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_texture_transform
+*
+* @private
+*/
+var GLTFTextureTransformExtension = class {
+	constructor() {
+		this.name = EXTENSIONS.KHR_TEXTURE_TRANSFORM;
+	}
+	extendTexture(texture, transform) {
+		if ((transform.texCoord === void 0 || transform.texCoord === texture.channel) && transform.offset === void 0 && transform.rotation === void 0 && transform.scale === void 0) return texture;
+		texture = texture.clone();
+		if (transform.texCoord !== void 0) texture.channel = transform.texCoord;
+		if (transform.offset !== void 0) texture.offset.fromArray(transform.offset);
+		if (transform.rotation !== void 0) texture.rotation = transform.rotation;
+		if (transform.scale !== void 0) texture.repeat.fromArray(transform.scale);
+		texture.needsUpdate = true;
+		return texture;
+	}
+};
+/**
+* Mesh Quantization Extension
+*
+* Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_mesh_quantization
+*
+* @private
+*/
+var GLTFMeshQuantizationExtension = class {
+	constructor() {
+		this.name = EXTENSIONS.KHR_MESH_QUANTIZATION;
+	}
+};
+/********** INTERPOLATION ********/
+var GLTFCubicSplineInterpolant = class extends Interpolant {
+	constructor(parameterPositions, sampleValues, sampleSize, resultBuffer) {
+		super(parameterPositions, sampleValues, sampleSize, resultBuffer);
+	}
+	copySampleValue_(index) {
+		const result = this.resultBuffer, values = this.sampleValues, valueSize = this.valueSize, offset = index * valueSize * 3 + valueSize;
+		for (let i = 0; i !== valueSize; i++) result[i] = values[offset + i];
+		return result;
+	}
+	interpolate_(i1, t0, t, t1) {
+		const result = this.resultBuffer;
+		const values = this.sampleValues;
+		const stride = this.valueSize;
+		const stride2 = stride * 2;
+		const stride3 = stride * 3;
+		const td = t1 - t0;
+		const p = (t - t0) / td;
+		const pp = p * p;
+		const ppp = pp * p;
+		const offset1 = i1 * stride3;
+		const offset0 = offset1 - stride3;
+		const s2 = -2 * ppp + 3 * pp;
+		const s3 = ppp - pp;
+		const s0 = 1 - s2;
+		const s1 = s3 - pp + p;
+		for (let i = 0; i !== stride; i++) {
+			const p0 = values[offset0 + i + stride];
+			const m0 = values[offset0 + i + stride2] * td;
+			const p1 = values[offset1 + i + stride];
+			const m1 = values[offset1 + i] * td;
+			result[i] = s0 * p0 + s1 * m0 + s2 * p1 + s3 * m1;
+		}
+		return result;
+	}
+};
+var _quaternion = new Quaternion();
+var GLTFCubicSplineQuaternionInterpolant = class extends GLTFCubicSplineInterpolant {
+	interpolate_(i1, t0, t, t1) {
+		const result = super.interpolate_(i1, t0, t, t1);
+		_quaternion.fromArray(result).normalize().toArray(result);
+		return result;
+	}
+};
+/********** INTERNALS ************/
+var WEBGL_CONSTANTS = {
+	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
+};
+var WEBGL_COMPONENT_TYPES = {
+	5120: Int8Array,
+	5121: Uint8Array,
+	5122: Int16Array,
+	5123: Uint16Array,
+	5125: Uint32Array,
+	5126: Float32Array
+};
+var WEBGL_FILTERS = {
+	9728: NearestFilter,
+	9729: LinearFilter,
+	9984: NearestMipmapNearestFilter,
+	9985: LinearMipmapNearestFilter,
+	9986: NearestMipmapLinearFilter,
+	9987: LinearMipmapLinearFilter
+};
+var WEBGL_WRAPPINGS = {
+	33071: ClampToEdgeWrapping,
+	33648: MirroredRepeatWrapping,
+	10497: RepeatWrapping
+};
+var WEBGL_TYPE_SIZES = {
+	"SCALAR": 1,
+	"VEC2": 2,
+	"VEC3": 3,
+	"VEC4": 4,
+	"MAT2": 4,
+	"MAT3": 9,
+	"MAT4": 16
+};
+var ATTRIBUTES = {
+	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"
+};
+var PATH_PROPERTIES = {
+	scale: "scale",
+	translation: "position",
+	rotation: "quaternion",
+	weights: "morphTargetInfluences"
+};
+var INTERPOLATION = {
+	CUBICSPLINE: void 0,
+	LINEAR: InterpolateLinear,
+	STEP: InterpolateDiscrete
+};
+var ALPHA_MODES = {
+	OPAQUE: "OPAQUE",
+	MASK: "MASK",
+	BLEND: "BLEND"
+};
+/**
+* Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#default-material
+*
+* @private
+* @param {Object<string, Material>} cache
+* @return {Material}
+*/
+function createDefaultMaterial(cache) {
+	if (cache["DefaultMaterial"] === void 0) cache["DefaultMaterial"] = new MeshStandardMaterial({
+		color: 16777215,
+		emissive: 0,
+		metalness: 1,
+		roughness: 1,
+		transparent: false,
+		depthTest: true,
+		side: 0
+	});
+	return cache["DefaultMaterial"];
+}
+function addUnknownExtensionsToUserData(knownExtensions, object, objectDef) {
+	for (const name in objectDef.extensions) if (knownExtensions[name] === void 0) {
+		object.userData.gltfExtensions = object.userData.gltfExtensions || {};
+		object.userData.gltfExtensions[name] = objectDef.extensions[name];
+	}
+}
+/**
+*
+* @private
+* @param {Object3D|Material|BufferGeometry|Object|AnimationClip} object
+* @param {GLTF.definition} gltfDef
+*/
+function assignExtrasToUserData(object, gltfDef) {
+	if (gltfDef.extras !== void 0) if (typeof gltfDef.extras === "object") Object.assign(object.userData, gltfDef.extras);
+	else console.warn("THREE.GLTFLoader: Ignoring primitive type .extras, " + gltfDef.extras);
+}
+/**
+* Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#morph-targets
+*
+* @private
+* @param {BufferGeometry} geometry
+* @param {Array<GLTF.Target>} targets
+* @param {GLTFParser} parser
+* @return {Promise<BufferGeometry>}
+*/
+function addMorphTargets(geometry, targets, parser) {
+	let hasMorphPosition = false;
+	let hasMorphNormal = false;
+	let hasMorphColor = false;
+	for (let i = 0, il = targets.length; i < il; i++) {
+		const target = targets[i];
+		if (target.POSITION !== void 0) hasMorphPosition = true;
+		if (target.NORMAL !== void 0) hasMorphNormal = true;
+		if (target.COLOR_0 !== void 0) hasMorphColor = true;
+		if (hasMorphPosition && hasMorphNormal && hasMorphColor) break;
+	}
+	if (!hasMorphPosition && !hasMorphNormal && !hasMorphColor) return Promise.resolve(geometry);
+	const pendingPositionAccessors = [];
+	const pendingNormalAccessors = [];
+	const pendingColorAccessors = [];
+	for (let i = 0, il = targets.length; i < il; i++) {
+		const target = targets[i];
+		if (hasMorphPosition) {
+			const pendingAccessor = target.POSITION !== void 0 ? parser.getDependency("accessor", target.POSITION) : geometry.attributes.position;
+			pendingPositionAccessors.push(pendingAccessor);
+		}
+		if (hasMorphNormal) {
+			const pendingAccessor = target.NORMAL !== void 0 ? parser.getDependency("accessor", target.NORMAL) : geometry.attributes.normal;
+			pendingNormalAccessors.push(pendingAccessor);
+		}
+		if (hasMorphColor) {
+			const pendingAccessor = target.COLOR_0 !== void 0 ? parser.getDependency("accessor", target.COLOR_0) : geometry.attributes.color;
+			pendingColorAccessors.push(pendingAccessor);
+		}
+	}
+	return Promise.all([
+		Promise.all(pendingPositionAccessors),
+		Promise.all(pendingNormalAccessors),
+		Promise.all(pendingColorAccessors)
+	]).then(function(accessors) {
+		const morphPositions = accessors[0];
+		const morphNormals = accessors[1];
+		const morphColors = accessors[2];
+		if (hasMorphPosition) geometry.morphAttributes.position = morphPositions;
+		if (hasMorphNormal) geometry.morphAttributes.normal = morphNormals;
+		if (hasMorphColor) geometry.morphAttributes.color = morphColors;
+		geometry.morphTargetsRelative = true;
+		return geometry;
+	});
+}
+/**
+*
+* @private
+* @param {Mesh} mesh
+* @param {GLTF.Mesh} meshDef
+*/
+function updateMorphTargets(mesh, meshDef) {
+	mesh.updateMorphTargets();
+	if (meshDef.weights !== void 0) for (let i = 0, il = meshDef.weights.length; i < il; i++) mesh.morphTargetInfluences[i] = meshDef.weights[i];
+	if (meshDef.extras && Array.isArray(meshDef.extras.targetNames)) {
+		const targetNames = meshDef.extras.targetNames;
+		if (mesh.morphTargetInfluences.length === targetNames.length) {
+			mesh.morphTargetDictionary = {};
+			for (let i = 0, il = targetNames.length; i < il; i++) mesh.morphTargetDictionary[targetNames[i]] = i;
+		} else console.warn("THREE.GLTFLoader: Invalid extras.targetNames length. Ignoring names.");
+	}
+}
+function createPrimitiveKey(primitiveDef) {
+	let geometryKey;
+	const dracoExtension = primitiveDef.extensions && primitiveDef.extensions[EXTENSIONS.KHR_DRACO_MESH_COMPRESSION];
+	if (dracoExtension) geometryKey = "draco:" + dracoExtension.bufferView + ":" + dracoExtension.indices + ":" + createAttributesKey(dracoExtension.attributes);
+	else geometryKey = primitiveDef.indices + ":" + createAttributesKey(primitiveDef.attributes) + ":" + primitiveDef.mode;
+	if (primitiveDef.targets !== void 0) for (let i = 0, il = primitiveDef.targets.length; i < il; i++) geometryKey += ":" + createAttributesKey(primitiveDef.targets[i]);
+	return geometryKey;
+}
+function createAttributesKey(attributes) {
+	let attributesKey = "";
+	const keys = Object.keys(attributes).sort();
+	for (let i = 0, il = keys.length; i < il; i++) attributesKey += keys[i] + ":" + attributes[keys[i]] + ";";
+	return attributesKey;
+}
+function getNormalizedComponentScale(constructor) {
+	switch (constructor) {
+		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 getImageURIMimeType(uri) {
+	if (uri.search(/\.jpe?g($|\?)/i) > 0 || uri.search(/^data\:image\/jpeg/) === 0) return "image/jpeg";
+	if (uri.search(/\.webp($|\?)/i) > 0 || uri.search(/^data\:image\/webp/) === 0) return "image/webp";
+	if (uri.search(/\.ktx2($|\?)/i) > 0 || uri.search(/^data\:image\/ktx2/) === 0) return "image/ktx2";
+	return "image/png";
+}
+var _identityMatrix = new Matrix4();
+var GLTFParser = class {
+	constructor(json = {}, options = {}) {
+		this.json = json;
+		this.extensions = {};
+		this.plugins = {};
+		this.options = options;
+		this.cache = new GLTFRegistry();
+		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 isSafari = false;
+		let safariVersion = -1;
+		let isFirefox = false;
+		let firefoxVersion = -1;
+		if (typeof navigator !== "undefined" && typeof navigator.userAgent !== "undefined") {
+			const userAgent = navigator.userAgent;
+			isSafari = /^((?!chrome|android).)*safari/i.test(userAgent) === true;
+			const safariMatch = userAgent.match(/Version\/(\d+)/);
+			safariVersion = isSafari && safariMatch ? parseInt(safariMatch[1], 10) : -1;
+			isFirefox = userAgent.indexOf("Firefox") > -1;
+			firefoxVersion = isFirefox ? userAgent.match(/Firefox\/([0-9]+)\./)[1] : -1;
+		}
+		if (typeof createImageBitmap === "undefined" || isSafari && safariVersion < 17 || isFirefox && firefoxVersion < 98) this.textureLoader = new TextureLoader(this.options.manager);
+		else this.textureLoader = new ImageBitmapLoader(this.options.manager);
+		this.textureLoader.setCrossOrigin(this.options.crossOrigin);
+		this.textureLoader.setRequestHeader(this.options.requestHeader);
+		this.fileLoader = new FileLoader(this.options.manager);
+		this.fileLoader.setResponseType("arraybuffer");
+		if (this.options.crossOrigin === "use-credentials") this.fileLoader.setWithCredentials(true);
+	}
+	setExtensions(extensions) {
+		this.extensions = extensions;
+	}
+	setPlugins(plugins) {
+		this.plugins = plugins;
+	}
+	parse(onLoad, onError) {
+		const parser = this;
+		const json = this.json;
+		const extensions = this.extensions;
+		this.cache.removeAll();
+		this.nodeCache = {};
+		this._invokeAll(function(ext) {
+			return ext._markDefs && ext._markDefs();
+		});
+		Promise.all(this._invokeAll(function(ext) {
+			return ext.beforeRoot && ext.beforeRoot();
+		})).then(function() {
+			return Promise.all([
+				parser.getDependencies("scene"),
+				parser.getDependencies("animation"),
+				parser.getDependencies("camera")
+			]);
+		}).then(function(dependencies) {
+			const result = {
+				scene: dependencies[0][json.scene || 0],
+				scenes: dependencies[0],
+				animations: dependencies[1],
+				cameras: dependencies[2],
+				asset: json.asset,
+				parser,
+				userData: {}
+			};
+			addUnknownExtensionsToUserData(extensions, result, json);
+			assignExtrasToUserData(result, json);
+			return Promise.all(parser._invokeAll(function(ext) {
+				return ext.afterRoot && ext.afterRoot(result);
+			})).then(function() {
+				for (const scene of result.scenes) scene.updateMatrixWorld();
+				onLoad(result);
+			});
+		}).catch(onError);
+	}
+	/**
+	* Marks the special nodes/meshes in json for efficient parse.
+	*
+	* @private
+	*/
+	_markDefs() {
+		const nodeDefs = this.json.nodes || [];
+		const skinDefs = this.json.skins || [];
+		const meshDefs = this.json.meshes || [];
+		for (let skinIndex = 0, skinLength = skinDefs.length; skinIndex < skinLength; skinIndex++) {
+			const joints = skinDefs[skinIndex].joints;
+			for (let i = 0, il = joints.length; i < il; i++) nodeDefs[joints[i]].isBone = true;
+		}
+		for (let nodeIndex = 0, nodeLength = nodeDefs.length; nodeIndex < nodeLength; nodeIndex++) {
+			const nodeDef = nodeDefs[nodeIndex];
+			if (nodeDef.mesh !== void 0) {
+				this._addNodeRef(this.meshCache, nodeDef.mesh);
+				if (nodeDef.skin !== void 0) meshDefs[nodeDef.mesh].isSkinnedMesh = true;
+			}
+			if (nodeDef.camera !== void 0) this._addNodeRef(this.cameraCache, nodeDef.camera);
+		}
+	}
+	/**
+	* Counts references to shared node / Object3D resources. These resources
+	* can be reused, or "instantiated", at multiple nodes in the scene
+	* hierarchy. Mesh, Camera, and Light instances are instantiated and must
+	* be marked. Non-scenegraph resources (like Materials, Geometries, and
+	* Textures) can be reused directly and are not marked here.
+	*
+	* Example: CesiumMilkTruck sample model reuses "Wheel" meshes.
+	*
+	* @private
+	* @param {Object} cache
+	* @param {Object3D} index
+	*/
+	_addNodeRef(cache, index) {
+		if (index === void 0) return;
+		if (cache.refs[index] === void 0) cache.refs[index] = cache.uses[index] = 0;
+		cache.refs[index]++;
+	}
+	/**
+	* Returns a reference to a shared resource, cloning it if necessary.
+	*
+	* @private
+	* @param {Object} cache
+	* @param {number} index
+	* @param {Object} object
+	* @return {Object}
+	*/
+	_getNodeRef(cache, index, object) {
+		if (cache.refs[index] <= 1) return object;
+		const ref = object.clone();
+		const updateMappings = (original, clone) => {
+			const mappings = this.associations.get(original);
+			if (mappings != null) this.associations.set(clone, mappings);
+			for (const [i, child] of original.children.entries()) updateMappings(child, clone.children[i]);
+		};
+		updateMappings(object, ref);
+		ref.name += "_instance_" + cache.uses[index]++;
+		return ref;
+	}
+	_invokeOne(func) {
+		const extensions = Object.values(this.plugins);
+		extensions.push(this);
+		for (let i = 0; i < extensions.length; i++) {
+			const result = func(extensions[i]);
+			if (result) return result;
+		}
+		return null;
+	}
+	_invokeAll(func) {
+		const extensions = Object.values(this.plugins);
+		extensions.unshift(this);
+		const pending = [];
+		for (let i = 0; i < extensions.length; i++) {
+			const result = func(extensions[i]);
+			if (result) pending.push(result);
+		}
+		return pending;
+	}
+	/**
+	* Requests the specified dependency asynchronously, with caching.
+	*
+	* @private
+	* @param {string} type
+	* @param {number} index
+	* @return {Promise<Object3D|Material|Texture|AnimationClip|ArrayBuffer|Object>}
+	*/
+	getDependency(type, index) {
+		const cacheKey = type + ":" + index;
+		let dependency = this.cache.get(cacheKey);
+		if (!dependency) {
+			switch (type) {
+				case "scene":
+					dependency = this.loadScene(index);
+					break;
+				case "node":
+					dependency = this._invokeOne(function(ext) {
+						return ext.loadNode && ext.loadNode(index);
+					});
+					break;
+				case "mesh":
+					dependency = this._invokeOne(function(ext) {
+						return ext.loadMesh && ext.loadMesh(index);
+					});
+					break;
+				case "accessor":
+					dependency = this.loadAccessor(index);
+					break;
+				case "bufferView":
+					dependency = this._invokeOne(function(ext) {
+						return ext.loadBufferView && ext.loadBufferView(index);
+					});
+					break;
+				case "buffer":
+					dependency = this.loadBuffer(index);
+					break;
+				case "material":
+					dependency = this._invokeOne(function(ext) {
+						return ext.loadMaterial && ext.loadMaterial(index);
+					});
+					break;
+				case "texture":
+					dependency = this._invokeOne(function(ext) {
+						return ext.loadTexture && ext.loadTexture(index);
+					});
+					break;
+				case "skin":
+					dependency = this.loadSkin(index);
+					break;
+				case "animation":
+					dependency = this._invokeOne(function(ext) {
+						return ext.loadAnimation && ext.loadAnimation(index);
+					});
+					break;
+				case "camera":
+					dependency = this.loadCamera(index);
+					break;
+				default:
+					dependency = this._invokeOne(function(ext) {
+						return ext != this && ext.getDependency && ext.getDependency(type, index);
+					});
+					if (!dependency) throw new Error("Unknown type: " + type);
+					break;
+			}
+			this.cache.add(cacheKey, dependency);
+		}
+		return dependency;
+	}
+	/**
+	* Requests all dependencies of the specified type asynchronously, with caching.
+	*
+	* @private
+	* @param {string} type
+	* @return {Promise<Array<Object>>}
+	*/
+	getDependencies(type) {
+		let dependencies = this.cache.get(type);
+		if (!dependencies) {
+			const parser = this;
+			const defs = this.json[type + (type === "mesh" ? "es" : "s")] || [];
+			dependencies = Promise.all(defs.map(function(def, index) {
+				return parser.getDependency(type, index);
+			}));
+			this.cache.add(type, dependencies);
+		}
+		return dependencies;
+	}
+	/**
+	* Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#buffers-and-buffer-views
+	*
+	* @private
+	* @param {number} bufferIndex
+	* @return {Promise<ArrayBuffer>}
+	*/
+	loadBuffer(bufferIndex) {
+		const bufferDef = this.json.buffers[bufferIndex];
+		const loader = this.fileLoader;
+		if (bufferDef.type && bufferDef.type !== "arraybuffer") throw new Error("THREE.GLTFLoader: " + bufferDef.type + " buffer type is not supported.");
+		if (bufferDef.uri === void 0 && bufferIndex === 0) return Promise.resolve(this.extensions[EXTENSIONS.KHR_BINARY_GLTF].body);
+		const options = this.options;
+		return new Promise(function(resolve, reject) {
+			loader.load(LoaderUtils.resolveURL(bufferDef.uri, options.path), resolve, void 0, function() {
+				reject(/* @__PURE__ */ new Error("THREE.GLTFLoader: Failed to load buffer \"" + bufferDef.uri + "\"."));
+			});
+		});
+	}
+	/**
+	* Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#buffers-and-buffer-views
+	*
+	* @private
+	* @param {number} bufferViewIndex
+	* @return {Promise<ArrayBuffer>}
+	*/
+	loadBufferView(bufferViewIndex) {
+		const bufferViewDef = this.json.bufferViews[bufferViewIndex];
+		return this.getDependency("buffer", bufferViewDef.buffer).then(function(buffer) {
+			const byteLength = bufferViewDef.byteLength || 0;
+			const byteOffset = bufferViewDef.byteOffset || 0;
+			return buffer.slice(byteOffset, byteOffset + byteLength);
+		});
+	}
+	/**
+	* Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#accessors
+	*
+	* @private
+	* @param {number} accessorIndex
+	* @return {Promise<BufferAttribute|InterleavedBufferAttribute>}
+	*/
+	loadAccessor(accessorIndex) {
+		const parser = this;
+		const json = this.json;
+		const accessorDef = this.json.accessors[accessorIndex];
+		if (accessorDef.bufferView === void 0 && accessorDef.sparse === void 0) {
+			const itemSize = WEBGL_TYPE_SIZES[accessorDef.type];
+			const TypedArray = WEBGL_COMPONENT_TYPES[accessorDef.componentType];
+			const normalized = accessorDef.normalized === true;
+			const array = new TypedArray(accessorDef.count * itemSize);
+			return Promise.resolve(new BufferAttribute(array, itemSize, normalized));
+		}
+		const pendingBufferViews = [];
+		if (accessorDef.bufferView !== void 0) pendingBufferViews.push(this.getDependency("bufferView", accessorDef.bufferView));
+		else pendingBufferViews.push(null);
+		if (accessorDef.sparse !== void 0) {
+			pendingBufferViews.push(this.getDependency("bufferView", accessorDef.sparse.indices.bufferView));
+			pendingBufferViews.push(this.getDependency("bufferView", accessorDef.sparse.values.bufferView));
+		}
+		return Promise.all(pendingBufferViews).then(function(bufferViews) {
+			const bufferView = bufferViews[0];
+			const itemSize = WEBGL_TYPE_SIZES[accessorDef.type];
+			const TypedArray = WEBGL_COMPONENT_TYPES[accessorDef.componentType];
+			const elementBytes = TypedArray.BYTES_PER_ELEMENT;
+			const itemBytes = elementBytes * itemSize;
+			const byteOffset = accessorDef.byteOffset || 0;
+			const byteStride = accessorDef.bufferView !== void 0 ? json.bufferViews[accessorDef.bufferView].byteStride : void 0;
+			const normalized = accessorDef.normalized === true;
+			let array, bufferAttribute;
+			if (byteStride && byteStride !== itemBytes) {
+				const ibSlice = Math.floor(byteOffset / byteStride);
+				const ibCacheKey = "InterleavedBuffer:" + accessorDef.bufferView + ":" + accessorDef.componentType + ":" + ibSlice + ":" + accessorDef.count;
+				let ib = parser.cache.get(ibCacheKey);
+				if (!ib) {
+					array = new TypedArray(bufferView, ibSlice * byteStride, accessorDef.count * byteStride / elementBytes);
+					ib = new InterleavedBuffer(array, byteStride / elementBytes);
+					parser.cache.add(ibCacheKey, ib);
+				}
+				bufferAttribute = new InterleavedBufferAttribute(ib, itemSize, byteOffset % byteStride / elementBytes, normalized);
+			} else {
+				if (bufferView === null) array = new TypedArray(accessorDef.count * itemSize);
+				else array = new TypedArray(bufferView, byteOffset, accessorDef.count * itemSize);
+				bufferAttribute = new BufferAttribute(array, itemSize, normalized);
+			}
+			if (accessorDef.sparse !== void 0) {
+				const itemSizeIndices = WEBGL_TYPE_SIZES.SCALAR;
+				const TypedArrayIndices = WEBGL_COMPONENT_TYPES[accessorDef.sparse.indices.componentType];
+				const byteOffsetIndices = accessorDef.sparse.indices.byteOffset || 0;
+				const byteOffsetValues = accessorDef.sparse.values.byteOffset || 0;
+				const sparseIndices = new TypedArrayIndices(bufferViews[1], byteOffsetIndices, accessorDef.sparse.count * itemSizeIndices);
+				const sparseValues = new TypedArray(bufferViews[2], byteOffsetValues, accessorDef.sparse.count * itemSize);
+				if (bufferView !== null) bufferAttribute = new BufferAttribute(bufferAttribute.array.slice(), bufferAttribute.itemSize, bufferAttribute.normalized);
+				bufferAttribute.normalized = false;
+				for (let i = 0, il = sparseIndices.length; i < il; i++) {
+					const index = sparseIndices[i];
+					bufferAttribute.setX(index, sparseValues[i * itemSize]);
+					if (itemSize >= 2) bufferAttribute.setY(index, sparseValues[i * itemSize + 1]);
+					if (itemSize >= 3) bufferAttribute.setZ(index, sparseValues[i * itemSize + 2]);
+					if (itemSize >= 4) bufferAttribute.setW(index, sparseValues[i * itemSize + 3]);
+					if (itemSize >= 5) throw new Error("THREE.GLTFLoader: Unsupported itemSize in sparse BufferAttribute.");
+				}
+				bufferAttribute.normalized = normalized;
+			}
+			return bufferAttribute;
+		});
+	}
+	/**
+	* Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#textures
+	*
+	* @private
+	* @param {number} textureIndex
+	* @return {Promise<?Texture>}
+	*/
+	loadTexture(textureIndex) {
+		const json = this.json;
+		const options = this.options;
+		const sourceIndex = json.textures[textureIndex].source;
+		const sourceDef = json.images[sourceIndex];
+		let loader = this.textureLoader;
+		if (sourceDef.uri) {
+			const handler = options.manager.getHandler(sourceDef.uri);
+			if (handler !== null) loader = handler;
+		}
+		return this.loadTextureImage(textureIndex, sourceIndex, loader);
+	}
+	loadTextureImage(textureIndex, sourceIndex, loader) {
+		const parser = this;
+		const json = this.json;
+		const textureDef = json.textures[textureIndex];
+		const sourceDef = json.images[sourceIndex];
+		const cacheKey = (sourceDef.uri || sourceDef.bufferView) + ":" + textureDef.sampler;
+		if (this.textureCache[cacheKey]) return this.textureCache[cacheKey];
+		const promise = this.loadImageSource(sourceIndex, loader).then(function(texture) {
+			texture.flipY = false;
+			texture.name = textureDef.name || sourceDef.name || "";
+			if (texture.name === "" && typeof sourceDef.uri === "string" && sourceDef.uri.startsWith("data:image/") === false) texture.name = sourceDef.uri;
+			const sampler = (json.samplers || {})[textureDef.sampler] || {};
+			texture.magFilter = WEBGL_FILTERS[sampler.magFilter] || 1006;
+			texture.minFilter = WEBGL_FILTERS[sampler.minFilter] || 1008;
+			texture.wrapS = WEBGL_WRAPPINGS[sampler.wrapS] || 1e3;
+			texture.wrapT = WEBGL_WRAPPINGS[sampler.wrapT] || 1e3;
+			texture.generateMipmaps = !texture.isCompressedTexture && texture.minFilter !== 1003 && texture.minFilter !== 1006;
+			parser.associations.set(texture, { textures: textureIndex });
+			return texture;
+		}).catch(function() {
+			return null;
+		});
+		this.textureCache[cacheKey] = promise;
+		return promise;
+	}
+	loadImageSource(sourceIndex, loader) {
+		const parser = this;
+		const json = this.json;
+		const options = this.options;
+		if (this.sourceCache[sourceIndex] !== void 0) return this.sourceCache[sourceIndex].then((texture) => texture.clone());
+		const sourceDef = json.images[sourceIndex];
+		const URL = self.URL || self.webkitURL;
+		let sourceURI = sourceDef.uri || "";
+		let isObjectURL = false;
+		if (sourceDef.bufferView !== void 0) sourceURI = parser.getDependency("bufferView", sourceDef.bufferView).then(function(bufferView) {
+			isObjectURL = true;
+			const blob = new Blob([bufferView], { type: sourceDef.mimeType });
+			sourceURI = URL.createObjectURL(blob);
+			return sourceURI;
+		});
+		else if (sourceDef.uri === void 0) throw new Error("THREE.GLTFLoader: Image " + sourceIndex + " is missing URI and bufferView");
+		const promise = Promise.resolve(sourceURI).then(function(sourceURI) {
+			return new Promise(function(resolve, reject) {
+				let onLoad = resolve;
+				if (loader.isImageBitmapLoader === true) onLoad = function(imageBitmap) {
+					const texture = new Texture(imageBitmap);
+					texture.needsUpdate = true;
+					resolve(texture);
+				};
+				loader.load(LoaderUtils.resolveURL(sourceURI, options.path), onLoad, void 0, reject);
+			});
+		}).then(function(texture) {
+			if (isObjectURL === true) URL.revokeObjectURL(sourceURI);
+			assignExtrasToUserData(texture, sourceDef);
+			texture.userData.mimeType = sourceDef.mimeType || getImageURIMimeType(sourceDef.uri);
+			return texture;
+		}).catch(function(error) {
+			console.error("THREE.GLTFLoader: Couldn't load texture", sourceURI);
+			throw error;
+		});
+		this.sourceCache[sourceIndex] = promise;
+		return promise;
+	}
+	/**
+	* Asynchronously assigns a texture to the given material parameters.
+	*
+	* @private
+	* @param {Object} materialParams
+	* @param {string} mapName
+	* @param {Object} mapDef
+	* @param {string} [colorSpace]
+	* @return {Promise<Texture>}
+	*/
+	assignTexture(materialParams, mapName, mapDef, colorSpace) {
+		const parser = this;
+		return this.getDependency("texture", mapDef.index).then(function(texture) {
+			if (!texture) return null;
+			if (mapDef.texCoord !== void 0 && mapDef.texCoord > 0) {
+				texture = texture.clone();
+				texture.channel = mapDef.texCoord;
+			}
+			if (parser.extensions[EXTENSIONS.KHR_TEXTURE_TRANSFORM]) {
+				const transform = mapDef.extensions !== void 0 ? mapDef.extensions[EXTENSIONS.KHR_TEXTURE_TRANSFORM] : void 0;
+				if (transform) {
+					const gltfReference = parser.associations.get(texture);
+					texture = parser.extensions[EXTENSIONS.KHR_TEXTURE_TRANSFORM].extendTexture(texture, transform);
+					parser.associations.set(texture, gltfReference);
+				}
+			}
+			if (colorSpace !== void 0) texture.colorSpace = colorSpace;
+			materialParams[mapName] = texture;
+			return texture;
+		});
+	}
+	/**
+	* Assigns final material to a Mesh, Line, or Points instance. The instance
+	* already has a material (generated from the glTF material options alone)
+	* but reuse of the same glTF material may require multiple threejs materials
+	* to accommodate different primitive types, defines, etc. New materials will
+	* be created if necessary, and reused from a cache.
+	*
+	* @private
+	* @param {Object3D} mesh Mesh, Line, or Points instance.
+	*/
+	assignFinalMaterial(mesh) {
+		const geometry = mesh.geometry;
+		let material = mesh.material;
+		const useDerivativeTangents = geometry.attributes.tangent === void 0;
+		const useVertexColors = geometry.attributes.color !== void 0;
+		const useFlatShading = geometry.attributes.normal === void 0;
+		if (mesh.isPoints) {
+			const cacheKey = "PointsMaterial:" + material.uuid;
+			let pointsMaterial = this.cache.get(cacheKey);
+			if (!pointsMaterial) {
+				pointsMaterial = new PointsMaterial();
+				Material.prototype.copy.call(pointsMaterial, material);
+				pointsMaterial.color.copy(material.color);
+				pointsMaterial.map = material.map;
+				pointsMaterial.sizeAttenuation = false;
+				this.cache.add(cacheKey, pointsMaterial);
+			}
+			material = pointsMaterial;
+		} else if (mesh.isLine) {
+			const cacheKey = "LineBasicMaterial:" + material.uuid;
+			let lineMaterial = this.cache.get(cacheKey);
+			if (!lineMaterial) {
+				lineMaterial = new LineBasicMaterial();
+				Material.prototype.copy.call(lineMaterial, material);
+				lineMaterial.color.copy(material.color);
+				lineMaterial.map = material.map;
+				this.cache.add(cacheKey, lineMaterial);
+			}
+			material = lineMaterial;
+		}
+		if (useDerivativeTangents || useVertexColors || useFlatShading) {
+			let cacheKey = "ClonedMaterial:" + material.uuid + ":";
+			if (useDerivativeTangents) cacheKey += "derivative-tangents:";
+			if (useVertexColors) cacheKey += "vertex-colors:";
+			if (useFlatShading) cacheKey += "flat-shading:";
+			let cachedMaterial = this.cache.get(cacheKey);
+			if (!cachedMaterial) {
+				cachedMaterial = material.clone();
+				if (useVertexColors) cachedMaterial.vertexColors = true;
+				if (useFlatShading) cachedMaterial.flatShading = true;
+				if (useDerivativeTangents) {
+					if (cachedMaterial.normalScale) cachedMaterial.normalScale.y *= -1;
+					if (cachedMaterial.clearcoatNormalScale) cachedMaterial.clearcoatNormalScale.y *= -1;
+				}
+				this.cache.add(cacheKey, cachedMaterial);
+				this.associations.set(cachedMaterial, this.associations.get(material));
+			}
+			material = cachedMaterial;
+		}
+		mesh.material = material;
+	}
+	getMaterialType() {
+		return MeshStandardMaterial;
+	}
+	/**
+	* Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#materials
+	*
+	* @private
+	* @param {number} materialIndex
+	* @return {Promise<Material>}
+	*/
+	loadMaterial(materialIndex) {
+		const parser = this;
+		const json = this.json;
+		const extensions = this.extensions;
+		const materialDef = json.materials[materialIndex];
+		let materialType;
+		const materialParams = {};
+		const materialExtensions = materialDef.extensions || {};
+		const pending = [];
+		if (materialExtensions[EXTENSIONS.KHR_MATERIALS_UNLIT]) {
+			const kmuExtension = extensions[EXTENSIONS.KHR_MATERIALS_UNLIT];
+			materialType = kmuExtension.getMaterialType();
+			pending.push(kmuExtension.extendParams(materialParams, materialDef, parser));
+		} else {
+			const metallicRoughness = materialDef.pbrMetallicRoughness || {};
+			materialParams.color = new Color(1, 1, 1);
+			materialParams.opacity = 1;
+			if (Array.isArray(metallicRoughness.baseColorFactor)) {
+				const array = metallicRoughness.baseColorFactor;
+				materialParams.color.setRGB(array[0], array[1], array[2], LinearSRGBColorSpace);
+				materialParams.opacity = array[3];
+			}
+			if (metallicRoughness.baseColorTexture !== void 0) pending.push(parser.assignTexture(materialParams, "map", metallicRoughness.baseColorTexture, SRGBColorSpace));
+			materialParams.metalness = metallicRoughness.metallicFactor !== void 0 ? metallicRoughness.metallicFactor : 1;
+			materialParams.roughness = metallicRoughness.roughnessFactor !== void 0 ? metallicRoughness.roughnessFactor : 1;
+			if (metallicRoughness.metallicRoughnessTexture !== void 0) {
+				pending.push(parser.assignTexture(materialParams, "metalnessMap", metallicRoughness.metallicRoughnessTexture));
+				pending.push(parser.assignTexture(materialParams, "roughnessMap", metallicRoughness.metallicRoughnessTexture));
+			}
+			materialType = this._invokeOne(function(ext) {
+				return ext.getMaterialType && ext.getMaterialType(materialIndex);
+			});
+			pending.push(Promise.all(this._invokeAll(function(ext) {
+				return ext.extendMaterialParams && ext.extendMaterialParams(materialIndex, materialParams);
+			})));
+		}
+		if (materialDef.doubleSided === true) materialParams.side = 2;
+		const alphaMode = materialDef.alphaMode || ALPHA_MODES.OPAQUE;
+		if (alphaMode === ALPHA_MODES.BLEND) {
+			materialParams.transparent = true;
+			materialParams.depthWrite = false;
+		} else {
+			materialParams.transparent = false;
+			if (alphaMode === ALPHA_MODES.MASK) materialParams.alphaTest = materialDef.alphaCutoff !== void 0 ? materialDef.alphaCutoff : .5;
+		}
+		if (materialDef.normalTexture !== void 0 && materialType !== MeshBasicMaterial) {
+			pending.push(parser.assignTexture(materialParams, "normalMap", materialDef.normalTexture));
+			materialParams.normalScale = new Vector2(1, 1);
+			if (materialDef.normalTexture.scale !== void 0) {
+				const scale = materialDef.normalTexture.scale;
+				materialParams.normalScale.set(scale, scale);
+			}
+		}
+		if (materialDef.occlusionTexture !== void 0 && materialType !== MeshBasicMaterial) {
+			pending.push(parser.assignTexture(materialParams, "aoMap", materialDef.occlusionTexture));
+			if (materialDef.occlusionTexture.strength !== void 0) materialParams.aoMapIntensity = materialDef.occlusionTexture.strength;
+		}
+		if (materialDef.emissiveFactor !== void 0 && materialType !== MeshBasicMaterial) {
+			const emissiveFactor = materialDef.emissiveFactor;
+			materialParams.emissive = new Color().setRGB(emissiveFactor[0], emissiveFactor[1], emissiveFactor[2], LinearSRGBColorSpace);
+		}
+		if (materialDef.emissiveTexture !== void 0 && materialType !== MeshBasicMaterial) pending.push(parser.assignTexture(materialParams, "emissiveMap", materialDef.emissiveTexture, SRGBColorSpace));
+		return Promise.all(pending).then(function() {
+			const material = new materialType(materialParams);
+			if (materialDef.name) material.name = materialDef.name;
+			assignExtrasToUserData(material, materialDef);
+			parser.associations.set(material, { materials: materialIndex });
+			if (materialDef.extensions) addUnknownExtensionsToUserData(extensions, material, materialDef);
+			return material;
+		});
+	}
+	/**
+	* When Object3D instances are targeted by animation, they need unique names.
+	*
+	* @private
+	* @param {string} originalName
+	* @return {string}
+	*/
+	createUniqueName(originalName) {
+		const sanitizedName = PropertyBinding.sanitizeNodeName(originalName || "");
+		if (sanitizedName in this.nodeNamesUsed) return sanitizedName + "_" + ++this.nodeNamesUsed[sanitizedName];
+		else {
+			this.nodeNamesUsed[sanitizedName] = 0;
+			return sanitizedName;
+		}
+	}
+	/**
+	* Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#geometry
+	*
+	* Creates BufferGeometries from primitives.
+	*
+	* @private
+	* @param {Array<GLTF.Primitive>} primitives
+	* @return {Promise<Array<BufferGeometry>>}
+	*/
+	loadGeometries(primitives) {
+		const parser = this;
+		const extensions = this.extensions;
+		const cache = this.primitiveCache;
+		function createDracoPrimitive(primitive) {
+			return extensions[EXTENSIONS.KHR_DRACO_MESH_COMPRESSION].decodePrimitive(primitive, parser).then(function(geometry) {
+				return addPrimitiveAttributes(geometry, primitive, parser);
+			});
+		}
+		const pending = [];
+		for (let i = 0, il = primitives.length; i < il; i++) {
+			const primitive = primitives[i];
+			const cacheKey = createPrimitiveKey(primitive);
+			const cached = cache[cacheKey];
+			if (cached) pending.push(cached.promise);
+			else {
+				let geometryPromise;
+				if (primitive.extensions && primitive.extensions[EXTENSIONS.KHR_DRACO_MESH_COMPRESSION]) geometryPromise = createDracoPrimitive(primitive);
+				else geometryPromise = addPrimitiveAttributes(new BufferGeometry(), primitive, parser);
+				cache[cacheKey] = {
+					primitive,
+					promise: geometryPromise
+				};
+				pending.push(geometryPromise);
+			}
+		}
+		return Promise.all(pending);
+	}
+	/**
+	* Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#meshes
+	*
+	* @private
+	* @param {number} meshIndex
+	* @return {Promise<Group|Mesh|SkinnedMesh|Line|Points>}
+	*/
+	loadMesh(meshIndex) {
+		const parser = this;
+		const json = this.json;
+		const extensions = this.extensions;
+		const meshDef = json.meshes[meshIndex];
+		const primitives = meshDef.primitives;
+		const pending = [];
+		for (let i = 0, il = primitives.length; i < il; i++) {
+			const material = primitives[i].material === void 0 ? createDefaultMaterial(this.cache) : this.getDependency("material", primitives[i].material);
+			pending.push(material);
+		}
+		pending.push(parser.loadGeometries(primitives));
+		return Promise.all(pending).then(function(results) {
+			const materials = results.slice(0, results.length - 1);
+			const geometries = results[results.length - 1];
+			const meshes = [];
+			for (let i = 0, il = geometries.length; i < il; i++) {
+				const geometry = geometries[i];
+				const primitive = primitives[i];
+				let mesh;
+				const material = materials[i];
+				if (primitive.mode === WEBGL_CONSTANTS.TRIANGLES || primitive.mode === WEBGL_CONSTANTS.TRIANGLE_STRIP || primitive.mode === WEBGL_CONSTANTS.TRIANGLE_FAN || primitive.mode === void 0) {
+					mesh = meshDef.isSkinnedMesh === true ? new SkinnedMesh(geometry, material) : new Mesh(geometry, material);
+					if (mesh.isSkinnedMesh === true) mesh.normalizeSkinWeights();
+					if (primitive.mode === WEBGL_CONSTANTS.TRIANGLE_STRIP) mesh.geometry = toTrianglesDrawMode(mesh.geometry, 1);
+					else if (primitive.mode === WEBGL_CONSTANTS.TRIANGLE_FAN) mesh.geometry = toTrianglesDrawMode(mesh.geometry, 2);
+				} else if (primitive.mode === WEBGL_CONSTANTS.LINES) mesh = new LineSegments(geometry, material);
+				else if (primitive.mode === WEBGL_CONSTANTS.LINE_STRIP) mesh = new Line(geometry, material);
+				else if (primitive.mode === WEBGL_CONSTANTS.LINE_LOOP) mesh = new LineLoop(geometry, material);
+				else if (primitive.mode === WEBGL_CONSTANTS.POINTS) mesh = new Points(geometry, material);
+				else throw new Error("THREE.GLTFLoader: Primitive mode unsupported: " + primitive.mode);
+				if (Object.keys(mesh.geometry.morphAttributes).length > 0) updateMorphTargets(mesh, meshDef);
+				mesh.name = parser.createUniqueName(meshDef.name || "mesh_" + meshIndex);
+				assignExtrasToUserData(mesh, meshDef);
+				if (primitive.extensions) addUnknownExtensionsToUserData(extensions, mesh, primitive);
+				parser.assignFinalMaterial(mesh);
+				meshes.push(mesh);
+			}
+			for (let i = 0, il = meshes.length; i < il; i++) parser.associations.set(meshes[i], {
+				meshes: meshIndex,
+				primitives: i
+			});
+			if (meshes.length === 1) {
+				if (meshDef.extensions) addUnknownExtensionsToUserData(extensions, meshes[0], meshDef);
+				return meshes[0];
+			}
+			const group = new Group();
+			if (meshDef.extensions) addUnknownExtensionsToUserData(extensions, group, meshDef);
+			parser.associations.set(group, { meshes: meshIndex });
+			for (let i = 0, il = meshes.length; i < il; i++) group.add(meshes[i]);
+			return group;
+		});
+	}
+	/**
+	* Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#cameras
+	*
+	* @private
+	* @param {number} cameraIndex
+	* @return {Promise<Camera>|undefined}
+	*/
+	loadCamera(cameraIndex) {
+		let camera;
+		const cameraDef = this.json.cameras[cameraIndex];
+		const params = cameraDef[cameraDef.type];
+		if (!params) {
+			console.warn("THREE.GLTFLoader: Missing camera parameters.");
+			return;
+		}
+		if (cameraDef.type === "perspective") camera = new PerspectiveCamera(MathUtils.radToDeg(params.yfov), params.aspectRatio || 1, params.znear || 1, params.zfar || 2e6);
+		else if (cameraDef.type === "orthographic") camera = new OrthographicCamera(-params.xmag, params.xmag, params.ymag, -params.ymag, params.znear, params.zfar);
+		if (cameraDef.name) camera.name = this.createUniqueName(cameraDef.name);
+		assignExtrasToUserData(camera, cameraDef);
+		return Promise.resolve(camera);
+	}
+	/**
+	* Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#skins
+	*
+	* @private
+	* @param {number} skinIndex
+	* @return {Promise<Skeleton>}
+	*/
+	loadSkin(skinIndex) {
+		const skinDef = this.json.skins[skinIndex];
+		const pending = [];
+		for (let i = 0, il = skinDef.joints.length; i < il; i++) pending.push(this._loadNodeShallow(skinDef.joints[i]));
+		if (skinDef.inverseBindMatrices !== void 0) pending.push(this.getDependency("accessor", skinDef.inverseBindMatrices));
+		else pending.push(null);
+		return Promise.all(pending).then(function(results) {
+			const inverseBindMatrices = results.pop();
+			const jointNodes = results;
+			const bones = [];
+			const boneInverses = [];
+			for (let i = 0, il = jointNodes.length; i < il; i++) {
+				const jointNode = jointNodes[i];
+				if (jointNode) {
+					bones.push(jointNode);
+					const mat = new Matrix4();
+					if (inverseBindMatrices !== null) mat.fromArray(inverseBindMatrices.array, i * 16);
+					boneInverses.push(mat);
+				} else console.warn("THREE.GLTFLoader: Joint \"%s\" could not be found.", skinDef.joints[i]);
+			}
+			return new Skeleton(bones, boneInverses);
+		});
+	}
+	/**
+	* Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#animations
+	*
+	* @private
+	* @param {number} animationIndex
+	* @return {Promise<AnimationClip>}
+	*/
+	loadAnimation(animationIndex) {
+		const json = this.json;
+		const parser = this;
+		const animationDef = json.animations[animationIndex];
+		const animationName = animationDef.name ? animationDef.name : "animation_" + animationIndex;
+		const pendingNodes = [];
+		const pendingInputAccessors = [];
+		const pendingOutputAccessors = [];
+		const pendingSamplers = [];
+		const pendingTargets = [];
+		for (let i = 0, il = animationDef.channels.length; i < il; i++) {
+			const channel = animationDef.channels[i];
+			const sampler = animationDef.samplers[channel.sampler];
+			const target = channel.target;
+			const name = target.node;
+			const input = animationDef.parameters !== void 0 ? animationDef.parameters[sampler.input] : sampler.input;
+			const output = animationDef.parameters !== void 0 ? animationDef.parameters[sampler.output] : sampler.output;
+			if (target.node === void 0) continue;
+			pendingNodes.push(this.getDependency("node", name));
+			pendingInputAccessors.push(this.getDependency("accessor", input));
+			pendingOutputAccessors.push(this.getDependency("accessor", output));
+			pendingSamplers.push(sampler);
+			pendingTargets.push(target);
+		}
+		return Promise.all([
+			Promise.all(pendingNodes),
+			Promise.all(pendingInputAccessors),
+			Promise.all(pendingOutputAccessors),
+			Promise.all(pendingSamplers),
+			Promise.all(pendingTargets)
+		]).then(function(dependencies) {
+			const nodes = dependencies[0];
+			const inputAccessors = dependencies[1];
+			const outputAccessors = dependencies[2];
+			const samplers = dependencies[3];
+			const targets = dependencies[4];
+			const tracks = [];
+			for (let i = 0, il = nodes.length; i < il; i++) {
+				const node = nodes[i];
+				const inputAccessor = inputAccessors[i];
+				const outputAccessor = outputAccessors[i];
+				const sampler = samplers[i];
+				const target = targets[i];
+				if (node === void 0) continue;
+				if (node.updateMatrix) node.updateMatrix();
+				const createdTracks = parser._createAnimationTracks(node, inputAccessor, outputAccessor, sampler, target);
+				if (createdTracks) for (let k = 0; k < createdTracks.length; k++) tracks.push(createdTracks[k]);
+			}
+			const animation = new AnimationClip(animationName, void 0, tracks);
+			assignExtrasToUserData(animation, animationDef);
+			return animation;
+		});
+	}
+	createNodeMesh(nodeIndex) {
+		const json = this.json;
+		const parser = this;
+		const nodeDef = json.nodes[nodeIndex];
+		if (nodeDef.mesh === void 0) return null;
+		return parser.getDependency("mesh", nodeDef.mesh).then(function(mesh) {
+			const node = parser._getNodeRef(parser.meshCache, nodeDef.mesh, mesh);
+			if (nodeDef.weights !== void 0) node.traverse(function(o) {
+				if (!o.isMesh) return;
+				for (let i = 0, il = nodeDef.weights.length; i < il; i++) o.morphTargetInfluences[i] = nodeDef.weights[i];
+			});
+			return node;
+		});
+	}
+	/**
+	* Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#nodes-and-hierarchy
+	*
+	* @private
+	* @param {number} nodeIndex
+	* @return {Promise<Object3D>}
+	*/
+	loadNode(nodeIndex) {
+		const json = this.json;
+		const parser = this;
+		const nodeDef = json.nodes[nodeIndex];
+		const nodePending = parser._loadNodeShallow(nodeIndex);
+		const childPending = [];
+		const childrenDef = nodeDef.children || [];
+		for (let i = 0, il = childrenDef.length; i < il; i++) childPending.push(parser.getDependency("node", childrenDef[i]));
+		const skeletonPending = nodeDef.skin === void 0 ? Promise.resolve(null) : parser.getDependency("skin", nodeDef.skin);
+		return Promise.all([
+			nodePending,
+			Promise.all(childPending),
+			skeletonPending
+		]).then(function(results) {
+			const node = results[0];
+			const children = results[1];
+			const skeleton = results[2];
+			if (skeleton !== null) node.traverse(function(mesh) {
+				if (!mesh.isSkinnedMesh) return;
+				mesh.bind(skeleton, _identityMatrix);
+			});
+			for (let i = 0, il = children.length; i < il; i++) node.add(children[i]);
+			if (node.userData.pivot !== void 0 && children.length > 0) {
+				const pivot = node.userData.pivot;
+				const pivotChild = children[0];
+				node.pivot = new Vector3().fromArray(pivot);
+				node.position.x -= pivot[0];
+				node.position.y -= pivot[1];
+				node.position.z -= pivot[2];
+				pivotChild.position.set(0, 0, 0);
+				delete node.userData.pivot;
+			}
+			return node;
+		});
+	}
+	_loadNodeShallow(nodeIndex) {
+		const json = this.json;
+		const extensions = this.extensions;
+		const parser = this;
+		if (this.nodeCache[nodeIndex] !== void 0) return this.nodeCache[nodeIndex];
+		const nodeDef = json.nodes[nodeIndex];
+		const nodeName = nodeDef.name ? parser.createUniqueName(nodeDef.name) : "";
+		const pending = [];
+		const meshPromise = parser._invokeOne(function(ext) {
+			return ext.createNodeMesh && ext.createNodeMesh(nodeIndex);
+		});
+		if (meshPromise) pending.push(meshPromise);
+		if (nodeDef.camera !== void 0) pending.push(parser.getDependency("camera", nodeDef.camera).then(function(camera) {
+			return parser._getNodeRef(parser.cameraCache, nodeDef.camera, camera);
+		}));
+		parser._invokeAll(function(ext) {
+			return ext.createNodeAttachment && ext.createNodeAttachment(nodeIndex);
+		}).forEach(function(promise) {
+			pending.push(promise);
+		});
+		this.nodeCache[nodeIndex] = Promise.all(pending).then(function(objects) {
+			let node;
+			if (nodeDef.isBone === true) node = new Bone();
+			else if (objects.length > 1) node = new Group();
+			else if (objects.length === 1) node = objects[0];
+			else node = new Object3D();
+			if (node !== objects[0]) for (let i = 0, il = objects.length; i < il; i++) node.add(objects[i]);
+			if (nodeDef.name) {
+				node.userData.name = nodeDef.name;
+				node.name = nodeName;
+			}
+			assignExtrasToUserData(node, nodeDef);
+			if (nodeDef.extensions) addUnknownExtensionsToUserData(extensions, node, nodeDef);
+			if (nodeDef.matrix !== void 0) {
+				const matrix = new Matrix4();
+				matrix.fromArray(nodeDef.matrix);
+				node.applyMatrix4(matrix);
+			} else {
+				if (nodeDef.translation !== void 0) node.position.fromArray(nodeDef.translation);
+				if (nodeDef.rotation !== void 0) node.quaternion.fromArray(nodeDef.rotation);
+				if (nodeDef.scale !== void 0) node.scale.fromArray(nodeDef.scale);
+			}
+			if (!parser.associations.has(node)) parser.associations.set(node, {});
+			else if (nodeDef.mesh !== void 0 && parser.meshCache.refs[nodeDef.mesh] > 1) {
+				const mapping = parser.associations.get(node);
+				parser.associations.set(node, { ...mapping });
+			}
+			parser.associations.get(node).nodes = nodeIndex;
+			return node;
+		});
+		return this.nodeCache[nodeIndex];
+	}
+	/**
+	* Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#scenes
+	*
+	* @private
+	* @param {number} sceneIndex
+	* @return {Promise<Group>}
+	*/
+	loadScene(sceneIndex) {
+		const extensions = this.extensions;
+		const sceneDef = this.json.scenes[sceneIndex];
+		const parser = this;
+		const scene = new Group();
+		if (sceneDef.name) scene.name = parser.createUniqueName(sceneDef.name);
+		assignExtrasToUserData(scene, sceneDef);
+		if (sceneDef.extensions) addUnknownExtensionsToUserData(extensions, scene, sceneDef);
+		const nodeIds = sceneDef.nodes || [];
+		const pending = [];
+		for (let i = 0, il = nodeIds.length; i < il; i++) pending.push(parser.getDependency("node", nodeIds[i]));
+		return Promise.all(pending).then(function(nodes) {
+			for (let i = 0, il = nodes.length; i < il; i++) {
+				const node = nodes[i];
+				if (node.parent !== null) scene.add(clone(node));
+				else scene.add(node);
+			}
+			const reduceAssociations = (node) => {
+				const reducedAssociations = /* @__PURE__ */ new Map();
+				for (const [key, value] of parser.associations) if (key instanceof Material || key instanceof Texture) reducedAssociations.set(key, value);
+				node.traverse((node) => {
+					const mappings = parser.associations.get(node);
+					if (mappings != null) reducedAssociations.set(node, mappings);
+				});
+				return reducedAssociations;
+			};
+			parser.associations = reduceAssociations(scene);
+			return scene;
+		});
+	}
+	_createAnimationTracks(node, inputAccessor, outputAccessor, sampler, target) {
+		const tracks = [];
+		const targetName = node.name ? node.name : node.uuid;
+		const targetNames = [];
+		function collectMorphTargets(object) {
+			if (object.morphTargetInfluences) targetNames.push(object.name ? object.name : object.uuid);
+		}
+		if (PATH_PROPERTIES[target.path] === PATH_PROPERTIES.weights) {
+			collectMorphTargets(node);
+			if (node.isGroup) node.children.forEach(collectMorphTargets);
+		} else targetNames.push(targetName);
+		let TypedKeyframeTrack;
+		switch (PATH_PROPERTIES[target.path]) {
+			case PATH_PROPERTIES.weights:
+				TypedKeyframeTrack = NumberKeyframeTrack;
+				break;
+			case PATH_PROPERTIES.rotation:
+				TypedKeyframeTrack = QuaternionKeyframeTrack;
+				break;
+			case PATH_PROPERTIES.translation:
+			case PATH_PROPERTIES.scale:
+				TypedKeyframeTrack = VectorKeyframeTrack;
+				break;
+			default:
+				switch (outputAccessor.itemSize) {
+					case 1:
+						TypedKeyframeTrack = NumberKeyframeTrack;
+						break;
+					default:
+						TypedKeyframeTrack = VectorKeyframeTrack;
+						break;
+				}
+				break;
+		}
+		const interpolation = sampler.interpolation !== void 0 ? INTERPOLATION[sampler.interpolation] : InterpolateLinear;
+		const outputArray = this._getArrayFromAccessor(outputAccessor);
+		for (let j = 0, jl = targetNames.length; j < jl; j++) {
+			const track = new TypedKeyframeTrack(targetNames[j] + "." + PATH_PROPERTIES[target.path], inputAccessor.array, outputArray, interpolation);
+			if (sampler.interpolation === "CUBICSPLINE") this._createCubicSplineTrackInterpolant(track);
+			tracks.push(track);
+		}
+		return tracks;
+	}
+	_getArrayFromAccessor(accessor) {
+		let outputArray = accessor.array;
+		if (accessor.normalized) {
+			const scale = getNormalizedComponentScale(outputArray.constructor);
+			const scaled = new Float32Array(outputArray.length);
+			for (let j = 0, jl = outputArray.length; j < jl; j++) scaled[j] = outputArray[j] * scale;
+			outputArray = scaled;
+		}
+		return outputArray;
+	}
+	_createCubicSplineTrackInterpolant(track) {
+		track.createInterpolant = function InterpolantFactoryMethodGLTFCubicSpline(result) {
+			return new (this instanceof QuaternionKeyframeTrack ? GLTFCubicSplineQuaternionInterpolant : GLTFCubicSplineInterpolant)(this.times, this.values, this.getValueSize() / 3, result);
+		};
+		track.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline = true;
+	}
+};
+/**
+*
+* @private
+* @param {BufferGeometry} geometry
+* @param {GLTF.Primitive} primitiveDef
+* @param {GLTFParser} parser
+*/
+function computeBounds(geometry, primitiveDef, parser) {
+	const attributes = primitiveDef.attributes;
+	const box = new Box3();
+	if (attributes.POSITION !== void 0) {
+		const accessor = parser.json.accessors[attributes.POSITION];
+		const min = accessor.min;
+		const max = accessor.max;
+		if (min !== void 0 && max !== void 0) {
+			box.set(new Vector3(min[0], min[1], min[2]), new Vector3(max[0], max[1], max[2]));
+			if (accessor.normalized) {
+				const boxScale = getNormalizedComponentScale(WEBGL_COMPONENT_TYPES[accessor.componentType]);
+				box.min.multiplyScalar(boxScale);
+				box.max.multiplyScalar(boxScale);
+			}
+		} else {
+			console.warn("THREE.GLTFLoader: Missing min/max properties for accessor POSITION.");
+			return;
+		}
+	} else return;
+	const targets = primitiveDef.targets;
+	if (targets !== void 0) {
+		const maxDisplacement = new Vector3();
+		const vector = new Vector3();
+		for (let i = 0, il = targets.length; i < il; i++) {
+			const target = targets[i];
+			if (target.POSITION !== void 0) {
+				const accessor = parser.json.accessors[target.POSITION];
+				const min = accessor.min;
+				const max = accessor.max;
+				if (min !== void 0 && max !== void 0) {
+					vector.setX(Math.max(Math.abs(min[0]), Math.abs(max[0])));
+					vector.setY(Math.max(Math.abs(min[1]), Math.abs(max[1])));
+					vector.setZ(Math.max(Math.abs(min[2]), Math.abs(max[2])));
+					if (accessor.normalized) {
+						const boxScale = getNormalizedComponentScale(WEBGL_COMPONENT_TYPES[accessor.componentType]);
+						vector.multiplyScalar(boxScale);
+					}
+					maxDisplacement.max(vector);
+				} else console.warn("THREE.GLTFLoader: Missing min/max properties for accessor POSITION.");
+			}
+		}
+		box.expandByVector(maxDisplacement);
+	}
+	geometry.boundingBox = box;
+	const sphere = new Sphere();
+	box.getCenter(sphere.center);
+	sphere.radius = box.min.distanceTo(box.max) / 2;
+	geometry.boundingSphere = sphere;
+}
+/**
+*
+* @private
+* @param {BufferGeometry} geometry
+* @param {GLTF.Primitive} primitiveDef
+* @param {GLTFParser} parser
+* @return {Promise<BufferGeometry>}
+*/
+function addPrimitiveAttributes(geometry, primitiveDef, parser) {
+	const attributes = primitiveDef.attributes;
+	const pending = [];
+	function assignAttributeAccessor(accessorIndex, attributeName) {
+		return parser.getDependency("accessor", accessorIndex).then(function(accessor) {
+			geometry.setAttribute(attributeName, accessor);
+		});
+	}
+	for (const gltfAttributeName in attributes) {
+		const threeAttributeName = ATTRIBUTES[gltfAttributeName] || gltfAttributeName.toLowerCase();
+		if (threeAttributeName in geometry.attributes) continue;
+		pending.push(assignAttributeAccessor(attributes[gltfAttributeName], threeAttributeName));
+	}
+	if (primitiveDef.indices !== void 0 && !geometry.index) {
+		const accessor = parser.getDependency("accessor", primitiveDef.indices).then(function(accessor) {
+			geometry.setIndex(accessor);
+		});
+		pending.push(accessor);
+	}
+	if (ColorManagement.workingColorSpace !== "srgb-linear" && "COLOR_0" in attributes) console.warn(`THREE.GLTFLoader: Converting vertex colors from "srgb-linear" to "${ColorManagement.workingColorSpace}" not supported.`);
+	assignExtrasToUserData(geometry, primitiveDef);
+	computeBounds(geometry, primitiveDef, parser);
+	return Promise.all(pending).then(function() {
+		return primitiveDef.targets !== void 0 ? addMorphTargets(geometry, primitiveDef.targets, parser) : geometry;
+	});
+}
+//#endregion
+export { GLTFLoader };
+
+//# sourceMappingURL=three_addons_loaders_GLTFLoader__js.js.map