file-viewer3 1.0.8 → 1.0.26

package/dist/components/ColladaLoader.js

@@ -0,0 +1,2282 @@
+import { $ as e, Bt as t, C as n, Ct as r, Dt as i, E as a, Et as o, F as s, Ft as c, Ht as l, I as u, K as d, Lt as f, Mt as p, Ot as m, R as h, Tt as g, U as _, V as v, Z as y, b, bt as x, et as S, f as C, ft as w, ht as T, m as E, n as D, nt as O, o as k, p as A, pt as j, q as M, r as N, rt as P, tt as F, u as I, w as L, wt as R, x as z, yt as B, z as V, zt as H } from "./three.module.js";
+//#region node_modules/.pnpm/three@0.184.0/node_modules/three/examples/jsm/loaders/TGALoader.js
+var U = class extends b {
+	constructor(e) {
+		super(e);
+	}
+	parse(e) {
+		function t(e) {
+			switch (e.image_type) {
+				case d:
+				case m:
+					if (e.colormap_length > 256 || e.colormap_size !== 24 || e.colormap_type !== 1) throw Error("THREE.TGALoader: Invalid type colormap data for indexed type.");
+					break;
+				case f:
+				case p:
+				case h:
+				case g:
+					if (e.colormap_type) throw Error("THREE.TGALoader: Invalid type colormap data for colormap type.");
+					break;
+				case u: throw Error("THREE.TGALoader: No data.");
+				default: throw Error("THREE.TGALoader: Invalid type " + e.image_type);
+			}
+			if (e.width <= 0 || e.height <= 0) throw Error("THREE.TGALoader: Invalid image size.");
+			if (e.pixel_size !== 8 && e.pixel_size !== 16 && e.pixel_size !== 24 && e.pixel_size !== 32) throw Error("THREE.TGALoader: Invalid pixel size " + e.pixel_size);
+		}
+		function n(e, t, n, r, i) {
+			let a, o, s = n.pixel_size >> 3, c = n.width * n.height * s;
+			if (t && (o = i.subarray(r, r += n.colormap_length * (n.colormap_size >> 3))), e) {
+				a = new Uint8Array(c);
+				let e, t, n, o = 0, l = new Uint8Array(s);
+				for (; o < c;) if (e = i[r++], t = (e & 127) + 1, e & 128) {
+					for (n = 0; n < s; ++n) l[n] = i[r++];
+					for (n = 0; n < t; ++n) a.set(l, o + n * s);
+					o += s * t;
+				} else {
+					for (t *= s, n = 0; n < t; ++n) a[o + n] = i[r++];
+					o += t;
+				}
+			} else a = i.subarray(r, r += t ? n.width * n.height : c);
+			return {
+				pixel_data: a,
+				palettes: o
+			};
+		}
+		function r(e, t, n, r, i, a, o, s, c) {
+			let l = c, u, d = 0, f, p, m = E.width;
+			for (p = t; p !== r; p += n) for (f = i; f !== o; f += a, d++) u = s[d], e[(f + m * p) * 4 + 3] = 255, e[(f + m * p) * 4 + 2] = l[u * 3 + 0], e[(f + m * p) * 4 + 1] = l[u * 3 + 1], e[(f + m * p) * 4 + 0] = l[u * 3 + 2];
+			return e;
+		}
+		function i(e, t, n, r, i, a, o, s) {
+			let c, l = 0, u, d, f = E.width;
+			for (d = t; d !== r; d += n) for (u = i; u !== o; u += a, l += 2) c = s[l + 0] + (s[l + 1] << 8), e[(u + f * d) * 4 + 0] = (c & 31744) >> 7, e[(u + f * d) * 4 + 1] = (c & 992) >> 2, e[(u + f * d) * 4 + 2] = (c & 31) << 3, e[(u + f * d) * 4 + 3] = c & 32768 ? 0 : 255;
+			return e;
+		}
+		function a(e, t, n, r, i, a, o, s) {
+			let c = 0, l, u, d = E.width;
+			for (u = t; u !== r; u += n) for (l = i; l !== o; l += a, c += 3) e[(l + d * u) * 4 + 3] = 255, e[(l + d * u) * 4 + 2] = s[c + 0], e[(l + d * u) * 4 + 1] = s[c + 1], e[(l + d * u) * 4 + 0] = s[c + 2];
+			return e;
+		}
+		function o(e, t, n, r, i, a, o, s) {
+			let c = 0, l, u, d = E.width;
+			for (u = t; u !== r; u += n) for (l = i; l !== o; l += a, c += 4) e[(l + d * u) * 4 + 2] = s[c + 0], e[(l + d * u) * 4 + 1] = s[c + 1], e[(l + d * u) * 4 + 0] = s[c + 2], e[(l + d * u) * 4 + 3] = s[c + 3];
+			return e;
+		}
+		function s(e, t, n, r, i, a, o, s) {
+			let c, l = 0, u, d, f = E.width;
+			for (d = t; d !== r; d += n) for (u = i; u !== o; u += a, l++) c = s[l], e[(u + f * d) * 4 + 0] = c, e[(u + f * d) * 4 + 1] = c, e[(u + f * d) * 4 + 2] = c, e[(u + f * d) * 4 + 3] = 255;
+			return e;
+		}
+		function c(e, t, n, r, i, a, o, s) {
+			let c = 0, l, u, d = E.width;
+			for (u = t; u !== r; u += n) for (l = i; l !== o; l += a, c += 2) e[(l + d * u) * 4 + 0] = s[c + 0], e[(l + d * u) * 4 + 1] = s[c + 0], e[(l + d * u) * 4 + 2] = s[c + 0], e[(l + d * u) * 4 + 3] = s[c + 1];
+			return e;
+		}
+		function l(e, t, n, l, u) {
+			let d, f, p, m, h, g;
+			switch ((E.flags & v) >> y) {
+				default:
+				case S:
+					d = 0, p = 1, h = t, f = 0, m = 1, g = n;
+					break;
+				case b:
+					d = 0, p = 1, h = t, f = n - 1, m = -1, g = -1;
+					break;
+				case C:
+					d = t - 1, p = -1, h = -1, f = 0, m = 1, g = n;
+					break;
+				case x:
+					d = t - 1, p = -1, h = -1, f = n - 1, m = -1, g = -1;
+					break;
+			}
+			if (k) switch (E.pixel_size) {
+				case 8:
+					s(e, f, m, g, d, p, h, l);
+					break;
+				case 16:
+					c(e, f, m, g, d, p, h, l);
+					break;
+				default: throw Error("THREE.TGALoader: Format not supported.");
+			}
+			else switch (E.pixel_size) {
+				case 8:
+					r(e, f, m, g, d, p, h, l, u);
+					break;
+				case 16:
+					i(e, f, m, g, d, p, h, l);
+					break;
+				case 24:
+					a(e, f, m, g, d, p, h, l);
+					break;
+				case 32:
+					o(e, f, m, g, d, p, h, l);
+					break;
+				default: throw Error("THREE.TGALoader: Format not supported.");
+			}
+			return e;
+		}
+		let u = 0, d = 1, f = 2, p = 3, m = 9, h = 10, g = 11, v = 48, y = 4, b = 0, x = 1, S = 2, C = 3;
+		if (e.length < 19) throw Error("THREE.TGALoader: Not enough data to contain header.");
+		let w = 0, T = new Uint8Array(e), E = {
+			id_length: T[w++],
+			colormap_type: T[w++],
+			image_type: T[w++],
+			colormap_index: T[w++] | T[w++] << 8,
+			colormap_length: T[w++] | T[w++] << 8,
+			colormap_size: T[w++],
+			origin: [T[w++] | T[w++] << 8, T[w++] | T[w++] << 8],
+			width: T[w++] | T[w++] << 8,
+			height: T[w++] | T[w++] << 8,
+			pixel_size: T[w++],
+			flags: T[w++]
+		};
+		if (t(E), E.id_length + w > e.length) throw Error("THREE.TGALoader: No data.");
+		w += E.id_length;
+		let D = !1, O = !1, k = !1;
+		switch (E.image_type) {
+			case 9:
+				D = !0, O = !0;
+				break;
+			case 1:
+				O = !0;
+				break;
+			case 10:
+				D = !0;
+				break;
+			case 2: break;
+			case 11:
+				D = !0, k = !0;
+				break;
+			case 3:
+				k = !0;
+				break;
+		}
+		let A = new Uint8Array(E.width * E.height * 4), j = n(D, O, E, w, T);
+		return l(A, E.width, E.height, j.pixel_data, j.palettes), {
+			data: A,
+			width: E.width,
+			height: E.height,
+			flipY: !0,
+			generateMipmaps: !0,
+			minFilter: _
+		};
+	}
+};
+//#endregion
+//#region node_modules/.pnpm/three@0.184.0/node_modules/three/examples/jsm/loaders/collada/ColladaParser.js
+function W(e, t) {
+	let n = [], r = e.childNodes;
+	for (let e = 0, i = r.length; e < i; e++) {
+		let i = r[e];
+		i.nodeName === t && n.push(i);
+	}
+	return n;
+}
+function G(e) {
+	return e.length === 0 ? [] : e.trim().split(/\s+/);
+}
+function K(e) {
+	return e.length === 0 ? [] : e.trim().split(/\s+/).map(parseFloat);
+}
+function q(e) {
+	return e.length === 0 ? [] : e.trim().split(/\s+/).map((e) => parseInt(e));
+}
+function J(e) {
+	return e.substring(1);
+}
+var Y = class {
+	constructor() {
+		this.count = 0;
+	}
+	generateId() {
+		return "three_default_" + this.count++;
+	}
+	parse(e) {
+		if (e.length === 0) return null;
+		let t = new DOMParser().parseFromString(e, "application/xml"), n = W(t, "COLLADA")[0], r = t.getElementsByTagName("parsererror")[0];
+		if (r !== void 0) {
+			let e = W(r, "div")[0], t;
+			return t = e ? e.textContent : this.parserErrorToText(r), console.error("THREE.ColladaLoader: Failed to parse collada file.\n", t), null;
+		}
+		let i = n.getAttribute("version");
+		console.debug("THREE.ColladaLoader: File version", i);
+		let a = this.parseAsset(W(n, "asset")[0]), o = {
+			animations: {},
+			clips: {},
+			controllers: {},
+			images: {},
+			effects: {},
+			materials: {},
+			cameras: {},
+			lights: {},
+			geometries: {},
+			nodes: {},
+			visualScenes: {},
+			kinematicsModels: {},
+			physicsModels: {},
+			kinematicsScenes: {},
+			joints: {}
+		};
+		return this.library = o, this.collada = n, this.parseLibrary(n, "library_animations", "animation", this.parseAnimation.bind(this)), this.parseLibrary(n, "library_animation_clips", "animation_clip", this.parseAnimationClip.bind(this)), this.parseLibrary(n, "library_controllers", "controller", this.parseController.bind(this)), this.parseLibrary(n, "library_images", "image", this.parseImage.bind(this)), this.parseLibrary(n, "library_effects", "effect", this.parseEffect.bind(this)), this.parseLibrary(n, "library_materials", "material", this.parseMaterial.bind(this)), this.parseLibrary(n, "library_cameras", "camera", this.parseCamera.bind(this)), this.parseLibrary(n, "library_lights", "light", this.parseLight.bind(this)), this.parseLibrary(n, "library_geometries", "geometry", this.parseGeometry.bind(this)), this.parseLibrary(n, "library_nodes", "node", this.parseNode.bind(this)), this.parseLibrary(n, "library_visual_scenes", "visual_scene", this.parseVisualScene.bind(this)), this.parseLibrary(n, "library_joints", "joint", this.parseLibraryJoint.bind(this)), this.parseLibrary(n, "library_kinematics_models", "kinematics_model", this.parseKinematicsModel.bind(this)), this.parseLibrary(n, "library_physics_models", "physics_model", this.parsePhysicsModel.bind(this)), this.parseLibrary(n, "scene", "instance_kinematics_scene", this.parseKinematicsScene.bind(this)), {
+			library: o,
+			asset: a,
+			collada: n
+		};
+	}
+	parserErrorToText(e) {
+		let t = [], n = [e];
+		for (; n.length;) {
+			let e = n.shift();
+			e.nodeType === Node.TEXT_NODE ? t.push(e.textContent) : (t.push("\n"), n.push(...e.childNodes));
+		}
+		return t.join("").trim();
+	}
+	parseAsset(e) {
+		return {
+			unit: this.parseAssetUnit(W(e, "unit")[0]),
+			upAxis: this.parseAssetUpAxis(W(e, "up_axis")[0])
+		};
+	}
+	parseAssetUnit(e) {
+		return e !== void 0 && e.hasAttribute("meter") === !0 ? parseFloat(e.getAttribute("meter")) : 1;
+	}
+	parseAssetUpAxis(e) {
+		return e === void 0 ? "Y_UP" : e.textContent;
+	}
+	parseLibrary(e, t, n, r) {
+		let i = W(e, t)[0];
+		if (i !== void 0) {
+			let e = W(i, n);
+			for (let t = 0; t < e.length; t++) r(e[t]);
+		}
+	}
+	parseAnimation(e) {
+		let t = {
+			sources: {},
+			samplers: {},
+			channels: {}
+		}, n = !1;
+		for (let r = 0, i = e.childNodes.length; r < i; r++) {
+			let i = e.childNodes[r];
+			if (i.nodeType !== 1) continue;
+			let a;
+			switch (i.nodeName) {
+				case "source":
+					a = i.getAttribute("id"), t.sources[a] = this.parseSource(i);
+					break;
+				case "sampler":
+					a = i.getAttribute("id"), t.samplers[a] = this.parseAnimationSampler(i);
+					break;
+				case "channel":
+					a = i.getAttribute("target"), t.channels[a] = this.parseAnimationChannel(i);
+					break;
+				case "animation":
+					this.parseAnimation(i), n = !0;
+					break;
+				default:
+			}
+		}
+		n === !1 && (this.library.animations[e.getAttribute("id") || y.generateUUID()] = t);
+	}
+	parseAnimationSampler(e) {
+		let t = { inputs: {} };
+		for (let n = 0, r = e.childNodes.length; n < r; n++) {
+			let r = e.childNodes[n];
+			if (r.nodeType === 1) switch (r.nodeName) {
+				case "input":
+					let e = J(r.getAttribute("source")), n = r.getAttribute("semantic");
+					t.inputs[n] = e;
+					break;
+			}
+		}
+		return t;
+	}
+	parseAnimationChannel(e) {
+		let t = {}, n = e.getAttribute("target").split("/"), r = n.shift(), i = n.shift(), a = i.indexOf("(") !== -1, o = i.indexOf(".") !== -1;
+		if (o) n = i.split("."), i = n.shift(), t.member = n.shift();
+		else if (a) {
+			let e = i.split("(");
+			i = e.shift();
+			for (let t = 0; t < e.length; t++) e[t] = parseInt(e[t].replace(/\)/, ""));
+			t.indices = e;
+		}
+		return t.id = r, t.sid = i, t.arraySyntax = a, t.memberSyntax = o, t.sampler = J(e.getAttribute("source")), t;
+	}
+	parseAnimationClip(e) {
+		let t = {
+			name: e.getAttribute("id") || "default",
+			start: parseFloat(e.getAttribute("start") || 0),
+			end: parseFloat(e.getAttribute("end") || 0),
+			animations: []
+		};
+		for (let n = 0, r = e.childNodes.length; n < r; n++) {
+			let r = e.childNodes[n];
+			if (r.nodeType === 1) switch (r.nodeName) {
+				case "instance_animation":
+					t.animations.push(J(r.getAttribute("url")));
+					break;
+			}
+		}
+		this.library.clips[e.getAttribute("id")] = t;
+	}
+	parseController(e) {
+		let t = {};
+		for (let n = 0, r = e.childNodes.length; n < r; n++) {
+			let r = e.childNodes[n];
+			if (r.nodeType === 1) switch (r.nodeName) {
+				case "skin":
+					t.id = J(r.getAttribute("source")), t.skin = this.parseSkin(r);
+					break;
+				case "morph":
+					t.id = J(r.getAttribute("source")), console.warn("THREE.ColladaLoader: Morph target animation not supported yet.");
+					break;
+			}
+		}
+		this.library.controllers[e.getAttribute("id")] = t;
+	}
+	parseSkin(e) {
+		let t = { sources: {} };
+		for (let n = 0, r = e.childNodes.length; n < r; n++) {
+			let r = e.childNodes[n];
+			if (r.nodeType === 1) switch (r.nodeName) {
+				case "bind_shape_matrix":
+					t.bindShapeMatrix = K(r.textContent);
+					break;
+				case "source":
+					let e = r.getAttribute("id");
+					t.sources[e] = this.parseSource(r);
+					break;
+				case "joints":
+					t.joints = this.parseJoints(r);
+					break;
+				case "vertex_weights":
+					t.vertexWeights = this.parseVertexWeights(r);
+					break;
+			}
+		}
+		return t;
+	}
+	parseJoints(e) {
+		let t = { inputs: {} };
+		for (let n = 0, r = e.childNodes.length; n < r; n++) {
+			let r = e.childNodes[n];
+			if (r.nodeType === 1) switch (r.nodeName) {
+				case "input":
+					let e = r.getAttribute("semantic"), n = J(r.getAttribute("source"));
+					t.inputs[e] = n;
+					break;
+			}
+		}
+		return t;
+	}
+	parseVertexWeights(e) {
+		let t = { inputs: {} };
+		for (let n = 0, r = e.childNodes.length; n < r; n++) {
+			let r = e.childNodes[n];
+			if (r.nodeType === 1) switch (r.nodeName) {
+				case "input":
+					let e = r.getAttribute("semantic"), n = J(r.getAttribute("source")), i = parseInt(r.getAttribute("offset"));
+					t.inputs[e] = {
+						id: n,
+						offset: i
+					};
+					break;
+				case "vcount":
+					t.vcount = q(r.textContent);
+					break;
+				case "v":
+					t.v = q(r.textContent);
+					break;
+			}
+		}
+		return t;
+	}
+	parseImage(e) {
+		let t = { init_from: W(e, "init_from")[0].textContent };
+		this.library.images[e.getAttribute("id")] = t;
+	}
+	parseEffect(e) {
+		let t = {};
+		for (let n = 0, r = e.childNodes.length; n < r; n++) {
+			let r = e.childNodes[n];
+			if (r.nodeType === 1) switch (r.nodeName) {
+				case "profile_COMMON":
+					t.profile = this.parseEffectProfileCOMMON(r);
+					break;
+			}
+		}
+		this.library.effects[e.getAttribute("id")] = t;
+	}
+	parseEffectProfileCOMMON(e) {
+		let t = {
+			surfaces: {},
+			samplers: {}
+		};
+		for (let n = 0, r = e.childNodes.length; n < r; n++) {
+			let r = e.childNodes[n];
+			if (r.nodeType === 1) switch (r.nodeName) {
+				case "newparam":
+					this.parseEffectNewparam(r, t);
+					break;
+				case "technique":
+					t.technique = this.parseEffectTechnique(r);
+					break;
+				case "extra":
+					t.extra = this.parseEffectExtra(r);
+					break;
+			}
+		}
+		return t;
+	}
+	parseEffectNewparam(e, t) {
+		let n = e.getAttribute("sid");
+		for (let r = 0, i = e.childNodes.length; r < i; r++) {
+			let i = e.childNodes[r];
+			if (i.nodeType === 1) switch (i.nodeName) {
+				case "surface":
+					t.surfaces[n] = this.parseEffectSurface(i);
+					break;
+				case "sampler2D":
+					t.samplers[n] = this.parseEffectSampler(i);
+					break;
+			}
+		}
+	}
+	parseEffectSurface(e) {
+		let t = {};
+		for (let n = 0, r = e.childNodes.length; n < r; n++) {
+			let r = e.childNodes[n];
+			if (r.nodeType === 1) switch (r.nodeName) {
+				case "init_from":
+					t.init_from = r.textContent;
+					break;
+			}
+		}
+		return t;
+	}
+	parseEffectSampler(e) {
+		let t = {};
+		for (let n = 0, r = e.childNodes.length; n < r; n++) {
+			let r = e.childNodes[n];
+			if (r.nodeType === 1) switch (r.nodeName) {
+				case "source":
+					t.source = r.textContent;
+					break;
+			}
+		}
+		return t;
+	}
+	parseEffectTechnique(e) {
+		let t = {};
+		for (let n = 0, r = e.childNodes.length; n < r; n++) {
+			let r = e.childNodes[n];
+			if (r.nodeType === 1) switch (r.nodeName) {
+				case "constant":
+				case "lambert":
+				case "blinn":
+				case "phong":
+					t.type = r.nodeName, t.parameters = this.parseEffectParameters(r);
+					break;
+				case "extra":
+					t.extra = this.parseEffectExtra(r);
+					break;
+			}
+		}
+		return t;
+	}
+	parseEffectParameters(e) {
+		let t = {};
+		for (let n = 0, r = e.childNodes.length; n < r; n++) {
+			let r = e.childNodes[n];
+			if (r.nodeType === 1) switch (r.nodeName) {
+				case "emission":
+				case "diffuse":
+				case "specular":
+				case "bump":
+				case "ambient":
+				case "shininess":
+				case "transparency":
+					t[r.nodeName] = this.parseEffectParameter(r);
+					break;
+				case "transparent":
+					t[r.nodeName] = {
+						opaque: r.hasAttribute("opaque") ? r.getAttribute("opaque") : "A_ONE",
+						data: this.parseEffectParameter(r)
+					};
+					break;
+			}
+		}
+		return t;
+	}
+	parseEffectParameter(e) {
+		let t = {};
+		for (let n = 0, r = e.childNodes.length; n < r; n++) {
+			let r = e.childNodes[n];
+			if (r.nodeType === 1) switch (r.nodeName) {
+				case "color":
+					t[r.nodeName] = K(r.textContent);
+					break;
+				case "float":
+					t[r.nodeName] = parseFloat(r.textContent);
+					break;
+				case "texture":
+					t[r.nodeName] = {
+						id: r.getAttribute("texture"),
+						extra: this.parseEffectParameterTexture(r)
+					};
+					break;
+			}
+		}
+		return t;
+	}
+	parseEffectParameterTexture(e) {
+		let t = { technique: {} };
+		for (let n = 0, r = e.childNodes.length; n < r; n++) {
+			let r = e.childNodes[n];
+			if (r.nodeType === 1) switch (r.nodeName) {
+				case "extra":
+					this.parseEffectParameterTextureExtra(r, t);
+					break;
+			}
+		}
+		return t;
+	}
+	parseEffectParameterTextureExtra(e, t) {
+		for (let n = 0, r = e.childNodes.length; n < r; n++) {
+			let r = e.childNodes[n];
+			if (r.nodeType === 1) switch (r.nodeName) {
+				case "technique":
+					this.parseEffectParameterTextureExtraTechnique(r, t);
+					break;
+			}
+		}
+	}
+	parseEffectParameterTextureExtraTechnique(e, t) {
+		for (let n = 0, r = e.childNodes.length; n < r; n++) {
+			let r = e.childNodes[n];
+			if (r.nodeType === 1) switch (r.nodeName) {
+				case "repeatU":
+				case "repeatV":
+				case "offsetU":
+				case "offsetV":
+					t.technique[r.nodeName] = parseFloat(r.textContent);
+					break;
+				case "wrapU":
+				case "wrapV":
+					r.textContent.toUpperCase() === "TRUE" ? t.technique[r.nodeName] = 1 : r.textContent.toUpperCase() === "FALSE" ? t.technique[r.nodeName] = 0 : t.technique[r.nodeName] = parseInt(r.textContent);
+					break;
+				case "bump":
+					t[r.nodeName] = this.parseEffectExtraTechniqueBump(r);
+					break;
+			}
+		}
+	}
+	parseEffectExtra(e) {
+		let t = {};
+		for (let n = 0, r = e.childNodes.length; n < r; n++) {
+			let r = e.childNodes[n];
+			if (r.nodeType === 1) switch (r.nodeName) {
+				case "technique":
+					t.technique = this.parseEffectExtraTechnique(r);
+					break;
+			}
+		}
+		return t;
+	}
+	parseEffectExtraTechnique(e) {
+		let t = {};
+		for (let n = 0, r = e.childNodes.length; n < r; n++) {
+			let r = e.childNodes[n];
+			if (r.nodeType === 1) switch (r.nodeName) {
+				case "double_sided":
+					t[r.nodeName] = parseInt(r.textContent);
+					break;
+				case "bump":
+					t[r.nodeName] = this.parseEffectExtraTechniqueBump(r);
+					break;
+			}
+		}
+		return t;
+	}
+	parseEffectExtraTechniqueBump(e) {
+		let t = {};
+		for (let n = 0, r = e.childNodes.length; n < r; n++) {
+			let r = e.childNodes[n];
+			if (r.nodeType === 1) switch (r.nodeName) {
+				case "texture":
+					t[r.nodeName] = {
+						id: r.getAttribute("texture"),
+						texcoord: r.getAttribute("texcoord"),
+						extra: this.parseEffectParameterTexture(r)
+					};
+					break;
+			}
+		}
+		return t;
+	}
+	parseMaterial(e) {
+		let t = { name: e.getAttribute("name") };
+		for (let n = 0, r = e.childNodes.length; n < r; n++) {
+			let r = e.childNodes[n];
+			if (r.nodeType === 1) switch (r.nodeName) {
+				case "instance_effect":
+					t.url = J(r.getAttribute("url"));
+					break;
+			}
+		}
+		this.library.materials[e.getAttribute("id")] = t;
+	}
+	parseCamera(e) {
+		let t = { name: e.getAttribute("name") };
+		for (let n = 0, r = e.childNodes.length; n < r; n++) {
+			let r = e.childNodes[n];
+			if (r.nodeType === 1) switch (r.nodeName) {
+				case "optics":
+					t.optics = this.parseCameraOptics(r);
+					break;
+			}
+		}
+		this.library.cameras[e.getAttribute("id")] = t;
+	}
+	parseCameraOptics(e) {
+		for (let t = 0; t < e.childNodes.length; t++) {
+			let n = e.childNodes[t];
+			switch (n.nodeName) {
+				case "technique_common": return this.parseCameraTechnique(n);
+			}
+		}
+		return {};
+	}
+	parseCameraTechnique(e) {
+		let t = {};
+		for (let n = 0; n < e.childNodes.length; n++) {
+			let r = e.childNodes[n];
+			switch (r.nodeName) {
+				case "perspective":
+				case "orthographic":
+					t.technique = r.nodeName, t.parameters = this.parseCameraParameters(r);
+					break;
+			}
+		}
+		return t;
+	}
+	parseCameraParameters(e) {
+		let t = {};
+		for (let n = 0; n < e.childNodes.length; n++) {
+			let r = e.childNodes[n];
+			switch (r.nodeName) {
+				case "xfov":
+				case "yfov":
+				case "xmag":
+				case "ymag":
+				case "znear":
+				case "zfar":
+				case "aspect_ratio":
+					t[r.nodeName] = parseFloat(r.textContent);
+					break;
+			}
+		}
+		return t;
+	}
+	parseLight(e) {
+		let t = {};
+		for (let n = 0, r = e.childNodes.length; n < r; n++) {
+			let r = e.childNodes[n];
+			if (r.nodeType === 1) switch (r.nodeName) {
+				case "technique_common":
+					t = this.parseLightTechnique(r);
+					break;
+			}
+		}
+		this.library.lights[e.getAttribute("id")] = t;
+	}
+	parseLightTechnique(e) {
+		let t = {};
+		for (let n = 0, r = e.childNodes.length; n < r; n++) {
+			let r = e.childNodes[n];
+			if (r.nodeType === 1) switch (r.nodeName) {
+				case "directional":
+				case "point":
+				case "spot":
+				case "ambient":
+					t.technique = r.nodeName, t.parameters = this.parseLightParameters(r);
+					break;
+			}
+		}
+		return t;
+	}
+	parseLightParameters(e) {
+		let t = {};
+		for (let n = 0, r = e.childNodes.length; n < r; n++) {
+			let r = e.childNodes[n];
+			if (r.nodeType === 1) switch (r.nodeName) {
+				case "color":
+					let e = K(r.textContent);
+					t.color = new A().fromArray(e), E.colorSpaceToWorking(t.color, R);
+					break;
+				case "falloff_angle":
+					t.falloffAngle = parseFloat(r.textContent);
+					break;
+				case "quadratic_attenuation":
+					let n = parseFloat(r.textContent);
+					t.distance = n ? Math.sqrt(1 / n) : 0;
+					break;
+			}
+		}
+		return t;
+	}
+	parseGeometry(e) {
+		let t = {
+			name: e.getAttribute("name"),
+			sources: {},
+			vertices: {},
+			primitives: []
+		}, n = W(e, "mesh")[0];
+		if (n !== void 0) {
+			for (let e = 0; e < n.childNodes.length; e++) {
+				let r = n.childNodes[e];
+				if (r.nodeType !== 1) continue;
+				let i = r.getAttribute("id");
+				switch (r.nodeName) {
+					case "source":
+						t.sources[i] = this.parseSource(r);
+						break;
+					case "vertices":
+						t.vertices = this.parseGeometryVertices(r);
+						break;
+					case "polygons":
+					case "lines":
+					case "linestrips":
+					case "polylist":
+					case "triangles":
+						t.primitives.push(this.parseGeometryPrimitive(r));
+						break;
+					default:
+				}
+			}
+			this.library.geometries[e.getAttribute("id")] = t;
+		}
+	}
+	parseSource(e) {
+		let t = {
+			array: [],
+			stride: 3
+		};
+		for (let n = 0; n < e.childNodes.length; n++) {
+			let r = e.childNodes[n];
+			if (r.nodeType === 1) switch (r.nodeName) {
+				case "float_array":
+					t.array = K(r.textContent);
+					break;
+				case "Name_array":
+					t.array = G(r.textContent);
+					break;
+				case "technique_common":
+					let e = W(r, "accessor")[0];
+					e !== void 0 && (t.stride = parseInt(e.getAttribute("stride")));
+					break;
+			}
+		}
+		return t;
+	}
+	parseGeometryVertices(e) {
+		let t = {};
+		for (let n = 0; n < e.childNodes.length; n++) {
+			let r = e.childNodes[n];
+			r.nodeType === 1 && (t[r.getAttribute("semantic")] = J(r.getAttribute("source")));
+		}
+		return t;
+	}
+	parseGeometryPrimitive(e) {
+		let t = {
+			type: e.nodeName,
+			material: e.getAttribute("material"),
+			count: parseInt(e.getAttribute("count")),
+			inputs: {},
+			stride: 0,
+			hasUV: !1
+		};
+		for (let n = 0, r = e.childNodes.length; n < r; n++) {
+			let r = e.childNodes[n];
+			if (r.nodeType === 1) switch (r.nodeName) {
+				case "input":
+					let e = J(r.getAttribute("source")), n = r.getAttribute("semantic"), i = parseInt(r.getAttribute("offset")), a = parseInt(r.getAttribute("set")), o = a > 0 ? n + a : n;
+					t.inputs[o] = {
+						id: e,
+						offset: i
+					}, t.stride = Math.max(t.stride, i + 1), n === "TEXCOORD" && (t.hasUV = !0);
+					break;
+				case "vcount":
+					t.vcount = q(r.textContent);
+					break;
+				case "p":
+					t.p = q(r.textContent);
+					break;
+			}
+		}
+		return t.type === "polygons" && (t.vcount = [t.p.length / t.stride]), t;
+	}
+	parseLibraryJoint(e) {
+		this.library.joints[e.getAttribute("id")] = this.parseKinematicsJoint(e);
+	}
+	parseKinematicsModel(e) {
+		let t = {
+			name: e.getAttribute("name") || "",
+			joints: {},
+			links: []
+		};
+		for (let n = 0; n < e.childNodes.length; n++) {
+			let r = e.childNodes[n];
+			if (r.nodeType === 1) switch (r.nodeName) {
+				case "technique_common":
+					this.parseKinematicsTechniqueCommon(r, t);
+					break;
+			}
+		}
+		this.library.kinematicsModels[e.getAttribute("id")] = t;
+	}
+	parseKinematicsTechniqueCommon(e, t) {
+		for (let n = 0; n < e.childNodes.length; n++) {
+			let r = e.childNodes[n];
+			if (r.nodeType === 1) switch (r.nodeName) {
+				case "joint":
+					t.joints[r.getAttribute("sid")] = this.parseKinematicsJoint(r);
+					break;
+				case "instance_joint":
+					t.joints[r.getAttribute("sid")] = this.library.joints[J(r.getAttribute("url"))];
+					break;
+				case "link":
+					t.links.push(this.parseKinematicsLink(r));
+					break;
+			}
+		}
+	}
+	parseKinematicsJoint(e) {
+		let t;
+		for (let n = 0; n < e.childNodes.length; n++) {
+			let r = e.childNodes[n];
+			if (r.nodeType === 1) switch (r.nodeName) {
+				case "prismatic":
+				case "revolute":
+					t = this.parseKinematicsJointParameter(r);
+					break;
+			}
+		}
+		return t;
+	}
+	parseKinematicsJointParameter(e) {
+		let n = {
+			sid: e.getAttribute("sid"),
+			name: e.getAttribute("name") || "",
+			axis: new t(),
+			limits: {
+				min: 0,
+				max: 0
+			},
+			type: e.nodeName,
+			static: !1,
+			zeroPosition: 0,
+			middlePosition: 0
+		};
+		for (let t = 0; t < e.childNodes.length; t++) {
+			let r = e.childNodes[t];
+			if (r.nodeType === 1) switch (r.nodeName) {
+				case "axis":
+					let e = K(r.textContent);
+					n.axis.fromArray(e);
+					break;
+				case "limits":
+					let t = r.getElementsByTagName("max")[0], i = r.getElementsByTagName("min")[0];
+					n.limits.max = parseFloat(t.textContent), n.limits.min = parseFloat(i.textContent);
+					break;
+			}
+		}
+		return n.limits.min >= n.limits.max && (n.static = !0), n.middlePosition = (n.limits.min + n.limits.max) / 2, n;
+	}
+	parseKinematicsLink(e) {
+		let t = {
+			sid: e.getAttribute("sid"),
+			name: e.getAttribute("name") || "",
+			attachments: [],
+			transforms: []
+		};
+		for (let n = 0; n < e.childNodes.length; n++) {
+			let r = e.childNodes[n];
+			if (r.nodeType === 1) switch (r.nodeName) {
+				case "attachment_full":
+					t.attachments.push(this.parseKinematicsAttachment(r));
+					break;
+				case "matrix":
+				case "translate":
+				case "rotate":
+					t.transforms.push(this.parseKinematicsTransform(r));
+					break;
+			}
+		}
+		return t;
+	}
+	parseKinematicsAttachment(e) {
+		let t = {
+			joint: e.getAttribute("joint").split("/").pop(),
+			transforms: [],
+			links: []
+		};
+		for (let n = 0; n < e.childNodes.length; n++) {
+			let r = e.childNodes[n];
+			if (r.nodeType === 1) switch (r.nodeName) {
+				case "link":
+					t.links.push(this.parseKinematicsLink(r));
+					break;
+				case "matrix":
+				case "translate":
+				case "rotate":
+					t.transforms.push(this.parseKinematicsTransform(r));
+					break;
+			}
+		}
+		return t;
+	}
+	parseKinematicsTransform(n) {
+		let r = { type: n.nodeName }, i = K(n.textContent);
+		switch (r.type) {
+			case "matrix":
+				r.obj = new e(), r.obj.fromArray(i).transpose();
+				break;
+			case "translate":
+				r.obj = new t(), r.obj.fromArray(i);
+				break;
+			case "rotate":
+				r.obj = new t(), r.obj.fromArray(i), r.angle = y.degToRad(i[3]);
+				break;
+		}
+		return r;
+	}
+	parsePhysicsModel(e) {
+		let t = {
+			name: e.getAttribute("name") || "",
+			rigidBodies: {}
+		};
+		for (let n = 0; n < e.childNodes.length; n++) {
+			let r = e.childNodes[n];
+			if (r.nodeType === 1) switch (r.nodeName) {
+				case "rigid_body":
+					t.rigidBodies[r.getAttribute("name")] = {}, this.parsePhysicsRigidBody(r, t.rigidBodies[r.getAttribute("name")]);
+					break;
+			}
+		}
+		this.library.physicsModels[e.getAttribute("id")] = t;
+	}
+	parsePhysicsRigidBody(e, t) {
+		for (let n = 0; n < e.childNodes.length; n++) {
+			let r = e.childNodes[n];
+			if (r.nodeType === 1) switch (r.nodeName) {
+				case "technique_common":
+					this.parsePhysicsTechniqueCommon(r, t);
+					break;
+			}
+		}
+	}
+	parsePhysicsTechniqueCommon(e, t) {
+		for (let n = 0; n < e.childNodes.length; n++) {
+			let r = e.childNodes[n];
+			if (r.nodeType === 1) switch (r.nodeName) {
+				case "inertia":
+					t.inertia = K(r.textContent);
+					break;
+				case "mass":
+					t.mass = K(r.textContent)[0];
+					break;
+			}
+		}
+	}
+	parseKinematicsScene(e) {
+		let t = { bindJointAxis: [] };
+		for (let n = 0; n < e.childNodes.length; n++) {
+			let r = e.childNodes[n];
+			if (r.nodeType === 1) switch (r.nodeName) {
+				case "bind_joint_axis":
+					t.bindJointAxis.push(this.parseKinematicsBindJointAxis(r));
+					break;
+			}
+		}
+		this.library.kinematicsScenes[J(e.getAttribute("url"))] = t;
+	}
+	parseKinematicsBindJointAxis(e) {
+		let t = { target: e.getAttribute("target").split("/").pop() };
+		for (let n = 0; n < e.childNodes.length; n++) {
+			let r = e.childNodes[n];
+			if (r.nodeType === 1) switch (r.nodeName) {
+				case "axis":
+					t.axis = r.getElementsByTagName("param")[0].textContent;
+					let e = t.axis.split("inst_").pop().split("axis")[0];
+					t.jointIndex = e.substring(0, e.length - 1);
+					break;
+			}
+		}
+		return t;
+	}
+	prepareNodes(e) {
+		let t = e.getElementsByTagName("node");
+		for (let e = 0; e < t.length; e++) {
+			let n = t[e];
+			n.hasAttribute("id") === !1 && n.setAttribute("id", this.generateId());
+		}
+	}
+	parseNode(n) {
+		let r = new e(), i = new t(), a = {
+			name: n.getAttribute("name") || "",
+			type: n.getAttribute("type"),
+			id: n.getAttribute("id"),
+			sid: n.getAttribute("sid"),
+			matrix: new e(),
+			nodes: [],
+			instanceCameras: [],
+			instanceControllers: [],
+			instanceLights: [],
+			instanceGeometries: [],
+			instanceNodes: [],
+			transforms: {},
+			transformData: {},
+			transformOrder: []
+		};
+		for (let e = 0; e < n.childNodes.length; e++) {
+			let t = n.childNodes[e];
+			if (t.nodeType !== 1) continue;
+			let o;
+			switch (t.nodeName) {
+				case "node":
+					a.nodes.push(t.getAttribute("id")), this.parseNode(t);
+					break;
+				case "instance_camera":
+					a.instanceCameras.push(J(t.getAttribute("url")));
+					break;
+				case "instance_controller":
+					a.instanceControllers.push(this.parseNodeInstance(t));
+					break;
+				case "instance_light":
+					a.instanceLights.push(J(t.getAttribute("url")));
+					break;
+				case "instance_geometry":
+					a.instanceGeometries.push(this.parseNodeInstance(t));
+					break;
+				case "instance_node":
+					a.instanceNodes.push(J(t.getAttribute("url")));
+					break;
+				case "matrix":
+					o = K(t.textContent), a.matrix.multiply(r.fromArray(o).transpose());
+					{
+						let e = t.getAttribute("sid");
+						a.transforms[e] = t.nodeName, a.transformData[e] = {
+							type: "matrix",
+							array: o
+						}, a.transformOrder.push(e);
+					}
+					break;
+				case "translate":
+					o = K(t.textContent), i.fromArray(o), a.matrix.multiply(r.makeTranslation(i.x, i.y, i.z));
+					{
+						let e = t.getAttribute("sid");
+						a.transforms[e] = t.nodeName, a.transformData[e] = {
+							type: "translate",
+							x: o[0],
+							y: o[1],
+							z: o[2]
+						}, a.transformOrder.push(e);
+					}
+					break;
+				case "rotate":
+					o = K(t.textContent);
+					{
+						let e = y.degToRad(o[3]);
+						a.matrix.multiply(r.makeRotationAxis(i.fromArray(o), e));
+						let n = t.getAttribute("sid");
+						a.transforms[n] = t.nodeName, a.transformData[n] = {
+							type: "rotate",
+							axis: [
+								o[0],
+								o[1],
+								o[2]
+							],
+							angle: o[3]
+						}, a.transformOrder.push(n);
+					}
+					break;
+				case "scale":
+					o = K(t.textContent), a.matrix.scale(i.fromArray(o));
+					{
+						let e = t.getAttribute("sid");
+						a.transforms[e] = t.nodeName, a.transformData[e] = {
+							type: "scale",
+							x: o[0],
+							y: o[1],
+							z: o[2]
+						}, a.transformOrder.push(e);
+					}
+					break;
+				case "extra": break;
+				default:
+			}
+		}
+		return this.hasNode(a.id) ? console.warn("THREE.ColladaLoader: There is already a node with ID %s. Exclude current node from further processing.", a.id) : this.library.nodes[a.id] = a, a;
+	}
+	parseNodeInstance(e) {
+		let t = {
+			id: J(e.getAttribute("url")),
+			materials: {},
+			skeletons: []
+		};
+		for (let n = 0; n < e.childNodes.length; n++) {
+			let r = e.childNodes[n];
+			switch (r.nodeName) {
+				case "bind_material":
+					let e = r.getElementsByTagName("instance_material");
+					for (let n = 0; n < e.length; n++) {
+						let r = e[n], i = r.getAttribute("symbol"), a = r.getAttribute("target");
+						t.materials[i] = J(a);
+					}
+					break;
+				case "skeleton":
+					t.skeletons.push(J(r.textContent));
+					break;
+				default: break;
+			}
+		}
+		return t;
+	}
+	parseVisualScene(e) {
+		let t = {
+			name: e.getAttribute("name"),
+			children: []
+		};
+		this.prepareNodes(e);
+		let n = W(e, "node");
+		for (let e = 0; e < n.length; e++) t.children.push(this.parseNode(n[e]));
+		this.library.visualScenes[e.getAttribute("id")] = t;
+	}
+	hasNode(e) {
+		return this.library.nodes[e] !== void 0;
+	}
+}, X = class {
+	constructor(n, r, i, a) {
+		this.library = n, this.collada = r, this.textureLoader = i, this.tgaLoader = a, this.tempColor = new A(), this.animations = [], this.kinematics = {}, this.position = new t(), this.scale = new t(), this.quaternion = new B(), this.matrix = new e(), this.deferredPivotAnimations = {}, this.transformNodes = {};
+	}
+	compose() {
+		let e = this.library;
+		this.buildLibrary(e.animations, this.buildAnimation.bind(this)), this.buildLibrary(e.clips, this.buildAnimationClip.bind(this)), this.buildLibrary(e.controllers, this.buildController.bind(this)), this.buildLibrary(e.images, this.buildImage.bind(this)), this.buildLibrary(e.effects, this.buildEffect.bind(this)), this.buildLibrary(e.materials, this.buildMaterial.bind(this)), this.buildLibrary(e.cameras, this.buildCamera.bind(this)), this.buildLibrary(e.lights, this.buildLight.bind(this)), this.buildLibrary(e.geometries, this.buildGeometry.bind(this)), this.buildLibrary(e.visualScenes, this.buildVisualScene.bind(this)), this.setupAnimations(), this.setupKinematics();
+		let t = this.parseScene(W(this.collada, "scene")[0]);
+		return t.animations = this.animations, {
+			scene: t,
+			animations: this.animations,
+			kinematics: this.kinematics
+		};
+	}
+	buildLibrary(e, t) {
+		for (let n in e) {
+			let r = e[n];
+			r.build = t(e[n]);
+		}
+	}
+	getBuild(e, t) {
+		return e.build === void 0 && (e.build = t(e)), e.build;
+	}
+	isEmpty(e) {
+		return Object.keys(e).length === 0;
+	}
+	buildAnimation(e) {
+		let t = [], n = e.channels, r = e.samplers, i = e.sources, a = this.aggregateAnimationChannels(n, r, i);
+		for (let e in a) {
+			let n = this.library.nodes[e];
+			if (!n) continue;
+			let r = a[e];
+			if (this.hasPivotTransforms(n)) this.collectDeferredPivotAnimation(e, r);
+			else {
+				let i = this.getNode(e), a = !1;
+				for (let e in r) {
+					let o = n.transforms[e], s = n.transformData[e], c = r[e];
+					switch (o) {
+						case "matrix":
+							this.buildMatrixTracks(i, c, n, t);
+							break;
+						case "translate":
+							this.buildTranslateTrack(i, c, s, t);
+							break;
+						case "rotate":
+							a || (this.buildRotateTrack(i, e, c, s, n, t), a = !0);
+							break;
+						case "scale":
+							this.buildScaleTrack(i, c, s, t);
+							break;
+					}
+				}
+			}
+		}
+		return t;
+	}
+	collectDeferredPivotAnimation(e, t) {
+		this.deferredPivotAnimations[e] || (this.deferredPivotAnimations[e] = {});
+		let n = this.deferredPivotAnimations[e];
+		for (let e in t) {
+			n[e] || (n[e] = {});
+			for (let r in t[e]) n[e][r] = t[e][r];
+		}
+	}
+	hasPivotTransforms(e) {
+		for (let t of [
+			"rotatePivot",
+			"rotatePivotInverse",
+			"rotatePivotTranslation",
+			"scalePivot",
+			"scalePivotInverse",
+			"scalePivotTranslation"
+		]) if (e.transforms[t] !== void 0) return !0;
+		return !1;
+	}
+	getAnimation(e) {
+		return this.getBuild(this.library.animations[e], this.buildAnimation.bind(this));
+	}
+	aggregateAnimationChannels(e, t, n) {
+		let r = {};
+		for (let i in e) {
+			if (!e.hasOwnProperty(i)) continue;
+			let a = e[i], o = t[a.sampler], s = o.inputs.INPUT, c = o.inputs.OUTPUT, l = n[s], u = n[c], d = o.inputs.INTERPOLATION, f = o.inputs.IN_TANGENT, p = o.inputs.OUT_TANGENT, m = d ? n[d] : null, h = f ? n[f] : null, g = p ? n[p] : null, _ = a.id, v = a.sid, y = a.member || "default";
+			r[_] || (r[_] = {}), r[_][v] || (r[_][v] = {}), r[_][v][y] = {
+				times: l.array,
+				values: u.array,
+				stride: u.stride,
+				arraySyntax: a.arraySyntax,
+				indices: a.indices,
+				interpolation: m ? m.array : null,
+				inTangent: h ? h.array : null,
+				outTangent: g ? g.array : null,
+				inTangentStride: h ? h.stride : 0,
+				outTangentStride: g ? g.stride : 0
+			};
+		}
+		return r;
+	}
+	buildMatrixTracks(e, t, n, r) {
+		let i = n.matrix.clone().transpose(), a = {};
+		for (let e in t) {
+			let n = t[e], r = n.times, i = n.values, o = n.stride;
+			for (let e = 0, t = r.length; e < t; e++) {
+				let t = r[e], s = e * o;
+				if (a[t] === void 0 && (a[t] = {}), n.arraySyntax === !0) {
+					let e = i[s], r = n.indices[0] + 4 * n.indices[1];
+					a[t][r] = e;
+				} else for (let e = 0; e < o; e++) a[t][e] = i[s + e];
+			}
+		}
+		let o = this.prepareAnimationData(a, i), s = {
+			name: e.uuid,
+			keyframes: o
+		};
+		this.createKeyframeTracks(s, r);
+	}
+	buildTranslateTrack(e, t, n, r) {
+		if (t.default && t.default.stride === 3) {
+			let n = t.default, i = Array.from(n.times), a = Array.from(n.values), o = new l(e.uuid + ".position", i, a), s = this.getInterpolationInfo(t);
+			this.applyInterpolation(o, s, t), r.push(o);
+			return;
+		}
+		let i = this.getTimesForAllAxes(t);
+		if (i.length === 0) return;
+		let a = [], o = this.getInterpolationInfo(t);
+		for (let e = 0; e < i.length; e++) {
+			let r = i[e], o = this.getValueAtTime(t.X, r, n.x), s = this.getValueAtTime(t.Y, r, n.y), c = this.getValueAtTime(t.Z, r, n.z);
+			a.push(o, s, c);
+		}
+		let s = new l(e.uuid + ".position", i, a);
+		this.applyInterpolation(s, o), r.push(s);
+	}
+	buildRotateTrack(e, n, r, i, a, o) {
+		let s = r.ANGLE || r.default;
+		if (!s) return;
+		let c = Array.from(s.times);
+		if (c.length === 0) return;
+		let l = [];
+		for (let e of a.transformOrder) if (a.transforms[e] === "rotate") {
+			let n = a.transformData[e];
+			l.push({
+				sid: e,
+				axis: new t(n.axis[0], n.axis[1], n.axis[2]),
+				defaultAngle: n.angle
+			});
+		}
+		let u = new B(), d = new B(), f = new B(), p = [], m = this.getInterpolationInfo(r);
+		for (let e = 0; e < c.length; e++) {
+			let t = c[e];
+			u.identity();
+			for (let e of l) {
+				let r;
+				r = e.sid === n ? this.getValueAtTime(s, t, e.defaultAngle) : e.defaultAngle;
+				let i = y.degToRad(r);
+				f.setFromAxisAngle(e.axis, i), u.multiply(f);
+			}
+			e > 0 && d.dot(u) < 0 && (u.x = -u.x, u.y = -u.y, u.z = -u.z, u.w = -u.w), d.copy(u), p.push(u.x, u.y, u.z, u.w);
+		}
+		let h = new x(e.uuid + ".quaternion", c, p);
+		this.applyInterpolation(h, m), o.push(h);
+	}
+	buildScaleTrack(e, t, n, r) {
+		if (t.default && t.default.stride === 3) {
+			let n = t.default, i = Array.from(n.times), a = Array.from(n.values), o = new l(e.uuid + ".scale", i, a), s = this.getInterpolationInfo(t);
+			this.applyInterpolation(o, s, t), r.push(o);
+			return;
+		}
+		let i = this.getTimesForAllAxes(t);
+		if (i.length === 0) return;
+		let a = [], o = this.getInterpolationInfo(t);
+		for (let e = 0; e < i.length; e++) {
+			let r = i[e], o = this.getValueAtTime(t.X, r, n.x), s = this.getValueAtTime(t.Y, r, n.y), c = this.getValueAtTime(t.Z, r, n.z);
+			a.push(o, s, c);
+		}
+		let s = new l(e.uuid + ".scale", i, a);
+		this.applyInterpolation(s, o), r.push(s);
+	}
+	getTimesForAllAxes(e) {
+		let t = [];
+		return e.X && (t = t.concat(Array.from(e.X.times))), e.Y && (t = t.concat(Array.from(e.Y.times))), e.Z && (t = t.concat(Array.from(e.Z.times))), e.ANGLE && (t = t.concat(Array.from(e.ANGLE.times))), e.default && (t = t.concat(Array.from(e.default.times))), t = [...new Set(t)].sort((e, t) => e - t), t;
+	}
+	getValueAtTime(e, t, n) {
+		if (!e) return n;
+		let r = e.times, i = e.values, a = e.interpolation;
+		for (let n = 0; n < r.length; n++) {
+			if (r[n] === t) return i[n];
+			if (r[n] > t) {
+				if (n === 0) return i[0];
+				let o = n - 1, s = n, c = r[o], l = r[s], u = i[o], d = i[s], f = a ? a[o] : "LINEAR";
+				return f === "STEP" ? u : f === "BEZIER" && e.inTangent && e.outTangent ? this.evaluateBezierComponent(e, o, s, c, l, t) : u + (t - c) / (l - c) * (d - u);
+			}
+		}
+		return i[i.length - 1];
+	}
+	evaluateBezierComponent(e, t, n, r, i, a) {
+		let o = e.values, s = e.inTangent, c = e.outTangent, l = e.inTangentStride || 1, u = o[t], d = o[n], f, p, m, h;
+		l === 2 ? (f = c[t * 2], p = c[t * 2 + 1], m = s[n * 2], h = s[n * 2 + 1]) : (f = r + (i - r) / 3, p = c[t], m = i - (i - r) / 3, h = s[n]);
+		let g = (a - r) / (i - r);
+		for (let e = 0; e < 8; e++) {
+			let e = g * g, t = e * g, n = 1 - g, o = n * n, s = o * n * r + 3 * o * g * f + 3 * n * e * m + t * i, c = 3 * o * (f - r) + 6 * n * g * (m - f) + 3 * e * (i - m);
+			if (Math.abs(c) < 1e-10) break;
+			let l = s - a;
+			if (Math.abs(l) < 1e-10) break;
+			g -= l / c, g = Math.max(0, Math.min(1, g));
+		}
+		let _ = g * g, v = _ * g, y = 1 - g, b = y * y;
+		return b * y * u + 3 * b * g * p + 3 * y * _ * h + v * d;
+	}
+	getInterpolationInfo(e) {
+		let t = [
+			"X",
+			"Y",
+			"Z",
+			"ANGLE",
+			"default"
+		], n = null, r = !0;
+		for (let i of t) {
+			let t = e[i];
+			if (!t || !t.interpolation) continue;
+			let a = t.interpolation;
+			for (let e = 0; e < a.length; e++) {
+				let t = a[e];
+				n === null ? n = t : t !== n && (r = !1);
+			}
+		}
+		return {
+			type: n || "LINEAR",
+			uniform: r
+		};
+	}
+	applyInterpolation(e, t, n = null) {
+		if (t.type === "STEP" && t.uniform) e.setInterpolation(u);
+		else if (t.type === "BEZIER" && t.uniform && n) {
+			let t = n.default;
+			t && t.inTangent && t.outTangent && (e.setInterpolation(s), e.settings = {
+				inTangents: new Float32Array(t.inTangent),
+				outTangents: new Float32Array(t.outTangent)
+			});
+		}
+	}
+	prepareAnimationData(e, t) {
+		let n = [];
+		for (let t in e) n.push({
+			time: parseFloat(t),
+			value: e[t]
+		});
+		n.sort((e, t) => e.time - t.time);
+		for (let e = 0; e < 16; e++) this.transformAnimationData(n, e, t.elements[e]);
+		return n;
+	}
+	createKeyframeTracks(e, t) {
+		let n = e.keyframes, r = e.name, i = [], a = [], o = [], s = [], c = this.position, u = this.quaternion, d = this.scale, f = this.matrix;
+		for (let e = 0, t = n.length; e < t; e++) {
+			let t = n[e], r = t.time, l = t.value;
+			f.fromArray(l).transpose(), f.decompose(c, u, d), i.push(r), a.push(c.x, c.y, c.z), o.push(u.x, u.y, u.z, u.w), s.push(d.x, d.y, d.z);
+		}
+		return a.length > 0 && t.push(new l(r + ".position", i, a)), o.length > 0 && t.push(new x(r + ".quaternion", i, o)), s.length > 0 && t.push(new l(r + ".scale", i, s)), t;
+	}
+	transformAnimationData(e, t, n) {
+		let r, i = !0, a, o;
+		for (a = 0, o = e.length; a < o; a++) r = e[a], r.value[t] === void 0 ? r.value[t] = null : i = !1;
+		if (i === !0) for (a = 0, o = e.length; a < o; a++) r = e[a], r.value[t] = n;
+		else this.createMissingKeyframes(e, t);
+	}
+	createMissingKeyframes(e, t) {
+		let n, r;
+		for (let i = 0, a = e.length; i < a; i++) {
+			let a = e[i];
+			if (a.value[t] === null) {
+				if (n = this.getPrev(e, i, t), r = this.getNext(e, i, t), n === null) {
+					a.value[t] = r.value[t];
+					continue;
+				}
+				if (r === null) {
+					a.value[t] = n.value[t];
+					continue;
+				}
+				this.interpolate(a, n, r, t);
+			}
+		}
+	}
+	getPrev(e, t, n) {
+		for (; t >= 0;) {
+			let r = e[t];
+			if (r.value[n] !== null) return r;
+			t--;
+		}
+		return null;
+	}
+	getNext(e, t, n) {
+		for (; t < e.length;) {
+			let r = e[t];
+			if (r.value[n] !== null) return r;
+			t++;
+		}
+		return null;
+	}
+	interpolate(e, t, n, r) {
+		if (n.time - t.time === 0) {
+			e.value[r] = t.value[r];
+			return;
+		}
+		e.value[r] = (e.time - t.time) * (n.value[r] - t.value[r]) / (n.time - t.time) + t.value[r];
+	}
+	buildAnimationClip(e) {
+		let t = [], n = e.name, r = e.end - e.start || -1, i = e.animations;
+		for (let e = 0, n = i.length; e < n; e++) {
+			let n = this.getAnimation(i[e]);
+			for (let e = 0, r = n.length; e < r; e++) t.push(n[e]);
+		}
+		return new N(n, r, t);
+	}
+	getAnimationClip(e) {
+		return this.getBuild(this.library.clips[e], this.buildAnimationClip.bind(this));
+	}
+	buildController(e) {
+		let t = { id: e.id }, n = this.library.geometries[t.id];
+		return e.skin !== void 0 && (t.skin = this.buildSkin(e.skin), n.sources.skinIndices = t.skin.indices, n.sources.skinWeights = t.skin.weights), t;
+	}
+	buildSkin(t) {
+		let n = {
+			joints: [],
+			indices: {
+				array: [],
+				stride: 4
+			},
+			weights: {
+				array: [],
+				stride: 4
+			}
+		}, r = t.sources, i = t.vertexWeights, a = i.vcount, o = i.v, s = i.inputs.JOINT.offset, c = i.inputs.WEIGHT.offset, l = t.sources[t.joints.inputs.JOINT], u = t.sources[t.joints.inputs.INV_BIND_MATRIX], d = r[i.inputs.WEIGHT.id].array, f = 0, p, m, h;
+		for (p = 0, h = a.length; p < h; p++) {
+			let e = a[p], t = [];
+			for (m = 0; m < e; m++) {
+				let e = o[f + s], n = d[o[f + c]];
+				t.push({
+					index: e,
+					weight: n
+				}), f += 2;
+			}
+			for (t.sort(g), m = 0; m < 4; m++) {
+				let e = t[m];
+				e === void 0 ? (n.indices.array.push(0), n.weights.array.push(0)) : (n.indices.array.push(e.index), n.weights.array.push(e.weight));
+			}
+		}
+		for (t.bindShapeMatrix ? n.bindMatrix = new e().fromArray(t.bindShapeMatrix).transpose() : n.bindMatrix = new e().identity(), p = 0, h = l.array.length; p < h; p++) {
+			let t = l.array[p], r = new e().fromArray(u.array, p * u.stride).transpose();
+			n.joints.push({
+				name: t,
+				boneInverse: r
+			});
+		}
+		return n;
+		function g(e, t) {
+			return t.weight - e.weight;
+		}
+	}
+	getController(e) {
+		return this.getBuild(this.library.controllers[e], this.buildController.bind(this));
+	}
+	buildImage(e) {
+		return e.build === void 0 ? e.init_from : e.build;
+	}
+	getImage(e) {
+		let t = this.library.images[e];
+		return t === void 0 ? (console.warn("THREE.ColladaLoader: Couldn't find image with ID:", e), null) : this.getBuild(t, this.buildImage.bind(this));
+	}
+	buildEffect(e) {
+		return e;
+	}
+	getEffect(e) {
+		return this.getBuild(this.library.effects[e], this.buildEffect.bind(this));
+	}
+	getTextureLoader(e) {
+		let t, n = e.slice((e.lastIndexOf(".") - 1 >>> 0) + 2);
+		switch (n = n.toLowerCase(), n) {
+			case "tga":
+				t = this.tgaLoader;
+				break;
+			default: t = this.textureLoader;
+		}
+		return t;
+	}
+	buildMaterial(e) {
+		let t = this.getEffect(e.url), n = t.profile.technique, i;
+		switch (n.type) {
+			case "phong":
+			case "blinn":
+				i = new P();
+				break;
+			case "lambert":
+				i = new O();
+				break;
+			default:
+				i = new F();
+				break;
+		}
+		i.name = e.name || "";
+		let a = this;
+		function o(e, n = null) {
+			let i = t.profile.samplers[e.id], o = null;
+			if (i !== void 0) {
+				let e = t.profile.surfaces[i.source];
+				o = a.getImage(e.init_from);
+			} else console.warn("THREE.ColladaLoader: Undefined sampler. Access image directly (see #12530)."), o = a.getImage(e.id);
+			if (o !== null) {
+				let t = a.getTextureLoader(o);
+				if (t !== void 0) {
+					let i = t.load(o), s = e.extra;
+					if (s !== void 0 && s.technique !== void 0 && a.isEmpty(s.technique) === !1) {
+						let e = s.technique;
+						i.wrapS = e.wrapU ? r : C, i.wrapT = e.wrapV ? r : C, i.offset.set(e.offsetU || 0, e.offsetV || 0), i.repeat.set(e.repeatU || 1, e.repeatV || 1);
+					} else i.wrapS = r, i.wrapT = r;
+					return n !== null && (i.colorSpace = n), i;
+				} else return console.warn("THREE.ColladaLoader: Loader for texture %s not found.", o), null;
+			} else return console.warn("THREE.ColladaLoader: Couldn't create texture with ID:", e.id), null;
+		}
+		let s = n.parameters;
+		for (let e in s) {
+			let t = s[e];
+			switch (e) {
+				case "diffuse":
+					t.color && i.color.fromArray(t.color), t.texture && (i.map = o(t.texture, R));
+					break;
+				case "specular":
+					t.color && i.specular && i.specular.fromArray(t.color), t.texture && (i.specularMap = o(t.texture));
+					break;
+				case "bump":
+					t.texture && (i.normalMap = o(t.texture));
+					break;
+				case "ambient":
+					t.texture && (i.lightMap = o(t.texture, R));
+					break;
+				case "shininess":
+					t.float && i.shininess && (i.shininess = t.float);
+					break;
+				case "emission":
+					t.color && i.emissive && i.emissive.fromArray(t.color), t.texture && (i.emissiveMap = o(t.texture, R));
+					break;
+			}
+		}
+		E.colorSpaceToWorking(i.color, R), i.specular && E.colorSpaceToWorking(i.specular, R), i.emissive && E.colorSpaceToWorking(i.emissive, R);
+		let c = s.transparent, l = s.transparency;
+		if (l === void 0 && c && (l = { float: 1 }), c === void 0 && l && (c = {
+			opaque: "A_ONE",
+			data: { color: [
+				1,
+				1,
+				1,
+				1
+			] }
+		}), c && l) if (c.data.texture) i.transparent = !0;
+		else {
+			let e = c.data.color;
+			switch (c.opaque) {
+				case "A_ONE":
+					i.opacity = e[3] * l.float;
+					break;
+				case "RGB_ZERO":
+					i.opacity = 1 - e[0] * l.float;
+					break;
+				case "A_ZERO":
+					i.opacity = 1 - e[3] * l.float;
+					break;
+				case "RGB_ONE":
+					i.opacity = e[0] * l.float;
+					break;
+				default: console.warn("THREE.ColladaLoader: Invalid opaque type \"%s\" of transparent tag.", c.opaque);
+			}
+			i.opacity < 1 && (i.transparent = !0);
+		}
+		if (n.extra !== void 0 && n.extra.technique !== void 0) {
+			let e = n.extra.technique;
+			for (let t in e) {
+				let n = e[t];
+				switch (t) {
+					case "double_sided":
+						i.side = n === 1 ? 2 : 0;
+						break;
+					case "bump":
+						i.normalMap = o(n.texture), i.normalScale = new H(1, 1);
+						break;
+				}
+			}
+		}
+		return i;
+	}
+	getMaterial(e) {
+		return this.getBuild(this.library.materials[e], this.buildMaterial.bind(this));
+	}
+	buildCamera(e) {
+		let t;
+		switch (e.optics.technique) {
+			case "perspective":
+				t = new j(e.optics.parameters.yfov, e.optics.parameters.aspect_ratio, e.optics.parameters.znear, e.optics.parameters.zfar);
+				break;
+			case "orthographic":
+				let n = e.optics.parameters.ymag, r = e.optics.parameters.xmag, i = e.optics.parameters.aspect_ratio;
+				r = r === void 0 ? n * i : r, n = n === void 0 ? r / i : n, r *= .5, n *= .5, t = new w(-r, r, n, -n, e.optics.parameters.znear, e.optics.parameters.zfar);
+				break;
+			default:
+				t = new j();
+				break;
+		}
+		return t.name = e.name || "", t;
+	}
+	getCamera(e) {
+		let t = this.library.cameras[e];
+		return t === void 0 ? (console.warn("THREE.ColladaLoader: Couldn't find camera with ID:", e), null) : this.getBuild(t, this.buildCamera.bind(this));
+	}
+	buildLight(e) {
+		let t;
+		switch (e.technique) {
+			case "directional":
+				t = new z();
+				break;
+			case "point":
+				t = new T();
+				break;
+			case "spot":
+				t = new p();
+				break;
+			case "ambient":
+				t = new D();
+				break;
+		}
+		return e.parameters.color && t.color.copy(e.parameters.color), e.parameters.distance && (t.distance = e.parameters.distance), e.parameters.falloffAngle && (t.angle = y.degToRad(e.parameters.falloffAngle)), t;
+	}
+	getLight(e) {
+		let t = this.library.lights[e];
+		return t === void 0 ? (console.warn("THREE.ColladaLoader: Couldn't find light with ID:", e), null) : this.getBuild(t, this.buildLight.bind(this));
+	}
+	groupPrimitives(e) {
+		let t = {};
+		for (let n = 0; n < e.length; n++) {
+			let r = e[n];
+			t[r.type] === void 0 && (t[r.type] = []), t[r.type].push(r);
+		}
+		return t;
+	}
+	checkUVCoordinates(e) {
+		let t = 0;
+		for (let n = 0, r = e.length; n < r; n++) e[n].hasUV === !0 && t++;
+		t > 0 && t < e.length && (e.uvsNeedsFix = !0);
+	}
+	buildGeometry(e) {
+		let t = {}, n = e.sources, r = e.vertices, i = e.primitives;
+		if (i.length === 0) return {};
+		let a = this.groupPrimitives(i);
+		for (let e in a) {
+			let i = a[e];
+			this.checkUVCoordinates(i), t[e] = this.buildGeometryType(i, n, r);
+		}
+		return t;
+	}
+	buildGeometryType(e, t, n) {
+		let r = {}, i = {
+			array: [],
+			stride: 0
+		}, a = {
+			array: [],
+			stride: 0
+		}, o = {
+			array: [],
+			stride: 0
+		}, s = {
+			array: [],
+			stride: 0
+		}, c = {
+			array: [],
+			stride: 0
+		}, l = {
+			array: [],
+			stride: 4
+		}, u = {
+			array: [],
+			stride: 4
+		}, d = new I(), f = [], p = 0;
+		for (let r = 0; r < e.length; r++) {
+			let m = e[r], h = m.inputs, g = 0;
+			switch (m.type) {
+				case "lines":
+				case "linestrips":
+					g = m.count * 2;
+					break;
+				case "triangles":
+					g = m.count * 3;
+					break;
+				case "polygons":
+				case "polylist":
+					for (let e = 0; e < m.count; e++) {
+						let t = m.vcount[e];
+						switch (t) {
+							case 3:
+								g += 3;
+								break;
+							case 4:
+								g += 6;
+								break;
+							default:
+								g += (t - 2) * 3;
+								break;
+						}
+					}
+					break;
+				default: console.warn("THREE.ColladaLoader: Unknown primitive type:", m.type);
+			}
+			d.addGroup(p, g, r), p += g, m.material && f.push(m.material);
+			for (let r in h) {
+				let d = h[r];
+				switch (r) {
+					case "VERTEX":
+						for (let r in n) {
+							let f = n[r];
+							switch (r) {
+								case "POSITION":
+									let n = i.array.length;
+									if (this.buildGeometryData(m, t[f], d.offset, i.array), i.stride = t[f].stride, t.skinWeights && t.skinIndices && (this.buildGeometryData(m, t.skinIndices, d.offset, l.array), this.buildGeometryData(m, t.skinWeights, d.offset, u.array)), m.hasUV === !1 && e.uvsNeedsFix === !0) {
+										let e = (i.array.length - n) / i.stride;
+										for (let t = 0; t < e; t++) o.array.push(0, 0);
+									}
+									break;
+								case "NORMAL":
+									this.buildGeometryData(m, t[f], d.offset, a.array), a.stride = t[f].stride;
+									break;
+								case "COLOR":
+									this.buildGeometryData(m, t[f], d.offset, c.array), c.stride = t[f].stride;
+									break;
+								case "TEXCOORD":
+									this.buildGeometryData(m, t[f], d.offset, o.array), o.stride = t[f].stride;
+									break;
+								case "TEXCOORD1":
+									this.buildGeometryData(m, t[f], d.offset, s.array), o.stride = t[f].stride;
+									break;
+								default: console.warn("THREE.ColladaLoader: Semantic \"%s\" not handled in geometry build process.", r);
+							}
+						}
+						break;
+					case "NORMAL":
+						this.buildGeometryData(m, t[d.id], d.offset, a.array), a.stride = t[d.id].stride;
+						break;
+					case "COLOR":
+						this.buildGeometryData(m, t[d.id], d.offset, c.array, !0), c.stride = t[d.id].stride;
+						break;
+					case "TEXCOORD":
+						this.buildGeometryData(m, t[d.id], d.offset, o.array), o.stride = t[d.id].stride;
+						break;
+					case "TEXCOORD1":
+						this.buildGeometryData(m, t[d.id], d.offset, s.array), s.stride = t[d.id].stride;
+						break;
+				}
+			}
+		}
+		return i.array.length > 0 && d.setAttribute("position", new L(i.array, i.stride)), a.array.length > 0 && d.setAttribute("normal", new L(a.array, a.stride)), c.array.length > 0 && d.setAttribute("color", new L(c.array, c.stride)), o.array.length > 0 && d.setAttribute("uv", new L(o.array, o.stride)), s.array.length > 0 && d.setAttribute("uv1", new L(s.array, s.stride)), l.array.length > 0 && d.setAttribute("skinIndex", new L(l.array, l.stride)), u.array.length > 0 && d.setAttribute("skinWeight", new L(u.array, u.stride)), r.data = d, r.type = e[0].type, r.materialKeys = f, r;
+	}
+	buildGeometryData(e, n, r, i, a = !1) {
+		let s = e.p, c = e.stride, l = e.vcount, u = this.tempColor;
+		function d(e) {
+			let t = s[e + r] * m, n = t + m;
+			for (; t < n; t++) i.push(p[t]);
+			if (a) {
+				let e = i.length - m - 1;
+				u.setRGB(i[e + 0], i[e + 1], i[e + 2], R), i[e + 0] = u.r, i[e + 1] = u.g, i[e + 2] = u.b;
+			}
+		}
+		let p = n.array, m = n.stride;
+		if (e.vcount !== void 0) {
+			let e = 0;
+			for (let n = 0, r = l.length; n < r; n++) {
+				let r = l[n];
+				if (r === 4) {
+					let t = e + c * 0, n = e + c * 1, r = e + c * 2, i = e + c * 3;
+					d(t), d(n), d(i), d(n), d(r), d(i);
+				} else if (r === 3) {
+					let t = e + c * 0, n = e + c * 1, r = e + c * 2;
+					d(t), d(n), d(r);
+				} else if (r > 4) {
+					let n = [];
+					for (let i = 0; i < r; i++) {
+						let r = s[e + c * i] * m, a = p[r], o = p[r + 1], l = p[r + 2];
+						n.push(new t(a, o, l));
+					}
+					let i = new t(), a = new f();
+					a.a = n[0], a.b = n[1], a.c = n[2], a.getNormal(i);
+					let l = [];
+					if (Math.abs(i.x) > Math.abs(i.y) && Math.abs(i.x) > Math.abs(i.z)) for (let e = 0; e < r; e++) l.push(new H(n[e].y, n[e].z));
+					else if (Math.abs(i.y) > Math.abs(i.z)) for (let e = 0; e < r; e++) l.push(new H(n[e].x, n[e].z));
+					else for (let e = 0; e < r; e++) l.push(new H(n[e].x, n[e].y));
+					let u = o.isClockWise(l);
+					u === !0 && l.reverse();
+					let h = o.triangulateShape(l, []);
+					for (let t = 0; t < h.length; t++) {
+						let n = h[t], i, a, o;
+						u === !1 ? (i = n[0], a = n[1], o = n[2]) : (i = r - 1 - n[0], a = r - 1 - n[2], o = r - 1 - n[1]);
+						let s = e + c * i, l = e + c * a, f = e + c * o;
+						d(s), d(l), d(f);
+					}
+				}
+				e += c * r;
+			}
+		} else for (let e = 0, t = s.length; e < t; e += c) d(e);
+	}
+	getGeometry(e) {
+		return this.getBuild(this.library.geometries[e], this.buildGeometry.bind(this));
+	}
+	buildKinematicsModel(e) {
+		return e.build === void 0 ? e : e.build;
+	}
+	getKinematicsModel(e) {
+		return this.getBuild(this.library.kinematicsModels[e], this.buildKinematicsModel.bind(this));
+	}
+	buildKinematicsScene(e) {
+		return e.build === void 0 ? e : e.build;
+	}
+	getKinematicsScene(e) {
+		return this.getBuild(this.library.kinematicsScenes[e], this.buildKinematicsScene.bind(this));
+	}
+	setupKinematics() {
+		let t = Object.keys(this.library.kinematicsModels)[0], n = Object.keys(this.library.kinematicsScenes)[0], r = Object.keys(this.library.visualScenes)[0];
+		if (t === void 0 || n === void 0) return;
+		let i = this.getKinematicsModel(t), a = this.getKinematicsScene(n), o = this.getVisualScene(r), s = a.bindJointAxis, c = {}, l = this.collada, u = this;
+		for (let e = 0, t = s.length; e < t; e++) {
+			let t = s[e], n = l.querySelector("[sid=\"" + t.target + "\"]");
+			if (n) {
+				let e = n.parentElement;
+				d(t.jointIndex, e);
+			}
+		}
+		function d(e, t) {
+			let n = t.getAttribute("name"), r = i.joints[e], a = u.buildTransformList(t);
+			o.traverse(function(t) {
+				t.name === n && (c[e] = {
+					object: t,
+					transforms: a,
+					joint: r,
+					position: r.zeroPosition
+				});
+			});
+		}
+		let f = new e(), p = this.matrix;
+		this.kinematics = {
+			joints: i && i.joints,
+			getJointValue: function(e) {
+				let t = c[e];
+				if (t) return t.position;
+				console.warn("THREE.ColladaLoader: Joint " + e + " doesn't exist.");
+			},
+			setJointValue: function(e, t) {
+				let n = c[e];
+				if (n) {
+					let r = n.joint;
+					if (t > r.limits.max || t < r.limits.min) console.warn("THREE.ColladaLoader: Joint " + e + " value " + t + " outside of limits (min: " + r.limits.min + ", max: " + r.limits.max + ").");
+					else if (r.static) console.warn("THREE.ColladaLoader: Joint " + e + " is static.");
+					else {
+						let i = n.object, a = r.axis, o = n.transforms;
+						p.identity();
+						for (let n = 0; n < o.length; n++) {
+							let i = o[n];
+							if (i.sid && i.sid.indexOf(e) !== -1) switch (r.type) {
+								case "revolute":
+									p.multiply(f.makeRotationAxis(a, y.degToRad(t)));
+									break;
+								case "prismatic":
+									p.multiply(f.makeTranslation(a.x * t, a.y * t, a.z * t));
+									break;
+								default:
+									console.warn("THREE.ColladaLoader: Unknown joint type: " + r.type);
+									break;
+							}
+							else switch (i.type) {
+								case "matrix":
+									p.multiply(i.obj);
+									break;
+								case "translate":
+									p.multiply(f.makeTranslation(i.obj.x, i.obj.y, i.obj.z));
+									break;
+								case "scale":
+									p.scale(i.obj);
+									break;
+								case "rotate":
+									p.multiply(f.makeRotationAxis(i.obj, i.angle));
+									break;
+							}
+						}
+						i.matrix.copy(p), i.matrix.decompose(i.position, i.quaternion, i.scale), c[e].position = t;
+					}
+				} else console.warn("THREE.ColladaLoader: Joint " + e + " does not exist.");
+			}
+		};
+	}
+	buildTransformList(n) {
+		let r = [], i = this.collada.querySelector("[id=\"" + n.id + "\"]");
+		for (let n = 0; n < i.childNodes.length; n++) {
+			let a = i.childNodes[n];
+			if (a.nodeType !== 1) continue;
+			let o, s;
+			switch (a.nodeName) {
+				case "matrix":
+					o = K(a.textContent);
+					let n = new e().fromArray(o).transpose();
+					r.push({
+						sid: a.getAttribute("sid"),
+						type: a.nodeName,
+						obj: n
+					});
+					break;
+				case "translate":
+				case "scale":
+					o = K(a.textContent), s = new t().fromArray(o), r.push({
+						sid: a.getAttribute("sid"),
+						type: a.nodeName,
+						obj: s
+					});
+					break;
+				case "rotate":
+					o = K(a.textContent), s = new t().fromArray(o);
+					let i = y.degToRad(o[3]);
+					r.push({
+						sid: a.getAttribute("sid"),
+						type: a.nodeName,
+						obj: s,
+						angle: i
+					});
+					break;
+			}
+		}
+		return r;
+	}
+	buildSkeleton(e, t) {
+		let n = [], r = [], a, o, s;
+		for (a = 0; a < e.length; a++) {
+			let r = e[a], i;
+			if (this.hasNode(r)) i = this.getNode(r), this.buildBoneHierarchy(i, t, n);
+			else if (this.hasVisualScene(r)) {
+				let e = this.library.visualScenes[r].children;
+				for (let r = 0; r < e.length; r++) {
+					let i = e[r];
+					if (i.type === "JOINT") {
+						let e = this.getNode(i.id);
+						this.buildBoneHierarchy(e, t, n);
+					}
+				}
+			} else console.error("THREE.ColladaLoader: Unable to find root bone of skeleton with ID:", r);
+		}
+		for (a = 0; a < t.length; a++) for (o = 0; o < n.length; o++) if (s = n[o], s.bone.name === t[a].name) {
+			r[a] = s, s.processed = !0;
+			break;
+		}
+		for (a = 0; a < n.length; a++) s = n[a], s.processed === !1 && (r.push(s), s.processed = !0);
+		let c = [], l = [];
+		for (a = 0; a < r.length; a++) s = r[a], c.push(s.bone), l.push(s.boneInverse);
+		return new i(c, l);
+	}
+	buildBoneHierarchy(t, n, r) {
+		t.traverse(function(t) {
+			if (t.isBone === !0) {
+				let i;
+				for (let e = 0; e < n.length; e++) {
+					let r = n[e];
+					if (r.name === t.name) {
+						i = r.boneInverse;
+						break;
+					}
+				}
+				i === void 0 && (i = new e()), r.push({
+					bone: t,
+					boneInverse: i,
+					processed: !1
+				});
+			}
+		});
+	}
+	buildNode(e) {
+		let t = [], n = e.matrix, r = e.nodes, i = e.type, o = e.instanceCameras, s = e.instanceControllers, c = e.instanceLights, l = e.instanceGeometries, u = e.instanceNodes;
+		for (let e = 0, n = r.length; e < n; e++) t.push(this.getNode(r[e]));
+		for (let e = 0, n = o.length; e < n; e++) {
+			let n = this.getCamera(o[e]);
+			n !== null && t.push(n.clone());
+		}
+		for (let e = 0, n = s.length; e < n; e++) {
+			let n = s[e], r = this.getController(n.id), i = this.getGeometry(r.id), a = this.buildObjects(i, n.materials), o = n.skeletons, c = r.skin.joints, l = this.buildSkeleton(o, c);
+			for (let e = 0, n = a.length; e < n; e++) {
+				let n = a[e];
+				n.isSkinnedMesh && (n.bind(l, r.skin.bindMatrix), n.normalizeSkinWeights()), t.push(n);
+			}
+		}
+		for (let e = 0, n = c.length; e < n; e++) {
+			let n = this.getLight(c[e]);
+			n !== null && t.push(n.clone());
+		}
+		for (let e = 0, n = l.length; e < n; e++) {
+			let n = l[e], r = this.getGeometry(n.id), i = this.buildObjects(r, n.materials);
+			for (let e = 0, n = i.length; e < n; e++) t.push(i[e]);
+		}
+		for (let e = 0, n = u.length; e < n; e++) t.push(this.getNode(u[e]).clone());
+		let d;
+		if (r.length === 0 && t.length === 1) d = t[0];
+		else {
+			d = i === "JOINT" ? new k() : new a();
+			for (let e = 0; e < t.length; e++) d.add(t[e]);
+		}
+		return d.name = i === "JOINT" ? e.sid : e.name, i !== "JOINT" && this.hasPivotTransforms(e) ? this.wrapWithTransformHierarchy(d, e) : (d.matrix.copy(n), d.matrix.decompose(d.position, d.quaternion, d.scale), d);
+	}
+	wrapWithTransformHierarchy(n, r) {
+		let i = r.id;
+		this.transformNodes[i] = {};
+		let o = r.transformOrder, s = r.transformData, c = new a();
+		c.name = r.name;
+		let l = c;
+		for (let n = 0; n < o.length; n++) {
+			let c = o[n], u = s[c], d = new a();
+			switch (d.name = r.name + "_" + c, u.type) {
+				case "translate":
+					d.position.set(u.x, u.y, u.z);
+					break;
+				case "rotate": {
+					let e = new t(u.axis[0], u.axis[1], u.axis[2]), n = y.degToRad(u.angle);
+					d.quaternion.setFromAxisAngle(e, n), d.userData.rotationAxis = e;
+					break;
+				}
+				case "scale":
+					d.scale.set(u.x, u.y, u.z);
+					break;
+				case "matrix":
+					new e().fromArray(u.array).transpose().decompose(d.position, d.quaternion, d.scale);
+					break;
+			}
+			this.transformNodes[i][c] = d, l.add(d), l = d;
+		}
+		return l.add(n), c;
+	}
+	resolveMaterialBinding(e, t) {
+		let n = [];
+		for (let r = 0, i = e.length; r < i; r++) {
+			let i = t[e[r]];
+			i === void 0 ? (console.warn("THREE.ColladaLoader: Material with key %s not found. Apply fallback material.", e[r]), n.push(this.fallbackMaterial)) : n.push(this.getMaterial(i));
+		}
+		return n;
+	}
+	get fallbackMaterial() {
+		return this._fallbackMaterial === void 0 && (this._fallbackMaterial = new F({
+			name: d.DEFAULT_MATERIAL_NAME,
+			color: 16711935
+		})), this._fallbackMaterial;
+	}
+	buildObjects(e, t) {
+		let n = [];
+		for (let r in e) {
+			let i = e[r], a = this.resolveMaterialBinding(i.materialKeys, t);
+			if (a.length === 0 && (r === "lines" || r === "linestrips" ? a.push(new V()) : a.push(new P())), r === "lines" || r === "linestrips") for (let e = 0, t = a.length; e < t; e++) {
+				let t = a[e];
+				if (t.isMeshPhongMaterial === !0 || t.isMeshLambertMaterial === !0) {
+					let n = new V();
+					n.color.copy(t.color), n.opacity = t.opacity, n.transparent = t.transparent, a[e] = n;
+				}
+			}
+			let o = i.data.attributes.skinIndex !== void 0, s = a.length === 1 ? a[0] : a, c;
+			switch (r) {
+				case "lines":
+					c = new v(i.data, s);
+					break;
+				case "linestrips":
+					c = new h(i.data, s);
+					break;
+				case "triangles":
+				case "polygons":
+				case "polylist":
+					c = o ? new m(i.data, s) : new S(i.data, s);
+					break;
+			}
+			n.push(c);
+		}
+		return n;
+	}
+	hasNode(e) {
+		return this.library.nodes[e] !== void 0;
+	}
+	getNode(e) {
+		return this.getBuild(this.library.nodes[e], this.buildNode.bind(this));
+	}
+	buildVisualScene(e) {
+		let t = new a();
+		t.name = e.name;
+		let n = e.children;
+		for (let e = 0; e < n.length; e++) {
+			let r = n[e];
+			t.add(this.getNode(r.id));
+		}
+		return t;
+	}
+	hasVisualScene(e) {
+		return this.library.visualScenes[e] !== void 0;
+	}
+	getVisualScene(e) {
+		return this.getBuild(this.library.visualScenes[e], this.buildVisualScene.bind(this));
+	}
+	parseScene(e) {
+		let t = W(e, "instance_visual_scene")[0];
+		return this.getVisualScene(this.parseId(t.getAttribute("url")));
+	}
+	parseId(e) {
+		return e.substring(1);
+	}
+	setupAnimations() {
+		let e = this.library.clips;
+		if (this.isEmpty(e) === !0) {
+			if (this.isEmpty(this.library.animations) === !1) {
+				let e = [];
+				for (let t in this.library.animations) {
+					let n = this.getAnimation(t);
+					for (let t = 0, r = n.length; t < r; t++) e.push(n[t]);
+				}
+				this.buildDeferredPivotAnimationTracks(e), this.animations.push(new N("default", -1, e));
+			}
+		} else for (let t in e) this.animations.push(this.getAnimationClip(t));
+	}
+	buildDeferredPivotAnimationTracks(e) {
+		for (let t in this.deferredPivotAnimations) {
+			let n = this.library.nodes[t];
+			if (!n) continue;
+			let r = this.deferredPivotAnimations[t];
+			this.buildTransformHierarchyTracks(t, r, n, e);
+		}
+	}
+	buildTransformHierarchyTracks(e, t, n, r) {
+		let i = this.transformNodes[e];
+		if (!i) {
+			console.warn("THREE.ColladaLoader: Transform hierarchy not found for node:", e);
+			return;
+		}
+		for (let e in t) {
+			let a = i[e];
+			if (!a) continue;
+			let o = n.transforms[e], s = n.transformData[e], c = t[e];
+			switch (o) {
+				case "translate":
+					this.buildHierarchyTranslateTrack(a, c, s, r);
+					break;
+				case "rotate":
+					this.buildHierarchyRotateTrack(a, c, s, r);
+					break;
+				case "scale":
+					this.buildHierarchyScaleTrack(a, c, s, r);
+					break;
+			}
+		}
+	}
+	buildHierarchyTranslateTrack(e, t, n, r) {
+		if (t.default && t.default.stride === 3) {
+			let n = t.default, i = new l(e.uuid + ".position", Array.from(n.times), Array.from(n.values)), a = this.getInterpolationInfo(t);
+			this.applyInterpolation(i, a, t), r.push(i);
+			return;
+		}
+		let i = this.getTimesForAllAxes(t);
+		if (i.length === 0) return;
+		let a = [], o = this.getInterpolationInfo(t);
+		for (let e = 0; e < i.length; e++) {
+			let r = i[e], o = this.getValueAtTime(t.X, r, n.x), s = this.getValueAtTime(t.Y, r, n.y), c = this.getValueAtTime(t.Z, r, n.z);
+			a.push(o, s, c);
+		}
+		let s = new l(e.uuid + ".position", i, a);
+		this.applyInterpolation(s, o), r.push(s);
+	}
+	buildHierarchyRotateTrack(e, n, r, i) {
+		let a = n.ANGLE || n.default;
+		if (!a) return;
+		let o = Array.from(a.times);
+		if (o.length === 0) return;
+		let s = e.userData.rotationAxis || new t(r.axis[0], r.axis[1], r.axis[2]), c = new B(), l = new B(), u = [], d = this.getInterpolationInfo(n);
+		for (let e = 0; e < o.length; e++) {
+			let t = o[e], n = this.getValueAtTime(a, t, r.angle), i = y.degToRad(n);
+			c.setFromAxisAngle(s, i), e > 0 && l.dot(c) < 0 && (c.x = -c.x, c.y = -c.y, c.z = -c.z, c.w = -c.w), l.copy(c), u.push(c.x, c.y, c.z, c.w);
+		}
+		let f = new x(e.uuid + ".quaternion", o, u);
+		this.applyInterpolation(f, d), i.push(f);
+	}
+	buildHierarchyScaleTrack(e, t, n, r) {
+		if (t.default && t.default.stride === 3) {
+			let n = t.default, i = new l(e.uuid + ".scale", Array.from(n.times), Array.from(n.values)), a = this.getInterpolationInfo(t);
+			this.applyInterpolation(i, a, t), r.push(i);
+			return;
+		}
+		let i = this.getTimesForAllAxes(t);
+		if (i.length === 0) return;
+		let a = [], o = this.getInterpolationInfo(t);
+		for (let e = 0; e < i.length; e++) {
+			let r = i[e], o = this.getValueAtTime(t.X, r, n.x), s = this.getValueAtTime(t.Y, r, n.y), c = this.getValueAtTime(t.Z, r, n.z);
+			a.push(o, s, c);
+		}
+		let s = new l(e.uuid + ".scale", i, a);
+		this.applyInterpolation(s, o), r.push(s);
+	}
+}, Z = class extends d {
+	load(e, t, r, i) {
+		let a = this, o = a.path === "" ? M.extractUrlBase(e) : a.path, s = new n(a.manager);
+		s.setPath(a.path), s.setRequestHeader(a.requestHeader), s.setWithCredentials(a.withCredentials), s.load(e, function(n) {
+			try {
+				t(a.parse(n, o));
+			} catch (t) {
+				i ? i(t) : console.error(t), a.manager.itemError(e);
+			}
+		}, r, i);
+	}
+	parse(e, t) {
+		if (e.length === 0) return { scene: new g() };
+		let n = new Y().parse(e);
+		if (n === null) return null;
+		let { library: r, asset: i, collada: a } = n, o = new c(this.manager);
+		o.setPath(this.resourcePath || t).setCrossOrigin(this.crossOrigin);
+		let s;
+		U && (s = new U(this.manager), s.setPath(this.resourcePath || t));
+		let { scene: l, animations: u, kinematics: d } = new X(r, a, o, s).compose();
+		return l.animations = u, i.upAxis === "Z_UP" && (console.warn("THREE.ColladaLoader: You are loading an asset with a Z-UP coordinate system. The loader just rotates the asset to transform it into Y-UP. The vertex data are not converted, see #24289."), l.rotation.set(-Math.PI / 2, 0, 0)), l.scale.multiplyScalar(i.unit), {
+			get animations() {
+				return console.warn("THREE.ColladaLoader: Please access animations over scene.animations now."), u;
+			},
+			kinematics: d,
+			library: r,
+			scene: l
+		};
+	}
+};
+//#endregion
+export { Z as ColladaLoader };