import { Ai as Object3D, Cn as GLBufferAttribute, Cs as Vector2, Gr as MathUtils, Jr as Matrix4, Nn as Group, So as SkinnedMesh, at as Color, bo as Skeleton, ki as NumberKeyframeTrack, oa as Quaternion, sa as QuaternionKeyframeTrack, un as Euler, ws as Vector3, y as AnimationClip } from "./three.module-C9LqGydR.js";
//#region node_modules/@pixiv/three-vrm-animation/lib/three-vrm-animation.module.js
/*!
* @pixiv/three-vrm-animation v3.4.1
* The implementation of VRM Animation
*
* Copyright (c) 2019-2025 pixiv Inc.
* @pixiv/three-vrm-animation is distributed under MIT License
* https://github.com/pixiv/three-vrm/blob/release/LICENSE
*/
var __async = (__this, __arguments, generator) => {
	return new Promise((resolve, reject) => {
		var fulfilled = (value) => {
			try {
				step(generator.next(value));
			} catch (e) {
				reject(e);
			}
		};
		var rejected = (value) => {
			try {
				step(generator.throw(value));
			} catch (e) {
				reject(e);
			}
		};
		var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
		step((generator = generator.apply(__this, __arguments)).next());
	});
};
var __async2 = (__this, __arguments, generator) => {
	return new Promise((resolve, reject) => {
		var fulfilled = (value) => {
			try {
				step(generator.next(value));
			} catch (e) {
				reject(e);
			}
		};
		var rejected = (value) => {
			try {
				step(generator.throw(value));
			} catch (e) {
				reject(e);
			}
		};
		var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
		step((generator = generator.apply(__this, __arguments)).next());
	});
};
var VRMExpression = class extends Object3D {
	constructor(expressionName) {
		super();
		this.weight = 0;
		this.isBinary = false;
		this.overrideBlink = "none";
		this.overrideLookAt = "none";
		this.overrideMouth = "none";
		this._binds = [];
		this.name = `VRMExpression_${expressionName}`;
		this.expressionName = expressionName;
		this.type = "VRMExpression";
		this.visible = false;
	}
	/**
	* Binds that this expression influences.
	*/
	get binds() {
		return this._binds;
	}
	/**
	* A value represents how much it should override blink expressions.
	* `0.0` == no override at all, `1.0` == completely block the expressions.
	*/
	get overrideBlinkAmount() {
		if (this.overrideBlink === "block") return 0 < this.outputWeight ? 1 : 0;
		else if (this.overrideBlink === "blend") return this.outputWeight;
		else return 0;
	}
	/**
	* A value represents how much it should override lookAt expressions.
	* `0.0` == no override at all, `1.0` == completely block the expressions.
	*/
	get overrideLookAtAmount() {
		if (this.overrideLookAt === "block") return 0 < this.outputWeight ? 1 : 0;
		else if (this.overrideLookAt === "blend") return this.outputWeight;
		else return 0;
	}
	/**
	* A value represents how much it should override mouth expressions.
	* `0.0` == no override at all, `1.0` == completely block the expressions.
	*/
	get overrideMouthAmount() {
		if (this.overrideMouth === "block") return 0 < this.outputWeight ? 1 : 0;
		else if (this.overrideMouth === "blend") return this.outputWeight;
		else return 0;
	}
	/**
	* An output weight of this expression, considering the {@link isBinary}.
	*/
	get outputWeight() {
		if (this.isBinary) return this.weight > .5 ? 1 : 0;
		return this.weight;
	}
	/**
	* Add an expression bind to the expression.
	*
	* @param bind A bind to add
	*/
	addBind(bind) {
		this._binds.push(bind);
	}
	/**
	* Delete an expression bind from the expression.
	*
	* @param bind A bind to delete
	*/
	deleteBind(bind) {
		const index = this._binds.indexOf(bind);
		if (index >= 0) this._binds.splice(index, 1);
	}
	/**
	* Apply weight to every assigned blend shapes.
	* Should be called every frame.
	*/
	applyWeight(options) {
		var _a;
		let actualWeight = this.outputWeight;
		actualWeight *= (_a = options == null ? void 0 : options.multiplier) != null ? _a : 1;
		if (this.isBinary && actualWeight < 1) actualWeight = 0;
		this._binds.forEach((bind) => bind.applyWeight(actualWeight));
	}
	/**
	* Clear previously assigned blend shapes.
	*/
	clearAppliedWeight() {
		this._binds.forEach((bind) => bind.clearAppliedWeight());
	}
};
function extractPrimitivesInternal(gltf, nodeIndex, node) {
	var _a, _b;
	const json = gltf.parser.json;
	const schemaNode = (_a = json.nodes) == null ? void 0 : _a[nodeIndex];
	if (schemaNode == null) {
		console.warn(`extractPrimitivesInternal: Attempt to use nodes[${nodeIndex}] of glTF but the node doesn't exist`);
		return null;
	}
	const meshIndex = schemaNode.mesh;
	if (meshIndex == null) return null;
	const schemaMesh = (_b = json.meshes) == null ? void 0 : _b[meshIndex];
	if (schemaMesh == null) {
		console.warn(`extractPrimitivesInternal: Attempt to use meshes[${meshIndex}] of glTF but the mesh doesn't exist`);
		return null;
	}
	const primitiveCount = schemaMesh.primitives.length;
	const primitives = [];
	node.traverse((object) => {
		if (primitives.length < primitiveCount) {
			if (object.isMesh) primitives.push(object);
		}
	});
	return primitives;
}
function gltfExtractPrimitivesFromNode(gltf, nodeIndex) {
	return __async2(this, null, function* () {
		return extractPrimitivesInternal(gltf, nodeIndex, yield gltf.parser.getDependency("node", nodeIndex));
	});
}
var VRMExpressionPresetName = {
	Aa: "aa",
	Ih: "ih",
	Ou: "ou",
	Ee: "ee",
	Oh: "oh",
	Blink: "blink",
	Happy: "happy",
	Angry: "angry",
	Sad: "sad",
	Relaxed: "relaxed",
	LookUp: "lookUp",
	Surprised: "surprised",
	LookDown: "lookDown",
	LookLeft: "lookLeft",
	LookRight: "lookRight",
	BlinkLeft: "blinkLeft",
	BlinkRight: "blinkRight",
	Neutral: "neutral"
};
function saturate(value) {
	return Math.max(Math.min(value, 1), 0);
}
var VRMExpressionManager = class _VRMExpressionManager {
	/**
	* Create a new {@link VRMExpressionManager}.
	*/
	constructor() {
		this.blinkExpressionNames = [
			"blink",
			"blinkLeft",
			"blinkRight"
		];
		this.lookAtExpressionNames = [
			"lookLeft",
			"lookRight",
			"lookUp",
			"lookDown"
		];
		this.mouthExpressionNames = [
			"aa",
			"ee",
			"ih",
			"oh",
			"ou"
		];
		this._expressions = [];
		this._expressionMap = {};
	}
	get expressions() {
		return this._expressions.concat();
	}
	get expressionMap() {
		return Object.assign({}, this._expressionMap);
	}
	/**
	* A map from name to expression, but excluding custom expressions.
	*/
	get presetExpressionMap() {
		const result = {};
		const presetNameSet = new Set(Object.values(VRMExpressionPresetName));
		Object.entries(this._expressionMap).forEach(([name, expression]) => {
			if (presetNameSet.has(name)) result[name] = expression;
		});
		return result;
	}
	/**
	* A map from name to expression, but excluding preset expressions.
	*/
	get customExpressionMap() {
		const result = {};
		const presetNameSet = new Set(Object.values(VRMExpressionPresetName));
		Object.entries(this._expressionMap).forEach(([name, expression]) => {
			if (!presetNameSet.has(name)) result[name] = expression;
		});
		return result;
	}
	/**
	* Copy the given {@link VRMExpressionManager} into this one.
	* @param source The {@link VRMExpressionManager} you want to copy
	* @returns this
	*/
	copy(source) {
		this._expressions.concat().forEach((expression) => {
			this.unregisterExpression(expression);
		});
		source._expressions.forEach((expression) => {
			this.registerExpression(expression);
		});
		this.blinkExpressionNames = source.blinkExpressionNames.concat();
		this.lookAtExpressionNames = source.lookAtExpressionNames.concat();
		this.mouthExpressionNames = source.mouthExpressionNames.concat();
		return this;
	}
	/**
	* Returns a clone of this {@link VRMExpressionManager}.
	* @returns Copied {@link VRMExpressionManager}
	*/
	clone() {
		return new _VRMExpressionManager().copy(this);
	}
	/**
	* Return a registered expression.
	* If it cannot find an expression, it will return `null` instead.
	*
	* @param name Name or preset name of the expression
	*/
	getExpression(name) {
		var _a;
		return (_a = this._expressionMap[name]) != null ? _a : null;
	}
	/**
	* Register an expression.
	*
	* @param expression {@link VRMExpression} that describes the expression
	*/
	registerExpression(expression) {
		this._expressions.push(expression);
		this._expressionMap[expression.expressionName] = expression;
	}
	/**
	* Unregister an expression.
	*
	* @param expression The expression you want to unregister
	*/
	unregisterExpression(expression) {
		const index = this._expressions.indexOf(expression);
		if (index === -1) console.warn("VRMExpressionManager: The specified expressions is not registered");
		this._expressions.splice(index, 1);
		delete this._expressionMap[expression.expressionName];
	}
	/**
	* Get the current weight of the specified expression.
	* If it doesn't have an expression of given name, it will return `null` instead.
	*
	* @param name Name of the expression
	*/
	getValue(name) {
		var _a;
		const expression = this.getExpression(name);
		return (_a = expression == null ? void 0 : expression.weight) != null ? _a : null;
	}
	/**
	* Set a weight to the specified expression.
	*
	* @param name Name of the expression
	* @param weight Weight
	*/
	setValue(name, weight) {
		const expression = this.getExpression(name);
		if (expression) expression.weight = saturate(weight);
	}
	/**
	* Reset weights of all expressions to `0.0`.
	*/
	resetValues() {
		this._expressions.forEach((expression) => {
			expression.weight = 0;
		});
	}
	/**
	* Get a track name of specified expression.
	* This track name is needed to manipulate its expression via keyframe animations.
	*
	* @example Manipulate an expression using keyframe animation
	* ```js
	* const trackName = vrm.expressionManager.getExpressionTrackName( 'blink' );
	* const track = new THREE.NumberKeyframeTrack(
	*   name,
	*   [ 0.0, 0.5, 1.0 ], // times
	*   [ 0.0, 1.0, 0.0 ] // values
	* );
	*
	* const clip = new THREE.AnimationClip(
	*   'blink', // name
	*   1.0, // duration
	*   [ track ] // tracks
	* );
	*
	* const mixer = new THREE.AnimationMixer( vrm.scene );
	* const action = mixer.clipAction( clip );
	* action.play();
	* ```
	*
	* @param name Name of the expression
	*/
	getExpressionTrackName(name) {
		const expression = this.getExpression(name);
		return expression ? `${expression.name}.weight` : null;
	}
	/**
	* Update every expressions.
	*/
	update() {
		const weightMultipliers = this._calculateWeightMultipliers();
		this._expressions.forEach((expression) => {
			expression.clearAppliedWeight();
		});
		this._expressions.forEach((expression) => {
			let multiplier = 1;
			const name = expression.expressionName;
			if (this.blinkExpressionNames.indexOf(name) !== -1) multiplier *= weightMultipliers.blink;
			if (this.lookAtExpressionNames.indexOf(name) !== -1) multiplier *= weightMultipliers.lookAt;
			if (this.mouthExpressionNames.indexOf(name) !== -1) multiplier *= weightMultipliers.mouth;
			expression.applyWeight({ multiplier });
		});
	}
	/**
	* Calculate sum of override amounts to see how much we should multiply weights of certain expressions.
	*/
	_calculateWeightMultipliers() {
		let blink = 1;
		let lookAt = 1;
		let mouth = 1;
		this._expressions.forEach((expression) => {
			blink -= expression.overrideBlinkAmount;
			lookAt -= expression.overrideLookAtAmount;
			mouth -= expression.overrideMouthAmount;
		});
		blink = Math.max(0, blink);
		lookAt = Math.max(0, lookAt);
		mouth = Math.max(0, mouth);
		return {
			blink,
			lookAt,
			mouth
		};
	}
};
var VRMExpressionMaterialColorType = {
	Color: "color",
	EmissionColor: "emissionColor",
	ShadeColor: "shadeColor",
	MatcapColor: "matcapColor",
	RimColor: "rimColor",
	OutlineColor: "outlineColor"
};
var v0ExpressionMaterialColorMap = {
	_Color: VRMExpressionMaterialColorType.Color,
	_EmissionColor: VRMExpressionMaterialColorType.EmissionColor,
	_ShadeColor: VRMExpressionMaterialColorType.ShadeColor,
	_RimColor: VRMExpressionMaterialColorType.RimColor,
	_OutlineColor: VRMExpressionMaterialColorType.OutlineColor
};
var _color = new Color();
var _VRMExpressionMaterialColorBind = class _VRMExpressionMaterialColorBind2 {
	constructor({ material, type, targetValue, targetAlpha }) {
		this.material = material;
		this.type = type;
		this.targetValue = targetValue;
		this.targetAlpha = targetAlpha != null ? targetAlpha : 1;
		const color = this._initColorBindState();
		const alpha = this._initAlphaBindState();
		this._state = {
			color,
			alpha
		};
	}
	applyWeight(weight) {
		const { color, alpha } = this._state;
		if (color != null) {
			const { propertyName, deltaValue } = color;
			const target = this.material[propertyName];
			if (target != void 0) target.add(_color.copy(deltaValue).multiplyScalar(weight));
		}
		if (alpha != null) {
			const { propertyName, deltaValue } = alpha;
			if (this.material[propertyName] != void 0) this.material[propertyName] += deltaValue * weight;
		}
	}
	clearAppliedWeight() {
		const { color, alpha } = this._state;
		if (color != null) {
			const { propertyName, initialValue } = color;
			const target = this.material[propertyName];
			if (target != void 0) target.copy(initialValue);
		}
		if (alpha != null) {
			const { propertyName, initialValue } = alpha;
			if (this.material[propertyName] != void 0) this.material[propertyName] = initialValue;
		}
	}
	_initColorBindState() {
		var _a, _b, _c;
		const { material, type, targetValue } = this;
		const propertyNameMap = this._getPropertyNameMap();
		const propertyName = (_b = (_a = propertyNameMap == null ? void 0 : propertyNameMap[type]) == null ? void 0 : _a[0]) != null ? _b : null;
		if (propertyName == null) {
			console.warn(`Tried to add a material color bind to the material ${(_c = material.name) != null ? _c : "(no name)"}, the type ${type} but the material or the type is not supported.`);
			return null;
		}
		const initialValue = material[propertyName].clone();
		return {
			propertyName,
			initialValue,
			deltaValue: new Color(targetValue.r - initialValue.r, targetValue.g - initialValue.g, targetValue.b - initialValue.b)
		};
	}
	_initAlphaBindState() {
		var _a, _b, _c;
		const { material, type, targetAlpha } = this;
		const propertyNameMap = this._getPropertyNameMap();
		const propertyName = (_b = (_a = propertyNameMap == null ? void 0 : propertyNameMap[type]) == null ? void 0 : _a[1]) != null ? _b : null;
		if (propertyName == null && targetAlpha !== 1) {
			console.warn(`Tried to add a material alpha bind to the material ${(_c = material.name) != null ? _c : "(no name)"}, the type ${type} but the material or the type does not support alpha.`);
			return null;
		}
		if (propertyName == null) return null;
		const initialValue = material[propertyName];
		return {
			propertyName,
			initialValue,
			deltaValue: targetAlpha - initialValue
		};
	}
	_getPropertyNameMap() {
		var _a, _b;
		return (_b = (_a = Object.entries(_VRMExpressionMaterialColorBind2._propertyNameMapMap).find(([distinguisher]) => {
			return this.material[distinguisher] === true;
		})) == null ? void 0 : _a[1]) != null ? _b : null;
	}
};
_VRMExpressionMaterialColorBind._propertyNameMapMap = {
	isMeshStandardMaterial: {
		color: ["color", "opacity"],
		emissionColor: ["emissive", null]
	},
	isMeshBasicMaterial: { color: ["color", "opacity"] },
	isMToonMaterial: {
		color: ["color", "opacity"],
		emissionColor: ["emissive", null],
		outlineColor: ["outlineColorFactor", null],
		matcapColor: ["matcapFactor", null],
		rimColor: ["parametricRimColorFactor", null],
		shadeColor: ["shadeColorFactor", null]
	}
};
var VRMExpressionMaterialColorBind = _VRMExpressionMaterialColorBind;
var VRMExpressionMorphTargetBind = class {
	constructor({ primitives, index, weight }) {
		this.primitives = primitives;
		this.index = index;
		this.weight = weight;
	}
	applyWeight(weight) {
		this.primitives.forEach((mesh) => {
			var _a;
			if (((_a = mesh.morphTargetInfluences) == null ? void 0 : _a[this.index]) != null) mesh.morphTargetInfluences[this.index] += this.weight * weight;
		});
	}
	clearAppliedWeight() {
		this.primitives.forEach((mesh) => {
			var _a;
			if (((_a = mesh.morphTargetInfluences) == null ? void 0 : _a[this.index]) != null) mesh.morphTargetInfluences[this.index] = 0;
		});
	}
};
var _v2 = new Vector2();
var _VRMExpressionTextureTransformBind = class _VRMExpressionTextureTransformBind2 {
	constructor({ material, scale, offset }) {
		var _a, _b;
		this.material = material;
		this.scale = scale;
		this.offset = offset;
		const propertyNames = (_a = Object.entries(_VRMExpressionTextureTransformBind2._propertyNamesMap).find(([distinguisher]) => {
			return material[distinguisher] === true;
		})) == null ? void 0 : _a[1];
		if (propertyNames == null) {
			console.warn(`Tried to add a texture transform bind to the material ${(_b = material.name) != null ? _b : "(no name)"} but the material is not supported.`);
			this._properties = [];
		} else {
			this._properties = [];
			propertyNames.forEach((propertyName) => {
				var _a2;
				const texture = (_a2 = material[propertyName]) == null ? void 0 : _a2.clone();
				if (!texture) return null;
				material[propertyName] = texture;
				const initialOffset = texture.offset.clone();
				const initialScale = texture.repeat.clone();
				const deltaOffset = offset.clone().sub(initialOffset);
				const deltaScale = scale.clone().sub(initialScale);
				this._properties.push({
					name: propertyName,
					initialOffset,
					deltaOffset,
					initialScale,
					deltaScale
				});
			});
		}
	}
	applyWeight(weight) {
		this._properties.forEach((property) => {
			const target = this.material[property.name];
			if (target === void 0) return;
			target.offset.add(_v2.copy(property.deltaOffset).multiplyScalar(weight));
			target.repeat.add(_v2.copy(property.deltaScale).multiplyScalar(weight));
		});
	}
	clearAppliedWeight() {
		this._properties.forEach((property) => {
			const target = this.material[property.name];
			if (target === void 0) return;
			target.offset.copy(property.initialOffset);
			target.repeat.copy(property.initialScale);
		});
	}
};
_VRMExpressionTextureTransformBind._propertyNamesMap = {
	isMeshStandardMaterial: [
		"map",
		"emissiveMap",
		"bumpMap",
		"normalMap",
		"displacementMap",
		"roughnessMap",
		"metalnessMap",
		"alphaMap"
	],
	isMeshBasicMaterial: [
		"map",
		"specularMap",
		"alphaMap"
	],
	isMToonMaterial: [
		"map",
		"normalMap",
		"emissiveMap",
		"shadeMultiplyTexture",
		"rimMultiplyTexture",
		"outlineWidthMultiplyTexture",
		"uvAnimationMaskTexture"
	]
};
var VRMExpressionTextureTransformBind = _VRMExpressionTextureTransformBind;
var POSSIBLE_SPEC_VERSIONS = /* @__PURE__ */ new Set(["1.0", "1.0-beta"]);
var _VRMExpressionLoaderPlugin = class _VRMExpressionLoaderPlugin2 {
	get name() {
		return "VRMExpressionLoaderPlugin";
	}
	constructor(parser) {
		this.parser = parser;
	}
	afterRoot(gltf) {
		return __async2(this, null, function* () {
			gltf.userData.vrmExpressionManager = yield this._import(gltf);
		});
	}
	/**
	* Import a {@link VRMExpressionManager} from a VRM.
	*
	* @param gltf A parsed result of GLTF taken from GLTFLoader
	*/
	_import(gltf) {
		return __async2(this, null, function* () {
			const v1Result = yield this._v1Import(gltf);
			if (v1Result) return v1Result;
			const v0Result = yield this._v0Import(gltf);
			if (v0Result) return v0Result;
			return null;
		});
	}
	_v1Import(gltf) {
		return __async2(this, null, function* () {
			var _a, _b;
			const json = this.parser.json;
			if (!(((_a = json.extensionsUsed) == null ? void 0 : _a.indexOf("VRMC_vrm")) !== -1)) return null;
			const extension = (_b = json.extensions) == null ? void 0 : _b["VRMC_vrm"];
			if (!extension) return null;
			const specVersion = extension.specVersion;
			if (!POSSIBLE_SPEC_VERSIONS.has(specVersion)) {
				console.warn(`VRMExpressionLoaderPlugin: Unknown VRMC_vrm specVersion "${specVersion}"`);
				return null;
			}
			const schemaExpressions = extension.expressions;
			if (!schemaExpressions) return null;
			const presetNameSet = new Set(Object.values(VRMExpressionPresetName));
			const nameSchemaExpressionMap = /* @__PURE__ */ new Map();
			if (schemaExpressions.preset != null) Object.entries(schemaExpressions.preset).forEach(([name, schemaExpression]) => {
				if (schemaExpression == null) return;
				if (!presetNameSet.has(name)) {
					console.warn(`VRMExpressionLoaderPlugin: Unknown preset name "${name}" detected. Ignoring the expression`);
					return;
				}
				nameSchemaExpressionMap.set(name, schemaExpression);
			});
			if (schemaExpressions.custom != null) Object.entries(schemaExpressions.custom).forEach(([name, schemaExpression]) => {
				if (presetNameSet.has(name)) {
					console.warn(`VRMExpressionLoaderPlugin: Custom expression cannot have preset name "${name}". Ignoring the expression`);
					return;
				}
				nameSchemaExpressionMap.set(name, schemaExpression);
			});
			const manager = new VRMExpressionManager();
			yield Promise.all(Array.from(nameSchemaExpressionMap.entries()).map((_0) => __async2(this, [_0], function* ([name, schemaExpression]) {
				var _a2, _b2, _c, _d, _e, _f, _g;
				const expression = new VRMExpression(name);
				gltf.scene.add(expression);
				expression.isBinary = (_a2 = schemaExpression.isBinary) != null ? _a2 : false;
				expression.overrideBlink = (_b2 = schemaExpression.overrideBlink) != null ? _b2 : "none";
				expression.overrideLookAt = (_c = schemaExpression.overrideLookAt) != null ? _c : "none";
				expression.overrideMouth = (_d = schemaExpression.overrideMouth) != null ? _d : "none";
				(_e = schemaExpression.morphTargetBinds) == null || _e.forEach((bind) => __async2(this, null, function* () {
					var _a3;
					if (bind.node === void 0 || bind.index === void 0) return;
					const primitives = yield gltfExtractPrimitivesFromNode(gltf, bind.node);
					const morphTargetIndex = bind.index;
					if (!primitives.every((primitive) => Array.isArray(primitive.morphTargetInfluences) && morphTargetIndex < primitive.morphTargetInfluences.length)) {
						console.warn(`VRMExpressionLoaderPlugin: ${schemaExpression.name} attempts to index morph #${morphTargetIndex} but not found.`);
						return;
					}
					expression.addBind(new VRMExpressionMorphTargetBind({
						primitives,
						index: morphTargetIndex,
						weight: (_a3 = bind.weight) != null ? _a3 : 1
					}));
				}));
				if (schemaExpression.materialColorBinds || schemaExpression.textureTransformBinds) {
					const gltfMaterials = [];
					gltf.scene.traverse((object) => {
						const material = object.material;
						if (material) if (Array.isArray(material)) gltfMaterials.push(...material);
						else gltfMaterials.push(material);
					});
					(_f = schemaExpression.materialColorBinds) == null || _f.forEach((bind) => __async2(this, null, function* () {
						gltfMaterials.filter((material) => {
							var _a3;
							const materialIndex = (_a3 = this.parser.associations.get(material)) == null ? void 0 : _a3.materials;
							return bind.material === materialIndex;
						}).forEach((material) => {
							expression.addBind(new VRMExpressionMaterialColorBind({
								material,
								type: bind.type,
								targetValue: new Color().fromArray(bind.targetValue),
								targetAlpha: bind.targetValue[3]
							}));
						});
					}));
					(_g = schemaExpression.textureTransformBinds) == null || _g.forEach((bind) => __async2(this, null, function* () {
						gltfMaterials.filter((material) => {
							var _a3;
							const materialIndex = (_a3 = this.parser.associations.get(material)) == null ? void 0 : _a3.materials;
							return bind.material === materialIndex;
						}).forEach((material) => {
							var _a3, _b3;
							expression.addBind(new VRMExpressionTextureTransformBind({
								material,
								offset: new Vector2().fromArray((_a3 = bind.offset) != null ? _a3 : [0, 0]),
								scale: new Vector2().fromArray((_b3 = bind.scale) != null ? _b3 : [1, 1])
							}));
						});
					}));
				}
				manager.registerExpression(expression);
			})));
			return manager;
		});
	}
	_v0Import(gltf) {
		return __async2(this, null, function* () {
			var _a;
			const json = this.parser.json;
			const vrmExt = (_a = json.extensions) == null ? void 0 : _a.VRM;
			if (!vrmExt) return null;
			const schemaBlendShape = vrmExt.blendShapeMaster;
			if (!schemaBlendShape) return null;
			const manager = new VRMExpressionManager();
			const schemaBlendShapeGroups = schemaBlendShape.blendShapeGroups;
			if (!schemaBlendShapeGroups) return manager;
			const blendShapeNameSet = /* @__PURE__ */ new Set();
			yield Promise.all(schemaBlendShapeGroups.map((schemaGroup) => __async2(this, null, function* () {
				var _a2;
				const v0PresetName = schemaGroup.presetName;
				const v1PresetName = v0PresetName != null && _VRMExpressionLoaderPlugin2.v0v1PresetNameMap[v0PresetName] || null;
				const name = v1PresetName != null ? v1PresetName : schemaGroup.name;
				if (name == null) {
					console.warn("VRMExpressionLoaderPlugin: One of custom expressions has no name. Ignoring the expression");
					return;
				}
				if (blendShapeNameSet.has(name)) {
					console.warn(`VRMExpressionLoaderPlugin: An expression preset ${v0PresetName} has duplicated entries. Ignoring the expression`);
					return;
				}
				blendShapeNameSet.add(name);
				const expression = new VRMExpression(name);
				gltf.scene.add(expression);
				expression.isBinary = (_a2 = schemaGroup.isBinary) != null ? _a2 : false;
				if (schemaGroup.binds) schemaGroup.binds.forEach((bind) => __async2(this, null, function* () {
					var _a3;
					if (bind.mesh === void 0 || bind.index === void 0) return;
					const nodesUsingMesh = [];
					(_a3 = json.nodes) == null || _a3.forEach((node, i) => {
						if (node.mesh === bind.mesh) nodesUsingMesh.push(i);
					});
					const morphTargetIndex = bind.index;
					yield Promise.all(nodesUsingMesh.map((nodeIndex) => __async2(this, null, function* () {
						var _a4;
						const primitives = yield gltfExtractPrimitivesFromNode(gltf, nodeIndex);
						if (!primitives.every((primitive) => Array.isArray(primitive.morphTargetInfluences) && morphTargetIndex < primitive.morphTargetInfluences.length)) {
							console.warn(`VRMExpressionLoaderPlugin: ${schemaGroup.name} attempts to index ${morphTargetIndex}th morph but not found.`);
							return;
						}
						expression.addBind(new VRMExpressionMorphTargetBind({
							primitives,
							index: morphTargetIndex,
							weight: .01 * ((_a4 = bind.weight) != null ? _a4 : 100)
						}));
					})));
				}));
				const materialValues = schemaGroup.materialValues;
				if (materialValues && materialValues.length !== 0) materialValues.forEach((materialValue) => {
					if (materialValue.materialName === void 0 || materialValue.propertyName === void 0 || materialValue.targetValue === void 0) return;
					const materials = [];
					gltf.scene.traverse((object) => {
						if (object.material) {
							const material = object.material;
							if (Array.isArray(material)) materials.push(...material.filter((mtl) => (mtl.name === materialValue.materialName || mtl.name === materialValue.materialName + " (Outline)") && materials.indexOf(mtl) === -1));
							else if (material.name === materialValue.materialName && materials.indexOf(material) === -1) materials.push(material);
						}
					});
					const materialPropertyName = materialValue.propertyName;
					materials.forEach((material) => {
						if (materialPropertyName === "_MainTex_ST") {
							const scale = new Vector2(materialValue.targetValue[0], materialValue.targetValue[1]);
							const offset = new Vector2(materialValue.targetValue[2], materialValue.targetValue[3]);
							offset.y = 1 - offset.y - scale.y;
							expression.addBind(new VRMExpressionTextureTransformBind({
								material,
								scale,
								offset
							}));
							return;
						}
						const materialColorType = v0ExpressionMaterialColorMap[materialPropertyName];
						if (materialColorType) {
							expression.addBind(new VRMExpressionMaterialColorBind({
								material,
								type: materialColorType,
								targetValue: new Color().fromArray(materialValue.targetValue),
								targetAlpha: materialValue.targetValue[3]
							}));
							return;
						}
						console.warn(materialPropertyName + " is not supported");
					});
				});
				manager.registerExpression(expression);
			})));
			return manager;
		});
	}
};
_VRMExpressionLoaderPlugin.v0v1PresetNameMap = {
	a: "aa",
	e: "ee",
	i: "ih",
	o: "oh",
	u: "ou",
	blink: "blink",
	joy: "happy",
	angry: "angry",
	sorrow: "sad",
	fun: "relaxed",
	lookup: "lookUp",
	lookdown: "lookDown",
	lookleft: "lookLeft",
	lookright: "lookRight",
	blink_l: "blinkLeft",
	blink_r: "blinkRight",
	neutral: "neutral"
};
var _VRMFirstPerson = class _VRMFirstPerson2 {
	/**
	* Create a new VRMFirstPerson object.
	*
	* @param humanoid A {@link VRMHumanoid}
	* @param meshAnnotations A {@link VRMFirstPersonMeshAnnotation}
	*/
	constructor(humanoid, meshAnnotations) {
		this._firstPersonOnlyLayer = _VRMFirstPerson2.DEFAULT_FIRSTPERSON_ONLY_LAYER;
		this._thirdPersonOnlyLayer = _VRMFirstPerson2.DEFAULT_THIRDPERSON_ONLY_LAYER;
		this._initializedLayers = false;
		this.humanoid = humanoid;
		this.meshAnnotations = meshAnnotations;
	}
	/**
	* Copy the given {@link VRMFirstPerson} into this one.
	* {@link humanoid} must be same as the source one.
	* @param source The {@link VRMFirstPerson} you want to copy
	* @returns this
	*/
	copy(source) {
		if (this.humanoid !== source.humanoid) throw new Error("VRMFirstPerson: humanoid must be same in order to copy");
		this.meshAnnotations = source.meshAnnotations.map((annotation) => ({
			meshes: annotation.meshes.concat(),
			type: annotation.type
		}));
		return this;
	}
	/**
	* Returns a clone of this {@link VRMFirstPerson}.
	* @returns Copied {@link VRMFirstPerson}
	*/
	clone() {
		return new _VRMFirstPerson2(this.humanoid, this.meshAnnotations).copy(this);
	}
	/**
	* A camera layer represents `FirstPersonOnly` layer.
	* Note that **you must call {@link setup} first before you use the layer feature** or it does not work properly.
	*
	* The value is {@link DEFAULT_FIRSTPERSON_ONLY_LAYER} by default but you can change the layer by specifying via {@link setup} if you prefer.
	*
	* @see https://vrm.dev/en/univrm/api/univrm_use_firstperson/
	* @see https://threejs.org/docs/#api/en/core/Layers
	*/
	get firstPersonOnlyLayer() {
		return this._firstPersonOnlyLayer;
	}
	/**
	* A camera layer represents `ThirdPersonOnly` layer.
	* Note that **you must call {@link setup} first before you use the layer feature** or it does not work properly.
	*
	* The value is {@link DEFAULT_THIRDPERSON_ONLY_LAYER} by default but you can change the layer by specifying via {@link setup} if you prefer.
	*
	* @see https://vrm.dev/en/univrm/api/univrm_use_firstperson/
	* @see https://threejs.org/docs/#api/en/core/Layers
	*/
	get thirdPersonOnlyLayer() {
		return this._thirdPersonOnlyLayer;
	}
	/**
	* In this method, it assigns layers for every meshes based on mesh annotations.
	* You must call this method first before you use the layer feature.
	*
	* This is an equivalent of [VRMFirstPerson.Setup](https://github.com/vrm-c/UniVRM/blob/73a5bd8fcddaa2a7a8735099a97e63c9db3e5ea0/Assets/VRM/Runtime/FirstPerson/VRMFirstPerson.cs#L295-L299) of the UniVRM.
	*
	* The `cameraLayer` parameter specifies which layer will be assigned for `FirstPersonOnly` / `ThirdPersonOnly`.
	* In UniVRM, we specified those by naming each desired layer as `FIRSTPERSON_ONLY_LAYER` / `THIRDPERSON_ONLY_LAYER`
	* but we are going to specify these layers at here since we are unable to name layers in Three.js.
	*
	* @param cameraLayer Specify which layer will be for `FirstPersonOnly` / `ThirdPersonOnly`.
	*/
	setup({ firstPersonOnlyLayer = _VRMFirstPerson2.DEFAULT_FIRSTPERSON_ONLY_LAYER, thirdPersonOnlyLayer = _VRMFirstPerson2.DEFAULT_THIRDPERSON_ONLY_LAYER } = {}) {
		if (this._initializedLayers) return;
		this._firstPersonOnlyLayer = firstPersonOnlyLayer;
		this._thirdPersonOnlyLayer = thirdPersonOnlyLayer;
		this.meshAnnotations.forEach((item) => {
			item.meshes.forEach((mesh) => {
				if (item.type === "firstPersonOnly") {
					mesh.layers.set(this._firstPersonOnlyLayer);
					mesh.traverse((child) => child.layers.set(this._firstPersonOnlyLayer));
				} else if (item.type === "thirdPersonOnly") {
					mesh.layers.set(this._thirdPersonOnlyLayer);
					mesh.traverse((child) => child.layers.set(this._thirdPersonOnlyLayer));
				} else if (item.type === "auto") this._createHeadlessModel(mesh);
			});
		});
		this._initializedLayers = true;
	}
	_excludeTriangles(triangles, bws, skinIndex, exclude) {
		let count = 0;
		if (bws != null && bws.length > 0) for (let i = 0; i < triangles.length; i += 3) {
			const a = triangles[i];
			const b = triangles[i + 1];
			const c = triangles[i + 2];
			const bw0 = bws[a];
			const skin0 = skinIndex[a];
			if (bw0[0] > 0 && exclude.includes(skin0[0])) continue;
			if (bw0[1] > 0 && exclude.includes(skin0[1])) continue;
			if (bw0[2] > 0 && exclude.includes(skin0[2])) continue;
			if (bw0[3] > 0 && exclude.includes(skin0[3])) continue;
			const bw1 = bws[b];
			const skin1 = skinIndex[b];
			if (bw1[0] > 0 && exclude.includes(skin1[0])) continue;
			if (bw1[1] > 0 && exclude.includes(skin1[1])) continue;
			if (bw1[2] > 0 && exclude.includes(skin1[2])) continue;
			if (bw1[3] > 0 && exclude.includes(skin1[3])) continue;
			const bw2 = bws[c];
			const skin2 = skinIndex[c];
			if (bw2[0] > 0 && exclude.includes(skin2[0])) continue;
			if (bw2[1] > 0 && exclude.includes(skin2[1])) continue;
			if (bw2[2] > 0 && exclude.includes(skin2[2])) continue;
			if (bw2[3] > 0 && exclude.includes(skin2[3])) continue;
			triangles[count++] = a;
			triangles[count++] = b;
			triangles[count++] = c;
		}
		return count;
	}
	_createErasedMesh(src, erasingBonesIndex) {
		const dst = new SkinnedMesh(src.geometry.clone(), src.material);
		dst.name = `${src.name}(erase)`;
		dst.frustumCulled = src.frustumCulled;
		dst.layers.set(this._firstPersonOnlyLayer);
		const geometry = dst.geometry;
		const skinIndexAttr = geometry.getAttribute("skinIndex");
		const skinIndexAttrArray = skinIndexAttr instanceof GLBufferAttribute ? [] : skinIndexAttr.array;
		const skinIndex = [];
		for (let i = 0; i < skinIndexAttrArray.length; i += 4) skinIndex.push([
			skinIndexAttrArray[i],
			skinIndexAttrArray[i + 1],
			skinIndexAttrArray[i + 2],
			skinIndexAttrArray[i + 3]
		]);
		const skinWeightAttr = geometry.getAttribute("skinWeight");
		const skinWeightAttrArray = skinWeightAttr instanceof GLBufferAttribute ? [] : skinWeightAttr.array;
		const skinWeight = [];
		for (let i = 0; i < skinWeightAttrArray.length; i += 4) skinWeight.push([
			skinWeightAttrArray[i],
			skinWeightAttrArray[i + 1],
			skinWeightAttrArray[i + 2],
			skinWeightAttrArray[i + 3]
		]);
		const index = geometry.getIndex();
		if (!index) throw new Error("The geometry doesn't have an index buffer");
		const oldTriangles = Array.from(index.array);
		const count = this._excludeTriangles(oldTriangles, skinWeight, skinIndex, erasingBonesIndex);
		const newTriangle = [];
		for (let i = 0; i < count; i++) newTriangle[i] = oldTriangles[i];
		geometry.setIndex(newTriangle);
		if (src.onBeforeRender) dst.onBeforeRender = src.onBeforeRender;
		dst.bind(new Skeleton(src.skeleton.bones, src.skeleton.boneInverses), new Matrix4());
		return dst;
	}
	_createHeadlessModelForSkinnedMesh(parent, mesh) {
		const eraseBoneIndexes = [];
		mesh.skeleton.bones.forEach((bone, index) => {
			if (this._isEraseTarget(bone)) eraseBoneIndexes.push(index);
		});
		if (!eraseBoneIndexes.length) {
			mesh.layers.enable(this._thirdPersonOnlyLayer);
			mesh.layers.enable(this._firstPersonOnlyLayer);
			return;
		}
		mesh.layers.set(this._thirdPersonOnlyLayer);
		const newMesh = this._createErasedMesh(mesh, eraseBoneIndexes);
		parent.add(newMesh);
	}
	_createHeadlessModel(node) {
		if (node.type === "Group") {
			node.layers.set(this._thirdPersonOnlyLayer);
			if (this._isEraseTarget(node)) node.traverse((child) => child.layers.set(this._thirdPersonOnlyLayer));
			else {
				const parent = new Group();
				parent.name = `_headless_${node.name}`;
				parent.layers.set(this._firstPersonOnlyLayer);
				node.parent.add(parent);
				node.children.filter((child) => child.type === "SkinnedMesh").forEach((child) => {
					const skinnedMesh = child;
					this._createHeadlessModelForSkinnedMesh(parent, skinnedMesh);
				});
			}
		} else if (node.type === "SkinnedMesh") {
			const skinnedMesh = node;
			this._createHeadlessModelForSkinnedMesh(node.parent, skinnedMesh);
		} else if (this._isEraseTarget(node)) {
			node.layers.set(this._thirdPersonOnlyLayer);
			node.traverse((child) => child.layers.set(this._thirdPersonOnlyLayer));
		}
	}
	_isEraseTarget(bone) {
		if (bone === this.humanoid.getRawBoneNode("head")) return true;
		else if (!bone.parent) return false;
		else return this._isEraseTarget(bone.parent);
	}
};
_VRMFirstPerson.DEFAULT_FIRSTPERSON_ONLY_LAYER = 9;
_VRMFirstPerson.DEFAULT_THIRDPERSON_ONLY_LAYER = 10;
new Vector3();
new Vector3();
new Quaternion();
var VRMHumanBoneParentMap = {
	hips: null,
	spine: "hips",
	chest: "spine",
	upperChest: "chest",
	neck: "upperChest",
	head: "neck",
	leftEye: "head",
	rightEye: "head",
	jaw: "head",
	leftUpperLeg: "hips",
	leftLowerLeg: "leftUpperLeg",
	leftFoot: "leftLowerLeg",
	leftToes: "leftFoot",
	rightUpperLeg: "hips",
	rightLowerLeg: "rightUpperLeg",
	rightFoot: "rightLowerLeg",
	rightToes: "rightFoot",
	leftShoulder: "upperChest",
	leftUpperArm: "leftShoulder",
	leftLowerArm: "leftUpperArm",
	leftHand: "leftLowerArm",
	rightShoulder: "upperChest",
	rightUpperArm: "rightShoulder",
	rightLowerArm: "rightUpperArm",
	rightHand: "rightLowerArm",
	leftThumbMetacarpal: "leftHand",
	leftThumbProximal: "leftThumbMetacarpal",
	leftThumbDistal: "leftThumbProximal",
	leftIndexProximal: "leftHand",
	leftIndexIntermediate: "leftIndexProximal",
	leftIndexDistal: "leftIndexIntermediate",
	leftMiddleProximal: "leftHand",
	leftMiddleIntermediate: "leftMiddleProximal",
	leftMiddleDistal: "leftMiddleIntermediate",
	leftRingProximal: "leftHand",
	leftRingIntermediate: "leftRingProximal",
	leftRingDistal: "leftRingIntermediate",
	leftLittleProximal: "leftHand",
	leftLittleIntermediate: "leftLittleProximal",
	leftLittleDistal: "leftLittleIntermediate",
	rightThumbMetacarpal: "rightHand",
	rightThumbProximal: "rightThumbMetacarpal",
	rightThumbDistal: "rightThumbProximal",
	rightIndexProximal: "rightHand",
	rightIndexIntermediate: "rightIndexProximal",
	rightIndexDistal: "rightIndexIntermediate",
	rightMiddleProximal: "rightHand",
	rightMiddleIntermediate: "rightMiddleProximal",
	rightMiddleDistal: "rightMiddleIntermediate",
	rightRingProximal: "rightHand",
	rightRingIntermediate: "rightRingProximal",
	rightRingDistal: "rightRingIntermediate",
	rightLittleProximal: "rightHand",
	rightLittleIntermediate: "rightLittleProximal",
	rightLittleDistal: "rightLittleIntermediate"
};
function quatInvertCompat(target) {
	if (target.invert) target.invert();
	else target.inverse();
	return target;
}
new Vector3();
new Quaternion();
new Vector3();
new Quaternion();
new Vector3();
new Quaternion();
new Quaternion();
new Vector3();
new Vector3();
var SQRT_2_OVER_2 = Math.sqrt(2) / 2;
new Quaternion(0, 0, -SQRT_2_OVER_2, SQRT_2_OVER_2);
new Vector3(0, 1, 0);
var _position = new Vector3();
var _scale = new Vector3();
function getWorldQuaternionLite(object, out) {
	object.matrixWorld.decompose(_position, out, _scale);
	return out;
}
function calcAzimuthAltitude(vector) {
	return [Math.atan2(-vector.z, vector.x), Math.atan2(vector.y, Math.sqrt(vector.x * vector.x + vector.z * vector.z))];
}
function sanitizeAngle(angle) {
	const roundTurn = Math.round(angle / 2 / Math.PI);
	return angle - 2 * Math.PI * roundTurn;
}
var VEC3_POSITIVE_Z = new Vector3(0, 0, 1);
var _v3A5 = new Vector3();
var _v3B3 = new Vector3();
var _v3C = new Vector3();
var _quatA5 = new Quaternion();
var _quatB2 = new Quaternion();
var _quatC = new Quaternion();
var _quatD = new Quaternion();
var _eulerA = new Euler();
var _VRMLookAt = class _VRMLookAt2 {
	/**
	* Create a new {@link VRMLookAt}.
	*
	* @param humanoid A {@link VRMHumanoid}
	* @param applier A {@link VRMLookAtApplier}
	*/
	constructor(humanoid, applier) {
		this.offsetFromHeadBone = new Vector3();
		this.autoUpdate = true;
		this.faceFront = new Vector3(0, 0, 1);
		this.humanoid = humanoid;
		this.applier = applier;
		this._yaw = 0;
		this._pitch = 0;
		this._needsUpdate = true;
		this._restHeadWorldQuaternion = this.getLookAtWorldQuaternion(new Quaternion());
	}
	/**
	* Its current angle around Y axis, in degree.
	*/
	get yaw() {
		return this._yaw;
	}
	/**
	* Its current angle around Y axis, in degree.
	*/
	set yaw(value) {
		this._yaw = value;
		this._needsUpdate = true;
	}
	/**
	* Its current angle around X axis, in degree.
	*/
	get pitch() {
		return this._pitch;
	}
	/**
	* Its current angle around X axis, in degree.
	*/
	set pitch(value) {
		this._pitch = value;
		this._needsUpdate = true;
	}
	/**
	* @deprecated Use {@link getEuler} instead.
	*/
	get euler() {
		console.warn("VRMLookAt: euler is deprecated. use getEuler() instead.");
		return this.getEuler(new Euler());
	}
	/**
	* Get its yaw-pitch angles as an `Euler`.
	* Does NOT consider {@link faceFront}; it returns `Euler(0, 0, 0; "YXZ")` by default regardless of the faceFront value.
	*
	* @param target The target euler
	*/
	getEuler(target) {
		return target.set(MathUtils.DEG2RAD * this._pitch, MathUtils.DEG2RAD * this._yaw, 0, "YXZ");
	}
	/**
	* Copy the given {@link VRMLookAt} into this one.
	* {@link humanoid} must be same as the source one.
	* {@link applier} will reference the same instance as the source one.
	* @param source The {@link VRMLookAt} you want to copy
	* @returns this
	*/
	copy(source) {
		if (this.humanoid !== source.humanoid) throw new Error("VRMLookAt: humanoid must be same in order to copy");
		this.offsetFromHeadBone.copy(source.offsetFromHeadBone);
		this.applier = source.applier;
		this.autoUpdate = source.autoUpdate;
		this.target = source.target;
		this.faceFront.copy(source.faceFront);
		return this;
	}
	/**
	* Returns a clone of this {@link VRMLookAt}.
	* Note that {@link humanoid} and {@link applier} will reference the same instance as this one.
	* @returns Copied {@link VRMLookAt}
	*/
	clone() {
		return new _VRMLookAt2(this.humanoid, this.applier).copy(this);
	}
	/**
	* Reset the lookAt direction (yaw and pitch) to the initial direction.
	*/
	reset() {
		this._yaw = 0;
		this._pitch = 0;
		this._needsUpdate = true;
	}
	/**
	* Get its lookAt position in world coordinate.
	*
	* @param target A target `THREE.Vector3`
	*/
	getLookAtWorldPosition(target) {
		const head = this.humanoid.getRawBoneNode("head");
		return target.copy(this.offsetFromHeadBone).applyMatrix4(head.matrixWorld);
	}
	/**
	* Get its lookAt rotation in world coordinate.
	* Does NOT consider {@link faceFront}.
	*
	* @param target A target `THREE.Quaternion`
	*/
	getLookAtWorldQuaternion(target) {
		return getWorldQuaternionLite(this.humanoid.getRawBoneNode("head"), target);
	}
	/**
	* Get a quaternion that rotates the +Z unit vector of the humanoid Head to the {@link faceFront} direction.
	*
	* @param target A target `THREE.Quaternion`
	*/
	getFaceFrontQuaternion(target) {
		if (this.faceFront.distanceToSquared(VEC3_POSITIVE_Z) < .01) return target.copy(this._restHeadWorldQuaternion).invert();
		const [faceFrontAzimuth, faceFrontAltitude] = calcAzimuthAltitude(this.faceFront);
		_eulerA.set(0, .5 * Math.PI + faceFrontAzimuth, faceFrontAltitude, "YZX");
		return target.setFromEuler(_eulerA).premultiply(_quatD.copy(this._restHeadWorldQuaternion).invert());
	}
	/**
	* Get its LookAt direction in world coordinate.
	*
	* @param target A target `THREE.Vector3`
	*/
	getLookAtWorldDirection(target) {
		this.getLookAtWorldQuaternion(_quatB2);
		this.getFaceFrontQuaternion(_quatC);
		return target.copy(VEC3_POSITIVE_Z).applyQuaternion(_quatB2).applyQuaternion(_quatC).applyEuler(this.getEuler(_eulerA));
	}
	/**
	* Set its lookAt target position.
	*
	* Note that its result will be instantly overwritten if {@link VRMLookAtHead.autoUpdate} is enabled.
	*
	* If you want to track an object continuously, you might want to use {@link target} instead.
	*
	* @param position A target position, in world space
	*/
	lookAt(position) {
		const headRotDiffInv = _quatA5.copy(this._restHeadWorldQuaternion).multiply(quatInvertCompat(this.getLookAtWorldQuaternion(_quatB2)));
		const headPos = this.getLookAtWorldPosition(_v3B3);
		const lookAtDir = _v3C.copy(position).sub(headPos).applyQuaternion(headRotDiffInv).normalize();
		const [azimuthFrom, altitudeFrom] = calcAzimuthAltitude(this.faceFront);
		const [azimuthTo, altitudeTo] = calcAzimuthAltitude(lookAtDir);
		const yaw = sanitizeAngle(azimuthTo - azimuthFrom);
		const pitch = sanitizeAngle(altitudeFrom - altitudeTo);
		this._yaw = MathUtils.RAD2DEG * yaw;
		this._pitch = MathUtils.RAD2DEG * pitch;
		this._needsUpdate = true;
	}
	/**
	* Update the VRMLookAtHead.
	* If {@link autoUpdate} is enabled, this will make it look at the {@link target}.
	*
	* @param delta deltaTime, it isn't used though. You can use the parameter if you want to use this in your own extended {@link VRMLookAt}.
	*/
	update(delta) {
		if (this.target != null && this.autoUpdate) this.lookAt(this.target.getWorldPosition(_v3A5));
		if (this._needsUpdate) {
			this._needsUpdate = false;
			this.applier.applyYawPitch(this._yaw, this._pitch);
		}
	}
};
_VRMLookAt.EULER_ORDER = "YXZ";
var VRMLookAt = _VRMLookAt;
var VEC3_POSITIVE_Z2 = new Vector3(0, 0, 1);
var _quatA6 = new Quaternion();
var _quatB3 = new Quaternion();
var _eulerA2 = new Euler(0, 0, 0, "YXZ");
var VRMLookAtBoneApplier = class {
	/**
	* Create a new {@link VRMLookAtBoneApplier}.
	*
	* @param humanoid A {@link VRMHumanoid}
	* @param rangeMapHorizontalInner A {@link VRMLookAtRangeMap} used for inner transverse direction
	* @param rangeMapHorizontalOuter A {@link VRMLookAtRangeMap} used for outer transverse direction
	* @param rangeMapVerticalDown A {@link VRMLookAtRangeMap} used for down direction
	* @param rangeMapVerticalUp A {@link VRMLookAtRangeMap} used for up direction
	*/
	constructor(humanoid, rangeMapHorizontalInner, rangeMapHorizontalOuter, rangeMapVerticalDown, rangeMapVerticalUp) {
		this.humanoid = humanoid;
		this.rangeMapHorizontalInner = rangeMapHorizontalInner;
		this.rangeMapHorizontalOuter = rangeMapHorizontalOuter;
		this.rangeMapVerticalDown = rangeMapVerticalDown;
		this.rangeMapVerticalUp = rangeMapVerticalUp;
		this.faceFront = new Vector3(0, 0, 1);
		this._restQuatLeftEye = new Quaternion();
		this._restQuatRightEye = new Quaternion();
		this._restLeftEyeParentWorldQuat = new Quaternion();
		this._restRightEyeParentWorldQuat = new Quaternion();
		const leftEye = this.humanoid.getRawBoneNode("leftEye");
		const rightEye = this.humanoid.getRawBoneNode("rightEye");
		if (leftEye) {
			this._restQuatLeftEye.copy(leftEye.quaternion);
			getWorldQuaternionLite(leftEye.parent, this._restLeftEyeParentWorldQuat);
		}
		if (rightEye) {
			this._restQuatRightEye.copy(rightEye.quaternion);
			getWorldQuaternionLite(rightEye.parent, this._restRightEyeParentWorldQuat);
		}
	}
	/**
	* Apply the input angle to its associated VRM model.
	*
	* @param yaw Rotation around Y axis, in degree
	* @param pitch Rotation around X axis, in degree
	*/
	applyYawPitch(yaw, pitch) {
		const leftEye = this.humanoid.getRawBoneNode("leftEye");
		const rightEye = this.humanoid.getRawBoneNode("rightEye");
		const leftEyeNormalized = this.humanoid.getNormalizedBoneNode("leftEye");
		const rightEyeNormalized = this.humanoid.getNormalizedBoneNode("rightEye");
		if (leftEye) {
			if (pitch < 0) _eulerA2.x = -MathUtils.DEG2RAD * this.rangeMapVerticalDown.map(-pitch);
			else _eulerA2.x = MathUtils.DEG2RAD * this.rangeMapVerticalUp.map(pitch);
			if (yaw < 0) _eulerA2.y = -MathUtils.DEG2RAD * this.rangeMapHorizontalInner.map(-yaw);
			else _eulerA2.y = MathUtils.DEG2RAD * this.rangeMapHorizontalOuter.map(yaw);
			_quatA6.setFromEuler(_eulerA2);
			this._getWorldFaceFrontQuat(_quatB3);
			leftEyeNormalized.quaternion.copy(_quatB3).multiply(_quatA6).multiply(_quatB3.invert());
			_quatA6.copy(this._restLeftEyeParentWorldQuat);
			leftEye.quaternion.copy(leftEyeNormalized.quaternion).multiply(_quatA6).premultiply(_quatA6.invert()).multiply(this._restQuatLeftEye);
		}
		if (rightEye) {
			if (pitch < 0) _eulerA2.x = -MathUtils.DEG2RAD * this.rangeMapVerticalDown.map(-pitch);
			else _eulerA2.x = MathUtils.DEG2RAD * this.rangeMapVerticalUp.map(pitch);
			if (yaw < 0) _eulerA2.y = -MathUtils.DEG2RAD * this.rangeMapHorizontalOuter.map(-yaw);
			else _eulerA2.y = MathUtils.DEG2RAD * this.rangeMapHorizontalInner.map(yaw);
			_quatA6.setFromEuler(_eulerA2);
			this._getWorldFaceFrontQuat(_quatB3);
			rightEyeNormalized.quaternion.copy(_quatB3).multiply(_quatA6).multiply(_quatB3.invert());
			_quatA6.copy(this._restRightEyeParentWorldQuat);
			rightEye.quaternion.copy(rightEyeNormalized.quaternion).multiply(_quatA6).premultiply(_quatA6.invert()).multiply(this._restQuatRightEye);
		}
	}
	/**
	* @deprecated Use {@link applyYawPitch} instead.
	*/
	lookAt(euler) {
		console.warn("VRMLookAtBoneApplier: lookAt() is deprecated. use apply() instead.");
		const yaw = MathUtils.RAD2DEG * euler.y;
		const pitch = MathUtils.RAD2DEG * euler.x;
		this.applyYawPitch(yaw, pitch);
	}
	/**
	* Get a quaternion that rotates the world-space +Z unit vector to the {@link faceFront} direction.
	*
	* @param target A target `THREE.Quaternion`
	*/
	_getWorldFaceFrontQuat(target) {
		if (this.faceFront.distanceToSquared(VEC3_POSITIVE_Z2) < .01) return target.identity();
		const [faceFrontAzimuth, faceFrontAltitude] = calcAzimuthAltitude(this.faceFront);
		_eulerA2.set(0, .5 * Math.PI + faceFrontAzimuth, faceFrontAltitude, "YZX");
		return target.setFromEuler(_eulerA2);
	}
};
VRMLookAtBoneApplier.type = "bone";
var VRMLookAtExpressionApplier = class {
	/**
	* Create a new {@link VRMLookAtExpressionApplier}.
	*
	* @param expressions A {@link VRMExpressionManager}
	* @param rangeMapHorizontalInner A {@link VRMLookAtRangeMap} used for inner transverse direction
	* @param rangeMapHorizontalOuter A {@link VRMLookAtRangeMap} used for outer transverse direction
	* @param rangeMapVerticalDown A {@link VRMLookAtRangeMap} used for down direction
	* @param rangeMapVerticalUp A {@link VRMLookAtRangeMap} used for up direction
	*/
	constructor(expressions, rangeMapHorizontalInner, rangeMapHorizontalOuter, rangeMapVerticalDown, rangeMapVerticalUp) {
		this.expressions = expressions;
		this.rangeMapHorizontalInner = rangeMapHorizontalInner;
		this.rangeMapHorizontalOuter = rangeMapHorizontalOuter;
		this.rangeMapVerticalDown = rangeMapVerticalDown;
		this.rangeMapVerticalUp = rangeMapVerticalUp;
	}
	/**
	* Apply the input angle to its associated VRM model.
	*
	* @param yaw Rotation around Y axis, in degree
	* @param pitch Rotation around X axis, in degree
	*/
	applyYawPitch(yaw, pitch) {
		if (pitch < 0) {
			this.expressions.setValue("lookDown", 0);
			this.expressions.setValue("lookUp", this.rangeMapVerticalUp.map(-pitch));
		} else {
			this.expressions.setValue("lookUp", 0);
			this.expressions.setValue("lookDown", this.rangeMapVerticalDown.map(pitch));
		}
		if (yaw < 0) {
			this.expressions.setValue("lookLeft", 0);
			this.expressions.setValue("lookRight", this.rangeMapHorizontalOuter.map(-yaw));
		} else {
			this.expressions.setValue("lookRight", 0);
			this.expressions.setValue("lookLeft", this.rangeMapHorizontalOuter.map(yaw));
		}
	}
	/**
	* @deprecated Use {@link applyYawPitch} instead.
	*/
	lookAt(euler) {
		console.warn("VRMLookAtBoneApplier: lookAt() is deprecated. use apply() instead.");
		const yaw = MathUtils.RAD2DEG * euler.y;
		const pitch = MathUtils.RAD2DEG * euler.x;
		this.applyYawPitch(yaw, pitch);
	}
};
VRMLookAtExpressionApplier.type = "expression";
var RAD2DEG = 180 / Math.PI;
var _eulerA3 = /* @__PURE__ */ new Euler();
var VRMLookAtQuaternionProxy = class extends Object3D {
	constructor(lookAt) {
		super();
		this.vrmLookAt = lookAt;
		this.type = "VRMLookAtQuaternionProxy";
		const prevRotationOnChangeCallback = this.rotation._onChangeCallback;
		this.rotation._onChange(() => {
			prevRotationOnChangeCallback();
			this._applyToLookAt();
		});
		const prevQuaternionOnChangeCallback = this.quaternion._onChangeCallback;
		this.quaternion._onChange(() => {
			prevQuaternionOnChangeCallback();
			this._applyToLookAt();
		});
	}
	_applyToLookAt() {
		_eulerA3.setFromQuaternion(this.quaternion, VRMLookAt.EULER_ORDER);
		this.vrmLookAt.yaw = RAD2DEG * _eulerA3.y;
		this.vrmLookAt.pitch = RAD2DEG * _eulerA3.x;
	}
};
function createVRMAnimationHumanoidTracks(vrmAnimation, humanoid, metaVersion) {
	var _a, _b;
	const translation = /* @__PURE__ */ new Map();
	const rotation = /* @__PURE__ */ new Map();
	for (const [name, origTrack] of vrmAnimation.humanoidTracks.rotation.entries()) {
		const nodeName = (_a = humanoid.getNormalizedBoneNode(name)) == null ? void 0 : _a.name;
		if (nodeName != null) {
			const track = new QuaternionKeyframeTrack(`${nodeName}.quaternion`, origTrack.times, origTrack.values.map((v, i) => metaVersion === "0" && i % 2 === 0 ? -v : v));
			rotation.set(name, track);
		}
	}
	for (const [name, origTrack] of vrmAnimation.humanoidTracks.translation.entries()) {
		const nodeName = (_b = humanoid.getNormalizedBoneNode(name)) == null ? void 0 : _b.name;
		if (nodeName != null) {
			const animationY = vrmAnimation.restHipsPosition.y;
			const scale = humanoid.normalizedRestPose.hips.position[1] / animationY;
			const track = origTrack.clone();
			track.values = track.values.map((v, i) => (metaVersion === "0" && i % 3 !== 1 ? -v : v) * scale);
			track.name = `${nodeName}.position`;
			translation.set(name, track);
		}
	}
	return {
		translation,
		rotation
	};
}
function createVRMAnimationExpressionTracks(vrmAnimation, expressionManager) {
	const preset = /* @__PURE__ */ new Map();
	const custom = /* @__PURE__ */ new Map();
	for (const [name, origTrack] of vrmAnimation.expressionTracks.preset.entries()) {
		const trackName = expressionManager.getExpressionTrackName(name);
		if (trackName != null) {
			const track = origTrack.clone();
			track.name = trackName;
			preset.set(name, track);
		}
	}
	for (const [name, origTrack] of vrmAnimation.expressionTracks.custom.entries()) {
		const trackName = expressionManager.getExpressionTrackName(name);
		if (trackName != null) {
			const track = origTrack.clone();
			track.name = trackName;
			custom.set(name, track);
		}
	}
	return {
		preset,
		custom
	};
}
function createVRMAnimationLookAtTrack(vrmAnimation, trackName) {
	if (vrmAnimation.lookAtTrack == null) return null;
	const track = vrmAnimation.lookAtTrack.clone();
	track.name = trackName;
	return track;
}
function createVRMAnimationClip(vrmAnimation, vrm) {
	const tracks = [];
	const humanoidTracks = createVRMAnimationHumanoidTracks(vrmAnimation, vrm.humanoid, vrm.meta.metaVersion);
	tracks.push(...humanoidTracks.translation.values());
	tracks.push(...humanoidTracks.rotation.values());
	if (vrm.expressionManager != null) {
		const expressionTracks = createVRMAnimationExpressionTracks(vrmAnimation, vrm.expressionManager);
		tracks.push(...expressionTracks.preset.values());
		tracks.push(...expressionTracks.custom.values());
	}
	if (vrm.lookAt != null) {
		let proxy = vrm.scene.children.find((obj) => obj instanceof VRMLookAtQuaternionProxy);
		if (proxy == null) {
			console.warn("createVRMAnimationClip: VRMLookAtQuaternionProxy is not found. Creating a new one automatically. To suppress this warning, create a VRMLookAtQuaternionProxy manually");
			proxy = new VRMLookAtQuaternionProxy(vrm.lookAt);
			proxy.name = "VRMLookAtQuaternionProxy";
			vrm.scene.add(proxy);
		} else if (proxy.name === "") {
			console.warn("createVRMAnimationClip: VRMLookAtQuaternionProxy is found but its name is not set. Setting the name automatically. To suppress this warning, set the name manually");
			proxy.name = "VRMLookAtQuaternionProxy";
		}
		const track = createVRMAnimationLookAtTrack(vrmAnimation, `${proxy.name}.quaternion`);
		if (track != null) tracks.push(track);
	}
	return new AnimationClip("Clip", vrmAnimation.duration, tracks);
}
var VRMAnimation = class {
	constructor() {
		this.duration = 0;
		this.restHipsPosition = new Vector3();
		this.humanoidTracks = {
			translation: /* @__PURE__ */ new Map(),
			rotation: /* @__PURE__ */ new Map()
		};
		this.expressionTracks = {
			preset: /* @__PURE__ */ new Map(),
			custom: /* @__PURE__ */ new Map()
		};
		this.lookAtTrack = null;
	}
};
function arrayChunk(array, every) {
	const N = array.length;
	const ret = [];
	let current = [];
	let remaining = 0;
	for (let i = 0; i < N; i++) {
		const el = array[i];
		if (remaining <= 0) {
			remaining = every;
			current = [];
			ret.push(current);
		}
		current.push(el);
		remaining--;
	}
	return ret;
}
var MAT4_IDENTITY = /* @__PURE__ */ new Matrix4();
var _v3A6 = /* @__PURE__ */ new Vector3();
var _quatA7 = /* @__PURE__ */ new Quaternion();
var _quatB4 = /* @__PURE__ */ new Quaternion();
var _quatC2 = /* @__PURE__ */ new Quaternion();
var POSSIBLE_SPEC_VERSIONS2 = /* @__PURE__ */ new Set(["1.0", "1.0-draft"]);
var vrmExpressionPresetNameSet = /* @__PURE__ */ new Set(Object.values(VRMExpressionPresetName));
var VRMAnimationLoaderPlugin = class {
	constructor(parser) {
		this.parser = parser;
	}
	get name() {
		return "VRMC_vrm_animation";
	}
	afterRoot(gltf) {
		return __async(this, null, function* () {
			var _a, _b, _c;
			const defGltf = gltf.parser.json;
			const defExtensionsUsed = defGltf.extensionsUsed;
			if (defExtensionsUsed == null || defExtensionsUsed.indexOf(this.name) == -1) return;
			const defExtension = (_a = defGltf.extensions) == null ? void 0 : _a[this.name];
			if (defExtension == null) return;
			const specVersion = defExtension.specVersion;
			if (specVersion == null) console.warn("VRMAnimationLoaderPlugin: specVersion of the VRMA is not defined. Consider updating the animation file. Assuming the spec version is 1.0.");
			else {
				if (!POSSIBLE_SPEC_VERSIONS2.has(specVersion)) {
					console.warn(`VRMAnimationLoaderPlugin: Unknown VRMC_vrm_animation spec version: ${specVersion}`);
					return;
				}
				if (specVersion === "1.0-draft") console.warn("VRMAnimationLoaderPlugin: Using a draft spec version: 1.0-draft. Some behaviors may be different. Consider updating the animation file.");
			}
			const nodeMap = this._createNodeMap(defExtension);
			const worldMatrixMap = yield this._createBoneWorldMatrixMap(gltf, defExtension);
			const hipsNode = (_c = (_b = defExtension.humanoid) == null ? void 0 : _b.humanBones["hips"]) == null ? void 0 : _c.node;
			const hips = hipsNode != null ? yield gltf.parser.getDependency("node", hipsNode) : null;
			const restHipsPosition = new Vector3();
			hips?.getWorldPosition(restHipsPosition);
			if (restHipsPosition.y < .001) console.warn("VRMAnimationLoaderPlugin: The loaded VRM Animation might violate the VRM T-pose (The y component of the rest hips position is approximately zero or below.)");
			const animations = gltf.animations.map((clip, iAnimation) => {
				const defAnimation = defGltf.animations[iAnimation];
				const animation = this._parseAnimation(clip, defAnimation, nodeMap, worldMatrixMap);
				animation.restHipsPosition = restHipsPosition;
				return animation;
			});
			gltf.userData.vrmAnimations = animations;
		});
	}
	_createNodeMap(defExtension) {
		var _a, _b, _c, _d, _e;
		const humanoidIndexToName = /* @__PURE__ */ new Map();
		const expressionsIndexToName = /* @__PURE__ */ new Map();
		const humanBones = (_a = defExtension.humanoid) == null ? void 0 : _a.humanBones;
		if (humanBones) Object.entries(humanBones).forEach(([name, bone]) => {
			const node = bone == null ? void 0 : bone.node;
			if (node != null) humanoidIndexToName.set(node, name);
		});
		const preset = (_b = defExtension.expressions) == null ? void 0 : _b.preset;
		if (preset) Object.entries(preset).forEach(([name, expression]) => {
			const node = expression == null ? void 0 : expression.node;
			if (node != null) expressionsIndexToName.set(node, name);
		});
		const custom = (_c = defExtension.expressions) == null ? void 0 : _c.custom;
		if (custom) Object.entries(custom).forEach(([name, expression]) => {
			const { node } = expression;
			expressionsIndexToName.set(node, name);
		});
		return {
			humanoidIndexToName,
			expressionsIndexToName,
			lookAtIndex: (_e = (_d = defExtension.lookAt) == null ? void 0 : _d.node) != null ? _e : null
		};
	}
	_createBoneWorldMatrixMap(gltf, defExtension) {
		return __async(this, null, function* () {
			var _a, _b;
			gltf.scene.updateWorldMatrix(false, true);
			const threeNodes = yield gltf.parser.getDependencies("node");
			const worldMatrixMap = /* @__PURE__ */ new Map();
			if (defExtension.humanoid == null) return worldMatrixMap;
			for (const [boneName, humanBone] of Object.entries(defExtension.humanoid.humanBones)) {
				const node = humanBone == null ? void 0 : humanBone.node;
				if (node != null) {
					const threeNode = threeNodes[node];
					worldMatrixMap.set(boneName, threeNode.matrixWorld);
					if (boneName === "hips") worldMatrixMap.set("hipsParent", (_b = (_a = threeNode.parent) == null ? void 0 : _a.matrixWorld) != null ? _b : MAT4_IDENTITY);
				}
			}
			return worldMatrixMap;
		});
	}
	_parseAnimation(animationClip, defAnimation, nodeMap, worldMatrixMap) {
		const tracks = animationClip.tracks;
		const defChannels = defAnimation.channels;
		const result = new VRMAnimation();
		result.duration = animationClip.duration;
		defChannels.forEach((channel, iChannel) => {
			const { node, path } = channel.target;
			const origTrack = tracks[iChannel];
			if (node == null) return;
			const boneName = nodeMap.humanoidIndexToName.get(node);
			if (boneName != null) {
				let parentBoneName = VRMHumanBoneParentMap[boneName];
				while (parentBoneName != null && worldMatrixMap.get(parentBoneName) == null) parentBoneName = VRMHumanBoneParentMap[parentBoneName];
				if (parentBoneName == null) parentBoneName = "hipsParent";
				if (path === "translation") if (boneName !== "hips") console.warn(`The loading animation contains a translation track for ${boneName}, which is not permitted in the VRMC_vrm_animation spec. ignoring the track`);
				else {
					const hipsParentWorldMatrix = worldMatrixMap.get("hipsParent");
					const trackValues = arrayChunk(origTrack.values, 3).flatMap((v) => _v3A6.fromArray(v).applyMatrix4(hipsParentWorldMatrix).toArray());
					const track = origTrack.clone();
					track.values = new Float32Array(trackValues);
					result.humanoidTracks.translation.set(boneName, track);
				}
				else if (path === "rotation") {
					const worldMatrix = worldMatrixMap.get(boneName);
					const parentWorldMatrix = worldMatrixMap.get(parentBoneName);
					worldMatrix.decompose(_v3A6, _quatA7, _v3A6);
					_quatA7.invert();
					parentWorldMatrix.decompose(_v3A6, _quatB4, _v3A6);
					const trackValues = arrayChunk(origTrack.values, 4).flatMap((q) => _quatC2.fromArray(q).premultiply(_quatB4).multiply(_quatA7).toArray());
					const track = origTrack.clone();
					track.values = new Float32Array(trackValues);
					result.humanoidTracks.rotation.set(boneName, track);
				} else throw new Error(`Invalid path "${path}"`);
				return;
			}
			const expressionName = nodeMap.expressionsIndexToName.get(node);
			if (expressionName != null) {
				if (path === "translation") {
					const times = origTrack.times;
					const values = new Float32Array(origTrack.values.length / 3);
					for (let i = 0; i < values.length; i++) values[i] = origTrack.values[3 * i];
					const newTrack = new NumberKeyframeTrack(`${expressionName}.weight`, times, values);
					if (vrmExpressionPresetNameSet.has(expressionName)) result.expressionTracks.preset.set(expressionName, newTrack);
					else result.expressionTracks.custom.set(expressionName, newTrack);
				} else throw new Error(`Invalid path "${path}"`);
				return;
			}
			if (node === nodeMap.lookAtIndex) if (path === "rotation") result.lookAtTrack = origTrack;
			else throw new Error(`Invalid path "${path}"`);
		});
		return result;
	}
};
/*!
* @pixiv/three-vrm-core v3.4.1
* The implementation of core features of VRM, for @pixiv/three-vrm
*
* Copyright (c) 2019-2025 pixiv Inc.
* @pixiv/three-vrm-core is distributed under MIT License
* https://github.com/pixiv/three-vrm/blob/release/LICENSE
*/
//#endregion
export { VRMAnimation, VRMAnimationLoaderPlugin, VRMLookAtQuaternionProxy, createVRMAnimationClip, createVRMAnimationExpressionTracks, createVRMAnimationHumanoidTracks, createVRMAnimationLookAtTrack };

//# sourceMappingURL=@pixiv_three-vrm-animation.js.map