@pixiv/three-vrm-core 1.0.0-beta.8 → 1.0.0

package/lib/three-vrm-core.module.js

@@ -1,5 +1,5 @@
 /*!
- * @pixiv/three-vrm-core v1.0.0-beta.8
+ * @pixiv/three-vrm-core v1.0.0
  * The implementation of core features of VRM, for @pixiv/three-vrm
  *
  * Copyright (c) 2020-2021 pixiv Inc.
@@ -18,7 +18,7 @@ class VRMExpression extends THREE.Object3D {
          */
         this.weight = 0.0;
         /**
-         * Interpret non-zero values as 1.
+         * Interpret values greater than 0.5 as 1.0, ortherwise 0.0.
          */
         this.isBinary = false;
         /**
@@ -96,7 +96,7 @@ class VRMExpression extends THREE.Object3D {
      */
     applyWeight(options) {
         var _a;
-        let actualWeight = this.isBinary ? (this.weight === 0.0 ? 0.0 : 1.0) : this.weight;
+        let actualWeight = this.isBinary ? (this.weight <= 0.5 ? 0.0 : 1.0) : this.weight;
         actualWeight *= (_a = options === null || options === void 0 ? void 0 : options.multiplier) !== null && _a !== void 0 ? _a : 1.0;
         this._binds.forEach((bind) => bind.applyWeight(actualWeight));
     }
@@ -525,6 +525,23 @@ class VRMExpressionManager {
     }
 }
 
+/* eslint-disable @typescript-eslint/naming-convention */
+const VRMExpressionMaterialColorType = {
+    Color: 'color',
+    EmissionColor: 'emissionColor',
+    ShadeColor: 'shadeColor',
+    MatcapColor: 'matcapColor',
+    RimColor: 'rimColor',
+    OutlineColor: 'outlineColor',
+};
+const v0ExpressionMaterialColorMap = {
+    _Color: VRMExpressionMaterialColorType.Color,
+    _EmissionColor: VRMExpressionMaterialColorType.EmissionColor,
+    _ShadeColor: VRMExpressionMaterialColorType.ShadeColor,
+    _RimColor: VRMExpressionMaterialColorType.RimColor,
+    _OutlineColor: VRMExpressionMaterialColorType.OutlineColor,
+};
+
 const _color = new THREE.Color();
 /**
  * A bind of expression influences to a material color.
@@ -547,7 +564,8 @@ class VRMExpressionMaterialColorBind {
         else {
             const target = material[propertyName];
             const initialValue = target.clone();
-            const deltaValue = this.targetValue.clone().sub(initialValue);
+            // 負の値を保持するためにColor.subを使わずに差分を計算する
+            const deltaValue = new THREE.Color(targetValue.r - initialValue.r, targetValue.g - initialValue.g, targetValue.b - initialValue.b);
             this._state = {
                 propertyName,
                 initialValue,
@@ -586,6 +604,9 @@ class VRMExpressionMaterialColorBind {
         }
     }
 }
+/**
+ * Mapping of property names from VRMC/materialColorBinds.type to three.js/Material.
+ */
 VRMExpressionMaterialColorBind._propertyNameMapMap = {
     isMeshStandardMaterial: {
         color: 'color',
@@ -597,9 +618,10 @@ VRMExpressionMaterialColorBind._propertyNameMapMap = {
     isMToonMaterial: {
         color: 'color',
         emissionColor: 'emissive',
-        outlineColor: 'outlineFactor',
-        rimColor: 'rimFactor',
-        shadeColor: 'shadeFactor',
+        outlineColor: 'outlineColorFactor',
+        matcapColor: 'matcapFactor',
+        rimColor: 'parametricRimColorFactor',
+        shadeColor: 'shadeColorFactor',
     },
 };
 
@@ -716,6 +738,10 @@ VRMExpressionTextureTransformBind._propertyNamesMap = {
     ],
 };
 
+/**
+ * Possible spec versions it recognizes.
+ */
+const POSSIBLE_SPEC_VERSIONS$4 = new Set(['1.0', '1.0-beta']);
 /**
  * A plugin of GLTFLoader that imports a {@link VRMExpressionManager} from a VRM extension of a GLTF.
  */
@@ -764,7 +790,8 @@ class VRMExpressionLoaderPlugin {
                 return null;
             }
             const specVersion = extension.specVersion;
-            if (specVersion !== '1.0-beta') {
+            if (!POSSIBLE_SPEC_VERSIONS$4.has(specVersion)) {
+                console.warn(`VRMExpressionLoaderPlugin: Unknown VRMC_vrm specVersion "${specVersion}"`);
                 return null;
             }
             const schemaExpressions = extension.expressions;
@@ -905,6 +932,7 @@ class VRMExpressionLoaderPlugin {
                 gltf.scene.add(expression);
                 expression.isBinary = (_b = schemaGroup.isBinary) !== null && _b !== void 0 ? _b : false;
                 // v0 doesn't have ignore properties
+                // Bind morphTarget
                 if (schemaGroup.binds) {
                     schemaGroup.binds.forEach((bind) => __awaiter(this, void 0, void 0, function* () {
                         var _c;
@@ -935,9 +963,62 @@ class VRMExpressionLoaderPlugin {
                         })));
                     }));
                 }
+                // Bind MaterialColor and TextureTransform
                 const materialValues = schemaGroup.materialValues;
                 if (materialValues && materialValues.length !== 0) {
-                    console.warn('Material binds of VRM 0.0 are not supported. Setup the model in VRM 1.0 and try again');
+                    materialValues.forEach((materialValue) => {
+                        if (materialValue.materialName === undefined ||
+                            materialValue.propertyName === undefined ||
+                            materialValue.targetValue === undefined) {
+                            return;
+                        }
+                        /**
+                         * アバターのオブジェクトに設定されているマテリアルの内から
+                         * materialValueで指定されているマテリアルを集める。
+                         *
+                         * 特定には名前を使用する。
+                         * アウトライン描画用のマテリアルも同時に集める。
+                         */
+                        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) => {
+                            // TextureTransformBind
+                            if (materialPropertyName === '_MainTex_ST') {
+                                const scale = new THREE.Vector2(materialValue.targetValue[0], materialValue.targetValue[1]);
+                                const offset = new THREE.Vector2(materialValue.targetValue[2], materialValue.targetValue[3]);
+                                expression.addBind(new VRMExpressionTextureTransformBind({
+                                    material,
+                                    scale,
+                                    offset,
+                                }));
+                                return;
+                            }
+                            // MaterialColorBind
+                            const materialColorType = v0ExpressionMaterialColorMap[materialPropertyName];
+                            if (materialColorType) {
+                                expression.addBind(new VRMExpressionMaterialColorBind({
+                                    material,
+                                    type: materialColorType,
+                                    targetValue: new THREE.Color(...materialValue.targetValue.slice(0, 3)),
+                                }));
+                                return;
+                            }
+                            console.warn(materialPropertyName + ' is not supported');
+                        });
+                    });
                 }
                 manager.registerExpression(expression);
             })));
@@ -967,15 +1048,6 @@ VRMExpressionLoaderPlugin.v0v1PresetNameMap = {
     neutral: 'neutral',
 };
 
-/* eslint-disable @typescript-eslint/naming-convention */
-const VRMExpressionMaterialColorType = {
-    Color: 'color',
-    EmissionColor: 'emissionColor',
-    ShadeColor: 'shadeColor',
-    RimColor: 'rimColor',
-    OutlineColor: 'outlineColor',
-};
-
 /* eslint-disable @typescript-eslint/naming-convention */
 const VRMExpressionOverrideType = {
     None: 'none',
@@ -1204,7 +1276,7 @@ class VRMFirstPerson {
         }
     }
     _isEraseTarget(bone) {
-        if (bone === this.humanoid.getBoneNode('head')) {
+        if (bone === this.humanoid.getRawBoneNode('head')) {
             return true;
         }
         else if (!bone.parent) {
@@ -1228,6 +1300,10 @@ VRMFirstPerson.DEFAULT_FIRSTPERSON_ONLY_LAYER = 9;
  */
 VRMFirstPerson.DEFAULT_THIRDPERSON_ONLY_LAYER = 10;
 
+/**
+ * Possible spec versions it recognizes.
+ */
+const POSSIBLE_SPEC_VERSIONS$3 = new Set(['1.0', '1.0-beta']);
 /**
  * A plugin of GLTFLoader that imports a {@link VRMFirstPerson} from a VRM extension of a GLTF.
  */
@@ -1289,7 +1365,8 @@ class VRMFirstPersonLoaderPlugin {
                 return null;
             }
             const specVersion = extension.specVersion;
-            if (specVersion !== '1.0-beta') {
+            if (!POSSIBLE_SPEC_VERSIONS$3.has(specVersion)) {
+                console.warn(`VRMFirstPersonLoaderPlugin: Unknown VRMC_vrm specVersion "${specVersion}"`);
                 return null;
             }
             const schemaFirstPerson = extension.firstPerson;
@@ -1362,7 +1439,109 @@ const VRMFirstPersonMeshAnnotationType = {
     FirstPersonOnly: 'firstPersonOnly',
 };
 
+const _v3A$4 = new THREE.Vector3();
+const _v3B$2 = new THREE.Vector3();
+const _quatA$5 = new THREE.Quaternion();
+class VRMHumanoidHelper extends THREE.Group {
+    constructor(humanoid) {
+        super();
+        this.vrmHumanoid = humanoid;
+        this._boneAxesMap = new Map();
+        Object.values(humanoid.humanBones).forEach((bone) => {
+            const helper = new THREE.AxesHelper(1.0);
+            helper.matrixAutoUpdate = false;
+            helper.material.depthTest = false;
+            helper.material.depthWrite = false;
+            this.add(helper);
+            // TODO: type assertion is not needed in later versions of TypeScript
+            this._boneAxesMap.set(bone, helper);
+        });
+    }
+    dispose() {
+        Array.from(this._boneAxesMap.values()).forEach((axes) => {
+            axes.geometry.dispose();
+            axes.material.dispose();
+        });
+    }
+    updateMatrixWorld(force) {
+        Array.from(this._boneAxesMap.entries()).forEach(([bone, axes]) => {
+            bone.node.updateWorldMatrix(true, false);
+            bone.node.matrixWorld.decompose(_v3A$4, _quatA$5, _v3B$2);
+            const scale = _v3A$4.set(0.1, 0.1, 0.1).divide(_v3B$2);
+            axes.matrix.copy(bone.node.matrixWorld).scale(scale);
+        });
+        super.updateMatrixWorld(force);
+    }
+}
+
 /* eslint-disable @typescript-eslint/naming-convention */
+/**
+ * The list of {@link VRMHumanBoneName}. Dependency aware.
+ */
+const VRMHumanBoneList = [
+    'hips',
+    'spine',
+    'chest',
+    'upperChest',
+    'neck',
+    'head',
+    'leftEye',
+    'rightEye',
+    'jaw',
+    'leftUpperLeg',
+    'leftLowerLeg',
+    'leftFoot',
+    'leftToes',
+    'rightUpperLeg',
+    'rightLowerLeg',
+    'rightFoot',
+    'rightToes',
+    'leftShoulder',
+    'leftUpperArm',
+    'leftLowerArm',
+    'leftHand',
+    'rightShoulder',
+    'rightUpperArm',
+    'rightLowerArm',
+    'rightHand',
+    'leftThumbMetacarpal',
+    'leftThumbProximal',
+    'leftThumbDistal',
+    'leftIndexProximal',
+    'leftIndexIntermediate',
+    'leftIndexDistal',
+    'leftMiddleProximal',
+    'leftMiddleIntermediate',
+    'leftMiddleDistal',
+    'leftRingProximal',
+    'leftRingIntermediate',
+    'leftRingDistal',
+    'leftLittleProximal',
+    'leftLittleIntermediate',
+    'leftLittleDistal',
+    'rightThumbMetacarpal',
+    'rightThumbProximal',
+    'rightThumbDistal',
+    'rightIndexProximal',
+    'rightIndexIntermediate',
+    'rightIndexDistal',
+    'rightMiddleProximal',
+    'rightMiddleIntermediate',
+    'rightMiddleDistal',
+    'rightRingProximal',
+    'rightRingIntermediate',
+    'rightRingDistal',
+    'rightLittleProximal',
+    'rightLittleIntermediate',
+    'rightLittleDistal',
+];
+
+/* eslint-disable @typescript-eslint/naming-convention */
+/**
+ * The names of {@link VRMHumanoid} bone names.
+ *
+ * Ref: https://github.com/vrm-c/vrm-specification/blob/master/specification/VRMC_vrm-1.0/humanoid.md
+ */
 const VRMHumanBoneName = {
     Hips: 'hips',
     Spine: 'spine',
@@ -1389,8 +1568,8 @@ const VRMHumanBoneName = {
     RightUpperArm: 'rightUpperArm',
     RightLowerArm: 'rightLowerArm',
     RightHand: 'rightHand',
+    LeftThumbMetacarpal: 'leftThumbMetacarpal',
     LeftThumbProximal: 'leftThumbProximal',
-    LeftThumbIntermediate: 'leftThumbIntermediate',
     LeftThumbDistal: 'leftThumbDistal',
     LeftIndexProximal: 'leftIndexProximal',
     LeftIndexIntermediate: 'leftIndexIntermediate',
@@ -1404,8 +1583,8 @@ const VRMHumanBoneName = {
     LeftLittleProximal: 'leftLittleProximal',
     LeftLittleIntermediate: 'leftLittleIntermediate',
     LeftLittleDistal: 'leftLittleDistal',
+    RightThumbMetacarpal: 'rightThumbMetacarpal',
     RightThumbProximal: 'rightThumbProximal',
-    RightThumbIntermediate: 'rightThumbIntermediate',
     RightThumbDistal: 'rightThumbDistal',
     RightIndexProximal: 'rightIndexProximal',
     RightIndexIntermediate: 'rightIndexIntermediate',
@@ -1421,6 +1600,70 @@ const VRMHumanBoneName = {
     RightLittleDistal: 'rightLittleDistal',
 };
 
+/* eslint-disable @typescript-eslint/naming-convention */
+/**
+ * An object that maps from {@link VRMHumanBoneName} to its parent {@link VRMHumanBoneName}.
+ *
+ * Ref: https://github.com/vrm-c/vrm-specification/blob/master/specification/VRMC_vrm-1.0/humanoid.md
+ */
+const 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: 'chest',
+    leftUpperArm: 'leftShoulder',
+    leftLowerArm: 'leftUpperArm',
+    leftHand: 'leftLowerArm',
+    rightShoulder: 'chest',
+    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',
+};
+
 /**
  * A compat function for `Quaternion.invert()` / `Quaternion.inverse()`.
  * `Quaternion.invert()` is introduced in r123 and `Quaternion.inverse()` emits a warning.
@@ -1437,37 +1680,20 @@ function quatInvertCompat(target) {
     return target;
 }
 
-const _v3A$2 = new THREE.Vector3();
-const _quatA$2 = new THREE.Quaternion();
+const _v3A$3 = new THREE.Vector3();
+const _quatA$4 = new THREE.Quaternion();
 /**
- * A class represents a humanoid of a VRM.
+ * A class represents the Rig of a VRM.
  */
-class VRMHumanoid {
+class VRMRig {
     /**
      * Create a new {@link VRMHumanoid}.
-     * @param boneArray A {@link VRMHumanBones} contains all the bones of the new humanoid
+     * @param humanBones A {@link VRMHumanBones} contains all the bones of the new humanoid
      */
     constructor(humanBones) {
         this.humanBones = humanBones;
         this.restPose = this.getAbsolutePose();
     }
-    /**
-     * Copy the given {@link VRMHumanoid} into this one.
-     * @param source The {@link VRMHumanoid} you want to copy
-     * @returns this
-     */
-    copy(source) {
-        this.humanBones = source.humanBones;
-        this.restPose = source.restPose;
-        return this;
-    }
-    /**
-     * Returns a clone of this {@link VRMHumanoid}.
-     * @returns Copied {@link VRMHumanoid}
-     */
-    clone() {
-        return new VRMHumanoid(this.humanBones).copy(this);
-    }
     /**
      * Return the current absolute pose of this humanoid as a {@link VRMPose}.
      * Note that the output result will contain initial state of the VRM and not compatible between different models.
@@ -1483,12 +1709,12 @@ class VRMHumanoid {
                 return;
             }
             // Get the position / rotation from the node
-            _v3A$2.copy(node.position);
-            _quatA$2.copy(node.quaternion);
+            _v3A$3.copy(node.position);
+            _quatA$4.copy(node.quaternion);
             // Convert to raw arrays
             pose[vrmBoneName] = {
-                position: _v3A$2.toArray(),
-                rotation: _quatA$2.toArray(),
+                position: _v3A$3.toArray(),
+                rotation: _quatA$4.toArray(),
             };
         });
         return pose;
@@ -1508,22 +1734,22 @@ class VRMHumanoid {
                 return;
             }
             // Take a diff from restPose
-            _v3A$2.set(0, 0, 0);
-            _quatA$2.identity();
+            _v3A$3.set(0, 0, 0);
+            _quatA$4.identity();
             const restState = this.restPose[boneName];
             if (restState === null || restState === void 0 ? void 0 : restState.position) {
-                _v3A$2.fromArray(restState.position).negate();
+                _v3A$3.fromArray(restState.position).negate();
             }
             if (restState === null || restState === void 0 ? void 0 : restState.rotation) {
-                quatInvertCompat(_quatA$2.fromArray(restState.rotation));
+                quatInvertCompat(_quatA$4.fromArray(restState.rotation));
             }
             // Get the position / rotation from the node
-            _v3A$2.add(node.position);
-            _quatA$2.premultiply(node.quaternion);
+            _v3A$3.add(node.position);
+            _quatA$4.premultiply(node.quaternion);
             // Convert to raw arrays
             pose[boneName] = {
-                position: _v3A$2.toArray(),
-                rotation: _quatA$2.toArray(),
+                position: _v3A$3.toArray(),
+                rotation: _quatA$4.toArray(),
             };
         });
         return pose;
@@ -1553,13 +1779,13 @@ class VRMHumanoid {
             if (state === null || state === void 0 ? void 0 : state.position) {
                 node.position.fromArray(state.position);
                 if (restState.position) {
-                    node.position.add(_v3A$2.fromArray(restState.position));
+                    node.position.add(_v3A$3.fromArray(restState.position));
                 }
             }
             if (state === null || state === void 0 ? void 0 : state.rotation) {
                 node.quaternion.fromArray(state.rotation);
                 if (restState.rotation) {
-                    node.quaternion.multiply(_quatA$2.fromArray(restState.rotation));
+                    node.quaternion.multiply(_quatA$4.fromArray(restState.rotation));
                 }
             }
         });
@@ -1601,6 +1827,343 @@ class VRMHumanoid {
     }
 }
 
+const _v3A$2 = new THREE.Vector3();
+const _quatA$3 = new THREE.Quaternion();
+/**
+ * A class represents the normalized Rig of a VRM.
+ */
+class VRMHumanoidRig extends VRMRig {
+    constructor(humanoid) {
+        const { rigBones, root, parentWorldRotations, boneRotations } = VRMHumanoidRig._setupTransforms(humanoid);
+        super(rigBones);
+        this.original = humanoid;
+        this.root = root;
+        this._parentWorldRotations = parentWorldRotations;
+        this._boneRotations = boneRotations;
+    }
+    static _setupTransforms(modelRig) {
+        const root = new THREE.Object3D();
+        root.name = 'VRMHumanoidRig';
+        // store boneWorldPositions and boneWorldRotations
+        const boneWorldPositions = {};
+        const boneWorldRotations = {};
+        const boneRotations = {};
+        VRMHumanBoneList.forEach((boneName) => {
+            const boneNode = modelRig.getBoneNode(boneName);
+            if (boneNode) {
+                const boneWorldPosition = new THREE.Vector3();
+                const boneWorldRotation = new THREE.Quaternion();
+                boneNode.updateWorldMatrix(true, false);
+                boneNode.matrixWorld.decompose(boneWorldPosition, boneWorldRotation, _v3A$2);
+                boneWorldPositions[boneName] = boneWorldPosition;
+                boneWorldRotations[boneName] = boneWorldRotation;
+                boneRotations[boneName] = boneNode.quaternion.clone();
+            }
+        });
+        // build rig hierarchy + store parentWorldRotations
+        const parentWorldRotations = {};
+        const rigBones = {};
+        VRMHumanBoneList.forEach((boneName) => {
+            var _a;
+            const boneNode = modelRig.getBoneNode(boneName);
+            if (boneNode) {
+                const boneWorldPosition = boneWorldPositions[boneName];
+                // see the nearest parent position
+                let currentBoneName = boneName;
+                let parentWorldPosition;
+                let parentWorldRotation;
+                while (parentWorldPosition == null) {
+                    currentBoneName = VRMHumanBoneParentMap[currentBoneName];
+                    if (currentBoneName == null) {
+                        break;
+                    }
+                    parentWorldPosition = boneWorldPositions[currentBoneName];
+                    parentWorldRotation = boneWorldRotations[currentBoneName];
+                }
+                // add to hierarchy
+                const rigBoneNode = new THREE.Object3D();
+                rigBoneNode.name = 'Normalized_' + boneNode.name;
+                const parentRigBoneNode = (currentBoneName ? (_a = rigBones[currentBoneName]) === null || _a === void 0 ? void 0 : _a.node : root);
+                parentRigBoneNode.add(rigBoneNode);
+                rigBoneNode.position.copy(boneWorldPosition);
+                if (parentWorldPosition) {
+                    rigBoneNode.position.sub(parentWorldPosition);
+                }
+                rigBones[boneName] = { node: rigBoneNode };
+                // store parentWorldRotation
+                parentWorldRotations[boneName] = parentWorldRotation !== null && parentWorldRotation !== void 0 ? parentWorldRotation : new THREE.Quaternion();
+            }
+        });
+        return {
+            rigBones: rigBones,
+            root,
+            parentWorldRotations,
+            boneRotations,
+        };
+    }
+    /**
+     * Update this humanoid rig.
+     */
+    update() {
+        VRMHumanBoneList.forEach((boneName) => {
+            const boneNode = this.original.getBoneNode(boneName);
+            if (boneNode != null) {
+                const rigBoneNode = this.getBoneNode(boneName);
+                const parentWorldRotation = this._parentWorldRotations[boneName];
+                const invParentWorldRotation = _quatA$3.copy(parentWorldRotation).invert();
+                const boneRotation = this._boneRotations[boneName];
+                boneNode.quaternion
+                    .copy(rigBoneNode.quaternion)
+                    .multiply(parentWorldRotation)
+                    .premultiply(invParentWorldRotation)
+                    .multiply(boneRotation);
+                // Move the mass center of the VRM
+                if (boneName === 'hips') {
+                    const boneWorldPosition = rigBoneNode.getWorldPosition(new THREE.Vector3());
+                    const parentWorldMatrix = boneNode.parent.matrixWorld;
+                    const localPosition = boneWorldPosition.applyMatrix4(parentWorldMatrix.invert());
+                    boneNode.position.copy(localPosition);
+                }
+            }
+        });
+    }
+}
+
+/**
+ * A class represents a humanoid of a VRM.
+ */
+class VRMHumanoid {
+    /**
+     * Create a new {@link VRMHumanoid}.
+     * @param humanBones A {@link VRMHumanBones} contains all the bones of the new humanoid
+     * @param autoUpdateHumanBones Whether it copies pose from normalizedHumanBones to rawHumanBones on {@link update}. `true` by default.
+     */
+    constructor(humanBones, options) {
+        var _a;
+        this.autoUpdateHumanBones = (_a = options === null || options === void 0 ? void 0 : options.autoUpdateHumanBones) !== null && _a !== void 0 ? _a : true;
+        this._rawHumanBones = new VRMRig(humanBones);
+        this._normalizedHumanBones = new VRMHumanoidRig(this._rawHumanBones);
+    }
+    /**
+     * @deprecated Deprecated. Use either {@link rawRestPose} or {@link normalizedRestPose} instead.
+     */
+    get restPose() {
+        console.warn('VRMHumanoid: restPose is deprecated. Use either rawRestPose or normalizedRestPose instead.');
+        return this.rawRestPose;
+    }
+    /**
+     * A {@link VRMPose} of its raw human bones that is its default state.
+     * Note that it's not compatible with {@link setRawPose} and {@link getRawPose}, since it contains non-relative values of each local transforms.
+     */
+    get rawRestPose() {
+        return this._rawHumanBones.restPose;
+    }
+    /**
+     * A {@link VRMPose} of its normalized human bones that is its default state.
+     * Note that it's not compatible with {@link setNormalizedPose} and {@link getNormalizedPose}, since it contains non-relative values of each local transforms.
+     */
+    get normalizedRestPose() {
+        return this._normalizedHumanBones.restPose;
+    }
+    /**
+     * A map from {@link VRMHumanBoneName} to raw {@link VRMHumanBone}s.
+     */
+    get humanBones() {
+        // an alias of `rawHumanBones`
+        return this._rawHumanBones.humanBones;
+    }
+    /**
+     * A map from {@link VRMHumanBoneName} to raw {@link VRMHumanBone}s.
+     */
+    get rawHumanBones() {
+        return this._rawHumanBones.humanBones;
+    }
+    /**
+     * A map from {@link VRMHumanBoneName} to normalized {@link VRMHumanBone}s.
+     */
+    get normalizedHumanBones() {
+        return this._normalizedHumanBones.humanBones;
+    }
+    /**
+     * The root of normalized {@link VRMHumanBone}s.
+     */
+    get normalizedHumanBonesRoot() {
+        return this._normalizedHumanBones.root;
+    }
+    /**
+     * Copy the given {@link VRMHumanoid} into this one.
+     * @param source The {@link VRMHumanoid} you want to copy
+     * @returns this
+     */
+    copy(source) {
+        this.autoUpdateHumanBones = source.autoUpdateHumanBones;
+        this._rawHumanBones = new VRMRig(source.humanBones);
+        this._normalizedHumanBones = new VRMHumanoidRig(this._rawHumanBones);
+        return this;
+    }
+    /**
+     * Returns a clone of this {@link VRMHumanoid}.
+     * @returns Copied {@link VRMHumanoid}
+     */
+    clone() {
+        return new VRMHumanoid(this.humanBones, { autoUpdateHumanBones: this.autoUpdateHumanBones }).copy(this);
+    }
+    /**
+     * @deprecated Deprecated. Use either {@link getRawAbsolutePose} or {@link getNormalizedAbsolutePose} instead.
+     */
+    getAbsolutePose() {
+        console.warn('VRMHumanoid: getAbsolutePose() is deprecated. Use either getRawAbsolutePose() or getNormalizedAbsolutePose() instead.');
+        return this.getRawAbsolutePose();
+    }
+    /**
+     * Return the current absolute pose of this raw human bones as a {@link VRMPose}.
+     * Note that the output result will contain initial state of the VRM and not compatible between different models.
+     * You might want to use {@link getRawPose} instead.
+     */
+    getRawAbsolutePose() {
+        return this._rawHumanBones.getAbsolutePose();
+    }
+    /**
+     * Return the current absolute pose of this normalized human bones as a {@link VRMPose}.
+     * Note that the output result will contain initial state of the VRM and not compatible between different models.
+     * You might want to use {@link getNormalizedPose} instead.
+     */
+    getNormalizedAbsolutePose() {
+        return this._normalizedHumanBones.getAbsolutePose();
+    }
+    /**
+     * @deprecated Deprecated. Use either {@link getRawPose} or {@link getNormalizedPose} instead.
+     */
+    getPose() {
+        console.warn('VRMHumanoid: getPose() is deprecated. Use either getRawPose() or getNormalizedPose() instead.');
+        return this.getRawPose();
+    }
+    /**
+     * Return the current pose of raw human bones as a {@link VRMPose}.
+     *
+     * Each transform is a local transform relative from rest pose (T-pose).
+     */
+    getRawPose() {
+        return this._rawHumanBones.getPose();
+    }
+    /**
+     * Return the current pose of normalized human bones as a {@link VRMPose}.
+     *
+     * Each transform is a local transform relative from rest pose (T-pose).
+     */
+    getNormalizedPose() {
+        return this._normalizedHumanBones.getPose();
+    }
+    /**
+     * @deprecated Deprecated. Use either {@link setRawPose} or {@link setNormalizedPose} instead.
+     */
+    setPose(poseObject) {
+        console.warn('VRMHumanoid: setPose() is deprecated. Use either setRawPose() or setNormalizedPose() instead.');
+        return this.setRawPose(poseObject);
+    }
+    /**
+     * Let the raw human bones do a specified pose.
+     *
+     * Each transform have to be a local transform relative from rest pose (T-pose).
+     * You can pass what you got from {@link getRawPose}.
+     *
+     * If you are using {@link autoUpdateHumanBones}, you might want to use {@link setNormalizedPose} instead.
+     *
+     * @param poseObject A {@link VRMPose} that represents a single pose
+     */
+    setRawPose(poseObject) {
+        return this._rawHumanBones.setPose(poseObject);
+    }
+    /**
+     * Let the normalized human bones do a specified pose.
+     *
+     * Each transform have to be a local transform relative from rest pose (T-pose).
+     * You can pass what you got from {@link getNormalizedPose}.
+     *
+     * @param poseObject A {@link VRMPose} that represents a single pose
+     */
+    setNormalizedPose(poseObject) {
+        return this._normalizedHumanBones.setPose(poseObject);
+    }
+    /**
+     * @deprecated Deprecated. Use either {@link resetRawPose} or {@link resetNormalizedPose} instead.
+     */
+    resetPose() {
+        console.warn('VRMHumanoid: resetPose() is deprecated. Use either resetRawPose() or resetNormalizedPose() instead.');
+        return this.resetRawPose();
+    }
+    /**
+     * Reset the raw humanoid to its rest pose.
+     *
+     * If you are using {@link autoUpdateHumanBones}, you might want to use {@link resetNormalizedPose} instead.
+     */
+    resetRawPose() {
+        return this._rawHumanBones.resetPose();
+    }
+    /**
+     * Reset the normalized humanoid to its rest pose.
+     */
+    resetNormalizedPose() {
+        return this._rawHumanBones.resetPose();
+    }
+    /**
+     * @deprecated Deprecated. Use either {@link getRawBone} or {@link getNormalizedBone} instead.
+     */
+    getBone(name) {
+        console.warn('VRMHumanoid: getBone() is deprecated. Use either getRawBone() or getNormalizedBone() instead.');
+        return this.getRawBone(name);
+    }
+    /**
+     * Return a raw {@link VRMHumanBone} bound to a specified {@link VRMHumanBoneName}.
+     *
+     * @param name Name of the bone you want
+     */
+    getRawBone(name) {
+        return this._rawHumanBones.getBone(name);
+    }
+    /**
+     * Return a normalized {@link VRMHumanBone} bound to a specified {@link VRMHumanBoneName}.
+     *
+     * @param name Name of the bone you want
+     */
+    getNormalizedBone(name) {
+        return this._normalizedHumanBones.getBone(name);
+    }
+    /**
+     * @deprecated Deprecated. Use either {@link getRawBoneNode} or {@link getNormalizedBoneNode} instead.
+     */
+    getBoneNode(name) {
+        console.warn('VRMHumanoid: getBoneNode() is deprecated. Use either getRawBoneNode() or getNormalizedBoneNode() instead.');
+        return this.getRawBoneNode(name);
+    }
+    /**
+     * Return a raw bone as a `THREE.Object3D` bound to a specified {@link VRMHumanBoneName}.
+     *
+     * @param name Name of the bone you want
+     */
+    getRawBoneNode(name) {
+        return this._rawHumanBones.getBoneNode(name);
+    }
+    /**
+     * Return a normalized bone as a `THREE.Object3D` bound to a specified {@link VRMHumanBoneName}.
+     *
+     * @param name Name of the bone you want
+     */
+    getNormalizedBoneNode(name) {
+        return this._normalizedHumanBones.getBoneNode(name);
+    }
+    /**
+     * Update the humanoid component.
+     *
+     * If {@link autoUpdateHumanBones} is `true`, it transfers the pose of normalized human bones to raw human bones.
+     */
+    update() {
+        if (this.autoUpdateHumanBones) {
+            this._normalizedHumanBones.update();
+        }
+    }
+}
+
 /* eslint-disable @typescript-eslint/naming-convention */
 const VRMRequiredHumanBoneName = {
     Hips: 'hips',
@@ -1620,12 +2183,27 @@ const VRMRequiredHumanBoneName = {
     RightHand: 'rightHand',
 };
 
+/**
+ * Possible spec versions it recognizes.
+ */
+const POSSIBLE_SPEC_VERSIONS$2 = new Set(['1.0', '1.0-beta']);
+/**
+ * A map from old thumb bone names to new thumb bone names
+ */
+const thumbBoneNameMap = {
+    leftThumbProximal: 'leftThumbMetacarpal',
+    leftThumbIntermediate: 'leftThumbProximal',
+    rightThumbProximal: 'rightThumbMetacarpal',
+    rightThumbIntermediate: 'rightThumbProximal',
+};
 /**
  * A plugin of GLTFLoader that imports a {@link VRMHumanoid} from a VRM extension of a GLTF.
  */
 class VRMHumanoidLoaderPlugin {
-    constructor(parser) {
+    constructor(parser, options) {
         this.parser = parser;
+        this.helperRoot = options === null || options === void 0 ? void 0 : options.helperRoot;
+        this.autoUpdateHumanBones = options === null || options === void 0 ? void 0 : options.autoUpdateHumanBones;
     }
     get name() {
         // We should use the extension name instead but we have multiple plugins for an extension...
@@ -1668,18 +2246,33 @@ class VRMHumanoidLoaderPlugin {
                 return null;
             }
             const specVersion = extension.specVersion;
-            if (specVersion !== '1.0-beta') {
+            if (!POSSIBLE_SPEC_VERSIONS$2.has(specVersion)) {
+                console.warn(`VRMHumanoidLoaderPlugin: Unknown VRMC_vrm specVersion "${specVersion}"`);
                 return null;
             }
             const schemaHumanoid = extension.humanoid;
             if (!schemaHumanoid) {
                 return null;
             }
+            /**
+             * compat: 1.0-beta thumb bone names
+             *
+             * `true` if `leftThumbIntermediate` or `rightThumbIntermediate` exists
+             */
+            const existsPreviousThumbName = schemaHumanoid.humanBones.leftThumbIntermediate != null ||
+                schemaHumanoid.humanBones.rightThumbIntermediate != null;
             const humanBones = {};
             if (schemaHumanoid.humanBones != null) {
                 yield Promise.all(Object.entries(schemaHumanoid.humanBones).map(([boneNameString, schemaHumanBone]) => __awaiter(this, void 0, void 0, function* () {
-                    const boneName = boneNameString;
+                    let boneName = boneNameString;
                     const index = schemaHumanBone.node;
+                    // compat: 1.0-beta previous thumb bone names
+                    if (existsPreviousThumbName) {
+                        const thumbBoneName = thumbBoneNameMap[boneName];
+                        if (thumbBoneName != null) {
+                            boneName = thumbBoneName;
+                        }
+                    }
                     const node = yield this.parser.getDependency('node', index);
                     // if the specified node does not exist, emit a warning
                     if (node == null) {
@@ -1690,7 +2283,16 @@ class VRMHumanoidLoaderPlugin {
                     humanBones[boneName] = { node };
                 })));
             }
-            return new VRMHumanoid(this._ensureRequiredBonesExist(humanBones));
+            const humanoid = new VRMHumanoid(this._ensureRequiredBonesExist(humanBones), {
+                autoUpdateHumanBones: this.autoUpdateHumanBones,
+            });
+            gltf.scene.add(humanoid.normalizedHumanBonesRoot);
+            if (this.helperRoot) {
+                const helper = new VRMHumanoidHelper(humanoid);
+                this.helperRoot.add(helper);
+                helper.renderOrder = this.helperRoot.renderOrder;
+            }
+            return humanoid;
         });
     }
     _v0Import(gltf) {
@@ -1719,17 +2321,29 @@ class VRMHumanoidLoaderPlugin {
                         console.warn(`A glTF node bound to the humanoid bone ${boneName} (index = ${index}) does not exist`);
                         return;
                     }
+                    // map to new bone name
+                    const thumbBoneName = thumbBoneNameMap[boneName];
+                    const newBoneName = (thumbBoneName !== null && thumbBoneName !== void 0 ? thumbBoneName : boneName);
                     // v0 VRMs might have a multiple nodes attached to a single bone...
                     // so if there already is an entry in the `humanBones`, show a warning and ignore it
-                    if (humanBones[boneName] != null) {
-                        console.warn(`Multiple bone entries for ${boneName} detected (index = ${index}), ignoring duplicated entries.`);
+                    if (humanBones[newBoneName] != null) {
+                        console.warn(`Multiple bone entries for ${newBoneName} detected (index = ${index}), ignoring duplicated entries.`);
                         return;
                     }
                     // set to the `humanBones`
-                    humanBones[boneName] = { node };
+                    humanBones[newBoneName] = { node };
                 })));
             }
-            return new VRMHumanoid(this._ensureRequiredBonesExist(humanBones));
+            const humanoid = new VRMHumanoid(this._ensureRequiredBonesExist(humanBones), {
+                autoUpdateHumanBones: this.autoUpdateHumanBones,
+            });
+            gltf.scene.add(humanoid.normalizedHumanBonesRoot);
+            if (this.helperRoot) {
+                const helper = new VRMHumanoidHelper(humanoid);
+                this.helperRoot.add(helper);
+                helper.renderOrder = this.helperRoot.renderOrder;
+            }
+            return humanoid;
         });
     }
     /**
@@ -1847,8 +2461,8 @@ class LineAndSphereBufferGeometry extends THREE.BufferGeometry {
     }
 }
 
-const _quatA$1 = new THREE.Quaternion();
-const _quatB$1 = new THREE.Quaternion();
+const _quatA$2 = new THREE.Quaternion();
+const _quatB$2 = new THREE.Quaternion();
 const _v3A$1 = new THREE.Vector3();
 const _v3B$1 = new THREE.Vector3();
 const SQRT_2_OVER_2 = Math.sqrt(2.0) / 2.0;
@@ -1909,27 +2523,34 @@ class VRMLookAtHelper extends THREE.Group {
         this._lineTarget.material.dispose();
     }
     updateMatrixWorld(force) {
-        this.vrmLookAt.getLookAtWorldPosition(_v3A$1);
-        this.vrmLookAt.getLookAtWorldQuaternion(_quatA$1);
-        const yaw = this.vrmLookAt.euler.y;
-        const pitch = this.vrmLookAt.euler.x;
+        // update geometries
+        const yaw = THREE.MathUtils.DEG2RAD * this.vrmLookAt.yaw;
         this._meshYaw.geometry.theta = yaw;
         this._meshYaw.geometry.update();
-        this._meshYaw.position.copy(_v3A$1);
-        this._meshYaw.quaternion.copy(_quatA$1);
+        const pitch = THREE.MathUtils.DEG2RAD * this.vrmLookAt.pitch;
         this._meshPitch.geometry.theta = pitch;
         this._meshPitch.geometry.update();
+        // get world position and quaternion
+        this.vrmLookAt.getLookAtWorldPosition(_v3A$1);
+        this.vrmLookAt.getLookAtWorldQuaternion(_quatA$2);
+        // calculate rotation using faceFront
+        _quatA$2.multiply(this.vrmLookAt.getFaceFrontQuaternion(_quatB$2));
+        // set transform to meshes
+        this._meshYaw.position.copy(_v3A$1);
+        this._meshYaw.quaternion.copy(_quatA$2);
         this._meshPitch.position.copy(_v3A$1);
-        this._meshPitch.quaternion.copy(_quatA$1);
-        this._meshPitch.quaternion.multiply(_quatB$1.setFromAxisAngle(VEC3_POSITIVE_Y, yaw));
+        this._meshPitch.quaternion.copy(_quatA$2);
+        this._meshPitch.quaternion.multiply(_quatB$2.setFromAxisAngle(VEC3_POSITIVE_Y, yaw));
         this._meshPitch.quaternion.multiply(QUAT_XY_CW90);
-        const target = this.vrmLookAt.target;
-        if (target != null) {
+        // update target line and sphere
+        const { target, autoUpdate } = this.vrmLookAt;
+        if (target != null && autoUpdate) {
             target.getWorldPosition(_v3B$1).sub(_v3A$1);
             this._lineTarget.geometry.tail.copy(_v3B$1);
             this._lineTarget.geometry.update();
             this._lineTarget.position.copy(_v3A$1);
         }
+        // apply transform to meshes
         super.updateMatrixWorld(force);
     }
 }
@@ -1947,11 +2568,45 @@ function getWorldQuaternionLite(object, out) {
     return out;
 }
 
+/**
+ * Calculate azimuth / altitude angles from a vector.
+ *
+ * This returns a difference of angles from (1, 0, 0).
+ * Azimuth represents an angle around Y axis.
+ * Altitude represents an angle around Z axis.
+ * It is rotated in intrinsic Y-Z order.
+ *
+ * @param vector The vector
+ * @returns A tuple contains two angles, `[ azimuth, altitude ]`
+ */
+function calcAzimuthAltitude(vector) {
+    return [Math.atan2(-vector.z, vector.x), Math.atan2(vector.y, Math.sqrt(vector.x * vector.x + vector.z * vector.z))];
+}
+
+/**
+ * Make sure the angle is within -PI to PI.
+ *
+ * @example
+ * ```js
+ * sanitizeAngle(1.5 * Math.PI) // -0.5 * PI
+ * ```
+ *
+ * @param angle An input angle
+ */
+function sanitizeAngle(angle) {
+    const roundTurn = Math.round(angle / 2.0 / Math.PI);
+    return angle - 2.0 * Math.PI * roundTurn;
+}
+
+const VEC3_POSITIVE_Z$1 = new THREE.Vector3(0.0, 0.0, 1.0);
 const _v3A = new THREE.Vector3();
 const _v3B = new THREE.Vector3();
 const _v3C = new THREE.Vector3();
-const _quatA = new THREE.Quaternion();
-const _quatB = new THREE.Quaternion();
+const _quatA$1 = new THREE.Quaternion();
+const _quatB$1 = new THREE.Quaternion();
+const _quatC = new THREE.Quaternion();
+const _quatD = new THREE.Quaternion();
+const _eulerA$1 = new THREE.Euler();
 /**
  * A class controls eye gaze movements of a VRM.
  */
@@ -1969,6 +2624,7 @@ class VRMLookAt {
         this.offsetFromHeadBone = new THREE.Vector3();
         /**
          * If this is true, the LookAt will be updated automatically by calling {@link update}, towarding the direction to the {@link target}.
+         * `true` by default.
          *
          * See also: {@link target}
          */
@@ -1979,15 +2635,54 @@ class VRMLookAt {
          * You usually don't want to touch this.
          */
         this.faceFront = new THREE.Vector3(0.0, 0.0, 1.0);
-        this._euler = new THREE.Euler(0.0, 0.0, 0.0, VRMLookAt.EULER_ORDER);
         this.humanoid = humanoid;
         this.applier = applier;
+        this._yaw = 0.0;
+        this._pitch = 0.0;
+        this._needsUpdate = true;
+        this._restHeadWorldQuaternion = this.getLookAtWorldQuaternion(new THREE.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 euler direction.
+     * Its current angle around X axis, in degree.
+     */
+    set pitch(value) {
+        this._pitch = value;
+        this._needsUpdate = true;
+    }
+    /**
+     * @deprecated Use {@link getEuler} instead.
      */
     get euler() {
-        return this._euler.clone();
+        console.warn('VRMLookAt: euler is deprecated. use getEuler() instead.');
+        return this.getEuler(new THREE.Euler());
+    }
+    /**
+     * Get its yaw-pitch angles as an `Euler`.
+     * Does NOT consider {@link faceFront}.
+     *
+     * @param target The target euler
+     */
+    getEuler(target) {
+        return target.set(THREE.MathUtils.DEG2RAD * this._pitch, THREE.MathUtils.DEG2RAD * this._yaw, 0.0, 'YXZ');
     }
     /**
      * Copy the given {@link VRMLookAt} into this one.
@@ -2019,8 +2714,9 @@ class VRMLookAt {
      * Reset the lookAt direction to initial direction.
      */
     reset() {
-        this._euler.set(0.0, 0.0, 0.0);
-        this.applier.lookAt(this._euler);
+        this._yaw = 0.0;
+        this._pitch = 0.0;
+        this._needsUpdate = true;
     }
     /**
      * Get its head position in world coordinate.
@@ -2028,36 +2724,68 @@ class VRMLookAt {
      * @param target A target `THREE.Vector3`
      */
     getLookAtWorldPosition(target) {
-        const head = this.humanoid.getBoneNode('head');
+        const head = this.humanoid.getRawBoneNode('head');
         return target.copy(this.offsetFromHeadBone).applyMatrix4(head.matrixWorld);
     }
     /**
-     * Get its LookAt orientation in world coordinate.
+     * Get its head rotation in world coordinate.
+     * Does NOT consider {@link faceFront}.
      *
-     * @param target A target `THREE.Vector3`
+     * @param target A target `THREE.Quaternion`
      */
     getLookAtWorldQuaternion(target) {
-        const head = this.humanoid.getBoneNode('head');
+        const head = this.humanoid.getRawBoneNode('head');
         return getWorldQuaternionLite(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$1) < 0.01) {
+            return target.copy(this._restHeadWorldQuaternion).invert();
+        }
+        const [faceFrontAzimuth, faceFrontAltitude] = calcAzimuthAltitude(this.faceFront);
+        _eulerA$1.set(0.0, 0.5 * Math.PI + faceFrontAzimuth, faceFrontAltitude, 'YZX');
+        return target.setFromEuler(_eulerA$1).premultiply(_quatD.copy(this._restHeadWorldQuaternion).invert());
+    }
     /**
      * Get its LookAt direction in world coordinate.
      *
      * @param target A target `THREE.Vector3`
      */
     getLookAtWorldDirection(target) {
-        this.getLookAtWorldQuaternion(_quatA);
-        return target.copy(this.faceFront).applyEuler(this._euler).applyQuaternion(_quatA);
+        this.getLookAtWorldQuaternion(_quatB$1);
+        this.getFaceFrontQuaternion(_quatC);
+        return target
+            .copy(VEC3_POSITIVE_Z$1)
+            .applyQuaternion(_quatB$1)
+            .applyQuaternion(_quatC)
+            .applyEuler(this.getEuler(_eulerA$1));
     }
     /**
      * Set its LookAt position.
      * Note that its result will be instantly overwritten if {@link VRMLookAtHead.autoUpdate} is enabled.
      *
-     * @param position A target position
+     * @param position A target position, in world space
      */
     lookAt(position) {
-        this._calcEuler(this._euler, position);
-        this.applier.lookAt(this._euler);
+        // Look at direction in local coordinate
+        const headRotDiffInv = _quatA$1
+            .copy(this._restHeadWorldQuaternion)
+            .multiply(quatInvertCompat(this.getLookAtWorldQuaternion(_quatB$1)));
+        const headPos = this.getLookAtWorldPosition(_v3B);
+        const lookAtDir = _v3C.copy(position).sub(headPos).applyQuaternion(headRotDiffInv).normalize();
+        // calculate angles
+        const [azimuthFrom, altitudeFrom] = calcAzimuthAltitude(this.faceFront);
+        const [azimuthTo, altitudeTo] = calcAzimuthAltitude(lookAtDir);
+        const yaw = sanitizeAngle(azimuthTo - azimuthFrom);
+        const pitch = sanitizeAngle(altitudeFrom - altitudeTo); // spinning (1, 0, 0) CCW around Z axis makes the vector look up, while spinning (0, 0, 1) CCW around X axis makes the vector look down
+        // apply angles
+        this._yaw = THREE.MathUtils.RAD2DEG * yaw;
+        this._pitch = THREE.MathUtils.RAD2DEG * pitch;
+        this._needsUpdate = true;
     }
     /**
      * Update the VRMLookAtHead.
@@ -2066,28 +2794,20 @@ class VRMLookAt {
      * @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 && this.autoUpdate) {
+        if (this.target != null && this.autoUpdate) {
             this.lookAt(this.target.getWorldPosition(_v3A));
-            this.applier.lookAt(this._euler);
         }
-    }
-    _calcEuler(target, position) {
-        // Look at direction in local coordinate
-        const headRotInv = quatInvertCompat(this.getLookAtWorldQuaternion(_quatA));
-        const headPos = this.getLookAtWorldPosition(_v3B);
-        const lookAtDir = _v3C.copy(position).sub(headPos).applyQuaternion(headRotInv).normalize();
-        // calculate the rotation
-        const rotLocal = _quatB.setFromUnitVectors(this.faceFront, lookAtDir);
-        // Transform the direction into local coordinate from the first person bone
-        _v3C.set(0.0, 0.0, 1.0).applyQuaternion(rotLocal);
-        // convert the direction into euler
-        target.x = Math.atan2(-_v3C.y, Math.sqrt(_v3C.x * _v3C.x + _v3C.z * _v3C.z));
-        target.y = Math.atan2(_v3C.x, _v3C.z);
-        return target;
+        if (this._needsUpdate) {
+            this._needsUpdate = false;
+            this.applier.applyYawPitch(this._yaw, this._pitch);
+        }
     }
 }
 VRMLookAt.EULER_ORDER = 'YXZ'; // yaw-pitch-roll
 
+const VEC3_POSITIVE_Z = new THREE.Vector3(0.0, 0.0, 1.0);
+const _quatA = new THREE.Quaternion();
+const _quatB = new THREE.Quaternion();
 const _eulerA = new THREE.Euler(0.0, 0.0, 0.0, 'YXZ');
 /**
  * A class that applies eye gaze directions to a VRM.
@@ -2109,50 +2829,115 @@ class VRMLookAtBoneApplier {
         this.rangeMapHorizontalOuter = rangeMapHorizontalOuter;
         this.rangeMapVerticalDown = rangeMapVerticalDown;
         this.rangeMapVerticalUp = rangeMapVerticalUp;
+        this.faceFront = new THREE.Vector3(0.0, 0.0, 1.0);
+        // set rest quaternions
+        this._restQuatLeftEye = new THREE.Quaternion();
+        this._restQuatRightEye = new THREE.Quaternion();
+        this._restLeftEyeParentWorldQuat = new THREE.Quaternion();
+        this._restRightEyeParentWorldQuat = new THREE.Quaternion();
+        const leftEye = this.humanoid.getRawBoneNode('leftEye');
+        const rightEye = this.humanoid.getRawBoneNode('leftEye');
+        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 angle An input angle
+     * @param yaw Rotation around Y axis, in degree
+     * @param pitch Rotation around X axis, in degree
      */
-    lookAt(angle) {
-        const srcX = (angle.x * 180.0) / Math.PI;
-        const srcY = (angle.y * 180.0) / Math.PI;
-        const leftEye = this.humanoid.getBoneNode('leftEye');
-        const rightEye = this.humanoid.getBoneNode('rightEye');
+    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');
         // left
         if (leftEye) {
-            if (srcX < 0.0) {
-                _eulerA.x = (-this.rangeMapVerticalDown.map(-srcX) / 180.0) * Math.PI;
+            if (pitch < 0.0) {
+                _eulerA.x = -THREE.MathUtils.DEG2RAD * this.rangeMapVerticalDown.map(-pitch);
             }
             else {
-                _eulerA.x = (this.rangeMapVerticalUp.map(srcX) / 180.0) * Math.PI;
+                _eulerA.x = THREE.MathUtils.DEG2RAD * this.rangeMapVerticalUp.map(pitch);
             }
-            if (srcY < 0.0) {
-                _eulerA.y = (-this.rangeMapHorizontalInner.map(-srcY) / 180.0) * Math.PI;
+            if (yaw < 0.0) {
+                _eulerA.y = -THREE.MathUtils.DEG2RAD * this.rangeMapHorizontalInner.map(-yaw);
             }
             else {
-                _eulerA.y = (this.rangeMapHorizontalOuter.map(srcY) / 180.0) * Math.PI;
-            }
-            leftEye.quaternion.setFromEuler(_eulerA);
+                _eulerA.y = THREE.MathUtils.DEG2RAD * this.rangeMapHorizontalOuter.map(yaw);
+            }
+            _quatA.setFromEuler(_eulerA);
+            this._getWorldFaceFrontQuat(_quatB);
+            // _quatB * _quatA * _quatB^-1
+            // where _quatA is LookAt rotation
+            // and _quatB is worldFaceFrontQuat
+            leftEyeNormalized.quaternion.copy(_quatB).multiply(_quatA).multiply(_quatB.invert());
+            _quatA.copy(this._restLeftEyeParentWorldQuat);
+            // _quatA^-1 * leftEyeNormalized.quaternion * _quatA * restQuatLeftEye
+            // where _quatA is restLeftEyeParentWorldQuat
+            leftEye.quaternion
+                .copy(leftEyeNormalized.quaternion)
+                .multiply(_quatA)
+                .premultiply(_quatA.invert())
+                .multiply(this._restQuatLeftEye);
         }
         // right
         if (rightEye) {
-            if (srcX < 0.0) {
-                _eulerA.x = (-this.rangeMapVerticalDown.map(-srcX) / 180.0) * Math.PI;
+            if (pitch < 0.0) {
+                _eulerA.x = -THREE.MathUtils.DEG2RAD * this.rangeMapVerticalDown.map(-pitch);
             }
             else {
-                _eulerA.x = (this.rangeMapVerticalUp.map(srcX) / 180.0) * Math.PI;
+                _eulerA.x = THREE.MathUtils.DEG2RAD * this.rangeMapVerticalUp.map(pitch);
             }
-            if (srcY < 0.0) {
-                _eulerA.y = (-this.rangeMapHorizontalOuter.map(-srcY) / 180.0) * Math.PI;
+            if (yaw < 0.0) {
+                _eulerA.y = -THREE.MathUtils.DEG2RAD * this.rangeMapHorizontalOuter.map(-yaw);
             }
             else {
-                _eulerA.y = (this.rangeMapHorizontalInner.map(srcY) / 180.0) * Math.PI;
-            }
-            rightEye.quaternion.setFromEuler(_eulerA);
+                _eulerA.y = THREE.MathUtils.DEG2RAD * this.rangeMapHorizontalInner.map(yaw);
+            }
+            _quatA.setFromEuler(_eulerA);
+            this._getWorldFaceFrontQuat(_quatB);
+            // _quatB * _quatA * _quatB^-1
+            // where _quatA is LookAt rotation
+            // and _quatB is worldFaceFrontQuat
+            rightEyeNormalized.quaternion.copy(_quatB).multiply(_quatA).multiply(_quatB.invert());
+            _quatA.copy(this._restRightEyeParentWorldQuat);
+            // _quatA^-1 * rightEyeNormalized.quaternion * _quatA * restQuatRightEye
+            // where _quatA is restRightEyeParentWorldQuat
+            rightEye.quaternion
+                .copy(rightEyeNormalized.quaternion)
+                .multiply(_quatA)
+                .premultiply(_quatA.invert())
+                .multiply(this._restQuatRightEye);
         }
     }
+    /**
+     * @deprecated Use {@link applyYawPitch} instead.
+     */
+    lookAt(euler) {
+        console.warn('VRMLookAtBoneApplier: lookAt() is deprecated. use apply() instead.');
+        const yaw = THREE.MathUtils.RAD2DEG * euler.y;
+        const pitch = THREE.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_Z) < 0.01) {
+            return target.identity();
+        }
+        const [faceFrontAzimuth, faceFrontAltitude] = calcAzimuthAltitude(this.faceFront);
+        _eulerA.set(0.0, 0.5 * Math.PI + faceFrontAzimuth, faceFrontAltitude, 'YZX');
+        return target.setFromEuler(_eulerA);
+    }
 }
 /**
  * Represent its type of applier.
@@ -2183,28 +2968,36 @@ class VRMLookAtExpressionApplier {
     /**
      * Apply the input angle to its associated VRM model.
      *
-     * @param angle An input angle
+     * @param yaw Rotation around Y axis, in degree
+     * @param pitch Rotation around X axis, in degree
      */
-    lookAt(angle) {
-        const srcX = (angle.x * 180.0) / Math.PI;
-        const srcY = (angle.y * 180.0) / Math.PI;
-        if (srcX < 0.0) {
+    applyYawPitch(yaw, pitch) {
+        if (pitch < 0.0) {
             this.expressions.setValue('lookDown', 0.0);
-            this.expressions.setValue('lookUp', this.rangeMapVerticalUp.map(-srcX));
+            this.expressions.setValue('lookUp', this.rangeMapVerticalUp.map(-pitch));
         }
         else {
             this.expressions.setValue('lookUp', 0.0);
-            this.expressions.setValue('lookDown', this.rangeMapVerticalDown.map(srcX));
+            this.expressions.setValue('lookDown', this.rangeMapVerticalDown.map(pitch));
         }
-        if (srcY < 0.0) {
+        if (yaw < 0.0) {
             this.expressions.setValue('lookLeft', 0.0);
-            this.expressions.setValue('lookRight', this.rangeMapHorizontalOuter.map(-srcY));
+            this.expressions.setValue('lookRight', this.rangeMapHorizontalOuter.map(-yaw));
         }
         else {
             this.expressions.setValue('lookRight', 0.0);
-            this.expressions.setValue('lookLeft', this.rangeMapHorizontalOuter.map(srcY));
+            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 = THREE.MathUtils.RAD2DEG * euler.y;
+        const pitch = THREE.MathUtils.RAD2DEG * euler.x;
+        this.applyYawPitch(yaw, pitch);
+    }
 }
 /**
  * Represent its type of applier.
@@ -2231,6 +3024,10 @@ class VRMLookAtRangeMap {
     }
 }
 
+/**
+ * Possible spec versions it recognizes.
+ */
+const POSSIBLE_SPEC_VERSIONS$1 = new Set(['1.0', '1.0-beta']);
 /**
  * A plugin of GLTFLoader that imports a {@link VRMLookAt} from a VRM extension of a GLTF.
  */
@@ -2252,14 +3049,14 @@ class VRMLookAtLoaderPlugin {
                 return;
             }
             else if (vrmHumanoid === undefined) {
-                throw new Error('VRMFirstPersonLoaderPlugin: vrmHumanoid is undefined. VRMHumanoidLoaderPlugin have to be used first');
+                throw new Error('VRMLookAtLoaderPlugin: vrmHumanoid is undefined. VRMHumanoidLoaderPlugin have to be used first');
             }
             const vrmExpressionManager = gltf.userData.vrmExpressionManager;
             if (vrmExpressionManager === null) {
                 return;
             }
             else if (vrmExpressionManager === undefined) {
-                throw new Error('VRMFirstPersonLoaderPlugin: vrmExpressionManager is undefined. VRMExpressionLoaderPlugin have to be used first');
+                throw new Error('VRMLookAtLoaderPlugin: vrmExpressionManager is undefined. VRMExpressionLoaderPlugin have to be used first');
             }
             gltf.userData.vrmLookAt = yield this._import(gltf, vrmHumanoid, vrmExpressionManager);
         });
@@ -2301,7 +3098,8 @@ class VRMLookAtLoaderPlugin {
                 return null;
             }
             const specVersion = extension.specVersion;
-            if (specVersion !== '1.0-beta') {
+            if (!POSSIBLE_SPEC_VERSIONS$1.has(specVersion)) {
+                console.warn(`VRMLookAtLoaderPlugin: Unknown VRMC_vrm specVersion "${specVersion}"`);
                 return null;
             }
             const schemaLookAt = extension.lookAt;
@@ -2363,6 +3161,9 @@ class VRMLookAtLoaderPlugin {
             }
             // VRM 0.0 are facing Z- instead of Z+
             lookAt.faceFront.set(0.0, 0.0, -1.0);
+            if (applier instanceof VRMLookAtBoneApplier) {
+                applier.faceFront.set(0.0, 0.0, -1.0);
+            }
             return lookAt;
         });
     }
@@ -2418,6 +3219,10 @@ function resolveURL(url, path) {
     return path + url;
 }
 
+/**
+ * Possible spec versions it recognizes.
+ */
+const POSSIBLE_SPEC_VERSIONS = new Set(['1.0', '1.0-beta']);
 /**
  * A plugin of GLTFLoader that imports a {@link VRM1Meta} from a VRM extension of a GLTF.
  */
@@ -2465,7 +3270,8 @@ class VRMMetaLoaderPlugin {
                 return null;
             }
             const specVersion = extension.specVersion;
-            if (specVersion !== '1.0-beta') {
+            if (!POSSIBLE_SPEC_VERSIONS.has(specVersion)) {
+                console.warn(`VRMMetaLoaderPlugin: Unknown VRMC_vrm specVersion "${specVersion}"`);
                 return null;
             }
             const schemaMeta = extension.meta;
@@ -2521,7 +3327,7 @@ class VRMMetaLoaderPlugin {
             }
             // throw an error if acceptV0Meta is false
             if (!this.acceptV0Meta) {
-                throw new Error('VRMMetaLoaderPlugin: Attempted to load VRM0.X meta but acceptV0Meta is false');
+                throw new Error('VRMMetaLoaderPlugin: Attempted to load VRM0.0 meta but acceptV0Meta is false');
             }
             // load thumbnail texture
             let texture;
@@ -2590,11 +3396,11 @@ class VRMCore {
      */
     constructor(params) {
         this.scene = params.scene;
+        this.meta = params.meta;
         this.humanoid = params.humanoid;
         this.expressionManager = params.expressionManager;
         this.firstPerson = params.firstPerson;
         this.lookAt = params.lookAt;
-        this.meta = params.meta;
     }
     /**
      * **You need to call this on your update loop.**
@@ -2604,6 +3410,7 @@ class VRMCore {
      * @param delta deltaTime
      */
     update(delta) {
+        this.humanoid.update();
         if (this.lookAt) {
             this.lookAt.update(delta);
         }
@@ -2618,9 +3425,10 @@ class VRMCoreLoaderPlugin {
         var _a, _b, _c, _d, _e;
         this.parser = parser;
         const helperRoot = options === null || options === void 0 ? void 0 : options.helperRoot;
+        const autoUpdateHumanBones = options === null || options === void 0 ? void 0 : options.autoUpdateHumanBones;
         this.expressionPlugin = (_a = options === null || options === void 0 ? void 0 : options.expressionPlugin) !== null && _a !== void 0 ? _a : new VRMExpressionLoaderPlugin(parser);
         this.firstPersonPlugin = (_b = options === null || options === void 0 ? void 0 : options.firstPersonPlugin) !== null && _b !== void 0 ? _b : new VRMFirstPersonLoaderPlugin(parser);
-        this.humanoidPlugin = (_c = options === null || options === void 0 ? void 0 : options.humanoidPlugin) !== null && _c !== void 0 ? _c : new VRMHumanoidLoaderPlugin(parser);
+        this.humanoidPlugin = (_c = options === null || options === void 0 ? void 0 : options.humanoidPlugin) !== null && _c !== void 0 ? _c : new VRMHumanoidLoaderPlugin(parser, { helperRoot, autoUpdateHumanBones });
         this.lookAtPlugin = (_d = options === null || options === void 0 ? void 0 : options.lookAtPlugin) !== null && _d !== void 0 ? _d : new VRMLookAtLoaderPlugin(parser, { helperRoot });
         this.metaPlugin = (_e = options === null || options === void 0 ? void 0 : options.metaPlugin) !== null && _e !== void 0 ? _e : new VRMMetaLoaderPlugin(parser);
     }
@@ -2635,18 +3443,24 @@ class VRMCoreLoaderPlugin {
             yield this.expressionPlugin.afterRoot(gltf);
             yield this.lookAtPlugin.afterRoot(gltf);
             yield this.firstPersonPlugin.afterRoot(gltf);
-            const vrmCore = new VRMCore({
-                scene: gltf.scene,
-                expressionManager: gltf.userData.vrmExpressionManager,
-                firstPerson: gltf.userData.vrmFirstPerson,
-                humanoid: gltf.userData.vrmHumanoid,
-                lookAt: gltf.userData.vrmLookAt,
-                meta: gltf.userData.vrmMeta,
-            });
-            gltf.userData.vrmCore = vrmCore;
+            const meta = gltf.userData.vrmMeta;
+            const humanoid = gltf.userData.vrmHumanoid;
+            // meta and humanoid are required to be a VRM.
+            // Don't create VRM if they are null
+            if (meta && humanoid) {
+                const vrmCore = new VRMCore({
+                    scene: gltf.scene,
+                    expressionManager: gltf.userData.vrmExpressionManager,
+                    firstPerson: gltf.userData.vrmFirstPerson,
+                    humanoid,
+                    lookAt: gltf.userData.vrmLookAt,
+                    meta,
+                });
+                gltf.userData.vrmCore = vrmCore;
+            }
         });
     }
 }
 
-export { VRMCore, VRMCoreLoaderPlugin, VRMExpression, VRMExpressionLoaderPlugin, VRMExpressionManager, VRMExpressionMaterialColorType, VRMExpressionOverrideType, VRMExpressionPresetName, VRMFirstPerson, VRMFirstPersonLoaderPlugin, VRMFirstPersonMeshAnnotationType, VRMHumanBoneName, VRMHumanoid, VRMHumanoidLoaderPlugin, VRMLookAt, VRMLookAtBoneApplier, VRMLookAtExpressionApplier, VRMLookAtHelper, VRMLookAtLoaderPlugin, VRMLookAtRangeMap, VRMLookAtTypeName, VRMMetaLoaderPlugin, VRMRequiredHumanBoneName };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"three-vrm-core.module.js","sources":["../src/expressions/VRMExpression.ts","../../../node_modules/tslib/tslib.es6.js","../src/utils/gltfExtractPrimitivesFromNode.ts","../src/utils/gltfGetAssociatedMaterialIndex.ts","../src/expressions/VRMExpressionPresetName.ts","../src/utils/saturate.ts","../src/expressions/VRMExpressionManager.ts","../src/expressions/VRMExpressionMaterialColorBind.ts","../src/expressions/VRMExpressionMorphTargetBind.ts","../src/expressions/VRMExpressionTextureTransformBind.ts","../src/expressions/VRMExpressionLoaderPlugin.ts","../src/expressions/VRMExpressionMaterialColorType.ts","../src/expressions/VRMExpressionOverrideType.ts","../src/firstPerson/VRMFirstPerson.ts","../src/firstPerson/VRMFirstPersonLoaderPlugin.ts","../src/firstPerson/VRMFirstPersonMeshAnnotationType.ts","../src/humanoid/VRMHumanBoneName.ts","../src/utils/quatInvertCompat.ts","../src/humanoid/VRMHumanoid.ts","../src/humanoid/VRMRequiredHumanBoneName.ts","../src/humanoid/VRMHumanoidLoaderPlugin.ts","../src/lookAt/helpers/utils/FanBufferGeometry.ts","../src/lookAt/helpers/utils/LineAndSphereBufferGeometry.ts","../src/lookAt/helpers/VRMLookAtHelper.ts","../src/utils/getWorldQuaternionLite.ts","../src/lookAt/VRMLookAt.ts","../src/lookAt/VRMLookAtBoneApplier.ts","../src/lookAt/VRMLookAtExpressionApplier.ts","../src/lookAt/VRMLookAtRangeMap.ts","../src/lookAt/VRMLookAtLoaderPlugin.ts","../src/lookAt/VRMLookAtTypeName.ts","../src/utils/resolveURL.ts","../src/meta/VRMMetaLoaderPlugin.ts","../src/VRMCore.ts","../src/VRMCoreLoaderPlugin.ts"],"sourcesContent":["import * as THREE from 'three';\nimport { VRMExpressionBind } from './VRMExpressionBind';\nimport type { VRMExpressionOverrideType } from './VRMExpressionOverrideType';\n\n// animationMixer の監視対象は、Scene の中に入っている必要がある。\n// そのため、表示オブジェクトではないけれど、Object3D を継承して Scene に投入できるようにする。\nexport class VRMExpression extends THREE.Object3D {\n  /**\n   * Name of this expression.\n   * Distinguished with `name` since `name` will be conflicted with Object3D.\n   */\n  public expressionName: string;\n\n  /**\n   * The current weight of the expression.\n   */\n  public weight = 0.0;\n\n  /**\n   * Interpret non-zero values as 1.\n   */\n  public isBinary = false;\n\n  /**\n   * Specify how the expression overrides blink expressions.\n   */\n  public overrideBlink: VRMExpressionOverrideType = 'none';\n\n  /**\n   * Specify how the expression overrides lookAt expressions.\n   */\n  public overrideLookAt: VRMExpressionOverrideType = 'none';\n\n  /**\n   * Specify how the expression overrides mouth expressions.\n   */\n  public overrideMouth: VRMExpressionOverrideType = 'none';\n\n  private _binds: VRMExpressionBind[] = [];\n\n  /**\n   * A value represents how much it should override blink expressions.\n   * `0.0` == no override at all, `1.0` == completely block the expressions.\n   */\n  public get overrideBlinkAmount(): number {\n    if (this.overrideBlink === 'block') {\n      return 0.0 < this.weight ? 1.0 : 0.0;\n    } else if (this.overrideBlink === 'blend') {\n      return this.weight;\n    } else {\n      return 0.0;\n    }\n  }\n\n  /**\n   * A value represents how much it should override lookAt expressions.\n   * `0.0` == no override at all, `1.0` == completely block the expressions.\n   */\n  public get overrideLookAtAmount(): number {\n    if (this.overrideLookAt === 'block') {\n      return 0.0 < this.weight ? 1.0 : 0.0;\n    } else if (this.overrideLookAt === 'blend') {\n      return this.weight;\n    } else {\n      return 0.0;\n    }\n  }\n\n  /**\n   * A value represents how much it should override mouth expressions.\n   * `0.0` == no override at all, `1.0` == completely block the expressions.\n   */\n  public get overrideMouthAmount(): number {\n    if (this.overrideMouth === 'block') {\n      return 0.0 < this.weight ? 1.0 : 0.0;\n    } else if (this.overrideMouth === 'blend') {\n      return this.weight;\n    } else {\n      return 0.0;\n    }\n  }\n\n  constructor(expressionName: string) {\n    super();\n\n    this.name = `VRMExpression_${expressionName}`;\n    this.expressionName = expressionName;\n\n    // traverse 時の救済手段として Object3D ではないことを明示しておく\n    this.type = 'VRMExpression';\n    // 表示目的のオブジェクトではないので、負荷軽減のために visible を false にしておく。\n    // これにより、このインスタンスに対する毎フレームの matrix 自動計算を省略できる。\n    this.visible = false;\n  }\n\n  public addBind(bind: VRMExpressionBind): void {\n    this._binds.push(bind);\n  }\n\n  /**\n   * Apply weight to every assigned blend shapes.\n   * Should be called every frame.\n   */\n  public applyWeight(options?: {\n    /**\n     * Multiplies a value to its weight to apply.\n     * Intended to be used for overriding an expression weight by another expression.\n     * See also: {@link overrideBlink}, {@link overrideLookAt}, {@link overrideMouth}\n     */\n    multiplier?: number;\n  }): void {\n    let actualWeight = this.isBinary ? (this.weight === 0.0 ? 0.0 : 1.0) : this.weight;\n    actualWeight *= options?.multiplier ?? 1.0;\n\n    this._binds.forEach((bind) => bind.applyWeight(actualWeight));\n  }\n\n  /**\n   * Clear previously assigned blend shapes.\n   */\n  public clearAppliedWeight(): void {\n    this._binds.forEach((bind) => bind.clearAppliedWeight());\n  }\n}\n","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n}\r\n\r\nexport function __spreadArray(to, from) {\r\n    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)\r\n        to[j] = from[i];\r\n    return to;\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n","import type { GLTF } from 'three/examples/jsm/loaders/GLTFLoader';\nimport { GLTF as GLTFSchema } from '@gltf-transform/core';\n\nfunction extractPrimitivesInternal(gltf: GLTF, nodeIndex: number, node: THREE.Object3D): THREE.Mesh[] | null {\n  const json = gltf.parser.json as GLTFSchema.IGLTF;\n\n  /**\n   * Let's list up every possible patterns that parsed gltf nodes with a mesh can have,,,\n   *\n   * \"*\" indicates that those meshes should be listed up using this function\n   *\n   * ### A node with a (mesh, a signle primitive)\n   *\n   * - `THREE.Mesh`: The only primitive of the mesh *\n   *\n   * ### A node with a (mesh, multiple primitives)\n   *\n   * - `THREE.Group`: The root of the mesh\n   *   - `THREE.Mesh`: A primitive of the mesh *\n   *   - `THREE.Mesh`: A primitive of the mesh (2) *\n   *\n   * ### A node with a (mesh, multiple primitives) AND (a child with a mesh, a single primitive)\n   *\n   * - `THREE.Group`: The root of the mesh\n   *   - `THREE.Mesh`: A primitive of the mesh *\n   *   - `THREE.Mesh`: A primitive of the mesh (2) *\n   *   - `THREE.Mesh`: A primitive of a MESH OF THE CHILD\n   *\n   * ### A node with a (mesh, multiple primitives) AND (a child with a mesh, multiple primitives)\n   *\n   * - `THREE.Group`: The root of the mesh\n   *   - `THREE.Mesh`: A primitive of the mesh *\n   *   - `THREE.Mesh`: A primitive of the mesh (2) *\n   *   - `THREE.Group`: The root of a MESH OF THE CHILD\n   *     - `THREE.Mesh`: A primitive of the mesh of the child\n   *     - `THREE.Mesh`: A primitive of the mesh of the child (2)\n   *\n   * ### A node with a (mesh, multiple primitives) BUT the node is a bone\n   *\n   * - `THREE.Bone`: The root of the node, as a bone\n   *   - `THREE.Group`: The root of the mesh\n   *     - `THREE.Mesh`: A primitive of the mesh *\n   *     - `THREE.Mesh`: A primitive of the mesh (2) *\n   *\n   * ### A node with a (mesh, multiple primitives) AND (a child with a mesh, multiple primitives) BUT the node is a bone\n   *\n   * - `THREE.Bone`: The root of the node, as a bone\n   *   - `THREE.Group`: The root of the mesh\n   *     - `THREE.Mesh`: A primitive of the mesh *\n   *     - `THREE.Mesh`: A primitive of the mesh (2) *\n   *   - `THREE.Group`: The root of a MESH OF THE CHILD\n   *     - `THREE.Mesh`: A primitive of the mesh of the child\n   *     - `THREE.Mesh`: A primitive of the mesh of the child (2)\n   *\n   * ...I will take a strategy that traverses the root of the node and take first (primitiveCount) meshes.\n   */\n\n  // Make sure that the node has a mesh\n  const schemaNode = json.nodes?.[nodeIndex];\n  if (schemaNode == null) {\n    console.warn(`extractPrimitivesInternal: Attempt to use nodes[${nodeIndex}] of glTF but the node doesn't exist`);\n    return null;\n  }\n\n  const meshIndex = schemaNode.mesh;\n  if (meshIndex == null) {\n    return null;\n  }\n\n  // How many primitives the mesh has?\n  const schemaMesh = json.meshes?.[meshIndex];\n  if (schemaMesh == null) {\n    console.warn(`extractPrimitivesInternal: Attempt to use meshes[${meshIndex}] of glTF but the mesh doesn't exist`);\n    return null;\n  }\n\n  const primitiveCount = schemaMesh.primitives.length;\n\n  // Traverse the node and take first (primitiveCount) meshes\n  const primitives: THREE.Mesh[] = [];\n  node.traverse((object) => {\n    if (primitives.length < primitiveCount) {\n      if ((object as any).isMesh) {\n        primitives.push(object as THREE.Mesh);\n      }\n    }\n  });\n\n  return primitives;\n}\n\n/**\n * Extract primitives ( `THREE.Mesh[]` ) of a node from a loaded GLTF.\n * The main purpose of this function is to distinguish primitives and children from a node that has both meshes and children.\n *\n * It utilizes the behavior that GLTFLoader adds mesh primitives to the node object ( `THREE.Group` ) first then adds its children.\n *\n * @param gltf A GLTF object taken from GLTFLoader\n * @param nodeIndex The index of the node\n */\nexport async function gltfExtractPrimitivesFromNode(gltf: GLTF, nodeIndex: number): Promise<THREE.Mesh[] | null> {\n  const node: THREE.Object3D = await gltf.parser.getDependency('node', nodeIndex);\n  return extractPrimitivesInternal(gltf, nodeIndex, node);\n}\n\n/**\n * Extract primitives ( `THREE.Mesh[]` ) of nodes from a loaded GLTF.\n * See {@link gltfExtractPrimitivesFromNode} for more details.\n *\n * It returns a map from node index to extraction result.\n * If a node does not have a mesh, the entry for the node will not be put in the returning map.\n *\n * @param gltf A GLTF object taken from GLTFLoader\n */\nexport async function gltfExtractPrimitivesFromNodes(gltf: GLTF): Promise<Map<number, THREE.Mesh[]>> {\n  const nodes: THREE.Object3D[] = await gltf.parser.getDependencies('node');\n  const map = new Map<number, THREE.Mesh[]>();\n\n  nodes.forEach((node, index) => {\n    const result = extractPrimitivesInternal(gltf, index, node);\n    if (result != null) {\n      map.set(index, result);\n    }\n  });\n\n  return map;\n}\n","import * as THREE from 'three';\nimport { GLTFParser } from 'three/examples/jsm/loaders/GLTFLoader';\n\n/**\n * Get a material definition index of glTF from associated material.\n * It's basically a comat code between Three.js r133 or above and previous versions.\n * @param parser GLTFParser\n * @param material A material of gltf\n * @returns Material definition index of glTF\n */\nexport function gltfGetAssociatedMaterialIndex(parser: GLTFParser, material: THREE.Material): number | null {\n  const threeRevision = parseInt(THREE.REVISION, 10);\n\n  let index: number | null = null;\n\n  if (threeRevision >= 133) {\n    index = parser.associations.get(material)?.materials ?? null;\n  } else {\n    // COMPAT: structure of `parser.associations` has been changed @ r133\n    // See: https://github.com/mrdoob/three.js/pull/21737\n    // Ref: https://github.com/three-types/three-ts-types/commit/5246676e479b61a9ff2db71df4119f6f1462580d\n    type GLTFReferencePre133 = {\n      type: 'materials' | 'nodes' | 'textures' | 'meshes';\n      index: number;\n    };\n\n    type GLTFAssociationsPre133 = Map<THREE.Object3D | THREE.Material | THREE.Texture, GLTFReferencePre133>;\n\n    const associations = parser.associations as GLTFAssociationsPre133;\n\n    const reference = associations.get(material);\n\n    if (reference?.type === 'materials') {\n      index = reference.index;\n    }\n  }\n\n  return index;\n}\n","/* eslint-disable @typescript-eslint/naming-convention */\n\nexport const VRMExpressionPresetName = {\n  Aa: 'aa',\n  Ih: 'ih',\n  Ou: 'ou',\n  Ee: 'ee',\n  Oh: 'oh',\n  Blink: 'blink',\n  Happy: 'happy',\n  Angry: 'angry',\n  Sad: 'sad',\n  Relaxed: 'relaxed',\n  LookUp: 'lookUp',\n  Surprised: 'surprised',\n  LookDown: 'lookDown',\n  LookLeft: 'lookLeft',\n  LookRight: 'lookRight',\n  BlinkLeft: 'blinkLeft',\n  BlinkRight: 'blinkRight',\n  Neutral: 'neutral',\n} as const;\n\nexport type VRMExpressionPresetName = typeof VRMExpressionPresetName[keyof typeof VRMExpressionPresetName];\n","/**\n * Clamp the input value within [0.0 - 1.0].\n *\n * @param value The input value\n */\nexport function saturate(value: number): number {\n  return Math.max(Math.min(value, 1.0), 0.0);\n}\n","import { VRMExpressionPresetName } from './VRMExpressionPresetName';\nimport { saturate } from '../utils/saturate';\nimport type { VRMExpression } from './VRMExpression';\n\nexport class VRMExpressionManager {\n  /**\n   * A set of name or preset name of expressions that will be overridden by {@link VRMExpression.overrideBlink}.\n   */\n  public blinkExpressionNames = ['blink', 'blinkLeft', 'blinkRight'];\n\n  /**\n   * A set of name or preset name of expressions that will be overridden by {@link VRMExpression.overrideLookAt}.\n   */\n  public lookAtExpressionNames = ['lookLeft', 'lookRight', 'lookUp', 'lookDown'];\n\n  /**\n   * A set of name or preset name of expressions that will be overridden by {@link VRMExpression.overrideMouth}.\n   */\n  public mouthExpressionNames = ['aa', 'ee', 'ih', 'oh', 'ou'];\n\n  /**\n   * A set of {@link VRMExpression}.\n   * When you want to register expressions, use {@link registerExpression}\n   */\n  private _expressions: VRMExpression[] = [];\n  public get expressions(): VRMExpression[] {\n    return this._expressions.concat();\n  }\n\n  /**\n   * A map from name to expression.\n   */\n  private _expressionMap: { [name: string]: VRMExpression } = {};\n  public get expressionMap(): { [name: string]: VRMExpression } {\n    return Object.assign({}, this._expressionMap);\n  }\n\n  /**\n   * A map from name to expression, but excluding custom expressions.\n   */\n  public get presetExpressionMap(): { [name in VRMExpressionPresetName]?: VRMExpression } {\n    const result: { [name in VRMExpressionPresetName]?: VRMExpression } = {};\n\n    const presetNameSet = new Set<string>(Object.values(VRMExpressionPresetName));\n\n    Object.entries(this._expressionMap).forEach(([name, expression]) => {\n      if (presetNameSet.has(name)) {\n        result[name as VRMExpressionPresetName] = expression;\n      }\n    });\n\n    return result;\n  }\n\n  /**\n   * A map from name to expression, but excluding preset expressions.\n   */\n  public get customExpressionMap(): { [name: string]: VRMExpression } {\n    const result: { [name: string]: VRMExpression } = {};\n\n    const presetNameSet = new Set<string>(Object.values(VRMExpressionPresetName));\n\n    Object.entries(this._expressionMap).forEach(([name, expression]) => {\n      if (!presetNameSet.has(name)) {\n        result[name] = expression;\n      }\n    });\n\n    return result;\n  }\n\n  /**\n   * Create a new {@link VRMExpressionManager}.\n   */\n  public constructor() {\n    // do nothing\n  }\n\n  /**\n   * Copy the given {@link VRMExpressionManager} into this one.\n   * @param source The {@link VRMExpressionManager} you want to copy\n   * @returns this\n   */\n  public copy(source: VRMExpressionManager): this {\n    // first unregister all the expression it has\n    const expressions = this._expressions.concat();\n    expressions.forEach((expression) => {\n      this.unregisterExpression(expression);\n    });\n\n    // then register all the expression of the source\n    source._expressions.forEach((expression) => {\n      this.registerExpression(expression);\n    });\n\n    // copy remaining members\n    this.blinkExpressionNames = source.blinkExpressionNames.concat();\n    this.lookAtExpressionNames = source.lookAtExpressionNames.concat();\n    this.mouthExpressionNames = source.mouthExpressionNames.concat();\n\n    return this;\n  }\n\n  /**\n   * Returns a clone of this {@link VRMExpressionManager}.\n   * @returns Copied {@link VRMExpressionManager}\n   */\n  public clone(): VRMExpressionManager {\n    return new VRMExpressionManager().copy(this);\n  }\n\n  /**\n   * Return a registered expression.\n   * If it cannot find an expression, it will return `null` instead.\n   *\n   * @param name Name or preset name of the expression\n   */\n  public getExpression(name: VRMExpressionPresetName | string): VRMExpression | null {\n    return this._expressionMap[name] ?? null;\n  }\n\n  /**\n   * Register an expression.\n   *\n   * @param expression {@link VRMExpression} that describes the expression\n   */\n  public registerExpression(expression: VRMExpression): void {\n    this._expressions.push(expression);\n    this._expressionMap[expression.expressionName] = expression;\n  }\n\n  /**\n   * Unregister an expression.\n   *\n   * @param expression The expression you want to unregister\n   */\n  public unregisterExpression(expression: VRMExpression): void {\n    const index = this._expressions.indexOf(expression);\n    if (index === -1) {\n      console.warn('VRMExpressionManager: The specified expressions is not registered');\n    }\n\n    this._expressions.splice(index, 1);\n    delete this._expressionMap[expression.expressionName];\n  }\n\n  /**\n   * Get the current weight of the specified expression.\n   * If it doesn't have an expression of given name, it will return `null` instead.\n   *\n   * @param name Name of the expression\n   */\n  public getValue(name: VRMExpressionPresetName | string): number | null {\n    const expression = this.getExpression(name);\n    return expression?.weight ?? null;\n  }\n\n  /**\n   * Set a weight to the specified expression.\n   *\n   * @param name Name of the expression\n   * @param weight Weight\n   */\n  public setValue(name: VRMExpressionPresetName | string, weight: number): void {\n    const expression = this.getExpression(name);\n    if (expression) {\n      expression.weight = saturate(weight);\n    }\n  }\n\n  /**\n   * Get a track name of specified expression.\n   * This track name is needed to manipulate its expression via keyframe animations.\n   *\n   * @example Manipulate an expression using keyframe animation\n   * ```js\n   * const trackName = vrm.expressionManager.getExpressionTrackName( 'blink' );\n   * const track = new THREE.NumberKeyframeTrack(\n   *   name,\n   *   [ 0.0, 0.5, 1.0 ], // times\n   *   [ 0.0, 1.0, 0.0 ] // values\n   * );\n   *\n   * const clip = new THREE.AnimationClip(\n   *   'blink', // name\n   *   1.0, // duration\n   *   [ track ] // tracks\n   * );\n   *\n   * const mixer = new THREE.AnimationMixer( vrm.scene );\n   * const action = mixer.clipAction( clip );\n   * action.play();\n   * ```\n   *\n   * @param name Name of the expression\n   */\n  public getExpressionTrackName(name: VRMExpressionPresetName | string): string | null {\n    const expression = this.getExpression(name);\n    return expression ? `${expression.name}.weight` : null;\n  }\n\n  /**\n   * Update every expressions.\n   */\n  public update(): void {\n    // see how much we should override certain expressions\n    const weightMultipliers = this._calculateWeightMultipliers();\n\n    // reset expression binds first\n    this._expressions.forEach((expression) => {\n      expression.clearAppliedWeight();\n    });\n\n    // then apply binds\n    this._expressions.forEach((expression) => {\n      let multiplier = 1.0;\n      const name = expression.expressionName;\n\n      if (this.blinkExpressionNames.indexOf(name) !== -1) {\n        multiplier *= weightMultipliers.blink;\n      }\n\n      if (this.lookAtExpressionNames.indexOf(name) !== -1) {\n        multiplier *= weightMultipliers.lookAt;\n      }\n\n      if (this.mouthExpressionNames.indexOf(name) !== -1) {\n        multiplier *= weightMultipliers.mouth;\n      }\n\n      expression.applyWeight({ multiplier });\n    });\n  }\n\n  /**\n   * Calculate sum of override amounts to see how much we should multiply weights of certain expressions.\n   */\n  private _calculateWeightMultipliers(): {\n    blink: number;\n    lookAt: number;\n    mouth: number;\n  } {\n    let blink = 1.0;\n    let lookAt = 1.0;\n    let mouth = 1.0;\n\n    this._expressions.forEach((expression) => {\n      blink -= expression.overrideBlinkAmount;\n      lookAt -= expression.overrideLookAtAmount;\n      mouth -= expression.overrideMouthAmount;\n    });\n\n    blink = Math.max(0.0, blink);\n    lookAt = Math.max(0.0, lookAt);\n    mouth = Math.max(0.0, mouth);\n\n    return { blink, lookAt, mouth };\n  }\n}\n","import * as THREE from 'three';\nimport type { VRMExpressionBind } from './VRMExpressionBind';\nimport type { VRMExpressionMaterialColorType } from './VRMExpressionMaterialColorType';\n\nconst _color = new THREE.Color();\n\n/**\n * A bind of expression influences to a material color.\n */\nexport class VRMExpressionMaterialColorBind implements VRMExpressionBind {\n  private static _propertyNameMapMap: {\n    [distinguisher: string]: { [type in VRMExpressionMaterialColorType]?: string };\n  } = {\n    isMeshStandardMaterial: {\n      color: 'color',\n      emissionColor: 'emissive',\n    },\n    isMeshBasicMaterial: {\n      color: 'color',\n    },\n    isMToonMaterial: {\n      color: 'color',\n      emissionColor: 'emissive',\n      outlineColor: 'outlineFactor',\n      rimColor: 'rimFactor',\n      shadeColor: 'shadeFactor',\n    },\n  };\n\n  /**\n   * The target material.\n   */\n  public readonly material: THREE.Material;\n\n  /**\n   * The type of the target property of the material.\n   */\n  public readonly type: VRMExpressionMaterialColorType;\n\n  /**\n   * The target color.\n   */\n  public readonly targetValue: THREE.Color;\n\n  /**\n   * Its state.\n   * If it cannot find the target property in constructor, it will be null instead.\n   */\n  private _state: {\n    propertyName: string;\n    initialValue: THREE.Color;\n    deltaValue: THREE.Color;\n  } | null;\n\n  public constructor({\n    material,\n    type,\n    targetValue,\n  }: {\n    /**\n     * The target material.\n     */\n    material: THREE.Material;\n\n    /**\n     * The type of the target property of the material.\n     */\n    type: VRMExpressionMaterialColorType;\n\n    /**\n     * The target color.\n     */\n    targetValue: THREE.Color;\n  }) {\n    this.material = material;\n    this.type = type;\n    this.targetValue = targetValue;\n\n    // init property name\n    const propertyNameMap = Object.entries(VRMExpressionMaterialColorBind._propertyNameMapMap).find(\n      ([distinguisher]) => {\n        return (material as any)[distinguisher] === true;\n      },\n    )?.[1];\n    const propertyName = propertyNameMap?.[type] ?? null;\n\n    if (propertyName == null) {\n      console.warn(\n        `Tried to add a material color bind to the material ${\n          material.name ?? '(no name)'\n        }, the type ${type} but the material or the type is not supported.`,\n      );\n\n      this._state = null;\n    } else {\n      const target = (material as any)[propertyName] as THREE.Color;\n\n      const initialValue = target.clone();\n      const deltaValue = this.targetValue.clone().sub(initialValue);\n\n      this._state = {\n        propertyName,\n        initialValue,\n        deltaValue,\n      };\n    }\n  }\n\n  public applyWeight(weight: number): void {\n    if (this._state == null) {\n      // warning is already emitted in constructor\n      return;\n    }\n\n    const { propertyName, deltaValue } = this._state;\n\n    const target = (this.material as any)[propertyName] as THREE.Color;\n    if (target === undefined) {\n      return;\n    } // TODO: we should kick this at `addMaterialValue`\n\n    target.add(_color.copy(deltaValue).multiplyScalar(weight));\n\n    if (typeof (this.material as any).shouldApplyUniforms === 'boolean') {\n      (this.material as any).shouldApplyUniforms = true;\n    }\n  }\n\n  public clearAppliedWeight(): void {\n    if (this._state == null) {\n      // warning is already emitted in constructor\n      return;\n    }\n\n    const { propertyName, initialValue } = this._state;\n\n    const target = (this.material as any)[propertyName] as THREE.Color;\n    if (target === undefined) {\n      return;\n    } // TODO: we should kick this at `addMaterialValue`\n\n    target.copy(initialValue);\n\n    if (typeof (this.material as any).shouldApplyUniforms === 'boolean') {\n      (this.material as any).shouldApplyUniforms = true;\n    }\n  }\n}\n","import type * as THREE from 'three';\nimport type { VRMExpressionBind } from './VRMExpressionBind';\n\n/**\n * A bind of {@link VRMExpression} influences to morph targets.\n */\nexport class VRMExpressionMorphTargetBind implements VRMExpressionBind {\n  /**\n   * The mesh primitives that attached to target mesh.\n   */\n  public readonly primitives: THREE.Mesh[];\n\n  /**\n   * The index of the morph target in the mesh.\n   */\n  public readonly index: number;\n\n  /**\n   * The weight value of target morph target. Ranging in [0.0 - 1.0].\n   */\n  public readonly weight: number;\n\n  public constructor({\n    primitives,\n    index,\n    weight,\n  }: {\n    /**\n     * The mesh primitives that attached to target mesh.\n     */\n    primitives: THREE.Mesh[];\n\n    /**\n     * The index of the morph target in the mesh.\n     */\n    index: number;\n\n    /**\n     * The weight value of target morph target. Ranging in [0.0 - 1.0].\n     */\n    weight: number;\n  }) {\n    this.primitives = primitives;\n    this.index = index;\n    this.weight = weight;\n  }\n\n  public applyWeight(weight: number): void {\n    this.primitives.forEach((mesh) => {\n      if (mesh.morphTargetInfluences?.[this.index] != null) {\n        mesh.morphTargetInfluences[this.index] += this.weight * weight;\n      }\n    });\n  }\n\n  public clearAppliedWeight(): void {\n    this.primitives.forEach((mesh) => {\n      if (mesh.morphTargetInfluences?.[this.index] != null) {\n        mesh.morphTargetInfluences[this.index] = 0.0;\n      }\n    });\n  }\n}\n","import * as THREE from 'three';\nimport type { VRMExpressionBind } from './VRMExpressionBind';\n\nconst _v2 = new THREE.Vector2();\n\n/**\n * A bind of expression influences to texture transforms.\n */\nexport class VRMExpressionTextureTransformBind implements VRMExpressionBind {\n  private static _propertyNamesMap: { [distinguisher: string]: string[] } = {\n    isMeshStandardMaterial: [\n      'map',\n      'emissiveMap',\n      'bumpMap',\n      'normalMap',\n      'displacementMap',\n      'roughnessMap',\n      'metalnessMap',\n      'alphaMap',\n    ],\n    isMeshBasicMaterial: ['map', 'specularMap', 'alphaMap'],\n    isMToonMaterial: [\n      'map',\n      'normalMap',\n      'emissiveMap',\n      'shadeMultiplyTexture',\n      'rimMultiplyTexture',\n      'outlineWidthMultiplyTexture',\n      'uvAnimationMaskTexture',\n    ],\n  };\n\n  /**\n   * The target material.\n   */\n  public readonly material: THREE.Material;\n\n  /**\n   * The uv scale of the texture.\n   */\n  public readonly scale: THREE.Vector2;\n\n  /**\n   * The uv offset of the texture.\n   */\n  public readonly offset: THREE.Vector2;\n\n  /**\n   * The list of texture names and its state that should be transformed by this bind.\n   */\n  private _properties: {\n    name: string;\n    initialOffset: THREE.Vector2;\n    initialScale: THREE.Vector2;\n    deltaOffset: THREE.Vector2;\n    deltaScale: THREE.Vector2;\n  }[];\n\n  public constructor({\n    material,\n    scale,\n    offset,\n  }: {\n    /**\n     * The target material.\n     */\n    material: THREE.Material;\n\n    /**\n     * The uv scale of the texture.\n     */\n    scale: THREE.Vector2;\n\n    /**\n     * The uv offset of the texture.\n     */\n    offset: THREE.Vector2;\n  }) {\n    this.material = material;\n    this.scale = scale;\n    this.offset = offset;\n\n    const propertyNames = Object.entries(VRMExpressionTextureTransformBind._propertyNamesMap).find(\n      ([distinguisher]) => {\n        return (material as any)[distinguisher] === true;\n      },\n    )?.[1];\n\n    if (propertyNames == null) {\n      console.warn(\n        `Tried to add a texture transform bind to the material ${\n          material.name ?? '(no name)'\n        } but the material is not supported.`,\n      );\n\n      this._properties = [];\n    } else {\n      this._properties = [];\n\n      propertyNames.forEach((propertyName) => {\n        const texture = ((material as any)[propertyName] as THREE.Texture | undefined)?.clone();\n        if (!texture) {\n          return null;\n        }\n\n        (material as any)[propertyName] = texture; // because the texture is cloned\n\n        const initialOffset = texture.offset.clone();\n        const initialScale = texture.repeat.clone();\n        const deltaOffset = offset.clone().sub(initialOffset);\n        const deltaScale = scale.clone().sub(initialScale);\n\n        this._properties.push({\n          name: propertyName,\n          initialOffset,\n          deltaOffset,\n          initialScale,\n          deltaScale,\n        });\n      });\n    }\n  }\n\n  public applyWeight(weight: number): void {\n    this._properties.forEach((property) => {\n      const target = (this.material as any)[property.name] as THREE.Texture;\n      if (target === undefined) {\n        return;\n      } // TODO: we should kick this at `addMaterialValue`\n\n      target.offset.add(_v2.copy(property.deltaOffset).multiplyScalar(weight));\n      target.repeat.add(_v2.copy(property.deltaScale).multiplyScalar(weight));\n\n      target.needsUpdate = true;\n    });\n  }\n\n  public clearAppliedWeight(): void {\n    this._properties.forEach((property) => {\n      const target = (this.material as any)[property.name] as THREE.Texture;\n      if (target === undefined) {\n        return;\n      } // TODO: we should kick this at `addMaterialValue`\n\n      target.offset.copy(property.initialOffset);\n      target.repeat.copy(property.initialScale);\n\n      target.needsUpdate = true;\n    });\n  }\n}\n","import type * as V0VRM from '@pixiv/types-vrm-0.0';\nimport type * as V1VRMSchema from '@pixiv/types-vrmc-vrm-1.0';\nimport * as THREE from 'three';\nimport { GLTF, GLTFLoaderPlugin, GLTFParser } from 'three/examples/jsm/loaders/GLTFLoader';\nimport { gltfExtractPrimitivesFromNode } from '../utils/gltfExtractPrimitivesFromNode';\nimport { gltfGetAssociatedMaterialIndex } from '../utils/gltfGetAssociatedMaterialIndex';\nimport { VRMExpression } from './VRMExpression';\nimport { VRMExpressionManager } from './VRMExpressionManager';\nimport { VRMExpressionMaterialColorBind } from './VRMExpressionMaterialColorBind';\nimport { VRMExpressionMorphTargetBind } from './VRMExpressionMorphTargetBind';\nimport { VRMExpressionPresetName } from './VRMExpressionPresetName';\nimport { VRMExpressionTextureTransformBind } from './VRMExpressionTextureTransformBind';\nimport { GLTF as GLTFSchema } from '@gltf-transform/core';\n\n/**\n * A plugin of GLTFLoader that imports a {@link VRMExpressionManager} from a VRM extension of a GLTF.\n */\nexport class VRMExpressionLoaderPlugin implements GLTFLoaderPlugin {\n  public static readonly v0v1PresetNameMap: { [v0Name in V0VRM.BlendShapePresetName]?: VRMExpressionPresetName } = {\n    a: 'aa',\n    e: 'ee',\n    i: 'ih',\n    o: 'oh',\n    u: 'ou',\n    blink: 'blink',\n    joy: 'happy',\n    angry: 'angry',\n    sorrow: 'sad',\n    fun: 'relaxed',\n    lookup: 'lookUp',\n    lookdown: 'lookDown',\n    lookleft: 'lookLeft',\n    lookright: 'lookRight',\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    blink_l: 'blinkLeft',\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    blink_r: 'blinkRight',\n    neutral: 'neutral',\n  };\n\n  public readonly parser: GLTFParser;\n\n  public get name(): string {\n    // We should use the extension name instead but we have multiple plugins for an extension...\n    return 'VRMExpressionLoaderPlugin';\n  }\n\n  public constructor(parser: GLTFParser) {\n    this.parser = parser;\n  }\n\n  public async afterRoot(gltf: GLTF): Promise<void> {\n    gltf.userData.vrmExpressionManager = await this._import(gltf);\n  }\n\n  /**\n   * Import a {@link VRMExpressionManager} from a VRM.\n   *\n   * @param gltf A parsed result of GLTF taken from GLTFLoader\n   */\n  private async _import(gltf: GLTF): Promise<VRMExpressionManager | null> {\n    const v1Result = await this._v1Import(gltf);\n    if (v1Result) {\n      return v1Result;\n    }\n\n    const v0Result = await this._v0Import(gltf);\n    if (v0Result) {\n      return v0Result;\n    }\n\n    return null;\n  }\n\n  private async _v1Import(gltf: GLTF): Promise<VRMExpressionManager | null> {\n    const json = this.parser.json as GLTFSchema.IGLTF;\n\n    // early abort if it doesn't use vrm\n    const isVRMUsed = json.extensionsUsed?.indexOf('VRMC_vrm') !== -1;\n    if (!isVRMUsed) {\n      return null;\n    }\n\n    const extension = json.extensions?.['VRMC_vrm'] as V1VRMSchema.VRMCVRM | undefined;\n    if (!extension) {\n      return null;\n    }\n\n    const specVersion = extension.specVersion;\n    if (specVersion !== '1.0-beta') {\n      return null;\n    }\n\n    const schemaExpressions = extension.expressions;\n    if (!schemaExpressions) {\n      return null;\n    }\n\n    // list expressions\n    const presetNameSet = new Set<string>(Object.values(VRMExpressionPresetName));\n    const nameSchemaExpressionMap = new Map<string, V1VRMSchema.Expression>();\n\n    if (schemaExpressions.preset != null) {\n      Object.entries(schemaExpressions.preset).forEach(([name, schemaExpression]) => {\n        if (schemaExpression == null) {\n          return;\n        } // typescript\n\n        if (!presetNameSet.has(name)) {\n          console.warn(`VRMExpressionLoaderPlugin: Unknown preset name \"${name}\" detected. Ignoring the expression`);\n          return;\n        }\n\n        nameSchemaExpressionMap.set(name, schemaExpression);\n      });\n    }\n\n    if (schemaExpressions.custom != null) {\n      Object.entries(schemaExpressions.custom).forEach(([name, schemaExpression]) => {\n        if (presetNameSet.has(name)) {\n          console.warn(\n            `VRMExpressionLoaderPlugin: Custom expression cannot have preset name \"${name}\". Ignoring the expression`,\n          );\n          return;\n        }\n\n        nameSchemaExpressionMap.set(name, schemaExpression);\n      });\n    }\n\n    // prepare manager\n    const manager = new VRMExpressionManager();\n\n    // load expressions\n    await Promise.all(\n      Array.from(nameSchemaExpressionMap.entries()).map(async ([name, schemaExpression]) => {\n        const expression = new VRMExpression(name);\n        gltf.scene.add(expression);\n\n        expression.isBinary = schemaExpression.isBinary ?? false;\n        expression.overrideBlink = schemaExpression.overrideBlink ?? 'none';\n        expression.overrideLookAt = schemaExpression.overrideLookAt ?? 'none';\n        expression.overrideMouth = schemaExpression.overrideMouth ?? 'none';\n\n        schemaExpression.morphTargetBinds?.forEach(async (bind) => {\n          if (bind.node === undefined || bind.index === undefined) {\n            return;\n          }\n\n          const primitives = (await gltfExtractPrimitivesFromNode(gltf, bind.node))!;\n          const morphTargetIndex = bind.index;\n\n          // check if the mesh has the target morph target\n          if (\n            !primitives.every(\n              (primitive) =>\n                Array.isArray(primitive.morphTargetInfluences) &&\n                morphTargetIndex < primitive.morphTargetInfluences.length,\n            )\n          ) {\n            console.warn(\n              `VRMExpressionLoaderPlugin: ${schemaExpression.name} attempts to index morph #${morphTargetIndex} but not found.`,\n            );\n            return;\n          }\n\n          expression.addBind(\n            new VRMExpressionMorphTargetBind({\n              primitives,\n              index: morphTargetIndex,\n              weight: bind.weight ?? 1.0,\n            }),\n          );\n        });\n\n        if (schemaExpression.materialColorBinds || schemaExpression.textureTransformBinds) {\n          // list up every material in `gltf.scene`\n          const gltfMaterials: THREE.Material[] = [];\n          gltf.scene.traverse((object) => {\n            const material = (object as any).material as THREE.Material | undefined;\n            if (material) {\n              gltfMaterials.push(material);\n            }\n          });\n\n          schemaExpression.materialColorBinds?.forEach(async (bind) => {\n            const materials = gltfMaterials.filter((material) => {\n              const materialIndex = gltfGetAssociatedMaterialIndex(this.parser, material);\n              return bind.material === materialIndex;\n            });\n\n            materials.forEach((material) => {\n              expression.addBind(\n                new VRMExpressionMaterialColorBind({\n                  material,\n                  type: bind.type,\n                  targetValue: new THREE.Color().fromArray(bind.targetValue),\n                }),\n              );\n            });\n          });\n\n          schemaExpression.textureTransformBinds?.forEach(async (bind) => {\n            const materials = gltfMaterials.filter((material) => {\n              const materialIndex = gltfGetAssociatedMaterialIndex(this.parser, material);\n              return bind.material === materialIndex;\n            });\n\n            materials.forEach((material) => {\n              expression.addBind(\n                new VRMExpressionTextureTransformBind({\n                  material,\n                  offset: new THREE.Vector2().fromArray(bind.offset ?? [0.0, 0.0]),\n                  scale: new THREE.Vector2().fromArray(bind.scale ?? [1.0, 1.0]),\n                }),\n              );\n            });\n          });\n        }\n\n        manager.registerExpression(expression);\n      }),\n    );\n\n    return manager;\n  }\n\n  private async _v0Import(gltf: GLTF): Promise<VRMExpressionManager | null> {\n    const json = this.parser.json as GLTFSchema.IGLTF;\n\n    // early abort if it doesn't use vrm\n    const vrmExt = json.extensions?.VRM as V0VRM.VRM | undefined;\n    if (!vrmExt) {\n      return null;\n    }\n\n    const schemaBlendShape = vrmExt.blendShapeMaster;\n    if (!schemaBlendShape) {\n      return null;\n    }\n\n    const manager = new VRMExpressionManager();\n\n    const schemaBlendShapeGroups = schemaBlendShape.blendShapeGroups;\n    if (!schemaBlendShapeGroups) {\n      return manager;\n    }\n\n    const blendShapeNameSet = new Set<string>();\n\n    await Promise.all(\n      schemaBlendShapeGroups.map(async (schemaGroup) => {\n        const v0PresetName = schemaGroup.presetName;\n        const v1PresetName =\n          (v0PresetName != null && VRMExpressionLoaderPlugin.v0v1PresetNameMap[v0PresetName]) || null;\n        const name = v1PresetName ?? schemaGroup.name;\n\n        if (name == null) {\n          console.warn('VRMExpressionLoaderPlugin: One of custom expressions has no name. Ignoring the expression');\n          return;\n        }\n\n        // duplication check\n        if (blendShapeNameSet.has(name)) {\n          console.warn(\n            `VRMExpressionLoaderPlugin: An expression preset ${v0PresetName} has duplicated entries. Ignoring the expression`,\n          );\n          return;\n        }\n\n        blendShapeNameSet.add(name);\n\n        const expression = new VRMExpression(name);\n        gltf.scene.add(expression);\n\n        expression.isBinary = schemaGroup.isBinary ?? false;\n        // v0 doesn't have ignore properties\n\n        if (schemaGroup.binds) {\n          schemaGroup.binds.forEach(async (bind) => {\n            if (bind.mesh === undefined || bind.index === undefined) {\n              return;\n            }\n\n            const nodesUsingMesh: number[] = [];\n            json.nodes?.forEach((node, i) => {\n              if (node.mesh === bind.mesh) {\n                nodesUsingMesh.push(i);\n              }\n            });\n\n            const morphTargetIndex = bind.index;\n\n            await Promise.all(\n              nodesUsingMesh.map(async (nodeIndex) => {\n                const primitives = (await gltfExtractPrimitivesFromNode(gltf, nodeIndex))!;\n\n                // check if the mesh has the target morph target\n                if (\n                  !primitives.every(\n                    (primitive) =>\n                      Array.isArray(primitive.morphTargetInfluences) &&\n                      morphTargetIndex < primitive.morphTargetInfluences.length,\n                  )\n                ) {\n                  console.warn(\n                    `VRMExpressionLoaderPlugin: ${schemaGroup.name} attempts to index ${morphTargetIndex}th morph but not found.`,\n                  );\n                  return;\n                }\n\n                expression.addBind(\n                  new VRMExpressionMorphTargetBind({\n                    primitives,\n                    index: morphTargetIndex,\n                    weight: 0.01 * (bind.weight ?? 100), // narrowing the range from [ 0.0 - 100.0 ] to [ 0.0 - 1.0 ]\n                  }),\n                );\n              }),\n            );\n          });\n        }\n\n        const materialValues = schemaGroup.materialValues;\n        if (materialValues && materialValues.length !== 0) {\n          console.warn('Material binds of VRM 0.0 are not supported. Setup the model in VRM 1.0 and try again');\n        }\n\n        manager.registerExpression(expression);\n      }),\n    );\n\n    return manager;\n  }\n}\n","/* eslint-disable @typescript-eslint/naming-convention */\n\nexport const VRMExpressionMaterialColorType = {\n  Color: 'color',\n  EmissionColor: 'emissionColor',\n  ShadeColor: 'shadeColor',\n  RimColor: 'rimColor',\n  OutlineColor: 'outlineColor',\n} as const;\n\nexport type VRMExpressionMaterialColorType = typeof VRMExpressionMaterialColorType[keyof typeof VRMExpressionMaterialColorType];\n","/* eslint-disable @typescript-eslint/naming-convention */\n\nexport const VRMExpressionOverrideType = {\n  None: 'none',\n  Block: 'block',\n  Blend: 'blend',\n} as const;\n\nexport type VRMExpressionOverrideType = typeof VRMExpressionOverrideType[keyof typeof VRMExpressionOverrideType];\n","import type { VRMFirstPersonMeshAnnotation } from './VRMFirstPersonMeshAnnotation';\nimport * as THREE from 'three';\nimport type { VRMHumanoid } from '../humanoid';\n\nexport class VRMFirstPerson {\n  /**\n   * A default camera layer for `FirstPersonOnly` layer.\n   *\n   * @see [[getFirstPersonOnlyLayer]]\n   */\n  public static readonly DEFAULT_FIRSTPERSON_ONLY_LAYER = 9;\n\n  /**\n   * A default camera layer for `ThirdPersonOnly` layer.\n   *\n   * @see [[getThirdPersonOnlyLayer]]\n   */\n  public static readonly DEFAULT_THIRDPERSON_ONLY_LAYER = 10;\n\n  /**\n   * Its associated {@link VRMHumanoid}.\n   */\n  public readonly humanoid: VRMHumanoid;\n  public meshAnnotations: VRMFirstPersonMeshAnnotation[];\n\n  private _firstPersonOnlyLayer = VRMFirstPerson.DEFAULT_FIRSTPERSON_ONLY_LAYER;\n  private _thirdPersonOnlyLayer = VRMFirstPerson.DEFAULT_THIRDPERSON_ONLY_LAYER;\n\n  private _initializedLayers = false;\n\n  /**\n   * Create a new VRMFirstPerson object.\n   *\n   * @param humanoid A {@link VRMHumanoid}\n   * @param meshAnnotations A renderer settings. See the description of [[RendererFirstPersonFlags]] for more info\n   */\n  public constructor(humanoid: VRMHumanoid, meshAnnotations: VRMFirstPersonMeshAnnotation[]) {\n    this.humanoid = humanoid;\n    this.meshAnnotations = meshAnnotations;\n  }\n\n  /**\n   * Copy the given {@link VRMFirstPerson} into this one.\n   * {@link humanoid} must be same as the source one.\n   * @param source The {@link VRMFirstPerson} you want to copy\n   * @returns this\n   */\n  public copy(source: VRMFirstPerson): this {\n    if (this.humanoid !== source.humanoid) {\n      throw new Error('VRMFirstPerson: humanoid must be same in order to copy');\n    }\n\n    this.meshAnnotations = source.meshAnnotations.map((annotation) => ({\n      meshes: annotation.meshes.concat(),\n      type: annotation.type,\n    }));\n\n    return this;\n  }\n\n  /**\n   * Returns a clone of this {@link VRMFirstPerson}.\n   * @returns Copied {@link VRMFirstPerson}\n   */\n  public clone(): VRMFirstPerson {\n    return new VRMFirstPerson(this.humanoid, this.meshAnnotations).copy(this);\n  }\n\n  /**\n   * A camera layer represents `FirstPersonOnly` layer.\n   * Note that **you must call {@link setup} first before you use the layer feature** or it does not work properly.\n   *\n   * The value is {@link DEFAULT_FIRSTPERSON_ONLY_LAYER} by default but you can change the layer by specifying via {@link setup} if you prefer.\n   *\n   * @see https://vrm.dev/en/univrm/api/univrm_use_firstperson/\n   * @see https://threejs.org/docs/#api/en/core/Layers\n   */\n  public get firstPersonOnlyLayer(): number {\n    return this._firstPersonOnlyLayer;\n  }\n\n  /**\n   * A camera layer represents `ThirdPersonOnly` layer.\n   * Note that **you must call {@link setup} first before you use the layer feature** or it does not work properly.\n   *\n   * The value is {@link DEFAULT_THIRDPERSON_ONLY_LAYER} by default but you can change the layer by specifying via {@link setup} if you prefer.\n   *\n   * @see https://vrm.dev/en/univrm/api/univrm_use_firstperson/\n   * @see https://threejs.org/docs/#api/en/core/Layers\n   */\n  public get thirdPersonOnlyLayer(): number {\n    return this._thirdPersonOnlyLayer;\n  }\n\n  /**\n   * In this method, it assigns layers for every meshes based on mesh annotations.\n   * You must call this method first before you use the layer feature.\n   *\n   * 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.\n   *\n   * The `cameraLayer` parameter specifies which layer will be assigned for `FirstPersonOnly` / `ThirdPersonOnly`.\n   * In UniVRM, we specified those by naming each desired layer as `FIRSTPERSON_ONLY_LAYER` / `THIRDPERSON_ONLY_LAYER`\n   * but we are going to specify these layers at here since we are unable to name layers in Three.js.\n   *\n   * @param cameraLayer Specify which layer will be for `FirstPersonOnly` / `ThirdPersonOnly`.\n   */\n  public setup({\n    firstPersonOnlyLayer = VRMFirstPerson.DEFAULT_FIRSTPERSON_ONLY_LAYER,\n    thirdPersonOnlyLayer = VRMFirstPerson.DEFAULT_THIRDPERSON_ONLY_LAYER,\n  } = {}): void {\n    if (this._initializedLayers) {\n      return;\n    }\n    this._firstPersonOnlyLayer = firstPersonOnlyLayer;\n    this._thirdPersonOnlyLayer = thirdPersonOnlyLayer;\n\n    this.meshAnnotations.forEach((item) => {\n      item.meshes.forEach((mesh) => {\n        if (item.type === 'firstPersonOnly') {\n          mesh.layers.set(this._firstPersonOnlyLayer);\n          mesh.traverse((child) => child.layers.set(this._firstPersonOnlyLayer));\n        } else if (item.type === 'thirdPersonOnly') {\n          mesh.layers.set(this._thirdPersonOnlyLayer);\n          mesh.traverse((child) => child.layers.set(this._thirdPersonOnlyLayer));\n        } else if (item.type === 'auto') {\n          this._createHeadlessModel(mesh);\n        }\n      });\n    });\n\n    this._initializedLayers = true;\n  }\n\n  private _excludeTriangles(triangles: number[], bws: number[][], skinIndex: number[][], exclude: number[]): number {\n    let count = 0;\n    if (bws != null && bws.length > 0) {\n      for (let i = 0; i < triangles.length; i += 3) {\n        const a = triangles[i];\n        const b = triangles[i + 1];\n        const c = triangles[i + 2];\n        const bw0 = bws[a];\n        const skin0 = skinIndex[a];\n\n        if (bw0[0] > 0 && exclude.includes(skin0[0])) continue;\n        if (bw0[1] > 0 && exclude.includes(skin0[1])) continue;\n        if (bw0[2] > 0 && exclude.includes(skin0[2])) continue;\n        if (bw0[3] > 0 && exclude.includes(skin0[3])) continue;\n\n        const bw1 = bws[b];\n        const skin1 = skinIndex[b];\n        if (bw1[0] > 0 && exclude.includes(skin1[0])) continue;\n        if (bw1[1] > 0 && exclude.includes(skin1[1])) continue;\n        if (bw1[2] > 0 && exclude.includes(skin1[2])) continue;\n        if (bw1[3] > 0 && exclude.includes(skin1[3])) continue;\n\n        const bw2 = bws[c];\n        const skin2 = skinIndex[c];\n        if (bw2[0] > 0 && exclude.includes(skin2[0])) continue;\n        if (bw2[1] > 0 && exclude.includes(skin2[1])) continue;\n        if (bw2[2] > 0 && exclude.includes(skin2[2])) continue;\n        if (bw2[3] > 0 && exclude.includes(skin2[3])) continue;\n\n        triangles[count++] = a;\n        triangles[count++] = b;\n        triangles[count++] = c;\n      }\n    }\n    return count;\n  }\n\n  private _createErasedMesh(src: THREE.SkinnedMesh, erasingBonesIndex: number[]): THREE.SkinnedMesh {\n    const dst = new THREE.SkinnedMesh(src.geometry.clone(), src.material);\n    dst.name = `${src.name}(erase)`;\n    dst.frustumCulled = src.frustumCulled;\n    dst.layers.set(this._firstPersonOnlyLayer);\n\n    const geometry = dst.geometry;\n\n    const skinIndexAttr = geometry.getAttribute('skinIndex').array;\n    const skinIndex = [];\n    for (let i = 0; i < skinIndexAttr.length; i += 4) {\n      skinIndex.push([skinIndexAttr[i], skinIndexAttr[i + 1], skinIndexAttr[i + 2], skinIndexAttr[i + 3]]);\n    }\n\n    const skinWeightAttr = geometry.getAttribute('skinWeight').array;\n    const skinWeight = [];\n    for (let i = 0; i < skinWeightAttr.length; i += 4) {\n      skinWeight.push([skinWeightAttr[i], skinWeightAttr[i + 1], skinWeightAttr[i + 2], skinWeightAttr[i + 3]]);\n    }\n\n    const index = geometry.getIndex();\n    if (!index) {\n      throw new Error(\"The geometry doesn't have an index buffer\");\n    }\n    const oldTriangles = Array.from(index.array);\n\n    const count = this._excludeTriangles(oldTriangles, skinWeight, skinIndex, erasingBonesIndex);\n    const newTriangle: number[] = [];\n    for (let i = 0; i < count; i++) {\n      newTriangle[i] = oldTriangles[i];\n    }\n    geometry.setIndex(newTriangle);\n\n    // mtoon material includes onBeforeRender. this is unsupported at SkinnedMesh#clone\n    if (src.onBeforeRender) {\n      dst.onBeforeRender = src.onBeforeRender;\n    }\n    dst.bind(new THREE.Skeleton(src.skeleton.bones, src.skeleton.boneInverses), new THREE.Matrix4());\n    return dst;\n  }\n\n  private _createHeadlessModelForSkinnedMesh(parent: THREE.Object3D, mesh: THREE.SkinnedMesh): void {\n    const eraseBoneIndexes: number[] = [];\n    mesh.skeleton.bones.forEach((bone, index) => {\n      if (this._isEraseTarget(bone)) eraseBoneIndexes.push(index);\n    });\n\n    // Unlike UniVRM we don't copy mesh if no invisible bone was found\n    if (!eraseBoneIndexes.length) {\n      mesh.layers.enable(this._thirdPersonOnlyLayer);\n      mesh.layers.enable(this._firstPersonOnlyLayer);\n      return;\n    }\n    mesh.layers.set(this._thirdPersonOnlyLayer);\n    const newMesh = this._createErasedMesh(mesh, eraseBoneIndexes);\n    parent.add(newMesh);\n  }\n\n  private _createHeadlessModel(node: THREE.Object3D): void {\n    if (node.type === 'Group') {\n      node.layers.set(this._thirdPersonOnlyLayer);\n      if (this._isEraseTarget(node)) {\n        node.traverse((child) => child.layers.set(this._thirdPersonOnlyLayer));\n      } else {\n        const parent = new THREE.Group();\n        parent.name = `_headless_${node.name}`;\n        parent.layers.set(this._firstPersonOnlyLayer);\n        node.parent!.add(parent);\n        node.children\n          .filter((child) => child.type === 'SkinnedMesh')\n          .forEach((child) => {\n            const skinnedMesh = child as THREE.SkinnedMesh;\n            this._createHeadlessModelForSkinnedMesh(parent, skinnedMesh);\n          });\n      }\n    } else if (node.type === 'SkinnedMesh') {\n      const skinnedMesh = node as THREE.SkinnedMesh;\n      this._createHeadlessModelForSkinnedMesh(node.parent!, skinnedMesh);\n    } else {\n      if (this._isEraseTarget(node)) {\n        node.layers.set(this._thirdPersonOnlyLayer);\n        node.traverse((child) => child.layers.set(this._thirdPersonOnlyLayer));\n      }\n    }\n  }\n\n  private _isEraseTarget(bone: THREE.Object3D): boolean {\n    if (bone === this.humanoid.getBoneNode('head')) {\n      return true;\n    } else if (!bone.parent) {\n      return false;\n    } else {\n      return this._isEraseTarget(bone.parent);\n    }\n  }\n}\n","import type * as V0VRM from '@pixiv/types-vrm-0.0';\nimport type * as V1VRMSchema from '@pixiv/types-vrmc-vrm-1.0';\nimport type { GLTF, GLTFLoaderPlugin, GLTFParser } from 'three/examples/jsm/loaders/GLTFLoader';\nimport type { VRMHumanoid } from '../humanoid/VRMHumanoid';\nimport { gltfExtractPrimitivesFromNodes } from '../utils/gltfExtractPrimitivesFromNode';\nimport { VRMFirstPerson } from './VRMFirstPerson';\nimport type { VRMFirstPersonMeshAnnotation } from './VRMFirstPersonMeshAnnotation';\nimport type { VRMFirstPersonMeshAnnotationType } from './VRMFirstPersonMeshAnnotationType';\nimport { GLTF as GLTFSchema } from '@gltf-transform/core';\n\n/**\n * A plugin of GLTFLoader that imports a {@link VRMFirstPerson} from a VRM extension of a GLTF.\n */\nexport class VRMFirstPersonLoaderPlugin implements GLTFLoaderPlugin {\n  public readonly parser: GLTFParser;\n\n  public get name(): string {\n    // We should use the extension name instead but we have multiple plugins for an extension...\n    return 'VRMFirstPersonLoaderPlugin';\n  }\n\n  public constructor(parser: GLTFParser) {\n    this.parser = parser;\n  }\n\n  public async afterRoot(gltf: GLTF): Promise<void> {\n    const vrmHumanoid = gltf.userData.vrmHumanoid as VRMHumanoid | undefined;\n\n    // explicitly distinguish null and undefined\n    // since vrmHumanoid might be null as a result\n    if (vrmHumanoid === null) {\n      return;\n    } else if (vrmHumanoid === undefined) {\n      throw new Error(\n        'VRMFirstPersonLoaderPlugin: vrmHumanoid is undefined. VRMHumanoidLoaderPlugin have to be used first',\n      );\n    }\n\n    gltf.userData.vrmFirstPerson = await this._import(gltf, vrmHumanoid);\n  }\n\n  /**\n   * Import a {@link VRMFirstPerson} from a VRM.\n   *\n   * @param gltf A parsed result of GLTF taken from GLTFLoader\n   * @param humanoid A {@link VRMHumanoid} instance that represents the VRM\n   */\n\n  private async _import(gltf: GLTF, humanoid: VRMHumanoid | null): Promise<VRMFirstPerson | null> {\n    if (humanoid == null) {\n      return null;\n    }\n\n    const v1Result = await this._v1Import(gltf, humanoid);\n    if (v1Result) {\n      return v1Result;\n    }\n\n    const v0Result = await this._v0Import(gltf, humanoid);\n    if (v0Result) {\n      return v0Result;\n    }\n\n    return null;\n  }\n\n  private async _v1Import(gltf: GLTF, humanoid: VRMHumanoid): Promise<VRMFirstPerson | null> {\n    const json = this.parser.json as GLTFSchema.IGLTF;\n\n    // early abort if it doesn't use vrm\n    const isVRMUsed = json.extensionsUsed?.indexOf('VRMC_vrm') !== -1;\n    if (!isVRMUsed) {\n      return null;\n    }\n\n    const extension = json.extensions?.['VRMC_vrm'] as V1VRMSchema.VRMCVRM | undefined;\n    if (!extension) {\n      return null;\n    }\n\n    const specVersion = extension.specVersion;\n    if (specVersion !== '1.0-beta') {\n      return null;\n    }\n\n    const schemaFirstPerson = extension.firstPerson;\n    if (!schemaFirstPerson) {\n      return null;\n    }\n\n    const meshAnnotations: VRMFirstPersonMeshAnnotation[] = [];\n    const nodePrimitivesMap = await gltfExtractPrimitivesFromNodes(gltf);\n    Array.from(nodePrimitivesMap.entries()).forEach(([nodeIndex, primitives]) => {\n      const annotation = schemaFirstPerson.meshAnnotations\n        ? schemaFirstPerson.meshAnnotations.find((a) => a.node === nodeIndex)\n        : undefined;\n\n      meshAnnotations.push({\n        meshes: primitives,\n        type: annotation?.type ?? 'both',\n      });\n    });\n\n    return new VRMFirstPerson(humanoid, meshAnnotations);\n  }\n\n  private async _v0Import(gltf: GLTF, humanoid: VRMHumanoid): Promise<VRMFirstPerson | null> {\n    const json = this.parser.json as GLTFSchema.IGLTF;\n\n    const vrmExt = json.extensions?.VRM as V0VRM.VRM | undefined;\n    if (!vrmExt) {\n      return null;\n    }\n\n    const schemaFirstPerson: V0VRM.FirstPerson | undefined = vrmExt.firstPerson;\n    if (!schemaFirstPerson) {\n      return null;\n    }\n\n    const meshAnnotations: VRMFirstPersonMeshAnnotation[] = [];\n    const nodePrimitivesMap = await gltfExtractPrimitivesFromNodes(gltf);\n\n    Array.from(nodePrimitivesMap.entries()).forEach(([nodeIndex, primitives]) => {\n      const schemaNode = json.nodes![nodeIndex];\n\n      const flag = schemaFirstPerson.meshAnnotations\n        ? schemaFirstPerson.meshAnnotations.find((a) => a.mesh === schemaNode.mesh)\n        : undefined;\n\n      meshAnnotations.push({\n        meshes: primitives,\n        type: this._convertV0FlagToV1Type(flag?.firstPersonFlag),\n      });\n    });\n\n    return new VRMFirstPerson(humanoid, meshAnnotations);\n  }\n\n  private _convertV0FlagToV1Type(flag: string | undefined): VRMFirstPersonMeshAnnotationType {\n    if (flag === 'FirstPersonOnly') {\n      return 'firstPersonOnly';\n    } else if (flag === 'ThirdPersonOnly') {\n      return 'thirdPersonOnly';\n    } else if (flag === 'Auto') {\n      return 'auto';\n    } else {\n      return 'both';\n    }\n  }\n}\n","/* eslint-disable @typescript-eslint/naming-convention */\n\nexport const VRMFirstPersonMeshAnnotationType = {\n  Auto: 'auto',\n  Both: 'both',\n  ThirdPersonOnly: 'thirdPersonOnly',\n  FirstPersonOnly: 'firstPersonOnly',\n} as const;\n\nexport type VRMFirstPersonMeshAnnotationType = typeof VRMFirstPersonMeshAnnotationType[keyof typeof VRMFirstPersonMeshAnnotationType];\n","/* eslint-disable @typescript-eslint/naming-convention */\n\nexport const VRMHumanBoneName = {\n  Hips: 'hips',\n  Spine: 'spine',\n  Chest: 'chest',\n  UpperChest: 'upperChest',\n  Neck: 'neck',\n  Head: 'head',\n  LeftEye: 'leftEye',\n  RightEye: 'rightEye',\n  Jaw: 'jaw',\n  LeftUpperLeg: 'leftUpperLeg',\n  LeftLowerLeg: 'leftLowerLeg',\n  LeftFoot: 'leftFoot',\n  LeftToes: 'leftToes',\n  RightUpperLeg: 'rightUpperLeg',\n  RightLowerLeg: 'rightLowerLeg',\n  RightFoot: 'rightFoot',\n  RightToes: 'rightToes',\n  LeftShoulder: 'leftShoulder',\n  LeftUpperArm: 'leftUpperArm',\n  LeftLowerArm: 'leftLowerArm',\n  LeftHand: 'leftHand',\n  RightShoulder: 'rightShoulder',\n  RightUpperArm: 'rightUpperArm',\n  RightLowerArm: 'rightLowerArm',\n  RightHand: 'rightHand',\n  LeftThumbProximal: 'leftThumbProximal',\n  LeftThumbIntermediate: 'leftThumbIntermediate',\n  LeftThumbDistal: 'leftThumbDistal',\n  LeftIndexProximal: 'leftIndexProximal',\n  LeftIndexIntermediate: 'leftIndexIntermediate',\n  LeftIndexDistal: 'leftIndexDistal',\n  LeftMiddleProximal: 'leftMiddleProximal',\n  LeftMiddleIntermediate: 'leftMiddleIntermediate',\n  LeftMiddleDistal: 'leftMiddleDistal',\n  LeftRingProximal: 'leftRingProximal',\n  LeftRingIntermediate: 'leftRingIntermediate',\n  LeftRingDistal: 'leftRingDistal',\n  LeftLittleProximal: 'leftLittleProximal',\n  LeftLittleIntermediate: 'leftLittleIntermediate',\n  LeftLittleDistal: 'leftLittleDistal',\n  RightThumbProximal: 'rightThumbProximal',\n  RightThumbIntermediate: 'rightThumbIntermediate',\n  RightThumbDistal: 'rightThumbDistal',\n  RightIndexProximal: 'rightIndexProximal',\n  RightIndexIntermediate: 'rightIndexIntermediate',\n  RightIndexDistal: 'rightIndexDistal',\n  RightMiddleProximal: 'rightMiddleProximal',\n  RightMiddleIntermediate: 'rightMiddleIntermediate',\n  RightMiddleDistal: 'rightMiddleDistal',\n  RightRingProximal: 'rightRingProximal',\n  RightRingIntermediate: 'rightRingIntermediate',\n  RightRingDistal: 'rightRingDistal',\n  RightLittleProximal: 'rightLittleProximal',\n  RightLittleIntermediate: 'rightLittleIntermediate',\n  RightLittleDistal: 'rightLittleDistal',\n} as const;\n\nexport type VRMHumanBoneName = typeof VRMHumanBoneName[keyof typeof VRMHumanBoneName];\n","import * as THREE from 'three';\n\n/**\n * A compat function for `Quaternion.invert()` / `Quaternion.inverse()`.\n * `Quaternion.invert()` is introduced in r123 and `Quaternion.inverse()` emits a warning.\n * We are going to use this compat for a while.\n * @param target A target quaternion\n */\nexport function quatInvertCompat<T extends THREE.Quaternion>(target: T): T {\n  if ((target as any).invert) {\n    target.invert();\n  } else {\n    (target as any).inverse();\n  }\n\n  return target;\n}\n","import * as THREE from 'three';\nimport { quatInvertCompat } from '../utils/quatInvertCompat';\nimport type { VRMHumanBone } from './VRMHumanBone';\nimport type { VRMHumanBones } from './VRMHumanBones';\nimport type { VRMHumanBoneName } from './VRMHumanBoneName';\nimport type { VRMPose } from './VRMPose';\n\nconst _v3A = new THREE.Vector3();\nconst _quatA = new THREE.Quaternion();\n\n/**\n * A class represents a humanoid of a VRM.\n */\nexport class VRMHumanoid {\n  /**\n   * A {@link VRMHumanBones} that contains all the human bones of the VRM.\n   * You might want to get these bones using {@link VRMHumanoid.getBone}.\n   */\n  public humanBones: VRMHumanBones;\n\n  /**\n   * A {@link VRMPose} that is its default state.\n   * Note that it's not compatible with {@link setPose} and {@link getPose}, since it contains non-relative values of each local transforms.\n   */\n  public restPose: VRMPose;\n\n  /**\n   * Create a new {@link VRMHumanoid}.\n   * @param boneArray A {@link VRMHumanBones} contains all the bones of the new humanoid\n   */\n  public constructor(humanBones: VRMHumanBones) {\n    this.humanBones = humanBones;\n\n    this.restPose = this.getAbsolutePose();\n  }\n\n  /**\n   * Copy the given {@link VRMHumanoid} into this one.\n   * @param source The {@link VRMHumanoid} you want to copy\n   * @returns this\n   */\n  public copy(source: VRMHumanoid): this {\n    this.humanBones = source.humanBones;\n    this.restPose = source.restPose;\n\n    return this;\n  }\n\n  /**\n   * Returns a clone of this {@link VRMHumanoid}.\n   * @returns Copied {@link VRMHumanoid}\n   */\n  public clone(): VRMHumanoid {\n    return new VRMHumanoid(this.humanBones).copy(this);\n  }\n\n  /**\n   * Return the current absolute pose of this humanoid as a {@link VRMPose}.\n   * Note that the output result will contain initial state of the VRM and not compatible between different models.\n   * You might want to use {@link getPose} instead.\n   */\n  public getAbsolutePose(): VRMPose {\n    const pose = {} as VRMPose;\n\n    Object.keys(this.humanBones).forEach((vrmBoneNameString) => {\n      const vrmBoneName = vrmBoneNameString as VRMHumanBoneName;\n      const node = this.getBoneNode(vrmBoneName);\n\n      // Ignore when there are no bone on the VRMHumanoid\n      if (!node) {\n        return;\n      }\n\n      // Get the position / rotation from the node\n      _v3A.copy(node.position);\n      _quatA.copy(node.quaternion);\n\n      // Convert to raw arrays\n      pose[vrmBoneName] = {\n        position: _v3A.toArray() as [number, number, number],\n        rotation: _quatA.toArray() as [number, number, number, number],\n      };\n    });\n\n    return pose;\n  }\n\n  /**\n   * Return the current pose of this humanoid as a {@link VRMPose}.\n   *\n   * Each transform is a local transform relative from rest pose (T-pose).\n   */\n  public getPose(): VRMPose {\n    const pose = {} as VRMPose;\n\n    Object.keys(this.humanBones).forEach((boneNameString) => {\n      const boneName = boneNameString as VRMHumanBoneName;\n      const node = this.getBoneNode(boneName);\n\n      // Ignore when there are no bone on the VRMHumanoid\n      if (!node) {\n        return;\n      }\n\n      // Take a diff from restPose\n      _v3A.set(0, 0, 0);\n      _quatA.identity();\n\n      const restState = this.restPose[boneName];\n      if (restState?.position) {\n        _v3A.fromArray(restState.position).negate();\n      }\n      if (restState?.rotation) {\n        quatInvertCompat(_quatA.fromArray(restState.rotation));\n      }\n\n      // Get the position / rotation from the node\n      _v3A.add(node.position);\n      _quatA.premultiply(node.quaternion);\n\n      // Convert to raw arrays\n      pose[boneName] = {\n        position: _v3A.toArray() as [number, number, number],\n        rotation: _quatA.toArray() as [number, number, number, number],\n      };\n    });\n\n    return pose;\n  }\n\n  /**\n   * Let the humanoid do a specified pose.\n   *\n   * Each transform have to be a local transform relative from rest pose (T-pose).\n   * You can pass what you got from {@link getPose}.\n   *\n   * @param poseObject A [[VRMPose]] that represents a single pose\n   */\n  public setPose(poseObject: VRMPose): void {\n    Object.entries(poseObject).forEach(([boneNameString, state]) => {\n      const boneName = boneNameString as VRMHumanBoneName;\n      const node = this.getBoneNode(boneName);\n\n      // Ignore when there are no bone that is defined in the pose on the VRMHumanoid\n      if (!node) {\n        return;\n      }\n\n      const restState = this.restPose[boneName];\n      if (!restState) {\n        // It's very unlikely. Possibly a bug\n        return;\n      }\n\n      // Apply the state to the actual bone\n      if (state?.position) {\n        node.position.fromArray(state.position);\n\n        if (restState.position) {\n          node.position.add(_v3A.fromArray(restState.position));\n        }\n      }\n\n      if (state?.rotation) {\n        node.quaternion.fromArray(state.rotation);\n\n        if (restState.rotation) {\n          node.quaternion.multiply(_quatA.fromArray(restState.rotation));\n        }\n      }\n    });\n  }\n\n  /**\n   * Reset the humanoid to its rest pose.\n   */\n  public resetPose(): void {\n    Object.entries(this.restPose).forEach(([boneName, rest]) => {\n      const node = this.getBoneNode(boneName as VRMHumanBoneName);\n\n      if (!node) {\n        return;\n      }\n\n      if (rest?.position) {\n        node.position.fromArray(rest.position);\n      }\n\n      if (rest?.rotation) {\n        node.quaternion.fromArray(rest.rotation);\n      }\n    });\n  }\n\n  /**\n   * Return a bone bound to a specified {@link VRMHumanBoneName}, as a {@link VRMHumanBone}.\n   *\n   * @param name Name of the bone you want\n   */\n  public getBone(name: VRMHumanBoneName): VRMHumanBone | undefined {\n    return this.humanBones[name] ?? undefined;\n  }\n\n  /**\n   * Return a bone bound to a specified {@link VRMHumanBoneName}, as a `THREE.Object3D`.\n   *\n   * @param name Name of the bone you want\n   */\n  public getBoneNode(name: VRMHumanBoneName): THREE.Object3D | null {\n    return this.humanBones[name]?.node ?? null;\n  }\n}\n","/* eslint-disable @typescript-eslint/naming-convention */\n\nexport const VRMRequiredHumanBoneName = {\n  Hips: 'hips',\n  Spine: 'spine',\n  Head: 'head',\n  LeftUpperLeg: 'leftUpperLeg',\n  LeftLowerLeg: 'leftLowerLeg',\n  LeftFoot: 'leftFoot',\n  RightUpperLeg: 'rightUpperLeg',\n  RightLowerLeg: 'rightLowerLeg',\n  RightFoot: 'rightFoot',\n  LeftUpperArm: 'leftUpperArm',\n  LeftLowerArm: 'leftLowerArm',\n  LeftHand: 'leftHand',\n  RightUpperArm: 'rightUpperArm',\n  RightLowerArm: 'rightLowerArm',\n  RightHand: 'rightHand',\n} as const;\n\nexport type VRMRequiredHumanBoneName = typeof VRMRequiredHumanBoneName[keyof typeof VRMRequiredHumanBoneName];\n","import type * as V0VRM from '@pixiv/types-vrm-0.0';\nimport type * as V1VRMSchema from '@pixiv/types-vrmc-vrm-1.0';\nimport type { GLTF, GLTFLoaderPlugin, GLTFParser } from 'three/examples/jsm/loaders/GLTFLoader';\nimport { VRMHumanoid } from './VRMHumanoid';\nimport type { VRMHumanBones } from './VRMHumanBones';\nimport { VRMRequiredHumanBoneName } from './VRMRequiredHumanBoneName';\nimport { GLTF as GLTFSchema } from '@gltf-transform/core';\n\n/**\n * A plugin of GLTFLoader that imports a {@link VRMHumanoid} from a VRM extension of a GLTF.\n */\nexport class VRMHumanoidLoaderPlugin implements GLTFLoaderPlugin {\n  public readonly parser: GLTFParser;\n\n  public get name(): string {\n    // We should use the extension name instead but we have multiple plugins for an extension...\n    return 'VRMHumanoidLoaderPlugin';\n  }\n\n  public constructor(parser: GLTFParser) {\n    this.parser = parser;\n  }\n\n  public async afterRoot(gltf: GLTF): Promise<void> {\n    gltf.userData.vrmHumanoid = await this._import(gltf);\n  }\n\n  /**\n   * Import a {@link VRMHumanoid} from a VRM.\n   *\n   * @param gltf A parsed result of GLTF taken from GLTFLoader\n   */\n  private async _import(gltf: GLTF): Promise<VRMHumanoid | null> {\n    const v1Result = await this._v1Import(gltf);\n    if (v1Result) {\n      return v1Result;\n    }\n\n    const v0Result = await this._v0Import(gltf);\n    if (v0Result) {\n      return v0Result;\n    }\n\n    return null;\n  }\n\n  private async _v1Import(gltf: GLTF): Promise<VRMHumanoid | null> {\n    const json = this.parser.json as GLTFSchema.IGLTF;\n\n    // early abort if it doesn't use vrm\n    const isVRMUsed = json.extensionsUsed?.indexOf('VRMC_vrm') !== -1;\n    if (!isVRMUsed) {\n      return null;\n    }\n\n    const extension = json.extensions?.['VRMC_vrm'] as V1VRMSchema.VRMCVRM | undefined;\n    if (!extension) {\n      return null;\n    }\n\n    const specVersion = extension.specVersion;\n    if (specVersion !== '1.0-beta') {\n      return null;\n    }\n\n    const schemaHumanoid = extension.humanoid;\n    if (!schemaHumanoid) {\n      return null;\n    }\n\n    const humanBones: Partial<VRMHumanBones> = {};\n    if (schemaHumanoid.humanBones != null) {\n      await Promise.all(\n        Object.entries(schemaHumanoid.humanBones).map(async ([boneNameString, schemaHumanBone]) => {\n          const boneName = boneNameString as V1VRMSchema.HumanoidHumanBoneName;\n          const index = schemaHumanBone.node;\n\n          const node = await this.parser.getDependency('node', index);\n\n          // if the specified node does not exist, emit a warning\n          if (node == null) {\n            console.warn(`A glTF node bound to the humanoid bone ${boneName} (index = ${index}) does not exist`);\n            return;\n          }\n\n          // set to the `humanBones`\n          humanBones[boneName] = { node };\n        }),\n      );\n    }\n\n    return new VRMHumanoid(this._ensureRequiredBonesExist(humanBones));\n  }\n\n  private async _v0Import(gltf: GLTF): Promise<VRMHumanoid | null> {\n    const json = this.parser.json as GLTFSchema.IGLTF;\n\n    const vrmExt = json.extensions?.VRM as V0VRM.VRM | undefined;\n    if (!vrmExt) {\n      return null;\n    }\n\n    const schemaHumanoid: V0VRM.Humanoid | undefined = vrmExt.humanoid;\n    if (!schemaHumanoid) {\n      return null;\n    }\n\n    const humanBones: Partial<VRMHumanBones> = {};\n    if (schemaHumanoid.humanBones != null) {\n      await Promise.all(\n        schemaHumanoid.humanBones.map(async (bone) => {\n          const boneName = bone.bone;\n          const index = bone.node;\n\n          if (boneName == null || index == null) {\n            return;\n          }\n\n          const node = await this.parser.getDependency('node', index);\n\n          // if the specified node does not exist, emit a warning\n          if (node == null) {\n            console.warn(`A glTF node bound to the humanoid bone ${boneName} (index = ${index}) does not exist`);\n            return;\n          }\n\n          // v0 VRMs might have a multiple nodes attached to a single bone...\n          // so if there already is an entry in the `humanBones`, show a warning and ignore it\n          if (humanBones[boneName] != null) {\n            console.warn(\n              `Multiple bone entries for ${boneName} detected (index = ${index}), ignoring duplicated entries.`,\n            );\n            return;\n          }\n\n          // set to the `humanBones`\n          humanBones[boneName] = { node };\n        }),\n      );\n    }\n\n    return new VRMHumanoid(this._ensureRequiredBonesExist(humanBones));\n  }\n\n  /**\n   * Ensure required bones exist in given human bones.\n   * @param humanBones Human bones\n   * @returns Human bones, no longer partial!\n   */\n  private _ensureRequiredBonesExist(humanBones: Partial<VRMHumanBones>): VRMHumanBones {\n    // ensure required bones exist\n    const missingRequiredBones = Object.values(VRMRequiredHumanBoneName).filter(\n      (requiredBoneName) => humanBones[requiredBoneName] == null,\n    );\n\n    // throw an error if there are missing bones\n    if (missingRequiredBones.length > 0) {\n      throw new Error(\n        `VRMHumanoidLoaderPlugin: These humanoid bones are required but not exist: ${missingRequiredBones.join(', ')}`,\n      );\n    }\n\n    return humanBones as VRMHumanBones;\n  }\n}\n","import * as THREE from 'three';\n\nexport class FanBufferGeometry extends THREE.BufferGeometry {\n  public theta: number;\n  public radius: number;\n  private _currentTheta = 0;\n  private _currentRadius = 0;\n  private readonly _attrPos: THREE.BufferAttribute;\n  private readonly _attrIndex: THREE.BufferAttribute;\n\n  public constructor() {\n    super();\n\n    this.theta = 0.0;\n    this.radius = 0.0;\n    this._currentTheta = 0.0;\n    this._currentRadius = 0.0;\n\n    this._attrPos = new THREE.BufferAttribute(new Float32Array(65 * 3), 3);\n    this.setAttribute('position', this._attrPos);\n\n    this._attrIndex = new THREE.BufferAttribute(new Uint16Array(3 * 63), 1);\n    this.setIndex(this._attrIndex);\n\n    this._buildIndex();\n    this.update();\n  }\n\n  public update(): void {\n    let shouldUpdateGeometry = false;\n\n    if (this._currentTheta !== this.theta) {\n      this._currentTheta = this.theta;\n      shouldUpdateGeometry = true;\n    }\n\n    if (this._currentRadius !== this.radius) {\n      this._currentRadius = this.radius;\n      shouldUpdateGeometry = true;\n    }\n\n    if (shouldUpdateGeometry) {\n      this._buildPosition();\n    }\n  }\n\n  private _buildPosition(): void {\n    this._attrPos.setXYZ(0, 0.0, 0.0, 0.0);\n\n    for (let i = 0; i < 64; i++) {\n      const t = (i / 63.0) * this._currentTheta;\n\n      this._attrPos.setXYZ(i + 1, this._currentRadius * Math.sin(t), 0.0, this._currentRadius * Math.cos(t));\n    }\n\n    this._attrPos.needsUpdate = true;\n  }\n\n  private _buildIndex(): void {\n    for (let i = 0; i < 63; i++) {\n      this._attrIndex.setXYZ(i * 3, 0, i + 1, i + 2);\n    }\n\n    this._attrIndex.needsUpdate = true;\n  }\n}\n","import * as THREE from 'three';\n\nexport class LineAndSphereBufferGeometry extends THREE.BufferGeometry {\n  public radius: number;\n  public tail: THREE.Vector3;\n  private _currentRadius: number;\n  private _currentTail: THREE.Vector3;\n  private readonly _attrPos: THREE.BufferAttribute;\n  private readonly _attrIndex: THREE.BufferAttribute;\n\n  public constructor() {\n    super();\n\n    this.radius = 0.0;\n    this._currentRadius = 0.0;\n\n    this.tail = new THREE.Vector3();\n    this._currentTail = new THREE.Vector3();\n\n    this._attrPos = new THREE.BufferAttribute(new Float32Array(294), 3);\n    this.setAttribute('position', this._attrPos);\n\n    this._attrIndex = new THREE.BufferAttribute(new Uint16Array(194), 1);\n    this.setIndex(this._attrIndex);\n\n    this._buildIndex();\n    this.update();\n  }\n\n  public update(): void {\n    let shouldUpdateGeometry = false;\n\n    if (this._currentRadius !== this.radius) {\n      this._currentRadius = this.radius;\n      shouldUpdateGeometry = true;\n    }\n\n    if (!this._currentTail.equals(this.tail)) {\n      this._currentTail.copy(this.tail);\n      shouldUpdateGeometry = true;\n    }\n\n    if (shouldUpdateGeometry) {\n      this._buildPosition();\n    }\n  }\n\n  private _buildPosition(): void {\n    for (let i = 0; i < 32; i++) {\n      const t = (i / 16.0) * Math.PI;\n\n      this._attrPos.setXYZ(i, Math.cos(t), Math.sin(t), 0.0);\n      this._attrPos.setXYZ(32 + i, 0.0, Math.cos(t), Math.sin(t));\n      this._attrPos.setXYZ(64 + i, Math.sin(t), 0.0, Math.cos(t));\n    }\n\n    this.scale(this._currentRadius, this._currentRadius, this._currentRadius);\n    this.translate(this._currentTail.x, this._currentTail.y, this._currentTail.z);\n\n    this._attrPos.setXYZ(96, 0, 0, 0);\n    this._attrPos.setXYZ(97, this._currentTail.x, this._currentTail.y, this._currentTail.z);\n\n    this._attrPos.needsUpdate = true;\n  }\n\n  private _buildIndex(): void {\n    for (let i = 0; i < 32; i++) {\n      const i1 = (i + 1) % 32;\n\n      this._attrIndex.setXY(i * 2, i, i1);\n      this._attrIndex.setXY(64 + i * 2, 32 + i, 32 + i1);\n      this._attrIndex.setXY(128 + i * 2, 64 + i, 64 + i1);\n    }\n    this._attrIndex.setXY(192, 96, 97);\n\n    this._attrIndex.needsUpdate = true;\n  }\n}\n","import * as THREE from 'three';\nimport { VRMLookAt } from '../VRMLookAt';\nimport { FanBufferGeometry } from './utils/FanBufferGeometry';\nimport { LineAndSphereBufferGeometry } from './utils/LineAndSphereBufferGeometry';\n\nconst _quatA = new THREE.Quaternion();\nconst _quatB = new THREE.Quaternion();\nconst _v3A = new THREE.Vector3();\nconst _v3B = new THREE.Vector3();\n\nconst SQRT_2_OVER_2 = Math.sqrt(2.0) / 2.0;\nconst QUAT_XY_CW90 = new THREE.Quaternion(0, 0, -SQRT_2_OVER_2, SQRT_2_OVER_2);\nconst VEC3_POSITIVE_Y = new THREE.Vector3(0.0, 1.0, 0.0);\n\nexport class VRMLookAtHelper extends THREE.Group {\n  public readonly vrmLookAt: VRMLookAt;\n  private readonly _meshYaw: THREE.Mesh<FanBufferGeometry, THREE.MeshBasicMaterial>;\n  private readonly _meshPitch: THREE.Mesh<FanBufferGeometry, THREE.MeshBasicMaterial>;\n  private readonly _lineTarget: THREE.LineSegments<LineAndSphereBufferGeometry, THREE.LineBasicMaterial>;\n\n  public constructor(lookAt: VRMLookAt) {\n    super();\n    this.matrixAutoUpdate = false;\n\n    this.vrmLookAt = lookAt;\n\n    {\n      const geometry = new FanBufferGeometry();\n      geometry.radius = 0.5;\n\n      const material = new THREE.MeshBasicMaterial({\n        color: 0x00ff00,\n        transparent: true,\n        opacity: 0.5,\n        side: THREE.DoubleSide,\n        depthTest: false,\n        depthWrite: false,\n      });\n\n      this._meshPitch = new THREE.Mesh(geometry, material);\n      this.add(this._meshPitch);\n    }\n\n    {\n      const geometry = new FanBufferGeometry();\n      geometry.radius = 0.5;\n\n      const material = new THREE.MeshBasicMaterial({\n        color: 0xff0000,\n        transparent: true,\n        opacity: 0.5,\n        side: THREE.DoubleSide,\n        depthTest: false,\n        depthWrite: false,\n      });\n\n      this._meshYaw = new THREE.Mesh(geometry, material);\n      this.add(this._meshYaw);\n    }\n\n    {\n      const geometry = new LineAndSphereBufferGeometry();\n      geometry.radius = 0.1;\n\n      const material = new THREE.LineBasicMaterial({\n        color: 0xffffff,\n        depthTest: false,\n        depthWrite: false,\n      });\n\n      this._lineTarget = new THREE.LineSegments(geometry, material);\n      this._lineTarget.frustumCulled = false;\n      this.add(this._lineTarget);\n    }\n  }\n\n  public dispose(): void {\n    this._meshYaw.geometry.dispose();\n    this._meshYaw.material.dispose();\n\n    this._meshPitch.geometry.dispose();\n    this._meshPitch.material.dispose();\n\n    this._lineTarget.geometry.dispose();\n    this._lineTarget.material.dispose();\n  }\n\n  public updateMatrixWorld(force: boolean): void {\n    this.vrmLookAt.getLookAtWorldPosition(_v3A);\n    this.vrmLookAt.getLookAtWorldQuaternion(_quatA);\n\n    const yaw = this.vrmLookAt.euler.y;\n    const pitch = this.vrmLookAt.euler.x;\n\n    this._meshYaw.geometry.theta = yaw;\n    this._meshYaw.geometry.update();\n    this._meshYaw.position.copy(_v3A);\n    this._meshYaw.quaternion.copy(_quatA);\n\n    this._meshPitch.geometry.theta = pitch;\n    this._meshPitch.geometry.update();\n    this._meshPitch.position.copy(_v3A);\n    this._meshPitch.quaternion.copy(_quatA);\n    this._meshPitch.quaternion.multiply(_quatB.setFromAxisAngle(VEC3_POSITIVE_Y, yaw));\n    this._meshPitch.quaternion.multiply(QUAT_XY_CW90);\n\n    const target = this.vrmLookAt.target;\n    if (target != null) {\n      target.getWorldPosition(_v3B).sub(_v3A);\n      this._lineTarget.geometry.tail.copy(_v3B);\n      this._lineTarget.geometry.update();\n      this._lineTarget.position.copy(_v3A);\n    }\n\n    super.updateMatrixWorld(force);\n  }\n}\n","import * as THREE from 'three';\n\nconst _position = new THREE.Vector3();\nconst _scale = new THREE.Vector3();\n\n/**\n * Extract world rotation of an object from its world space matrix, in cheaper way.\n *\n * @param object The object\n * @param out Target vector\n */\nexport function getWorldQuaternionLite(object: THREE.Object3D, out: THREE.Quaternion): THREE.Quaternion {\n  object.matrixWorld.decompose(_position, out, _scale);\n  return out;\n}\n","import * as THREE from 'three';\nimport { VRMHumanoid } from '../humanoid';\nimport { getWorldQuaternionLite } from '../utils/getWorldQuaternionLite';\nimport { quatInvertCompat } from '../utils/quatInvertCompat';\nimport type { VRMLookAtApplier } from './VRMLookAtApplier';\n\nconst _v3A = new THREE.Vector3();\nconst _v3B = new THREE.Vector3();\nconst _v3C = new THREE.Vector3();\nconst _quatA = new THREE.Quaternion();\nconst _quatB = new THREE.Quaternion();\n\n/**\n * A class controls eye gaze movements of a VRM.\n */\nexport class VRMLookAt {\n  public static readonly EULER_ORDER = 'YXZ'; // yaw-pitch-roll\n\n  /**\n   * The origin of LookAt. Position offset from the head bone.\n   */\n  public offsetFromHeadBone = new THREE.Vector3();\n\n  /**\n   * Its associated {@link VRMHumanoid}.\n   */\n  public readonly humanoid: VRMHumanoid;\n\n  /**\n   * The {@link VRMLookAtApplier} of the LookAt.\n   */\n  public applier: VRMLookAtApplier;\n\n  /**\n   * If this is true, the LookAt will be updated automatically by calling {@link update}, towarding the direction to the {@link target}.\n   *\n   * See also: {@link target}\n   */\n  public autoUpdate = true;\n\n  /**\n   * The target object of the LookAt.\n   * Note that it does not make any sense if {@link autoUpdate} is disabled.\n   *\n   * See also: {@link autoUpdate}\n   */\n  public target?: THREE.Object3D;\n\n  /**\n   * The front direction of the face.\n   * Intended to be used for VRM 0.0 compat (VRM 0.0 models are facing Z- instead of Z+).\n   * You usually don't want to touch this.\n   */\n  public faceFront = new THREE.Vector3(0.0, 0.0, 1.0);\n\n  protected _euler: THREE.Euler = new THREE.Euler(0.0, 0.0, 0.0, VRMLookAt.EULER_ORDER);\n\n  /**\n   * Its current euler direction.\n   */\n  public get euler(): THREE.Euler {\n    return this._euler.clone();\n  }\n\n  /**\n   * Create a new {@link VRMLookAt}.\n   *\n   * @param humanoid A {@link VRMHumanoid}\n   * @param applier A {@link VRMLookAtApplier}\n   */\n  public constructor(humanoid: VRMHumanoid, applier: VRMLookAtApplier) {\n    this.humanoid = humanoid;\n    this.applier = applier;\n  }\n\n  /**\n   * Copy the given {@link VRMLookAt} into this one.\n   * {@link humanoid} must be same as the source one.\n   * {@link applier} will reference the same instance as the source one.\n   * @param source The {@link VRMLookAt} you want to copy\n   * @returns this\n   */\n  public copy(source: VRMLookAt): this {\n    if (this.humanoid !== source.humanoid) {\n      throw new Error('VRMLookAt: humanoid must be same in order to copy');\n    }\n\n    this.offsetFromHeadBone.copy(source.offsetFromHeadBone);\n    this.applier = source.applier;\n    this.autoUpdate = source.autoUpdate;\n    this.target = source.target;\n    this.faceFront.copy(source.faceFront);\n\n    return this;\n  }\n\n  /**\n   * Returns a clone of this {@link VRMLookAt}.\n   * Note that {@link humanoid} and {@link applier} will reference the same instance as this one.\n   * @returns Copied {@link VRMLookAt}\n   */\n  public clone(): VRMLookAt {\n    return new VRMLookAt(this.humanoid, this.applier).copy(this);\n  }\n\n  /**\n   * Reset the lookAt direction to initial direction.\n   */\n  public reset(): void {\n    this._euler.set(0.0, 0.0, 0.0);\n\n    this.applier.lookAt(this._euler);\n  }\n\n  /**\n   * Get its head position in world coordinate.\n   *\n   * @param target A target `THREE.Vector3`\n   */\n  public getLookAtWorldPosition(target: THREE.Vector3): THREE.Vector3 {\n    const head = this.humanoid.getBoneNode('head')!;\n\n    return target.copy(this.offsetFromHeadBone).applyMatrix4(head.matrixWorld);\n  }\n\n  /**\n   * Get its LookAt orientation in world coordinate.\n   *\n   * @param target A target `THREE.Vector3`\n   */\n  public getLookAtWorldQuaternion(target: THREE.Quaternion): THREE.Quaternion {\n    const head = this.humanoid.getBoneNode('head')!;\n\n    return getWorldQuaternionLite(head, target);\n  }\n\n  /**\n   * Get its LookAt direction in world coordinate.\n   *\n   * @param target A target `THREE.Vector3`\n   */\n  public getLookAtWorldDirection(target: THREE.Vector3): THREE.Vector3 {\n    this.getLookAtWorldQuaternion(_quatA);\n\n    return target.copy(this.faceFront).applyEuler(this._euler).applyQuaternion(_quatA);\n  }\n\n  /**\n   * Set its LookAt position.\n   * Note that its result will be instantly overwritten if {@link VRMLookAtHead.autoUpdate} is enabled.\n   *\n   * @param position A target position\n   */\n  public lookAt(position: THREE.Vector3): void {\n    this._calcEuler(this._euler, position);\n\n    this.applier.lookAt(this._euler);\n  }\n\n  /**\n   * Update the VRMLookAtHead.\n   * If {@link VRMLookAtHead.autoUpdate} is disabled, it will do nothing.\n   *\n   * @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}.\n   */\n  public update(delta: number): void {\n    if (this.target && this.autoUpdate) {\n      this.lookAt(this.target.getWorldPosition(_v3A));\n\n      this.applier.lookAt(this._euler);\n    }\n  }\n\n  protected _calcEuler(target: THREE.Euler, position: THREE.Vector3): THREE.Euler {\n    // Look at direction in local coordinate\n    const headRotInv = quatInvertCompat(this.getLookAtWorldQuaternion(_quatA));\n    const headPos = this.getLookAtWorldPosition(_v3B);\n    const lookAtDir = _v3C.copy(position).sub(headPos).applyQuaternion(headRotInv).normalize();\n\n    // calculate the rotation\n    const rotLocal = _quatB.setFromUnitVectors(this.faceFront, lookAtDir);\n\n    // Transform the direction into local coordinate from the first person bone\n    _v3C.set(0.0, 0.0, 1.0).applyQuaternion(rotLocal);\n\n    // convert the direction into euler\n    target.x = Math.atan2(-_v3C.y, Math.sqrt(_v3C.x * _v3C.x + _v3C.z * _v3C.z));\n    target.y = Math.atan2(_v3C.x, _v3C.z);\n\n    return target;\n  }\n}\n","import { VRMHumanoid } from '../humanoid';\nimport * as THREE from 'three';\nimport type { VRMLookAtApplier } from './VRMLookAtApplier';\nimport { VRMLookAtRangeMap } from './VRMLookAtRangeMap';\n\nconst _eulerA = new THREE.Euler(0.0, 0.0, 0.0, 'YXZ');\n\n/**\n * A class that applies eye gaze directions to a VRM.\n * It will be used by {@link VRMLookAt}.\n */\nexport class VRMLookAtBoneApplier implements VRMLookAtApplier {\n  /**\n   * Represent its type of applier.\n   */\n  public static readonly type = 'bone';\n\n  /**\n   * Its associated {@link VRMHumanoid}.\n   */\n  public readonly humanoid: VRMHumanoid;\n\n  /**\n   * A {@link VRMLookAtRangeMap} for horizontal inward movement. The left eye moves right. The right eye moves left.\n   */\n  public rangeMapHorizontalInner: VRMLookAtRangeMap;\n\n  /**\n   * A {@link VRMLookAtRangeMap} for horizontal outward movement. The left eye moves left. The right eye moves right.\n   */\n  public rangeMapHorizontalOuter: VRMLookAtRangeMap;\n\n  /**\n   * A {@link VRMLookAtRangeMap} for vertical downward movement. Both eyes move upwards.\n   */\n  public rangeMapVerticalDown: VRMLookAtRangeMap;\n\n  /**\n   * A {@link VRMLookAtRangeMap} for vertical upward movement. Both eyes move downwards.\n   */\n  public rangeMapVerticalUp: VRMLookAtRangeMap;\n\n  /**\n   * Create a new {@link VRMLookAtBoneApplier}.\n   *\n   * @param humanoid A {@link VRMHumanoid}\n   * @param rangeMapHorizontalInner A {@link VRMLookAtRangeMap} used for inner transverse direction\n   * @param rangeMapHorizontalOuter A {@link VRMLookAtRangeMap} used for outer transverse direction\n   * @param rangeMapVerticalDown A {@link VRMLookAtRangeMap} used for down direction\n   * @param rangeMapVerticalUp A {@link VRMLookAtRangeMap} used for up direction\n   */\n  public constructor(\n    humanoid: VRMHumanoid,\n    rangeMapHorizontalInner: VRMLookAtRangeMap,\n    rangeMapHorizontalOuter: VRMLookAtRangeMap,\n    rangeMapVerticalDown: VRMLookAtRangeMap,\n    rangeMapVerticalUp: VRMLookAtRangeMap,\n  ) {\n    this.humanoid = humanoid;\n\n    this.rangeMapHorizontalInner = rangeMapHorizontalInner;\n    this.rangeMapHorizontalOuter = rangeMapHorizontalOuter;\n    this.rangeMapVerticalDown = rangeMapVerticalDown;\n    this.rangeMapVerticalUp = rangeMapVerticalUp;\n  }\n\n  /**\n   * Apply the input angle to its associated VRM model.\n   *\n   * @param angle An input angle\n   */\n  public lookAt(angle: THREE.Euler): void {\n    const srcX = (angle.x * 180.0) / Math.PI;\n    const srcY = (angle.y * 180.0) / Math.PI;\n\n    const leftEye = this.humanoid.getBoneNode('leftEye');\n    const rightEye = this.humanoid.getBoneNode('rightEye');\n\n    // left\n    if (leftEye) {\n      if (srcX < 0.0) {\n        _eulerA.x = (-this.rangeMapVerticalDown.map(-srcX) / 180.0) * Math.PI;\n      } else {\n        _eulerA.x = (this.rangeMapVerticalUp.map(srcX) / 180.0) * Math.PI;\n      }\n\n      if (srcY < 0.0) {\n        _eulerA.y = (-this.rangeMapHorizontalInner.map(-srcY) / 180.0) * Math.PI;\n      } else {\n        _eulerA.y = (this.rangeMapHorizontalOuter.map(srcY) / 180.0) * Math.PI;\n      }\n\n      leftEye.quaternion.setFromEuler(_eulerA);\n    }\n\n    // right\n    if (rightEye) {\n      if (srcX < 0.0) {\n        _eulerA.x = (-this.rangeMapVerticalDown.map(-srcX) / 180.0) * Math.PI;\n      } else {\n        _eulerA.x = (this.rangeMapVerticalUp.map(srcX) / 180.0) * Math.PI;\n      }\n\n      if (srcY < 0.0) {\n        _eulerA.y = (-this.rangeMapHorizontalOuter.map(-srcY) / 180.0) * Math.PI;\n      } else {\n        _eulerA.y = (this.rangeMapHorizontalInner.map(srcY) / 180.0) * Math.PI;\n      }\n\n      rightEye.quaternion.setFromEuler(_eulerA);\n    }\n  }\n}\n","import { VRMExpressionManager } from '../expressions';\nimport * as THREE from 'three';\nimport type { VRMLookAtApplier } from './VRMLookAtApplier';\nimport { VRMLookAtRangeMap } from './VRMLookAtRangeMap';\n\n/**\n * A class that applies eye gaze directions to a VRM.\n * It will be used by {@link VRMLookAt}.\n */\nexport class VRMLookAtExpressionApplier implements VRMLookAtApplier {\n  /**\n   * Represent its type of applier.\n   */\n  public static readonly type = 'expression';\n\n  /**\n   * Its associated {@link VRMExpressionManager}.\n   */\n  public readonly expressions: VRMExpressionManager;\n\n  /**\n   * It won't be used in expression applier.\n   * See also: {@link rangeMapHorizontalOuter}\n   */\n  public rangeMapHorizontalInner: VRMLookAtRangeMap;\n\n  /**\n   * A {@link VRMLookAtRangeMap} for horizontal movement. Both eyes move left or right.\n   */\n  public rangeMapHorizontalOuter: VRMLookAtRangeMap;\n\n  /**\n   * A {@link VRMLookAtRangeMap} for vertical downward movement. Both eyes move upwards.\n   */\n  public rangeMapVerticalDown: VRMLookAtRangeMap;\n\n  /**\n   * A {@link VRMLookAtRangeMap} for vertical upward movement. Both eyes move downwards.\n   */\n  public rangeMapVerticalUp: VRMLookAtRangeMap;\n\n  /**\n   * Create a new {@link VRMLookAtExpressionApplier}.\n   *\n   * @param expressions A {@link VRMExpressionManager}\n   * @param rangeMapHorizontalInner A {@link VRMLookAtRangeMap} used for inner transverse direction\n   * @param rangeMapHorizontalOuter A {@link VRMLookAtRangeMap} used for outer transverse direction\n   * @param rangeMapVerticalDown A {@link VRMLookAtRangeMap} used for down direction\n   * @param rangeMapVerticalUp A {@link VRMLookAtRangeMap} used for up direction\n   */\n  public constructor(\n    expressions: VRMExpressionManager,\n    rangeMapHorizontalInner: VRMLookAtRangeMap,\n    rangeMapHorizontalOuter: VRMLookAtRangeMap,\n    rangeMapVerticalDown: VRMLookAtRangeMap,\n    rangeMapVerticalUp: VRMLookAtRangeMap,\n  ) {\n    this.expressions = expressions;\n\n    this.rangeMapHorizontalInner = rangeMapHorizontalInner;\n    this.rangeMapHorizontalOuter = rangeMapHorizontalOuter;\n    this.rangeMapVerticalDown = rangeMapVerticalDown;\n    this.rangeMapVerticalUp = rangeMapVerticalUp;\n  }\n\n  /**\n   * Apply the input angle to its associated VRM model.\n   *\n   * @param angle An input angle\n   */\n  public lookAt(angle: THREE.Euler): void {\n    const srcX = (angle.x * 180.0) / Math.PI;\n    const srcY = (angle.y * 180.0) / Math.PI;\n\n    if (srcX < 0.0) {\n      this.expressions.setValue('lookDown', 0.0);\n      this.expressions.setValue('lookUp', this.rangeMapVerticalUp.map(-srcX));\n    } else {\n      this.expressions.setValue('lookUp', 0.0);\n      this.expressions.setValue('lookDown', this.rangeMapVerticalDown.map(srcX));\n    }\n\n    if (srcY < 0.0) {\n      this.expressions.setValue('lookLeft', 0.0);\n      this.expressions.setValue('lookRight', this.rangeMapHorizontalOuter.map(-srcY));\n    } else {\n      this.expressions.setValue('lookRight', 0.0);\n      this.expressions.setValue('lookLeft', this.rangeMapHorizontalOuter.map(srcY));\n    }\n  }\n}\n","import { saturate } from '../utils/saturate';\n\nexport class VRMLookAtRangeMap {\n  /**\n   * Limits the maximum angle of the input angle of the LookAt vector from the front of the head (the positive z axis).\n   */\n  public inputMaxValue: number;\n\n  /**\n   * Represents an angle (in degrees) for bone type of LookAt appliers, or a weight for expression type of LookAt appliers.\n   * The input value will take `1.0` when the input angle equals (or greater) to {@link inputMaxValue}.\n   */\n  public outputScale: number;\n\n  /**\n   * Create a new {@link VRMLookAtRangeMap}.\n   *\n   * @param inputMaxValue The {@link inputMaxValue} of the map\n   * @param outputScale The {@link outputScale} of the map\n   */\n  public constructor(inputMaxValue: number, outputScale: number) {\n    this.inputMaxValue = inputMaxValue;\n    this.outputScale = outputScale;\n  }\n\n  /**\n   * Evaluate an input value and output a mapped value.\n   * @param src The input value\n   */\n  public map(src: number): number {\n    return this.outputScale * saturate(src / this.inputMaxValue);\n  }\n}\n","import type * as V0VRM from '@pixiv/types-vrm-0.0';\nimport type * as V1VRMSchema from '@pixiv/types-vrmc-vrm-1.0';\nimport type { GLTF, GLTFLoaderPlugin, GLTFParser } from 'three/examples/jsm/loaders/GLTFLoader';\nimport type { VRMExpressionManager } from '../expressions/VRMExpressionManager';\nimport type { VRMHumanoid } from '../humanoid/VRMHumanoid';\nimport { VRMLookAtHelper } from './helpers/VRMLookAtHelper';\nimport { VRMLookAt } from './VRMLookAt';\nimport type { VRMLookAtApplier } from './VRMLookAtApplier';\nimport { VRMLookAtBoneApplier } from './VRMLookAtBoneApplier';\nimport { VRMLookAtExpressionApplier } from './VRMLookAtExpressionApplier';\nimport type { VRMLookAtLoaderPluginOptions } from './VRMLookAtLoaderPluginOptions';\nimport { VRMLookAtRangeMap } from './VRMLookAtRangeMap';\nimport { GLTF as GLTFSchema } from '@gltf-transform/core';\n\n/**\n * A plugin of GLTFLoader that imports a {@link VRMLookAt} from a VRM extension of a GLTF.\n */\nexport class VRMLookAtLoaderPlugin implements GLTFLoaderPlugin {\n  /**\n   * Specify an Object3D to add {@link VRMLookAtHelper} s.\n   * If not specified, helper will not be created.\n   * If `renderOrder` is set to the root, helpers will copy the same `renderOrder` .\n   */\n  public helperRoot?: THREE.Object3D;\n\n  public readonly parser: GLTFParser;\n\n  public get name(): string {\n    // We should use the extension name instead but we have multiple plugins for an extension...\n    return 'VRMLookAtLoaderPlugin';\n  }\n\n  public constructor(parser: GLTFParser, options?: VRMLookAtLoaderPluginOptions) {\n    this.parser = parser;\n\n    this.helperRoot = options?.helperRoot;\n  }\n\n  public async afterRoot(gltf: GLTF): Promise<void> {\n    const vrmHumanoid = gltf.userData.vrmHumanoid as VRMHumanoid | undefined;\n\n    // explicitly distinguish null and undefined\n    // since vrmHumanoid might be null as a result\n    if (vrmHumanoid === null) {\n      return;\n    } else if (vrmHumanoid === undefined) {\n      throw new Error(\n        'VRMFirstPersonLoaderPlugin: vrmHumanoid is undefined. VRMHumanoidLoaderPlugin have to be used first',\n      );\n    }\n\n    const vrmExpressionManager = gltf.userData.vrmExpressionManager as VRMExpressionManager | undefined;\n\n    if (vrmExpressionManager === null) {\n      return;\n    } else if (vrmExpressionManager === undefined) {\n      throw new Error(\n        'VRMFirstPersonLoaderPlugin: vrmExpressionManager is undefined. VRMExpressionLoaderPlugin have to be used first',\n      );\n    }\n\n    gltf.userData.vrmLookAt = await this._import(gltf, vrmHumanoid, vrmExpressionManager);\n  }\n\n  /**\n   * Import a {@link VRMLookAt} from a VRM.\n   *\n   * @param gltf A parsed result of GLTF taken from GLTFLoader\n   * @param humanoid A {@link VRMHumanoid} instance that represents the VRM\n   * @param expressions A {@link VRMExpressionManager} instance that represents the VRM\n   */\n  private async _import(\n    gltf: GLTF,\n    humanoid: VRMHumanoid | null,\n    expressions: VRMExpressionManager | null,\n  ): Promise<VRMLookAt | null> {\n    if (humanoid == null || expressions == null) {\n      return null;\n    }\n\n    const v1Result = await this._v1Import(gltf, humanoid, expressions);\n    if (v1Result) {\n      return v1Result;\n    }\n\n    const v0Result = await this._v0Import(gltf, humanoid, expressions);\n    if (v0Result) {\n      return v0Result;\n    }\n\n    return null;\n  }\n\n  private async _v1Import(\n    gltf: GLTF,\n    humanoid: VRMHumanoid,\n    expressions: VRMExpressionManager,\n  ): Promise<VRMLookAt | null> {\n    const json = this.parser.json as GLTFSchema.IGLTF;\n\n    // early abort if it doesn't use vrm\n    const isVRMUsed = json.extensionsUsed?.indexOf('VRMC_vrm') !== -1;\n    if (!isVRMUsed) {\n      return null;\n    }\n\n    const extension = json.extensions?.['VRMC_vrm'] as V1VRMSchema.VRMCVRM | undefined;\n    if (!extension) {\n      return null;\n    }\n\n    const specVersion = extension.specVersion;\n    if (specVersion !== '1.0-beta') {\n      return null;\n    }\n\n    const schemaLookAt = extension.lookAt;\n    if (!schemaLookAt) {\n      return null;\n    }\n\n    const defaultOutputScale = schemaLookAt.type === 'expression' ? 1.0 : 10.0;\n\n    const mapHI = this._v1ImportRangeMap(schemaLookAt.rangeMapHorizontalInner, defaultOutputScale);\n    const mapHO = this._v1ImportRangeMap(schemaLookAt.rangeMapHorizontalOuter, defaultOutputScale);\n    const mapVD = this._v1ImportRangeMap(schemaLookAt.rangeMapVerticalDown, defaultOutputScale);\n    const mapVU = this._v1ImportRangeMap(schemaLookAt.rangeMapVerticalUp, defaultOutputScale);\n\n    let applier;\n\n    if (schemaLookAt.type === 'expression') {\n      applier = new VRMLookAtExpressionApplier(expressions, mapHI, mapHO, mapVD, mapVU);\n    } else {\n      applier = new VRMLookAtBoneApplier(humanoid, mapHI, mapHO, mapVD, mapVU);\n    }\n\n    const lookAt = this._importLookAt(humanoid, applier);\n\n    lookAt.offsetFromHeadBone.fromArray(schemaLookAt.offsetFromHeadBone ?? [0.0, 0.06, 0.0]);\n\n    return lookAt;\n  }\n\n  private _v1ImportRangeMap(\n    schemaRangeMap: V1VRMSchema.LookAtRangeMap | undefined,\n    defaultOutputScale: number,\n  ): VRMLookAtRangeMap {\n    return new VRMLookAtRangeMap(\n      schemaRangeMap?.inputMaxValue ?? 90.0,\n      schemaRangeMap?.outputScale ?? defaultOutputScale,\n    );\n  }\n\n  private async _v0Import(\n    gltf: GLTF,\n    humanoid: VRMHumanoid,\n    expressions: VRMExpressionManager,\n  ): Promise<VRMLookAt | null> {\n    const json = this.parser.json as GLTFSchema.IGLTF;\n\n    // early abort if it doesn't use vrm\n    const vrmExt = json.extensions?.VRM as V0VRM.VRM | undefined;\n    if (!vrmExt) {\n      return null;\n    }\n\n    const schemaFirstPerson = vrmExt.firstPerson;\n    if (!schemaFirstPerson) {\n      return null;\n    }\n\n    const defaultOutputScale = schemaFirstPerson.lookAtTypeName === 'BlendShape' ? 1.0 : 10.0;\n\n    const mapHI = this._v0ImportDegreeMap(schemaFirstPerson.lookAtHorizontalInner, defaultOutputScale);\n    const mapHO = this._v0ImportDegreeMap(schemaFirstPerson.lookAtHorizontalOuter, defaultOutputScale);\n    const mapVD = this._v0ImportDegreeMap(schemaFirstPerson.lookAtVerticalDown, defaultOutputScale);\n    const mapVU = this._v0ImportDegreeMap(schemaFirstPerson.lookAtVerticalUp, defaultOutputScale);\n\n    let applier;\n\n    if (schemaFirstPerson.lookAtTypeName === 'BlendShape') {\n      applier = new VRMLookAtExpressionApplier(expressions, mapHI, mapHO, mapVD, mapVU);\n    } else {\n      applier = new VRMLookAtBoneApplier(humanoid, mapHI, mapHO, mapVD, mapVU);\n    }\n\n    const lookAt = this._importLookAt(humanoid, applier);\n\n    if (schemaFirstPerson.firstPersonBoneOffset) {\n      lookAt.offsetFromHeadBone.set(\n        schemaFirstPerson.firstPersonBoneOffset.x ?? 0.0,\n        schemaFirstPerson.firstPersonBoneOffset.y ?? 0.06,\n        -(schemaFirstPerson.firstPersonBoneOffset.z ?? 0.0),\n      );\n    } else {\n      lookAt.offsetFromHeadBone.set(0.0, 0.06, 0.0);\n    }\n\n    // VRM 0.0 are facing Z- instead of Z+\n    lookAt.faceFront.set(0.0, 0.0, -1.0);\n\n    return lookAt;\n  }\n\n  private _v0ImportDegreeMap(\n    schemaDegreeMap: V0VRM.FirstPersonDegreeMap | undefined,\n    defaultOutputScale: number,\n  ): VRMLookAtRangeMap {\n    const curve = schemaDegreeMap?.curve;\n    if (JSON.stringify(curve) !== '[0,0,0,1,1,1,1,0]') {\n      console.warn('Curves of LookAtDegreeMap defined in VRM 0.0 are not supported');\n    }\n\n    return new VRMLookAtRangeMap(schemaDegreeMap?.xRange ?? 90.0, schemaDegreeMap?.yRange ?? defaultOutputScale);\n  }\n\n  private _importLookAt(humanoid: VRMHumanoid, applier: VRMLookAtApplier): VRMLookAt {\n    const lookAt = new VRMLookAt(humanoid, applier);\n\n    if (this.helperRoot) {\n      const helper = new VRMLookAtHelper(lookAt);\n      this.helperRoot.add(helper);\n      helper.renderOrder = this.helperRoot.renderOrder;\n    }\n\n    return lookAt;\n  }\n}\n","/* eslint-disable @typescript-eslint/naming-convention */\n\n/**\n * Represents a type of applier.\n */\nexport const VRMLookAtTypeName = {\n  Bone: 'bone',\n  Expression: 'expression',\n};\n\nexport type VRMLookAtTypeName = typeof VRMLookAtTypeName[keyof typeof VRMLookAtTypeName];\n","/**\n * Yoinked from https://github.com/mrdoob/three.js/blob/master/examples/jsm/loaders/GLTFLoader.js\n */\nexport function resolveURL(url: string, path: string): string {\n  // Invalid URL\n  if (typeof url !== 'string' || url === '') return '';\n\n  // Host Relative URL\n  if (/^https?:\\/\\//i.test(path) && /^\\//.test(url)) {\n    path = path.replace(/(^https?:\\/\\/[^/]+).*/i, '$1');\n  }\n\n  // Absolute URL http://,https://,//\n  if (/^(https?:)?\\/\\//i.test(url)) return url;\n\n  // Data URI\n  if (/^data:.*,.*$/i.test(url)) return url;\n\n  // Blob URL\n  if (/^blob:.*$/i.test(url)) return url;\n\n  // Relative URL\n  return path + url;\n}\n","import type { GLTF, GLTFLoaderPlugin, GLTFParser } from 'three/examples/jsm/loaders/GLTFLoader';\nimport type { VRM0Meta } from './VRM0Meta';\nimport type { VRM1Meta } from './VRM1Meta';\nimport type { VRMMeta } from './VRMMeta';\nimport type { VRMMetaLoaderPluginOptions } from './VRMMetaLoaderPluginOptions';\nimport type * as V0VRM from '@pixiv/types-vrm-0.0';\nimport type * as V1VRMSchema from '@pixiv/types-vrmc-vrm-1.0';\nimport * as THREE from 'three';\nimport { resolveURL } from '../utils/resolveURL';\nimport { GLTF as GLTFSchema } from '@gltf-transform/core';\n\n/**\n * A plugin of GLTFLoader that imports a {@link VRM1Meta} from a VRM extension of a GLTF.\n */\nexport class VRMMetaLoaderPlugin implements GLTFLoaderPlugin {\n  public readonly parser: GLTFParser;\n\n  /**\n   * If `false`, it won't load its thumbnail image ({@link VRM1Meta.thumbnailImage}).\n   * `true` by default.\n   */\n  public needThumbnailImage: boolean;\n\n  /**\n   * A list of license urls.\n   * This meta loader will accept these `licenseUrl`s.\n   * Otherwise it won't be loaded.\n   */\n  public acceptLicenseUrls: string[];\n\n  /**\n   * Whether it should accept VRM0.X meta or not.\n   * Note that it might load {@link VRM0Meta} instead of {@link VRM1Meta} when this is `true`.\n   * `true` by default.\n   */\n  public acceptV0Meta: boolean;\n\n  public get name(): string {\n    // We should use the extension name instead but we have multiple plugins for an extension...\n    return 'VRMMetaLoaderPlugin';\n  }\n\n  public constructor(parser: GLTFParser, options?: VRMMetaLoaderPluginOptions) {\n    this.parser = parser;\n\n    this.needThumbnailImage = options?.needThumbnailImage ?? true;\n    this.acceptLicenseUrls = options?.acceptLicenseUrls ?? ['https://vrm.dev/licenses/1.0/'];\n    this.acceptV0Meta = options?.acceptV0Meta ?? true;\n  }\n\n  public async afterRoot(gltf: GLTF): Promise<void> {\n    gltf.userData.vrmMeta = await this._import(gltf);\n  }\n\n  private async _import(gltf: GLTF): Promise<VRMMeta | null> {\n    const v1Result = await this._v1Import(gltf);\n    if (v1Result != null) {\n      return v1Result;\n    }\n\n    const v0Result = await this._v0Import(gltf);\n    if (v0Result != null) {\n      return v0Result;\n    }\n\n    return null;\n  }\n\n  private async _v1Import(gltf: GLTF): Promise<VRM1Meta | null> {\n    const json = this.parser.json as GLTFSchema.IGLTF;\n\n    // early abort if it doesn't use vrm\n    const isVRMUsed = json.extensionsUsed?.indexOf('VRMC_vrm') !== -1;\n    if (!isVRMUsed) {\n      return null;\n    }\n\n    const extension = json.extensions?.['VRMC_vrm'] as V1VRMSchema.VRMCVRM | undefined;\n    if (extension == null) {\n      return null;\n    }\n\n    const specVersion = extension.specVersion;\n    if (specVersion !== '1.0-beta') {\n      return null;\n    }\n\n    const schemaMeta = extension.meta;\n    if (!schemaMeta) {\n      return null;\n    }\n\n    // throw an error if acceptV0Meta is false\n    const licenseUrl = schemaMeta.licenseUrl;\n    const acceptLicenseUrlsSet = new Set(this.acceptLicenseUrls);\n    if (!acceptLicenseUrlsSet.has(licenseUrl)) {\n      throw new Error(`VRMMetaLoaderPlugin: The license url \"${licenseUrl}\" is not accepted`);\n    }\n\n    let thumbnailImage: HTMLImageElement | undefined = undefined;\n    if (this.needThumbnailImage && schemaMeta.thumbnailImage != null) {\n      thumbnailImage = (await this._extractGLTFImage(schemaMeta.thumbnailImage)) ?? undefined;\n    }\n\n    return {\n      metaVersion: '1',\n      name: schemaMeta.name,\n      version: schemaMeta.version,\n      authors: schemaMeta.authors,\n      copyrightInformation: schemaMeta.copyrightInformation,\n      contactInformation: schemaMeta.contactInformation,\n      references: schemaMeta.references,\n      thirdPartyLicenses: schemaMeta.thirdPartyLicenses,\n      thumbnailImage,\n      licenseUrl: schemaMeta.licenseUrl,\n      avatarPermission: schemaMeta.avatarPermission,\n      allowExcessivelyViolentUsage: schemaMeta.allowExcessivelyViolentUsage,\n      allowExcessivelySexualUsage: schemaMeta.allowExcessivelySexualUsage,\n      commercialUsage: schemaMeta.commercialUsage,\n      allowPoliticalOrReligiousUsage: schemaMeta.allowPoliticalOrReligiousUsage,\n      allowAntisocialOrHateUsage: schemaMeta.allowAntisocialOrHateUsage,\n      creditNotation: schemaMeta.creditNotation,\n      allowRedistribution: schemaMeta.allowRedistribution,\n      modification: schemaMeta.modification,\n      otherLicenseUrl: schemaMeta.otherLicenseUrl,\n    };\n  }\n\n  private async _v0Import(gltf: GLTF): Promise<VRM0Meta | null> {\n    const json = this.parser.json as GLTFSchema.IGLTF;\n\n    // early abort if it doesn't use vrm\n    const vrmExt = json.extensions?.VRM as V0VRM.VRM | undefined;\n    if (!vrmExt) {\n      return null;\n    }\n\n    const schemaMeta = vrmExt.meta;\n    if (!schemaMeta) {\n      return null;\n    }\n\n    // throw an error if acceptV0Meta is false\n    if (!this.acceptV0Meta) {\n      throw new Error('VRMMetaLoaderPlugin: Attempted to load VRM0.X meta but acceptV0Meta is false');\n    }\n\n    // load thumbnail texture\n    let texture: THREE.Texture | null | undefined;\n    if (this.needThumbnailImage && schemaMeta.texture != null && schemaMeta.texture !== -1) {\n      texture = await this.parser.getDependency('texture', schemaMeta.texture);\n    }\n\n    return {\n      metaVersion: '0',\n      allowedUserName: schemaMeta.allowedUserName,\n      author: schemaMeta.author,\n      commercialUssageName: schemaMeta.commercialUssageName,\n      contactInformation: schemaMeta.contactInformation,\n      licenseName: schemaMeta.licenseName,\n      otherLicenseUrl: schemaMeta.otherLicenseUrl,\n      otherPermissionUrl: schemaMeta.otherPermissionUrl,\n      reference: schemaMeta.reference,\n      sexualUssageName: schemaMeta.sexualUssageName,\n      texture: texture ?? undefined,\n      title: schemaMeta.title,\n      version: schemaMeta.version,\n      violentUssageName: schemaMeta.violentUssageName,\n    };\n  }\n\n  private async _extractGLTFImage(index: number): Promise<HTMLImageElement | null> {\n    const json = this.parser.json as GLTFSchema.IGLTF;\n\n    const source = json.images?.[index];\n\n    if (source == null) {\n      console.warn(\n        `VRMMetaLoaderPlugin: Attempt to use images[${index}] of glTF as a thumbnail but the image doesn't exist`,\n      );\n      return null;\n    }\n\n    // Ref: https://github.com/mrdoob/three.js/blob/r124/examples/jsm/loaders/GLTFLoader.js#L2467\n\n    // `source.uri` might be a reference to a file\n    let sourceURI: string | undefined = source.uri;\n\n    // Load the binary as a blob\n    if (source.bufferView != null) {\n      const bufferView = await this.parser.getDependency('bufferView', source.bufferView);\n      const blob = new Blob([bufferView], { type: source.mimeType });\n      sourceURI = URL.createObjectURL(blob);\n    }\n\n    if (sourceURI == null) {\n      console.warn(\n        `VRMMetaLoaderPlugin: Attempt to use images[${index}] of glTF as a thumbnail but the image couldn't load properly`,\n      );\n      return null;\n    }\n\n    const loader = new THREE.ImageLoader();\n    return await loader.loadAsync(resolveURL(sourceURI, (this.parser as any).options.path)).catch((error) => {\n      console.error(error);\n      console.warn('VRMMetaLoaderPlugin: Failed to load a thumbnail image');\n      return null;\n    });\n  }\n}\n","import * as THREE from 'three';\nimport { VRMExpressionManager } from './expressions/VRMExpressionManager';\nimport { VRMFirstPerson } from './firstPerson/VRMFirstPerson';\nimport { VRMHumanoid } from './humanoid/VRMHumanoid';\nimport { VRMLookAt } from './lookAt/VRMLookAt';\nimport { VRMMeta } from './meta/VRMMeta';\nimport { VRMCoreParameters } from './VRMCoreParameters';\n\n/**\n * A class that represents a single VRM model.\n * This class only includes core spec of the VRM (`VRMC_vrm`).\n */\nexport class VRMCore {\n  /**\n   * `THREE.Group` that contains the entire VRM.\n   */\n  public readonly scene: THREE.Group;\n\n  /**\n   * Contains {@link VRMHumanoid} of the VRM.\n   * You can control each bones using {@link VRMHumanoid.getBoneNode}.\n   *\n   * @TODO Add a link to VRM spec\n   */\n  public readonly humanoid?: VRMHumanoid;\n\n  /**\n   * Contains {@link VRMExpressionManager} of the VRM.\n   * You might want to control these facial expressions via {@link VRMExpressionManager.setValue}.\n   */\n  public readonly expressionManager?: VRMExpressionManager;\n\n  /**\n   * Contains {@link VRMFirstPerson} of the VRM.\n   * VRMFirstPerson is mostly used for mesh culling for first person view.\n   */\n  public readonly firstPerson?: VRMFirstPerson;\n\n  /**\n   * Contains {@link VRMLookAt} of the VRM.\n   * You might want to use {@link VRMLookAt.target} to control the eye direction of your VRMs.\n   */\n  public readonly lookAt?: VRMLookAt;\n\n  /**\n   * Contains meta fields of the VRM.\n   * You might want to refer these license fields before use your VRMs.\n   */\n  public readonly meta?: VRMMeta;\n\n  /**\n   * Create a new VRM instance.\n   *\n   * @param params [[VRMParameters]] that represents components of the VRM\n   */\n  public constructor(params: VRMCoreParameters) {\n    this.scene = params.scene;\n    this.humanoid = params.humanoid;\n    this.expressionManager = params.expressionManager;\n    this.firstPerson = params.firstPerson;\n    this.lookAt = params.lookAt;\n    this.meta = params.meta;\n  }\n\n  /**\n   * **You need to call this on your update loop.**\n   *\n   * This function updates every VRM components.\n   *\n   * @param delta deltaTime\n   */\n  public update(delta: number): void {\n    if (this.lookAt) {\n      this.lookAt.update(delta);\n    }\n\n    if (this.expressionManager) {\n      this.expressionManager.update();\n    }\n  }\n}\n","import { GLTF, GLTFLoaderPlugin, GLTFParser } from 'three/examples/jsm/loaders/GLTFLoader';\nimport { VRMCoreLoaderPluginOptions } from './VRMCoreLoaderPluginOptions';\nimport { VRMCore } from './VRMCore';\nimport { VRMExpressionLoaderPlugin } from './expressions/VRMExpressionLoaderPlugin';\nimport { VRMFirstPersonLoaderPlugin } from './firstPerson/VRMFirstPersonLoaderPlugin';\nimport { VRMHumanoidLoaderPlugin } from './humanoid/VRMHumanoidLoaderPlugin';\nimport { VRMMetaLoaderPlugin } from './meta/VRMMetaLoaderPlugin';\nimport { VRMLookAtLoaderPlugin } from './lookAt/VRMLookAtLoaderPlugin';\n\nexport class VRMCoreLoaderPlugin implements GLTFLoaderPlugin {\n  public get name(): string {\n    // We should use the extension name instead but we have multiple plugins for an extension...\n    return 'VRMC_vrm';\n  }\n\n  public readonly parser: GLTFParser;\n\n  public readonly expressionPlugin: VRMExpressionLoaderPlugin;\n  public readonly firstPersonPlugin: VRMFirstPersonLoaderPlugin;\n  public readonly humanoidPlugin: VRMHumanoidLoaderPlugin;\n  public readonly lookAtPlugin: VRMLookAtLoaderPlugin;\n  public readonly metaPlugin: VRMMetaLoaderPlugin;\n\n  public constructor(parser: GLTFParser, options?: VRMCoreLoaderPluginOptions) {\n    this.parser = parser;\n\n    const helperRoot = options?.helperRoot;\n\n    this.expressionPlugin = options?.expressionPlugin ?? new VRMExpressionLoaderPlugin(parser);\n    this.firstPersonPlugin = options?.firstPersonPlugin ?? new VRMFirstPersonLoaderPlugin(parser);\n    this.humanoidPlugin = options?.humanoidPlugin ?? new VRMHumanoidLoaderPlugin(parser);\n    this.lookAtPlugin = options?.lookAtPlugin ?? new VRMLookAtLoaderPlugin(parser, { helperRoot });\n    this.metaPlugin = options?.metaPlugin ?? new VRMMetaLoaderPlugin(parser);\n  }\n\n  public async afterRoot(gltf: GLTF): Promise<void> {\n    await this.metaPlugin.afterRoot(gltf);\n    await this.humanoidPlugin.afterRoot(gltf);\n    await this.expressionPlugin.afterRoot(gltf);\n    await this.lookAtPlugin.afterRoot(gltf);\n    await this.firstPersonPlugin.afterRoot(gltf);\n\n    const vrmCore = new VRMCore({\n      scene: gltf.scene,\n      expressionManager: gltf.userData.vrmExpressionManager,\n      firstPerson: gltf.userData.vrmFirstPerson,\n      humanoid: gltf.userData.vrmHumanoid,\n      lookAt: gltf.userData.vrmLookAt,\n      meta: gltf.userData.vrmMeta,\n    });\n    gltf.userData.vrmCore = vrmCore;\n  }\n}\n"],"names":["_v3A","_quatA","_quatB","_v3B"],"mappings":"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"}
+export { VRMCore, VRMCoreLoaderPlugin, VRMExpression, VRMExpressionLoaderPlugin, VRMExpressionManager, VRMExpressionMaterialColorType, VRMExpressionOverrideType, VRMExpressionPresetName, VRMFirstPerson, VRMFirstPersonLoaderPlugin, VRMFirstPersonMeshAnnotationType, VRMHumanBoneList, VRMHumanBoneName, VRMHumanBoneParentMap, VRMHumanoid, VRMHumanoidHelper, VRMHumanoidLoaderPlugin, VRMLookAt, VRMLookAtBoneApplier, VRMLookAtExpressionApplier, VRMLookAtHelper, VRMLookAtLoaderPlugin, VRMLookAtRangeMap, VRMLookAtTypeName, VRMMetaLoaderPlugin, VRMRequiredHumanBoneName };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"three-vrm-core.module.js","sources":["../src/expressions/VRMExpression.ts","../../../node_modules/tslib/tslib.es6.js","../src/utils/gltfExtractPrimitivesFromNode.ts","../src/utils/gltfGetAssociatedMaterialIndex.ts","../src/expressions/VRMExpressionPresetName.ts","../src/utils/saturate.ts","../src/expressions/VRMExpressionManager.ts","../src/expressions/VRMExpressionMaterialColorType.ts","../src/expressions/VRMExpressionMaterialColorBind.ts","../src/expressions/VRMExpressionMorphTargetBind.ts","../src/expressions/VRMExpressionTextureTransformBind.ts","../src/expressions/VRMExpressionLoaderPlugin.ts","../src/expressions/VRMExpressionOverrideType.ts","../src/firstPerson/VRMFirstPerson.ts","../src/firstPerson/VRMFirstPersonLoaderPlugin.ts","../src/firstPerson/VRMFirstPersonMeshAnnotationType.ts","../src/humanoid/helpers/VRMHumanoidHelper.ts","../src/humanoid/VRMHumanBoneList.ts","../src/humanoid/VRMHumanBoneName.ts","../src/humanoid/VRMHumanBoneParentMap.ts","../src/utils/quatInvertCompat.ts","../src/humanoid/VRMRig.ts","../src/humanoid/VRMHumanoidRig.ts","../src/humanoid/VRMHumanoid.ts","../src/humanoid/VRMRequiredHumanBoneName.ts","../src/humanoid/VRMHumanoidLoaderPlugin.ts","../src/lookAt/helpers/utils/FanBufferGeometry.ts","../src/lookAt/helpers/utils/LineAndSphereBufferGeometry.ts","../src/lookAt/helpers/VRMLookAtHelper.ts","../src/utils/getWorldQuaternionLite.ts","../src/lookAt/utils/calcAzimuthAltitude.ts","../src/lookAt/utils/sanitizeAngle.ts","../src/lookAt/VRMLookAt.ts","../src/lookAt/VRMLookAtBoneApplier.ts","../src/lookAt/VRMLookAtExpressionApplier.ts","../src/lookAt/VRMLookAtRangeMap.ts","../src/lookAt/VRMLookAtLoaderPlugin.ts","../src/lookAt/VRMLookAtTypeName.ts","../src/utils/resolveURL.ts","../src/meta/VRMMetaLoaderPlugin.ts","../src/VRMCore.ts","../src/VRMCoreLoaderPlugin.ts"],"sourcesContent":["import * as THREE from 'three';\nimport { VRMExpressionBind } from './VRMExpressionBind';\nimport type { VRMExpressionOverrideType } from './VRMExpressionOverrideType';\n\n// animationMixer の監視対象は、Scene の中に入っている必要がある。\n// そのため、表示オブジェクトではないけれど、Object3D を継承して Scene に投入できるようにする。\nexport class VRMExpression extends THREE.Object3D {\n  /**\n   * Name of this expression.\n   * Distinguished with `name` since `name` will be conflicted with Object3D.\n   */\n  public expressionName: string;\n\n  /**\n   * The current weight of the expression.\n   */\n  public weight = 0.0;\n\n  /**\n   * Interpret values greater than 0.5 as 1.0, ortherwise 0.0.\n   */\n  public isBinary = false;\n\n  /**\n   * Specify how the expression overrides blink expressions.\n   */\n  public overrideBlink: VRMExpressionOverrideType = 'none';\n\n  /**\n   * Specify how the expression overrides lookAt expressions.\n   */\n  public overrideLookAt: VRMExpressionOverrideType = 'none';\n\n  /**\n   * Specify how the expression overrides mouth expressions.\n   */\n  public overrideMouth: VRMExpressionOverrideType = 'none';\n\n  private _binds: VRMExpressionBind[] = [];\n\n  /**\n   * A value represents how much it should override blink expressions.\n   * `0.0` == no override at all, `1.0` == completely block the expressions.\n   */\n  public get overrideBlinkAmount(): number {\n    if (this.overrideBlink === 'block') {\n      return 0.0 < this.weight ? 1.0 : 0.0;\n    } else if (this.overrideBlink === 'blend') {\n      return this.weight;\n    } else {\n      return 0.0;\n    }\n  }\n\n  /**\n   * A value represents how much it should override lookAt expressions.\n   * `0.0` == no override at all, `1.0` == completely block the expressions.\n   */\n  public get overrideLookAtAmount(): number {\n    if (this.overrideLookAt === 'block') {\n      return 0.0 < this.weight ? 1.0 : 0.0;\n    } else if (this.overrideLookAt === 'blend') {\n      return this.weight;\n    } else {\n      return 0.0;\n    }\n  }\n\n  /**\n   * A value represents how much it should override mouth expressions.\n   * `0.0` == no override at all, `1.0` == completely block the expressions.\n   */\n  public get overrideMouthAmount(): number {\n    if (this.overrideMouth === 'block') {\n      return 0.0 < this.weight ? 1.0 : 0.0;\n    } else if (this.overrideMouth === 'blend') {\n      return this.weight;\n    } else {\n      return 0.0;\n    }\n  }\n\n  constructor(expressionName: string) {\n    super();\n\n    this.name = `VRMExpression_${expressionName}`;\n    this.expressionName = expressionName;\n\n    // traverse 時の救済手段として Object3D ではないことを明示しておく\n    this.type = 'VRMExpression';\n    // 表示目的のオブジェクトではないので、負荷軽減のために visible を false にしておく。\n    // これにより、このインスタンスに対する毎フレームの matrix 自動計算を省略できる。\n    this.visible = false;\n  }\n\n  public addBind(bind: VRMExpressionBind): void {\n    this._binds.push(bind);\n  }\n\n  /**\n   * Apply weight to every assigned blend shapes.\n   * Should be called every frame.\n   */\n  public applyWeight(options?: {\n    /**\n     * Multiplies a value to its weight to apply.\n     * Intended to be used for overriding an expression weight by another expression.\n     * See also: {@link overrideBlink}, {@link overrideLookAt}, {@link overrideMouth}\n     */\n    multiplier?: number;\n  }): void {\n    let actualWeight = this.isBinary ? (this.weight <= 0.5 ? 0.0 : 1.0) : this.weight;\n    actualWeight *= options?.multiplier ?? 1.0;\n\n    this._binds.forEach((bind) => bind.applyWeight(actualWeight));\n  }\n\n  /**\n   * Clear previously assigned blend shapes.\n   */\n  public clearAppliedWeight(): void {\n    this._binds.forEach((bind) => bind.clearAppliedWeight());\n  }\n}\n","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n}\r\n\r\nexport function __spreadArray(to, from) {\r\n    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)\r\n        to[j] = from[i];\r\n    return to;\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n","import type { GLTF } from 'three/examples/jsm/loaders/GLTFLoader.js';\nimport { GLTF as GLTFSchema } from '@gltf-transform/core';\n\nfunction extractPrimitivesInternal(gltf: GLTF, nodeIndex: number, node: THREE.Object3D): THREE.Mesh[] | null {\n  const json = gltf.parser.json as GLTFSchema.IGLTF;\n\n  /**\n   * Let's list up every possible patterns that parsed gltf nodes with a mesh can have,,,\n   *\n   * \"*\" indicates that those meshes should be listed up using this function\n   *\n   * ### A node with a (mesh, a signle primitive)\n   *\n   * - `THREE.Mesh`: The only primitive of the mesh *\n   *\n   * ### A node with a (mesh, multiple primitives)\n   *\n   * - `THREE.Group`: The root of the mesh\n   *   - `THREE.Mesh`: A primitive of the mesh *\n   *   - `THREE.Mesh`: A primitive of the mesh (2) *\n   *\n   * ### A node with a (mesh, multiple primitives) AND (a child with a mesh, a single primitive)\n   *\n   * - `THREE.Group`: The root of the mesh\n   *   - `THREE.Mesh`: A primitive of the mesh *\n   *   - `THREE.Mesh`: A primitive of the mesh (2) *\n   *   - `THREE.Mesh`: A primitive of a MESH OF THE CHILD\n   *\n   * ### A node with a (mesh, multiple primitives) AND (a child with a mesh, multiple primitives)\n   *\n   * - `THREE.Group`: The root of the mesh\n   *   - `THREE.Mesh`: A primitive of the mesh *\n   *   - `THREE.Mesh`: A primitive of the mesh (2) *\n   *   - `THREE.Group`: The root of a MESH OF THE CHILD\n   *     - `THREE.Mesh`: A primitive of the mesh of the child\n   *     - `THREE.Mesh`: A primitive of the mesh of the child (2)\n   *\n   * ### A node with a (mesh, multiple primitives) BUT the node is a bone\n   *\n   * - `THREE.Bone`: The root of the node, as a bone\n   *   - `THREE.Group`: The root of the mesh\n   *     - `THREE.Mesh`: A primitive of the mesh *\n   *     - `THREE.Mesh`: A primitive of the mesh (2) *\n   *\n   * ### A node with a (mesh, multiple primitives) AND (a child with a mesh, multiple primitives) BUT the node is a bone\n   *\n   * - `THREE.Bone`: The root of the node, as a bone\n   *   - `THREE.Group`: The root of the mesh\n   *     - `THREE.Mesh`: A primitive of the mesh *\n   *     - `THREE.Mesh`: A primitive of the mesh (2) *\n   *   - `THREE.Group`: The root of a MESH OF THE CHILD\n   *     - `THREE.Mesh`: A primitive of the mesh of the child\n   *     - `THREE.Mesh`: A primitive of the mesh of the child (2)\n   *\n   * ...I will take a strategy that traverses the root of the node and take first (primitiveCount) meshes.\n   */\n\n  // Make sure that the node has a mesh\n  const schemaNode = json.nodes?.[nodeIndex];\n  if (schemaNode == null) {\n    console.warn(`extractPrimitivesInternal: Attempt to use nodes[${nodeIndex}] of glTF but the node doesn't exist`);\n    return null;\n  }\n\n  const meshIndex = schemaNode.mesh;\n  if (meshIndex == null) {\n    return null;\n  }\n\n  // How many primitives the mesh has?\n  const schemaMesh = json.meshes?.[meshIndex];\n  if (schemaMesh == null) {\n    console.warn(`extractPrimitivesInternal: Attempt to use meshes[${meshIndex}] of glTF but the mesh doesn't exist`);\n    return null;\n  }\n\n  const primitiveCount = schemaMesh.primitives.length;\n\n  // Traverse the node and take first (primitiveCount) meshes\n  const primitives: THREE.Mesh[] = [];\n  node.traverse((object) => {\n    if (primitives.length < primitiveCount) {\n      if ((object as any).isMesh) {\n        primitives.push(object as THREE.Mesh);\n      }\n    }\n  });\n\n  return primitives;\n}\n\n/**\n * Extract primitives ( `THREE.Mesh[]` ) of a node from a loaded GLTF.\n * The main purpose of this function is to distinguish primitives and children from a node that has both meshes and children.\n *\n * It utilizes the behavior that GLTFLoader adds mesh primitives to the node object ( `THREE.Group` ) first then adds its children.\n *\n * @param gltf A GLTF object taken from GLTFLoader\n * @param nodeIndex The index of the node\n */\nexport async function gltfExtractPrimitivesFromNode(gltf: GLTF, nodeIndex: number): Promise<THREE.Mesh[] | null> {\n  const node: THREE.Object3D = await gltf.parser.getDependency('node', nodeIndex);\n  return extractPrimitivesInternal(gltf, nodeIndex, node);\n}\n\n/**\n * Extract primitives ( `THREE.Mesh[]` ) of nodes from a loaded GLTF.\n * See {@link gltfExtractPrimitivesFromNode} for more details.\n *\n * It returns a map from node index to extraction result.\n * If a node does not have a mesh, the entry for the node will not be put in the returning map.\n *\n * @param gltf A GLTF object taken from GLTFLoader\n */\nexport async function gltfExtractPrimitivesFromNodes(gltf: GLTF): Promise<Map<number, THREE.Mesh[]>> {\n  const nodes: THREE.Object3D[] = await gltf.parser.getDependencies('node');\n  const map = new Map<number, THREE.Mesh[]>();\n\n  nodes.forEach((node, index) => {\n    const result = extractPrimitivesInternal(gltf, index, node);\n    if (result != null) {\n      map.set(index, result);\n    }\n  });\n\n  return map;\n}\n","import * as THREE from 'three';\nimport { GLTFParser } from 'three/examples/jsm/loaders/GLTFLoader.js';\n\n/**\n * Get a material definition index of glTF from associated material.\n * It's basically a comat code between Three.js r133 or above and previous versions.\n * @param parser GLTFParser\n * @param material A material of gltf\n * @returns Material definition index of glTF\n */\nexport function gltfGetAssociatedMaterialIndex(parser: GLTFParser, material: THREE.Material): number | null {\n  const threeRevision = parseInt(THREE.REVISION, 10);\n\n  let index: number | null = null;\n\n  if (threeRevision >= 133) {\n    index = parser.associations.get(material)?.materials ?? null;\n  } else {\n    // COMPAT: structure of `parser.associations` has been changed @ r133\n    // See: https://github.com/mrdoob/three.js/pull/21737\n    // Ref: https://github.com/three-types/three-ts-types/commit/5246676e479b61a9ff2db71df4119f6f1462580d\n    type GLTFReferencePre133 = {\n      type: 'materials' | 'nodes' | 'textures' | 'meshes';\n      index: number;\n    };\n\n    type GLTFAssociationsPre133 = Map<THREE.Object3D | THREE.Material | THREE.Texture, GLTFReferencePre133>;\n\n    const associations = parser.associations as GLTFAssociationsPre133;\n\n    const reference = associations.get(material);\n\n    if (reference?.type === 'materials') {\n      index = reference.index;\n    }\n  }\n\n  return index;\n}\n","/* eslint-disable @typescript-eslint/naming-convention */\n\nexport const VRMExpressionPresetName = {\n  Aa: 'aa',\n  Ih: 'ih',\n  Ou: 'ou',\n  Ee: 'ee',\n  Oh: 'oh',\n  Blink: 'blink',\n  Happy: 'happy',\n  Angry: 'angry',\n  Sad: 'sad',\n  Relaxed: 'relaxed',\n  LookUp: 'lookUp',\n  Surprised: 'surprised',\n  LookDown: 'lookDown',\n  LookLeft: 'lookLeft',\n  LookRight: 'lookRight',\n  BlinkLeft: 'blinkLeft',\n  BlinkRight: 'blinkRight',\n  Neutral: 'neutral',\n} as const;\n\nexport type VRMExpressionPresetName = typeof VRMExpressionPresetName[keyof typeof VRMExpressionPresetName];\n","/**\n * Clamp the input value within [0.0 - 1.0].\n *\n * @param value The input value\n */\nexport function saturate(value: number): number {\n  return Math.max(Math.min(value, 1.0), 0.0);\n}\n","import { VRMExpressionPresetName } from './VRMExpressionPresetName';\nimport { saturate } from '../utils/saturate';\nimport type { VRMExpression } from './VRMExpression';\n\nexport class VRMExpressionManager {\n  /**\n   * A set of name or preset name of expressions that will be overridden by {@link VRMExpression.overrideBlink}.\n   */\n  public blinkExpressionNames = ['blink', 'blinkLeft', 'blinkRight'];\n\n  /**\n   * A set of name or preset name of expressions that will be overridden by {@link VRMExpression.overrideLookAt}.\n   */\n  public lookAtExpressionNames = ['lookLeft', 'lookRight', 'lookUp', 'lookDown'];\n\n  /**\n   * A set of name or preset name of expressions that will be overridden by {@link VRMExpression.overrideMouth}.\n   */\n  public mouthExpressionNames = ['aa', 'ee', 'ih', 'oh', 'ou'];\n\n  /**\n   * A set of {@link VRMExpression}.\n   * When you want to register expressions, use {@link registerExpression}\n   */\n  private _expressions: VRMExpression[] = [];\n  public get expressions(): VRMExpression[] {\n    return this._expressions.concat();\n  }\n\n  /**\n   * A map from name to expression.\n   */\n  private _expressionMap: { [name: string]: VRMExpression } = {};\n  public get expressionMap(): { [name: string]: VRMExpression } {\n    return Object.assign({}, this._expressionMap);\n  }\n\n  /**\n   * A map from name to expression, but excluding custom expressions.\n   */\n  public get presetExpressionMap(): { [name in VRMExpressionPresetName]?: VRMExpression } {\n    const result: { [name in VRMExpressionPresetName]?: VRMExpression } = {};\n\n    const presetNameSet = new Set<string>(Object.values(VRMExpressionPresetName));\n\n    Object.entries(this._expressionMap).forEach(([name, expression]) => {\n      if (presetNameSet.has(name)) {\n        result[name as VRMExpressionPresetName] = expression;\n      }\n    });\n\n    return result;\n  }\n\n  /**\n   * A map from name to expression, but excluding preset expressions.\n   */\n  public get customExpressionMap(): { [name: string]: VRMExpression } {\n    const result: { [name: string]: VRMExpression } = {};\n\n    const presetNameSet = new Set<string>(Object.values(VRMExpressionPresetName));\n\n    Object.entries(this._expressionMap).forEach(([name, expression]) => {\n      if (!presetNameSet.has(name)) {\n        result[name] = expression;\n      }\n    });\n\n    return result;\n  }\n\n  /**\n   * Create a new {@link VRMExpressionManager}.\n   */\n  public constructor() {\n    // do nothing\n  }\n\n  /**\n   * Copy the given {@link VRMExpressionManager} into this one.\n   * @param source The {@link VRMExpressionManager} you want to copy\n   * @returns this\n   */\n  public copy(source: VRMExpressionManager): this {\n    // first unregister all the expression it has\n    const expressions = this._expressions.concat();\n    expressions.forEach((expression) => {\n      this.unregisterExpression(expression);\n    });\n\n    // then register all the expression of the source\n    source._expressions.forEach((expression) => {\n      this.registerExpression(expression);\n    });\n\n    // copy remaining members\n    this.blinkExpressionNames = source.blinkExpressionNames.concat();\n    this.lookAtExpressionNames = source.lookAtExpressionNames.concat();\n    this.mouthExpressionNames = source.mouthExpressionNames.concat();\n\n    return this;\n  }\n\n  /**\n   * Returns a clone of this {@link VRMExpressionManager}.\n   * @returns Copied {@link VRMExpressionManager}\n   */\n  public clone(): VRMExpressionManager {\n    return new VRMExpressionManager().copy(this);\n  }\n\n  /**\n   * Return a registered expression.\n   * If it cannot find an expression, it will return `null` instead.\n   *\n   * @param name Name or preset name of the expression\n   */\n  public getExpression(name: VRMExpressionPresetName | string): VRMExpression | null {\n    return this._expressionMap[name] ?? null;\n  }\n\n  /**\n   * Register an expression.\n   *\n   * @param expression {@link VRMExpression} that describes the expression\n   */\n  public registerExpression(expression: VRMExpression): void {\n    this._expressions.push(expression);\n    this._expressionMap[expression.expressionName] = expression;\n  }\n\n  /**\n   * Unregister an expression.\n   *\n   * @param expression The expression you want to unregister\n   */\n  public unregisterExpression(expression: VRMExpression): void {\n    const index = this._expressions.indexOf(expression);\n    if (index === -1) {\n      console.warn('VRMExpressionManager: The specified expressions is not registered');\n    }\n\n    this._expressions.splice(index, 1);\n    delete this._expressionMap[expression.expressionName];\n  }\n\n  /**\n   * Get the current weight of the specified expression.\n   * If it doesn't have an expression of given name, it will return `null` instead.\n   *\n   * @param name Name of the expression\n   */\n  public getValue(name: VRMExpressionPresetName | string): number | null {\n    const expression = this.getExpression(name);\n    return expression?.weight ?? null;\n  }\n\n  /**\n   * Set a weight to the specified expression.\n   *\n   * @param name Name of the expression\n   * @param weight Weight\n   */\n  public setValue(name: VRMExpressionPresetName | string, weight: number): void {\n    const expression = this.getExpression(name);\n    if (expression) {\n      expression.weight = saturate(weight);\n    }\n  }\n\n  /**\n   * Get a track name of specified expression.\n   * This track name is needed to manipulate its expression via keyframe animations.\n   *\n   * @example Manipulate an expression using keyframe animation\n   * ```js\n   * const trackName = vrm.expressionManager.getExpressionTrackName( 'blink' );\n   * const track = new THREE.NumberKeyframeTrack(\n   *   name,\n   *   [ 0.0, 0.5, 1.0 ], // times\n   *   [ 0.0, 1.0, 0.0 ] // values\n   * );\n   *\n   * const clip = new THREE.AnimationClip(\n   *   'blink', // name\n   *   1.0, // duration\n   *   [ track ] // tracks\n   * );\n   *\n   * const mixer = new THREE.AnimationMixer( vrm.scene );\n   * const action = mixer.clipAction( clip );\n   * action.play();\n   * ```\n   *\n   * @param name Name of the expression\n   */\n  public getExpressionTrackName(name: VRMExpressionPresetName | string): string | null {\n    const expression = this.getExpression(name);\n    return expression ? `${expression.name}.weight` : null;\n  }\n\n  /**\n   * Update every expressions.\n   */\n  public update(): void {\n    // see how much we should override certain expressions\n    const weightMultipliers = this._calculateWeightMultipliers();\n\n    // reset expression binds first\n    this._expressions.forEach((expression) => {\n      expression.clearAppliedWeight();\n    });\n\n    // then apply binds\n    this._expressions.forEach((expression) => {\n      let multiplier = 1.0;\n      const name = expression.expressionName;\n\n      if (this.blinkExpressionNames.indexOf(name) !== -1) {\n        multiplier *= weightMultipliers.blink;\n      }\n\n      if (this.lookAtExpressionNames.indexOf(name) !== -1) {\n        multiplier *= weightMultipliers.lookAt;\n      }\n\n      if (this.mouthExpressionNames.indexOf(name) !== -1) {\n        multiplier *= weightMultipliers.mouth;\n      }\n\n      expression.applyWeight({ multiplier });\n    });\n  }\n\n  /**\n   * Calculate sum of override amounts to see how much we should multiply weights of certain expressions.\n   */\n  private _calculateWeightMultipliers(): {\n    blink: number;\n    lookAt: number;\n    mouth: number;\n  } {\n    let blink = 1.0;\n    let lookAt = 1.0;\n    let mouth = 1.0;\n\n    this._expressions.forEach((expression) => {\n      blink -= expression.overrideBlinkAmount;\n      lookAt -= expression.overrideLookAtAmount;\n      mouth -= expression.overrideMouthAmount;\n    });\n\n    blink = Math.max(0.0, blink);\n    lookAt = Math.max(0.0, lookAt);\n    mouth = Math.max(0.0, mouth);\n\n    return { blink, lookAt, mouth };\n  }\n}\n","/* eslint-disable @typescript-eslint/naming-convention */\n\nexport const VRMExpressionMaterialColorType = {\n  Color: 'color',\n  EmissionColor: 'emissionColor',\n  ShadeColor: 'shadeColor',\n  MatcapColor: 'matcapColor',\n  RimColor: 'rimColor',\n  OutlineColor: 'outlineColor',\n} as const;\n\nexport type VRMExpressionMaterialColorType = typeof VRMExpressionMaterialColorType[keyof typeof VRMExpressionMaterialColorType];\n\nexport const v0ExpressionMaterialColorMap: { [key: string]: VRMExpressionMaterialColorType | undefined } = {\n  _Color: VRMExpressionMaterialColorType.Color,\n  _EmissionColor: VRMExpressionMaterialColorType.EmissionColor,\n  _ShadeColor: VRMExpressionMaterialColorType.ShadeColor,\n  _RimColor: VRMExpressionMaterialColorType.RimColor,\n  _OutlineColor: VRMExpressionMaterialColorType.OutlineColor,\n};\n","import * as THREE from 'three';\nimport type { VRMExpressionBind } from './VRMExpressionBind';\nimport type { VRMExpressionMaterialColorType } from './VRMExpressionMaterialColorType';\n\nconst _color = new THREE.Color();\n\n/**\n * A bind of expression influences to a material color.\n */\nexport class VRMExpressionMaterialColorBind implements VRMExpressionBind {\n  /**\n   * Mapping of property names from VRMC/materialColorBinds.type to three.js/Material.\n   */\n  private static _propertyNameMapMap: {\n    [distinguisher: string]: { [type in VRMExpressionMaterialColorType]?: string };\n  } = {\n    isMeshStandardMaterial: {\n      color: 'color',\n      emissionColor: 'emissive',\n    },\n    isMeshBasicMaterial: {\n      color: 'color',\n    },\n    isMToonMaterial: {\n      color: 'color',\n      emissionColor: 'emissive',\n      outlineColor: 'outlineColorFactor',\n      matcapColor: 'matcapFactor',\n      rimColor: 'parametricRimColorFactor',\n      shadeColor: 'shadeColorFactor',\n    },\n  };\n\n  /**\n   * The target material.\n   */\n  public readonly material: THREE.Material;\n\n  /**\n   * The type of the target property of the material.\n   */\n  public readonly type: VRMExpressionMaterialColorType;\n\n  /**\n   * The target color.\n   */\n  public readonly targetValue: THREE.Color;\n\n  /**\n   * Its state.\n   * If it cannot find the target property in constructor, it will be null instead.\n   */\n  private _state: {\n    propertyName: string;\n    initialValue: THREE.Color;\n    deltaValue: THREE.Color;\n  } | null;\n\n  public constructor({\n    material,\n    type,\n    targetValue,\n  }: {\n    /**\n     * The target material.\n     */\n    material: THREE.Material;\n\n    /**\n     * The type of the target property of the material.\n     */\n    type: VRMExpressionMaterialColorType;\n\n    /**\n     * The target color.\n     */\n    targetValue: THREE.Color;\n  }) {\n    this.material = material;\n    this.type = type;\n    this.targetValue = targetValue;\n\n    // init property name\n    const propertyNameMap = Object.entries(VRMExpressionMaterialColorBind._propertyNameMapMap).find(\n      ([distinguisher]) => {\n        return (material as any)[distinguisher] === true;\n      },\n    )?.[1];\n    const propertyName = propertyNameMap?.[type] ?? null;\n\n    if (propertyName == null) {\n      console.warn(\n        `Tried to add a material color bind to the material ${\n          material.name ?? '(no name)'\n        }, the type ${type} but the material or the type is not supported.`,\n      );\n\n      this._state = null;\n    } else {\n      const target = (material as any)[propertyName] as THREE.Color;\n\n      const initialValue = target.clone();\n\n      // 負の値を保持するためにColor.subを使わずに差分を計算する\n      const deltaValue = new THREE.Color(\n        targetValue.r - initialValue.r,\n        targetValue.g - initialValue.g,\n        targetValue.b - initialValue.b,\n      );\n\n      this._state = {\n        propertyName,\n        initialValue,\n        deltaValue,\n      };\n    }\n  }\n\n  public applyWeight(weight: number): void {\n    if (this._state == null) {\n      // warning is already emitted in constructor\n      return;\n    }\n\n    const { propertyName, deltaValue } = this._state;\n\n    const target = (this.material as any)[propertyName] as THREE.Color;\n    if (target === undefined) {\n      return;\n    } // TODO: we should kick this at `addMaterialValue`\n\n    target.add(_color.copy(deltaValue).multiplyScalar(weight));\n\n    if (typeof (this.material as any).shouldApplyUniforms === 'boolean') {\n      (this.material as any).shouldApplyUniforms = true;\n    }\n  }\n\n  public clearAppliedWeight(): void {\n    if (this._state == null) {\n      // warning is already emitted in constructor\n      return;\n    }\n\n    const { propertyName, initialValue } = this._state;\n\n    const target = (this.material as any)[propertyName] as THREE.Color;\n    if (target === undefined) {\n      return;\n    } // TODO: we should kick this at `addMaterialValue`\n\n    target.copy(initialValue);\n\n    if (typeof (this.material as any).shouldApplyUniforms === 'boolean') {\n      (this.material as any).shouldApplyUniforms = true;\n    }\n  }\n}\n","import type * as THREE from 'three';\nimport type { VRMExpressionBind } from './VRMExpressionBind';\n\n/**\n * A bind of {@link VRMExpression} influences to morph targets.\n */\nexport class VRMExpressionMorphTargetBind implements VRMExpressionBind {\n  /**\n   * The mesh primitives that attached to target mesh.\n   */\n  public readonly primitives: THREE.Mesh[];\n\n  /**\n   * The index of the morph target in the mesh.\n   */\n  public readonly index: number;\n\n  /**\n   * The weight value of target morph target. Ranging in [0.0 - 1.0].\n   */\n  public readonly weight: number;\n\n  public constructor({\n    primitives,\n    index,\n    weight,\n  }: {\n    /**\n     * The mesh primitives that attached to target mesh.\n     */\n    primitives: THREE.Mesh[];\n\n    /**\n     * The index of the morph target in the mesh.\n     */\n    index: number;\n\n    /**\n     * The weight value of target morph target. Ranging in [0.0 - 1.0].\n     */\n    weight: number;\n  }) {\n    this.primitives = primitives;\n    this.index = index;\n    this.weight = weight;\n  }\n\n  public applyWeight(weight: number): void {\n    this.primitives.forEach((mesh) => {\n      if (mesh.morphTargetInfluences?.[this.index] != null) {\n        mesh.morphTargetInfluences[this.index] += this.weight * weight;\n      }\n    });\n  }\n\n  public clearAppliedWeight(): void {\n    this.primitives.forEach((mesh) => {\n      if (mesh.morphTargetInfluences?.[this.index] != null) {\n        mesh.morphTargetInfluences[this.index] = 0.0;\n      }\n    });\n  }\n}\n","import * as THREE from 'three';\nimport type { VRMExpressionBind } from './VRMExpressionBind';\n\nconst _v2 = new THREE.Vector2();\n\n/**\n * A bind of expression influences to texture transforms.\n */\nexport class VRMExpressionTextureTransformBind implements VRMExpressionBind {\n  private static _propertyNamesMap: { [distinguisher: string]: string[] } = {\n    isMeshStandardMaterial: [\n      'map',\n      'emissiveMap',\n      'bumpMap',\n      'normalMap',\n      'displacementMap',\n      'roughnessMap',\n      'metalnessMap',\n      'alphaMap',\n    ],\n    isMeshBasicMaterial: ['map', 'specularMap', 'alphaMap'],\n    isMToonMaterial: [\n      'map',\n      'normalMap',\n      'emissiveMap',\n      'shadeMultiplyTexture',\n      'rimMultiplyTexture',\n      'outlineWidthMultiplyTexture',\n      'uvAnimationMaskTexture',\n    ],\n  };\n\n  /**\n   * The target material.\n   */\n  public readonly material: THREE.Material;\n\n  /**\n   * The uv scale of the texture.\n   */\n  public readonly scale: THREE.Vector2;\n\n  /**\n   * The uv offset of the texture.\n   */\n  public readonly offset: THREE.Vector2;\n\n  /**\n   * The list of texture names and its state that should be transformed by this bind.\n   */\n  private _properties: {\n    name: string;\n    initialOffset: THREE.Vector2;\n    initialScale: THREE.Vector2;\n    deltaOffset: THREE.Vector2;\n    deltaScale: THREE.Vector2;\n  }[];\n\n  public constructor({\n    material,\n    scale,\n    offset,\n  }: {\n    /**\n     * The target material.\n     */\n    material: THREE.Material;\n\n    /**\n     * The uv scale of the texture.\n     */\n    scale: THREE.Vector2;\n\n    /**\n     * The uv offset of the texture.\n     */\n    offset: THREE.Vector2;\n  }) {\n    this.material = material;\n    this.scale = scale;\n    this.offset = offset;\n\n    const propertyNames = Object.entries(VRMExpressionTextureTransformBind._propertyNamesMap).find(\n      ([distinguisher]) => {\n        return (material as any)[distinguisher] === true;\n      },\n    )?.[1];\n\n    if (propertyNames == null) {\n      console.warn(\n        `Tried to add a texture transform bind to the material ${\n          material.name ?? '(no name)'\n        } but the material is not supported.`,\n      );\n\n      this._properties = [];\n    } else {\n      this._properties = [];\n\n      propertyNames.forEach((propertyName) => {\n        const texture = ((material as any)[propertyName] as THREE.Texture | undefined)?.clone();\n        if (!texture) {\n          return null;\n        }\n\n        (material as any)[propertyName] = texture; // because the texture is cloned\n\n        const initialOffset = texture.offset.clone();\n        const initialScale = texture.repeat.clone();\n        const deltaOffset = offset.clone().sub(initialOffset);\n        const deltaScale = scale.clone().sub(initialScale);\n\n        this._properties.push({\n          name: propertyName,\n          initialOffset,\n          deltaOffset,\n          initialScale,\n          deltaScale,\n        });\n      });\n    }\n  }\n\n  public applyWeight(weight: number): void {\n    this._properties.forEach((property) => {\n      const target = (this.material as any)[property.name] as THREE.Texture;\n      if (target === undefined) {\n        return;\n      } // TODO: we should kick this at `addMaterialValue`\n\n      target.offset.add(_v2.copy(property.deltaOffset).multiplyScalar(weight));\n      target.repeat.add(_v2.copy(property.deltaScale).multiplyScalar(weight));\n\n      target.needsUpdate = true;\n    });\n  }\n\n  public clearAppliedWeight(): void {\n    this._properties.forEach((property) => {\n      const target = (this.material as any)[property.name] as THREE.Texture;\n      if (target === undefined) {\n        return;\n      } // TODO: we should kick this at `addMaterialValue`\n\n      target.offset.copy(property.initialOffset);\n      target.repeat.copy(property.initialScale);\n\n      target.needsUpdate = true;\n    });\n  }\n}\n","import type * as V0VRM from '@pixiv/types-vrm-0.0';\nimport type * as V1VRMSchema from '@pixiv/types-vrmc-vrm-1.0';\nimport * as THREE from 'three';\nimport { GLTF, GLTFLoaderPlugin, GLTFParser } from 'three/examples/jsm/loaders/GLTFLoader.js';\nimport { gltfExtractPrimitivesFromNode } from '../utils/gltfExtractPrimitivesFromNode';\nimport { gltfGetAssociatedMaterialIndex } from '../utils/gltfGetAssociatedMaterialIndex';\nimport { VRMExpression } from './VRMExpression';\nimport { VRMExpressionManager } from './VRMExpressionManager';\nimport { v0ExpressionMaterialColorMap } from './VRMExpressionMaterialColorType';\nimport { VRMExpressionMaterialColorBind } from './VRMExpressionMaterialColorBind';\nimport { VRMExpressionMorphTargetBind } from './VRMExpressionMorphTargetBind';\nimport { VRMExpressionPresetName } from './VRMExpressionPresetName';\nimport { VRMExpressionTextureTransformBind } from './VRMExpressionTextureTransformBind';\nimport { GLTF as GLTFSchema } from '@gltf-transform/core';\n\n/**\n * Possible spec versions it recognizes.\n */\nconst POSSIBLE_SPEC_VERSIONS = new Set(['1.0', '1.0-beta']);\n\n/**\n * A plugin of GLTFLoader that imports a {@link VRMExpressionManager} from a VRM extension of a GLTF.\n */\nexport class VRMExpressionLoaderPlugin implements GLTFLoaderPlugin {\n  public static readonly v0v1PresetNameMap: { [v0Name in V0VRM.BlendShapePresetName]?: VRMExpressionPresetName } = {\n    a: 'aa',\n    e: 'ee',\n    i: 'ih',\n    o: 'oh',\n    u: 'ou',\n    blink: 'blink',\n    joy: 'happy',\n    angry: 'angry',\n    sorrow: 'sad',\n    fun: 'relaxed',\n    lookup: 'lookUp',\n    lookdown: 'lookDown',\n    lookleft: 'lookLeft',\n    lookright: 'lookRight',\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    blink_l: 'blinkLeft',\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    blink_r: 'blinkRight',\n    neutral: 'neutral',\n  };\n\n  public readonly parser: GLTFParser;\n\n  public get name(): string {\n    // We should use the extension name instead but we have multiple plugins for an extension...\n    return 'VRMExpressionLoaderPlugin';\n  }\n\n  public constructor(parser: GLTFParser) {\n    this.parser = parser;\n  }\n\n  public async afterRoot(gltf: GLTF): Promise<void> {\n    gltf.userData.vrmExpressionManager = await this._import(gltf);\n  }\n\n  /**\n   * Import a {@link VRMExpressionManager} from a VRM.\n   *\n   * @param gltf A parsed result of GLTF taken from GLTFLoader\n   */\n  private async _import(gltf: GLTF): Promise<VRMExpressionManager | null> {\n    const v1Result = await this._v1Import(gltf);\n    if (v1Result) {\n      return v1Result;\n    }\n\n    const v0Result = await this._v0Import(gltf);\n    if (v0Result) {\n      return v0Result;\n    }\n\n    return null;\n  }\n\n  private async _v1Import(gltf: GLTF): Promise<VRMExpressionManager | null> {\n    const json = this.parser.json as GLTFSchema.IGLTF;\n\n    // early abort if it doesn't use vrm\n    const isVRMUsed = json.extensionsUsed?.indexOf('VRMC_vrm') !== -1;\n    if (!isVRMUsed) {\n      return null;\n    }\n\n    const extension = json.extensions?.['VRMC_vrm'] as V1VRMSchema.VRMCVRM | undefined;\n    if (!extension) {\n      return null;\n    }\n\n    const specVersion = extension.specVersion;\n    if (!POSSIBLE_SPEC_VERSIONS.has(specVersion)) {\n      console.warn(`VRMExpressionLoaderPlugin: Unknown VRMC_vrm specVersion \"${specVersion}\"`);\n      return null;\n    }\n\n    const schemaExpressions = extension.expressions;\n    if (!schemaExpressions) {\n      return null;\n    }\n\n    // list expressions\n    const presetNameSet = new Set<string>(Object.values(VRMExpressionPresetName));\n    const nameSchemaExpressionMap = new Map<string, V1VRMSchema.Expression>();\n\n    if (schemaExpressions.preset != null) {\n      Object.entries(schemaExpressions.preset).forEach(([name, schemaExpression]) => {\n        if (schemaExpression == null) {\n          return;\n        } // typescript\n\n        if (!presetNameSet.has(name)) {\n          console.warn(`VRMExpressionLoaderPlugin: Unknown preset name \"${name}\" detected. Ignoring the expression`);\n          return;\n        }\n\n        nameSchemaExpressionMap.set(name, schemaExpression);\n      });\n    }\n\n    if (schemaExpressions.custom != null) {\n      Object.entries(schemaExpressions.custom).forEach(([name, schemaExpression]) => {\n        if (presetNameSet.has(name)) {\n          console.warn(\n            `VRMExpressionLoaderPlugin: Custom expression cannot have preset name \"${name}\". Ignoring the expression`,\n          );\n          return;\n        }\n\n        nameSchemaExpressionMap.set(name, schemaExpression);\n      });\n    }\n\n    // prepare manager\n    const manager = new VRMExpressionManager();\n\n    // load expressions\n    await Promise.all(\n      Array.from(nameSchemaExpressionMap.entries()).map(async ([name, schemaExpression]) => {\n        const expression = new VRMExpression(name);\n        gltf.scene.add(expression);\n\n        expression.isBinary = schemaExpression.isBinary ?? false;\n        expression.overrideBlink = schemaExpression.overrideBlink ?? 'none';\n        expression.overrideLookAt = schemaExpression.overrideLookAt ?? 'none';\n        expression.overrideMouth = schemaExpression.overrideMouth ?? 'none';\n\n        schemaExpression.morphTargetBinds?.forEach(async (bind) => {\n          if (bind.node === undefined || bind.index === undefined) {\n            return;\n          }\n\n          const primitives = (await gltfExtractPrimitivesFromNode(gltf, bind.node))!;\n          const morphTargetIndex = bind.index;\n\n          // check if the mesh has the target morph target\n          if (\n            !primitives.every(\n              (primitive) =>\n                Array.isArray(primitive.morphTargetInfluences) &&\n                morphTargetIndex < primitive.morphTargetInfluences.length,\n            )\n          ) {\n            console.warn(\n              `VRMExpressionLoaderPlugin: ${schemaExpression.name} attempts to index morph #${morphTargetIndex} but not found.`,\n            );\n            return;\n          }\n\n          expression.addBind(\n            new VRMExpressionMorphTargetBind({\n              primitives,\n              index: morphTargetIndex,\n              weight: bind.weight ?? 1.0,\n            }),\n          );\n        });\n\n        if (schemaExpression.materialColorBinds || schemaExpression.textureTransformBinds) {\n          // list up every material in `gltf.scene`\n          const gltfMaterials: THREE.Material[] = [];\n          gltf.scene.traverse((object) => {\n            const material = (object as any).material as THREE.Material | undefined;\n            if (material) {\n              gltfMaterials.push(material);\n            }\n          });\n\n          schemaExpression.materialColorBinds?.forEach(async (bind) => {\n            const materials = gltfMaterials.filter((material) => {\n              const materialIndex = gltfGetAssociatedMaterialIndex(this.parser, material);\n              return bind.material === materialIndex;\n            });\n\n            materials.forEach((material) => {\n              expression.addBind(\n                new VRMExpressionMaterialColorBind({\n                  material,\n                  type: bind.type,\n                  targetValue: new THREE.Color().fromArray(bind.targetValue),\n                }),\n              );\n            });\n          });\n\n          schemaExpression.textureTransformBinds?.forEach(async (bind) => {\n            const materials = gltfMaterials.filter((material) => {\n              const materialIndex = gltfGetAssociatedMaterialIndex(this.parser, material);\n              return bind.material === materialIndex;\n            });\n\n            materials.forEach((material) => {\n              expression.addBind(\n                new VRMExpressionTextureTransformBind({\n                  material,\n                  offset: new THREE.Vector2().fromArray(bind.offset ?? [0.0, 0.0]),\n                  scale: new THREE.Vector2().fromArray(bind.scale ?? [1.0, 1.0]),\n                }),\n              );\n            });\n          });\n        }\n\n        manager.registerExpression(expression);\n      }),\n    );\n\n    return manager;\n  }\n\n  private async _v0Import(gltf: GLTF): Promise<VRMExpressionManager | null> {\n    const json = this.parser.json as GLTFSchema.IGLTF;\n\n    // early abort if it doesn't use vrm\n    const vrmExt = json.extensions?.VRM as V0VRM.VRM | undefined;\n    if (!vrmExt) {\n      return null;\n    }\n\n    const schemaBlendShape = vrmExt.blendShapeMaster;\n    if (!schemaBlendShape) {\n      return null;\n    }\n\n    const manager = new VRMExpressionManager();\n\n    const schemaBlendShapeGroups = schemaBlendShape.blendShapeGroups;\n    if (!schemaBlendShapeGroups) {\n      return manager;\n    }\n\n    const blendShapeNameSet = new Set<string>();\n\n    await Promise.all(\n      schemaBlendShapeGroups.map(async (schemaGroup) => {\n        const v0PresetName = schemaGroup.presetName;\n        const v1PresetName =\n          (v0PresetName != null && VRMExpressionLoaderPlugin.v0v1PresetNameMap[v0PresetName]) || null;\n        const name = v1PresetName ?? schemaGroup.name;\n\n        if (name == null) {\n          console.warn('VRMExpressionLoaderPlugin: One of custom expressions has no name. Ignoring the expression');\n          return;\n        }\n\n        // duplication check\n        if (blendShapeNameSet.has(name)) {\n          console.warn(\n            `VRMExpressionLoaderPlugin: An expression preset ${v0PresetName} has duplicated entries. Ignoring the expression`,\n          );\n          return;\n        }\n\n        blendShapeNameSet.add(name);\n\n        const expression = new VRMExpression(name);\n        gltf.scene.add(expression);\n\n        expression.isBinary = schemaGroup.isBinary ?? false;\n        // v0 doesn't have ignore properties\n\n        // Bind morphTarget\n        if (schemaGroup.binds) {\n          schemaGroup.binds.forEach(async (bind) => {\n            if (bind.mesh === undefined || bind.index === undefined) {\n              return;\n            }\n\n            const nodesUsingMesh: number[] = [];\n            json.nodes?.forEach((node, i) => {\n              if (node.mesh === bind.mesh) {\n                nodesUsingMesh.push(i);\n              }\n            });\n\n            const morphTargetIndex = bind.index;\n\n            await Promise.all(\n              nodesUsingMesh.map(async (nodeIndex) => {\n                const primitives = (await gltfExtractPrimitivesFromNode(gltf, nodeIndex))!;\n\n                // check if the mesh has the target morph target\n                if (\n                  !primitives.every(\n                    (primitive) =>\n                      Array.isArray(primitive.morphTargetInfluences) &&\n                      morphTargetIndex < primitive.morphTargetInfluences.length,\n                  )\n                ) {\n                  console.warn(\n                    `VRMExpressionLoaderPlugin: ${schemaGroup.name} attempts to index ${morphTargetIndex}th morph but not found.`,\n                  );\n                  return;\n                }\n\n                expression.addBind(\n                  new VRMExpressionMorphTargetBind({\n                    primitives,\n                    index: morphTargetIndex,\n                    weight: 0.01 * (bind.weight ?? 100), // narrowing the range from [ 0.0 - 100.0 ] to [ 0.0 - 1.0 ]\n                  }),\n                );\n              }),\n            );\n          });\n        }\n\n        // Bind MaterialColor and TextureTransform\n        const materialValues = schemaGroup.materialValues;\n        if (materialValues && materialValues.length !== 0) {\n          materialValues.forEach((materialValue) => {\n            if (\n              materialValue.materialName === undefined ||\n              materialValue.propertyName === undefined ||\n              materialValue.targetValue === undefined\n            ) {\n              return;\n            }\n\n            /**\n             * アバターのオブジェクトに設定されているマテリアルの内から\n             * materialValueで指定されているマテリアルを集める。\n             *\n             * 特定には名前を使用する。\n             * アウトライン描画用のマテリアルも同時に集める。\n             */\n            const materials: THREE.Material[] = [];\n            gltf.scene.traverse((object) => {\n              if ((object as any).material) {\n                const material: THREE.Material[] | THREE.Material = (object as any).material;\n                if (Array.isArray(material)) {\n                  materials.push(\n                    ...material.filter(\n                      (mtl) =>\n                        (mtl.name === materialValue.materialName! ||\n                          mtl.name === materialValue.materialName! + ' (Outline)') &&\n                        materials.indexOf(mtl) === -1,\n                    ),\n                  );\n                } else if (material.name === materialValue.materialName && materials.indexOf(material) === -1) {\n                  materials.push(material);\n                }\n              }\n            });\n\n            const materialPropertyName = materialValue.propertyName;\n            materials.forEach((material) => {\n              // TextureTransformBind\n              if (materialPropertyName === '_MainTex_ST') {\n                const scale = new THREE.Vector2(materialValue.targetValue![0], materialValue.targetValue![1]);\n                const offset = new THREE.Vector2(materialValue.targetValue![2], materialValue.targetValue![3]);\n                expression.addBind(\n                  new VRMExpressionTextureTransformBind({\n                    material,\n                    scale,\n                    offset,\n                  }),\n                );\n\n                return;\n              }\n\n              // MaterialColorBind\n              const materialColorType = v0ExpressionMaterialColorMap[materialPropertyName];\n              if (materialColorType) {\n                expression.addBind(\n                  new VRMExpressionMaterialColorBind({\n                    material,\n                    type: materialColorType,\n                    targetValue: new THREE.Color(...materialValue.targetValue!.slice(0, 3)),\n                  }),\n                );\n\n                return;\n              }\n\n              console.warn(materialPropertyName + ' is not supported');\n            });\n          });\n        }\n\n        manager.registerExpression(expression);\n      }),\n    );\n\n    return manager;\n  }\n}\n","/* eslint-disable @typescript-eslint/naming-convention */\n\nexport const VRMExpressionOverrideType = {\n  None: 'none',\n  Block: 'block',\n  Blend: 'blend',\n} as const;\n\nexport type VRMExpressionOverrideType = typeof VRMExpressionOverrideType[keyof typeof VRMExpressionOverrideType];\n","import type { VRMFirstPersonMeshAnnotation } from './VRMFirstPersonMeshAnnotation';\nimport * as THREE from 'three';\nimport type { VRMHumanoid } from '../humanoid';\n\nexport class VRMFirstPerson {\n  /**\n   * A default camera layer for `FirstPersonOnly` layer.\n   *\n   * @see [[getFirstPersonOnlyLayer]]\n   */\n  public static readonly DEFAULT_FIRSTPERSON_ONLY_LAYER = 9;\n\n  /**\n   * A default camera layer for `ThirdPersonOnly` layer.\n   *\n   * @see [[getThirdPersonOnlyLayer]]\n   */\n  public static readonly DEFAULT_THIRDPERSON_ONLY_LAYER = 10;\n\n  /**\n   * Its associated {@link VRMHumanoid}.\n   */\n  public readonly humanoid: VRMHumanoid;\n  public meshAnnotations: VRMFirstPersonMeshAnnotation[];\n\n  private _firstPersonOnlyLayer = VRMFirstPerson.DEFAULT_FIRSTPERSON_ONLY_LAYER;\n  private _thirdPersonOnlyLayer = VRMFirstPerson.DEFAULT_THIRDPERSON_ONLY_LAYER;\n\n  private _initializedLayers = false;\n\n  /**\n   * Create a new VRMFirstPerson object.\n   *\n   * @param humanoid A {@link VRMHumanoid}\n   * @param meshAnnotations A renderer settings. See the description of [[RendererFirstPersonFlags]] for more info\n   */\n  public constructor(humanoid: VRMHumanoid, meshAnnotations: VRMFirstPersonMeshAnnotation[]) {\n    this.humanoid = humanoid;\n    this.meshAnnotations = meshAnnotations;\n  }\n\n  /**\n   * Copy the given {@link VRMFirstPerson} into this one.\n   * {@link humanoid} must be same as the source one.\n   * @param source The {@link VRMFirstPerson} you want to copy\n   * @returns this\n   */\n  public copy(source: VRMFirstPerson): this {\n    if (this.humanoid !== source.humanoid) {\n      throw new Error('VRMFirstPerson: humanoid must be same in order to copy');\n    }\n\n    this.meshAnnotations = source.meshAnnotations.map((annotation) => ({\n      meshes: annotation.meshes.concat(),\n      type: annotation.type,\n    }));\n\n    return this;\n  }\n\n  /**\n   * Returns a clone of this {@link VRMFirstPerson}.\n   * @returns Copied {@link VRMFirstPerson}\n   */\n  public clone(): VRMFirstPerson {\n    return new VRMFirstPerson(this.humanoid, this.meshAnnotations).copy(this);\n  }\n\n  /**\n   * A camera layer represents `FirstPersonOnly` layer.\n   * Note that **you must call {@link setup} first before you use the layer feature** or it does not work properly.\n   *\n   * The value is {@link DEFAULT_FIRSTPERSON_ONLY_LAYER} by default but you can change the layer by specifying via {@link setup} if you prefer.\n   *\n   * @see https://vrm.dev/en/univrm/api/univrm_use_firstperson/\n   * @see https://threejs.org/docs/#api/en/core/Layers\n   */\n  public get firstPersonOnlyLayer(): number {\n    return this._firstPersonOnlyLayer;\n  }\n\n  /**\n   * A camera layer represents `ThirdPersonOnly` layer.\n   * Note that **you must call {@link setup} first before you use the layer feature** or it does not work properly.\n   *\n   * The value is {@link DEFAULT_THIRDPERSON_ONLY_LAYER} by default but you can change the layer by specifying via {@link setup} if you prefer.\n   *\n   * @see https://vrm.dev/en/univrm/api/univrm_use_firstperson/\n   * @see https://threejs.org/docs/#api/en/core/Layers\n   */\n  public get thirdPersonOnlyLayer(): number {\n    return this._thirdPersonOnlyLayer;\n  }\n\n  /**\n   * In this method, it assigns layers for every meshes based on mesh annotations.\n   * You must call this method first before you use the layer feature.\n   *\n   * 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.\n   *\n   * The `cameraLayer` parameter specifies which layer will be assigned for `FirstPersonOnly` / `ThirdPersonOnly`.\n   * In UniVRM, we specified those by naming each desired layer as `FIRSTPERSON_ONLY_LAYER` / `THIRDPERSON_ONLY_LAYER`\n   * but we are going to specify these layers at here since we are unable to name layers in Three.js.\n   *\n   * @param cameraLayer Specify which layer will be for `FirstPersonOnly` / `ThirdPersonOnly`.\n   */\n  public setup({\n    firstPersonOnlyLayer = VRMFirstPerson.DEFAULT_FIRSTPERSON_ONLY_LAYER,\n    thirdPersonOnlyLayer = VRMFirstPerson.DEFAULT_THIRDPERSON_ONLY_LAYER,\n  } = {}): void {\n    if (this._initializedLayers) {\n      return;\n    }\n    this._firstPersonOnlyLayer = firstPersonOnlyLayer;\n    this._thirdPersonOnlyLayer = thirdPersonOnlyLayer;\n\n    this.meshAnnotations.forEach((item) => {\n      item.meshes.forEach((mesh) => {\n        if (item.type === 'firstPersonOnly') {\n          mesh.layers.set(this._firstPersonOnlyLayer);\n          mesh.traverse((child) => child.layers.set(this._firstPersonOnlyLayer));\n        } else if (item.type === 'thirdPersonOnly') {\n          mesh.layers.set(this._thirdPersonOnlyLayer);\n          mesh.traverse((child) => child.layers.set(this._thirdPersonOnlyLayer));\n        } else if (item.type === 'auto') {\n          this._createHeadlessModel(mesh);\n        }\n      });\n    });\n\n    this._initializedLayers = true;\n  }\n\n  private _excludeTriangles(triangles: number[], bws: number[][], skinIndex: number[][], exclude: number[]): number {\n    let count = 0;\n    if (bws != null && bws.length > 0) {\n      for (let i = 0; i < triangles.length; i += 3) {\n        const a = triangles[i];\n        const b = triangles[i + 1];\n        const c = triangles[i + 2];\n        const bw0 = bws[a];\n        const skin0 = skinIndex[a];\n\n        if (bw0[0] > 0 && exclude.includes(skin0[0])) continue;\n        if (bw0[1] > 0 && exclude.includes(skin0[1])) continue;\n        if (bw0[2] > 0 && exclude.includes(skin0[2])) continue;\n        if (bw0[3] > 0 && exclude.includes(skin0[3])) continue;\n\n        const bw1 = bws[b];\n        const skin1 = skinIndex[b];\n        if (bw1[0] > 0 && exclude.includes(skin1[0])) continue;\n        if (bw1[1] > 0 && exclude.includes(skin1[1])) continue;\n        if (bw1[2] > 0 && exclude.includes(skin1[2])) continue;\n        if (bw1[3] > 0 && exclude.includes(skin1[3])) continue;\n\n        const bw2 = bws[c];\n        const skin2 = skinIndex[c];\n        if (bw2[0] > 0 && exclude.includes(skin2[0])) continue;\n        if (bw2[1] > 0 && exclude.includes(skin2[1])) continue;\n        if (bw2[2] > 0 && exclude.includes(skin2[2])) continue;\n        if (bw2[3] > 0 && exclude.includes(skin2[3])) continue;\n\n        triangles[count++] = a;\n        triangles[count++] = b;\n        triangles[count++] = c;\n      }\n    }\n    return count;\n  }\n\n  private _createErasedMesh(src: THREE.SkinnedMesh, erasingBonesIndex: number[]): THREE.SkinnedMesh {\n    const dst = new THREE.SkinnedMesh(src.geometry.clone(), src.material);\n    dst.name = `${src.name}(erase)`;\n    dst.frustumCulled = src.frustumCulled;\n    dst.layers.set(this._firstPersonOnlyLayer);\n\n    const geometry = dst.geometry;\n\n    const skinIndexAttr = geometry.getAttribute('skinIndex').array;\n    const skinIndex = [];\n    for (let i = 0; i < skinIndexAttr.length; i += 4) {\n      skinIndex.push([skinIndexAttr[i], skinIndexAttr[i + 1], skinIndexAttr[i + 2], skinIndexAttr[i + 3]]);\n    }\n\n    const skinWeightAttr = geometry.getAttribute('skinWeight').array;\n    const skinWeight = [];\n    for (let i = 0; i < skinWeightAttr.length; i += 4) {\n      skinWeight.push([skinWeightAttr[i], skinWeightAttr[i + 1], skinWeightAttr[i + 2], skinWeightAttr[i + 3]]);\n    }\n\n    const index = geometry.getIndex();\n    if (!index) {\n      throw new Error(\"The geometry doesn't have an index buffer\");\n    }\n    const oldTriangles = Array.from(index.array);\n\n    const count = this._excludeTriangles(oldTriangles, skinWeight, skinIndex, erasingBonesIndex);\n    const newTriangle: number[] = [];\n    for (let i = 0; i < count; i++) {\n      newTriangle[i] = oldTriangles[i];\n    }\n    geometry.setIndex(newTriangle);\n\n    // mtoon material includes onBeforeRender. this is unsupported at SkinnedMesh#clone\n    if (src.onBeforeRender) {\n      dst.onBeforeRender = src.onBeforeRender;\n    }\n    dst.bind(new THREE.Skeleton(src.skeleton.bones, src.skeleton.boneInverses), new THREE.Matrix4());\n    return dst;\n  }\n\n  private _createHeadlessModelForSkinnedMesh(parent: THREE.Object3D, mesh: THREE.SkinnedMesh): void {\n    const eraseBoneIndexes: number[] = [];\n    mesh.skeleton.bones.forEach((bone, index) => {\n      if (this._isEraseTarget(bone)) eraseBoneIndexes.push(index);\n    });\n\n    // Unlike UniVRM we don't copy mesh if no invisible bone was found\n    if (!eraseBoneIndexes.length) {\n      mesh.layers.enable(this._thirdPersonOnlyLayer);\n      mesh.layers.enable(this._firstPersonOnlyLayer);\n      return;\n    }\n    mesh.layers.set(this._thirdPersonOnlyLayer);\n    const newMesh = this._createErasedMesh(mesh, eraseBoneIndexes);\n    parent.add(newMesh);\n  }\n\n  private _createHeadlessModel(node: THREE.Object3D): void {\n    if (node.type === 'Group') {\n      node.layers.set(this._thirdPersonOnlyLayer);\n      if (this._isEraseTarget(node)) {\n        node.traverse((child) => child.layers.set(this._thirdPersonOnlyLayer));\n      } else {\n        const parent = new THREE.Group();\n        parent.name = `_headless_${node.name}`;\n        parent.layers.set(this._firstPersonOnlyLayer);\n        node.parent!.add(parent);\n        node.children\n          .filter((child) => child.type === 'SkinnedMesh')\n          .forEach((child) => {\n            const skinnedMesh = child as THREE.SkinnedMesh;\n            this._createHeadlessModelForSkinnedMesh(parent, skinnedMesh);\n          });\n      }\n    } else if (node.type === 'SkinnedMesh') {\n      const skinnedMesh = node as THREE.SkinnedMesh;\n      this._createHeadlessModelForSkinnedMesh(node.parent!, skinnedMesh);\n    } else {\n      if (this._isEraseTarget(node)) {\n        node.layers.set(this._thirdPersonOnlyLayer);\n        node.traverse((child) => child.layers.set(this._thirdPersonOnlyLayer));\n      }\n    }\n  }\n\n  private _isEraseTarget(bone: THREE.Object3D): boolean {\n    if (bone === this.humanoid.getRawBoneNode('head')) {\n      return true;\n    } else if (!bone.parent) {\n      return false;\n    } else {\n      return this._isEraseTarget(bone.parent);\n    }\n  }\n}\n","import type * as V0VRM from '@pixiv/types-vrm-0.0';\nimport type * as V1VRMSchema from '@pixiv/types-vrmc-vrm-1.0';\nimport type { GLTF, GLTFLoaderPlugin, GLTFParser } from 'three/examples/jsm/loaders/GLTFLoader.js';\nimport type { VRMHumanoid } from '../humanoid/VRMHumanoid';\nimport { gltfExtractPrimitivesFromNodes } from '../utils/gltfExtractPrimitivesFromNode';\nimport { VRMFirstPerson } from './VRMFirstPerson';\nimport type { VRMFirstPersonMeshAnnotation } from './VRMFirstPersonMeshAnnotation';\nimport type { VRMFirstPersonMeshAnnotationType } from './VRMFirstPersonMeshAnnotationType';\nimport { GLTF as GLTFSchema } from '@gltf-transform/core';\n\n/**\n * Possible spec versions it recognizes.\n */\nconst POSSIBLE_SPEC_VERSIONS = new Set(['1.0', '1.0-beta']);\n\n/**\n * A plugin of GLTFLoader that imports a {@link VRMFirstPerson} from a VRM extension of a GLTF.\n */\nexport class VRMFirstPersonLoaderPlugin implements GLTFLoaderPlugin {\n  public readonly parser: GLTFParser;\n\n  public get name(): string {\n    // We should use the extension name instead but we have multiple plugins for an extension...\n    return 'VRMFirstPersonLoaderPlugin';\n  }\n\n  public constructor(parser: GLTFParser) {\n    this.parser = parser;\n  }\n\n  public async afterRoot(gltf: GLTF): Promise<void> {\n    const vrmHumanoid = gltf.userData.vrmHumanoid as VRMHumanoid | undefined;\n\n    // explicitly distinguish null and undefined\n    // since vrmHumanoid might be null as a result\n    if (vrmHumanoid === null) {\n      return;\n    } else if (vrmHumanoid === undefined) {\n      throw new Error(\n        'VRMFirstPersonLoaderPlugin: vrmHumanoid is undefined. VRMHumanoidLoaderPlugin have to be used first',\n      );\n    }\n\n    gltf.userData.vrmFirstPerson = await this._import(gltf, vrmHumanoid);\n  }\n\n  /**\n   * Import a {@link VRMFirstPerson} from a VRM.\n   *\n   * @param gltf A parsed result of GLTF taken from GLTFLoader\n   * @param humanoid A {@link VRMHumanoid} instance that represents the VRM\n   */\n\n  private async _import(gltf: GLTF, humanoid: VRMHumanoid | null): Promise<VRMFirstPerson | null> {\n    if (humanoid == null) {\n      return null;\n    }\n\n    const v1Result = await this._v1Import(gltf, humanoid);\n    if (v1Result) {\n      return v1Result;\n    }\n\n    const v0Result = await this._v0Import(gltf, humanoid);\n    if (v0Result) {\n      return v0Result;\n    }\n\n    return null;\n  }\n\n  private async _v1Import(gltf: GLTF, humanoid: VRMHumanoid): Promise<VRMFirstPerson | null> {\n    const json = this.parser.json as GLTFSchema.IGLTF;\n\n    // early abort if it doesn't use vrm\n    const isVRMUsed = json.extensionsUsed?.indexOf('VRMC_vrm') !== -1;\n    if (!isVRMUsed) {\n      return null;\n    }\n\n    const extension = json.extensions?.['VRMC_vrm'] as V1VRMSchema.VRMCVRM | undefined;\n    if (!extension) {\n      return null;\n    }\n\n    const specVersion = extension.specVersion;\n    if (!POSSIBLE_SPEC_VERSIONS.has(specVersion)) {\n      console.warn(`VRMFirstPersonLoaderPlugin: Unknown VRMC_vrm specVersion \"${specVersion}\"`);\n      return null;\n    }\n\n    const schemaFirstPerson = extension.firstPerson;\n    if (!schemaFirstPerson) {\n      return null;\n    }\n\n    const meshAnnotations: VRMFirstPersonMeshAnnotation[] = [];\n    const nodePrimitivesMap = await gltfExtractPrimitivesFromNodes(gltf);\n    Array.from(nodePrimitivesMap.entries()).forEach(([nodeIndex, primitives]) => {\n      const annotation = schemaFirstPerson.meshAnnotations\n        ? schemaFirstPerson.meshAnnotations.find((a) => a.node === nodeIndex)\n        : undefined;\n\n      meshAnnotations.push({\n        meshes: primitives,\n        type: annotation?.type ?? 'both',\n      });\n    });\n\n    return new VRMFirstPerson(humanoid, meshAnnotations);\n  }\n\n  private async _v0Import(gltf: GLTF, humanoid: VRMHumanoid): Promise<VRMFirstPerson | null> {\n    const json = this.parser.json as GLTFSchema.IGLTF;\n\n    const vrmExt = json.extensions?.VRM as V0VRM.VRM | undefined;\n    if (!vrmExt) {\n      return null;\n    }\n\n    const schemaFirstPerson: V0VRM.FirstPerson | undefined = vrmExt.firstPerson;\n    if (!schemaFirstPerson) {\n      return null;\n    }\n\n    const meshAnnotations: VRMFirstPersonMeshAnnotation[] = [];\n    const nodePrimitivesMap = await gltfExtractPrimitivesFromNodes(gltf);\n\n    Array.from(nodePrimitivesMap.entries()).forEach(([nodeIndex, primitives]) => {\n      const schemaNode = json.nodes![nodeIndex];\n\n      const flag = schemaFirstPerson.meshAnnotations\n        ? schemaFirstPerson.meshAnnotations.find((a) => a.mesh === schemaNode.mesh)\n        : undefined;\n\n      meshAnnotations.push({\n        meshes: primitives,\n        type: this._convertV0FlagToV1Type(flag?.firstPersonFlag),\n      });\n    });\n\n    return new VRMFirstPerson(humanoid, meshAnnotations);\n  }\n\n  private _convertV0FlagToV1Type(flag: string | undefined): VRMFirstPersonMeshAnnotationType {\n    if (flag === 'FirstPersonOnly') {\n      return 'firstPersonOnly';\n    } else if (flag === 'ThirdPersonOnly') {\n      return 'thirdPersonOnly';\n    } else if (flag === 'Auto') {\n      return 'auto';\n    } else {\n      return 'both';\n    }\n  }\n}\n","/* eslint-disable @typescript-eslint/naming-convention */\n\nexport const VRMFirstPersonMeshAnnotationType = {\n  Auto: 'auto',\n  Both: 'both',\n  ThirdPersonOnly: 'thirdPersonOnly',\n  FirstPersonOnly: 'firstPersonOnly',\n} as const;\n\nexport type VRMFirstPersonMeshAnnotationType = typeof VRMFirstPersonMeshAnnotationType[keyof typeof VRMFirstPersonMeshAnnotationType];\n","import * as THREE from 'three';\nimport { VRMHumanBone } from '../VRMHumanBone';\nimport { VRMHumanoid } from '../VRMHumanoid';\n\nconst _v3A = new THREE.Vector3();\nconst _v3B = new THREE.Vector3();\nconst _quatA = new THREE.Quaternion();\n\nexport class VRMHumanoidHelper extends THREE.Group {\n  public readonly vrmHumanoid: VRMHumanoid;\n  private _boneAxesMap: Map<VRMHumanBone, THREE.AxesHelper>;\n\n  public constructor(humanoid: VRMHumanoid) {\n    super();\n\n    this.vrmHumanoid = humanoid;\n\n    this._boneAxesMap = new Map();\n\n    Object.values(humanoid.humanBones).forEach((bone) => {\n      const helper = new THREE.AxesHelper(1.0);\n\n      helper.matrixAutoUpdate = false;\n\n      (helper.material as THREE.Material).depthTest = false;\n      (helper.material as THREE.Material).depthWrite = false;\n\n      this.add(helper);\n\n      // TODO: type assertion is not needed in later versions of TypeScript\n      this._boneAxesMap.set(bone!, helper);\n    });\n  }\n\n  public dispose(): void {\n    Array.from(this._boneAxesMap.values()).forEach((axes) => {\n      axes.geometry.dispose();\n      (axes.material as THREE.Material).dispose();\n    });\n  }\n\n  public updateMatrixWorld(force: boolean): void {\n    Array.from(this._boneAxesMap.entries()).forEach(([bone, axes]) => {\n      bone.node.updateWorldMatrix(true, false);\n\n      bone.node.matrixWorld.decompose(_v3A, _quatA, _v3B);\n\n      const scale = _v3A.set(0.1, 0.1, 0.1).divide(_v3B);\n      axes.matrix.copy(bone.node.matrixWorld).scale(scale);\n    });\n\n    super.updateMatrixWorld(force);\n  }\n}\n","/* eslint-disable @typescript-eslint/naming-convention */\n\nimport { VRMHumanBoneName } from './VRMHumanBoneName';\n\n/**\n * The list of {@link VRMHumanBoneName}. Dependency aware.\n */\nexport const VRMHumanBoneList: VRMHumanBoneName[] = [\n  'hips',\n  'spine',\n  'chest',\n  'upperChest',\n  'neck',\n\n  'head',\n  'leftEye',\n  'rightEye',\n  'jaw',\n\n  'leftUpperLeg',\n  'leftLowerLeg',\n  'leftFoot',\n  'leftToes',\n\n  'rightUpperLeg',\n  'rightLowerLeg',\n  'rightFoot',\n  'rightToes',\n\n  'leftShoulder',\n  'leftUpperArm',\n  'leftLowerArm',\n  'leftHand',\n\n  'rightShoulder',\n  'rightUpperArm',\n  'rightLowerArm',\n  'rightHand',\n\n  'leftThumbMetacarpal',\n  'leftThumbProximal',\n  'leftThumbDistal',\n  'leftIndexProximal',\n  'leftIndexIntermediate',\n  'leftIndexDistal',\n  'leftMiddleProximal',\n  'leftMiddleIntermediate',\n  'leftMiddleDistal',\n  'leftRingProximal',\n  'leftRingIntermediate',\n  'leftRingDistal',\n  'leftLittleProximal',\n  'leftLittleIntermediate',\n  'leftLittleDistal',\n\n  'rightThumbMetacarpal',\n  'rightThumbProximal',\n  'rightThumbDistal',\n  'rightIndexProximal',\n  'rightIndexIntermediate',\n  'rightIndexDistal',\n  'rightMiddleProximal',\n  'rightMiddleIntermediate',\n  'rightMiddleDistal',\n  'rightRingProximal',\n  'rightRingIntermediate',\n  'rightRingDistal',\n  'rightLittleProximal',\n  'rightLittleIntermediate',\n  'rightLittleDistal',\n];\n","/* eslint-disable @typescript-eslint/naming-convention */\n\n/**\n * The names of {@link VRMHumanoid} bone names.\n *\n * Ref: https://github.com/vrm-c/vrm-specification/blob/master/specification/VRMC_vrm-1.0/humanoid.md\n */\nexport const VRMHumanBoneName = {\n  Hips: 'hips',\n  Spine: 'spine',\n  Chest: 'chest',\n  UpperChest: 'upperChest',\n  Neck: 'neck',\n\n  Head: 'head',\n  LeftEye: 'leftEye',\n  RightEye: 'rightEye',\n  Jaw: 'jaw',\n\n  LeftUpperLeg: 'leftUpperLeg',\n  LeftLowerLeg: 'leftLowerLeg',\n  LeftFoot: 'leftFoot',\n  LeftToes: 'leftToes',\n\n  RightUpperLeg: 'rightUpperLeg',\n  RightLowerLeg: 'rightLowerLeg',\n  RightFoot: 'rightFoot',\n  RightToes: 'rightToes',\n\n  LeftShoulder: 'leftShoulder',\n  LeftUpperArm: 'leftUpperArm',\n  LeftLowerArm: 'leftLowerArm',\n  LeftHand: 'leftHand',\n\n  RightShoulder: 'rightShoulder',\n  RightUpperArm: 'rightUpperArm',\n  RightLowerArm: 'rightLowerArm',\n  RightHand: 'rightHand',\n\n  LeftThumbMetacarpal: 'leftThumbMetacarpal',\n  LeftThumbProximal: 'leftThumbProximal',\n  LeftThumbDistal: 'leftThumbDistal',\n  LeftIndexProximal: 'leftIndexProximal',\n  LeftIndexIntermediate: 'leftIndexIntermediate',\n  LeftIndexDistal: 'leftIndexDistal',\n  LeftMiddleProximal: 'leftMiddleProximal',\n  LeftMiddleIntermediate: 'leftMiddleIntermediate',\n  LeftMiddleDistal: 'leftMiddleDistal',\n  LeftRingProximal: 'leftRingProximal',\n  LeftRingIntermediate: 'leftRingIntermediate',\n  LeftRingDistal: 'leftRingDistal',\n  LeftLittleProximal: 'leftLittleProximal',\n  LeftLittleIntermediate: 'leftLittleIntermediate',\n  LeftLittleDistal: 'leftLittleDistal',\n\n  RightThumbMetacarpal: 'rightThumbMetacarpal',\n  RightThumbProximal: 'rightThumbProximal',\n  RightThumbDistal: 'rightThumbDistal',\n  RightIndexProximal: 'rightIndexProximal',\n  RightIndexIntermediate: 'rightIndexIntermediate',\n  RightIndexDistal: 'rightIndexDistal',\n  RightMiddleProximal: 'rightMiddleProximal',\n  RightMiddleIntermediate: 'rightMiddleIntermediate',\n  RightMiddleDistal: 'rightMiddleDistal',\n  RightRingProximal: 'rightRingProximal',\n  RightRingIntermediate: 'rightRingIntermediate',\n  RightRingDistal: 'rightRingDistal',\n  RightLittleProximal: 'rightLittleProximal',\n  RightLittleIntermediate: 'rightLittleIntermediate',\n  RightLittleDistal: 'rightLittleDistal',\n} as const;\n\nexport type VRMHumanBoneName = typeof VRMHumanBoneName[keyof typeof VRMHumanBoneName];\n","/* eslint-disable @typescript-eslint/naming-convention */\n\nimport { VRMHumanBoneName } from './VRMHumanBoneName';\n\n/**\n * An object that maps from {@link VRMHumanBoneName} to its parent {@link VRMHumanBoneName}.\n *\n * Ref: https://github.com/vrm-c/vrm-specification/blob/master/specification/VRMC_vrm-1.0/humanoid.md\n */\nexport const VRMHumanBoneParentMap: { [bone in VRMHumanBoneName]: VRMHumanBoneName | null } = {\n  hips: null,\n  spine: 'hips',\n  chest: 'spine',\n  upperChest: 'chest',\n  neck: 'upperChest',\n\n  head: 'neck',\n  leftEye: 'head',\n  rightEye: 'head',\n  jaw: 'head',\n\n  leftUpperLeg: 'hips',\n  leftLowerLeg: 'leftUpperLeg',\n  leftFoot: 'leftLowerLeg',\n  leftToes: 'leftFoot',\n\n  rightUpperLeg: 'hips',\n  rightLowerLeg: 'rightUpperLeg',\n  rightFoot: 'rightLowerLeg',\n  rightToes: 'rightFoot',\n\n  leftShoulder: 'chest',\n  leftUpperArm: 'leftShoulder',\n  leftLowerArm: 'leftUpperArm',\n  leftHand: 'leftLowerArm',\n\n  rightShoulder: 'chest',\n  rightUpperArm: 'rightShoulder',\n  rightLowerArm: 'rightUpperArm',\n  rightHand: 'rightLowerArm',\n\n  leftThumbMetacarpal: 'leftHand',\n  leftThumbProximal: 'leftThumbMetacarpal',\n  leftThumbDistal: 'leftThumbProximal',\n  leftIndexProximal: 'leftHand',\n  leftIndexIntermediate: 'leftIndexProximal',\n  leftIndexDistal: 'leftIndexIntermediate',\n  leftMiddleProximal: 'leftHand',\n  leftMiddleIntermediate: 'leftMiddleProximal',\n  leftMiddleDistal: 'leftMiddleIntermediate',\n  leftRingProximal: 'leftHand',\n  leftRingIntermediate: 'leftRingProximal',\n  leftRingDistal: 'leftRingIntermediate',\n  leftLittleProximal: 'leftHand',\n  leftLittleIntermediate: 'leftLittleProximal',\n  leftLittleDistal: 'leftLittleIntermediate',\n\n  rightThumbMetacarpal: 'rightHand',\n  rightThumbProximal: 'rightThumbMetacarpal',\n  rightThumbDistal: 'rightThumbProximal',\n  rightIndexProximal: 'rightHand',\n  rightIndexIntermediate: 'rightIndexProximal',\n  rightIndexDistal: 'rightIndexIntermediate',\n  rightMiddleProximal: 'rightHand',\n  rightMiddleIntermediate: 'rightMiddleProximal',\n  rightMiddleDistal: 'rightMiddleIntermediate',\n  rightRingProximal: 'rightHand',\n  rightRingIntermediate: 'rightRingProximal',\n  rightRingDistal: 'rightRingIntermediate',\n  rightLittleProximal: 'rightHand',\n  rightLittleIntermediate: 'rightLittleProximal',\n  rightLittleDistal: 'rightLittleIntermediate',\n};\n","import * as THREE from 'three';\n\n/**\n * A compat function for `Quaternion.invert()` / `Quaternion.inverse()`.\n * `Quaternion.invert()` is introduced in r123 and `Quaternion.inverse()` emits a warning.\n * We are going to use this compat for a while.\n * @param target A target quaternion\n */\nexport function quatInvertCompat<T extends THREE.Quaternion>(target: T): T {\n  if ((target as any).invert) {\n    target.invert();\n  } else {\n    (target as any).inverse();\n  }\n\n  return target;\n}\n","import * as THREE from 'three';\nimport { quatInvertCompat } from '../utils/quatInvertCompat';\nimport type { VRMHumanBone } from './VRMHumanBone';\nimport type { VRMHumanBones } from './VRMHumanBones';\nimport type { VRMHumanBoneName } from './VRMHumanBoneName';\nimport type { VRMPose } from './VRMPose';\n\nconst _v3A = new THREE.Vector3();\nconst _quatA = new THREE.Quaternion();\n\n/**\n * A class represents the Rig of a VRM.\n */\nexport class VRMRig {\n  /**\n   * A {@link VRMHumanBones} that contains all the human bones of the VRM.\n   * You might want to get these bones using {@link VRMHumanoid.getBone}.\n   */\n  public humanBones: VRMHumanBones;\n\n  /**\n   * A {@link VRMPose} that is its default state.\n   * Note that it's not compatible with {@link setPose} and {@link getPose}, since it contains non-relative values of each local transforms.\n   */\n  public restPose: VRMPose;\n\n  /**\n   * Create a new {@link VRMHumanoid}.\n   * @param humanBones A {@link VRMHumanBones} contains all the bones of the new humanoid\n   */\n  public constructor(humanBones: VRMHumanBones) {\n    this.humanBones = humanBones;\n\n    this.restPose = this.getAbsolutePose();\n  }\n\n  /**\n   * Return the current absolute pose of this humanoid as a {@link VRMPose}.\n   * Note that the output result will contain initial state of the VRM and not compatible between different models.\n   * You might want to use {@link getPose} instead.\n   */\n  public getAbsolutePose(): VRMPose {\n    const pose = {} as VRMPose;\n\n    Object.keys(this.humanBones).forEach((vrmBoneNameString) => {\n      const vrmBoneName = vrmBoneNameString as VRMHumanBoneName;\n      const node = this.getBoneNode(vrmBoneName);\n\n      // Ignore when there are no bone on the VRMHumanoid\n      if (!node) {\n        return;\n      }\n\n      // Get the position / rotation from the node\n      _v3A.copy(node.position);\n      _quatA.copy(node.quaternion);\n\n      // Convert to raw arrays\n      pose[vrmBoneName] = {\n        position: _v3A.toArray() as [number, number, number],\n        rotation: _quatA.toArray() as [number, number, number, number],\n      };\n    });\n\n    return pose;\n  }\n\n  /**\n   * Return the current pose of this humanoid as a {@link VRMPose}.\n   *\n   * Each transform is a local transform relative from rest pose (T-pose).\n   */\n  public getPose(): VRMPose {\n    const pose = {} as VRMPose;\n\n    Object.keys(this.humanBones).forEach((boneNameString) => {\n      const boneName = boneNameString as VRMHumanBoneName;\n      const node = this.getBoneNode(boneName);\n\n      // Ignore when there are no bone on the VRMHumanoid\n      if (!node) {\n        return;\n      }\n\n      // Take a diff from restPose\n      _v3A.set(0, 0, 0);\n      _quatA.identity();\n\n      const restState = this.restPose[boneName];\n      if (restState?.position) {\n        _v3A.fromArray(restState.position).negate();\n      }\n      if (restState?.rotation) {\n        quatInvertCompat(_quatA.fromArray(restState.rotation));\n      }\n\n      // Get the position / rotation from the node\n      _v3A.add(node.position);\n      _quatA.premultiply(node.quaternion);\n\n      // Convert to raw arrays\n      pose[boneName] = {\n        position: _v3A.toArray() as [number, number, number],\n        rotation: _quatA.toArray() as [number, number, number, number],\n      };\n    });\n\n    return pose;\n  }\n\n  /**\n   * Let the humanoid do a specified pose.\n   *\n   * Each transform have to be a local transform relative from rest pose (T-pose).\n   * You can pass what you got from {@link getPose}.\n   *\n   * @param poseObject A [[VRMPose]] that represents a single pose\n   */\n  public setPose(poseObject: VRMPose): void {\n    Object.entries(poseObject).forEach(([boneNameString, state]) => {\n      const boneName = boneNameString as VRMHumanBoneName;\n      const node = this.getBoneNode(boneName);\n\n      // Ignore when there are no bone that is defined in the pose on the VRMHumanoid\n      if (!node) {\n        return;\n      }\n\n      const restState = this.restPose[boneName];\n      if (!restState) {\n        // It's very unlikely. Possibly a bug\n        return;\n      }\n\n      // Apply the state to the actual bone\n      if (state?.position) {\n        node.position.fromArray(state.position);\n\n        if (restState.position) {\n          node.position.add(_v3A.fromArray(restState.position));\n        }\n      }\n\n      if (state?.rotation) {\n        node.quaternion.fromArray(state.rotation);\n\n        if (restState.rotation) {\n          node.quaternion.multiply(_quatA.fromArray(restState.rotation));\n        }\n      }\n    });\n  }\n\n  /**\n   * Reset the humanoid to its rest pose.\n   */\n  public resetPose(): void {\n    Object.entries(this.restPose).forEach(([boneName, rest]) => {\n      const node = this.getBoneNode(boneName as VRMHumanBoneName);\n\n      if (!node) {\n        return;\n      }\n\n      if (rest?.position) {\n        node.position.fromArray(rest.position);\n      }\n\n      if (rest?.rotation) {\n        node.quaternion.fromArray(rest.rotation);\n      }\n    });\n  }\n\n  /**\n   * Return a bone bound to a specified {@link VRMHumanBoneName}, as a {@link VRMHumanBone}.\n   *\n   * @param name Name of the bone you want\n   */\n  public getBone(name: VRMHumanBoneName): VRMHumanBone | undefined {\n    return this.humanBones[name] ?? undefined;\n  }\n\n  /**\n   * Return a bone bound to a specified {@link VRMHumanBoneName}, as a `THREE.Object3D`.\n   *\n   * @param name Name of the bone you want\n   */\n  public getBoneNode(name: VRMHumanBoneName): THREE.Object3D | null {\n    return this.humanBones[name]?.node ?? null;\n  }\n}\n","import * as THREE from 'three';\nimport { VRMHumanBoneName, VRMHumanBones } from '.';\nimport { VRMHumanBoneList } from './VRMHumanBoneList';\nimport { VRMHumanBoneParentMap } from './VRMHumanBoneParentMap';\nimport { VRMRig } from './VRMRig';\n\nconst _v3A = new THREE.Vector3();\nconst _quatA = new THREE.Quaternion();\n\n/**\n * A class represents the normalized Rig of a VRM.\n */\nexport class VRMHumanoidRig extends VRMRig {\n  protected static _setupTransforms(\n    modelRig: VRMRig,\n  ): {\n    rigBones: VRMHumanBones;\n    root: THREE.Object3D;\n    parentWorldRotations: { [boneName in VRMHumanBoneName]?: THREE.Quaternion };\n    boneRotations: { [boneName in VRMHumanBoneName]?: THREE.Quaternion };\n  } {\n    const root = new THREE.Object3D();\n    root.name = 'VRMHumanoidRig';\n\n    // store boneWorldPositions and boneWorldRotations\n    const boneWorldPositions: { [boneName in VRMHumanBoneName]?: THREE.Vector3 } = {};\n    const boneWorldRotations: { [boneName in VRMHumanBoneName]?: THREE.Quaternion } = {};\n    const boneRotations: { [boneName in VRMHumanBoneName]?: THREE.Quaternion } = {};\n\n    VRMHumanBoneList.forEach((boneName) => {\n      const boneNode = modelRig.getBoneNode(boneName);\n\n      if (boneNode) {\n        const boneWorldPosition = new THREE.Vector3();\n        const boneWorldRotation = new THREE.Quaternion();\n\n        boneNode.updateWorldMatrix(true, false);\n        boneNode.matrixWorld.decompose(boneWorldPosition, boneWorldRotation, _v3A);\n\n        boneWorldPositions[boneName] = boneWorldPosition;\n        boneWorldRotations[boneName] = boneWorldRotation;\n        boneRotations[boneName] = boneNode.quaternion.clone();\n      }\n    });\n\n    // build rig hierarchy + store parentWorldRotations\n    const parentWorldRotations: { [boneName in VRMHumanBoneName]?: THREE.Quaternion } = {};\n\n    const rigBones: Partial<VRMHumanBones> = {};\n    VRMHumanBoneList.forEach((boneName) => {\n      const boneNode = modelRig.getBoneNode(boneName);\n\n      if (boneNode) {\n        const boneWorldPosition = boneWorldPositions[boneName] as THREE.Vector3;\n\n        // see the nearest parent position\n        let currentBoneName: VRMHumanBoneName | null = boneName;\n        let parentWorldPosition: THREE.Vector3 | undefined;\n        let parentWorldRotation: THREE.Quaternion | undefined;\n        while (parentWorldPosition == null) {\n          currentBoneName = VRMHumanBoneParentMap[currentBoneName];\n          if (currentBoneName == null) {\n            break;\n          }\n          parentWorldPosition = boneWorldPositions[currentBoneName];\n          parentWorldRotation = boneWorldRotations[currentBoneName];\n        }\n\n        // add to hierarchy\n        const rigBoneNode = new THREE.Object3D();\n        rigBoneNode.name = 'Normalized_' + boneNode.name;\n\n        const parentRigBoneNode = (currentBoneName ? rigBones[currentBoneName]?.node : root) as THREE.Object3D;\n\n        parentRigBoneNode.add(rigBoneNode);\n        rigBoneNode.position.copy(boneWorldPosition);\n        if (parentWorldPosition) {\n          rigBoneNode.position.sub(parentWorldPosition);\n        }\n\n        rigBones[boneName] = { node: rigBoneNode };\n\n        // store parentWorldRotation\n        parentWorldRotations[boneName] = parentWorldRotation ?? new THREE.Quaternion();\n      }\n    });\n\n    return {\n      rigBones: rigBones as VRMHumanBones,\n      root,\n      parentWorldRotations,\n      boneRotations,\n    };\n  }\n\n  public readonly original: VRMRig;\n  public readonly root: THREE.Object3D;\n  protected readonly _parentWorldRotations: { [boneName in VRMHumanBoneName]?: THREE.Quaternion };\n  protected readonly _boneRotations: { [boneName in VRMHumanBoneName]?: THREE.Quaternion };\n\n  public constructor(humanoid: VRMRig) {\n    const { rigBones, root, parentWorldRotations, boneRotations } = VRMHumanoidRig._setupTransforms(humanoid);\n\n    super(rigBones);\n\n    this.original = humanoid;\n    this.root = root;\n    this._parentWorldRotations = parentWorldRotations;\n    this._boneRotations = boneRotations;\n  }\n\n  /**\n   * Update this humanoid rig.\n   */\n  public update(): void {\n    VRMHumanBoneList.forEach((boneName) => {\n      const boneNode = this.original.getBoneNode(boneName);\n\n      if (boneNode != null) {\n        const rigBoneNode = this.getBoneNode(boneName)!;\n        const parentWorldRotation = this._parentWorldRotations[boneName]!;\n        const invParentWorldRotation = _quatA.copy(parentWorldRotation).invert();\n        const boneRotation = this._boneRotations[boneName]!;\n\n        boneNode.quaternion\n          .copy(rigBoneNode.quaternion)\n          .multiply(parentWorldRotation)\n          .premultiply(invParentWorldRotation)\n          .multiply(boneRotation);\n\n        // Move the mass center of the VRM\n        if (boneName === 'hips') {\n          const boneWorldPosition = rigBoneNode.getWorldPosition(new THREE.Vector3());\n          const parentWorldMatrix = boneNode.parent!.matrixWorld;\n          const localPosition = boneWorldPosition.applyMatrix4(parentWorldMatrix.invert());\n          boneNode.position.copy(localPosition);\n        }\n      }\n    });\n  }\n}\n","import * as THREE from 'three';\nimport type { VRMHumanBone } from './VRMHumanBone';\nimport type { VRMHumanBones } from './VRMHumanBones';\nimport type { VRMHumanBoneName } from './VRMHumanBoneName';\nimport type { VRMPose } from './VRMPose';\nimport { VRMRig } from './VRMRig';\nimport { VRMHumanoidRig } from './VRMHumanoidRig';\n\n/**\n * A class represents a humanoid of a VRM.\n */\nexport class VRMHumanoid {\n  /**\n   * Whether it copies pose from normalizedHumanBones to rawHumanBones on {@link update}.\n   * `true` by default.\n   *\n   * @default true\n   */\n  public autoUpdateHumanBones: boolean;\n\n  /**\n   * A raw rig of the VRM.\n   */\n  private _rawHumanBones: VRMRig; // TODO: Rename\n\n  /**\n   * A normalized rig of the VRM.\n   */\n  private _normalizedHumanBones: VRMHumanoidRig; // TODO: Rename\n\n  /**\n   * @deprecated Deprecated. Use either {@link rawRestPose} or {@link normalizedRestPose} instead.\n   */\n  public get restPose(): VRMPose {\n    console.warn('VRMHumanoid: restPose is deprecated. Use either rawRestPose or normalizedRestPose instead.');\n\n    return this.rawRestPose;\n  }\n\n  /**\n   * A {@link VRMPose} of its raw human bones that is its default state.\n   * Note that it's not compatible with {@link setRawPose} and {@link getRawPose}, since it contains non-relative values of each local transforms.\n   */\n  public get rawRestPose(): VRMPose {\n    return this._rawHumanBones.restPose;\n  }\n\n  /**\n   * A {@link VRMPose} of its normalized human bones that is its default state.\n   * Note that it's not compatible with {@link setNormalizedPose} and {@link getNormalizedPose}, since it contains non-relative values of each local transforms.\n   */\n  public get normalizedRestPose(): VRMPose {\n    return this._normalizedHumanBones.restPose;\n  }\n\n  /**\n   * A map from {@link VRMHumanBoneName} to raw {@link VRMHumanBone}s.\n   */\n  public get humanBones(): VRMHumanBones {\n    // an alias of `rawHumanBones`\n    return this._rawHumanBones.humanBones;\n  }\n\n  /**\n   * A map from {@link VRMHumanBoneName} to raw {@link VRMHumanBone}s.\n   */\n  public get rawHumanBones(): VRMHumanBones {\n    return this._rawHumanBones.humanBones;\n  }\n\n  /**\n   * A map from {@link VRMHumanBoneName} to normalized {@link VRMHumanBone}s.\n   */\n  public get normalizedHumanBones(): VRMHumanBones {\n    return this._normalizedHumanBones.humanBones;\n  }\n\n  /**\n   * The root of normalized {@link VRMHumanBone}s.\n   */\n  public get normalizedHumanBonesRoot(): THREE.Object3D {\n    return this._normalizedHumanBones.root;\n  }\n\n  /**\n   * Create a new {@link VRMHumanoid}.\n   * @param humanBones A {@link VRMHumanBones} contains all the bones of the new humanoid\n   * @param autoUpdateHumanBones Whether it copies pose from normalizedHumanBones to rawHumanBones on {@link update}. `true` by default.\n   */\n  public constructor(humanBones: VRMHumanBones, options?: { autoUpdateHumanBones?: boolean }) {\n    this.autoUpdateHumanBones = options?.autoUpdateHumanBones ?? true;\n    this._rawHumanBones = new VRMRig(humanBones);\n    this._normalizedHumanBones = new VRMHumanoidRig(this._rawHumanBones);\n  }\n\n  /**\n   * Copy the given {@link VRMHumanoid} into this one.\n   * @param source The {@link VRMHumanoid} you want to copy\n   * @returns this\n   */\n  public copy(source: VRMHumanoid): this {\n    this.autoUpdateHumanBones = source.autoUpdateHumanBones;\n    this._rawHumanBones = new VRMRig(source.humanBones);\n    this._normalizedHumanBones = new VRMHumanoidRig(this._rawHumanBones);\n\n    return this;\n  }\n\n  /**\n   * Returns a clone of this {@link VRMHumanoid}.\n   * @returns Copied {@link VRMHumanoid}\n   */\n  public clone(): VRMHumanoid {\n    return new VRMHumanoid(this.humanBones, { autoUpdateHumanBones: this.autoUpdateHumanBones }).copy(this);\n  }\n\n  /**\n   * @deprecated Deprecated. Use either {@link getRawAbsolutePose} or {@link getNormalizedAbsolutePose} instead.\n   */\n  public getAbsolutePose(): VRMPose {\n    console.warn(\n      'VRMHumanoid: getAbsolutePose() is deprecated. Use either getRawAbsolutePose() or getNormalizedAbsolutePose() instead.',\n    );\n\n    return this.getRawAbsolutePose();\n  }\n\n  /**\n   * Return the current absolute pose of this raw human bones as a {@link VRMPose}.\n   * Note that the output result will contain initial state of the VRM and not compatible between different models.\n   * You might want to use {@link getRawPose} instead.\n   */\n  public getRawAbsolutePose(): VRMPose {\n    return this._rawHumanBones.getAbsolutePose();\n  }\n\n  /**\n   * Return the current absolute pose of this normalized human bones as a {@link VRMPose}.\n   * Note that the output result will contain initial state of the VRM and not compatible between different models.\n   * You might want to use {@link getNormalizedPose} instead.\n   */\n  public getNormalizedAbsolutePose(): VRMPose {\n    return this._normalizedHumanBones.getAbsolutePose();\n  }\n\n  /**\n   * @deprecated Deprecated. Use either {@link getRawPose} or {@link getNormalizedPose} instead.\n   */\n  public getPose(): VRMPose {\n    console.warn('VRMHumanoid: getPose() is deprecated. Use either getRawPose() or getNormalizedPose() instead.');\n\n    return this.getRawPose();\n  }\n\n  /**\n   * Return the current pose of raw human bones as a {@link VRMPose}.\n   *\n   * Each transform is a local transform relative from rest pose (T-pose).\n   */\n  public getRawPose(): VRMPose {\n    return this._rawHumanBones.getPose();\n  }\n\n  /**\n   * Return the current pose of normalized human bones as a {@link VRMPose}.\n   *\n   * Each transform is a local transform relative from rest pose (T-pose).\n   */\n  public getNormalizedPose(): VRMPose {\n    return this._normalizedHumanBones.getPose();\n  }\n\n  /**\n   * @deprecated Deprecated. Use either {@link setRawPose} or {@link setNormalizedPose} instead.\n   */\n  public setPose(poseObject: VRMPose): void {\n    console.warn('VRMHumanoid: setPose() is deprecated. Use either setRawPose() or setNormalizedPose() instead.');\n\n    return this.setRawPose(poseObject);\n  }\n\n  /**\n   * Let the raw human bones do a specified pose.\n   *\n   * Each transform have to be a local transform relative from rest pose (T-pose).\n   * You can pass what you got from {@link getRawPose}.\n   *\n   * If you are using {@link autoUpdateHumanBones}, you might want to use {@link setNormalizedPose} instead.\n   *\n   * @param poseObject A {@link VRMPose} that represents a single pose\n   */\n  public setRawPose(poseObject: VRMPose): void {\n    return this._rawHumanBones.setPose(poseObject);\n  }\n\n  /**\n   * Let the normalized human bones do a specified pose.\n   *\n   * Each transform have to be a local transform relative from rest pose (T-pose).\n   * You can pass what you got from {@link getNormalizedPose}.\n   *\n   * @param poseObject A {@link VRMPose} that represents a single pose\n   */\n  public setNormalizedPose(poseObject: VRMPose): void {\n    return this._normalizedHumanBones.setPose(poseObject);\n  }\n\n  /**\n   * @deprecated Deprecated. Use either {@link resetRawPose} or {@link resetNormalizedPose} instead.\n   */\n  public resetPose(): void {\n    console.warn('VRMHumanoid: resetPose() is deprecated. Use either resetRawPose() or resetNormalizedPose() instead.');\n\n    return this.resetRawPose();\n  }\n\n  /**\n   * Reset the raw humanoid to its rest pose.\n   *\n   * If you are using {@link autoUpdateHumanBones}, you might want to use {@link resetNormalizedPose} instead.\n   */\n  public resetRawPose(): void {\n    return this._rawHumanBones.resetPose();\n  }\n\n  /**\n   * Reset the normalized humanoid to its rest pose.\n   */\n  public resetNormalizedPose(): void {\n    return this._rawHumanBones.resetPose();\n  }\n\n  /**\n   * @deprecated Deprecated. Use either {@link getRawBone} or {@link getNormalizedBone} instead.\n   */\n  public getBone(name: VRMHumanBoneName): VRMHumanBone | undefined {\n    console.warn('VRMHumanoid: getBone() is deprecated. Use either getRawBone() or getNormalizedBone() instead.');\n\n    return this.getRawBone(name);\n  }\n\n  /**\n   * Return a raw {@link VRMHumanBone} bound to a specified {@link VRMHumanBoneName}.\n   *\n   * @param name Name of the bone you want\n   */\n  public getRawBone(name: VRMHumanBoneName): VRMHumanBone | undefined {\n    return this._rawHumanBones.getBone(name);\n  }\n\n  /**\n   * Return a normalized {@link VRMHumanBone} bound to a specified {@link VRMHumanBoneName}.\n   *\n   * @param name Name of the bone you want\n   */\n  public getNormalizedBone(name: VRMHumanBoneName): VRMHumanBone | undefined {\n    return this._normalizedHumanBones.getBone(name);\n  }\n\n  /**\n   * @deprecated Deprecated. Use either {@link getRawBoneNode} or {@link getNormalizedBoneNode} instead.\n   */\n  public getBoneNode(name: VRMHumanBoneName): THREE.Object3D | null {\n    console.warn(\n      'VRMHumanoid: getBoneNode() is deprecated. Use either getRawBoneNode() or getNormalizedBoneNode() instead.',\n    );\n\n    return this.getRawBoneNode(name);\n  }\n\n  /**\n   * Return a raw bone as a `THREE.Object3D` bound to a specified {@link VRMHumanBoneName}.\n   *\n   * @param name Name of the bone you want\n   */\n  public getRawBoneNode(name: VRMHumanBoneName): THREE.Object3D | null {\n    return this._rawHumanBones.getBoneNode(name);\n  }\n\n  /**\n   * Return a normalized bone as a `THREE.Object3D` bound to a specified {@link VRMHumanBoneName}.\n   *\n   * @param name Name of the bone you want\n   */\n  public getNormalizedBoneNode(name: VRMHumanBoneName): THREE.Object3D | null {\n    return this._normalizedHumanBones.getBoneNode(name);\n  }\n\n  /**\n   * Update the humanoid component.\n   *\n   * If {@link autoUpdateHumanBones} is `true`, it transfers the pose of normalized human bones to raw human bones.\n   */\n  public update(): void {\n    if (this.autoUpdateHumanBones) {\n      this._normalizedHumanBones.update();\n    }\n  }\n}\n","/* eslint-disable @typescript-eslint/naming-convention */\n\nexport const VRMRequiredHumanBoneName = {\n  Hips: 'hips',\n  Spine: 'spine',\n  Head: 'head',\n  LeftUpperLeg: 'leftUpperLeg',\n  LeftLowerLeg: 'leftLowerLeg',\n  LeftFoot: 'leftFoot',\n  RightUpperLeg: 'rightUpperLeg',\n  RightLowerLeg: 'rightLowerLeg',\n  RightFoot: 'rightFoot',\n  LeftUpperArm: 'leftUpperArm',\n  LeftLowerArm: 'leftLowerArm',\n  LeftHand: 'leftHand',\n  RightUpperArm: 'rightUpperArm',\n  RightLowerArm: 'rightLowerArm',\n  RightHand: 'rightHand',\n} as const;\n\nexport type VRMRequiredHumanBoneName = typeof VRMRequiredHumanBoneName[keyof typeof VRMRequiredHumanBoneName];\n","import type * as V0VRM from '@pixiv/types-vrm-0.0';\nimport type * as V1VRMSchema from '@pixiv/types-vrmc-vrm-1.0';\nimport type { GLTF, GLTFLoaderPlugin, GLTFParser } from 'three/examples/jsm/loaders/GLTFLoader.js';\nimport { VRMHumanoid } from './VRMHumanoid';\nimport type { VRMHumanBones } from './VRMHumanBones';\nimport { VRMRequiredHumanBoneName } from './VRMRequiredHumanBoneName';\nimport { GLTF as GLTFSchema } from '@gltf-transform/core';\nimport { VRMHumanoidHelper } from './helpers/VRMHumanoidHelper';\nimport { VRMHumanoidLoaderPluginOptions } from './VRMHumanoidLoaderPluginOptions';\n\n/**\n * Possible spec versions it recognizes.\n */\nconst POSSIBLE_SPEC_VERSIONS = new Set(['1.0', '1.0-beta']);\n\n/**\n * A map from old thumb bone names to new thumb bone names\n */\nconst thumbBoneNameMap: { [key: string]: V1VRMSchema.HumanoidHumanBoneName | undefined } = {\n  leftThumbProximal: 'leftThumbMetacarpal',\n  leftThumbIntermediate: 'leftThumbProximal',\n  rightThumbProximal: 'rightThumbMetacarpal',\n  rightThumbIntermediate: 'rightThumbProximal',\n};\n\n/**\n * A plugin of GLTFLoader that imports a {@link VRMHumanoid} from a VRM extension of a GLTF.\n */\nexport class VRMHumanoidLoaderPlugin implements GLTFLoaderPlugin {\n  /**\n   * Specify an Object3D to add {@link VRMHumanoidHelper}.\n   * If not specified, helper will not be created.\n   * If `renderOrder` is set to the root, the helper will copy the same `renderOrder` .\n   */\n  public helperRoot?: THREE.Object3D;\n\n  public autoUpdateHumanBones?: boolean;\n\n  public readonly parser: GLTFParser;\n\n  public get name(): string {\n    // We should use the extension name instead but we have multiple plugins for an extension...\n    return 'VRMHumanoidLoaderPlugin';\n  }\n\n  public constructor(parser: GLTFParser, options?: VRMHumanoidLoaderPluginOptions) {\n    this.parser = parser;\n\n    this.helperRoot = options?.helperRoot;\n    this.autoUpdateHumanBones = options?.autoUpdateHumanBones;\n  }\n\n  public async afterRoot(gltf: GLTF): Promise<void> {\n    gltf.userData.vrmHumanoid = await this._import(gltf);\n  }\n\n  /**\n   * Import a {@link VRMHumanoid} from a VRM.\n   *\n   * @param gltf A parsed result of GLTF taken from GLTFLoader\n   */\n  private async _import(gltf: GLTF): Promise<VRMHumanoid | null> {\n    const v1Result = await this._v1Import(gltf);\n    if (v1Result) {\n      return v1Result;\n    }\n\n    const v0Result = await this._v0Import(gltf);\n    if (v0Result) {\n      return v0Result;\n    }\n\n    return null;\n  }\n\n  private async _v1Import(gltf: GLTF): Promise<VRMHumanoid | null> {\n    const json = this.parser.json as GLTFSchema.IGLTF;\n\n    // early abort if it doesn't use vrm\n    const isVRMUsed = json.extensionsUsed?.indexOf('VRMC_vrm') !== -1;\n    if (!isVRMUsed) {\n      return null;\n    }\n\n    const extension = json.extensions?.['VRMC_vrm'] as V1VRMSchema.VRMCVRM | undefined;\n    if (!extension) {\n      return null;\n    }\n\n    const specVersion = extension.specVersion;\n    if (!POSSIBLE_SPEC_VERSIONS.has(specVersion)) {\n      console.warn(`VRMHumanoidLoaderPlugin: Unknown VRMC_vrm specVersion \"${specVersion}\"`);\n      return null;\n    }\n\n    const schemaHumanoid = extension.humanoid;\n    if (!schemaHumanoid) {\n      return null;\n    }\n\n    /**\n     * compat: 1.0-beta thumb bone names\n     *\n     * `true` if `leftThumbIntermediate` or `rightThumbIntermediate` exists\n     */\n    const existsPreviousThumbName =\n      (schemaHumanoid.humanBones as any).leftThumbIntermediate != null ||\n      (schemaHumanoid.humanBones as any).rightThumbIntermediate != null;\n\n    const humanBones: Partial<VRMHumanBones> = {};\n    if (schemaHumanoid.humanBones != null) {\n      await Promise.all(\n        Object.entries(schemaHumanoid.humanBones).map(async ([boneNameString, schemaHumanBone]) => {\n          let boneName = boneNameString as V1VRMSchema.HumanoidHumanBoneName;\n          const index = schemaHumanBone.node;\n\n          // compat: 1.0-beta previous thumb bone names\n          if (existsPreviousThumbName) {\n            const thumbBoneName = thumbBoneNameMap[boneName];\n            if (thumbBoneName != null) {\n              boneName = thumbBoneName;\n            }\n          }\n\n          const node = await this.parser.getDependency('node', index);\n\n          // if the specified node does not exist, emit a warning\n          if (node == null) {\n            console.warn(`A glTF node bound to the humanoid bone ${boneName} (index = ${index}) does not exist`);\n            return;\n          }\n\n          // set to the `humanBones`\n          humanBones[boneName] = { node };\n        }),\n      );\n    }\n\n    const humanoid = new VRMHumanoid(this._ensureRequiredBonesExist(humanBones), {\n      autoUpdateHumanBones: this.autoUpdateHumanBones,\n    });\n    gltf.scene.add(humanoid.normalizedHumanBonesRoot);\n\n    if (this.helperRoot) {\n      const helper = new VRMHumanoidHelper(humanoid);\n      this.helperRoot.add(helper);\n      helper.renderOrder = this.helperRoot.renderOrder;\n    }\n\n    return humanoid;\n  }\n\n  private async _v0Import(gltf: GLTF): Promise<VRMHumanoid | null> {\n    const json = this.parser.json as GLTFSchema.IGLTF;\n\n    const vrmExt = json.extensions?.VRM as V0VRM.VRM | undefined;\n    if (!vrmExt) {\n      return null;\n    }\n\n    const schemaHumanoid: V0VRM.Humanoid | undefined = vrmExt.humanoid;\n    if (!schemaHumanoid) {\n      return null;\n    }\n\n    const humanBones: Partial<VRMHumanBones> = {};\n    if (schemaHumanoid.humanBones != null) {\n      await Promise.all(\n        schemaHumanoid.humanBones.map(async (bone) => {\n          const boneName = bone.bone;\n          const index = bone.node;\n\n          if (boneName == null || index == null) {\n            return;\n          }\n\n          const node = await this.parser.getDependency('node', index);\n\n          // if the specified node does not exist, emit a warning\n          if (node == null) {\n            console.warn(`A glTF node bound to the humanoid bone ${boneName} (index = ${index}) does not exist`);\n            return;\n          }\n\n          // map to new bone name\n          const thumbBoneName = thumbBoneNameMap[boneName];\n          const newBoneName = (thumbBoneName ?? boneName) as V1VRMSchema.HumanoidHumanBoneName;\n\n          // v0 VRMs might have a multiple nodes attached to a single bone...\n          // so if there already is an entry in the `humanBones`, show a warning and ignore it\n          if (humanBones[newBoneName] != null) {\n            console.warn(\n              `Multiple bone entries for ${newBoneName} detected (index = ${index}), ignoring duplicated entries.`,\n            );\n            return;\n          }\n\n          // set to the `humanBones`\n          humanBones[newBoneName] = { node };\n        }),\n      );\n    }\n\n    const humanoid = new VRMHumanoid(this._ensureRequiredBonesExist(humanBones), {\n      autoUpdateHumanBones: this.autoUpdateHumanBones,\n    });\n    gltf.scene.add(humanoid.normalizedHumanBonesRoot);\n\n    if (this.helperRoot) {\n      const helper = new VRMHumanoidHelper(humanoid);\n      this.helperRoot.add(helper);\n      helper.renderOrder = this.helperRoot.renderOrder;\n    }\n\n    return humanoid;\n  }\n\n  /**\n   * Ensure required bones exist in given human bones.\n   * @param humanBones Human bones\n   * @returns Human bones, no longer partial!\n   */\n  private _ensureRequiredBonesExist(humanBones: Partial<VRMHumanBones>): VRMHumanBones {\n    // ensure required bones exist\n    const missingRequiredBones = Object.values(VRMRequiredHumanBoneName).filter(\n      (requiredBoneName) => humanBones[requiredBoneName] == null,\n    );\n\n    // throw an error if there are missing bones\n    if (missingRequiredBones.length > 0) {\n      throw new Error(\n        `VRMHumanoidLoaderPlugin: These humanoid bones are required but not exist: ${missingRequiredBones.join(', ')}`,\n      );\n    }\n\n    return humanBones as VRMHumanBones;\n  }\n}\n","import * as THREE from 'three';\n\nexport class FanBufferGeometry extends THREE.BufferGeometry {\n  public theta: number;\n  public radius: number;\n  private _currentTheta = 0;\n  private _currentRadius = 0;\n  private readonly _attrPos: THREE.BufferAttribute;\n  private readonly _attrIndex: THREE.BufferAttribute;\n\n  public constructor() {\n    super();\n\n    this.theta = 0.0;\n    this.radius = 0.0;\n    this._currentTheta = 0.0;\n    this._currentRadius = 0.0;\n\n    this._attrPos = new THREE.BufferAttribute(new Float32Array(65 * 3), 3);\n    this.setAttribute('position', this._attrPos);\n\n    this._attrIndex = new THREE.BufferAttribute(new Uint16Array(3 * 63), 1);\n    this.setIndex(this._attrIndex);\n\n    this._buildIndex();\n    this.update();\n  }\n\n  public update(): void {\n    let shouldUpdateGeometry = false;\n\n    if (this._currentTheta !== this.theta) {\n      this._currentTheta = this.theta;\n      shouldUpdateGeometry = true;\n    }\n\n    if (this._currentRadius !== this.radius) {\n      this._currentRadius = this.radius;\n      shouldUpdateGeometry = true;\n    }\n\n    if (shouldUpdateGeometry) {\n      this._buildPosition();\n    }\n  }\n\n  private _buildPosition(): void {\n    this._attrPos.setXYZ(0, 0.0, 0.0, 0.0);\n\n    for (let i = 0; i < 64; i++) {\n      const t = (i / 63.0) * this._currentTheta;\n\n      this._attrPos.setXYZ(i + 1, this._currentRadius * Math.sin(t), 0.0, this._currentRadius * Math.cos(t));\n    }\n\n    this._attrPos.needsUpdate = true;\n  }\n\n  private _buildIndex(): void {\n    for (let i = 0; i < 63; i++) {\n      this._attrIndex.setXYZ(i * 3, 0, i + 1, i + 2);\n    }\n\n    this._attrIndex.needsUpdate = true;\n  }\n}\n","import * as THREE from 'three';\n\nexport class LineAndSphereBufferGeometry extends THREE.BufferGeometry {\n  public radius: number;\n  public tail: THREE.Vector3;\n  private _currentRadius: number;\n  private _currentTail: THREE.Vector3;\n  private readonly _attrPos: THREE.BufferAttribute;\n  private readonly _attrIndex: THREE.BufferAttribute;\n\n  public constructor() {\n    super();\n\n    this.radius = 0.0;\n    this._currentRadius = 0.0;\n\n    this.tail = new THREE.Vector3();\n    this._currentTail = new THREE.Vector3();\n\n    this._attrPos = new THREE.BufferAttribute(new Float32Array(294), 3);\n    this.setAttribute('position', this._attrPos);\n\n    this._attrIndex = new THREE.BufferAttribute(new Uint16Array(194), 1);\n    this.setIndex(this._attrIndex);\n\n    this._buildIndex();\n    this.update();\n  }\n\n  public update(): void {\n    let shouldUpdateGeometry = false;\n\n    if (this._currentRadius !== this.radius) {\n      this._currentRadius = this.radius;\n      shouldUpdateGeometry = true;\n    }\n\n    if (!this._currentTail.equals(this.tail)) {\n      this._currentTail.copy(this.tail);\n      shouldUpdateGeometry = true;\n    }\n\n    if (shouldUpdateGeometry) {\n      this._buildPosition();\n    }\n  }\n\n  private _buildPosition(): void {\n    for (let i = 0; i < 32; i++) {\n      const t = (i / 16.0) * Math.PI;\n\n      this._attrPos.setXYZ(i, Math.cos(t), Math.sin(t), 0.0);\n      this._attrPos.setXYZ(32 + i, 0.0, Math.cos(t), Math.sin(t));\n      this._attrPos.setXYZ(64 + i, Math.sin(t), 0.0, Math.cos(t));\n    }\n\n    this.scale(this._currentRadius, this._currentRadius, this._currentRadius);\n    this.translate(this._currentTail.x, this._currentTail.y, this._currentTail.z);\n\n    this._attrPos.setXYZ(96, 0, 0, 0);\n    this._attrPos.setXYZ(97, this._currentTail.x, this._currentTail.y, this._currentTail.z);\n\n    this._attrPos.needsUpdate = true;\n  }\n\n  private _buildIndex(): void {\n    for (let i = 0; i < 32; i++) {\n      const i1 = (i + 1) % 32;\n\n      this._attrIndex.setXY(i * 2, i, i1);\n      this._attrIndex.setXY(64 + i * 2, 32 + i, 32 + i1);\n      this._attrIndex.setXY(128 + i * 2, 64 + i, 64 + i1);\n    }\n    this._attrIndex.setXY(192, 96, 97);\n\n    this._attrIndex.needsUpdate = true;\n  }\n}\n","import * as THREE from 'three';\nimport { VRMLookAt } from '../VRMLookAt';\nimport { FanBufferGeometry } from './utils/FanBufferGeometry';\nimport { LineAndSphereBufferGeometry } from './utils/LineAndSphereBufferGeometry';\n\nconst _quatA = new THREE.Quaternion();\nconst _quatB = new THREE.Quaternion();\nconst _v3A = new THREE.Vector3();\nconst _v3B = new THREE.Vector3();\n\nconst SQRT_2_OVER_2 = Math.sqrt(2.0) / 2.0;\nconst QUAT_XY_CW90 = new THREE.Quaternion(0, 0, -SQRT_2_OVER_2, SQRT_2_OVER_2);\nconst VEC3_POSITIVE_Y = new THREE.Vector3(0.0, 1.0, 0.0);\n\nexport class VRMLookAtHelper extends THREE.Group {\n  public readonly vrmLookAt: VRMLookAt;\n  private readonly _meshYaw: THREE.Mesh<FanBufferGeometry, THREE.MeshBasicMaterial>;\n  private readonly _meshPitch: THREE.Mesh<FanBufferGeometry, THREE.MeshBasicMaterial>;\n  private readonly _lineTarget: THREE.LineSegments<LineAndSphereBufferGeometry, THREE.LineBasicMaterial>;\n\n  public constructor(lookAt: VRMLookAt) {\n    super();\n    this.matrixAutoUpdate = false;\n\n    this.vrmLookAt = lookAt;\n\n    {\n      const geometry = new FanBufferGeometry();\n      geometry.radius = 0.5;\n\n      const material = new THREE.MeshBasicMaterial({\n        color: 0x00ff00,\n        transparent: true,\n        opacity: 0.5,\n        side: THREE.DoubleSide,\n        depthTest: false,\n        depthWrite: false,\n      });\n\n      this._meshPitch = new THREE.Mesh(geometry, material);\n      this.add(this._meshPitch);\n    }\n\n    {\n      const geometry = new FanBufferGeometry();\n      geometry.radius = 0.5;\n\n      const material = new THREE.MeshBasicMaterial({\n        color: 0xff0000,\n        transparent: true,\n        opacity: 0.5,\n        side: THREE.DoubleSide,\n        depthTest: false,\n        depthWrite: false,\n      });\n\n      this._meshYaw = new THREE.Mesh(geometry, material);\n      this.add(this._meshYaw);\n    }\n\n    {\n      const geometry = new LineAndSphereBufferGeometry();\n      geometry.radius = 0.1;\n\n      const material = new THREE.LineBasicMaterial({\n        color: 0xffffff,\n        depthTest: false,\n        depthWrite: false,\n      });\n\n      this._lineTarget = new THREE.LineSegments(geometry, material);\n      this._lineTarget.frustumCulled = false;\n      this.add(this._lineTarget);\n    }\n  }\n\n  public dispose(): void {\n    this._meshYaw.geometry.dispose();\n    this._meshYaw.material.dispose();\n\n    this._meshPitch.geometry.dispose();\n    this._meshPitch.material.dispose();\n\n    this._lineTarget.geometry.dispose();\n    this._lineTarget.material.dispose();\n  }\n\n  public updateMatrixWorld(force: boolean): void {\n    // update geometries\n    const yaw = THREE.MathUtils.DEG2RAD * this.vrmLookAt.yaw;\n    this._meshYaw.geometry.theta = yaw;\n    this._meshYaw.geometry.update();\n\n    const pitch = THREE.MathUtils.DEG2RAD * this.vrmLookAt.pitch;\n    this._meshPitch.geometry.theta = pitch;\n    this._meshPitch.geometry.update();\n\n    // get world position and quaternion\n    this.vrmLookAt.getLookAtWorldPosition(_v3A);\n    this.vrmLookAt.getLookAtWorldQuaternion(_quatA);\n\n    // calculate rotation using faceFront\n    _quatA.multiply(this.vrmLookAt.getFaceFrontQuaternion(_quatB));\n\n    // set transform to meshes\n    this._meshYaw.position.copy(_v3A);\n    this._meshYaw.quaternion.copy(_quatA);\n\n    this._meshPitch.position.copy(_v3A);\n    this._meshPitch.quaternion.copy(_quatA);\n    this._meshPitch.quaternion.multiply(_quatB.setFromAxisAngle(VEC3_POSITIVE_Y, yaw));\n    this._meshPitch.quaternion.multiply(QUAT_XY_CW90);\n\n    // update target line and sphere\n    const { target, autoUpdate } = this.vrmLookAt;\n    if (target != null && autoUpdate) {\n      target.getWorldPosition(_v3B).sub(_v3A);\n      this._lineTarget.geometry.tail.copy(_v3B);\n      this._lineTarget.geometry.update();\n      this._lineTarget.position.copy(_v3A);\n    }\n\n    // apply transform to meshes\n    super.updateMatrixWorld(force);\n  }\n}\n","import * as THREE from 'three';\n\nconst _position = new THREE.Vector3();\nconst _scale = new THREE.Vector3();\n\n/**\n * Extract world rotation of an object from its world space matrix, in cheaper way.\n *\n * @param object The object\n * @param out Target vector\n */\nexport function getWorldQuaternionLite(object: THREE.Object3D, out: THREE.Quaternion): THREE.Quaternion {\n  object.matrixWorld.decompose(_position, out, _scale);\n  return out;\n}\n","import * as THREE from 'three';\n\n/**\n * Calculate azimuth / altitude angles from a vector.\n *\n * This returns a difference of angles from (1, 0, 0).\n * Azimuth represents an angle around Y axis.\n * Altitude represents an angle around Z axis.\n * It is rotated in intrinsic Y-Z order.\n *\n * @param vector The vector\n * @returns A tuple contains two angles, `[ azimuth, altitude ]`\n */\nexport function calcAzimuthAltitude(vector: THREE.Vector3): [azimuth: number, altitude: number] {\n  return [Math.atan2(-vector.z, vector.x), Math.atan2(vector.y, Math.sqrt(vector.x * vector.x + vector.z * vector.z))];\n}\n","/**\n * Make sure the angle is within -PI to PI.\n *\n * @example\n * ```js\n * sanitizeAngle(1.5 * Math.PI) // -0.5 * PI\n * ```\n *\n * @param angle An input angle\n */\nexport function sanitizeAngle(angle: number): number {\n  const roundTurn = Math.round(angle / 2.0 / Math.PI);\n  return angle - 2.0 * Math.PI * roundTurn;\n}\n","import * as THREE from 'three';\nimport { VRMHumanoid } from '../humanoid';\nimport { getWorldQuaternionLite } from '../utils/getWorldQuaternionLite';\nimport { quatInvertCompat } from '../utils/quatInvertCompat';\nimport { calcAzimuthAltitude } from './utils/calcAzimuthAltitude';\nimport type { VRMLookAtApplier } from './VRMLookAtApplier';\nimport { sanitizeAngle } from './utils/sanitizeAngle';\n\nconst VEC3_POSITIVE_Z = new THREE.Vector3(0.0, 0.0, 1.0);\n\nconst _v3A = new THREE.Vector3();\nconst _v3B = new THREE.Vector3();\nconst _v3C = new THREE.Vector3();\nconst _quatA = new THREE.Quaternion();\nconst _quatB = new THREE.Quaternion();\nconst _quatC = new THREE.Quaternion();\nconst _quatD = new THREE.Quaternion();\nconst _eulerA = new THREE.Euler();\n\n/**\n * A class controls eye gaze movements of a VRM.\n */\nexport class VRMLookAt {\n  public static readonly EULER_ORDER = 'YXZ'; // yaw-pitch-roll\n\n  /**\n   * The origin of LookAt. Position offset from the head bone.\n   */\n  public offsetFromHeadBone = new THREE.Vector3();\n\n  /**\n   * Its associated {@link VRMHumanoid}.\n   */\n  public readonly humanoid: VRMHumanoid;\n\n  /**\n   * The {@link VRMLookAtApplier} of the LookAt.\n   */\n  public applier: VRMLookAtApplier;\n\n  /**\n   * If this is true, the LookAt will be updated automatically by calling {@link update}, towarding the direction to the {@link target}.\n   * `true` by default.\n   *\n   * See also: {@link target}\n   */\n  public autoUpdate = true;\n\n  /**\n   * The target object of the LookAt.\n   * Note that it does not make any sense if {@link autoUpdate} is disabled.\n   *\n   * See also: {@link autoUpdate}\n   */\n  public target?: THREE.Object3D | null;\n\n  /**\n   * The front direction of the face.\n   * Intended to be used for VRM 0.0 compat (VRM 0.0 models are facing Z- instead of Z+).\n   * You usually don't want to touch this.\n   */\n  public faceFront = new THREE.Vector3(0.0, 0.0, 1.0);\n\n  /**\n   * Its current angle around Y axis, in degree.\n   */\n  protected _yaw: number;\n\n  /**\n   * Its current angle around Y axis, in degree.\n   */\n  public get yaw(): number {\n    return this._yaw;\n  }\n\n  /**\n   * Its current angle around Y axis, in degree.\n   */\n  public set yaw(value: number) {\n    this._yaw = value;\n    this._needsUpdate = true;\n  }\n\n  /**\n   * Its current angle around X axis, in degree.\n   */\n  protected _pitch: number;\n\n  /**\n   * Its current angle around X axis, in degree.\n   */\n  public get pitch(): number {\n    return this._pitch;\n  }\n\n  /**\n   * Its current angle around X axis, in degree.\n   */\n  public set pitch(value: number) {\n    this._pitch = value;\n    this._needsUpdate = true;\n  }\n\n  /**\n   * Specifies that angles need to be applied to its [@link applier].\n   */\n  protected _needsUpdate: boolean;\n\n  /**\n   * World rotation of the head in its rest pose.\n   */\n  private _restHeadWorldQuaternion: THREE.Quaternion;\n\n  /**\n   * @deprecated Use {@link getEuler} instead.\n   */\n  public get euler(): THREE.Euler {\n    console.warn('VRMLookAt: euler is deprecated. use getEuler() instead.');\n\n    return this.getEuler(new THREE.Euler());\n  }\n\n  /**\n   * Create a new {@link VRMLookAt}.\n   *\n   * @param humanoid A {@link VRMHumanoid}\n   * @param applier A {@link VRMLookAtApplier}\n   */\n  public constructor(humanoid: VRMHumanoid, applier: VRMLookAtApplier) {\n    this.humanoid = humanoid;\n    this.applier = applier;\n\n    this._yaw = 0.0;\n    this._pitch = 0.0;\n    this._needsUpdate = true;\n\n    this._restHeadWorldQuaternion = this.getLookAtWorldQuaternion(new THREE.Quaternion());\n  }\n\n  /**\n   * Get its yaw-pitch angles as an `Euler`.\n   * Does NOT consider {@link faceFront}.\n   *\n   * @param target The target euler\n   */\n  public getEuler(target: THREE.Euler): THREE.Euler {\n    return target.set(THREE.MathUtils.DEG2RAD * this._pitch, THREE.MathUtils.DEG2RAD * this._yaw, 0.0, 'YXZ');\n  }\n\n  /**\n   * Copy the given {@link VRMLookAt} into this one.\n   * {@link humanoid} must be same as the source one.\n   * {@link applier} will reference the same instance as the source one.\n   * @param source The {@link VRMLookAt} you want to copy\n   * @returns this\n   */\n  public copy(source: VRMLookAt): this {\n    if (this.humanoid !== source.humanoid) {\n      throw new Error('VRMLookAt: humanoid must be same in order to copy');\n    }\n\n    this.offsetFromHeadBone.copy(source.offsetFromHeadBone);\n    this.applier = source.applier;\n    this.autoUpdate = source.autoUpdate;\n    this.target = source.target;\n    this.faceFront.copy(source.faceFront);\n\n    return this;\n  }\n\n  /**\n   * Returns a clone of this {@link VRMLookAt}.\n   * Note that {@link humanoid} and {@link applier} will reference the same instance as this one.\n   * @returns Copied {@link VRMLookAt}\n   */\n  public clone(): VRMLookAt {\n    return new VRMLookAt(this.humanoid, this.applier).copy(this);\n  }\n\n  /**\n   * Reset the lookAt direction to initial direction.\n   */\n  public reset(): void {\n    this._yaw = 0.0;\n    this._pitch = 0.0;\n    this._needsUpdate = true;\n  }\n\n  /**\n   * Get its head position in world coordinate.\n   *\n   * @param target A target `THREE.Vector3`\n   */\n  public getLookAtWorldPosition(target: THREE.Vector3): THREE.Vector3 {\n    const head = this.humanoid.getRawBoneNode('head')!;\n\n    return target.copy(this.offsetFromHeadBone).applyMatrix4(head.matrixWorld);\n  }\n\n  /**\n   * Get its head rotation in world coordinate.\n   * Does NOT consider {@link faceFront}.\n   *\n   * @param target A target `THREE.Quaternion`\n   */\n  public getLookAtWorldQuaternion(target: THREE.Quaternion): THREE.Quaternion {\n    const head = this.humanoid.getRawBoneNode('head')!;\n\n    return getWorldQuaternionLite(head, target);\n  }\n\n  /**\n   * Get a quaternion that rotates the +Z unit vector of the humanoid Head to the {@link faceFront} direction.\n   *\n   * @param target A target `THREE.Quaternion`\n   */\n  public getFaceFrontQuaternion(target: THREE.Quaternion): THREE.Quaternion {\n    if (this.faceFront.distanceToSquared(VEC3_POSITIVE_Z) < 0.01) {\n      return target.copy(this._restHeadWorldQuaternion).invert();\n    }\n\n    const [faceFrontAzimuth, faceFrontAltitude] = calcAzimuthAltitude(this.faceFront);\n    _eulerA.set(0.0, 0.5 * Math.PI + faceFrontAzimuth, faceFrontAltitude, 'YZX');\n\n    return target.setFromEuler(_eulerA).premultiply(_quatD.copy(this._restHeadWorldQuaternion).invert());\n  }\n\n  /**\n   * Get its LookAt direction in world coordinate.\n   *\n   * @param target A target `THREE.Vector3`\n   */\n  public getLookAtWorldDirection(target: THREE.Vector3): THREE.Vector3 {\n    this.getLookAtWorldQuaternion(_quatB);\n    this.getFaceFrontQuaternion(_quatC);\n\n    return target\n      .copy(VEC3_POSITIVE_Z)\n      .applyQuaternion(_quatB)\n      .applyQuaternion(_quatC)\n      .applyEuler(this.getEuler(_eulerA));\n  }\n\n  /**\n   * Set its LookAt position.\n   * Note that its result will be instantly overwritten if {@link VRMLookAtHead.autoUpdate} is enabled.\n   *\n   * @param position A target position, in world space\n   */\n  public lookAt(position: THREE.Vector3): void {\n    // Look at direction in local coordinate\n    const headRotDiffInv = _quatA\n      .copy(this._restHeadWorldQuaternion)\n      .multiply(quatInvertCompat(this.getLookAtWorldQuaternion(_quatB)));\n    const headPos = this.getLookAtWorldPosition(_v3B);\n    const lookAtDir = _v3C.copy(position).sub(headPos).applyQuaternion(headRotDiffInv).normalize();\n\n    // calculate angles\n    const [azimuthFrom, altitudeFrom] = calcAzimuthAltitude(this.faceFront);\n    const [azimuthTo, altitudeTo] = calcAzimuthAltitude(lookAtDir);\n    const yaw = sanitizeAngle(azimuthTo - azimuthFrom);\n    const pitch = sanitizeAngle(altitudeFrom - altitudeTo); // spinning (1, 0, 0) CCW around Z axis makes the vector look up, while spinning (0, 0, 1) CCW around X axis makes the vector look down\n\n    // apply angles\n    this._yaw = THREE.MathUtils.RAD2DEG * yaw;\n    this._pitch = THREE.MathUtils.RAD2DEG * pitch;\n\n    this._needsUpdate = true;\n  }\n\n  /**\n   * Update the VRMLookAtHead.\n   * If {@link VRMLookAtHead.autoUpdate} is disabled, it will do nothing.\n   *\n   * @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}.\n   */\n  public update(delta: number): void {\n    if (this.target != null && this.autoUpdate) {\n      this.lookAt(this.target.getWorldPosition(_v3A));\n    }\n\n    if (this._needsUpdate) {\n      this._needsUpdate = false;\n\n      this.applier.applyYawPitch(this._yaw, this._pitch);\n    }\n  }\n}\n","import { VRMHumanoid } from '../humanoid';\nimport * as THREE from 'three';\nimport type { VRMLookAtApplier } from './VRMLookAtApplier';\nimport { VRMLookAtRangeMap } from './VRMLookAtRangeMap';\nimport { calcAzimuthAltitude } from './utils/calcAzimuthAltitude';\nimport { getWorldQuaternionLite } from '../utils/getWorldQuaternionLite';\n\nconst VEC3_POSITIVE_Z = new THREE.Vector3(0.0, 0.0, 1.0);\n\nconst _quatA = new THREE.Quaternion();\nconst _quatB = new THREE.Quaternion();\nconst _eulerA = new THREE.Euler(0.0, 0.0, 0.0, 'YXZ');\n\n/**\n * A class that applies eye gaze directions to a VRM.\n * It will be used by {@link VRMLookAt}.\n */\nexport class VRMLookAtBoneApplier implements VRMLookAtApplier {\n  /**\n   * Represent its type of applier.\n   */\n  public static readonly type = 'bone';\n\n  /**\n   * Its associated {@link VRMHumanoid}.\n   */\n  public readonly humanoid: VRMHumanoid;\n\n  /**\n   * A {@link VRMLookAtRangeMap} for horizontal inward movement. The left eye moves right. The right eye moves left.\n   */\n  public rangeMapHorizontalInner: VRMLookAtRangeMap;\n\n  /**\n   * A {@link VRMLookAtRangeMap} for horizontal outward movement. The left eye moves left. The right eye moves right.\n   */\n  public rangeMapHorizontalOuter: VRMLookAtRangeMap;\n\n  /**\n   * A {@link VRMLookAtRangeMap} for vertical downward movement. Both eyes move upwards.\n   */\n  public rangeMapVerticalDown: VRMLookAtRangeMap;\n\n  /**\n   * A {@link VRMLookAtRangeMap} for vertical upward movement. Both eyes move downwards.\n   */\n  public rangeMapVerticalUp: VRMLookAtRangeMap;\n\n  /**\n   * The front direction of the face.\n   * Intended to be used for VRM 0.0 compat (VRM 0.0 models are facing Z- instead of Z+).\n   * You usually don't want to touch this.\n   */\n  public faceFront: THREE.Vector3;\n\n  /**\n   * The rest quaternion of LeftEye bone.\n   */\n  private _restQuatLeftEye: THREE.Quaternion;\n\n  /**\n   * The rest quaternion of RightEye bone.\n   */\n  private _restQuatRightEye: THREE.Quaternion;\n\n  /**\n   * The world-space rest quaternion of the parent of the humanoid LeftEye.\n   */\n  private _restLeftEyeParentWorldQuat: THREE.Quaternion;\n\n  /**\n   * The world-space rest quaternion of the parent of the humanoid RightEye.\n   */\n  private _restRightEyeParentWorldQuat: THREE.Quaternion;\n\n  /**\n   * Create a new {@link VRMLookAtBoneApplier}.\n   *\n   * @param humanoid A {@link VRMHumanoid}\n   * @param rangeMapHorizontalInner A {@link VRMLookAtRangeMap} used for inner transverse direction\n   * @param rangeMapHorizontalOuter A {@link VRMLookAtRangeMap} used for outer transverse direction\n   * @param rangeMapVerticalDown A {@link VRMLookAtRangeMap} used for down direction\n   * @param rangeMapVerticalUp A {@link VRMLookAtRangeMap} used for up direction\n   */\n  public constructor(\n    humanoid: VRMHumanoid,\n    rangeMapHorizontalInner: VRMLookAtRangeMap,\n    rangeMapHorizontalOuter: VRMLookAtRangeMap,\n    rangeMapVerticalDown: VRMLookAtRangeMap,\n    rangeMapVerticalUp: VRMLookAtRangeMap,\n  ) {\n    this.humanoid = humanoid;\n\n    this.rangeMapHorizontalInner = rangeMapHorizontalInner;\n    this.rangeMapHorizontalOuter = rangeMapHorizontalOuter;\n    this.rangeMapVerticalDown = rangeMapVerticalDown;\n    this.rangeMapVerticalUp = rangeMapVerticalUp;\n\n    this.faceFront = new THREE.Vector3(0.0, 0.0, 1.0);\n\n    // set rest quaternions\n    this._restQuatLeftEye = new THREE.Quaternion();\n    this._restQuatRightEye = new THREE.Quaternion();\n    this._restLeftEyeParentWorldQuat = new THREE.Quaternion();\n    this._restRightEyeParentWorldQuat = new THREE.Quaternion();\n\n    const leftEye = this.humanoid.getRawBoneNode('leftEye');\n    const rightEye = this.humanoid.getRawBoneNode('leftEye');\n\n    if (leftEye) {\n      this._restQuatLeftEye.copy(leftEye.quaternion);\n      getWorldQuaternionLite(leftEye.parent!, this._restLeftEyeParentWorldQuat);\n    }\n\n    if (rightEye) {\n      this._restQuatRightEye.copy(rightEye.quaternion);\n      getWorldQuaternionLite(rightEye.parent!, this._restRightEyeParentWorldQuat);\n    }\n  }\n\n  /**\n   * Apply the input angle to its associated VRM model.\n   *\n   * @param yaw Rotation around Y axis, in degree\n   * @param pitch Rotation around X axis, in degree\n   */\n  public applyYawPitch(yaw: number, pitch: number): void {\n    const leftEye = this.humanoid.getRawBoneNode('leftEye');\n    const rightEye = this.humanoid.getRawBoneNode('rightEye');\n    const leftEyeNormalized = this.humanoid.getNormalizedBoneNode('leftEye');\n    const rightEyeNormalized = this.humanoid.getNormalizedBoneNode('rightEye');\n    // left\n    if (leftEye) {\n      if (pitch < 0.0) {\n        _eulerA.x = -THREE.MathUtils.DEG2RAD * this.rangeMapVerticalDown.map(-pitch);\n      } else {\n        _eulerA.x = THREE.MathUtils.DEG2RAD * this.rangeMapVerticalUp.map(pitch);\n      }\n\n      if (yaw < 0.0) {\n        _eulerA.y = -THREE.MathUtils.DEG2RAD * this.rangeMapHorizontalInner.map(-yaw);\n      } else {\n        _eulerA.y = THREE.MathUtils.DEG2RAD * this.rangeMapHorizontalOuter.map(yaw);\n      }\n\n      _quatA.setFromEuler(_eulerA);\n      this._getWorldFaceFrontQuat(_quatB);\n\n      // _quatB * _quatA * _quatB^-1\n      // where _quatA is LookAt rotation\n      // and _quatB is worldFaceFrontQuat\n      leftEyeNormalized!.quaternion.copy(_quatB).multiply(_quatA).multiply(_quatB.invert());\n\n      _quatA.copy(this._restLeftEyeParentWorldQuat);\n\n      // _quatA^-1 * leftEyeNormalized.quaternion * _quatA * restQuatLeftEye\n      // where _quatA is restLeftEyeParentWorldQuat\n      leftEye.quaternion\n        .copy(leftEyeNormalized!.quaternion)\n        .multiply(_quatA)\n        .premultiply(_quatA.invert())\n        .multiply(this._restQuatLeftEye);\n    }\n\n    // right\n    if (rightEye) {\n      if (pitch < 0.0) {\n        _eulerA.x = -THREE.MathUtils.DEG2RAD * this.rangeMapVerticalDown.map(-pitch);\n      } else {\n        _eulerA.x = THREE.MathUtils.DEG2RAD * this.rangeMapVerticalUp.map(pitch);\n      }\n\n      if (yaw < 0.0) {\n        _eulerA.y = -THREE.MathUtils.DEG2RAD * this.rangeMapHorizontalOuter.map(-yaw);\n      } else {\n        _eulerA.y = THREE.MathUtils.DEG2RAD * this.rangeMapHorizontalInner.map(yaw);\n      }\n\n      _quatA.setFromEuler(_eulerA);\n      this._getWorldFaceFrontQuat(_quatB);\n\n      // _quatB * _quatA * _quatB^-1\n      // where _quatA is LookAt rotation\n      // and _quatB is worldFaceFrontQuat\n      rightEyeNormalized!.quaternion.copy(_quatB).multiply(_quatA).multiply(_quatB.invert());\n\n      _quatA.copy(this._restRightEyeParentWorldQuat);\n\n      // _quatA^-1 * rightEyeNormalized.quaternion * _quatA * restQuatRightEye\n      // where _quatA is restRightEyeParentWorldQuat\n      rightEye.quaternion\n        .copy(rightEyeNormalized!.quaternion)\n        .multiply(_quatA)\n        .premultiply(_quatA.invert())\n        .multiply(this._restQuatRightEye);\n    }\n  }\n\n  /**\n   * @deprecated Use {@link applyYawPitch} instead.\n   */\n  public lookAt(euler: THREE.Euler): void {\n    console.warn('VRMLookAtBoneApplier: lookAt() is deprecated. use apply() instead.');\n\n    const yaw = THREE.MathUtils.RAD2DEG * euler.y;\n    const pitch = THREE.MathUtils.RAD2DEG * euler.x;\n\n    this.applyYawPitch(yaw, pitch);\n  }\n\n  /**\n   * Get a quaternion that rotates the world-space +Z unit vector to the {@link faceFront} direction.\n   *\n   * @param target A target `THREE.Quaternion`\n   */\n  private _getWorldFaceFrontQuat(target: THREE.Quaternion): THREE.Quaternion {\n    if (this.faceFront.distanceToSquared(VEC3_POSITIVE_Z) < 0.01) {\n      return target.identity();\n    }\n\n    const [faceFrontAzimuth, faceFrontAltitude] = calcAzimuthAltitude(this.faceFront);\n    _eulerA.set(0.0, 0.5 * Math.PI + faceFrontAzimuth, faceFrontAltitude, 'YZX');\n\n    return target.setFromEuler(_eulerA);\n  }\n}\n","import { VRMExpressionManager } from '../expressions';\nimport * as THREE from 'three';\nimport type { VRMLookAtApplier } from './VRMLookAtApplier';\nimport { VRMLookAtRangeMap } from './VRMLookAtRangeMap';\n\n/**\n * A class that applies eye gaze directions to a VRM.\n * It will be used by {@link VRMLookAt}.\n */\nexport class VRMLookAtExpressionApplier implements VRMLookAtApplier {\n  /**\n   * Represent its type of applier.\n   */\n  public static readonly type = 'expression';\n\n  /**\n   * Its associated {@link VRMExpressionManager}.\n   */\n  public readonly expressions: VRMExpressionManager;\n\n  /**\n   * It won't be used in expression applier.\n   * See also: {@link rangeMapHorizontalOuter}\n   */\n  public rangeMapHorizontalInner: VRMLookAtRangeMap;\n\n  /**\n   * A {@link VRMLookAtRangeMap} for horizontal movement. Both eyes move left or right.\n   */\n  public rangeMapHorizontalOuter: VRMLookAtRangeMap;\n\n  /**\n   * A {@link VRMLookAtRangeMap} for vertical downward movement. Both eyes move upwards.\n   */\n  public rangeMapVerticalDown: VRMLookAtRangeMap;\n\n  /**\n   * A {@link VRMLookAtRangeMap} for vertical upward movement. Both eyes move downwards.\n   */\n  public rangeMapVerticalUp: VRMLookAtRangeMap;\n\n  /**\n   * Create a new {@link VRMLookAtExpressionApplier}.\n   *\n   * @param expressions A {@link VRMExpressionManager}\n   * @param rangeMapHorizontalInner A {@link VRMLookAtRangeMap} used for inner transverse direction\n   * @param rangeMapHorizontalOuter A {@link VRMLookAtRangeMap} used for outer transverse direction\n   * @param rangeMapVerticalDown A {@link VRMLookAtRangeMap} used for down direction\n   * @param rangeMapVerticalUp A {@link VRMLookAtRangeMap} used for up direction\n   */\n  public constructor(\n    expressions: VRMExpressionManager,\n    rangeMapHorizontalInner: VRMLookAtRangeMap,\n    rangeMapHorizontalOuter: VRMLookAtRangeMap,\n    rangeMapVerticalDown: VRMLookAtRangeMap,\n    rangeMapVerticalUp: VRMLookAtRangeMap,\n  ) {\n    this.expressions = expressions;\n\n    this.rangeMapHorizontalInner = rangeMapHorizontalInner;\n    this.rangeMapHorizontalOuter = rangeMapHorizontalOuter;\n    this.rangeMapVerticalDown = rangeMapVerticalDown;\n    this.rangeMapVerticalUp = rangeMapVerticalUp;\n  }\n\n  /**\n   * Apply the input angle to its associated VRM model.\n   *\n   * @param yaw Rotation around Y axis, in degree\n   * @param pitch Rotation around X axis, in degree\n   */\n  public applyYawPitch(yaw: number, pitch: number): void {\n    if (pitch < 0.0) {\n      this.expressions.setValue('lookDown', 0.0);\n      this.expressions.setValue('lookUp', this.rangeMapVerticalUp.map(-pitch));\n    } else {\n      this.expressions.setValue('lookUp', 0.0);\n      this.expressions.setValue('lookDown', this.rangeMapVerticalDown.map(pitch));\n    }\n\n    if (yaw < 0.0) {\n      this.expressions.setValue('lookLeft', 0.0);\n      this.expressions.setValue('lookRight', this.rangeMapHorizontalOuter.map(-yaw));\n    } else {\n      this.expressions.setValue('lookRight', 0.0);\n      this.expressions.setValue('lookLeft', this.rangeMapHorizontalOuter.map(yaw));\n    }\n  }\n\n  /**\n   * @deprecated Use {@link applyYawPitch} instead.\n   */\n  public lookAt(euler: THREE.Euler): void {\n    console.warn('VRMLookAtBoneApplier: lookAt() is deprecated. use apply() instead.');\n\n    const yaw = THREE.MathUtils.RAD2DEG * euler.y;\n    const pitch = THREE.MathUtils.RAD2DEG * euler.x;\n\n    this.applyYawPitch(yaw, pitch);\n  }\n}\n","import { saturate } from '../utils/saturate';\n\nexport class VRMLookAtRangeMap {\n  /**\n   * Limits the maximum angle of the input angle of the LookAt vector from the front of the head (the positive z axis).\n   */\n  public inputMaxValue: number;\n\n  /**\n   * Represents an angle (in degrees) for bone type of LookAt appliers, or a weight for expression type of LookAt appliers.\n   * The input value will take `1.0` when the input angle equals (or greater) to {@link inputMaxValue}.\n   */\n  public outputScale: number;\n\n  /**\n   * Create a new {@link VRMLookAtRangeMap}.\n   *\n   * @param inputMaxValue The {@link inputMaxValue} of the map\n   * @param outputScale The {@link outputScale} of the map\n   */\n  public constructor(inputMaxValue: number, outputScale: number) {\n    this.inputMaxValue = inputMaxValue;\n    this.outputScale = outputScale;\n  }\n\n  /**\n   * Evaluate an input value and output a mapped value.\n   * @param src The input value\n   */\n  public map(src: number): number {\n    return this.outputScale * saturate(src / this.inputMaxValue);\n  }\n}\n","import type * as V0VRM from '@pixiv/types-vrm-0.0';\nimport type * as V1VRMSchema from '@pixiv/types-vrmc-vrm-1.0';\nimport type { GLTF, GLTFLoaderPlugin, GLTFParser } from 'three/examples/jsm/loaders/GLTFLoader.js';\nimport type { VRMExpressionManager } from '../expressions/VRMExpressionManager';\nimport type { VRMHumanoid } from '../humanoid/VRMHumanoid';\nimport { VRMLookAtHelper } from './helpers/VRMLookAtHelper';\nimport { VRMLookAt } from './VRMLookAt';\nimport type { VRMLookAtApplier } from './VRMLookAtApplier';\nimport { VRMLookAtBoneApplier } from './VRMLookAtBoneApplier';\nimport { VRMLookAtExpressionApplier } from './VRMLookAtExpressionApplier';\nimport type { VRMLookAtLoaderPluginOptions } from './VRMLookAtLoaderPluginOptions';\nimport { VRMLookAtRangeMap } from './VRMLookAtRangeMap';\nimport { GLTF as GLTFSchema } from '@gltf-transform/core';\n\n/**\n * Possible spec versions it recognizes.\n */\nconst POSSIBLE_SPEC_VERSIONS = new Set(['1.0', '1.0-beta']);\n\n/**\n * A plugin of GLTFLoader that imports a {@link VRMLookAt} from a VRM extension of a GLTF.\n */\nexport class VRMLookAtLoaderPlugin implements GLTFLoaderPlugin {\n  /**\n   * Specify an Object3D to add {@link VRMLookAtHelper} s.\n   * If not specified, helper will not be created.\n   * If `renderOrder` is set to the root, helpers will copy the same `renderOrder` .\n   */\n  public helperRoot?: THREE.Object3D;\n\n  public readonly parser: GLTFParser;\n\n  public get name(): string {\n    // We should use the extension name instead but we have multiple plugins for an extension...\n    return 'VRMLookAtLoaderPlugin';\n  }\n\n  public constructor(parser: GLTFParser, options?: VRMLookAtLoaderPluginOptions) {\n    this.parser = parser;\n\n    this.helperRoot = options?.helperRoot;\n  }\n\n  public async afterRoot(gltf: GLTF): Promise<void> {\n    const vrmHumanoid = gltf.userData.vrmHumanoid as VRMHumanoid | undefined;\n\n    // explicitly distinguish null and undefined\n    // since vrmHumanoid might be null as a result\n    if (vrmHumanoid === null) {\n      return;\n    } else if (vrmHumanoid === undefined) {\n      throw new Error('VRMLookAtLoaderPlugin: vrmHumanoid is undefined. VRMHumanoidLoaderPlugin have to be used first');\n    }\n\n    const vrmExpressionManager = gltf.userData.vrmExpressionManager as VRMExpressionManager | undefined;\n\n    if (vrmExpressionManager === null) {\n      return;\n    } else if (vrmExpressionManager === undefined) {\n      throw new Error(\n        'VRMLookAtLoaderPlugin: vrmExpressionManager is undefined. VRMExpressionLoaderPlugin have to be used first',\n      );\n    }\n\n    gltf.userData.vrmLookAt = await this._import(gltf, vrmHumanoid, vrmExpressionManager);\n  }\n\n  /**\n   * Import a {@link VRMLookAt} from a VRM.\n   *\n   * @param gltf A parsed result of GLTF taken from GLTFLoader\n   * @param humanoid A {@link VRMHumanoid} instance that represents the VRM\n   * @param expressions A {@link VRMExpressionManager} instance that represents the VRM\n   */\n  private async _import(\n    gltf: GLTF,\n    humanoid: VRMHumanoid | null,\n    expressions: VRMExpressionManager | null,\n  ): Promise<VRMLookAt | null> {\n    if (humanoid == null || expressions == null) {\n      return null;\n    }\n\n    const v1Result = await this._v1Import(gltf, humanoid, expressions);\n    if (v1Result) {\n      return v1Result;\n    }\n\n    const v0Result = await this._v0Import(gltf, humanoid, expressions);\n    if (v0Result) {\n      return v0Result;\n    }\n\n    return null;\n  }\n\n  private async _v1Import(\n    gltf: GLTF,\n    humanoid: VRMHumanoid,\n    expressions: VRMExpressionManager,\n  ): Promise<VRMLookAt | null> {\n    const json = this.parser.json as GLTFSchema.IGLTF;\n\n    // early abort if it doesn't use vrm\n    const isVRMUsed = json.extensionsUsed?.indexOf('VRMC_vrm') !== -1;\n    if (!isVRMUsed) {\n      return null;\n    }\n\n    const extension = json.extensions?.['VRMC_vrm'] as V1VRMSchema.VRMCVRM | undefined;\n    if (!extension) {\n      return null;\n    }\n\n    const specVersion = extension.specVersion;\n    if (!POSSIBLE_SPEC_VERSIONS.has(specVersion)) {\n      console.warn(`VRMLookAtLoaderPlugin: Unknown VRMC_vrm specVersion \"${specVersion}\"`);\n      return null;\n    }\n\n    const schemaLookAt = extension.lookAt;\n    if (!schemaLookAt) {\n      return null;\n    }\n\n    const defaultOutputScale = schemaLookAt.type === 'expression' ? 1.0 : 10.0;\n\n    const mapHI = this._v1ImportRangeMap(schemaLookAt.rangeMapHorizontalInner, defaultOutputScale);\n    const mapHO = this._v1ImportRangeMap(schemaLookAt.rangeMapHorizontalOuter, defaultOutputScale);\n    const mapVD = this._v1ImportRangeMap(schemaLookAt.rangeMapVerticalDown, defaultOutputScale);\n    const mapVU = this._v1ImportRangeMap(schemaLookAt.rangeMapVerticalUp, defaultOutputScale);\n\n    let applier;\n\n    if (schemaLookAt.type === 'expression') {\n      applier = new VRMLookAtExpressionApplier(expressions, mapHI, mapHO, mapVD, mapVU);\n    } else {\n      applier = new VRMLookAtBoneApplier(humanoid, mapHI, mapHO, mapVD, mapVU);\n    }\n\n    const lookAt = this._importLookAt(humanoid, applier);\n\n    lookAt.offsetFromHeadBone.fromArray(schemaLookAt.offsetFromHeadBone ?? [0.0, 0.06, 0.0]);\n\n    return lookAt;\n  }\n\n  private _v1ImportRangeMap(\n    schemaRangeMap: V1VRMSchema.LookAtRangeMap | undefined,\n    defaultOutputScale: number,\n  ): VRMLookAtRangeMap {\n    return new VRMLookAtRangeMap(\n      schemaRangeMap?.inputMaxValue ?? 90.0,\n      schemaRangeMap?.outputScale ?? defaultOutputScale,\n    );\n  }\n\n  private async _v0Import(\n    gltf: GLTF,\n    humanoid: VRMHumanoid,\n    expressions: VRMExpressionManager,\n  ): Promise<VRMLookAt | null> {\n    const json = this.parser.json as GLTFSchema.IGLTF;\n\n    // early abort if it doesn't use vrm\n    const vrmExt = json.extensions?.VRM as V0VRM.VRM | undefined;\n    if (!vrmExt) {\n      return null;\n    }\n\n    const schemaFirstPerson = vrmExt.firstPerson;\n    if (!schemaFirstPerson) {\n      return null;\n    }\n\n    const defaultOutputScale = schemaFirstPerson.lookAtTypeName === 'BlendShape' ? 1.0 : 10.0;\n\n    const mapHI = this._v0ImportDegreeMap(schemaFirstPerson.lookAtHorizontalInner, defaultOutputScale);\n    const mapHO = this._v0ImportDegreeMap(schemaFirstPerson.lookAtHorizontalOuter, defaultOutputScale);\n    const mapVD = this._v0ImportDegreeMap(schemaFirstPerson.lookAtVerticalDown, defaultOutputScale);\n    const mapVU = this._v0ImportDegreeMap(schemaFirstPerson.lookAtVerticalUp, defaultOutputScale);\n\n    let applier;\n\n    if (schemaFirstPerson.lookAtTypeName === 'BlendShape') {\n      applier = new VRMLookAtExpressionApplier(expressions, mapHI, mapHO, mapVD, mapVU);\n    } else {\n      applier = new VRMLookAtBoneApplier(humanoid, mapHI, mapHO, mapVD, mapVU);\n    }\n\n    const lookAt = this._importLookAt(humanoid, applier);\n\n    if (schemaFirstPerson.firstPersonBoneOffset) {\n      lookAt.offsetFromHeadBone.set(\n        schemaFirstPerson.firstPersonBoneOffset.x ?? 0.0,\n        schemaFirstPerson.firstPersonBoneOffset.y ?? 0.06,\n        -(schemaFirstPerson.firstPersonBoneOffset.z ?? 0.0),\n      );\n    } else {\n      lookAt.offsetFromHeadBone.set(0.0, 0.06, 0.0);\n    }\n\n    // VRM 0.0 are facing Z- instead of Z+\n    lookAt.faceFront.set(0.0, 0.0, -1.0);\n\n    if (applier instanceof VRMLookAtBoneApplier) {\n      applier.faceFront.set(0.0, 0.0, -1.0);\n    }\n\n    return lookAt;\n  }\n\n  private _v0ImportDegreeMap(\n    schemaDegreeMap: V0VRM.FirstPersonDegreeMap | undefined,\n    defaultOutputScale: number,\n  ): VRMLookAtRangeMap {\n    const curve = schemaDegreeMap?.curve;\n    if (JSON.stringify(curve) !== '[0,0,0,1,1,1,1,0]') {\n      console.warn('Curves of LookAtDegreeMap defined in VRM 0.0 are not supported');\n    }\n\n    return new VRMLookAtRangeMap(schemaDegreeMap?.xRange ?? 90.0, schemaDegreeMap?.yRange ?? defaultOutputScale);\n  }\n\n  private _importLookAt(humanoid: VRMHumanoid, applier: VRMLookAtApplier): VRMLookAt {\n    const lookAt = new VRMLookAt(humanoid, applier);\n\n    if (this.helperRoot) {\n      const helper = new VRMLookAtHelper(lookAt);\n      this.helperRoot.add(helper);\n      helper.renderOrder = this.helperRoot.renderOrder;\n    }\n\n    return lookAt;\n  }\n}\n","/* eslint-disable @typescript-eslint/naming-convention */\n\n/**\n * Represents a type of applier.\n */\nexport const VRMLookAtTypeName = {\n  Bone: 'bone',\n  Expression: 'expression',\n};\n\nexport type VRMLookAtTypeName = typeof VRMLookAtTypeName[keyof typeof VRMLookAtTypeName];\n","/**\n * Yoinked from https://github.com/mrdoob/three.js/blob/master/examples/jsm/loaders/GLTFLoader.js\n */\nexport function resolveURL(url: string, path: string): string {\n  // Invalid URL\n  if (typeof url !== 'string' || url === '') return '';\n\n  // Host Relative URL\n  if (/^https?:\\/\\//i.test(path) && /^\\//.test(url)) {\n    path = path.replace(/(^https?:\\/\\/[^/]+).*/i, '$1');\n  }\n\n  // Absolute URL http://,https://,//\n  if (/^(https?:)?\\/\\//i.test(url)) return url;\n\n  // Data URI\n  if (/^data:.*,.*$/i.test(url)) return url;\n\n  // Blob URL\n  if (/^blob:.*$/i.test(url)) return url;\n\n  // Relative URL\n  return path + url;\n}\n","import type { GLTF, GLTFLoaderPlugin, GLTFParser } from 'three/examples/jsm/loaders/GLTFLoader.js';\nimport type { VRM0Meta } from './VRM0Meta';\nimport type { VRM1Meta } from './VRM1Meta';\nimport type { VRMMeta } from './VRMMeta';\nimport type { VRMMetaLoaderPluginOptions } from './VRMMetaLoaderPluginOptions';\nimport type * as V0VRM from '@pixiv/types-vrm-0.0';\nimport type * as V1VRMSchema from '@pixiv/types-vrmc-vrm-1.0';\nimport * as THREE from 'three';\nimport { resolveURL } from '../utils/resolveURL';\nimport { GLTF as GLTFSchema } from '@gltf-transform/core';\n\n/**\n * Possible spec versions it recognizes.\n */\nconst POSSIBLE_SPEC_VERSIONS = new Set(['1.0', '1.0-beta']);\n\n/**\n * A plugin of GLTFLoader that imports a {@link VRM1Meta} from a VRM extension of a GLTF.\n */\nexport class VRMMetaLoaderPlugin implements GLTFLoaderPlugin {\n  public readonly parser: GLTFParser;\n\n  /**\n   * If `false`, it won't load its thumbnail image ({@link VRM1Meta.thumbnailImage}).\n   * `true` by default.\n   */\n  public needThumbnailImage: boolean;\n\n  /**\n   * A list of license urls.\n   * This meta loader will accept these `licenseUrl`s.\n   * Otherwise it won't be loaded.\n   */\n  public acceptLicenseUrls: string[];\n\n  /**\n   * Whether it should accept VRM0.0 meta or not.\n   * Note that it might load {@link VRM0Meta} instead of {@link VRM1Meta} when this is `true`.\n   * `true` by default.\n   */\n  public acceptV0Meta: boolean;\n\n  public get name(): string {\n    // We should use the extension name instead but we have multiple plugins for an extension...\n    return 'VRMMetaLoaderPlugin';\n  }\n\n  public constructor(parser: GLTFParser, options?: VRMMetaLoaderPluginOptions) {\n    this.parser = parser;\n\n    this.needThumbnailImage = options?.needThumbnailImage ?? true;\n    this.acceptLicenseUrls = options?.acceptLicenseUrls ?? ['https://vrm.dev/licenses/1.0/'];\n    this.acceptV0Meta = options?.acceptV0Meta ?? true;\n  }\n\n  public async afterRoot(gltf: GLTF): Promise<void> {\n    gltf.userData.vrmMeta = await this._import(gltf);\n  }\n\n  private async _import(gltf: GLTF): Promise<VRMMeta | null> {\n    const v1Result = await this._v1Import(gltf);\n    if (v1Result != null) {\n      return v1Result;\n    }\n\n    const v0Result = await this._v0Import(gltf);\n    if (v0Result != null) {\n      return v0Result;\n    }\n\n    return null;\n  }\n\n  private async _v1Import(gltf: GLTF): Promise<VRM1Meta | null> {\n    const json = this.parser.json as GLTFSchema.IGLTF;\n\n    // early abort if it doesn't use vrm\n    const isVRMUsed = json.extensionsUsed?.indexOf('VRMC_vrm') !== -1;\n    if (!isVRMUsed) {\n      return null;\n    }\n\n    const extension = json.extensions?.['VRMC_vrm'] as V1VRMSchema.VRMCVRM | undefined;\n    if (extension == null) {\n      return null;\n    }\n\n    const specVersion = extension.specVersion;\n    if (!POSSIBLE_SPEC_VERSIONS.has(specVersion)) {\n      console.warn(`VRMMetaLoaderPlugin: Unknown VRMC_vrm specVersion \"${specVersion}\"`);\n      return null;\n    }\n\n    const schemaMeta = extension.meta;\n    if (!schemaMeta) {\n      return null;\n    }\n\n    // throw an error if acceptV0Meta is false\n    const licenseUrl = schemaMeta.licenseUrl;\n    const acceptLicenseUrlsSet = new Set(this.acceptLicenseUrls);\n    if (!acceptLicenseUrlsSet.has(licenseUrl)) {\n      throw new Error(`VRMMetaLoaderPlugin: The license url \"${licenseUrl}\" is not accepted`);\n    }\n\n    let thumbnailImage: HTMLImageElement | undefined = undefined;\n    if (this.needThumbnailImage && schemaMeta.thumbnailImage != null) {\n      thumbnailImage = (await this._extractGLTFImage(schemaMeta.thumbnailImage)) ?? undefined;\n    }\n\n    return {\n      metaVersion: '1',\n      name: schemaMeta.name,\n      version: schemaMeta.version,\n      authors: schemaMeta.authors,\n      copyrightInformation: schemaMeta.copyrightInformation,\n      contactInformation: schemaMeta.contactInformation,\n      references: schemaMeta.references,\n      thirdPartyLicenses: schemaMeta.thirdPartyLicenses,\n      thumbnailImage,\n      licenseUrl: schemaMeta.licenseUrl,\n      avatarPermission: schemaMeta.avatarPermission,\n      allowExcessivelyViolentUsage: schemaMeta.allowExcessivelyViolentUsage,\n      allowExcessivelySexualUsage: schemaMeta.allowExcessivelySexualUsage,\n      commercialUsage: schemaMeta.commercialUsage,\n      allowPoliticalOrReligiousUsage: schemaMeta.allowPoliticalOrReligiousUsage,\n      allowAntisocialOrHateUsage: schemaMeta.allowAntisocialOrHateUsage,\n      creditNotation: schemaMeta.creditNotation,\n      allowRedistribution: schemaMeta.allowRedistribution,\n      modification: schemaMeta.modification,\n      otherLicenseUrl: schemaMeta.otherLicenseUrl,\n    };\n  }\n\n  private async _v0Import(gltf: GLTF): Promise<VRM0Meta | null> {\n    const json = this.parser.json as GLTFSchema.IGLTF;\n\n    // early abort if it doesn't use vrm\n    const vrmExt = json.extensions?.VRM as V0VRM.VRM | undefined;\n    if (!vrmExt) {\n      return null;\n    }\n\n    const schemaMeta = vrmExt.meta;\n    if (!schemaMeta) {\n      return null;\n    }\n\n    // throw an error if acceptV0Meta is false\n    if (!this.acceptV0Meta) {\n      throw new Error('VRMMetaLoaderPlugin: Attempted to load VRM0.0 meta but acceptV0Meta is false');\n    }\n\n    // load thumbnail texture\n    let texture: THREE.Texture | null | undefined;\n    if (this.needThumbnailImage && schemaMeta.texture != null && schemaMeta.texture !== -1) {\n      texture = await this.parser.getDependency('texture', schemaMeta.texture);\n    }\n\n    return {\n      metaVersion: '0',\n      allowedUserName: schemaMeta.allowedUserName,\n      author: schemaMeta.author,\n      commercialUssageName: schemaMeta.commercialUssageName,\n      contactInformation: schemaMeta.contactInformation,\n      licenseName: schemaMeta.licenseName,\n      otherLicenseUrl: schemaMeta.otherLicenseUrl,\n      otherPermissionUrl: schemaMeta.otherPermissionUrl,\n      reference: schemaMeta.reference,\n      sexualUssageName: schemaMeta.sexualUssageName,\n      texture: texture ?? undefined,\n      title: schemaMeta.title,\n      version: schemaMeta.version,\n      violentUssageName: schemaMeta.violentUssageName,\n    };\n  }\n\n  private async _extractGLTFImage(index: number): Promise<HTMLImageElement | null> {\n    const json = this.parser.json as GLTFSchema.IGLTF;\n\n    const source = json.images?.[index];\n\n    if (source == null) {\n      console.warn(\n        `VRMMetaLoaderPlugin: Attempt to use images[${index}] of glTF as a thumbnail but the image doesn't exist`,\n      );\n      return null;\n    }\n\n    // Ref: https://github.com/mrdoob/three.js/blob/r124/examples/jsm/loaders/GLTFLoader.js#L2467\n\n    // `source.uri` might be a reference to a file\n    let sourceURI: string | undefined = source.uri;\n\n    // Load the binary as a blob\n    if (source.bufferView != null) {\n      const bufferView = await this.parser.getDependency('bufferView', source.bufferView);\n      const blob = new Blob([bufferView], { type: source.mimeType });\n      sourceURI = URL.createObjectURL(blob);\n    }\n\n    if (sourceURI == null) {\n      console.warn(\n        `VRMMetaLoaderPlugin: Attempt to use images[${index}] of glTF as a thumbnail but the image couldn't load properly`,\n      );\n      return null;\n    }\n\n    const loader = new THREE.ImageLoader();\n    return await loader.loadAsync(resolveURL(sourceURI, (this.parser as any).options.path)).catch((error) => {\n      console.error(error);\n      console.warn('VRMMetaLoaderPlugin: Failed to load a thumbnail image');\n      return null;\n    });\n  }\n}\n","import * as THREE from 'three';\nimport { VRMExpressionManager } from './expressions/VRMExpressionManager';\nimport { VRMFirstPerson } from './firstPerson/VRMFirstPerson';\nimport { VRMHumanoid } from './humanoid/VRMHumanoid';\nimport { VRMLookAt } from './lookAt/VRMLookAt';\nimport { VRMMeta } from './meta/VRMMeta';\nimport { VRMCoreParameters } from './VRMCoreParameters';\n\n/**\n * A class that represents a single VRM model.\n * This class only includes core spec of the VRM (`VRMC_vrm`).\n */\nexport class VRMCore {\n  /**\n   * `THREE.Group` that contains the entire VRM.\n   */\n  public readonly scene: THREE.Group;\n\n  /**\n   * Contains meta fields of the VRM.\n   * You might want to refer these license fields before use your VRMs.\n   */\n  public readonly meta: VRMMeta;\n\n  /**\n   * Contains {@link VRMHumanoid} of the VRM.\n   * You can control each bones using {@link VRMHumanoid.getNormalizedBoneNode} or {@link VRMHumanoid.getRawBoneNode}.\n   *\n   * @TODO Add a link to VRM spec\n   */\n  public readonly humanoid: VRMHumanoid;\n\n  /**\n   * Contains {@link VRMExpressionManager} of the VRM.\n   * You might want to control these facial expressions via {@link VRMExpressionManager.setValue}.\n   */\n  public readonly expressionManager?: VRMExpressionManager;\n\n  /**\n   * Contains {@link VRMFirstPerson} of the VRM.\n   * VRMFirstPerson is mostly used for mesh culling for first person view.\n   */\n  public readonly firstPerson?: VRMFirstPerson;\n\n  /**\n   * Contains {@link VRMLookAt} of the VRM.\n   * You might want to use {@link VRMLookAt.target} to control the eye direction of your VRMs.\n   */\n  public readonly lookAt?: VRMLookAt;\n\n  /**\n   * Create a new VRM instance.\n   *\n   * @param params [[VRMParameters]] that represents components of the VRM\n   */\n  public constructor(params: VRMCoreParameters) {\n    this.scene = params.scene;\n    this.meta = params.meta;\n    this.humanoid = params.humanoid;\n    this.expressionManager = params.expressionManager;\n    this.firstPerson = params.firstPerson;\n    this.lookAt = params.lookAt;\n  }\n\n  /**\n   * **You need to call this on your update loop.**\n   *\n   * This function updates every VRM components.\n   *\n   * @param delta deltaTime\n   */\n  public update(delta: number): void {\n    this.humanoid.update();\n\n    if (this.lookAt) {\n      this.lookAt.update(delta);\n    }\n\n    if (this.expressionManager) {\n      this.expressionManager.update();\n    }\n  }\n}\n","import { GLTF, GLTFLoaderPlugin, GLTFParser } from 'three/examples/jsm/loaders/GLTFLoader.js';\nimport { VRMCoreLoaderPluginOptions } from './VRMCoreLoaderPluginOptions';\nimport { VRMCore } from './VRMCore';\nimport { VRMExpressionLoaderPlugin } from './expressions/VRMExpressionLoaderPlugin';\nimport { VRMFirstPersonLoaderPlugin } from './firstPerson/VRMFirstPersonLoaderPlugin';\nimport { VRMHumanoidLoaderPlugin } from './humanoid/VRMHumanoidLoaderPlugin';\nimport { VRMMetaLoaderPlugin } from './meta/VRMMetaLoaderPlugin';\nimport { VRMLookAtLoaderPlugin } from './lookAt/VRMLookAtLoaderPlugin';\nimport type { VRMHumanoid } from './humanoid';\nimport type { VRMMeta } from './meta';\n\nexport class VRMCoreLoaderPlugin implements GLTFLoaderPlugin {\n  public get name(): string {\n    // We should use the extension name instead but we have multiple plugins for an extension...\n    return 'VRMC_vrm';\n  }\n\n  public readonly parser: GLTFParser;\n\n  public readonly expressionPlugin: VRMExpressionLoaderPlugin;\n  public readonly firstPersonPlugin: VRMFirstPersonLoaderPlugin;\n  public readonly humanoidPlugin: VRMHumanoidLoaderPlugin;\n  public readonly lookAtPlugin: VRMLookAtLoaderPlugin;\n  public readonly metaPlugin: VRMMetaLoaderPlugin;\n\n  public constructor(parser: GLTFParser, options?: VRMCoreLoaderPluginOptions) {\n    this.parser = parser;\n\n    const helperRoot = options?.helperRoot;\n    const autoUpdateHumanBones = options?.autoUpdateHumanBones;\n\n    this.expressionPlugin = options?.expressionPlugin ?? new VRMExpressionLoaderPlugin(parser);\n    this.firstPersonPlugin = options?.firstPersonPlugin ?? new VRMFirstPersonLoaderPlugin(parser);\n    this.humanoidPlugin =\n      options?.humanoidPlugin ?? new VRMHumanoidLoaderPlugin(parser, { helperRoot, autoUpdateHumanBones });\n    this.lookAtPlugin = options?.lookAtPlugin ?? new VRMLookAtLoaderPlugin(parser, { helperRoot });\n    this.metaPlugin = options?.metaPlugin ?? new VRMMetaLoaderPlugin(parser);\n  }\n\n  public async afterRoot(gltf: GLTF): Promise<void> {\n    await this.metaPlugin.afterRoot(gltf);\n    await this.humanoidPlugin.afterRoot(gltf);\n    await this.expressionPlugin.afterRoot(gltf);\n    await this.lookAtPlugin.afterRoot(gltf);\n    await this.firstPersonPlugin.afterRoot(gltf);\n\n    const meta = gltf.userData.vrmMeta as VRMMeta | null;\n    const humanoid = gltf.userData.vrmHumanoid as VRMHumanoid | null;\n\n    // meta and humanoid are required to be a VRM.\n    // Don't create VRM if they are null\n    if (meta && humanoid) {\n      const vrmCore = new VRMCore({\n        scene: gltf.scene,\n        expressionManager: gltf.userData.vrmExpressionManager,\n        firstPerson: gltf.userData.vrmFirstPerson,\n        humanoid,\n        lookAt: gltf.userData.vrmLookAt,\n        meta,\n      });\n\n      gltf.userData.vrmCore = vrmCore;\n    }\n  }\n}\n"],"names":["POSSIBLE_SPEC_VERSIONS","_v3A","_v3B","_quatA","_quatB","VEC3_POSITIVE_Z","_eulerA"],"mappings":"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"}