@pixiv/three-vrm-core 1.0.0-beta.10 → 1.0.0-beta.11

package/lib/three-vrm-core.js

@@ -1,5 +1,5 @@
 /*!
- * @pixiv/three-vrm-core v1.0.0-beta.10
+ * @pixiv/three-vrm-core v1.0.0-beta.11
  * The implementation of core features of VRM, for @pixiv/three-vrm
  *
  * Copyright (c) 2020-2021 pixiv Inc.
@@ -34,104 +34,104 @@
 
     var THREE__namespace = /*#__PURE__*/_interopNamespace(THREE);
 
-    // animationMixer の監視対象は、Scene の中に入っている必要がある。
-    // そのため、表示オブジェクトではないけれど、Object3D を継承して Scene に投入できるようにする。
-    class VRMExpression extends THREE__namespace.Object3D {
-        constructor(expressionName) {
-            super();
-            /**
-             * The current weight of the expression.
-             */
-            this.weight = 0.0;
-            /**
-             * Interpret non-zero values as 1.
-             */
-            this.isBinary = false;
-            /**
-             * Specify how the expression overrides blink expressions.
-             */
-            this.overrideBlink = 'none';
-            /**
-             * Specify how the expression overrides lookAt expressions.
-             */
-            this.overrideLookAt = 'none';
-            /**
-             * Specify how the expression overrides mouth expressions.
-             */
-            this.overrideMouth = 'none';
-            this._binds = [];
-            this.name = `VRMExpression_${expressionName}`;
-            this.expressionName = expressionName;
-            // traverse 時の救済手段として Object3D ではないことを明示しておく
-            this.type = 'VRMExpression';
-            // 表示目的のオブジェクトではないので、負荷軽減のために visible を false にしておく。
-            // これにより、このインスタンスに対する毎フレームの matrix 自動計算を省略できる。
-            this.visible = false;
-        }
-        /**
-         * A value represents how much it should override blink expressions.
-         * `0.0` == no override at all, `1.0` == completely block the expressions.
-         */
-        get overrideBlinkAmount() {
-            if (this.overrideBlink === 'block') {
-                return 0.0 < this.weight ? 1.0 : 0.0;
-            }
-            else if (this.overrideBlink === 'blend') {
-                return this.weight;
-            }
-            else {
-                return 0.0;
-            }
-        }
-        /**
-         * A value represents how much it should override lookAt expressions.
-         * `0.0` == no override at all, `1.0` == completely block the expressions.
-         */
-        get overrideLookAtAmount() {
-            if (this.overrideLookAt === 'block') {
-                return 0.0 < this.weight ? 1.0 : 0.0;
-            }
-            else if (this.overrideLookAt === 'blend') {
-                return this.weight;
-            }
-            else {
-                return 0.0;
-            }
-        }
-        /**
-         * A value represents how much it should override mouth expressions.
-         * `0.0` == no override at all, `1.0` == completely block the expressions.
-         */
-        get overrideMouthAmount() {
-            if (this.overrideMouth === 'block') {
-                return 0.0 < this.weight ? 1.0 : 0.0;
-            }
-            else if (this.overrideMouth === 'blend') {
-                return this.weight;
-            }
-            else {
-                return 0.0;
-            }
-        }
-        addBind(bind) {
-            this._binds.push(bind);
-        }
-        /**
-         * Apply weight to every assigned blend shapes.
-         * Should be called every frame.
-         */
-        applyWeight(options) {
-            var _a;
-            let actualWeight = this.isBinary ? (this.weight === 0.0 ? 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));
-        }
-        /**
-         * Clear previously assigned blend shapes.
-         */
-        clearAppliedWeight() {
-            this._binds.forEach((bind) => bind.clearAppliedWeight());
-        }
+    // animationMixer の監視対象は、Scene の中に入っている必要がある。
+    // そのため、表示オブジェクトではないけれど、Object3D を継承して Scene に投入できるようにする。
+    class VRMExpression extends THREE__namespace.Object3D {
+        constructor(expressionName) {
+            super();
+            /**
+             * The current weight of the expression.
+             */
+            this.weight = 0.0;
+            /**
+             * Interpret non-zero values as 1.
+             */
+            this.isBinary = false;
+            /**
+             * Specify how the expression overrides blink expressions.
+             */
+            this.overrideBlink = 'none';
+            /**
+             * Specify how the expression overrides lookAt expressions.
+             */
+            this.overrideLookAt = 'none';
+            /**
+             * Specify how the expression overrides mouth expressions.
+             */
+            this.overrideMouth = 'none';
+            this._binds = [];
+            this.name = `VRMExpression_${expressionName}`;
+            this.expressionName = expressionName;
+            // traverse 時の救済手段として Object3D ではないことを明示しておく
+            this.type = 'VRMExpression';
+            // 表示目的のオブジェクトではないので、負荷軽減のために visible を false にしておく。
+            // これにより、このインスタンスに対する毎フレームの matrix 自動計算を省略できる。
+            this.visible = false;
+        }
+        /**
+         * A value represents how much it should override blink expressions.
+         * `0.0` == no override at all, `1.0` == completely block the expressions.
+         */
+        get overrideBlinkAmount() {
+            if (this.overrideBlink === 'block') {
+                return 0.0 < this.weight ? 1.0 : 0.0;
+            }
+            else if (this.overrideBlink === 'blend') {
+                return this.weight;
+            }
+            else {
+                return 0.0;
+            }
+        }
+        /**
+         * A value represents how much it should override lookAt expressions.
+         * `0.0` == no override at all, `1.0` == completely block the expressions.
+         */
+        get overrideLookAtAmount() {
+            if (this.overrideLookAt === 'block') {
+                return 0.0 < this.weight ? 1.0 : 0.0;
+            }
+            else if (this.overrideLookAt === 'blend') {
+                return this.weight;
+            }
+            else {
+                return 0.0;
+            }
+        }
+        /**
+         * A value represents how much it should override mouth expressions.
+         * `0.0` == no override at all, `1.0` == completely block the expressions.
+         */
+        get overrideMouthAmount() {
+            if (this.overrideMouth === 'block') {
+                return 0.0 < this.weight ? 1.0 : 0.0;
+            }
+            else if (this.overrideMouth === 'blend') {
+                return this.weight;
+            }
+            else {
+                return 0.0;
+            }
+        }
+        addBind(bind) {
+            this._binds.push(bind);
+        }
+        /**
+         * Apply weight to every assigned blend shapes.
+         * Should be called every frame.
+         */
+        applyWeight(options) {
+            var _a;
+            let actualWeight = this.isBinary ? (this.weight === 0.0 ? 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));
+        }
+        /**
+         * Clear previously assigned blend shapes.
+         */
+        clearAppliedWeight() {
+            this._binds.forEach((bind) => bind.clearAppliedWeight());
+        }
     }
 
     /*! *****************************************************************************
@@ -159,2520 +159,2520 @@
         });
     }
 
-    function extractPrimitivesInternal(gltf, nodeIndex, node) {
-        var _a, _b;
-        const json = gltf.parser.json;
-        /**
-         * Let's list up every possible patterns that parsed gltf nodes with a mesh can have,,,
-         *
-         * "*" indicates that those meshes should be listed up using this function
-         *
-         * ### A node with a (mesh, a signle primitive)
-         *
-         * - `THREE.Mesh`: The only primitive of the mesh *
-         *
-         * ### A node with a (mesh, multiple primitives)
-         *
-         * - `THREE.Group`: The root of the mesh
-         *   - `THREE.Mesh`: A primitive of the mesh *
-         *   - `THREE.Mesh`: A primitive of the mesh (2) *
-         *
-         * ### A node with a (mesh, multiple primitives) AND (a child with a mesh, a single primitive)
-         *
-         * - `THREE.Group`: The root of the mesh
-         *   - `THREE.Mesh`: A primitive of the mesh *
-         *   - `THREE.Mesh`: A primitive of the mesh (2) *
-         *   - `THREE.Mesh`: A primitive of a MESH OF THE CHILD
-         *
-         * ### A node with a (mesh, multiple primitives) AND (a child with a mesh, multiple primitives)
-         *
-         * - `THREE.Group`: The root of the mesh
-         *   - `THREE.Mesh`: A primitive of the mesh *
-         *   - `THREE.Mesh`: A primitive of the mesh (2) *
-         *   - `THREE.Group`: The root of a MESH OF THE CHILD
-         *     - `THREE.Mesh`: A primitive of the mesh of the child
-         *     - `THREE.Mesh`: A primitive of the mesh of the child (2)
-         *
-         * ### A node with a (mesh, multiple primitives) BUT the node is a bone
-         *
-         * - `THREE.Bone`: The root of the node, as a bone
-         *   - `THREE.Group`: The root of the mesh
-         *     - `THREE.Mesh`: A primitive of the mesh *
-         *     - `THREE.Mesh`: A primitive of the mesh (2) *
-         *
-         * ### A node with a (mesh, multiple primitives) AND (a child with a mesh, multiple primitives) BUT the node is a bone
-         *
-         * - `THREE.Bone`: The root of the node, as a bone
-         *   - `THREE.Group`: The root of the mesh
-         *     - `THREE.Mesh`: A primitive of the mesh *
-         *     - `THREE.Mesh`: A primitive of the mesh (2) *
-         *   - `THREE.Group`: The root of a MESH OF THE CHILD
-         *     - `THREE.Mesh`: A primitive of the mesh of the child
-         *     - `THREE.Mesh`: A primitive of the mesh of the child (2)
-         *
-         * ...I will take a strategy that traverses the root of the node and take first (primitiveCount) meshes.
-         */
-        // Make sure that the node has a mesh
-        const schemaNode = (_a = json.nodes) === null || _a === void 0 ? void 0 : _a[nodeIndex];
-        if (schemaNode == null) {
-            console.warn(`extractPrimitivesInternal: Attempt to use nodes[${nodeIndex}] of glTF but the node doesn't exist`);
-            return null;
-        }
-        const meshIndex = schemaNode.mesh;
-        if (meshIndex == null) {
-            return null;
-        }
-        // How many primitives the mesh has?
-        const schemaMesh = (_b = json.meshes) === null || _b === void 0 ? void 0 : _b[meshIndex];
-        if (schemaMesh == null) {
-            console.warn(`extractPrimitivesInternal: Attempt to use meshes[${meshIndex}] of glTF but the mesh doesn't exist`);
-            return null;
-        }
-        const primitiveCount = schemaMesh.primitives.length;
-        // Traverse the node and take first (primitiveCount) meshes
-        const primitives = [];
-        node.traverse((object) => {
-            if (primitives.length < primitiveCount) {
-                if (object.isMesh) {
-                    primitives.push(object);
-                }
-            }
-        });
-        return primitives;
-    }
-    /**
-     * Extract primitives ( `THREE.Mesh[]` ) of a node from a loaded GLTF.
-     * The main purpose of this function is to distinguish primitives and children from a node that has both meshes and children.
-     *
-     * It utilizes the behavior that GLTFLoader adds mesh primitives to the node object ( `THREE.Group` ) first then adds its children.
-     *
-     * @param gltf A GLTF object taken from GLTFLoader
-     * @param nodeIndex The index of the node
-     */
-    function gltfExtractPrimitivesFromNode(gltf, nodeIndex) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const node = yield gltf.parser.getDependency('node', nodeIndex);
-            return extractPrimitivesInternal(gltf, nodeIndex, node);
-        });
-    }
-    /**
-     * Extract primitives ( `THREE.Mesh[]` ) of nodes from a loaded GLTF.
-     * See {@link gltfExtractPrimitivesFromNode} for more details.
-     *
-     * It returns a map from node index to extraction result.
-     * If a node does not have a mesh, the entry for the node will not be put in the returning map.
-     *
-     * @param gltf A GLTF object taken from GLTFLoader
-     */
-    function gltfExtractPrimitivesFromNodes(gltf) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const nodes = yield gltf.parser.getDependencies('node');
-            const map = new Map();
-            nodes.forEach((node, index) => {
-                const result = extractPrimitivesInternal(gltf, index, node);
-                if (result != null) {
-                    map.set(index, result);
-                }
-            });
-            return map;
-        });
+    function extractPrimitivesInternal(gltf, nodeIndex, node) {
+        var _a, _b;
+        const json = gltf.parser.json;
+        /**
+         * Let's list up every possible patterns that parsed gltf nodes with a mesh can have,,,
+         *
+         * "*" indicates that those meshes should be listed up using this function
+         *
+         * ### A node with a (mesh, a signle primitive)
+         *
+         * - `THREE.Mesh`: The only primitive of the mesh *
+         *
+         * ### A node with a (mesh, multiple primitives)
+         *
+         * - `THREE.Group`: The root of the mesh
+         *   - `THREE.Mesh`: A primitive of the mesh *
+         *   - `THREE.Mesh`: A primitive of the mesh (2) *
+         *
+         * ### A node with a (mesh, multiple primitives) AND (a child with a mesh, a single primitive)
+         *
+         * - `THREE.Group`: The root of the mesh
+         *   - `THREE.Mesh`: A primitive of the mesh *
+         *   - `THREE.Mesh`: A primitive of the mesh (2) *
+         *   - `THREE.Mesh`: A primitive of a MESH OF THE CHILD
+         *
+         * ### A node with a (mesh, multiple primitives) AND (a child with a mesh, multiple primitives)
+         *
+         * - `THREE.Group`: The root of the mesh
+         *   - `THREE.Mesh`: A primitive of the mesh *
+         *   - `THREE.Mesh`: A primitive of the mesh (2) *
+         *   - `THREE.Group`: The root of a MESH OF THE CHILD
+         *     - `THREE.Mesh`: A primitive of the mesh of the child
+         *     - `THREE.Mesh`: A primitive of the mesh of the child (2)
+         *
+         * ### A node with a (mesh, multiple primitives) BUT the node is a bone
+         *
+         * - `THREE.Bone`: The root of the node, as a bone
+         *   - `THREE.Group`: The root of the mesh
+         *     - `THREE.Mesh`: A primitive of the mesh *
+         *     - `THREE.Mesh`: A primitive of the mesh (2) *
+         *
+         * ### A node with a (mesh, multiple primitives) AND (a child with a mesh, multiple primitives) BUT the node is a bone
+         *
+         * - `THREE.Bone`: The root of the node, as a bone
+         *   - `THREE.Group`: The root of the mesh
+         *     - `THREE.Mesh`: A primitive of the mesh *
+         *     - `THREE.Mesh`: A primitive of the mesh (2) *
+         *   - `THREE.Group`: The root of a MESH OF THE CHILD
+         *     - `THREE.Mesh`: A primitive of the mesh of the child
+         *     - `THREE.Mesh`: A primitive of the mesh of the child (2)
+         *
+         * ...I will take a strategy that traverses the root of the node and take first (primitiveCount) meshes.
+         */
+        // Make sure that the node has a mesh
+        const schemaNode = (_a = json.nodes) === null || _a === void 0 ? void 0 : _a[nodeIndex];
+        if (schemaNode == null) {
+            console.warn(`extractPrimitivesInternal: Attempt to use nodes[${nodeIndex}] of glTF but the node doesn't exist`);
+            return null;
+        }
+        const meshIndex = schemaNode.mesh;
+        if (meshIndex == null) {
+            return null;
+        }
+        // How many primitives the mesh has?
+        const schemaMesh = (_b = json.meshes) === null || _b === void 0 ? void 0 : _b[meshIndex];
+        if (schemaMesh == null) {
+            console.warn(`extractPrimitivesInternal: Attempt to use meshes[${meshIndex}] of glTF but the mesh doesn't exist`);
+            return null;
+        }
+        const primitiveCount = schemaMesh.primitives.length;
+        // Traverse the node and take first (primitiveCount) meshes
+        const primitives = [];
+        node.traverse((object) => {
+            if (primitives.length < primitiveCount) {
+                if (object.isMesh) {
+                    primitives.push(object);
+                }
+            }
+        });
+        return primitives;
+    }
+    /**
+     * Extract primitives ( `THREE.Mesh[]` ) of a node from a loaded GLTF.
+     * The main purpose of this function is to distinguish primitives and children from a node that has both meshes and children.
+     *
+     * It utilizes the behavior that GLTFLoader adds mesh primitives to the node object ( `THREE.Group` ) first then adds its children.
+     *
+     * @param gltf A GLTF object taken from GLTFLoader
+     * @param nodeIndex The index of the node
+     */
+    function gltfExtractPrimitivesFromNode(gltf, nodeIndex) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const node = yield gltf.parser.getDependency('node', nodeIndex);
+            return extractPrimitivesInternal(gltf, nodeIndex, node);
+        });
+    }
+    /**
+     * Extract primitives ( `THREE.Mesh[]` ) of nodes from a loaded GLTF.
+     * See {@link gltfExtractPrimitivesFromNode} for more details.
+     *
+     * It returns a map from node index to extraction result.
+     * If a node does not have a mesh, the entry for the node will not be put in the returning map.
+     *
+     * @param gltf A GLTF object taken from GLTFLoader
+     */
+    function gltfExtractPrimitivesFromNodes(gltf) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const nodes = yield gltf.parser.getDependencies('node');
+            const map = new Map();
+            nodes.forEach((node, index) => {
+                const result = extractPrimitivesInternal(gltf, index, node);
+                if (result != null) {
+                    map.set(index, result);
+                }
+            });
+            return map;
+        });
     }
 
-    /**
-     * Get a material definition index of glTF from associated material.
-     * It's basically a comat code between Three.js r133 or above and previous versions.
-     * @param parser GLTFParser
-     * @param material A material of gltf
-     * @returns Material definition index of glTF
-     */
-    function gltfGetAssociatedMaterialIndex(parser, material) {
-        var _a, _b;
-        const threeRevision = parseInt(THREE__namespace.REVISION, 10);
-        let index = null;
-        if (threeRevision >= 133) {
-            index = (_b = (_a = parser.associations.get(material)) === null || _a === void 0 ? void 0 : _a.materials) !== null && _b !== void 0 ? _b : null;
-        }
-        else {
-            const associations = parser.associations;
-            const reference = associations.get(material);
-            if ((reference === null || reference === void 0 ? void 0 : reference.type) === 'materials') {
-                index = reference.index;
-            }
-        }
-        return index;
+    /**
+     * Get a material definition index of glTF from associated material.
+     * It's basically a comat code between Three.js r133 or above and previous versions.
+     * @param parser GLTFParser
+     * @param material A material of gltf
+     * @returns Material definition index of glTF
+     */
+    function gltfGetAssociatedMaterialIndex(parser, material) {
+        var _a, _b;
+        const threeRevision = parseInt(THREE__namespace.REVISION, 10);
+        let index = null;
+        if (threeRevision >= 133) {
+            index = (_b = (_a = parser.associations.get(material)) === null || _a === void 0 ? void 0 : _a.materials) !== null && _b !== void 0 ? _b : null;
+        }
+        else {
+            const associations = parser.associations;
+            const reference = associations.get(material);
+            if ((reference === null || reference === void 0 ? void 0 : reference.type) === 'materials') {
+                index = reference.index;
+            }
+        }
+        return index;
     }
 
-    /* eslint-disable @typescript-eslint/naming-convention */
-    const VRMExpressionPresetName = {
-        Aa: 'aa',
-        Ih: 'ih',
-        Ou: 'ou',
-        Ee: 'ee',
-        Oh: 'oh',
-        Blink: 'blink',
-        Happy: 'happy',
-        Angry: 'angry',
-        Sad: 'sad',
-        Relaxed: 'relaxed',
-        LookUp: 'lookUp',
-        Surprised: 'surprised',
-        LookDown: 'lookDown',
-        LookLeft: 'lookLeft',
-        LookRight: 'lookRight',
-        BlinkLeft: 'blinkLeft',
-        BlinkRight: 'blinkRight',
-        Neutral: 'neutral',
+    /* eslint-disable @typescript-eslint/naming-convention */
+    const VRMExpressionPresetName = {
+        Aa: 'aa',
+        Ih: 'ih',
+        Ou: 'ou',
+        Ee: 'ee',
+        Oh: 'oh',
+        Blink: 'blink',
+        Happy: 'happy',
+        Angry: 'angry',
+        Sad: 'sad',
+        Relaxed: 'relaxed',
+        LookUp: 'lookUp',
+        Surprised: 'surprised',
+        LookDown: 'lookDown',
+        LookLeft: 'lookLeft',
+        LookRight: 'lookRight',
+        BlinkLeft: 'blinkLeft',
+        BlinkRight: 'blinkRight',
+        Neutral: 'neutral',
     };
 
-    /**
-     * Clamp the input value within [0.0 - 1.0].
-     *
-     * @param value The input value
-     */
-    function saturate(value) {
-        return Math.max(Math.min(value, 1.0), 0.0);
+    /**
+     * Clamp the input value within [0.0 - 1.0].
+     *
+     * @param value The input value
+     */
+    function saturate(value) {
+        return Math.max(Math.min(value, 1.0), 0.0);
     }
 
-    class VRMExpressionManager {
-        /**
-         * Create a new {@link VRMExpressionManager}.
-         */
-        constructor() {
-            /**
-             * A set of name or preset name of expressions that will be overridden by {@link VRMExpression.overrideBlink}.
-             */
-            this.blinkExpressionNames = ['blink', 'blinkLeft', 'blinkRight'];
-            /**
-             * A set of name or preset name of expressions that will be overridden by {@link VRMExpression.overrideLookAt}.
-             */
-            this.lookAtExpressionNames = ['lookLeft', 'lookRight', 'lookUp', 'lookDown'];
-            /**
-             * A set of name or preset name of expressions that will be overridden by {@link VRMExpression.overrideMouth}.
-             */
-            this.mouthExpressionNames = ['aa', 'ee', 'ih', 'oh', 'ou'];
-            /**
-             * A set of {@link VRMExpression}.
-             * When you want to register expressions, use {@link registerExpression}
-             */
-            this._expressions = [];
-            /**
-             * A map from name to expression.
-             */
-            this._expressionMap = {};
-            // do nothing
-        }
-        get expressions() {
-            return this._expressions.concat();
-        }
-        get expressionMap() {
-            return Object.assign({}, this._expressionMap);
-        }
-        /**
-         * A map from name to expression, but excluding custom expressions.
-         */
-        get presetExpressionMap() {
-            const result = {};
-            const presetNameSet = new Set(Object.values(VRMExpressionPresetName));
-            Object.entries(this._expressionMap).forEach(([name, expression]) => {
-                if (presetNameSet.has(name)) {
-                    result[name] = expression;
-                }
-            });
-            return result;
-        }
-        /**
-         * A map from name to expression, but excluding preset expressions.
-         */
-        get customExpressionMap() {
-            const result = {};
-            const presetNameSet = new Set(Object.values(VRMExpressionPresetName));
-            Object.entries(this._expressionMap).forEach(([name, expression]) => {
-                if (!presetNameSet.has(name)) {
-                    result[name] = expression;
-                }
-            });
-            return result;
-        }
-        /**
-         * Copy the given {@link VRMExpressionManager} into this one.
-         * @param source The {@link VRMExpressionManager} you want to copy
-         * @returns this
-         */
-        copy(source) {
-            // first unregister all the expression it has
-            const expressions = this._expressions.concat();
-            expressions.forEach((expression) => {
-                this.unregisterExpression(expression);
-            });
-            // then register all the expression of the source
-            source._expressions.forEach((expression) => {
-                this.registerExpression(expression);
-            });
-            // copy remaining members
-            this.blinkExpressionNames = source.blinkExpressionNames.concat();
-            this.lookAtExpressionNames = source.lookAtExpressionNames.concat();
-            this.mouthExpressionNames = source.mouthExpressionNames.concat();
-            return this;
-        }
-        /**
-         * Returns a clone of this {@link VRMExpressionManager}.
-         * @returns Copied {@link VRMExpressionManager}
-         */
-        clone() {
-            return new VRMExpressionManager().copy(this);
-        }
-        /**
-         * Return a registered expression.
-         * If it cannot find an expression, it will return `null` instead.
-         *
-         * @param name Name or preset name of the expression
-         */
-        getExpression(name) {
-            var _a;
-            return (_a = this._expressionMap[name]) !== null && _a !== void 0 ? _a : null;
-        }
-        /**
-         * Register an expression.
-         *
-         * @param expression {@link VRMExpression} that describes the expression
-         */
-        registerExpression(expression) {
-            this._expressions.push(expression);
-            this._expressionMap[expression.expressionName] = expression;
-        }
-        /**
-         * Unregister an expression.
-         *
-         * @param expression The expression you want to unregister
-         */
-        unregisterExpression(expression) {
-            const index = this._expressions.indexOf(expression);
-            if (index === -1) {
-                console.warn('VRMExpressionManager: The specified expressions is not registered');
-            }
-            this._expressions.splice(index, 1);
-            delete this._expressionMap[expression.expressionName];
-        }
-        /**
-         * Get the current weight of the specified expression.
-         * If it doesn't have an expression of given name, it will return `null` instead.
-         *
-         * @param name Name of the expression
-         */
-        getValue(name) {
-            var _a;
-            const expression = this.getExpression(name);
-            return (_a = expression === null || expression === void 0 ? void 0 : expression.weight) !== null && _a !== void 0 ? _a : null;
-        }
-        /**
-         * Set a weight to the specified expression.
-         *
-         * @param name Name of the expression
-         * @param weight Weight
-         */
-        setValue(name, weight) {
-            const expression = this.getExpression(name);
-            if (expression) {
-                expression.weight = saturate(weight);
-            }
-        }
-        /**
-         * Get a track name of specified expression.
-         * This track name is needed to manipulate its expression via keyframe animations.
-         *
-         * @example Manipulate an expression using keyframe animation
-         * ```js
-         * const trackName = vrm.expressionManager.getExpressionTrackName( 'blink' );
-         * const track = new THREE.NumberKeyframeTrack(
-         *   name,
-         *   [ 0.0, 0.5, 1.0 ], // times
-         *   [ 0.0, 1.0, 0.0 ] // values
-         * );
-         *
-         * const clip = new THREE.AnimationClip(
-         *   'blink', // name
-         *   1.0, // duration
-         *   [ track ] // tracks
-         * );
-         *
-         * const mixer = new THREE.AnimationMixer( vrm.scene );
-         * const action = mixer.clipAction( clip );
-         * action.play();
-         * ```
-         *
-         * @param name Name of the expression
-         */
-        getExpressionTrackName(name) {
-            const expression = this.getExpression(name);
-            return expression ? `${expression.name}.weight` : null;
-        }
-        /**
-         * Update every expressions.
-         */
-        update() {
-            // see how much we should override certain expressions
-            const weightMultipliers = this._calculateWeightMultipliers();
-            // reset expression binds first
-            this._expressions.forEach((expression) => {
-                expression.clearAppliedWeight();
-            });
-            // then apply binds
-            this._expressions.forEach((expression) => {
-                let multiplier = 1.0;
-                const name = expression.expressionName;
-                if (this.blinkExpressionNames.indexOf(name) !== -1) {
-                    multiplier *= weightMultipliers.blink;
-                }
-                if (this.lookAtExpressionNames.indexOf(name) !== -1) {
-                    multiplier *= weightMultipliers.lookAt;
-                }
-                if (this.mouthExpressionNames.indexOf(name) !== -1) {
-                    multiplier *= weightMultipliers.mouth;
-                }
-                expression.applyWeight({ multiplier });
-            });
-        }
-        /**
-         * Calculate sum of override amounts to see how much we should multiply weights of certain expressions.
-         */
-        _calculateWeightMultipliers() {
-            let blink = 1.0;
-            let lookAt = 1.0;
-            let mouth = 1.0;
-            this._expressions.forEach((expression) => {
-                blink -= expression.overrideBlinkAmount;
-                lookAt -= expression.overrideLookAtAmount;
-                mouth -= expression.overrideMouthAmount;
-            });
-            blink = Math.max(0.0, blink);
-            lookAt = Math.max(0.0, lookAt);
-            mouth = Math.max(0.0, mouth);
-            return { blink, lookAt, mouth };
-        }
+    class VRMExpressionManager {
+        /**
+         * Create a new {@link VRMExpressionManager}.
+         */
+        constructor() {
+            /**
+             * A set of name or preset name of expressions that will be overridden by {@link VRMExpression.overrideBlink}.
+             */
+            this.blinkExpressionNames = ['blink', 'blinkLeft', 'blinkRight'];
+            /**
+             * A set of name or preset name of expressions that will be overridden by {@link VRMExpression.overrideLookAt}.
+             */
+            this.lookAtExpressionNames = ['lookLeft', 'lookRight', 'lookUp', 'lookDown'];
+            /**
+             * A set of name or preset name of expressions that will be overridden by {@link VRMExpression.overrideMouth}.
+             */
+            this.mouthExpressionNames = ['aa', 'ee', 'ih', 'oh', 'ou'];
+            /**
+             * A set of {@link VRMExpression}.
+             * When you want to register expressions, use {@link registerExpression}
+             */
+            this._expressions = [];
+            /**
+             * A map from name to expression.
+             */
+            this._expressionMap = {};
+            // do nothing
+        }
+        get expressions() {
+            return this._expressions.concat();
+        }
+        get expressionMap() {
+            return Object.assign({}, this._expressionMap);
+        }
+        /**
+         * A map from name to expression, but excluding custom expressions.
+         */
+        get presetExpressionMap() {
+            const result = {};
+            const presetNameSet = new Set(Object.values(VRMExpressionPresetName));
+            Object.entries(this._expressionMap).forEach(([name, expression]) => {
+                if (presetNameSet.has(name)) {
+                    result[name] = expression;
+                }
+            });
+            return result;
+        }
+        /**
+         * A map from name to expression, but excluding preset expressions.
+         */
+        get customExpressionMap() {
+            const result = {};
+            const presetNameSet = new Set(Object.values(VRMExpressionPresetName));
+            Object.entries(this._expressionMap).forEach(([name, expression]) => {
+                if (!presetNameSet.has(name)) {
+                    result[name] = expression;
+                }
+            });
+            return result;
+        }
+        /**
+         * Copy the given {@link VRMExpressionManager} into this one.
+         * @param source The {@link VRMExpressionManager} you want to copy
+         * @returns this
+         */
+        copy(source) {
+            // first unregister all the expression it has
+            const expressions = this._expressions.concat();
+            expressions.forEach((expression) => {
+                this.unregisterExpression(expression);
+            });
+            // then register all the expression of the source
+            source._expressions.forEach((expression) => {
+                this.registerExpression(expression);
+            });
+            // copy remaining members
+            this.blinkExpressionNames = source.blinkExpressionNames.concat();
+            this.lookAtExpressionNames = source.lookAtExpressionNames.concat();
+            this.mouthExpressionNames = source.mouthExpressionNames.concat();
+            return this;
+        }
+        /**
+         * Returns a clone of this {@link VRMExpressionManager}.
+         * @returns Copied {@link VRMExpressionManager}
+         */
+        clone() {
+            return new VRMExpressionManager().copy(this);
+        }
+        /**
+         * Return a registered expression.
+         * If it cannot find an expression, it will return `null` instead.
+         *
+         * @param name Name or preset name of the expression
+         */
+        getExpression(name) {
+            var _a;
+            return (_a = this._expressionMap[name]) !== null && _a !== void 0 ? _a : null;
+        }
+        /**
+         * Register an expression.
+         *
+         * @param expression {@link VRMExpression} that describes the expression
+         */
+        registerExpression(expression) {
+            this._expressions.push(expression);
+            this._expressionMap[expression.expressionName] = expression;
+        }
+        /**
+         * Unregister an expression.
+         *
+         * @param expression The expression you want to unregister
+         */
+        unregisterExpression(expression) {
+            const index = this._expressions.indexOf(expression);
+            if (index === -1) {
+                console.warn('VRMExpressionManager: The specified expressions is not registered');
+            }
+            this._expressions.splice(index, 1);
+            delete this._expressionMap[expression.expressionName];
+        }
+        /**
+         * Get the current weight of the specified expression.
+         * If it doesn't have an expression of given name, it will return `null` instead.
+         *
+         * @param name Name of the expression
+         */
+        getValue(name) {
+            var _a;
+            const expression = this.getExpression(name);
+            return (_a = expression === null || expression === void 0 ? void 0 : expression.weight) !== null && _a !== void 0 ? _a : null;
+        }
+        /**
+         * Set a weight to the specified expression.
+         *
+         * @param name Name of the expression
+         * @param weight Weight
+         */
+        setValue(name, weight) {
+            const expression = this.getExpression(name);
+            if (expression) {
+                expression.weight = saturate(weight);
+            }
+        }
+        /**
+         * Get a track name of specified expression.
+         * This track name is needed to manipulate its expression via keyframe animations.
+         *
+         * @example Manipulate an expression using keyframe animation
+         * ```js
+         * const trackName = vrm.expressionManager.getExpressionTrackName( 'blink' );
+         * const track = new THREE.NumberKeyframeTrack(
+         *   name,
+         *   [ 0.0, 0.5, 1.0 ], // times
+         *   [ 0.0, 1.0, 0.0 ] // values
+         * );
+         *
+         * const clip = new THREE.AnimationClip(
+         *   'blink', // name
+         *   1.0, // duration
+         *   [ track ] // tracks
+         * );
+         *
+         * const mixer = new THREE.AnimationMixer( vrm.scene );
+         * const action = mixer.clipAction( clip );
+         * action.play();
+         * ```
+         *
+         * @param name Name of the expression
+         */
+        getExpressionTrackName(name) {
+            const expression = this.getExpression(name);
+            return expression ? `${expression.name}.weight` : null;
+        }
+        /**
+         * Update every expressions.
+         */
+        update() {
+            // see how much we should override certain expressions
+            const weightMultipliers = this._calculateWeightMultipliers();
+            // reset expression binds first
+            this._expressions.forEach((expression) => {
+                expression.clearAppliedWeight();
+            });
+            // then apply binds
+            this._expressions.forEach((expression) => {
+                let multiplier = 1.0;
+                const name = expression.expressionName;
+                if (this.blinkExpressionNames.indexOf(name) !== -1) {
+                    multiplier *= weightMultipliers.blink;
+                }
+                if (this.lookAtExpressionNames.indexOf(name) !== -1) {
+                    multiplier *= weightMultipliers.lookAt;
+                }
+                if (this.mouthExpressionNames.indexOf(name) !== -1) {
+                    multiplier *= weightMultipliers.mouth;
+                }
+                expression.applyWeight({ multiplier });
+            });
+        }
+        /**
+         * Calculate sum of override amounts to see how much we should multiply weights of certain expressions.
+         */
+        _calculateWeightMultipliers() {
+            let blink = 1.0;
+            let lookAt = 1.0;
+            let mouth = 1.0;
+            this._expressions.forEach((expression) => {
+                blink -= expression.overrideBlinkAmount;
+                lookAt -= expression.overrideLookAtAmount;
+                mouth -= expression.overrideMouthAmount;
+            });
+            blink = Math.max(0.0, blink);
+            lookAt = Math.max(0.0, lookAt);
+            mouth = Math.max(0.0, mouth);
+            return { blink, lookAt, mouth };
+        }
     }
 
-    const _color = new THREE__namespace.Color();
-    /**
-     * A bind of expression influences to a material color.
-     */
-    class VRMExpressionMaterialColorBind {
-        constructor({ material, type, targetValue, }) {
-            var _a, _b, _c;
-            this.material = material;
-            this.type = type;
-            this.targetValue = targetValue;
-            // init property name
-            const propertyNameMap = (_a = Object.entries(VRMExpressionMaterialColorBind._propertyNameMapMap).find(([distinguisher]) => {
-                return material[distinguisher] === true;
-            })) === null || _a === void 0 ? void 0 : _a[1];
-            const propertyName = (_b = propertyNameMap === null || propertyNameMap === void 0 ? void 0 : propertyNameMap[type]) !== null && _b !== void 0 ? _b : null;
-            if (propertyName == null) {
-                console.warn(`Tried to add a material color bind to the material ${(_c = material.name) !== null && _c !== void 0 ? _c : '(no name)'}, the type ${type} but the material or the type is not supported.`);
-                this._state = null;
-            }
-            else {
-                const target = material[propertyName];
-                const initialValue = target.clone();
-                const deltaValue = this.targetValue.clone().sub(initialValue);
-                this._state = {
-                    propertyName,
-                    initialValue,
-                    deltaValue,
-                };
-            }
-        }
-        applyWeight(weight) {
-            if (this._state == null) {
-                // warning is already emitted in constructor
-                return;
-            }
-            const { propertyName, deltaValue } = this._state;
-            const target = this.material[propertyName];
-            if (target === undefined) {
-                return;
-            } // TODO: we should kick this at `addMaterialValue`
-            target.add(_color.copy(deltaValue).multiplyScalar(weight));
-            if (typeof this.material.shouldApplyUniforms === 'boolean') {
-                this.material.shouldApplyUniforms = true;
-            }
-        }
-        clearAppliedWeight() {
-            if (this._state == null) {
-                // warning is already emitted in constructor
-                return;
-            }
-            const { propertyName, initialValue } = this._state;
-            const target = this.material[propertyName];
-            if (target === undefined) {
-                return;
-            } // TODO: we should kick this at `addMaterialValue`
-            target.copy(initialValue);
-            if (typeof this.material.shouldApplyUniforms === 'boolean') {
-                this.material.shouldApplyUniforms = true;
-            }
-        }
-    }
-    VRMExpressionMaterialColorBind._propertyNameMapMap = {
-        isMeshStandardMaterial: {
-            color: 'color',
-            emissionColor: 'emissive',
-        },
-        isMeshBasicMaterial: {
-            color: 'color',
-        },
-        isMToonMaterial: {
-            color: 'color',
-            emissionColor: 'emissive',
-            outlineColor: 'outlineFactor',
-            rimColor: 'rimFactor',
-            shadeColor: 'shadeFactor',
-        },
+    const _color = new THREE__namespace.Color();
+    /**
+     * A bind of expression influences to a material color.
+     */
+    class VRMExpressionMaterialColorBind {
+        constructor({ material, type, targetValue, }) {
+            var _a, _b, _c;
+            this.material = material;
+            this.type = type;
+            this.targetValue = targetValue;
+            // init property name
+            const propertyNameMap = (_a = Object.entries(VRMExpressionMaterialColorBind._propertyNameMapMap).find(([distinguisher]) => {
+                return material[distinguisher] === true;
+            })) === null || _a === void 0 ? void 0 : _a[1];
+            const propertyName = (_b = propertyNameMap === null || propertyNameMap === void 0 ? void 0 : propertyNameMap[type]) !== null && _b !== void 0 ? _b : null;
+            if (propertyName == null) {
+                console.warn(`Tried to add a material color bind to the material ${(_c = material.name) !== null && _c !== void 0 ? _c : '(no name)'}, the type ${type} but the material or the type is not supported.`);
+                this._state = null;
+            }
+            else {
+                const target = material[propertyName];
+                const initialValue = target.clone();
+                const deltaValue = this.targetValue.clone().sub(initialValue);
+                this._state = {
+                    propertyName,
+                    initialValue,
+                    deltaValue,
+                };
+            }
+        }
+        applyWeight(weight) {
+            if (this._state == null) {
+                // warning is already emitted in constructor
+                return;
+            }
+            const { propertyName, deltaValue } = this._state;
+            const target = this.material[propertyName];
+            if (target === undefined) {
+                return;
+            } // TODO: we should kick this at `addMaterialValue`
+            target.add(_color.copy(deltaValue).multiplyScalar(weight));
+            if (typeof this.material.shouldApplyUniforms === 'boolean') {
+                this.material.shouldApplyUniforms = true;
+            }
+        }
+        clearAppliedWeight() {
+            if (this._state == null) {
+                // warning is already emitted in constructor
+                return;
+            }
+            const { propertyName, initialValue } = this._state;
+            const target = this.material[propertyName];
+            if (target === undefined) {
+                return;
+            } // TODO: we should kick this at `addMaterialValue`
+            target.copy(initialValue);
+            if (typeof this.material.shouldApplyUniforms === 'boolean') {
+                this.material.shouldApplyUniforms = true;
+            }
+        }
+    }
+    VRMExpressionMaterialColorBind._propertyNameMapMap = {
+        isMeshStandardMaterial: {
+            color: 'color',
+            emissionColor: 'emissive',
+        },
+        isMeshBasicMaterial: {
+            color: 'color',
+        },
+        isMToonMaterial: {
+            color: 'color',
+            emissionColor: 'emissive',
+            outlineColor: 'outlineFactor',
+            rimColor: 'rimFactor',
+            shadeColor: 'shadeFactor',
+        },
     };
 
-    /**
-     * A bind of {@link VRMExpression} influences to morph targets.
-     */
-    class VRMExpressionMorphTargetBind {
-        constructor({ primitives, index, weight, }) {
-            this.primitives = primitives;
-            this.index = index;
-            this.weight = weight;
-        }
-        applyWeight(weight) {
-            this.primitives.forEach((mesh) => {
-                var _a;
-                if (((_a = mesh.morphTargetInfluences) === null || _a === void 0 ? void 0 : _a[this.index]) != null) {
-                    mesh.morphTargetInfluences[this.index] += this.weight * weight;
-                }
-            });
-        }
-        clearAppliedWeight() {
-            this.primitives.forEach((mesh) => {
-                var _a;
-                if (((_a = mesh.morphTargetInfluences) === null || _a === void 0 ? void 0 : _a[this.index]) != null) {
-                    mesh.morphTargetInfluences[this.index] = 0.0;
-                }
-            });
-        }
+    /**
+     * A bind of {@link VRMExpression} influences to morph targets.
+     */
+    class VRMExpressionMorphTargetBind {
+        constructor({ primitives, index, weight, }) {
+            this.primitives = primitives;
+            this.index = index;
+            this.weight = weight;
+        }
+        applyWeight(weight) {
+            this.primitives.forEach((mesh) => {
+                var _a;
+                if (((_a = mesh.morphTargetInfluences) === null || _a === void 0 ? void 0 : _a[this.index]) != null) {
+                    mesh.morphTargetInfluences[this.index] += this.weight * weight;
+                }
+            });
+        }
+        clearAppliedWeight() {
+            this.primitives.forEach((mesh) => {
+                var _a;
+                if (((_a = mesh.morphTargetInfluences) === null || _a === void 0 ? void 0 : _a[this.index]) != null) {
+                    mesh.morphTargetInfluences[this.index] = 0.0;
+                }
+            });
+        }
     }
 
-    const _v2 = new THREE__namespace.Vector2();
-    /**
-     * A bind of expression influences to texture transforms.
-     */
-    class VRMExpressionTextureTransformBind {
-        constructor({ material, scale, offset, }) {
-            var _a, _b;
-            this.material = material;
-            this.scale = scale;
-            this.offset = offset;
-            const propertyNames = (_a = Object.entries(VRMExpressionTextureTransformBind._propertyNamesMap).find(([distinguisher]) => {
-                return material[distinguisher] === true;
-            })) === null || _a === void 0 ? void 0 : _a[1];
-            if (propertyNames == null) {
-                console.warn(`Tried to add a texture transform bind to the material ${(_b = material.name) !== null && _b !== void 0 ? _b : '(no name)'} but the material is not supported.`);
-                this._properties = [];
-            }
-            else {
-                this._properties = [];
-                propertyNames.forEach((propertyName) => {
-                    var _a;
-                    const texture = (_a = material[propertyName]) === null || _a === void 0 ? void 0 : _a.clone();
-                    if (!texture) {
-                        return null;
-                    }
-                    material[propertyName] = texture; // because the texture is cloned
-                    const initialOffset = texture.offset.clone();
-                    const initialScale = texture.repeat.clone();
-                    const deltaOffset = offset.clone().sub(initialOffset);
-                    const deltaScale = scale.clone().sub(initialScale);
-                    this._properties.push({
-                        name: propertyName,
-                        initialOffset,
-                        deltaOffset,
-                        initialScale,
-                        deltaScale,
-                    });
-                });
-            }
-        }
-        applyWeight(weight) {
-            this._properties.forEach((property) => {
-                const target = this.material[property.name];
-                if (target === undefined) {
-                    return;
-                } // TODO: we should kick this at `addMaterialValue`
-                target.offset.add(_v2.copy(property.deltaOffset).multiplyScalar(weight));
-                target.repeat.add(_v2.copy(property.deltaScale).multiplyScalar(weight));
-                target.needsUpdate = true;
-            });
-        }
-        clearAppliedWeight() {
-            this._properties.forEach((property) => {
-                const target = this.material[property.name];
-                if (target === undefined) {
-                    return;
-                } // TODO: we should kick this at `addMaterialValue`
-                target.offset.copy(property.initialOffset);
-                target.repeat.copy(property.initialScale);
-                target.needsUpdate = true;
-            });
-        }
-    }
-    VRMExpressionTextureTransformBind._propertyNamesMap = {
-        isMeshStandardMaterial: [
-            'map',
-            'emissiveMap',
-            'bumpMap',
-            'normalMap',
-            'displacementMap',
-            'roughnessMap',
-            'metalnessMap',
-            'alphaMap',
-        ],
-        isMeshBasicMaterial: ['map', 'specularMap', 'alphaMap'],
-        isMToonMaterial: [
-            'map',
-            'normalMap',
-            'emissiveMap',
-            'shadeMultiplyTexture',
-            'rimMultiplyTexture',
-            'outlineWidthMultiplyTexture',
-            'uvAnimationMaskTexture',
-        ],
+    const _v2 = new THREE__namespace.Vector2();
+    /**
+     * A bind of expression influences to texture transforms.
+     */
+    class VRMExpressionTextureTransformBind {
+        constructor({ material, scale, offset, }) {
+            var _a, _b;
+            this.material = material;
+            this.scale = scale;
+            this.offset = offset;
+            const propertyNames = (_a = Object.entries(VRMExpressionTextureTransformBind._propertyNamesMap).find(([distinguisher]) => {
+                return material[distinguisher] === true;
+            })) === null || _a === void 0 ? void 0 : _a[1];
+            if (propertyNames == null) {
+                console.warn(`Tried to add a texture transform bind to the material ${(_b = material.name) !== null && _b !== void 0 ? _b : '(no name)'} but the material is not supported.`);
+                this._properties = [];
+            }
+            else {
+                this._properties = [];
+                propertyNames.forEach((propertyName) => {
+                    var _a;
+                    const texture = (_a = material[propertyName]) === null || _a === void 0 ? void 0 : _a.clone();
+                    if (!texture) {
+                        return null;
+                    }
+                    material[propertyName] = texture; // because the texture is cloned
+                    const initialOffset = texture.offset.clone();
+                    const initialScale = texture.repeat.clone();
+                    const deltaOffset = offset.clone().sub(initialOffset);
+                    const deltaScale = scale.clone().sub(initialScale);
+                    this._properties.push({
+                        name: propertyName,
+                        initialOffset,
+                        deltaOffset,
+                        initialScale,
+                        deltaScale,
+                    });
+                });
+            }
+        }
+        applyWeight(weight) {
+            this._properties.forEach((property) => {
+                const target = this.material[property.name];
+                if (target === undefined) {
+                    return;
+                } // TODO: we should kick this at `addMaterialValue`
+                target.offset.add(_v2.copy(property.deltaOffset).multiplyScalar(weight));
+                target.repeat.add(_v2.copy(property.deltaScale).multiplyScalar(weight));
+                target.needsUpdate = true;
+            });
+        }
+        clearAppliedWeight() {
+            this._properties.forEach((property) => {
+                const target = this.material[property.name];
+                if (target === undefined) {
+                    return;
+                } // TODO: we should kick this at `addMaterialValue`
+                target.offset.copy(property.initialOffset);
+                target.repeat.copy(property.initialScale);
+                target.needsUpdate = true;
+            });
+        }
+    }
+    VRMExpressionTextureTransformBind._propertyNamesMap = {
+        isMeshStandardMaterial: [
+            'map',
+            'emissiveMap',
+            'bumpMap',
+            'normalMap',
+            'displacementMap',
+            'roughnessMap',
+            'metalnessMap',
+            'alphaMap',
+        ],
+        isMeshBasicMaterial: ['map', 'specularMap', 'alphaMap'],
+        isMToonMaterial: [
+            'map',
+            'normalMap',
+            'emissiveMap',
+            'shadeMultiplyTexture',
+            'rimMultiplyTexture',
+            'outlineWidthMultiplyTexture',
+            'uvAnimationMaskTexture',
+        ],
     };
 
-    /**
-     * A plugin of GLTFLoader that imports a {@link VRMExpressionManager} from a VRM extension of a GLTF.
-     */
-    class VRMExpressionLoaderPlugin {
-        constructor(parser) {
-            this.parser = parser;
-        }
-        get name() {
-            // We should use the extension name instead but we have multiple plugins for an extension...
-            return 'VRMExpressionLoaderPlugin';
-        }
-        afterRoot(gltf) {
-            return __awaiter(this, void 0, void 0, function* () {
-                gltf.userData.vrmExpressionManager = yield this._import(gltf);
-            });
-        }
-        /**
-         * Import a {@link VRMExpressionManager} from a VRM.
-         *
-         * @param gltf A parsed result of GLTF taken from GLTFLoader
-         */
-        _import(gltf) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const v1Result = yield this._v1Import(gltf);
-                if (v1Result) {
-                    return v1Result;
-                }
-                const v0Result = yield this._v0Import(gltf);
-                if (v0Result) {
-                    return v0Result;
-                }
-                return null;
-            });
-        }
-        _v1Import(gltf) {
-            var _a, _b;
-            return __awaiter(this, void 0, void 0, function* () {
-                const json = this.parser.json;
-                // early abort if it doesn't use vrm
-                const isVRMUsed = ((_a = json.extensionsUsed) === null || _a === void 0 ? void 0 : _a.indexOf('VRMC_vrm')) !== -1;
-                if (!isVRMUsed) {
-                    return null;
-                }
-                const extension = (_b = json.extensions) === null || _b === void 0 ? void 0 : _b['VRMC_vrm'];
-                if (!extension) {
-                    return null;
-                }
-                const specVersion = extension.specVersion;
-                if (specVersion !== '1.0-beta') {
-                    return null;
-                }
-                const schemaExpressions = extension.expressions;
-                if (!schemaExpressions) {
-                    return null;
-                }
-                // list expressions
-                const presetNameSet = new Set(Object.values(VRMExpressionPresetName));
-                const nameSchemaExpressionMap = new Map();
-                if (schemaExpressions.preset != null) {
-                    Object.entries(schemaExpressions.preset).forEach(([name, schemaExpression]) => {
-                        if (schemaExpression == null) {
-                            return;
-                        } // typescript
-                        if (!presetNameSet.has(name)) {
-                            console.warn(`VRMExpressionLoaderPlugin: Unknown preset name "${name}" detected. Ignoring the expression`);
-                            return;
-                        }
-                        nameSchemaExpressionMap.set(name, schemaExpression);
-                    });
-                }
-                if (schemaExpressions.custom != null) {
-                    Object.entries(schemaExpressions.custom).forEach(([name, schemaExpression]) => {
-                        if (presetNameSet.has(name)) {
-                            console.warn(`VRMExpressionLoaderPlugin: Custom expression cannot have preset name "${name}". Ignoring the expression`);
-                            return;
-                        }
-                        nameSchemaExpressionMap.set(name, schemaExpression);
-                    });
-                }
-                // prepare manager
-                const manager = new VRMExpressionManager();
-                // load expressions
-                yield Promise.all(Array.from(nameSchemaExpressionMap.entries()).map(([name, schemaExpression]) => __awaiter(this, void 0, void 0, function* () {
-                    var _c, _d, _e, _f, _g, _h, _j;
-                    const expression = new VRMExpression(name);
-                    gltf.scene.add(expression);
-                    expression.isBinary = (_c = schemaExpression.isBinary) !== null && _c !== void 0 ? _c : false;
-                    expression.overrideBlink = (_d = schemaExpression.overrideBlink) !== null && _d !== void 0 ? _d : 'none';
-                    expression.overrideLookAt = (_e = schemaExpression.overrideLookAt) !== null && _e !== void 0 ? _e : 'none';
-                    expression.overrideMouth = (_f = schemaExpression.overrideMouth) !== null && _f !== void 0 ? _f : 'none';
-                    (_g = schemaExpression.morphTargetBinds) === null || _g === void 0 ? void 0 : _g.forEach((bind) => __awaiter(this, void 0, void 0, function* () {
-                        var _k;
-                        if (bind.node === undefined || bind.index === undefined) {
-                            return;
-                        }
-                        const primitives = (yield gltfExtractPrimitivesFromNode(gltf, bind.node));
-                        const morphTargetIndex = bind.index;
-                        // check if the mesh has the target morph target
-                        if (!primitives.every((primitive) => Array.isArray(primitive.morphTargetInfluences) &&
-                            morphTargetIndex < primitive.morphTargetInfluences.length)) {
-                            console.warn(`VRMExpressionLoaderPlugin: ${schemaExpression.name} attempts to index morph #${morphTargetIndex} but not found.`);
-                            return;
-                        }
-                        expression.addBind(new VRMExpressionMorphTargetBind({
-                            primitives,
-                            index: morphTargetIndex,
-                            weight: (_k = bind.weight) !== null && _k !== void 0 ? _k : 1.0,
-                        }));
-                    }));
-                    if (schemaExpression.materialColorBinds || schemaExpression.textureTransformBinds) {
-                        // list up every material in `gltf.scene`
-                        const gltfMaterials = [];
-                        gltf.scene.traverse((object) => {
-                            const material = object.material;
-                            if (material) {
-                                gltfMaterials.push(material);
-                            }
-                        });
-                        (_h = schemaExpression.materialColorBinds) === null || _h === void 0 ? void 0 : _h.forEach((bind) => __awaiter(this, void 0, void 0, function* () {
-                            const materials = gltfMaterials.filter((material) => {
-                                const materialIndex = gltfGetAssociatedMaterialIndex(this.parser, material);
-                                return bind.material === materialIndex;
-                            });
-                            materials.forEach((material) => {
-                                expression.addBind(new VRMExpressionMaterialColorBind({
-                                    material,
-                                    type: bind.type,
-                                    targetValue: new THREE__namespace.Color().fromArray(bind.targetValue),
-                                }));
-                            });
-                        }));
-                        (_j = schemaExpression.textureTransformBinds) === null || _j === void 0 ? void 0 : _j.forEach((bind) => __awaiter(this, void 0, void 0, function* () {
-                            const materials = gltfMaterials.filter((material) => {
-                                const materialIndex = gltfGetAssociatedMaterialIndex(this.parser, material);
-                                return bind.material === materialIndex;
-                            });
-                            materials.forEach((material) => {
-                                var _a, _b;
-                                expression.addBind(new VRMExpressionTextureTransformBind({
-                                    material,
-                                    offset: new THREE__namespace.Vector2().fromArray((_a = bind.offset) !== null && _a !== void 0 ? _a : [0.0, 0.0]),
-                                    scale: new THREE__namespace.Vector2().fromArray((_b = bind.scale) !== null && _b !== void 0 ? _b : [1.0, 1.0]),
-                                }));
-                            });
-                        }));
-                    }
-                    manager.registerExpression(expression);
-                })));
-                return manager;
-            });
-        }
-        _v0Import(gltf) {
-            var _a;
-            return __awaiter(this, void 0, void 0, function* () {
-                const json = this.parser.json;
-                // early abort if it doesn't use vrm
-                const vrmExt = (_a = json.extensions) === null || _a === void 0 ? void 0 : _a.VRM;
-                if (!vrmExt) {
-                    return null;
-                }
-                const schemaBlendShape = vrmExt.blendShapeMaster;
-                if (!schemaBlendShape) {
-                    return null;
-                }
-                const manager = new VRMExpressionManager();
-                const schemaBlendShapeGroups = schemaBlendShape.blendShapeGroups;
-                if (!schemaBlendShapeGroups) {
-                    return manager;
-                }
-                const blendShapeNameSet = new Set();
-                yield Promise.all(schemaBlendShapeGroups.map((schemaGroup) => __awaiter(this, void 0, void 0, function* () {
-                    var _b;
-                    const v0PresetName = schemaGroup.presetName;
-                    const v1PresetName = (v0PresetName != null && VRMExpressionLoaderPlugin.v0v1PresetNameMap[v0PresetName]) || null;
-                    const name = v1PresetName !== null && v1PresetName !== void 0 ? v1PresetName : schemaGroup.name;
-                    if (name == null) {
-                        console.warn('VRMExpressionLoaderPlugin: One of custom expressions has no name. Ignoring the expression');
-                        return;
-                    }
-                    // duplication check
-                    if (blendShapeNameSet.has(name)) {
-                        console.warn(`VRMExpressionLoaderPlugin: An expression preset ${v0PresetName} has duplicated entries. Ignoring the expression`);
-                        return;
-                    }
-                    blendShapeNameSet.add(name);
-                    const expression = new VRMExpression(name);
-                    gltf.scene.add(expression);
-                    expression.isBinary = (_b = schemaGroup.isBinary) !== null && _b !== void 0 ? _b : false;
-                    // v0 doesn't have ignore properties
-                    if (schemaGroup.binds) {
-                        schemaGroup.binds.forEach((bind) => __awaiter(this, void 0, void 0, function* () {
-                            var _c;
-                            if (bind.mesh === undefined || bind.index === undefined) {
-                                return;
-                            }
-                            const nodesUsingMesh = [];
-                            (_c = json.nodes) === null || _c === void 0 ? void 0 : _c.forEach((node, i) => {
-                                if (node.mesh === bind.mesh) {
-                                    nodesUsingMesh.push(i);
-                                }
-                            });
-                            const morphTargetIndex = bind.index;
-                            yield Promise.all(nodesUsingMesh.map((nodeIndex) => __awaiter(this, void 0, void 0, function* () {
-                                var _d;
-                                const primitives = (yield gltfExtractPrimitivesFromNode(gltf, nodeIndex));
-                                // check if the mesh has the target morph target
-                                if (!primitives.every((primitive) => Array.isArray(primitive.morphTargetInfluences) &&
-                                    morphTargetIndex < primitive.morphTargetInfluences.length)) {
-                                    console.warn(`VRMExpressionLoaderPlugin: ${schemaGroup.name} attempts to index ${morphTargetIndex}th morph but not found.`);
-                                    return;
-                                }
-                                expression.addBind(new VRMExpressionMorphTargetBind({
-                                    primitives,
-                                    index: morphTargetIndex,
-                                    weight: 0.01 * ((_d = bind.weight) !== null && _d !== void 0 ? _d : 100),
-                                }));
-                            })));
-                        }));
-                    }
-                    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');
-                    }
-                    manager.registerExpression(expression);
-                })));
-                return manager;
-            });
-        }
-    }
-    VRMExpressionLoaderPlugin.v0v1PresetNameMap = {
-        a: 'aa',
-        e: 'ee',
-        i: 'ih',
-        o: 'oh',
-        u: 'ou',
-        blink: 'blink',
-        joy: 'happy',
-        angry: 'angry',
-        sorrow: 'sad',
-        fun: 'relaxed',
-        lookup: 'lookUp',
-        lookdown: 'lookDown',
-        lookleft: 'lookLeft',
-        lookright: 'lookRight',
-        // eslint-disable-next-line @typescript-eslint/naming-convention
-        blink_l: 'blinkLeft',
-        // eslint-disable-next-line @typescript-eslint/naming-convention
-        blink_r: 'blinkRight',
-        neutral: 'neutral',
+    /**
+     * A plugin of GLTFLoader that imports a {@link VRMExpressionManager} from a VRM extension of a GLTF.
+     */
+    class VRMExpressionLoaderPlugin {
+        constructor(parser) {
+            this.parser = parser;
+        }
+        get name() {
+            // We should use the extension name instead but we have multiple plugins for an extension...
+            return 'VRMExpressionLoaderPlugin';
+        }
+        afterRoot(gltf) {
+            return __awaiter(this, void 0, void 0, function* () {
+                gltf.userData.vrmExpressionManager = yield this._import(gltf);
+            });
+        }
+        /**
+         * Import a {@link VRMExpressionManager} from a VRM.
+         *
+         * @param gltf A parsed result of GLTF taken from GLTFLoader
+         */
+        _import(gltf) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const v1Result = yield this._v1Import(gltf);
+                if (v1Result) {
+                    return v1Result;
+                }
+                const v0Result = yield this._v0Import(gltf);
+                if (v0Result) {
+                    return v0Result;
+                }
+                return null;
+            });
+        }
+        _v1Import(gltf) {
+            var _a, _b;
+            return __awaiter(this, void 0, void 0, function* () {
+                const json = this.parser.json;
+                // early abort if it doesn't use vrm
+                const isVRMUsed = ((_a = json.extensionsUsed) === null || _a === void 0 ? void 0 : _a.indexOf('VRMC_vrm')) !== -1;
+                if (!isVRMUsed) {
+                    return null;
+                }
+                const extension = (_b = json.extensions) === null || _b === void 0 ? void 0 : _b['VRMC_vrm'];
+                if (!extension) {
+                    return null;
+                }
+                const specVersion = extension.specVersion;
+                if (specVersion !== '1.0-beta') {
+                    return null;
+                }
+                const schemaExpressions = extension.expressions;
+                if (!schemaExpressions) {
+                    return null;
+                }
+                // list expressions
+                const presetNameSet = new Set(Object.values(VRMExpressionPresetName));
+                const nameSchemaExpressionMap = new Map();
+                if (schemaExpressions.preset != null) {
+                    Object.entries(schemaExpressions.preset).forEach(([name, schemaExpression]) => {
+                        if (schemaExpression == null) {
+                            return;
+                        } // typescript
+                        if (!presetNameSet.has(name)) {
+                            console.warn(`VRMExpressionLoaderPlugin: Unknown preset name "${name}" detected. Ignoring the expression`);
+                            return;
+                        }
+                        nameSchemaExpressionMap.set(name, schemaExpression);
+                    });
+                }
+                if (schemaExpressions.custom != null) {
+                    Object.entries(schemaExpressions.custom).forEach(([name, schemaExpression]) => {
+                        if (presetNameSet.has(name)) {
+                            console.warn(`VRMExpressionLoaderPlugin: Custom expression cannot have preset name "${name}". Ignoring the expression`);
+                            return;
+                        }
+                        nameSchemaExpressionMap.set(name, schemaExpression);
+                    });
+                }
+                // prepare manager
+                const manager = new VRMExpressionManager();
+                // load expressions
+                yield Promise.all(Array.from(nameSchemaExpressionMap.entries()).map(([name, schemaExpression]) => __awaiter(this, void 0, void 0, function* () {
+                    var _c, _d, _e, _f, _g, _h, _j;
+                    const expression = new VRMExpression(name);
+                    gltf.scene.add(expression);
+                    expression.isBinary = (_c = schemaExpression.isBinary) !== null && _c !== void 0 ? _c : false;
+                    expression.overrideBlink = (_d = schemaExpression.overrideBlink) !== null && _d !== void 0 ? _d : 'none';
+                    expression.overrideLookAt = (_e = schemaExpression.overrideLookAt) !== null && _e !== void 0 ? _e : 'none';
+                    expression.overrideMouth = (_f = schemaExpression.overrideMouth) !== null && _f !== void 0 ? _f : 'none';
+                    (_g = schemaExpression.morphTargetBinds) === null || _g === void 0 ? void 0 : _g.forEach((bind) => __awaiter(this, void 0, void 0, function* () {
+                        var _k;
+                        if (bind.node === undefined || bind.index === undefined) {
+                            return;
+                        }
+                        const primitives = (yield gltfExtractPrimitivesFromNode(gltf, bind.node));
+                        const morphTargetIndex = bind.index;
+                        // check if the mesh has the target morph target
+                        if (!primitives.every((primitive) => Array.isArray(primitive.morphTargetInfluences) &&
+                            morphTargetIndex < primitive.morphTargetInfluences.length)) {
+                            console.warn(`VRMExpressionLoaderPlugin: ${schemaExpression.name} attempts to index morph #${morphTargetIndex} but not found.`);
+                            return;
+                        }
+                        expression.addBind(new VRMExpressionMorphTargetBind({
+                            primitives,
+                            index: morphTargetIndex,
+                            weight: (_k = bind.weight) !== null && _k !== void 0 ? _k : 1.0,
+                        }));
+                    }));
+                    if (schemaExpression.materialColorBinds || schemaExpression.textureTransformBinds) {
+                        // list up every material in `gltf.scene`
+                        const gltfMaterials = [];
+                        gltf.scene.traverse((object) => {
+                            const material = object.material;
+                            if (material) {
+                                gltfMaterials.push(material);
+                            }
+                        });
+                        (_h = schemaExpression.materialColorBinds) === null || _h === void 0 ? void 0 : _h.forEach((bind) => __awaiter(this, void 0, void 0, function* () {
+                            const materials = gltfMaterials.filter((material) => {
+                                const materialIndex = gltfGetAssociatedMaterialIndex(this.parser, material);
+                                return bind.material === materialIndex;
+                            });
+                            materials.forEach((material) => {
+                                expression.addBind(new VRMExpressionMaterialColorBind({
+                                    material,
+                                    type: bind.type,
+                                    targetValue: new THREE__namespace.Color().fromArray(bind.targetValue),
+                                }));
+                            });
+                        }));
+                        (_j = schemaExpression.textureTransformBinds) === null || _j === void 0 ? void 0 : _j.forEach((bind) => __awaiter(this, void 0, void 0, function* () {
+                            const materials = gltfMaterials.filter((material) => {
+                                const materialIndex = gltfGetAssociatedMaterialIndex(this.parser, material);
+                                return bind.material === materialIndex;
+                            });
+                            materials.forEach((material) => {
+                                var _a, _b;
+                                expression.addBind(new VRMExpressionTextureTransformBind({
+                                    material,
+                                    offset: new THREE__namespace.Vector2().fromArray((_a = bind.offset) !== null && _a !== void 0 ? _a : [0.0, 0.0]),
+                                    scale: new THREE__namespace.Vector2().fromArray((_b = bind.scale) !== null && _b !== void 0 ? _b : [1.0, 1.0]),
+                                }));
+                            });
+                        }));
+                    }
+                    manager.registerExpression(expression);
+                })));
+                return manager;
+            });
+        }
+        _v0Import(gltf) {
+            var _a;
+            return __awaiter(this, void 0, void 0, function* () {
+                const json = this.parser.json;
+                // early abort if it doesn't use vrm
+                const vrmExt = (_a = json.extensions) === null || _a === void 0 ? void 0 : _a.VRM;
+                if (!vrmExt) {
+                    return null;
+                }
+                const schemaBlendShape = vrmExt.blendShapeMaster;
+                if (!schemaBlendShape) {
+                    return null;
+                }
+                const manager = new VRMExpressionManager();
+                const schemaBlendShapeGroups = schemaBlendShape.blendShapeGroups;
+                if (!schemaBlendShapeGroups) {
+                    return manager;
+                }
+                const blendShapeNameSet = new Set();
+                yield Promise.all(schemaBlendShapeGroups.map((schemaGroup) => __awaiter(this, void 0, void 0, function* () {
+                    var _b;
+                    const v0PresetName = schemaGroup.presetName;
+                    const v1PresetName = (v0PresetName != null && VRMExpressionLoaderPlugin.v0v1PresetNameMap[v0PresetName]) || null;
+                    const name = v1PresetName !== null && v1PresetName !== void 0 ? v1PresetName : schemaGroup.name;
+                    if (name == null) {
+                        console.warn('VRMExpressionLoaderPlugin: One of custom expressions has no name. Ignoring the expression');
+                        return;
+                    }
+                    // duplication check
+                    if (blendShapeNameSet.has(name)) {
+                        console.warn(`VRMExpressionLoaderPlugin: An expression preset ${v0PresetName} has duplicated entries. Ignoring the expression`);
+                        return;
+                    }
+                    blendShapeNameSet.add(name);
+                    const expression = new VRMExpression(name);
+                    gltf.scene.add(expression);
+                    expression.isBinary = (_b = schemaGroup.isBinary) !== null && _b !== void 0 ? _b : false;
+                    // v0 doesn't have ignore properties
+                    if (schemaGroup.binds) {
+                        schemaGroup.binds.forEach((bind) => __awaiter(this, void 0, void 0, function* () {
+                            var _c;
+                            if (bind.mesh === undefined || bind.index === undefined) {
+                                return;
+                            }
+                            const nodesUsingMesh = [];
+                            (_c = json.nodes) === null || _c === void 0 ? void 0 : _c.forEach((node, i) => {
+                                if (node.mesh === bind.mesh) {
+                                    nodesUsingMesh.push(i);
+                                }
+                            });
+                            const morphTargetIndex = bind.index;
+                            yield Promise.all(nodesUsingMesh.map((nodeIndex) => __awaiter(this, void 0, void 0, function* () {
+                                var _d;
+                                const primitives = (yield gltfExtractPrimitivesFromNode(gltf, nodeIndex));
+                                // check if the mesh has the target morph target
+                                if (!primitives.every((primitive) => Array.isArray(primitive.morphTargetInfluences) &&
+                                    morphTargetIndex < primitive.morphTargetInfluences.length)) {
+                                    console.warn(`VRMExpressionLoaderPlugin: ${schemaGroup.name} attempts to index ${morphTargetIndex}th morph but not found.`);
+                                    return;
+                                }
+                                expression.addBind(new VRMExpressionMorphTargetBind({
+                                    primitives,
+                                    index: morphTargetIndex,
+                                    weight: 0.01 * ((_d = bind.weight) !== null && _d !== void 0 ? _d : 100),
+                                }));
+                            })));
+                        }));
+                    }
+                    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');
+                    }
+                    manager.registerExpression(expression);
+                })));
+                return manager;
+            });
+        }
+    }
+    VRMExpressionLoaderPlugin.v0v1PresetNameMap = {
+        a: 'aa',
+        e: 'ee',
+        i: 'ih',
+        o: 'oh',
+        u: 'ou',
+        blink: 'blink',
+        joy: 'happy',
+        angry: 'angry',
+        sorrow: 'sad',
+        fun: 'relaxed',
+        lookup: 'lookUp',
+        lookdown: 'lookDown',
+        lookleft: 'lookLeft',
+        lookright: 'lookRight',
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        blink_l: 'blinkLeft',
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        blink_r: 'blinkRight',
+        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 VRMExpressionMaterialColorType = {
+        Color: 'color',
+        EmissionColor: 'emissionColor',
+        ShadeColor: 'shadeColor',
+        RimColor: 'rimColor',
+        OutlineColor: 'outlineColor',
     };
 
-    /* eslint-disable @typescript-eslint/naming-convention */
-    const VRMExpressionOverrideType = {
-        None: 'none',
-        Block: 'block',
-        Blend: 'blend',
+    /* eslint-disable @typescript-eslint/naming-convention */
+    const VRMExpressionOverrideType = {
+        None: 'none',
+        Block: 'block',
+        Blend: 'blend',
     };
 
-    class VRMFirstPerson {
-        /**
-         * Create a new VRMFirstPerson object.
-         *
-         * @param humanoid A {@link VRMHumanoid}
-         * @param meshAnnotations A renderer settings. See the description of [[RendererFirstPersonFlags]] for more info
-         */
-        constructor(humanoid, meshAnnotations) {
-            this._firstPersonOnlyLayer = VRMFirstPerson.DEFAULT_FIRSTPERSON_ONLY_LAYER;
-            this._thirdPersonOnlyLayer = VRMFirstPerson.DEFAULT_THIRDPERSON_ONLY_LAYER;
-            this._initializedLayers = false;
-            this.humanoid = humanoid;
-            this.meshAnnotations = meshAnnotations;
-        }
-        /**
-         * Copy the given {@link VRMFirstPerson} into this one.
-         * {@link humanoid} must be same as the source one.
-         * @param source The {@link VRMFirstPerson} you want to copy
-         * @returns this
-         */
-        copy(source) {
-            if (this.humanoid !== source.humanoid) {
-                throw new Error('VRMFirstPerson: humanoid must be same in order to copy');
-            }
-            this.meshAnnotations = source.meshAnnotations.map((annotation) => ({
-                meshes: annotation.meshes.concat(),
-                type: annotation.type,
-            }));
-            return this;
-        }
-        /**
-         * Returns a clone of this {@link VRMFirstPerson}.
-         * @returns Copied {@link VRMFirstPerson}
-         */
-        clone() {
-            return new VRMFirstPerson(this.humanoid, this.meshAnnotations).copy(this);
-        }
-        /**
-         * A camera layer represents `FirstPersonOnly` layer.
-         * Note that **you must call {@link setup} first before you use the layer feature** or it does not work properly.
-         *
-         * The value is {@link DEFAULT_FIRSTPERSON_ONLY_LAYER} by default but you can change the layer by specifying via {@link setup} if you prefer.
-         *
-         * @see https://vrm.dev/en/univrm/api/univrm_use_firstperson/
-         * @see https://threejs.org/docs/#api/en/core/Layers
-         */
-        get firstPersonOnlyLayer() {
-            return this._firstPersonOnlyLayer;
-        }
-        /**
-         * A camera layer represents `ThirdPersonOnly` layer.
-         * Note that **you must call {@link setup} first before you use the layer feature** or it does not work properly.
-         *
-         * The value is {@link DEFAULT_THIRDPERSON_ONLY_LAYER} by default but you can change the layer by specifying via {@link setup} if you prefer.
-         *
-         * @see https://vrm.dev/en/univrm/api/univrm_use_firstperson/
-         * @see https://threejs.org/docs/#api/en/core/Layers
-         */
-        get thirdPersonOnlyLayer() {
-            return this._thirdPersonOnlyLayer;
-        }
-        /**
-         * In this method, it assigns layers for every meshes based on mesh annotations.
-         * You must call this method first before you use the layer feature.
-         *
-         * This is an equivalent of [VRMFirstPerson.Setup](https://github.com/vrm-c/UniVRM/blob/73a5bd8fcddaa2a7a8735099a97e63c9db3e5ea0/Assets/VRM/Runtime/FirstPerson/VRMFirstPerson.cs#L295-L299) of the UniVRM.
-         *
-         * The `cameraLayer` parameter specifies which layer will be assigned for `FirstPersonOnly` / `ThirdPersonOnly`.
-         * In UniVRM, we specified those by naming each desired layer as `FIRSTPERSON_ONLY_LAYER` / `THIRDPERSON_ONLY_LAYER`
-         * but we are going to specify these layers at here since we are unable to name layers in Three.js.
-         *
-         * @param cameraLayer Specify which layer will be for `FirstPersonOnly` / `ThirdPersonOnly`.
-         */
-        setup({ firstPersonOnlyLayer = VRMFirstPerson.DEFAULT_FIRSTPERSON_ONLY_LAYER, thirdPersonOnlyLayer = VRMFirstPerson.DEFAULT_THIRDPERSON_ONLY_LAYER, } = {}) {
-            if (this._initializedLayers) {
-                return;
-            }
-            this._firstPersonOnlyLayer = firstPersonOnlyLayer;
-            this._thirdPersonOnlyLayer = thirdPersonOnlyLayer;
-            this.meshAnnotations.forEach((item) => {
-                item.meshes.forEach((mesh) => {
-                    if (item.type === 'firstPersonOnly') {
-                        mesh.layers.set(this._firstPersonOnlyLayer);
-                        mesh.traverse((child) => child.layers.set(this._firstPersonOnlyLayer));
-                    }
-                    else if (item.type === 'thirdPersonOnly') {
-                        mesh.layers.set(this._thirdPersonOnlyLayer);
-                        mesh.traverse((child) => child.layers.set(this._thirdPersonOnlyLayer));
-                    }
-                    else if (item.type === 'auto') {
-                        this._createHeadlessModel(mesh);
-                    }
-                });
-            });
-            this._initializedLayers = true;
-        }
-        _excludeTriangles(triangles, bws, skinIndex, exclude) {
-            let count = 0;
-            if (bws != null && bws.length > 0) {
-                for (let i = 0; i < triangles.length; i += 3) {
-                    const a = triangles[i];
-                    const b = triangles[i + 1];
-                    const c = triangles[i + 2];
-                    const bw0 = bws[a];
-                    const skin0 = skinIndex[a];
-                    if (bw0[0] > 0 && exclude.includes(skin0[0]))
-                        continue;
-                    if (bw0[1] > 0 && exclude.includes(skin0[1]))
-                        continue;
-                    if (bw0[2] > 0 && exclude.includes(skin0[2]))
-                        continue;
-                    if (bw0[3] > 0 && exclude.includes(skin0[3]))
-                        continue;
-                    const bw1 = bws[b];
-                    const skin1 = skinIndex[b];
-                    if (bw1[0] > 0 && exclude.includes(skin1[0]))
-                        continue;
-                    if (bw1[1] > 0 && exclude.includes(skin1[1]))
-                        continue;
-                    if (bw1[2] > 0 && exclude.includes(skin1[2]))
-                        continue;
-                    if (bw1[3] > 0 && exclude.includes(skin1[3]))
-                        continue;
-                    const bw2 = bws[c];
-                    const skin2 = skinIndex[c];
-                    if (bw2[0] > 0 && exclude.includes(skin2[0]))
-                        continue;
-                    if (bw2[1] > 0 && exclude.includes(skin2[1]))
-                        continue;
-                    if (bw2[2] > 0 && exclude.includes(skin2[2]))
-                        continue;
-                    if (bw2[3] > 0 && exclude.includes(skin2[3]))
-                        continue;
-                    triangles[count++] = a;
-                    triangles[count++] = b;
-                    triangles[count++] = c;
-                }
-            }
-            return count;
-        }
-        _createErasedMesh(src, erasingBonesIndex) {
-            const dst = new THREE__namespace.SkinnedMesh(src.geometry.clone(), src.material);
-            dst.name = `${src.name}(erase)`;
-            dst.frustumCulled = src.frustumCulled;
-            dst.layers.set(this._firstPersonOnlyLayer);
-            const geometry = dst.geometry;
-            const skinIndexAttr = geometry.getAttribute('skinIndex').array;
-            const skinIndex = [];
-            for (let i = 0; i < skinIndexAttr.length; i += 4) {
-                skinIndex.push([skinIndexAttr[i], skinIndexAttr[i + 1], skinIndexAttr[i + 2], skinIndexAttr[i + 3]]);
-            }
-            const skinWeightAttr = geometry.getAttribute('skinWeight').array;
-            const skinWeight = [];
-            for (let i = 0; i < skinWeightAttr.length; i += 4) {
-                skinWeight.push([skinWeightAttr[i], skinWeightAttr[i + 1], skinWeightAttr[i + 2], skinWeightAttr[i + 3]]);
-            }
-            const index = geometry.getIndex();
-            if (!index) {
-                throw new Error("The geometry doesn't have an index buffer");
-            }
-            const oldTriangles = Array.from(index.array);
-            const count = this._excludeTriangles(oldTriangles, skinWeight, skinIndex, erasingBonesIndex);
-            const newTriangle = [];
-            for (let i = 0; i < count; i++) {
-                newTriangle[i] = oldTriangles[i];
-            }
-            geometry.setIndex(newTriangle);
-            // mtoon material includes onBeforeRender. this is unsupported at SkinnedMesh#clone
-            if (src.onBeforeRender) {
-                dst.onBeforeRender = src.onBeforeRender;
-            }
-            dst.bind(new THREE__namespace.Skeleton(src.skeleton.bones, src.skeleton.boneInverses), new THREE__namespace.Matrix4());
-            return dst;
-        }
-        _createHeadlessModelForSkinnedMesh(parent, mesh) {
-            const eraseBoneIndexes = [];
-            mesh.skeleton.bones.forEach((bone, index) => {
-                if (this._isEraseTarget(bone))
-                    eraseBoneIndexes.push(index);
-            });
-            // Unlike UniVRM we don't copy mesh if no invisible bone was found
-            if (!eraseBoneIndexes.length) {
-                mesh.layers.enable(this._thirdPersonOnlyLayer);
-                mesh.layers.enable(this._firstPersonOnlyLayer);
-                return;
-            }
-            mesh.layers.set(this._thirdPersonOnlyLayer);
-            const newMesh = this._createErasedMesh(mesh, eraseBoneIndexes);
-            parent.add(newMesh);
-        }
-        _createHeadlessModel(node) {
-            if (node.type === 'Group') {
-                node.layers.set(this._thirdPersonOnlyLayer);
-                if (this._isEraseTarget(node)) {
-                    node.traverse((child) => child.layers.set(this._thirdPersonOnlyLayer));
-                }
-                else {
-                    const parent = new THREE__namespace.Group();
-                    parent.name = `_headless_${node.name}`;
-                    parent.layers.set(this._firstPersonOnlyLayer);
-                    node.parent.add(parent);
-                    node.children
-                        .filter((child) => child.type === 'SkinnedMesh')
-                        .forEach((child) => {
-                        const skinnedMesh = child;
-                        this._createHeadlessModelForSkinnedMesh(parent, skinnedMesh);
-                    });
-                }
-            }
-            else if (node.type === 'SkinnedMesh') {
-                const skinnedMesh = node;
-                this._createHeadlessModelForSkinnedMesh(node.parent, skinnedMesh);
-            }
-            else {
-                if (this._isEraseTarget(node)) {
-                    node.layers.set(this._thirdPersonOnlyLayer);
-                    node.traverse((child) => child.layers.set(this._thirdPersonOnlyLayer));
-                }
-            }
-        }
-        _isEraseTarget(bone) {
-            if (bone === this.humanoid.getBoneNode('head')) {
-                return true;
-            }
-            else if (!bone.parent) {
-                return false;
-            }
-            else {
-                return this._isEraseTarget(bone.parent);
-            }
-        }
-    }
-    /**
-     * A default camera layer for `FirstPersonOnly` layer.
-     *
-     * @see [[getFirstPersonOnlyLayer]]
-     */
-    VRMFirstPerson.DEFAULT_FIRSTPERSON_ONLY_LAYER = 9;
-    /**
-     * A default camera layer for `ThirdPersonOnly` layer.
-     *
-     * @see [[getThirdPersonOnlyLayer]]
-     */
+    class VRMFirstPerson {
+        /**
+         * Create a new VRMFirstPerson object.
+         *
+         * @param humanoid A {@link VRMHumanoid}
+         * @param meshAnnotations A renderer settings. See the description of [[RendererFirstPersonFlags]] for more info
+         */
+        constructor(humanoid, meshAnnotations) {
+            this._firstPersonOnlyLayer = VRMFirstPerson.DEFAULT_FIRSTPERSON_ONLY_LAYER;
+            this._thirdPersonOnlyLayer = VRMFirstPerson.DEFAULT_THIRDPERSON_ONLY_LAYER;
+            this._initializedLayers = false;
+            this.humanoid = humanoid;
+            this.meshAnnotations = meshAnnotations;
+        }
+        /**
+         * Copy the given {@link VRMFirstPerson} into this one.
+         * {@link humanoid} must be same as the source one.
+         * @param source The {@link VRMFirstPerson} you want to copy
+         * @returns this
+         */
+        copy(source) {
+            if (this.humanoid !== source.humanoid) {
+                throw new Error('VRMFirstPerson: humanoid must be same in order to copy');
+            }
+            this.meshAnnotations = source.meshAnnotations.map((annotation) => ({
+                meshes: annotation.meshes.concat(),
+                type: annotation.type,
+            }));
+            return this;
+        }
+        /**
+         * Returns a clone of this {@link VRMFirstPerson}.
+         * @returns Copied {@link VRMFirstPerson}
+         */
+        clone() {
+            return new VRMFirstPerson(this.humanoid, this.meshAnnotations).copy(this);
+        }
+        /**
+         * A camera layer represents `FirstPersonOnly` layer.
+         * Note that **you must call {@link setup} first before you use the layer feature** or it does not work properly.
+         *
+         * The value is {@link DEFAULT_FIRSTPERSON_ONLY_LAYER} by default but you can change the layer by specifying via {@link setup} if you prefer.
+         *
+         * @see https://vrm.dev/en/univrm/api/univrm_use_firstperson/
+         * @see https://threejs.org/docs/#api/en/core/Layers
+         */
+        get firstPersonOnlyLayer() {
+            return this._firstPersonOnlyLayer;
+        }
+        /**
+         * A camera layer represents `ThirdPersonOnly` layer.
+         * Note that **you must call {@link setup} first before you use the layer feature** or it does not work properly.
+         *
+         * The value is {@link DEFAULT_THIRDPERSON_ONLY_LAYER} by default but you can change the layer by specifying via {@link setup} if you prefer.
+         *
+         * @see https://vrm.dev/en/univrm/api/univrm_use_firstperson/
+         * @see https://threejs.org/docs/#api/en/core/Layers
+         */
+        get thirdPersonOnlyLayer() {
+            return this._thirdPersonOnlyLayer;
+        }
+        /**
+         * In this method, it assigns layers for every meshes based on mesh annotations.
+         * You must call this method first before you use the layer feature.
+         *
+         * This is an equivalent of [VRMFirstPerson.Setup](https://github.com/vrm-c/UniVRM/blob/73a5bd8fcddaa2a7a8735099a97e63c9db3e5ea0/Assets/VRM/Runtime/FirstPerson/VRMFirstPerson.cs#L295-L299) of the UniVRM.
+         *
+         * The `cameraLayer` parameter specifies which layer will be assigned for `FirstPersonOnly` / `ThirdPersonOnly`.
+         * In UniVRM, we specified those by naming each desired layer as `FIRSTPERSON_ONLY_LAYER` / `THIRDPERSON_ONLY_LAYER`
+         * but we are going to specify these layers at here since we are unable to name layers in Three.js.
+         *
+         * @param cameraLayer Specify which layer will be for `FirstPersonOnly` / `ThirdPersonOnly`.
+         */
+        setup({ firstPersonOnlyLayer = VRMFirstPerson.DEFAULT_FIRSTPERSON_ONLY_LAYER, thirdPersonOnlyLayer = VRMFirstPerson.DEFAULT_THIRDPERSON_ONLY_LAYER, } = {}) {
+            if (this._initializedLayers) {
+                return;
+            }
+            this._firstPersonOnlyLayer = firstPersonOnlyLayer;
+            this._thirdPersonOnlyLayer = thirdPersonOnlyLayer;
+            this.meshAnnotations.forEach((item) => {
+                item.meshes.forEach((mesh) => {
+                    if (item.type === 'firstPersonOnly') {
+                        mesh.layers.set(this._firstPersonOnlyLayer);
+                        mesh.traverse((child) => child.layers.set(this._firstPersonOnlyLayer));
+                    }
+                    else if (item.type === 'thirdPersonOnly') {
+                        mesh.layers.set(this._thirdPersonOnlyLayer);
+                        mesh.traverse((child) => child.layers.set(this._thirdPersonOnlyLayer));
+                    }
+                    else if (item.type === 'auto') {
+                        this._createHeadlessModel(mesh);
+                    }
+                });
+            });
+            this._initializedLayers = true;
+        }
+        _excludeTriangles(triangles, bws, skinIndex, exclude) {
+            let count = 0;
+            if (bws != null && bws.length > 0) {
+                for (let i = 0; i < triangles.length; i += 3) {
+                    const a = triangles[i];
+                    const b = triangles[i + 1];
+                    const c = triangles[i + 2];
+                    const bw0 = bws[a];
+                    const skin0 = skinIndex[a];
+                    if (bw0[0] > 0 && exclude.includes(skin0[0]))
+                        continue;
+                    if (bw0[1] > 0 && exclude.includes(skin0[1]))
+                        continue;
+                    if (bw0[2] > 0 && exclude.includes(skin0[2]))
+                        continue;
+                    if (bw0[3] > 0 && exclude.includes(skin0[3]))
+                        continue;
+                    const bw1 = bws[b];
+                    const skin1 = skinIndex[b];
+                    if (bw1[0] > 0 && exclude.includes(skin1[0]))
+                        continue;
+                    if (bw1[1] > 0 && exclude.includes(skin1[1]))
+                        continue;
+                    if (bw1[2] > 0 && exclude.includes(skin1[2]))
+                        continue;
+                    if (bw1[3] > 0 && exclude.includes(skin1[3]))
+                        continue;
+                    const bw2 = bws[c];
+                    const skin2 = skinIndex[c];
+                    if (bw2[0] > 0 && exclude.includes(skin2[0]))
+                        continue;
+                    if (bw2[1] > 0 && exclude.includes(skin2[1]))
+                        continue;
+                    if (bw2[2] > 0 && exclude.includes(skin2[2]))
+                        continue;
+                    if (bw2[3] > 0 && exclude.includes(skin2[3]))
+                        continue;
+                    triangles[count++] = a;
+                    triangles[count++] = b;
+                    triangles[count++] = c;
+                }
+            }
+            return count;
+        }
+        _createErasedMesh(src, erasingBonesIndex) {
+            const dst = new THREE__namespace.SkinnedMesh(src.geometry.clone(), src.material);
+            dst.name = `${src.name}(erase)`;
+            dst.frustumCulled = src.frustumCulled;
+            dst.layers.set(this._firstPersonOnlyLayer);
+            const geometry = dst.geometry;
+            const skinIndexAttr = geometry.getAttribute('skinIndex').array;
+            const skinIndex = [];
+            for (let i = 0; i < skinIndexAttr.length; i += 4) {
+                skinIndex.push([skinIndexAttr[i], skinIndexAttr[i + 1], skinIndexAttr[i + 2], skinIndexAttr[i + 3]]);
+            }
+            const skinWeightAttr = geometry.getAttribute('skinWeight').array;
+            const skinWeight = [];
+            for (let i = 0; i < skinWeightAttr.length; i += 4) {
+                skinWeight.push([skinWeightAttr[i], skinWeightAttr[i + 1], skinWeightAttr[i + 2], skinWeightAttr[i + 3]]);
+            }
+            const index = geometry.getIndex();
+            if (!index) {
+                throw new Error("The geometry doesn't have an index buffer");
+            }
+            const oldTriangles = Array.from(index.array);
+            const count = this._excludeTriangles(oldTriangles, skinWeight, skinIndex, erasingBonesIndex);
+            const newTriangle = [];
+            for (let i = 0; i < count; i++) {
+                newTriangle[i] = oldTriangles[i];
+            }
+            geometry.setIndex(newTriangle);
+            // mtoon material includes onBeforeRender. this is unsupported at SkinnedMesh#clone
+            if (src.onBeforeRender) {
+                dst.onBeforeRender = src.onBeforeRender;
+            }
+            dst.bind(new THREE__namespace.Skeleton(src.skeleton.bones, src.skeleton.boneInverses), new THREE__namespace.Matrix4());
+            return dst;
+        }
+        _createHeadlessModelForSkinnedMesh(parent, mesh) {
+            const eraseBoneIndexes = [];
+            mesh.skeleton.bones.forEach((bone, index) => {
+                if (this._isEraseTarget(bone))
+                    eraseBoneIndexes.push(index);
+            });
+            // Unlike UniVRM we don't copy mesh if no invisible bone was found
+            if (!eraseBoneIndexes.length) {
+                mesh.layers.enable(this._thirdPersonOnlyLayer);
+                mesh.layers.enable(this._firstPersonOnlyLayer);
+                return;
+            }
+            mesh.layers.set(this._thirdPersonOnlyLayer);
+            const newMesh = this._createErasedMesh(mesh, eraseBoneIndexes);
+            parent.add(newMesh);
+        }
+        _createHeadlessModel(node) {
+            if (node.type === 'Group') {
+                node.layers.set(this._thirdPersonOnlyLayer);
+                if (this._isEraseTarget(node)) {
+                    node.traverse((child) => child.layers.set(this._thirdPersonOnlyLayer));
+                }
+                else {
+                    const parent = new THREE__namespace.Group();
+                    parent.name = `_headless_${node.name}`;
+                    parent.layers.set(this._firstPersonOnlyLayer);
+                    node.parent.add(parent);
+                    node.children
+                        .filter((child) => child.type === 'SkinnedMesh')
+                        .forEach((child) => {
+                        const skinnedMesh = child;
+                        this._createHeadlessModelForSkinnedMesh(parent, skinnedMesh);
+                    });
+                }
+            }
+            else if (node.type === 'SkinnedMesh') {
+                const skinnedMesh = node;
+                this._createHeadlessModelForSkinnedMesh(node.parent, skinnedMesh);
+            }
+            else {
+                if (this._isEraseTarget(node)) {
+                    node.layers.set(this._thirdPersonOnlyLayer);
+                    node.traverse((child) => child.layers.set(this._thirdPersonOnlyLayer));
+                }
+            }
+        }
+        _isEraseTarget(bone) {
+            if (bone === this.humanoid.getBoneNode('head')) {
+                return true;
+            }
+            else if (!bone.parent) {
+                return false;
+            }
+            else {
+                return this._isEraseTarget(bone.parent);
+            }
+        }
+    }
+    /**
+     * A default camera layer for `FirstPersonOnly` layer.
+     *
+     * @see [[getFirstPersonOnlyLayer]]
+     */
+    VRMFirstPerson.DEFAULT_FIRSTPERSON_ONLY_LAYER = 9;
+    /**
+     * A default camera layer for `ThirdPersonOnly` layer.
+     *
+     * @see [[getThirdPersonOnlyLayer]]
+     */
     VRMFirstPerson.DEFAULT_THIRDPERSON_ONLY_LAYER = 10;
 
-    /**
-     * A plugin of GLTFLoader that imports a {@link VRMFirstPerson} from a VRM extension of a GLTF.
-     */
-    class VRMFirstPersonLoaderPlugin {
-        constructor(parser) {
-            this.parser = parser;
-        }
-        get name() {
-            // We should use the extension name instead but we have multiple plugins for an extension...
-            return 'VRMFirstPersonLoaderPlugin';
-        }
-        afterRoot(gltf) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const vrmHumanoid = gltf.userData.vrmHumanoid;
-                // explicitly distinguish null and undefined
-                // since vrmHumanoid might be null as a result
-                if (vrmHumanoid === null) {
-                    return;
-                }
-                else if (vrmHumanoid === undefined) {
-                    throw new Error('VRMFirstPersonLoaderPlugin: vrmHumanoid is undefined. VRMHumanoidLoaderPlugin have to be used first');
-                }
-                gltf.userData.vrmFirstPerson = yield this._import(gltf, vrmHumanoid);
-            });
-        }
-        /**
-         * Import a {@link VRMFirstPerson} from a VRM.
-         *
-         * @param gltf A parsed result of GLTF taken from GLTFLoader
-         * @param humanoid A {@link VRMHumanoid} instance that represents the VRM
-         */
-        _import(gltf, humanoid) {
-            return __awaiter(this, void 0, void 0, function* () {
-                if (humanoid == null) {
-                    return null;
-                }
-                const v1Result = yield this._v1Import(gltf, humanoid);
-                if (v1Result) {
-                    return v1Result;
-                }
-                const v0Result = yield this._v0Import(gltf, humanoid);
-                if (v0Result) {
-                    return v0Result;
-                }
-                return null;
-            });
-        }
-        _v1Import(gltf, humanoid) {
-            var _a, _b;
-            return __awaiter(this, void 0, void 0, function* () {
-                const json = this.parser.json;
-                // early abort if it doesn't use vrm
-                const isVRMUsed = ((_a = json.extensionsUsed) === null || _a === void 0 ? void 0 : _a.indexOf('VRMC_vrm')) !== -1;
-                if (!isVRMUsed) {
-                    return null;
-                }
-                const extension = (_b = json.extensions) === null || _b === void 0 ? void 0 : _b['VRMC_vrm'];
-                if (!extension) {
-                    return null;
-                }
-                const specVersion = extension.specVersion;
-                if (specVersion !== '1.0-beta') {
-                    return null;
-                }
-                const schemaFirstPerson = extension.firstPerson;
-                if (!schemaFirstPerson) {
-                    return null;
-                }
-                const meshAnnotations = [];
-                const nodePrimitivesMap = yield gltfExtractPrimitivesFromNodes(gltf);
-                Array.from(nodePrimitivesMap.entries()).forEach(([nodeIndex, primitives]) => {
-                    var _a;
-                    const annotation = schemaFirstPerson.meshAnnotations
-                        ? schemaFirstPerson.meshAnnotations.find((a) => a.node === nodeIndex)
-                        : undefined;
-                    meshAnnotations.push({
-                        meshes: primitives,
-                        type: (_a = annotation === null || annotation === void 0 ? void 0 : annotation.type) !== null && _a !== void 0 ? _a : 'both',
-                    });
-                });
-                return new VRMFirstPerson(humanoid, meshAnnotations);
-            });
-        }
-        _v0Import(gltf, humanoid) {
-            var _a;
-            return __awaiter(this, void 0, void 0, function* () {
-                const json = this.parser.json;
-                const vrmExt = (_a = json.extensions) === null || _a === void 0 ? void 0 : _a.VRM;
-                if (!vrmExt) {
-                    return null;
-                }
-                const schemaFirstPerson = vrmExt.firstPerson;
-                if (!schemaFirstPerson) {
-                    return null;
-                }
-                const meshAnnotations = [];
-                const nodePrimitivesMap = yield gltfExtractPrimitivesFromNodes(gltf);
-                Array.from(nodePrimitivesMap.entries()).forEach(([nodeIndex, primitives]) => {
-                    const schemaNode = json.nodes[nodeIndex];
-                    const flag = schemaFirstPerson.meshAnnotations
-                        ? schemaFirstPerson.meshAnnotations.find((a) => a.mesh === schemaNode.mesh)
-                        : undefined;
-                    meshAnnotations.push({
-                        meshes: primitives,
-                        type: this._convertV0FlagToV1Type(flag === null || flag === void 0 ? void 0 : flag.firstPersonFlag),
-                    });
-                });
-                return new VRMFirstPerson(humanoid, meshAnnotations);
-            });
-        }
-        _convertV0FlagToV1Type(flag) {
-            if (flag === 'FirstPersonOnly') {
-                return 'firstPersonOnly';
-            }
-            else if (flag === 'ThirdPersonOnly') {
-                return 'thirdPersonOnly';
-            }
-            else if (flag === 'Auto') {
-                return 'auto';
-            }
-            else {
-                return 'both';
-            }
-        }
+    /**
+     * A plugin of GLTFLoader that imports a {@link VRMFirstPerson} from a VRM extension of a GLTF.
+     */
+    class VRMFirstPersonLoaderPlugin {
+        constructor(parser) {
+            this.parser = parser;
+        }
+        get name() {
+            // We should use the extension name instead but we have multiple plugins for an extension...
+            return 'VRMFirstPersonLoaderPlugin';
+        }
+        afterRoot(gltf) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const vrmHumanoid = gltf.userData.vrmHumanoid;
+                // explicitly distinguish null and undefined
+                // since vrmHumanoid might be null as a result
+                if (vrmHumanoid === null) {
+                    return;
+                }
+                else if (vrmHumanoid === undefined) {
+                    throw new Error('VRMFirstPersonLoaderPlugin: vrmHumanoid is undefined. VRMHumanoidLoaderPlugin have to be used first');
+                }
+                gltf.userData.vrmFirstPerson = yield this._import(gltf, vrmHumanoid);
+            });
+        }
+        /**
+         * Import a {@link VRMFirstPerson} from a VRM.
+         *
+         * @param gltf A parsed result of GLTF taken from GLTFLoader
+         * @param humanoid A {@link VRMHumanoid} instance that represents the VRM
+         */
+        _import(gltf, humanoid) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (humanoid == null) {
+                    return null;
+                }
+                const v1Result = yield this._v1Import(gltf, humanoid);
+                if (v1Result) {
+                    return v1Result;
+                }
+                const v0Result = yield this._v0Import(gltf, humanoid);
+                if (v0Result) {
+                    return v0Result;
+                }
+                return null;
+            });
+        }
+        _v1Import(gltf, humanoid) {
+            var _a, _b;
+            return __awaiter(this, void 0, void 0, function* () {
+                const json = this.parser.json;
+                // early abort if it doesn't use vrm
+                const isVRMUsed = ((_a = json.extensionsUsed) === null || _a === void 0 ? void 0 : _a.indexOf('VRMC_vrm')) !== -1;
+                if (!isVRMUsed) {
+                    return null;
+                }
+                const extension = (_b = json.extensions) === null || _b === void 0 ? void 0 : _b['VRMC_vrm'];
+                if (!extension) {
+                    return null;
+                }
+                const specVersion = extension.specVersion;
+                if (specVersion !== '1.0-beta') {
+                    return null;
+                }
+                const schemaFirstPerson = extension.firstPerson;
+                if (!schemaFirstPerson) {
+                    return null;
+                }
+                const meshAnnotations = [];
+                const nodePrimitivesMap = yield gltfExtractPrimitivesFromNodes(gltf);
+                Array.from(nodePrimitivesMap.entries()).forEach(([nodeIndex, primitives]) => {
+                    var _a;
+                    const annotation = schemaFirstPerson.meshAnnotations
+                        ? schemaFirstPerson.meshAnnotations.find((a) => a.node === nodeIndex)
+                        : undefined;
+                    meshAnnotations.push({
+                        meshes: primitives,
+                        type: (_a = annotation === null || annotation === void 0 ? void 0 : annotation.type) !== null && _a !== void 0 ? _a : 'both',
+                    });
+                });
+                return new VRMFirstPerson(humanoid, meshAnnotations);
+            });
+        }
+        _v0Import(gltf, humanoid) {
+            var _a;
+            return __awaiter(this, void 0, void 0, function* () {
+                const json = this.parser.json;
+                const vrmExt = (_a = json.extensions) === null || _a === void 0 ? void 0 : _a.VRM;
+                if (!vrmExt) {
+                    return null;
+                }
+                const schemaFirstPerson = vrmExt.firstPerson;
+                if (!schemaFirstPerson) {
+                    return null;
+                }
+                const meshAnnotations = [];
+                const nodePrimitivesMap = yield gltfExtractPrimitivesFromNodes(gltf);
+                Array.from(nodePrimitivesMap.entries()).forEach(([nodeIndex, primitives]) => {
+                    const schemaNode = json.nodes[nodeIndex];
+                    const flag = schemaFirstPerson.meshAnnotations
+                        ? schemaFirstPerson.meshAnnotations.find((a) => a.mesh === schemaNode.mesh)
+                        : undefined;
+                    meshAnnotations.push({
+                        meshes: primitives,
+                        type: this._convertV0FlagToV1Type(flag === null || flag === void 0 ? void 0 : flag.firstPersonFlag),
+                    });
+                });
+                return new VRMFirstPerson(humanoid, meshAnnotations);
+            });
+        }
+        _convertV0FlagToV1Type(flag) {
+            if (flag === 'FirstPersonOnly') {
+                return 'firstPersonOnly';
+            }
+            else if (flag === 'ThirdPersonOnly') {
+                return 'thirdPersonOnly';
+            }
+            else if (flag === 'Auto') {
+                return 'auto';
+            }
+            else {
+                return 'both';
+            }
+        }
     }
 
-    /* eslint-disable @typescript-eslint/naming-convention */
-    const VRMFirstPersonMeshAnnotationType = {
-        Auto: 'auto',
-        Both: 'both',
-        ThirdPersonOnly: 'thirdPersonOnly',
-        FirstPersonOnly: 'firstPersonOnly',
+    /* eslint-disable @typescript-eslint/naming-convention */
+    const VRMFirstPersonMeshAnnotationType = {
+        Auto: 'auto',
+        Both: 'both',
+        ThirdPersonOnly: 'thirdPersonOnly',
+        FirstPersonOnly: 'firstPersonOnly',
     };
 
-    /* eslint-disable @typescript-eslint/naming-convention */
-    const VRMHumanBoneName = {
-        Hips: 'hips',
-        Spine: 'spine',
-        Chest: 'chest',
-        UpperChest: 'upperChest',
-        Neck: 'neck',
-        Head: 'head',
-        LeftEye: 'leftEye',
-        RightEye: 'rightEye',
-        Jaw: 'jaw',
-        LeftUpperLeg: 'leftUpperLeg',
-        LeftLowerLeg: 'leftLowerLeg',
-        LeftFoot: 'leftFoot',
-        LeftToes: 'leftToes',
-        RightUpperLeg: 'rightUpperLeg',
-        RightLowerLeg: 'rightLowerLeg',
-        RightFoot: 'rightFoot',
-        RightToes: 'rightToes',
-        LeftShoulder: 'leftShoulder',
-        LeftUpperArm: 'leftUpperArm',
-        LeftLowerArm: 'leftLowerArm',
-        LeftHand: 'leftHand',
-        RightShoulder: 'rightShoulder',
-        RightUpperArm: 'rightUpperArm',
-        RightLowerArm: 'rightLowerArm',
-        RightHand: 'rightHand',
-        LeftThumbProximal: 'leftThumbProximal',
-        LeftThumbIntermediate: 'leftThumbIntermediate',
-        LeftThumbDistal: 'leftThumbDistal',
-        LeftIndexProximal: 'leftIndexProximal',
-        LeftIndexIntermediate: 'leftIndexIntermediate',
-        LeftIndexDistal: 'leftIndexDistal',
-        LeftMiddleProximal: 'leftMiddleProximal',
-        LeftMiddleIntermediate: 'leftMiddleIntermediate',
-        LeftMiddleDistal: 'leftMiddleDistal',
-        LeftRingProximal: 'leftRingProximal',
-        LeftRingIntermediate: 'leftRingIntermediate',
-        LeftRingDistal: 'leftRingDistal',
-        LeftLittleProximal: 'leftLittleProximal',
-        LeftLittleIntermediate: 'leftLittleIntermediate',
-        LeftLittleDistal: 'leftLittleDistal',
-        RightThumbProximal: 'rightThumbProximal',
-        RightThumbIntermediate: 'rightThumbIntermediate',
-        RightThumbDistal: 'rightThumbDistal',
-        RightIndexProximal: 'rightIndexProximal',
-        RightIndexIntermediate: 'rightIndexIntermediate',
-        RightIndexDistal: 'rightIndexDistal',
-        RightMiddleProximal: 'rightMiddleProximal',
-        RightMiddleIntermediate: 'rightMiddleIntermediate',
-        RightMiddleDistal: 'rightMiddleDistal',
-        RightRingProximal: 'rightRingProximal',
-        RightRingIntermediate: 'rightRingIntermediate',
-        RightRingDistal: 'rightRingDistal',
-        RightLittleProximal: 'rightLittleProximal',
-        RightLittleIntermediate: 'rightLittleIntermediate',
-        RightLittleDistal: 'rightLittleDistal',
+    /* eslint-disable @typescript-eslint/naming-convention */
+    const VRMHumanBoneName = {
+        Hips: 'hips',
+        Spine: 'spine',
+        Chest: 'chest',
+        UpperChest: 'upperChest',
+        Neck: 'neck',
+        Head: 'head',
+        LeftEye: 'leftEye',
+        RightEye: 'rightEye',
+        Jaw: 'jaw',
+        LeftUpperLeg: 'leftUpperLeg',
+        LeftLowerLeg: 'leftLowerLeg',
+        LeftFoot: 'leftFoot',
+        LeftToes: 'leftToes',
+        RightUpperLeg: 'rightUpperLeg',
+        RightLowerLeg: 'rightLowerLeg',
+        RightFoot: 'rightFoot',
+        RightToes: 'rightToes',
+        LeftShoulder: 'leftShoulder',
+        LeftUpperArm: 'leftUpperArm',
+        LeftLowerArm: 'leftLowerArm',
+        LeftHand: 'leftHand',
+        RightShoulder: 'rightShoulder',
+        RightUpperArm: 'rightUpperArm',
+        RightLowerArm: 'rightLowerArm',
+        RightHand: 'rightHand',
+        LeftThumbProximal: 'leftThumbProximal',
+        LeftThumbIntermediate: 'leftThumbIntermediate',
+        LeftThumbDistal: 'leftThumbDistal',
+        LeftIndexProximal: 'leftIndexProximal',
+        LeftIndexIntermediate: 'leftIndexIntermediate',
+        LeftIndexDistal: 'leftIndexDistal',
+        LeftMiddleProximal: 'leftMiddleProximal',
+        LeftMiddleIntermediate: 'leftMiddleIntermediate',
+        LeftMiddleDistal: 'leftMiddleDistal',
+        LeftRingProximal: 'leftRingProximal',
+        LeftRingIntermediate: 'leftRingIntermediate',
+        LeftRingDistal: 'leftRingDistal',
+        LeftLittleProximal: 'leftLittleProximal',
+        LeftLittleIntermediate: 'leftLittleIntermediate',
+        LeftLittleDistal: 'leftLittleDistal',
+        RightThumbProximal: 'rightThumbProximal',
+        RightThumbIntermediate: 'rightThumbIntermediate',
+        RightThumbDistal: 'rightThumbDistal',
+        RightIndexProximal: 'rightIndexProximal',
+        RightIndexIntermediate: 'rightIndexIntermediate',
+        RightIndexDistal: 'rightIndexDistal',
+        RightMiddleProximal: 'rightMiddleProximal',
+        RightMiddleIntermediate: 'rightMiddleIntermediate',
+        RightMiddleDistal: 'rightMiddleDistal',
+        RightRingProximal: 'rightRingProximal',
+        RightRingIntermediate: 'rightRingIntermediate',
+        RightRingDistal: 'rightRingDistal',
+        RightLittleProximal: 'rightLittleProximal',
+        RightLittleIntermediate: 'rightLittleIntermediate',
+        RightLittleDistal: 'rightLittleDistal',
     };
 
-    /**
-     * A compat function for `Quaternion.invert()` / `Quaternion.inverse()`.
-     * `Quaternion.invert()` is introduced in r123 and `Quaternion.inverse()` emits a warning.
-     * We are going to use this compat for a while.
-     * @param target A target quaternion
-     */
-    function quatInvertCompat(target) {
-        if (target.invert) {
-            target.invert();
-        }
-        else {
-            target.inverse();
-        }
-        return target;
+    /**
+     * A compat function for `Quaternion.invert()` / `Quaternion.inverse()`.
+     * `Quaternion.invert()` is introduced in r123 and `Quaternion.inverse()` emits a warning.
+     * We are going to use this compat for a while.
+     * @param target A target quaternion
+     */
+    function quatInvertCompat(target) {
+        if (target.invert) {
+            target.invert();
+        }
+        else {
+            target.inverse();
+        }
+        return target;
     }
 
-    const _v3A$2 = new THREE__namespace.Vector3();
-    const _quatA$2 = new THREE__namespace.Quaternion();
-    /**
-     * A class represents a humanoid of a VRM.
-     */
-    class VRMHumanoid {
-        /**
-         * Create a new {@link VRMHumanoid}.
-         * @param boneArray 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.
-         * You might want to use {@link getPose} instead.
-         */
-        getAbsolutePose() {
-            const pose = {};
-            Object.keys(this.humanBones).forEach((vrmBoneNameString) => {
-                const vrmBoneName = vrmBoneNameString;
-                const node = this.getBoneNode(vrmBoneName);
-                // Ignore when there are no bone on the VRMHumanoid
-                if (!node) {
-                    return;
-                }
-                // Get the position / rotation from the node
-                _v3A$2.copy(node.position);
-                _quatA$2.copy(node.quaternion);
-                // Convert to raw arrays
-                pose[vrmBoneName] = {
-                    position: _v3A$2.toArray(),
-                    rotation: _quatA$2.toArray(),
-                };
-            });
-            return pose;
-        }
-        /**
-         * Return the current pose of this humanoid as a {@link VRMPose}.
-         *
-         * Each transform is a local transform relative from rest pose (T-pose).
-         */
-        getPose() {
-            const pose = {};
-            Object.keys(this.humanBones).forEach((boneNameString) => {
-                const boneName = boneNameString;
-                const node = this.getBoneNode(boneName);
-                // Ignore when there are no bone on the VRMHumanoid
-                if (!node) {
-                    return;
-                }
-                // Take a diff from restPose
-                _v3A$2.set(0, 0, 0);
-                _quatA$2.identity();
-                const restState = this.restPose[boneName];
-                if (restState === null || restState === void 0 ? void 0 : restState.position) {
-                    _v3A$2.fromArray(restState.position).negate();
-                }
-                if (restState === null || restState === void 0 ? void 0 : restState.rotation) {
-                    quatInvertCompat(_quatA$2.fromArray(restState.rotation));
-                }
-                // Get the position / rotation from the node
-                _v3A$2.add(node.position);
-                _quatA$2.premultiply(node.quaternion);
-                // Convert to raw arrays
-                pose[boneName] = {
-                    position: _v3A$2.toArray(),
-                    rotation: _quatA$2.toArray(),
-                };
-            });
-            return pose;
-        }
-        /**
-         * Let the humanoid 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 getPose}.
-         *
-         * @param poseObject A [[VRMPose]] that represents a single pose
-         */
-        setPose(poseObject) {
-            Object.entries(poseObject).forEach(([boneNameString, state]) => {
-                const boneName = boneNameString;
-                const node = this.getBoneNode(boneName);
-                // Ignore when there are no bone that is defined in the pose on the VRMHumanoid
-                if (!node) {
-                    return;
-                }
-                const restState = this.restPose[boneName];
-                if (!restState) {
-                    // It's very unlikely. Possibly a bug
-                    return;
-                }
-                // Apply the state to the actual bone
-                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));
-                    }
-                }
-                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));
-                    }
-                }
-            });
-        }
-        /**
-         * Reset the humanoid to its rest pose.
-         */
-        resetPose() {
-            Object.entries(this.restPose).forEach(([boneName, rest]) => {
-                const node = this.getBoneNode(boneName);
-                if (!node) {
-                    return;
-                }
-                if (rest === null || rest === void 0 ? void 0 : rest.position) {
-                    node.position.fromArray(rest.position);
-                }
-                if (rest === null || rest === void 0 ? void 0 : rest.rotation) {
-                    node.quaternion.fromArray(rest.rotation);
-                }
-            });
-        }
-        /**
-         * Return a bone bound to a specified {@link VRMHumanBoneName}, as a {@link VRMHumanBone}.
-         *
-         * @param name Name of the bone you want
-         */
-        getBone(name) {
-            var _a;
-            return (_a = this.humanBones[name]) !== null && _a !== void 0 ? _a : undefined;
-        }
-        /**
-         * Return a bone bound to a specified {@link VRMHumanBoneName}, as a `THREE.Object3D`.
-         *
-         * @param name Name of the bone you want
-         */
-        getBoneNode(name) {
-            var _a, _b;
-            return (_b = (_a = this.humanBones[name]) === null || _a === void 0 ? void 0 : _a.node) !== null && _b !== void 0 ? _b : null;
-        }
+    const _v3A$2 = new THREE__namespace.Vector3();
+    const _quatA$2 = new THREE__namespace.Quaternion();
+    /**
+     * A class represents a humanoid of a VRM.
+     */
+    class VRMHumanoid {
+        /**
+         * Create a new {@link VRMHumanoid}.
+         * @param boneArray 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.
+         * You might want to use {@link getPose} instead.
+         */
+        getAbsolutePose() {
+            const pose = {};
+            Object.keys(this.humanBones).forEach((vrmBoneNameString) => {
+                const vrmBoneName = vrmBoneNameString;
+                const node = this.getBoneNode(vrmBoneName);
+                // Ignore when there are no bone on the VRMHumanoid
+                if (!node) {
+                    return;
+                }
+                // Get the position / rotation from the node
+                _v3A$2.copy(node.position);
+                _quatA$2.copy(node.quaternion);
+                // Convert to raw arrays
+                pose[vrmBoneName] = {
+                    position: _v3A$2.toArray(),
+                    rotation: _quatA$2.toArray(),
+                };
+            });
+            return pose;
+        }
+        /**
+         * Return the current pose of this humanoid as a {@link VRMPose}.
+         *
+         * Each transform is a local transform relative from rest pose (T-pose).
+         */
+        getPose() {
+            const pose = {};
+            Object.keys(this.humanBones).forEach((boneNameString) => {
+                const boneName = boneNameString;
+                const node = this.getBoneNode(boneName);
+                // Ignore when there are no bone on the VRMHumanoid
+                if (!node) {
+                    return;
+                }
+                // Take a diff from restPose
+                _v3A$2.set(0, 0, 0);
+                _quatA$2.identity();
+                const restState = this.restPose[boneName];
+                if (restState === null || restState === void 0 ? void 0 : restState.position) {
+                    _v3A$2.fromArray(restState.position).negate();
+                }
+                if (restState === null || restState === void 0 ? void 0 : restState.rotation) {
+                    quatInvertCompat(_quatA$2.fromArray(restState.rotation));
+                }
+                // Get the position / rotation from the node
+                _v3A$2.add(node.position);
+                _quatA$2.premultiply(node.quaternion);
+                // Convert to raw arrays
+                pose[boneName] = {
+                    position: _v3A$2.toArray(),
+                    rotation: _quatA$2.toArray(),
+                };
+            });
+            return pose;
+        }
+        /**
+         * Let the humanoid 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 getPose}.
+         *
+         * @param poseObject A [[VRMPose]] that represents a single pose
+         */
+        setPose(poseObject) {
+            Object.entries(poseObject).forEach(([boneNameString, state]) => {
+                const boneName = boneNameString;
+                const node = this.getBoneNode(boneName);
+                // Ignore when there are no bone that is defined in the pose on the VRMHumanoid
+                if (!node) {
+                    return;
+                }
+                const restState = this.restPose[boneName];
+                if (!restState) {
+                    // It's very unlikely. Possibly a bug
+                    return;
+                }
+                // Apply the state to the actual bone
+                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));
+                    }
+                }
+                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));
+                    }
+                }
+            });
+        }
+        /**
+         * Reset the humanoid to its rest pose.
+         */
+        resetPose() {
+            Object.entries(this.restPose).forEach(([boneName, rest]) => {
+                const node = this.getBoneNode(boneName);
+                if (!node) {
+                    return;
+                }
+                if (rest === null || rest === void 0 ? void 0 : rest.position) {
+                    node.position.fromArray(rest.position);
+                }
+                if (rest === null || rest === void 0 ? void 0 : rest.rotation) {
+                    node.quaternion.fromArray(rest.rotation);
+                }
+            });
+        }
+        /**
+         * Return a bone bound to a specified {@link VRMHumanBoneName}, as a {@link VRMHumanBone}.
+         *
+         * @param name Name of the bone you want
+         */
+        getBone(name) {
+            var _a;
+            return (_a = this.humanBones[name]) !== null && _a !== void 0 ? _a : undefined;
+        }
+        /**
+         * Return a bone bound to a specified {@link VRMHumanBoneName}, as a `THREE.Object3D`.
+         *
+         * @param name Name of the bone you want
+         */
+        getBoneNode(name) {
+            var _a, _b;
+            return (_b = (_a = this.humanBones[name]) === null || _a === void 0 ? void 0 : _a.node) !== null && _b !== void 0 ? _b : null;
+        }
     }
 
-    /* eslint-disable @typescript-eslint/naming-convention */
-    const VRMRequiredHumanBoneName = {
-        Hips: 'hips',
-        Spine: 'spine',
-        Head: 'head',
-        LeftUpperLeg: 'leftUpperLeg',
-        LeftLowerLeg: 'leftLowerLeg',
-        LeftFoot: 'leftFoot',
-        RightUpperLeg: 'rightUpperLeg',
-        RightLowerLeg: 'rightLowerLeg',
-        RightFoot: 'rightFoot',
-        LeftUpperArm: 'leftUpperArm',
-        LeftLowerArm: 'leftLowerArm',
-        LeftHand: 'leftHand',
-        RightUpperArm: 'rightUpperArm',
-        RightLowerArm: 'rightLowerArm',
-        RightHand: 'rightHand',
+    /* eslint-disable @typescript-eslint/naming-convention */
+    const VRMRequiredHumanBoneName = {
+        Hips: 'hips',
+        Spine: 'spine',
+        Head: 'head',
+        LeftUpperLeg: 'leftUpperLeg',
+        LeftLowerLeg: 'leftLowerLeg',
+        LeftFoot: 'leftFoot',
+        RightUpperLeg: 'rightUpperLeg',
+        RightLowerLeg: 'rightLowerLeg',
+        RightFoot: 'rightFoot',
+        LeftUpperArm: 'leftUpperArm',
+        LeftLowerArm: 'leftLowerArm',
+        LeftHand: 'leftHand',
+        RightUpperArm: 'rightUpperArm',
+        RightLowerArm: 'rightLowerArm',
+        RightHand: 'rightHand',
     };
 
-    /**
-     * A plugin of GLTFLoader that imports a {@link VRMHumanoid} from a VRM extension of a GLTF.
-     */
-    class VRMHumanoidLoaderPlugin {
-        constructor(parser) {
-            this.parser = parser;
-        }
-        get name() {
-            // We should use the extension name instead but we have multiple plugins for an extension...
-            return 'VRMHumanoidLoaderPlugin';
-        }
-        afterRoot(gltf) {
-            return __awaiter(this, void 0, void 0, function* () {
-                gltf.userData.vrmHumanoid = yield this._import(gltf);
-            });
-        }
-        /**
-         * Import a {@link VRMHumanoid} from a VRM.
-         *
-         * @param gltf A parsed result of GLTF taken from GLTFLoader
-         */
-        _import(gltf) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const v1Result = yield this._v1Import(gltf);
-                if (v1Result) {
-                    return v1Result;
-                }
-                const v0Result = yield this._v0Import(gltf);
-                if (v0Result) {
-                    return v0Result;
-                }
-                return null;
-            });
-        }
-        _v1Import(gltf) {
-            var _a, _b;
-            return __awaiter(this, void 0, void 0, function* () {
-                const json = this.parser.json;
-                // early abort if it doesn't use vrm
-                const isVRMUsed = ((_a = json.extensionsUsed) === null || _a === void 0 ? void 0 : _a.indexOf('VRMC_vrm')) !== -1;
-                if (!isVRMUsed) {
-                    return null;
-                }
-                const extension = (_b = json.extensions) === null || _b === void 0 ? void 0 : _b['VRMC_vrm'];
-                if (!extension) {
-                    return null;
-                }
-                const specVersion = extension.specVersion;
-                if (specVersion !== '1.0-beta') {
-                    return null;
-                }
-                const schemaHumanoid = extension.humanoid;
-                if (!schemaHumanoid) {
-                    return 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;
-                        const index = schemaHumanBone.node;
-                        const node = yield this.parser.getDependency('node', index);
-                        // if the specified node does not exist, emit a warning
-                        if (node == null) {
-                            console.warn(`A glTF node bound to the humanoid bone ${boneName} (index = ${index}) does not exist`);
-                            return;
-                        }
-                        // set to the `humanBones`
-                        humanBones[boneName] = { node };
-                    })));
-                }
-                return new VRMHumanoid(this._ensureRequiredBonesExist(humanBones));
-            });
-        }
-        _v0Import(gltf) {
-            var _a;
-            return __awaiter(this, void 0, void 0, function* () {
-                const json = this.parser.json;
-                const vrmExt = (_a = json.extensions) === null || _a === void 0 ? void 0 : _a.VRM;
-                if (!vrmExt) {
-                    return null;
-                }
-                const schemaHumanoid = vrmExt.humanoid;
-                if (!schemaHumanoid) {
-                    return null;
-                }
-                const humanBones = {};
-                if (schemaHumanoid.humanBones != null) {
-                    yield Promise.all(schemaHumanoid.humanBones.map((bone) => __awaiter(this, void 0, void 0, function* () {
-                        const boneName = bone.bone;
-                        const index = bone.node;
-                        if (boneName == null || index == null) {
-                            return;
-                        }
-                        const node = yield this.parser.getDependency('node', index);
-                        // if the specified node does not exist, emit a warning
-                        if (node == null) {
-                            console.warn(`A glTF node bound to the humanoid bone ${boneName} (index = ${index}) does not exist`);
-                            return;
-                        }
-                        // 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.`);
-                            return;
-                        }
-                        // set to the `humanBones`
-                        humanBones[boneName] = { node };
-                    })));
-                }
-                return new VRMHumanoid(this._ensureRequiredBonesExist(humanBones));
-            });
-        }
-        /**
-         * Ensure required bones exist in given human bones.
-         * @param humanBones Human bones
-         * @returns Human bones, no longer partial!
-         */
-        _ensureRequiredBonesExist(humanBones) {
-            // ensure required bones exist
-            const missingRequiredBones = Object.values(VRMRequiredHumanBoneName).filter((requiredBoneName) => humanBones[requiredBoneName] == null);
-            // throw an error if there are missing bones
-            if (missingRequiredBones.length > 0) {
-                throw new Error(`VRMHumanoidLoaderPlugin: These humanoid bones are required but not exist: ${missingRequiredBones.join(', ')}`);
-            }
-            return humanBones;
-        }
+    /**
+     * A plugin of GLTFLoader that imports a {@link VRMHumanoid} from a VRM extension of a GLTF.
+     */
+    class VRMHumanoidLoaderPlugin {
+        constructor(parser) {
+            this.parser = parser;
+        }
+        get name() {
+            // We should use the extension name instead but we have multiple plugins for an extension...
+            return 'VRMHumanoidLoaderPlugin';
+        }
+        afterRoot(gltf) {
+            return __awaiter(this, void 0, void 0, function* () {
+                gltf.userData.vrmHumanoid = yield this._import(gltf);
+            });
+        }
+        /**
+         * Import a {@link VRMHumanoid} from a VRM.
+         *
+         * @param gltf A parsed result of GLTF taken from GLTFLoader
+         */
+        _import(gltf) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const v1Result = yield this._v1Import(gltf);
+                if (v1Result) {
+                    return v1Result;
+                }
+                const v0Result = yield this._v0Import(gltf);
+                if (v0Result) {
+                    return v0Result;
+                }
+                return null;
+            });
+        }
+        _v1Import(gltf) {
+            var _a, _b;
+            return __awaiter(this, void 0, void 0, function* () {
+                const json = this.parser.json;
+                // early abort if it doesn't use vrm
+                const isVRMUsed = ((_a = json.extensionsUsed) === null || _a === void 0 ? void 0 : _a.indexOf('VRMC_vrm')) !== -1;
+                if (!isVRMUsed) {
+                    return null;
+                }
+                const extension = (_b = json.extensions) === null || _b === void 0 ? void 0 : _b['VRMC_vrm'];
+                if (!extension) {
+                    return null;
+                }
+                const specVersion = extension.specVersion;
+                if (specVersion !== '1.0-beta') {
+                    return null;
+                }
+                const schemaHumanoid = extension.humanoid;
+                if (!schemaHumanoid) {
+                    return 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;
+                        const index = schemaHumanBone.node;
+                        const node = yield this.parser.getDependency('node', index);
+                        // if the specified node does not exist, emit a warning
+                        if (node == null) {
+                            console.warn(`A glTF node bound to the humanoid bone ${boneName} (index = ${index}) does not exist`);
+                            return;
+                        }
+                        // set to the `humanBones`
+                        humanBones[boneName] = { node };
+                    })));
+                }
+                return new VRMHumanoid(this._ensureRequiredBonesExist(humanBones));
+            });
+        }
+        _v0Import(gltf) {
+            var _a;
+            return __awaiter(this, void 0, void 0, function* () {
+                const json = this.parser.json;
+                const vrmExt = (_a = json.extensions) === null || _a === void 0 ? void 0 : _a.VRM;
+                if (!vrmExt) {
+                    return null;
+                }
+                const schemaHumanoid = vrmExt.humanoid;
+                if (!schemaHumanoid) {
+                    return null;
+                }
+                const humanBones = {};
+                if (schemaHumanoid.humanBones != null) {
+                    yield Promise.all(schemaHumanoid.humanBones.map((bone) => __awaiter(this, void 0, void 0, function* () {
+                        const boneName = bone.bone;
+                        const index = bone.node;
+                        if (boneName == null || index == null) {
+                            return;
+                        }
+                        const node = yield this.parser.getDependency('node', index);
+                        // if the specified node does not exist, emit a warning
+                        if (node == null) {
+                            console.warn(`A glTF node bound to the humanoid bone ${boneName} (index = ${index}) does not exist`);
+                            return;
+                        }
+                        // 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.`);
+                            return;
+                        }
+                        // set to the `humanBones`
+                        humanBones[boneName] = { node };
+                    })));
+                }
+                return new VRMHumanoid(this._ensureRequiredBonesExist(humanBones));
+            });
+        }
+        /**
+         * Ensure required bones exist in given human bones.
+         * @param humanBones Human bones
+         * @returns Human bones, no longer partial!
+         */
+        _ensureRequiredBonesExist(humanBones) {
+            // ensure required bones exist
+            const missingRequiredBones = Object.values(VRMRequiredHumanBoneName).filter((requiredBoneName) => humanBones[requiredBoneName] == null);
+            // throw an error if there are missing bones
+            if (missingRequiredBones.length > 0) {
+                throw new Error(`VRMHumanoidLoaderPlugin: These humanoid bones are required but not exist: ${missingRequiredBones.join(', ')}`);
+            }
+            return humanBones;
+        }
     }
 
-    class FanBufferGeometry extends THREE__namespace.BufferGeometry {
-        constructor() {
-            super();
-            this._currentTheta = 0;
-            this._currentRadius = 0;
-            this.theta = 0.0;
-            this.radius = 0.0;
-            this._currentTheta = 0.0;
-            this._currentRadius = 0.0;
-            this._attrPos = new THREE__namespace.BufferAttribute(new Float32Array(65 * 3), 3);
-            this.setAttribute('position', this._attrPos);
-            this._attrIndex = new THREE__namespace.BufferAttribute(new Uint16Array(3 * 63), 1);
-            this.setIndex(this._attrIndex);
-            this._buildIndex();
-            this.update();
-        }
-        update() {
-            let shouldUpdateGeometry = false;
-            if (this._currentTheta !== this.theta) {
-                this._currentTheta = this.theta;
-                shouldUpdateGeometry = true;
-            }
-            if (this._currentRadius !== this.radius) {
-                this._currentRadius = this.radius;
-                shouldUpdateGeometry = true;
-            }
-            if (shouldUpdateGeometry) {
-                this._buildPosition();
-            }
-        }
-        _buildPosition() {
-            this._attrPos.setXYZ(0, 0.0, 0.0, 0.0);
-            for (let i = 0; i < 64; i++) {
-                const t = (i / 63.0) * this._currentTheta;
-                this._attrPos.setXYZ(i + 1, this._currentRadius * Math.sin(t), 0.0, this._currentRadius * Math.cos(t));
-            }
-            this._attrPos.needsUpdate = true;
-        }
-        _buildIndex() {
-            for (let i = 0; i < 63; i++) {
-                this._attrIndex.setXYZ(i * 3, 0, i + 1, i + 2);
-            }
-            this._attrIndex.needsUpdate = true;
-        }
+    class FanBufferGeometry extends THREE__namespace.BufferGeometry {
+        constructor() {
+            super();
+            this._currentTheta = 0;
+            this._currentRadius = 0;
+            this.theta = 0.0;
+            this.radius = 0.0;
+            this._currentTheta = 0.0;
+            this._currentRadius = 0.0;
+            this._attrPos = new THREE__namespace.BufferAttribute(new Float32Array(65 * 3), 3);
+            this.setAttribute('position', this._attrPos);
+            this._attrIndex = new THREE__namespace.BufferAttribute(new Uint16Array(3 * 63), 1);
+            this.setIndex(this._attrIndex);
+            this._buildIndex();
+            this.update();
+        }
+        update() {
+            let shouldUpdateGeometry = false;
+            if (this._currentTheta !== this.theta) {
+                this._currentTheta = this.theta;
+                shouldUpdateGeometry = true;
+            }
+            if (this._currentRadius !== this.radius) {
+                this._currentRadius = this.radius;
+                shouldUpdateGeometry = true;
+            }
+            if (shouldUpdateGeometry) {
+                this._buildPosition();
+            }
+        }
+        _buildPosition() {
+            this._attrPos.setXYZ(0, 0.0, 0.0, 0.0);
+            for (let i = 0; i < 64; i++) {
+                const t = (i / 63.0) * this._currentTheta;
+                this._attrPos.setXYZ(i + 1, this._currentRadius * Math.sin(t), 0.0, this._currentRadius * Math.cos(t));
+            }
+            this._attrPos.needsUpdate = true;
+        }
+        _buildIndex() {
+            for (let i = 0; i < 63; i++) {
+                this._attrIndex.setXYZ(i * 3, 0, i + 1, i + 2);
+            }
+            this._attrIndex.needsUpdate = true;
+        }
     }
 
-    class LineAndSphereBufferGeometry extends THREE__namespace.BufferGeometry {
-        constructor() {
-            super();
-            this.radius = 0.0;
-            this._currentRadius = 0.0;
-            this.tail = new THREE__namespace.Vector3();
-            this._currentTail = new THREE__namespace.Vector3();
-            this._attrPos = new THREE__namespace.BufferAttribute(new Float32Array(294), 3);
-            this.setAttribute('position', this._attrPos);
-            this._attrIndex = new THREE__namespace.BufferAttribute(new Uint16Array(194), 1);
-            this.setIndex(this._attrIndex);
-            this._buildIndex();
-            this.update();
-        }
-        update() {
-            let shouldUpdateGeometry = false;
-            if (this._currentRadius !== this.radius) {
-                this._currentRadius = this.radius;
-                shouldUpdateGeometry = true;
-            }
-            if (!this._currentTail.equals(this.tail)) {
-                this._currentTail.copy(this.tail);
-                shouldUpdateGeometry = true;
-            }
-            if (shouldUpdateGeometry) {
-                this._buildPosition();
-            }
-        }
-        _buildPosition() {
-            for (let i = 0; i < 32; i++) {
-                const t = (i / 16.0) * Math.PI;
-                this._attrPos.setXYZ(i, Math.cos(t), Math.sin(t), 0.0);
-                this._attrPos.setXYZ(32 + i, 0.0, Math.cos(t), Math.sin(t));
-                this._attrPos.setXYZ(64 + i, Math.sin(t), 0.0, Math.cos(t));
-            }
-            this.scale(this._currentRadius, this._currentRadius, this._currentRadius);
-            this.translate(this._currentTail.x, this._currentTail.y, this._currentTail.z);
-            this._attrPos.setXYZ(96, 0, 0, 0);
-            this._attrPos.setXYZ(97, this._currentTail.x, this._currentTail.y, this._currentTail.z);
-            this._attrPos.needsUpdate = true;
-        }
-        _buildIndex() {
-            for (let i = 0; i < 32; i++) {
-                const i1 = (i + 1) % 32;
-                this._attrIndex.setXY(i * 2, i, i1);
-                this._attrIndex.setXY(64 + i * 2, 32 + i, 32 + i1);
-                this._attrIndex.setXY(128 + i * 2, 64 + i, 64 + i1);
-            }
-            this._attrIndex.setXY(192, 96, 97);
-            this._attrIndex.needsUpdate = true;
-        }
+    class LineAndSphereBufferGeometry extends THREE__namespace.BufferGeometry {
+        constructor() {
+            super();
+            this.radius = 0.0;
+            this._currentRadius = 0.0;
+            this.tail = new THREE__namespace.Vector3();
+            this._currentTail = new THREE__namespace.Vector3();
+            this._attrPos = new THREE__namespace.BufferAttribute(new Float32Array(294), 3);
+            this.setAttribute('position', this._attrPos);
+            this._attrIndex = new THREE__namespace.BufferAttribute(new Uint16Array(194), 1);
+            this.setIndex(this._attrIndex);
+            this._buildIndex();
+            this.update();
+        }
+        update() {
+            let shouldUpdateGeometry = false;
+            if (this._currentRadius !== this.radius) {
+                this._currentRadius = this.radius;
+                shouldUpdateGeometry = true;
+            }
+            if (!this._currentTail.equals(this.tail)) {
+                this._currentTail.copy(this.tail);
+                shouldUpdateGeometry = true;
+            }
+            if (shouldUpdateGeometry) {
+                this._buildPosition();
+            }
+        }
+        _buildPosition() {
+            for (let i = 0; i < 32; i++) {
+                const t = (i / 16.0) * Math.PI;
+                this._attrPos.setXYZ(i, Math.cos(t), Math.sin(t), 0.0);
+                this._attrPos.setXYZ(32 + i, 0.0, Math.cos(t), Math.sin(t));
+                this._attrPos.setXYZ(64 + i, Math.sin(t), 0.0, Math.cos(t));
+            }
+            this.scale(this._currentRadius, this._currentRadius, this._currentRadius);
+            this.translate(this._currentTail.x, this._currentTail.y, this._currentTail.z);
+            this._attrPos.setXYZ(96, 0, 0, 0);
+            this._attrPos.setXYZ(97, this._currentTail.x, this._currentTail.y, this._currentTail.z);
+            this._attrPos.needsUpdate = true;
+        }
+        _buildIndex() {
+            for (let i = 0; i < 32; i++) {
+                const i1 = (i + 1) % 32;
+                this._attrIndex.setXY(i * 2, i, i1);
+                this._attrIndex.setXY(64 + i * 2, 32 + i, 32 + i1);
+                this._attrIndex.setXY(128 + i * 2, 64 + i, 64 + i1);
+            }
+            this._attrIndex.setXY(192, 96, 97);
+            this._attrIndex.needsUpdate = true;
+        }
     }
 
-    const _quatA$1 = new THREE__namespace.Quaternion();
-    const _quatB$1 = new THREE__namespace.Quaternion();
-    const _v3A$1 = new THREE__namespace.Vector3();
-    const _v3B$1 = new THREE__namespace.Vector3();
-    const SQRT_2_OVER_2 = Math.sqrt(2.0) / 2.0;
-    const QUAT_XY_CW90 = new THREE__namespace.Quaternion(0, 0, -SQRT_2_OVER_2, SQRT_2_OVER_2);
-    const VEC3_POSITIVE_Y = new THREE__namespace.Vector3(0.0, 1.0, 0.0);
-    class VRMLookAtHelper extends THREE__namespace.Group {
-        constructor(lookAt) {
-            super();
-            this.matrixAutoUpdate = false;
-            this.vrmLookAt = lookAt;
-            {
-                const geometry = new FanBufferGeometry();
-                geometry.radius = 0.5;
-                const material = new THREE__namespace.MeshBasicMaterial({
-                    color: 0x00ff00,
-                    transparent: true,
-                    opacity: 0.5,
-                    side: THREE__namespace.DoubleSide,
-                    depthTest: false,
-                    depthWrite: false,
-                });
-                this._meshPitch = new THREE__namespace.Mesh(geometry, material);
-                this.add(this._meshPitch);
-            }
-            {
-                const geometry = new FanBufferGeometry();
-                geometry.radius = 0.5;
-                const material = new THREE__namespace.MeshBasicMaterial({
-                    color: 0xff0000,
-                    transparent: true,
-                    opacity: 0.5,
-                    side: THREE__namespace.DoubleSide,
-                    depthTest: false,
-                    depthWrite: false,
-                });
-                this._meshYaw = new THREE__namespace.Mesh(geometry, material);
-                this.add(this._meshYaw);
-            }
-            {
-                const geometry = new LineAndSphereBufferGeometry();
-                geometry.radius = 0.1;
-                const material = new THREE__namespace.LineBasicMaterial({
-                    color: 0xffffff,
-                    depthTest: false,
-                    depthWrite: false,
-                });
-                this._lineTarget = new THREE__namespace.LineSegments(geometry, material);
-                this._lineTarget.frustumCulled = false;
-                this.add(this._lineTarget);
-            }
-        }
-        dispose() {
-            this._meshYaw.geometry.dispose();
-            this._meshYaw.material.dispose();
-            this._meshPitch.geometry.dispose();
-            this._meshPitch.material.dispose();
-            this._lineTarget.geometry.dispose();
-            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;
-            this._meshYaw.geometry.theta = yaw;
-            this._meshYaw.geometry.update();
-            this._meshYaw.position.copy(_v3A$1);
-            this._meshYaw.quaternion.copy(_quatA$1);
-            this._meshPitch.geometry.theta = pitch;
-            this._meshPitch.geometry.update();
-            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.multiply(QUAT_XY_CW90);
-            const target = this.vrmLookAt.target;
-            if (target != null) {
-                target.getWorldPosition(_v3B$1).sub(_v3A$1);
-                this._lineTarget.geometry.tail.copy(_v3B$1);
-                this._lineTarget.geometry.update();
-                this._lineTarget.position.copy(_v3A$1);
-            }
-            super.updateMatrixWorld(force);
-        }
+    const _quatA$1 = new THREE__namespace.Quaternion();
+    const _quatB$1 = new THREE__namespace.Quaternion();
+    const _v3A$1 = new THREE__namespace.Vector3();
+    const _v3B$1 = new THREE__namespace.Vector3();
+    const SQRT_2_OVER_2 = Math.sqrt(2.0) / 2.0;
+    const QUAT_XY_CW90 = new THREE__namespace.Quaternion(0, 0, -SQRT_2_OVER_2, SQRT_2_OVER_2);
+    const VEC3_POSITIVE_Y = new THREE__namespace.Vector3(0.0, 1.0, 0.0);
+    class VRMLookAtHelper extends THREE__namespace.Group {
+        constructor(lookAt) {
+            super();
+            this.matrixAutoUpdate = false;
+            this.vrmLookAt = lookAt;
+            {
+                const geometry = new FanBufferGeometry();
+                geometry.radius = 0.5;
+                const material = new THREE__namespace.MeshBasicMaterial({
+                    color: 0x00ff00,
+                    transparent: true,
+                    opacity: 0.5,
+                    side: THREE__namespace.DoubleSide,
+                    depthTest: false,
+                    depthWrite: false,
+                });
+                this._meshPitch = new THREE__namespace.Mesh(geometry, material);
+                this.add(this._meshPitch);
+            }
+            {
+                const geometry = new FanBufferGeometry();
+                geometry.radius = 0.5;
+                const material = new THREE__namespace.MeshBasicMaterial({
+                    color: 0xff0000,
+                    transparent: true,
+                    opacity: 0.5,
+                    side: THREE__namespace.DoubleSide,
+                    depthTest: false,
+                    depthWrite: false,
+                });
+                this._meshYaw = new THREE__namespace.Mesh(geometry, material);
+                this.add(this._meshYaw);
+            }
+            {
+                const geometry = new LineAndSphereBufferGeometry();
+                geometry.radius = 0.1;
+                const material = new THREE__namespace.LineBasicMaterial({
+                    color: 0xffffff,
+                    depthTest: false,
+                    depthWrite: false,
+                });
+                this._lineTarget = new THREE__namespace.LineSegments(geometry, material);
+                this._lineTarget.frustumCulled = false;
+                this.add(this._lineTarget);
+            }
+        }
+        dispose() {
+            this._meshYaw.geometry.dispose();
+            this._meshYaw.material.dispose();
+            this._meshPitch.geometry.dispose();
+            this._meshPitch.material.dispose();
+            this._lineTarget.geometry.dispose();
+            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;
+            this._meshYaw.geometry.theta = yaw;
+            this._meshYaw.geometry.update();
+            this._meshYaw.position.copy(_v3A$1);
+            this._meshYaw.quaternion.copy(_quatA$1);
+            this._meshPitch.geometry.theta = pitch;
+            this._meshPitch.geometry.update();
+            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.multiply(QUAT_XY_CW90);
+            const target = this.vrmLookAt.target;
+            if (target != null) {
+                target.getWorldPosition(_v3B$1).sub(_v3A$1);
+                this._lineTarget.geometry.tail.copy(_v3B$1);
+                this._lineTarget.geometry.update();
+                this._lineTarget.position.copy(_v3A$1);
+            }
+            super.updateMatrixWorld(force);
+        }
     }
 
-    const _position = new THREE__namespace.Vector3();
-    const _scale = new THREE__namespace.Vector3();
-    /**
-     * Extract world rotation of an object from its world space matrix, in cheaper way.
-     *
-     * @param object The object
-     * @param out Target vector
-     */
-    function getWorldQuaternionLite(object, out) {
-        object.matrixWorld.decompose(_position, out, _scale);
-        return out;
+    const _position = new THREE__namespace.Vector3();
+    const _scale = new THREE__namespace.Vector3();
+    /**
+     * Extract world rotation of an object from its world space matrix, in cheaper way.
+     *
+     * @param object The object
+     * @param out Target vector
+     */
+    function getWorldQuaternionLite(object, out) {
+        object.matrixWorld.decompose(_position, out, _scale);
+        return out;
     }
 
-    const _v3A = new THREE__namespace.Vector3();
-    const _v3B = new THREE__namespace.Vector3();
-    const _v3C = new THREE__namespace.Vector3();
-    const _quatA = new THREE__namespace.Quaternion();
-    const _quatB = new THREE__namespace.Quaternion();
-    /**
-     * A class controls eye gaze movements of a VRM.
-     */
-    class VRMLookAt {
-        /**
-         * Create a new {@link VRMLookAt}.
-         *
-         * @param humanoid A {@link VRMHumanoid}
-         * @param applier A {@link VRMLookAtApplier}
-         */
-        constructor(humanoid, applier) {
-            /**
-             * The origin of LookAt. Position offset from the head bone.
-             */
-            this.offsetFromHeadBone = new THREE__namespace.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}
-             */
-            this.autoUpdate = true;
-            /**
-             * The front direction of the face.
-             * Intended to be used for VRM 0.0 compat (VRM 0.0 models are facing Z- instead of Z+).
-             * You usually don't want to touch this.
-             */
-            this.faceFront = new THREE__namespace.Vector3(0.0, 0.0, 1.0);
-            this._euler = new THREE__namespace.Euler(0.0, 0.0, 0.0, VRMLookAt.EULER_ORDER);
-            this.humanoid = humanoid;
-            this.applier = applier;
-        }
-        /**
-         * Its current euler direction.
-         */
-        get euler() {
-            return this._euler.clone();
-        }
-        /**
-         * Copy the given {@link VRMLookAt} into this one.
-         * {@link humanoid} must be same as the source one.
-         * {@link applier} will reference the same instance as the source one.
-         * @param source The {@link VRMLookAt} you want to copy
-         * @returns this
-         */
-        copy(source) {
-            if (this.humanoid !== source.humanoid) {
-                throw new Error('VRMLookAt: humanoid must be same in order to copy');
-            }
-            this.offsetFromHeadBone.copy(source.offsetFromHeadBone);
-            this.applier = source.applier;
-            this.autoUpdate = source.autoUpdate;
-            this.target = source.target;
-            this.faceFront.copy(source.faceFront);
-            return this;
-        }
-        /**
-         * Returns a clone of this {@link VRMLookAt}.
-         * Note that {@link humanoid} and {@link applier} will reference the same instance as this one.
-         * @returns Copied {@link VRMLookAt}
-         */
-        clone() {
-            return new VRMLookAt(this.humanoid, this.applier).copy(this);
-        }
-        /**
-         * Reset the lookAt direction to initial direction.
-         */
-        reset() {
-            this._euler.set(0.0, 0.0, 0.0);
-            this.applier.lookAt(this._euler);
-        }
-        /**
-         * Get its head position in world coordinate.
-         *
-         * @param target A target `THREE.Vector3`
-         */
-        getLookAtWorldPosition(target) {
-            const head = this.humanoid.getBoneNode('head');
-            return target.copy(this.offsetFromHeadBone).applyMatrix4(head.matrixWorld);
-        }
-        /**
-         * Get its LookAt orientation in world coordinate.
-         *
-         * @param target A target `THREE.Vector3`
-         */
-        getLookAtWorldQuaternion(target) {
-            const head = this.humanoid.getBoneNode('head');
-            return getWorldQuaternionLite(head, target);
-        }
-        /**
-         * 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);
-        }
-        /**
-         * Set its LookAt position.
-         * Note that its result will be instantly overwritten if {@link VRMLookAtHead.autoUpdate} is enabled.
-         *
-         * @param position A target position
-         */
-        lookAt(position) {
-            this._calcEuler(this._euler, position);
-            this.applier.lookAt(this._euler);
-        }
-        /**
-         * Update the VRMLookAtHead.
-         * If {@link VRMLookAtHead.autoUpdate} is disabled, it will do nothing.
-         *
-         * @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) {
-                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;
-        }
-    }
+    const _v3A = new THREE__namespace.Vector3();
+    const _v3B = new THREE__namespace.Vector3();
+    const _v3C = new THREE__namespace.Vector3();
+    const _quatA = new THREE__namespace.Quaternion();
+    const _quatB = new THREE__namespace.Quaternion();
+    /**
+     * A class controls eye gaze movements of a VRM.
+     */
+    class VRMLookAt {
+        /**
+         * Create a new {@link VRMLookAt}.
+         *
+         * @param humanoid A {@link VRMHumanoid}
+         * @param applier A {@link VRMLookAtApplier}
+         */
+        constructor(humanoid, applier) {
+            /**
+             * The origin of LookAt. Position offset from the head bone.
+             */
+            this.offsetFromHeadBone = new THREE__namespace.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}
+             */
+            this.autoUpdate = true;
+            /**
+             * The front direction of the face.
+             * Intended to be used for VRM 0.0 compat (VRM 0.0 models are facing Z- instead of Z+).
+             * You usually don't want to touch this.
+             */
+            this.faceFront = new THREE__namespace.Vector3(0.0, 0.0, 1.0);
+            this._euler = new THREE__namespace.Euler(0.0, 0.0, 0.0, VRMLookAt.EULER_ORDER);
+            this.humanoid = humanoid;
+            this.applier = applier;
+        }
+        /**
+         * Its current euler direction.
+         */
+        get euler() {
+            return this._euler.clone();
+        }
+        /**
+         * Copy the given {@link VRMLookAt} into this one.
+         * {@link humanoid} must be same as the source one.
+         * {@link applier} will reference the same instance as the source one.
+         * @param source The {@link VRMLookAt} you want to copy
+         * @returns this
+         */
+        copy(source) {
+            if (this.humanoid !== source.humanoid) {
+                throw new Error('VRMLookAt: humanoid must be same in order to copy');
+            }
+            this.offsetFromHeadBone.copy(source.offsetFromHeadBone);
+            this.applier = source.applier;
+            this.autoUpdate = source.autoUpdate;
+            this.target = source.target;
+            this.faceFront.copy(source.faceFront);
+            return this;
+        }
+        /**
+         * Returns a clone of this {@link VRMLookAt}.
+         * Note that {@link humanoid} and {@link applier} will reference the same instance as this one.
+         * @returns Copied {@link VRMLookAt}
+         */
+        clone() {
+            return new VRMLookAt(this.humanoid, this.applier).copy(this);
+        }
+        /**
+         * Reset the lookAt direction to initial direction.
+         */
+        reset() {
+            this._euler.set(0.0, 0.0, 0.0);
+            this.applier.lookAt(this._euler);
+        }
+        /**
+         * Get its head position in world coordinate.
+         *
+         * @param target A target `THREE.Vector3`
+         */
+        getLookAtWorldPosition(target) {
+            const head = this.humanoid.getBoneNode('head');
+            return target.copy(this.offsetFromHeadBone).applyMatrix4(head.matrixWorld);
+        }
+        /**
+         * Get its LookAt orientation in world coordinate.
+         *
+         * @param target A target `THREE.Vector3`
+         */
+        getLookAtWorldQuaternion(target) {
+            const head = this.humanoid.getBoneNode('head');
+            return getWorldQuaternionLite(head, target);
+        }
+        /**
+         * 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);
+        }
+        /**
+         * Set its LookAt position.
+         * Note that its result will be instantly overwritten if {@link VRMLookAtHead.autoUpdate} is enabled.
+         *
+         * @param position A target position
+         */
+        lookAt(position) {
+            this._calcEuler(this._euler, position);
+            this.applier.lookAt(this._euler);
+        }
+        /**
+         * Update the VRMLookAtHead.
+         * If {@link VRMLookAtHead.autoUpdate} is disabled, it will do nothing.
+         *
+         * @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) {
+                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;
+        }
+    }
     VRMLookAt.EULER_ORDER = 'YXZ'; // yaw-pitch-roll
 
-    const _eulerA = new THREE__namespace.Euler(0.0, 0.0, 0.0, 'YXZ');
-    /**
-     * A class that applies eye gaze directions to a VRM.
-     * It will be used by {@link VRMLookAt}.
-     */
-    class VRMLookAtBoneApplier {
-        /**
-         * Create a new {@link VRMLookAtBoneApplier}.
-         *
-         * @param humanoid A {@link VRMHumanoid}
-         * @param rangeMapHorizontalInner A {@link VRMLookAtRangeMap} used for inner transverse direction
-         * @param rangeMapHorizontalOuter A {@link VRMLookAtRangeMap} used for outer transverse direction
-         * @param rangeMapVerticalDown A {@link VRMLookAtRangeMap} used for down direction
-         * @param rangeMapVerticalUp A {@link VRMLookAtRangeMap} used for up direction
-         */
-        constructor(humanoid, rangeMapHorizontalInner, rangeMapHorizontalOuter, rangeMapVerticalDown, rangeMapVerticalUp) {
-            this.humanoid = humanoid;
-            this.rangeMapHorizontalInner = rangeMapHorizontalInner;
-            this.rangeMapHorizontalOuter = rangeMapHorizontalOuter;
-            this.rangeMapVerticalDown = rangeMapVerticalDown;
-            this.rangeMapVerticalUp = rangeMapVerticalUp;
-        }
-        /**
-         * Apply the input angle to its associated VRM model.
-         *
-         * @param angle An input angle
-         */
-        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');
-            // left
-            if (leftEye) {
-                if (srcX < 0.0) {
-                    _eulerA.x = (-this.rangeMapVerticalDown.map(-srcX) / 180.0) * Math.PI;
-                }
-                else {
-                    _eulerA.x = (this.rangeMapVerticalUp.map(srcX) / 180.0) * Math.PI;
-                }
-                if (srcY < 0.0) {
-                    _eulerA.y = (-this.rangeMapHorizontalInner.map(-srcY) / 180.0) * Math.PI;
-                }
-                else {
-                    _eulerA.y = (this.rangeMapHorizontalOuter.map(srcY) / 180.0) * Math.PI;
-                }
-                leftEye.quaternion.setFromEuler(_eulerA);
-            }
-            // right
-            if (rightEye) {
-                if (srcX < 0.0) {
-                    _eulerA.x = (-this.rangeMapVerticalDown.map(-srcX) / 180.0) * Math.PI;
-                }
-                else {
-                    _eulerA.x = (this.rangeMapVerticalUp.map(srcX) / 180.0) * Math.PI;
-                }
-                if (srcY < 0.0) {
-                    _eulerA.y = (-this.rangeMapHorizontalOuter.map(-srcY) / 180.0) * Math.PI;
-                }
-                else {
-                    _eulerA.y = (this.rangeMapHorizontalInner.map(srcY) / 180.0) * Math.PI;
-                }
-                rightEye.quaternion.setFromEuler(_eulerA);
-            }
-        }
-    }
-    /**
-     * Represent its type of applier.
-     */
+    const _eulerA = new THREE__namespace.Euler(0.0, 0.0, 0.0, 'YXZ');
+    /**
+     * A class that applies eye gaze directions to a VRM.
+     * It will be used by {@link VRMLookAt}.
+     */
+    class VRMLookAtBoneApplier {
+        /**
+         * Create a new {@link VRMLookAtBoneApplier}.
+         *
+         * @param humanoid A {@link VRMHumanoid}
+         * @param rangeMapHorizontalInner A {@link VRMLookAtRangeMap} used for inner transverse direction
+         * @param rangeMapHorizontalOuter A {@link VRMLookAtRangeMap} used for outer transverse direction
+         * @param rangeMapVerticalDown A {@link VRMLookAtRangeMap} used for down direction
+         * @param rangeMapVerticalUp A {@link VRMLookAtRangeMap} used for up direction
+         */
+        constructor(humanoid, rangeMapHorizontalInner, rangeMapHorizontalOuter, rangeMapVerticalDown, rangeMapVerticalUp) {
+            this.humanoid = humanoid;
+            this.rangeMapHorizontalInner = rangeMapHorizontalInner;
+            this.rangeMapHorizontalOuter = rangeMapHorizontalOuter;
+            this.rangeMapVerticalDown = rangeMapVerticalDown;
+            this.rangeMapVerticalUp = rangeMapVerticalUp;
+        }
+        /**
+         * Apply the input angle to its associated VRM model.
+         *
+         * @param angle An input angle
+         */
+        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');
+            // left
+            if (leftEye) {
+                if (srcX < 0.0) {
+                    _eulerA.x = (-this.rangeMapVerticalDown.map(-srcX) / 180.0) * Math.PI;
+                }
+                else {
+                    _eulerA.x = (this.rangeMapVerticalUp.map(srcX) / 180.0) * Math.PI;
+                }
+                if (srcY < 0.0) {
+                    _eulerA.y = (-this.rangeMapHorizontalInner.map(-srcY) / 180.0) * Math.PI;
+                }
+                else {
+                    _eulerA.y = (this.rangeMapHorizontalOuter.map(srcY) / 180.0) * Math.PI;
+                }
+                leftEye.quaternion.setFromEuler(_eulerA);
+            }
+            // right
+            if (rightEye) {
+                if (srcX < 0.0) {
+                    _eulerA.x = (-this.rangeMapVerticalDown.map(-srcX) / 180.0) * Math.PI;
+                }
+                else {
+                    _eulerA.x = (this.rangeMapVerticalUp.map(srcX) / 180.0) * Math.PI;
+                }
+                if (srcY < 0.0) {
+                    _eulerA.y = (-this.rangeMapHorizontalOuter.map(-srcY) / 180.0) * Math.PI;
+                }
+                else {
+                    _eulerA.y = (this.rangeMapHorizontalInner.map(srcY) / 180.0) * Math.PI;
+                }
+                rightEye.quaternion.setFromEuler(_eulerA);
+            }
+        }
+    }
+    /**
+     * Represent its type of applier.
+     */
     VRMLookAtBoneApplier.type = 'bone';
 
-    /**
-     * A class that applies eye gaze directions to a VRM.
-     * It will be used by {@link VRMLookAt}.
-     */
-    class VRMLookAtExpressionApplier {
-        /**
-         * Create a new {@link VRMLookAtExpressionApplier}.
-         *
-         * @param expressions A {@link VRMExpressionManager}
-         * @param rangeMapHorizontalInner A {@link VRMLookAtRangeMap} used for inner transverse direction
-         * @param rangeMapHorizontalOuter A {@link VRMLookAtRangeMap} used for outer transverse direction
-         * @param rangeMapVerticalDown A {@link VRMLookAtRangeMap} used for down direction
-         * @param rangeMapVerticalUp A {@link VRMLookAtRangeMap} used for up direction
-         */
-        constructor(expressions, rangeMapHorizontalInner, rangeMapHorizontalOuter, rangeMapVerticalDown, rangeMapVerticalUp) {
-            this.expressions = expressions;
-            this.rangeMapHorizontalInner = rangeMapHorizontalInner;
-            this.rangeMapHorizontalOuter = rangeMapHorizontalOuter;
-            this.rangeMapVerticalDown = rangeMapVerticalDown;
-            this.rangeMapVerticalUp = rangeMapVerticalUp;
-        }
-        /**
-         * Apply the input angle to its associated VRM model.
-         *
-         * @param angle An input angle
-         */
-        lookAt(angle) {
-            const srcX = (angle.x * 180.0) / Math.PI;
-            const srcY = (angle.y * 180.0) / Math.PI;
-            if (srcX < 0.0) {
-                this.expressions.setValue('lookDown', 0.0);
-                this.expressions.setValue('lookUp', this.rangeMapVerticalUp.map(-srcX));
-            }
-            else {
-                this.expressions.setValue('lookUp', 0.0);
-                this.expressions.setValue('lookDown', this.rangeMapVerticalDown.map(srcX));
-            }
-            if (srcY < 0.0) {
-                this.expressions.setValue('lookLeft', 0.0);
-                this.expressions.setValue('lookRight', this.rangeMapHorizontalOuter.map(-srcY));
-            }
-            else {
-                this.expressions.setValue('lookRight', 0.0);
-                this.expressions.setValue('lookLeft', this.rangeMapHorizontalOuter.map(srcY));
-            }
-        }
-    }
-    /**
-     * Represent its type of applier.
-     */
+    /**
+     * A class that applies eye gaze directions to a VRM.
+     * It will be used by {@link VRMLookAt}.
+     */
+    class VRMLookAtExpressionApplier {
+        /**
+         * Create a new {@link VRMLookAtExpressionApplier}.
+         *
+         * @param expressions A {@link VRMExpressionManager}
+         * @param rangeMapHorizontalInner A {@link VRMLookAtRangeMap} used for inner transverse direction
+         * @param rangeMapHorizontalOuter A {@link VRMLookAtRangeMap} used for outer transverse direction
+         * @param rangeMapVerticalDown A {@link VRMLookAtRangeMap} used for down direction
+         * @param rangeMapVerticalUp A {@link VRMLookAtRangeMap} used for up direction
+         */
+        constructor(expressions, rangeMapHorizontalInner, rangeMapHorizontalOuter, rangeMapVerticalDown, rangeMapVerticalUp) {
+            this.expressions = expressions;
+            this.rangeMapHorizontalInner = rangeMapHorizontalInner;
+            this.rangeMapHorizontalOuter = rangeMapHorizontalOuter;
+            this.rangeMapVerticalDown = rangeMapVerticalDown;
+            this.rangeMapVerticalUp = rangeMapVerticalUp;
+        }
+        /**
+         * Apply the input angle to its associated VRM model.
+         *
+         * @param angle An input angle
+         */
+        lookAt(angle) {
+            const srcX = (angle.x * 180.0) / Math.PI;
+            const srcY = (angle.y * 180.0) / Math.PI;
+            if (srcX < 0.0) {
+                this.expressions.setValue('lookDown', 0.0);
+                this.expressions.setValue('lookUp', this.rangeMapVerticalUp.map(-srcX));
+            }
+            else {
+                this.expressions.setValue('lookUp', 0.0);
+                this.expressions.setValue('lookDown', this.rangeMapVerticalDown.map(srcX));
+            }
+            if (srcY < 0.0) {
+                this.expressions.setValue('lookLeft', 0.0);
+                this.expressions.setValue('lookRight', this.rangeMapHorizontalOuter.map(-srcY));
+            }
+            else {
+                this.expressions.setValue('lookRight', 0.0);
+                this.expressions.setValue('lookLeft', this.rangeMapHorizontalOuter.map(srcY));
+            }
+        }
+    }
+    /**
+     * Represent its type of applier.
+     */
     VRMLookAtExpressionApplier.type = 'expression';
 
-    class VRMLookAtRangeMap {
-        /**
-         * Create a new {@link VRMLookAtRangeMap}.
-         *
-         * @param inputMaxValue The {@link inputMaxValue} of the map
-         * @param outputScale The {@link outputScale} of the map
-         */
-        constructor(inputMaxValue, outputScale) {
-            this.inputMaxValue = inputMaxValue;
-            this.outputScale = outputScale;
-        }
-        /**
-         * Evaluate an input value and output a mapped value.
-         * @param src The input value
-         */
-        map(src) {
-            return this.outputScale * saturate(src / this.inputMaxValue);
-        }
+    class VRMLookAtRangeMap {
+        /**
+         * Create a new {@link VRMLookAtRangeMap}.
+         *
+         * @param inputMaxValue The {@link inputMaxValue} of the map
+         * @param outputScale The {@link outputScale} of the map
+         */
+        constructor(inputMaxValue, outputScale) {
+            this.inputMaxValue = inputMaxValue;
+            this.outputScale = outputScale;
+        }
+        /**
+         * Evaluate an input value and output a mapped value.
+         * @param src The input value
+         */
+        map(src) {
+            return this.outputScale * saturate(src / this.inputMaxValue);
+        }
     }
 
-    /**
-     * A plugin of GLTFLoader that imports a {@link VRMLookAt} from a VRM extension of a GLTF.
-     */
-    class VRMLookAtLoaderPlugin {
-        constructor(parser, options) {
-            this.parser = parser;
-            this.helperRoot = options === null || options === void 0 ? void 0 : options.helperRoot;
-        }
-        get name() {
-            // We should use the extension name instead but we have multiple plugins for an extension...
-            return 'VRMLookAtLoaderPlugin';
-        }
-        afterRoot(gltf) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const vrmHumanoid = gltf.userData.vrmHumanoid;
-                // explicitly distinguish null and undefined
-                // since vrmHumanoid might be null as a result
-                if (vrmHumanoid === null) {
-                    return;
-                }
-                else if (vrmHumanoid === undefined) {
-                    throw new Error('VRMFirstPersonLoaderPlugin: 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');
-                }
-                gltf.userData.vrmLookAt = yield this._import(gltf, vrmHumanoid, vrmExpressionManager);
-            });
-        }
-        /**
-         * Import a {@link VRMLookAt} from a VRM.
-         *
-         * @param gltf A parsed result of GLTF taken from GLTFLoader
-         * @param humanoid A {@link VRMHumanoid} instance that represents the VRM
-         * @param expressions A {@link VRMExpressionManager} instance that represents the VRM
-         */
-        _import(gltf, humanoid, expressions) {
-            return __awaiter(this, void 0, void 0, function* () {
-                if (humanoid == null || expressions == null) {
-                    return null;
-                }
-                const v1Result = yield this._v1Import(gltf, humanoid, expressions);
-                if (v1Result) {
-                    return v1Result;
-                }
-                const v0Result = yield this._v0Import(gltf, humanoid, expressions);
-                if (v0Result) {
-                    return v0Result;
-                }
-                return null;
-            });
-        }
-        _v1Import(gltf, humanoid, expressions) {
-            var _a, _b, _c;
-            return __awaiter(this, void 0, void 0, function* () {
-                const json = this.parser.json;
-                // early abort if it doesn't use vrm
-                const isVRMUsed = ((_a = json.extensionsUsed) === null || _a === void 0 ? void 0 : _a.indexOf('VRMC_vrm')) !== -1;
-                if (!isVRMUsed) {
-                    return null;
-                }
-                const extension = (_b = json.extensions) === null || _b === void 0 ? void 0 : _b['VRMC_vrm'];
-                if (!extension) {
-                    return null;
-                }
-                const specVersion = extension.specVersion;
-                if (specVersion !== '1.0-beta') {
-                    return null;
-                }
-                const schemaLookAt = extension.lookAt;
-                if (!schemaLookAt) {
-                    return null;
-                }
-                const defaultOutputScale = schemaLookAt.type === 'expression' ? 1.0 : 10.0;
-                const mapHI = this._v1ImportRangeMap(schemaLookAt.rangeMapHorizontalInner, defaultOutputScale);
-                const mapHO = this._v1ImportRangeMap(schemaLookAt.rangeMapHorizontalOuter, defaultOutputScale);
-                const mapVD = this._v1ImportRangeMap(schemaLookAt.rangeMapVerticalDown, defaultOutputScale);
-                const mapVU = this._v1ImportRangeMap(schemaLookAt.rangeMapVerticalUp, defaultOutputScale);
-                let applier;
-                if (schemaLookAt.type === 'expression') {
-                    applier = new VRMLookAtExpressionApplier(expressions, mapHI, mapHO, mapVD, mapVU);
-                }
-                else {
-                    applier = new VRMLookAtBoneApplier(humanoid, mapHI, mapHO, mapVD, mapVU);
-                }
-                const lookAt = this._importLookAt(humanoid, applier);
-                lookAt.offsetFromHeadBone.fromArray((_c = schemaLookAt.offsetFromHeadBone) !== null && _c !== void 0 ? _c : [0.0, 0.06, 0.0]);
-                return lookAt;
-            });
-        }
-        _v1ImportRangeMap(schemaRangeMap, defaultOutputScale) {
-            var _a, _b;
-            return new VRMLookAtRangeMap((_a = schemaRangeMap === null || schemaRangeMap === void 0 ? void 0 : schemaRangeMap.inputMaxValue) !== null && _a !== void 0 ? _a : 90.0, (_b = schemaRangeMap === null || schemaRangeMap === void 0 ? void 0 : schemaRangeMap.outputScale) !== null && _b !== void 0 ? _b : defaultOutputScale);
-        }
-        _v0Import(gltf, humanoid, expressions) {
-            var _a, _b, _c, _d;
-            return __awaiter(this, void 0, void 0, function* () {
-                const json = this.parser.json;
-                // early abort if it doesn't use vrm
-                const vrmExt = (_a = json.extensions) === null || _a === void 0 ? void 0 : _a.VRM;
-                if (!vrmExt) {
-                    return null;
-                }
-                const schemaFirstPerson = vrmExt.firstPerson;
-                if (!schemaFirstPerson) {
-                    return null;
-                }
-                const defaultOutputScale = schemaFirstPerson.lookAtTypeName === 'BlendShape' ? 1.0 : 10.0;
-                const mapHI = this._v0ImportDegreeMap(schemaFirstPerson.lookAtHorizontalInner, defaultOutputScale);
-                const mapHO = this._v0ImportDegreeMap(schemaFirstPerson.lookAtHorizontalOuter, defaultOutputScale);
-                const mapVD = this._v0ImportDegreeMap(schemaFirstPerson.lookAtVerticalDown, defaultOutputScale);
-                const mapVU = this._v0ImportDegreeMap(schemaFirstPerson.lookAtVerticalUp, defaultOutputScale);
-                let applier;
-                if (schemaFirstPerson.lookAtTypeName === 'BlendShape') {
-                    applier = new VRMLookAtExpressionApplier(expressions, mapHI, mapHO, mapVD, mapVU);
-                }
-                else {
-                    applier = new VRMLookAtBoneApplier(humanoid, mapHI, mapHO, mapVD, mapVU);
-                }
-                const lookAt = this._importLookAt(humanoid, applier);
-                if (schemaFirstPerson.firstPersonBoneOffset) {
-                    lookAt.offsetFromHeadBone.set((_b = schemaFirstPerson.firstPersonBoneOffset.x) !== null && _b !== void 0 ? _b : 0.0, (_c = schemaFirstPerson.firstPersonBoneOffset.y) !== null && _c !== void 0 ? _c : 0.06, -((_d = schemaFirstPerson.firstPersonBoneOffset.z) !== null && _d !== void 0 ? _d : 0.0));
-                }
-                else {
-                    lookAt.offsetFromHeadBone.set(0.0, 0.06, 0.0);
-                }
-                // VRM 0.0 are facing Z- instead of Z+
-                lookAt.faceFront.set(0.0, 0.0, -1.0);
-                return lookAt;
-            });
-        }
-        _v0ImportDegreeMap(schemaDegreeMap, defaultOutputScale) {
-            var _a, _b;
-            const curve = schemaDegreeMap === null || schemaDegreeMap === void 0 ? void 0 : schemaDegreeMap.curve;
-            if (JSON.stringify(curve) !== '[0,0,0,1,1,1,1,0]') {
-                console.warn('Curves of LookAtDegreeMap defined in VRM 0.0 are not supported');
-            }
-            return new VRMLookAtRangeMap((_a = schemaDegreeMap === null || schemaDegreeMap === void 0 ? void 0 : schemaDegreeMap.xRange) !== null && _a !== void 0 ? _a : 90.0, (_b = schemaDegreeMap === null || schemaDegreeMap === void 0 ? void 0 : schemaDegreeMap.yRange) !== null && _b !== void 0 ? _b : defaultOutputScale);
-        }
-        _importLookAt(humanoid, applier) {
-            const lookAt = new VRMLookAt(humanoid, applier);
-            if (this.helperRoot) {
-                const helper = new VRMLookAtHelper(lookAt);
-                this.helperRoot.add(helper);
-                helper.renderOrder = this.helperRoot.renderOrder;
-            }
-            return lookAt;
-        }
+    /**
+     * A plugin of GLTFLoader that imports a {@link VRMLookAt} from a VRM extension of a GLTF.
+     */
+    class VRMLookAtLoaderPlugin {
+        constructor(parser, options) {
+            this.parser = parser;
+            this.helperRoot = options === null || options === void 0 ? void 0 : options.helperRoot;
+        }
+        get name() {
+            // We should use the extension name instead but we have multiple plugins for an extension...
+            return 'VRMLookAtLoaderPlugin';
+        }
+        afterRoot(gltf) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const vrmHumanoid = gltf.userData.vrmHumanoid;
+                // explicitly distinguish null and undefined
+                // since vrmHumanoid might be null as a result
+                if (vrmHumanoid === null) {
+                    return;
+                }
+                else if (vrmHumanoid === undefined) {
+                    throw new Error('VRMFirstPersonLoaderPlugin: 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');
+                }
+                gltf.userData.vrmLookAt = yield this._import(gltf, vrmHumanoid, vrmExpressionManager);
+            });
+        }
+        /**
+         * Import a {@link VRMLookAt} from a VRM.
+         *
+         * @param gltf A parsed result of GLTF taken from GLTFLoader
+         * @param humanoid A {@link VRMHumanoid} instance that represents the VRM
+         * @param expressions A {@link VRMExpressionManager} instance that represents the VRM
+         */
+        _import(gltf, humanoid, expressions) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (humanoid == null || expressions == null) {
+                    return null;
+                }
+                const v1Result = yield this._v1Import(gltf, humanoid, expressions);
+                if (v1Result) {
+                    return v1Result;
+                }
+                const v0Result = yield this._v0Import(gltf, humanoid, expressions);
+                if (v0Result) {
+                    return v0Result;
+                }
+                return null;
+            });
+        }
+        _v1Import(gltf, humanoid, expressions) {
+            var _a, _b, _c;
+            return __awaiter(this, void 0, void 0, function* () {
+                const json = this.parser.json;
+                // early abort if it doesn't use vrm
+                const isVRMUsed = ((_a = json.extensionsUsed) === null || _a === void 0 ? void 0 : _a.indexOf('VRMC_vrm')) !== -1;
+                if (!isVRMUsed) {
+                    return null;
+                }
+                const extension = (_b = json.extensions) === null || _b === void 0 ? void 0 : _b['VRMC_vrm'];
+                if (!extension) {
+                    return null;
+                }
+                const specVersion = extension.specVersion;
+                if (specVersion !== '1.0-beta') {
+                    return null;
+                }
+                const schemaLookAt = extension.lookAt;
+                if (!schemaLookAt) {
+                    return null;
+                }
+                const defaultOutputScale = schemaLookAt.type === 'expression' ? 1.0 : 10.0;
+                const mapHI = this._v1ImportRangeMap(schemaLookAt.rangeMapHorizontalInner, defaultOutputScale);
+                const mapHO = this._v1ImportRangeMap(schemaLookAt.rangeMapHorizontalOuter, defaultOutputScale);
+                const mapVD = this._v1ImportRangeMap(schemaLookAt.rangeMapVerticalDown, defaultOutputScale);
+                const mapVU = this._v1ImportRangeMap(schemaLookAt.rangeMapVerticalUp, defaultOutputScale);
+                let applier;
+                if (schemaLookAt.type === 'expression') {
+                    applier = new VRMLookAtExpressionApplier(expressions, mapHI, mapHO, mapVD, mapVU);
+                }
+                else {
+                    applier = new VRMLookAtBoneApplier(humanoid, mapHI, mapHO, mapVD, mapVU);
+                }
+                const lookAt = this._importLookAt(humanoid, applier);
+                lookAt.offsetFromHeadBone.fromArray((_c = schemaLookAt.offsetFromHeadBone) !== null && _c !== void 0 ? _c : [0.0, 0.06, 0.0]);
+                return lookAt;
+            });
+        }
+        _v1ImportRangeMap(schemaRangeMap, defaultOutputScale) {
+            var _a, _b;
+            return new VRMLookAtRangeMap((_a = schemaRangeMap === null || schemaRangeMap === void 0 ? void 0 : schemaRangeMap.inputMaxValue) !== null && _a !== void 0 ? _a : 90.0, (_b = schemaRangeMap === null || schemaRangeMap === void 0 ? void 0 : schemaRangeMap.outputScale) !== null && _b !== void 0 ? _b : defaultOutputScale);
+        }
+        _v0Import(gltf, humanoid, expressions) {
+            var _a, _b, _c, _d;
+            return __awaiter(this, void 0, void 0, function* () {
+                const json = this.parser.json;
+                // early abort if it doesn't use vrm
+                const vrmExt = (_a = json.extensions) === null || _a === void 0 ? void 0 : _a.VRM;
+                if (!vrmExt) {
+                    return null;
+                }
+                const schemaFirstPerson = vrmExt.firstPerson;
+                if (!schemaFirstPerson) {
+                    return null;
+                }
+                const defaultOutputScale = schemaFirstPerson.lookAtTypeName === 'BlendShape' ? 1.0 : 10.0;
+                const mapHI = this._v0ImportDegreeMap(schemaFirstPerson.lookAtHorizontalInner, defaultOutputScale);
+                const mapHO = this._v0ImportDegreeMap(schemaFirstPerson.lookAtHorizontalOuter, defaultOutputScale);
+                const mapVD = this._v0ImportDegreeMap(schemaFirstPerson.lookAtVerticalDown, defaultOutputScale);
+                const mapVU = this._v0ImportDegreeMap(schemaFirstPerson.lookAtVerticalUp, defaultOutputScale);
+                let applier;
+                if (schemaFirstPerson.lookAtTypeName === 'BlendShape') {
+                    applier = new VRMLookAtExpressionApplier(expressions, mapHI, mapHO, mapVD, mapVU);
+                }
+                else {
+                    applier = new VRMLookAtBoneApplier(humanoid, mapHI, mapHO, mapVD, mapVU);
+                }
+                const lookAt = this._importLookAt(humanoid, applier);
+                if (schemaFirstPerson.firstPersonBoneOffset) {
+                    lookAt.offsetFromHeadBone.set((_b = schemaFirstPerson.firstPersonBoneOffset.x) !== null && _b !== void 0 ? _b : 0.0, (_c = schemaFirstPerson.firstPersonBoneOffset.y) !== null && _c !== void 0 ? _c : 0.06, -((_d = schemaFirstPerson.firstPersonBoneOffset.z) !== null && _d !== void 0 ? _d : 0.0));
+                }
+                else {
+                    lookAt.offsetFromHeadBone.set(0.0, 0.06, 0.0);
+                }
+                // VRM 0.0 are facing Z- instead of Z+
+                lookAt.faceFront.set(0.0, 0.0, -1.0);
+                return lookAt;
+            });
+        }
+        _v0ImportDegreeMap(schemaDegreeMap, defaultOutputScale) {
+            var _a, _b;
+            const curve = schemaDegreeMap === null || schemaDegreeMap === void 0 ? void 0 : schemaDegreeMap.curve;
+            if (JSON.stringify(curve) !== '[0,0,0,1,1,1,1,0]') {
+                console.warn('Curves of LookAtDegreeMap defined in VRM 0.0 are not supported');
+            }
+            return new VRMLookAtRangeMap((_a = schemaDegreeMap === null || schemaDegreeMap === void 0 ? void 0 : schemaDegreeMap.xRange) !== null && _a !== void 0 ? _a : 90.0, (_b = schemaDegreeMap === null || schemaDegreeMap === void 0 ? void 0 : schemaDegreeMap.yRange) !== null && _b !== void 0 ? _b : defaultOutputScale);
+        }
+        _importLookAt(humanoid, applier) {
+            const lookAt = new VRMLookAt(humanoid, applier);
+            if (this.helperRoot) {
+                const helper = new VRMLookAtHelper(lookAt);
+                this.helperRoot.add(helper);
+                helper.renderOrder = this.helperRoot.renderOrder;
+            }
+            return lookAt;
+        }
     }
 
-    /* eslint-disable @typescript-eslint/naming-convention */
-    /**
-     * Represents a type of applier.
-     */
-    const VRMLookAtTypeName = {
-        Bone: 'bone',
-        Expression: 'expression',
+    /* eslint-disable @typescript-eslint/naming-convention */
+    /**
+     * Represents a type of applier.
+     */
+    const VRMLookAtTypeName = {
+        Bone: 'bone',
+        Expression: 'expression',
     };
 
-    /**
-     * Yoinked from https://github.com/mrdoob/three.js/blob/master/examples/jsm/loaders/GLTFLoader.js
-     */
-    function resolveURL(url, path) {
-        // Invalid URL
-        if (typeof url !== 'string' || url === '')
-            return '';
-        // Host Relative URL
-        if (/^https?:\/\//i.test(path) && /^\//.test(url)) {
-            path = path.replace(/(^https?:\/\/[^/]+).*/i, '$1');
-        }
-        // Absolute URL http://,https://,//
-        if (/^(https?:)?\/\//i.test(url))
-            return url;
-        // Data URI
-        if (/^data:.*,.*$/i.test(url))
-            return url;
-        // Blob URL
-        if (/^blob:.*$/i.test(url))
-            return url;
-        // Relative URL
-        return path + url;
+    /**
+     * Yoinked from https://github.com/mrdoob/three.js/blob/master/examples/jsm/loaders/GLTFLoader.js
+     */
+    function resolveURL(url, path) {
+        // Invalid URL
+        if (typeof url !== 'string' || url === '')
+            return '';
+        // Host Relative URL
+        if (/^https?:\/\//i.test(path) && /^\//.test(url)) {
+            path = path.replace(/(^https?:\/\/[^/]+).*/i, '$1');
+        }
+        // Absolute URL http://,https://,//
+        if (/^(https?:)?\/\//i.test(url))
+            return url;
+        // Data URI
+        if (/^data:.*,.*$/i.test(url))
+            return url;
+        // Blob URL
+        if (/^blob:.*$/i.test(url))
+            return url;
+        // Relative URL
+        return path + url;
     }
 
-    /**
-     * A plugin of GLTFLoader that imports a {@link VRM1Meta} from a VRM extension of a GLTF.
-     */
-    class VRMMetaLoaderPlugin {
-        constructor(parser, options) {
-            var _a, _b, _c;
-            this.parser = parser;
-            this.needThumbnailImage = (_a = options === null || options === void 0 ? void 0 : options.needThumbnailImage) !== null && _a !== void 0 ? _a : true;
-            this.acceptLicenseUrls = (_b = options === null || options === void 0 ? void 0 : options.acceptLicenseUrls) !== null && _b !== void 0 ? _b : ['https://vrm.dev/licenses/1.0/'];
-            this.acceptV0Meta = (_c = options === null || options === void 0 ? void 0 : options.acceptV0Meta) !== null && _c !== void 0 ? _c : true;
-        }
-        get name() {
-            // We should use the extension name instead but we have multiple plugins for an extension...
-            return 'VRMMetaLoaderPlugin';
-        }
-        afterRoot(gltf) {
-            return __awaiter(this, void 0, void 0, function* () {
-                gltf.userData.vrmMeta = yield this._import(gltf);
-            });
-        }
-        _import(gltf) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const v1Result = yield this._v1Import(gltf);
-                if (v1Result != null) {
-                    return v1Result;
-                }
-                const v0Result = yield this._v0Import(gltf);
-                if (v0Result != null) {
-                    return v0Result;
-                }
-                return null;
-            });
-        }
-        _v1Import(gltf) {
-            var _a, _b, _c;
-            return __awaiter(this, void 0, void 0, function* () {
-                const json = this.parser.json;
-                // early abort if it doesn't use vrm
-                const isVRMUsed = ((_a = json.extensionsUsed) === null || _a === void 0 ? void 0 : _a.indexOf('VRMC_vrm')) !== -1;
-                if (!isVRMUsed) {
-                    return null;
-                }
-                const extension = (_b = json.extensions) === null || _b === void 0 ? void 0 : _b['VRMC_vrm'];
-                if (extension == null) {
-                    return null;
-                }
-                const specVersion = extension.specVersion;
-                if (specVersion !== '1.0-beta') {
-                    return null;
-                }
-                const schemaMeta = extension.meta;
-                if (!schemaMeta) {
-                    return null;
-                }
-                // throw an error if acceptV0Meta is false
-                const licenseUrl = schemaMeta.licenseUrl;
-                const acceptLicenseUrlsSet = new Set(this.acceptLicenseUrls);
-                if (!acceptLicenseUrlsSet.has(licenseUrl)) {
-                    throw new Error(`VRMMetaLoaderPlugin: The license url "${licenseUrl}" is not accepted`);
-                }
-                let thumbnailImage = undefined;
-                if (this.needThumbnailImage && schemaMeta.thumbnailImage != null) {
-                    thumbnailImage = (_c = (yield this._extractGLTFImage(schemaMeta.thumbnailImage))) !== null && _c !== void 0 ? _c : undefined;
-                }
-                return {
-                    metaVersion: '1',
-                    name: schemaMeta.name,
-                    version: schemaMeta.version,
-                    authors: schemaMeta.authors,
-                    copyrightInformation: schemaMeta.copyrightInformation,
-                    contactInformation: schemaMeta.contactInformation,
-                    references: schemaMeta.references,
-                    thirdPartyLicenses: schemaMeta.thirdPartyLicenses,
-                    thumbnailImage,
-                    licenseUrl: schemaMeta.licenseUrl,
-                    avatarPermission: schemaMeta.avatarPermission,
-                    allowExcessivelyViolentUsage: schemaMeta.allowExcessivelyViolentUsage,
-                    allowExcessivelySexualUsage: schemaMeta.allowExcessivelySexualUsage,
-                    commercialUsage: schemaMeta.commercialUsage,
-                    allowPoliticalOrReligiousUsage: schemaMeta.allowPoliticalOrReligiousUsage,
-                    allowAntisocialOrHateUsage: schemaMeta.allowAntisocialOrHateUsage,
-                    creditNotation: schemaMeta.creditNotation,
-                    allowRedistribution: schemaMeta.allowRedistribution,
-                    modification: schemaMeta.modification,
-                    otherLicenseUrl: schemaMeta.otherLicenseUrl,
-                };
-            });
-        }
-        _v0Import(gltf) {
-            var _a;
-            return __awaiter(this, void 0, void 0, function* () {
-                const json = this.parser.json;
-                // early abort if it doesn't use vrm
-                const vrmExt = (_a = json.extensions) === null || _a === void 0 ? void 0 : _a.VRM;
-                if (!vrmExt) {
-                    return null;
-                }
-                const schemaMeta = vrmExt.meta;
-                if (!schemaMeta) {
-                    return null;
-                }
-                // throw an error if acceptV0Meta is false
-                if (!this.acceptV0Meta) {
-                    throw new Error('VRMMetaLoaderPlugin: Attempted to load VRM0.X meta but acceptV0Meta is false');
-                }
-                // load thumbnail texture
-                let texture;
-                if (this.needThumbnailImage && schemaMeta.texture != null && schemaMeta.texture !== -1) {
-                    texture = yield this.parser.getDependency('texture', schemaMeta.texture);
-                }
-                return {
-                    metaVersion: '0',
-                    allowedUserName: schemaMeta.allowedUserName,
-                    author: schemaMeta.author,
-                    commercialUssageName: schemaMeta.commercialUssageName,
-                    contactInformation: schemaMeta.contactInformation,
-                    licenseName: schemaMeta.licenseName,
-                    otherLicenseUrl: schemaMeta.otherLicenseUrl,
-                    otherPermissionUrl: schemaMeta.otherPermissionUrl,
-                    reference: schemaMeta.reference,
-                    sexualUssageName: schemaMeta.sexualUssageName,
-                    texture: texture !== null && texture !== void 0 ? texture : undefined,
-                    title: schemaMeta.title,
-                    version: schemaMeta.version,
-                    violentUssageName: schemaMeta.violentUssageName,
-                };
-            });
-        }
-        _extractGLTFImage(index) {
-            var _a;
-            return __awaiter(this, void 0, void 0, function* () {
-                const json = this.parser.json;
-                const source = (_a = json.images) === null || _a === void 0 ? void 0 : _a[index];
-                if (source == null) {
-                    console.warn(`VRMMetaLoaderPlugin: Attempt to use images[${index}] of glTF as a thumbnail but the image doesn't exist`);
-                    return null;
-                }
-                // Ref: https://github.com/mrdoob/three.js/blob/r124/examples/jsm/loaders/GLTFLoader.js#L2467
-                // `source.uri` might be a reference to a file
-                let sourceURI = source.uri;
-                // Load the binary as a blob
-                if (source.bufferView != null) {
-                    const bufferView = yield this.parser.getDependency('bufferView', source.bufferView);
-                    const blob = new Blob([bufferView], { type: source.mimeType });
-                    sourceURI = URL.createObjectURL(blob);
-                }
-                if (sourceURI == null) {
-                    console.warn(`VRMMetaLoaderPlugin: Attempt to use images[${index}] of glTF as a thumbnail but the image couldn't load properly`);
-                    return null;
-                }
-                const loader = new THREE__namespace.ImageLoader();
-                return yield loader.loadAsync(resolveURL(sourceURI, this.parser.options.path)).catch((error) => {
-                    console.error(error);
-                    console.warn('VRMMetaLoaderPlugin: Failed to load a thumbnail image');
-                    return null;
-                });
-            });
-        }
+    /**
+     * A plugin of GLTFLoader that imports a {@link VRM1Meta} from a VRM extension of a GLTF.
+     */
+    class VRMMetaLoaderPlugin {
+        constructor(parser, options) {
+            var _a, _b, _c;
+            this.parser = parser;
+            this.needThumbnailImage = (_a = options === null || options === void 0 ? void 0 : options.needThumbnailImage) !== null && _a !== void 0 ? _a : true;
+            this.acceptLicenseUrls = (_b = options === null || options === void 0 ? void 0 : options.acceptLicenseUrls) !== null && _b !== void 0 ? _b : ['https://vrm.dev/licenses/1.0/'];
+            this.acceptV0Meta = (_c = options === null || options === void 0 ? void 0 : options.acceptV0Meta) !== null && _c !== void 0 ? _c : true;
+        }
+        get name() {
+            // We should use the extension name instead but we have multiple plugins for an extension...
+            return 'VRMMetaLoaderPlugin';
+        }
+        afterRoot(gltf) {
+            return __awaiter(this, void 0, void 0, function* () {
+                gltf.userData.vrmMeta = yield this._import(gltf);
+            });
+        }
+        _import(gltf) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const v1Result = yield this._v1Import(gltf);
+                if (v1Result != null) {
+                    return v1Result;
+                }
+                const v0Result = yield this._v0Import(gltf);
+                if (v0Result != null) {
+                    return v0Result;
+                }
+                return null;
+            });
+        }
+        _v1Import(gltf) {
+            var _a, _b, _c;
+            return __awaiter(this, void 0, void 0, function* () {
+                const json = this.parser.json;
+                // early abort if it doesn't use vrm
+                const isVRMUsed = ((_a = json.extensionsUsed) === null || _a === void 0 ? void 0 : _a.indexOf('VRMC_vrm')) !== -1;
+                if (!isVRMUsed) {
+                    return null;
+                }
+                const extension = (_b = json.extensions) === null || _b === void 0 ? void 0 : _b['VRMC_vrm'];
+                if (extension == null) {
+                    return null;
+                }
+                const specVersion = extension.specVersion;
+                if (specVersion !== '1.0-beta') {
+                    return null;
+                }
+                const schemaMeta = extension.meta;
+                if (!schemaMeta) {
+                    return null;
+                }
+                // throw an error if acceptV0Meta is false
+                const licenseUrl = schemaMeta.licenseUrl;
+                const acceptLicenseUrlsSet = new Set(this.acceptLicenseUrls);
+                if (!acceptLicenseUrlsSet.has(licenseUrl)) {
+                    throw new Error(`VRMMetaLoaderPlugin: The license url "${licenseUrl}" is not accepted`);
+                }
+                let thumbnailImage = undefined;
+                if (this.needThumbnailImage && schemaMeta.thumbnailImage != null) {
+                    thumbnailImage = (_c = (yield this._extractGLTFImage(schemaMeta.thumbnailImage))) !== null && _c !== void 0 ? _c : undefined;
+                }
+                return {
+                    metaVersion: '1',
+                    name: schemaMeta.name,
+                    version: schemaMeta.version,
+                    authors: schemaMeta.authors,
+                    copyrightInformation: schemaMeta.copyrightInformation,
+                    contactInformation: schemaMeta.contactInformation,
+                    references: schemaMeta.references,
+                    thirdPartyLicenses: schemaMeta.thirdPartyLicenses,
+                    thumbnailImage,
+                    licenseUrl: schemaMeta.licenseUrl,
+                    avatarPermission: schemaMeta.avatarPermission,
+                    allowExcessivelyViolentUsage: schemaMeta.allowExcessivelyViolentUsage,
+                    allowExcessivelySexualUsage: schemaMeta.allowExcessivelySexualUsage,
+                    commercialUsage: schemaMeta.commercialUsage,
+                    allowPoliticalOrReligiousUsage: schemaMeta.allowPoliticalOrReligiousUsage,
+                    allowAntisocialOrHateUsage: schemaMeta.allowAntisocialOrHateUsage,
+                    creditNotation: schemaMeta.creditNotation,
+                    allowRedistribution: schemaMeta.allowRedistribution,
+                    modification: schemaMeta.modification,
+                    otherLicenseUrl: schemaMeta.otherLicenseUrl,
+                };
+            });
+        }
+        _v0Import(gltf) {
+            var _a;
+            return __awaiter(this, void 0, void 0, function* () {
+                const json = this.parser.json;
+                // early abort if it doesn't use vrm
+                const vrmExt = (_a = json.extensions) === null || _a === void 0 ? void 0 : _a.VRM;
+                if (!vrmExt) {
+                    return null;
+                }
+                const schemaMeta = vrmExt.meta;
+                if (!schemaMeta) {
+                    return null;
+                }
+                // throw an error if acceptV0Meta is false
+                if (!this.acceptV0Meta) {
+                    throw new Error('VRMMetaLoaderPlugin: Attempted to load VRM0.X meta but acceptV0Meta is false');
+                }
+                // load thumbnail texture
+                let texture;
+                if (this.needThumbnailImage && schemaMeta.texture != null && schemaMeta.texture !== -1) {
+                    texture = yield this.parser.getDependency('texture', schemaMeta.texture);
+                }
+                return {
+                    metaVersion: '0',
+                    allowedUserName: schemaMeta.allowedUserName,
+                    author: schemaMeta.author,
+                    commercialUssageName: schemaMeta.commercialUssageName,
+                    contactInformation: schemaMeta.contactInformation,
+                    licenseName: schemaMeta.licenseName,
+                    otherLicenseUrl: schemaMeta.otherLicenseUrl,
+                    otherPermissionUrl: schemaMeta.otherPermissionUrl,
+                    reference: schemaMeta.reference,
+                    sexualUssageName: schemaMeta.sexualUssageName,
+                    texture: texture !== null && texture !== void 0 ? texture : undefined,
+                    title: schemaMeta.title,
+                    version: schemaMeta.version,
+                    violentUssageName: schemaMeta.violentUssageName,
+                };
+            });
+        }
+        _extractGLTFImage(index) {
+            var _a;
+            return __awaiter(this, void 0, void 0, function* () {
+                const json = this.parser.json;
+                const source = (_a = json.images) === null || _a === void 0 ? void 0 : _a[index];
+                if (source == null) {
+                    console.warn(`VRMMetaLoaderPlugin: Attempt to use images[${index}] of glTF as a thumbnail but the image doesn't exist`);
+                    return null;
+                }
+                // Ref: https://github.com/mrdoob/three.js/blob/r124/examples/jsm/loaders/GLTFLoader.js#L2467
+                // `source.uri` might be a reference to a file
+                let sourceURI = source.uri;
+                // Load the binary as a blob
+                if (source.bufferView != null) {
+                    const bufferView = yield this.parser.getDependency('bufferView', source.bufferView);
+                    const blob = new Blob([bufferView], { type: source.mimeType });
+                    sourceURI = URL.createObjectURL(blob);
+                }
+                if (sourceURI == null) {
+                    console.warn(`VRMMetaLoaderPlugin: Attempt to use images[${index}] of glTF as a thumbnail but the image couldn't load properly`);
+                    return null;
+                }
+                const loader = new THREE__namespace.ImageLoader();
+                return yield loader.loadAsync(resolveURL(sourceURI, this.parser.options.path)).catch((error) => {
+                    console.error(error);
+                    console.warn('VRMMetaLoaderPlugin: Failed to load a thumbnail image');
+                    return null;
+                });
+            });
+        }
     }
 
-    /**
-     * A class that represents a single VRM model.
-     * This class only includes core spec of the VRM (`VRMC_vrm`).
-     */
-    class VRMCore {
-        /**
-         * Create a new VRM instance.
-         *
-         * @param params [[VRMParameters]] that represents components of the VRM
-         */
-        constructor(params) {
-            this.scene = params.scene;
-            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.**
-         *
-         * This function updates every VRM components.
-         *
-         * @param delta deltaTime
-         */
-        update(delta) {
-            if (this.lookAt) {
-                this.lookAt.update(delta);
-            }
-            if (this.expressionManager) {
-                this.expressionManager.update();
-            }
-        }
+    /**
+     * A class that represents a single VRM model.
+     * This class only includes core spec of the VRM (`VRMC_vrm`).
+     */
+    class VRMCore {
+        /**
+         * Create a new VRM instance.
+         *
+         * @param params [[VRMParameters]] that represents components of the VRM
+         */
+        constructor(params) {
+            this.scene = params.scene;
+            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.**
+         *
+         * This function updates every VRM components.
+         *
+         * @param delta deltaTime
+         */
+        update(delta) {
+            if (this.lookAt) {
+                this.lookAt.update(delta);
+            }
+            if (this.expressionManager) {
+                this.expressionManager.update();
+            }
+        }
     }
 
-    class VRMCoreLoaderPlugin {
-        constructor(parser, options) {
-            var _a, _b, _c, _d, _e;
-            this.parser = parser;
-            const helperRoot = options === null || options === void 0 ? void 0 : options.helperRoot;
-            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.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);
-        }
-        get name() {
-            // We should use the extension name instead but we have multiple plugins for an extension...
-            return 'VRMC_vrm';
-        }
-        afterRoot(gltf) {
-            return __awaiter(this, void 0, void 0, function* () {
-                yield this.metaPlugin.afterRoot(gltf);
-                yield this.humanoidPlugin.afterRoot(gltf);
-                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;
-            });
-        }
+    class VRMCoreLoaderPlugin {
+        constructor(parser, options) {
+            var _a, _b, _c, _d, _e;
+            this.parser = parser;
+            const helperRoot = options === null || options === void 0 ? void 0 : options.helperRoot;
+            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.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);
+        }
+        get name() {
+            // We should use the extension name instead but we have multiple plugins for an extension...
+            return 'VRMC_vrm';
+        }
+        afterRoot(gltf) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield this.metaPlugin.afterRoot(gltf);
+                yield this.humanoidPlugin.afterRoot(gltf);
+                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;
+            });
+        }
     }
 
     exports.VRMCore = VRMCore;