@pixiv/three-vrm-core 2.1.1 → 3.0.0-beta.0

package/lib/three-vrm-core.cjs

@@ -0,0 +1,3335 @@
+/*!
+ * @pixiv/three-vrm-core v3.0.0-beta.0
+ * The implementation of core features of VRM, for @pixiv/three-vrm
+ *
+ * Copyright (c) 2019-2024 pixiv Inc.
+ * @pixiv/three-vrm-core is distributed under MIT License
+ * https://github.com/pixiv/three-vrm/blob/release/LICENSE
+ */
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  VRMCore: () => VRMCore,
+  VRMCoreLoaderPlugin: () => VRMCoreLoaderPlugin,
+  VRMExpression: () => VRMExpression,
+  VRMExpressionLoaderPlugin: () => VRMExpressionLoaderPlugin,
+  VRMExpressionManager: () => VRMExpressionManager,
+  VRMExpressionMaterialColorBind: () => VRMExpressionMaterialColorBind,
+  VRMExpressionMaterialColorType: () => VRMExpressionMaterialColorType,
+  VRMExpressionMorphTargetBind: () => VRMExpressionMorphTargetBind,
+  VRMExpressionOverrideType: () => VRMExpressionOverrideType,
+  VRMExpressionPresetName: () => VRMExpressionPresetName,
+  VRMExpressionTextureTransformBind: () => VRMExpressionTextureTransformBind,
+  VRMFirstPerson: () => VRMFirstPerson,
+  VRMFirstPersonLoaderPlugin: () => VRMFirstPersonLoaderPlugin,
+  VRMFirstPersonMeshAnnotationType: () => VRMFirstPersonMeshAnnotationType,
+  VRMHumanBoneList: () => VRMHumanBoneList,
+  VRMHumanBoneName: () => VRMHumanBoneName,
+  VRMHumanBoneParentMap: () => VRMHumanBoneParentMap,
+  VRMHumanoid: () => VRMHumanoid,
+  VRMHumanoidHelper: () => VRMHumanoidHelper,
+  VRMHumanoidLoaderPlugin: () => VRMHumanoidLoaderPlugin,
+  VRMLookAt: () => VRMLookAt,
+  VRMLookAtBoneApplier: () => VRMLookAtBoneApplier,
+  VRMLookAtExpressionApplier: () => VRMLookAtExpressionApplier,
+  VRMLookAtHelper: () => VRMLookAtHelper,
+  VRMLookAtLoaderPlugin: () => VRMLookAtLoaderPlugin,
+  VRMLookAtRangeMap: () => VRMLookAtRangeMap,
+  VRMLookAtTypeName: () => VRMLookAtTypeName,
+  VRMMetaLoaderPlugin: () => VRMMetaLoaderPlugin,
+  VRMRequiredHumanBoneName: () => VRMRequiredHumanBoneName
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/expressions/VRMExpression.ts
+var THREE = __toESM(require("three"), 1);
+var VRMExpression = class extends THREE.Object3D {
+  constructor(expressionName) {
+    super();
+    /**
+     * The current weight of the expression.
+     */
+    this.weight = 0;
+    /**
+     * Interpret values greater than 0.5 as 1.0, ortherwise 0.0.
+     */
+    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;
+    this.type = "VRMExpression";
+    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 < this.weight ? 1 : 0;
+    } else if (this.overrideBlink === "blend") {
+      return this.weight;
+    } else {
+      return 0;
+    }
+  }
+  /**
+   * A value represents how much it should override lookAt expressions.
+   * `0.0` == no override at all, `1.0` == completely block the expressions.
+   */
+  get overrideLookAtAmount() {
+    if (this.overrideLookAt === "block") {
+      return 0 < this.weight ? 1 : 0;
+    } else if (this.overrideLookAt === "blend") {
+      return this.weight;
+    } else {
+      return 0;
+    }
+  }
+  /**
+   * A value represents how much it should override mouth expressions.
+   * `0.0` == no override at all, `1.0` == completely block the expressions.
+   */
+  get overrideMouthAmount() {
+    if (this.overrideMouth === "block") {
+      return 0 < this.weight ? 1 : 0;
+    } else if (this.overrideMouth === "blend") {
+      return this.weight;
+    } else {
+      return 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.5 ? 0 : 1 : this.weight;
+    actualWeight *= (_a = options == null ? void 0 : options.multiplier) != null ? _a : 1;
+    this._binds.forEach((bind) => bind.applyWeight(actualWeight));
+  }
+  /**
+   * Clear previously assigned blend shapes.
+   */
+  clearAppliedWeight() {
+    this._binds.forEach((bind) => bind.clearAppliedWeight());
+  }
+};
+
+// src/expressions/VRMExpressionLoaderPlugin.ts
+var THREE5 = __toESM(require("three"), 1);
+
+// src/utils/gltfExtractPrimitivesFromNode.ts
+function extractPrimitivesInternal(gltf, nodeIndex, node) {
+  var _a, _b;
+  const json = gltf.parser.json;
+  const schemaNode = (_a = json.nodes) == null ? void 0 : _a[nodeIndex];
+  if (schemaNode == null) {
+    console.warn(`extractPrimitivesInternal: Attempt to use nodes[${nodeIndex}] of glTF but the node doesn't exist`);
+    return null;
+  }
+  const meshIndex = schemaNode.mesh;
+  if (meshIndex == null) {
+    return null;
+  }
+  const schemaMesh = (_b = json.meshes) == null ? void 0 : _b[meshIndex];
+  if (schemaMesh == null) {
+    console.warn(`extractPrimitivesInternal: Attempt to use meshes[${meshIndex}] of glTF but the mesh doesn't exist`);
+    return null;
+  }
+  const primitiveCount = schemaMesh.primitives.length;
+  const primitives = [];
+  node.traverse((object) => {
+    if (primitives.length < primitiveCount) {
+      if (object.isMesh) {
+        primitives.push(object);
+      }
+    }
+  });
+  return primitives;
+}
+function gltfExtractPrimitivesFromNode(gltf, nodeIndex) {
+  return __async(this, null, function* () {
+    const node = yield gltf.parser.getDependency("node", nodeIndex);
+    return extractPrimitivesInternal(gltf, nodeIndex, node);
+  });
+}
+function gltfExtractPrimitivesFromNodes(gltf) {
+  return __async(this, null, function* () {
+    const nodes = yield gltf.parser.getDependencies("node");
+    const map = /* @__PURE__ */ new Map();
+    nodes.forEach((node, index) => {
+      const result = extractPrimitivesInternal(gltf, index, node);
+      if (result != null) {
+        map.set(index, result);
+      }
+    });
+    return map;
+  });
+}
+
+// src/utils/gltfGetAssociatedMaterialIndex.ts
+var THREE2 = __toESM(require("three"), 1);
+function gltfGetAssociatedMaterialIndex(parser, material) {
+  var _a, _b;
+  const threeRevision = parseInt(THREE2.REVISION, 10);
+  let index = null;
+  if (threeRevision >= 133) {
+    index = (_b = (_a = parser.associations.get(material)) == null ? void 0 : _a.materials) != null ? _b : null;
+  } else {
+    const associations = parser.associations;
+    const reference = associations.get(material);
+    if ((reference == null ? void 0 : reference.type) === "materials") {
+      index = reference.index;
+    }
+  }
+  return index;
+}
+
+// src/expressions/VRMExpressionPresetName.ts
+var VRMExpressionPresetName = {
+  Aa: "aa",
+  Ih: "ih",
+  Ou: "ou",
+  Ee: "ee",
+  Oh: "oh",
+  Blink: "blink",
+  Happy: "happy",
+  Angry: "angry",
+  Sad: "sad",
+  Relaxed: "relaxed",
+  LookUp: "lookUp",
+  Surprised: "surprised",
+  LookDown: "lookDown",
+  LookLeft: "lookLeft",
+  LookRight: "lookRight",
+  BlinkLeft: "blinkLeft",
+  BlinkRight: "blinkRight",
+  Neutral: "neutral"
+};
+
+// src/utils/saturate.ts
+function saturate(value) {
+  return Math.max(Math.min(value, 1), 0);
+}
+
+// src/expressions/VRMExpressionManager.ts
+var VRMExpressionManager = 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 = {};
+  }
+  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) {
+    const expressions = this._expressions.concat();
+    expressions.forEach((expression) => {
+      this.unregisterExpression(expression);
+    });
+    source._expressions.forEach((expression) => {
+      this.registerExpression(expression);
+    });
+    this.blinkExpressionNames = source.blinkExpressionNames.concat();
+    this.lookAtExpressionNames = source.lookAtExpressionNames.concat();
+    this.mouthExpressionNames = source.mouthExpressionNames.concat();
+    return this;
+  }
+  /**
+   * Returns a clone of this {@link VRMExpressionManager}.
+   * @returns Copied {@link VRMExpressionManager}
+   */
+  clone() {
+    return new _VRMExpressionManager().copy(this);
+  }
+  /**
+   * Return a registered expression.
+   * If it cannot find an expression, it will return `null` instead.
+   *
+   * @param name Name or preset name of the expression
+   */
+  getExpression(name) {
+    var _a;
+    return (_a = this._expressionMap[name]) != null ? _a : null;
+  }
+  /**
+   * Register an expression.
+   *
+   * @param expression {@link VRMExpression} that describes the expression
+   */
+  registerExpression(expression) {
+    this._expressions.push(expression);
+    this._expressionMap[expression.expressionName] = expression;
+  }
+  /**
+   * Unregister an expression.
+   *
+   * @param expression The expression you want to unregister
+   */
+  unregisterExpression(expression) {
+    const index = this._expressions.indexOf(expression);
+    if (index === -1) {
+      console.warn("VRMExpressionManager: The specified expressions is not registered");
+    }
+    this._expressions.splice(index, 1);
+    delete this._expressionMap[expression.expressionName];
+  }
+  /**
+   * Get the current weight of the specified expression.
+   * If it doesn't have an expression of given name, it will return `null` instead.
+   *
+   * @param name Name of the expression
+   */
+  getValue(name) {
+    var _a;
+    const expression = this.getExpression(name);
+    return (_a = expression == null ? void 0 : expression.weight) != null ? _a : null;
+  }
+  /**
+   * Set a weight to the specified expression.
+   *
+   * @param name Name of the expression
+   * @param weight Weight
+   */
+  setValue(name, weight) {
+    const expression = this.getExpression(name);
+    if (expression) {
+      expression.weight = saturate(weight);
+    }
+  }
+  /**
+   * Get a track name of specified expression.
+   * This track name is needed to manipulate its expression via keyframe animations.
+   *
+   * @example Manipulate an expression using keyframe animation
+   * ```js
+   * const trackName = vrm.expressionManager.getExpressionTrackName( 'blink' );
+   * const track = new THREE.NumberKeyframeTrack(
+   *   name,
+   *   [ 0.0, 0.5, 1.0 ], // times
+   *   [ 0.0, 1.0, 0.0 ] // values
+   * );
+   *
+   * const clip = new THREE.AnimationClip(
+   *   'blink', // name
+   *   1.0, // duration
+   *   [ track ] // tracks
+   * );
+   *
+   * const mixer = new THREE.AnimationMixer( vrm.scene );
+   * const action = mixer.clipAction( clip );
+   * action.play();
+   * ```
+   *
+   * @param name Name of the expression
+   */
+  getExpressionTrackName(name) {
+    const expression = this.getExpression(name);
+    return expression ? `${expression.name}.weight` : null;
+  }
+  /**
+   * Update every expressions.
+   */
+  update() {
+    const weightMultipliers = this._calculateWeightMultipliers();
+    this._expressions.forEach((expression) => {
+      expression.clearAppliedWeight();
+    });
+    this._expressions.forEach((expression) => {
+      let multiplier = 1;
+      const name = expression.expressionName;
+      if (this.blinkExpressionNames.indexOf(name) !== -1) {
+        multiplier *= weightMultipliers.blink;
+      }
+      if (this.lookAtExpressionNames.indexOf(name) !== -1) {
+        multiplier *= weightMultipliers.lookAt;
+      }
+      if (this.mouthExpressionNames.indexOf(name) !== -1) {
+        multiplier *= weightMultipliers.mouth;
+      }
+      expression.applyWeight({ multiplier });
+    });
+  }
+  /**
+   * Calculate sum of override amounts to see how much we should multiply weights of certain expressions.
+   */
+  _calculateWeightMultipliers() {
+    let blink = 1;
+    let lookAt = 1;
+    let mouth = 1;
+    this._expressions.forEach((expression) => {
+      blink -= expression.overrideBlinkAmount;
+      lookAt -= expression.overrideLookAtAmount;
+      mouth -= expression.overrideMouthAmount;
+    });
+    blink = Math.max(0, blink);
+    lookAt = Math.max(0, lookAt);
+    mouth = Math.max(0, mouth);
+    return { blink, lookAt, mouth };
+  }
+};
+
+// src/expressions/VRMExpressionMaterialColorType.ts
+var VRMExpressionMaterialColorType = {
+  Color: "color",
+  EmissionColor: "emissionColor",
+  ShadeColor: "shadeColor",
+  MatcapColor: "matcapColor",
+  RimColor: "rimColor",
+  OutlineColor: "outlineColor"
+};
+var v0ExpressionMaterialColorMap = {
+  _Color: VRMExpressionMaterialColorType.Color,
+  _EmissionColor: VRMExpressionMaterialColorType.EmissionColor,
+  _ShadeColor: VRMExpressionMaterialColorType.ShadeColor,
+  _RimColor: VRMExpressionMaterialColorType.RimColor,
+  _OutlineColor: VRMExpressionMaterialColorType.OutlineColor
+};
+
+// src/expressions/VRMExpressionMaterialColorBind.ts
+var THREE3 = __toESM(require("three"), 1);
+var _color = new THREE3.Color();
+var _VRMExpressionMaterialColorBind = class _VRMExpressionMaterialColorBind {
+  constructor({
+    material,
+    type,
+    targetValue,
+    targetAlpha
+  }) {
+    this.material = material;
+    this.type = type;
+    this.targetValue = targetValue;
+    this.targetAlpha = targetAlpha != null ? targetAlpha : 1;
+    const color = this._initColorBindState();
+    const alpha = this._initAlphaBindState();
+    this._state = { color, alpha };
+  }
+  applyWeight(weight) {
+    const { color, alpha } = this._state;
+    if (color != null) {
+      const { propertyName, deltaValue } = color;
+      const target = this.material[propertyName];
+      if (target != void 0) {
+        target.add(_color.copy(deltaValue).multiplyScalar(weight));
+      }
+    }
+    if (alpha != null) {
+      const { propertyName, deltaValue } = alpha;
+      const target = this.material[propertyName];
+      if (target != void 0) {
+        this.material[propertyName] += deltaValue * weight;
+      }
+    }
+  }
+  clearAppliedWeight() {
+    const { color, alpha } = this._state;
+    if (color != null) {
+      const { propertyName, initialValue } = color;
+      const target = this.material[propertyName];
+      if (target != void 0) {
+        target.copy(initialValue);
+      }
+    }
+    if (alpha != null) {
+      const { propertyName, initialValue } = alpha;
+      const target = this.material[propertyName];
+      if (target != void 0) {
+        this.material[propertyName] = initialValue;
+      }
+    }
+  }
+  _initColorBindState() {
+    var _a, _b, _c;
+    const { material, type, targetValue } = this;
+    const propertyNameMap = this._getPropertyNameMap();
+    const propertyName = (_b = (_a = propertyNameMap == null ? void 0 : propertyNameMap[type]) == null ? void 0 : _a[0]) != null ? _b : null;
+    if (propertyName == null) {
+      console.warn(
+        `Tried to add a material color bind to the material ${(_c = material.name) != null ? _c : "(no name)"}, the type ${type} but the material or the type is not supported.`
+      );
+      return null;
+    }
+    const target = material[propertyName];
+    const initialValue = target.clone();
+    const deltaValue = new THREE3.Color(
+      targetValue.r - initialValue.r,
+      targetValue.g - initialValue.g,
+      targetValue.b - initialValue.b
+    );
+    return { propertyName, initialValue, deltaValue };
+  }
+  _initAlphaBindState() {
+    var _a, _b, _c;
+    const { material, type, targetAlpha } = this;
+    const propertyNameMap = this._getPropertyNameMap();
+    const propertyName = (_b = (_a = propertyNameMap == null ? void 0 : propertyNameMap[type]) == null ? void 0 : _a[1]) != null ? _b : null;
+    if (propertyName == null && targetAlpha !== 1) {
+      console.warn(
+        `Tried to add a material alpha bind to the material ${(_c = material.name) != null ? _c : "(no name)"}, the type ${type} but the material or the type does not support alpha.`
+      );
+      return null;
+    }
+    if (propertyName == null) {
+      return null;
+    }
+    const initialValue = material[propertyName];
+    const deltaValue = targetAlpha - initialValue;
+    return { propertyName, initialValue, deltaValue };
+  }
+  _getPropertyNameMap() {
+    var _a, _b;
+    return (_b = (_a = Object.entries(_VRMExpressionMaterialColorBind._propertyNameMapMap).find(([distinguisher]) => {
+      return this.material[distinguisher] === true;
+    })) == null ? void 0 : _a[1]) != null ? _b : null;
+  }
+};
+/**
+ * Mapping of property names from VRMC/materialColorBinds.type to three.js/Material.
+ * The first element stands for color channels, the second element stands for the alpha channel.
+ * The second element can be null if the target property doesn't exist.
+ */
+// TODO: We might want to use the `satisfies` operator once we bump TS to 4.9 or higher
+// See: https://github.com/pixiv/three-vrm/pull/1323#discussion_r1374020035
+_VRMExpressionMaterialColorBind._propertyNameMapMap = {
+  isMeshStandardMaterial: {
+    color: ["color", "opacity"],
+    emissionColor: ["emissive", null]
+  },
+  isMeshBasicMaterial: {
+    color: ["color", "opacity"]
+  },
+  isMToonMaterial: {
+    color: ["color", "opacity"],
+    emissionColor: ["emissive", null],
+    outlineColor: ["outlineColorFactor", null],
+    matcapColor: ["matcapFactor", null],
+    rimColor: ["parametricRimColorFactor", null],
+    shadeColor: ["shadeColorFactor", null]
+  }
+};
+var VRMExpressionMaterialColorBind = _VRMExpressionMaterialColorBind;
+
+// src/expressions/VRMExpressionMorphTargetBind.ts
+var VRMExpressionMorphTargetBind = class {
+  constructor({
+    primitives,
+    index,
+    weight
+  }) {
+    this.primitives = primitives;
+    this.index = index;
+    this.weight = weight;
+  }
+  applyWeight(weight) {
+    this.primitives.forEach((mesh) => {
+      var _a;
+      if (((_a = mesh.morphTargetInfluences) == null ? void 0 : _a[this.index]) != null) {
+        mesh.morphTargetInfluences[this.index] += this.weight * weight;
+      }
+    });
+  }
+  clearAppliedWeight() {
+    this.primitives.forEach((mesh) => {
+      var _a;
+      if (((_a = mesh.morphTargetInfluences) == null ? void 0 : _a[this.index]) != null) {
+        mesh.morphTargetInfluences[this.index] = 0;
+      }
+    });
+  }
+};
+
+// src/expressions/VRMExpressionTextureTransformBind.ts
+var THREE4 = __toESM(require("three"), 1);
+var _v2 = new THREE4.Vector2();
+var _VRMExpressionTextureTransformBind = 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 ? void 0 : _a[1];
+    if (propertyNames == null) {
+      console.warn(
+        `Tried to add a texture transform bind to the material ${(_b = material.name) != null ? _b : "(no name)"} but the material is not supported.`
+      );
+      this._properties = [];
+    } else {
+      this._properties = [];
+      propertyNames.forEach((propertyName) => {
+        var _a2;
+        const texture = (_a2 = material[propertyName]) == null ? void 0 : _a2.clone();
+        if (!texture) {
+          return null;
+        }
+        material[propertyName] = texture;
+        const initialOffset = texture.offset.clone();
+        const initialScale = texture.repeat.clone();
+        const deltaOffset = offset.clone().sub(initialOffset);
+        const deltaScale = scale.clone().sub(initialScale);
+        this._properties.push({
+          name: propertyName,
+          initialOffset,
+          deltaOffset,
+          initialScale,
+          deltaScale
+        });
+      });
+    }
+  }
+  applyWeight(weight) {
+    this._properties.forEach((property) => {
+      const target = this.material[property.name];
+      if (target === void 0) {
+        return;
+      }
+      target.offset.add(_v2.copy(property.deltaOffset).multiplyScalar(weight));
+      target.repeat.add(_v2.copy(property.deltaScale).multiplyScalar(weight));
+    });
+  }
+  clearAppliedWeight() {
+    this._properties.forEach((property) => {
+      const target = this.material[property.name];
+      if (target === void 0) {
+        return;
+      }
+      target.offset.copy(property.initialOffset);
+      target.repeat.copy(property.initialScale);
+    });
+  }
+};
+_VRMExpressionTextureTransformBind._propertyNamesMap = {
+  isMeshStandardMaterial: [
+    "map",
+    "emissiveMap",
+    "bumpMap",
+    "normalMap",
+    "displacementMap",
+    "roughnessMap",
+    "metalnessMap",
+    "alphaMap"
+  ],
+  isMeshBasicMaterial: ["map", "specularMap", "alphaMap"],
+  isMToonMaterial: [
+    "map",
+    "normalMap",
+    "emissiveMap",
+    "shadeMultiplyTexture",
+    "rimMultiplyTexture",
+    "outlineWidthMultiplyTexture",
+    "uvAnimationMaskTexture"
+  ]
+};
+var VRMExpressionTextureTransformBind = _VRMExpressionTextureTransformBind;
+
+// src/expressions/VRMExpressionLoaderPlugin.ts
+var POSSIBLE_SPEC_VERSIONS = /* @__PURE__ */ new Set(["1.0", "1.0-beta"]);
+var _VRMExpressionLoaderPlugin = class _VRMExpressionLoaderPlugin {
+  get name() {
+    return "VRMExpressionLoaderPlugin";
+  }
+  constructor(parser) {
+    this.parser = parser;
+  }
+  afterRoot(gltf) {
+    return __async(this, null, function* () {
+      gltf.userData.vrmExpressionManager = yield this._import(gltf);
+    });
+  }
+  /**
+   * Import a {@link VRMExpressionManager} from a VRM.
+   *
+   * @param gltf A parsed result of GLTF taken from GLTFLoader
+   */
+  _import(gltf) {
+    return __async(this, null, function* () {
+      const v1Result = yield this._v1Import(gltf);
+      if (v1Result) {
+        return v1Result;
+      }
+      const v0Result = yield this._v0Import(gltf);
+      if (v0Result) {
+        return v0Result;
+      }
+      return null;
+    });
+  }
+  _v1Import(gltf) {
+    return __async(this, null, function* () {
+      var _a, _b;
+      const json = this.parser.json;
+      const isVRMUsed = ((_a = json.extensionsUsed) == null ? void 0 : _a.indexOf("VRMC_vrm")) !== -1;
+      if (!isVRMUsed) {
+        return null;
+      }
+      const extension = (_b = json.extensions) == null ? void 0 : _b["VRMC_vrm"];
+      if (!extension) {
+        return null;
+      }
+      const specVersion = extension.specVersion;
+      if (!POSSIBLE_SPEC_VERSIONS.has(specVersion)) {
+        console.warn(`VRMExpressionLoaderPlugin: Unknown VRMC_vrm specVersion "${specVersion}"`);
+        return null;
+      }
+      const schemaExpressions = extension.expressions;
+      if (!schemaExpressions) {
+        return null;
+      }
+      const presetNameSet = new Set(Object.values(VRMExpressionPresetName));
+      const nameSchemaExpressionMap = /* @__PURE__ */ new Map();
+      if (schemaExpressions.preset != null) {
+        Object.entries(schemaExpressions.preset).forEach(([name, schemaExpression]) => {
+          if (schemaExpression == null) {
+            return;
+          }
+          if (!presetNameSet.has(name)) {
+            console.warn(`VRMExpressionLoaderPlugin: Unknown preset name "${name}" detected. Ignoring the expression`);
+            return;
+          }
+          nameSchemaExpressionMap.set(name, schemaExpression);
+        });
+      }
+      if (schemaExpressions.custom != null) {
+        Object.entries(schemaExpressions.custom).forEach(([name, schemaExpression]) => {
+          if (presetNameSet.has(name)) {
+            console.warn(
+              `VRMExpressionLoaderPlugin: Custom expression cannot have preset name "${name}". Ignoring the expression`
+            );
+            return;
+          }
+          nameSchemaExpressionMap.set(name, schemaExpression);
+        });
+      }
+      const manager = new VRMExpressionManager();
+      yield Promise.all(
+        Array.from(nameSchemaExpressionMap.entries()).map((_0) => __async(this, [_0], function* ([name, schemaExpression]) {
+          var _a2, _b2, _c, _d, _e, _f, _g;
+          const expression = new VRMExpression(name);
+          gltf.scene.add(expression);
+          expression.isBinary = (_a2 = schemaExpression.isBinary) != null ? _a2 : false;
+          expression.overrideBlink = (_b2 = schemaExpression.overrideBlink) != null ? _b2 : "none";
+          expression.overrideLookAt = (_c = schemaExpression.overrideLookAt) != null ? _c : "none";
+          expression.overrideMouth = (_d = schemaExpression.overrideMouth) != null ? _d : "none";
+          (_e = schemaExpression.morphTargetBinds) == null ? void 0 : _e.forEach((bind) => __async(this, null, function* () {
+            var _a3;
+            if (bind.node === void 0 || bind.index === void 0) {
+              return;
+            }
+            const primitives = yield gltfExtractPrimitivesFromNode(gltf, bind.node);
+            const morphTargetIndex = bind.index;
+            if (!primitives.every(
+              (primitive) => Array.isArray(primitive.morphTargetInfluences) && morphTargetIndex < primitive.morphTargetInfluences.length
+            )) {
+              console.warn(
+                `VRMExpressionLoaderPlugin: ${schemaExpression.name} attempts to index morph #${morphTargetIndex} but not found.`
+              );
+              return;
+            }
+            expression.addBind(
+              new VRMExpressionMorphTargetBind({
+                primitives,
+                index: morphTargetIndex,
+                weight: (_a3 = bind.weight) != null ? _a3 : 1
+              })
+            );
+          }));
+          if (schemaExpression.materialColorBinds || schemaExpression.textureTransformBinds) {
+            const gltfMaterials = [];
+            gltf.scene.traverse((object) => {
+              const material = object.material;
+              if (material) {
+                gltfMaterials.push(material);
+              }
+            });
+            (_f = schemaExpression.materialColorBinds) == null ? void 0 : _f.forEach((bind) => __async(this, null, 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 THREE5.Color().fromArray(bind.targetValue),
+                    targetAlpha: bind.targetValue[3]
+                  })
+                );
+              });
+            }));
+            (_g = schemaExpression.textureTransformBinds) == null ? void 0 : _g.forEach((bind) => __async(this, null, function* () {
+              const materials = gltfMaterials.filter((material) => {
+                const materialIndex = gltfGetAssociatedMaterialIndex(this.parser, material);
+                return bind.material === materialIndex;
+              });
+              materials.forEach((material) => {
+                var _a3, _b3;
+                expression.addBind(
+                  new VRMExpressionTextureTransformBind({
+                    material,
+                    offset: new THREE5.Vector2().fromArray((_a3 = bind.offset) != null ? _a3 : [0, 0]),
+                    scale: new THREE5.Vector2().fromArray((_b3 = bind.scale) != null ? _b3 : [1, 1])
+                  })
+                );
+              });
+            }));
+          }
+          manager.registerExpression(expression);
+        }))
+      );
+      return manager;
+    });
+  }
+  _v0Import(gltf) {
+    return __async(this, null, function* () {
+      var _a;
+      const json = this.parser.json;
+      const vrmExt = (_a = json.extensions) == null ? void 0 : _a.VRM;
+      if (!vrmExt) {
+        return null;
+      }
+      const schemaBlendShape = vrmExt.blendShapeMaster;
+      if (!schemaBlendShape) {
+        return null;
+      }
+      const manager = new VRMExpressionManager();
+      const schemaBlendShapeGroups = schemaBlendShape.blendShapeGroups;
+      if (!schemaBlendShapeGroups) {
+        return manager;
+      }
+      const blendShapeNameSet = /* @__PURE__ */ new Set();
+      yield Promise.all(
+        schemaBlendShapeGroups.map((schemaGroup) => __async(this, null, function* () {
+          var _a2;
+          const v0PresetName = schemaGroup.presetName;
+          const v1PresetName = v0PresetName != null && _VRMExpressionLoaderPlugin.v0v1PresetNameMap[v0PresetName] || null;
+          const name = v1PresetName != null ? v1PresetName : schemaGroup.name;
+          if (name == null) {
+            console.warn("VRMExpressionLoaderPlugin: One of custom expressions has no name. Ignoring the expression");
+            return;
+          }
+          if (blendShapeNameSet.has(name)) {
+            console.warn(
+              `VRMExpressionLoaderPlugin: An expression preset ${v0PresetName} has duplicated entries. Ignoring the expression`
+            );
+            return;
+          }
+          blendShapeNameSet.add(name);
+          const expression = new VRMExpression(name);
+          gltf.scene.add(expression);
+          expression.isBinary = (_a2 = schemaGroup.isBinary) != null ? _a2 : false;
+          if (schemaGroup.binds) {
+            schemaGroup.binds.forEach((bind) => __async(this, null, function* () {
+              var _a3;
+              if (bind.mesh === void 0 || bind.index === void 0) {
+                return;
+              }
+              const nodesUsingMesh = [];
+              (_a3 = json.nodes) == null ? void 0 : _a3.forEach((node, i) => {
+                if (node.mesh === bind.mesh) {
+                  nodesUsingMesh.push(i);
+                }
+              });
+              const morphTargetIndex = bind.index;
+              yield Promise.all(
+                nodesUsingMesh.map((nodeIndex) => __async(this, null, function* () {
+                  var _a4;
+                  const primitives = yield gltfExtractPrimitivesFromNode(gltf, nodeIndex);
+                  if (!primitives.every(
+                    (primitive) => Array.isArray(primitive.morphTargetInfluences) && morphTargetIndex < primitive.morphTargetInfluences.length
+                  )) {
+                    console.warn(
+                      `VRMExpressionLoaderPlugin: ${schemaGroup.name} attempts to index ${morphTargetIndex}th morph but not found.`
+                    );
+                    return;
+                  }
+                  expression.addBind(
+                    new VRMExpressionMorphTargetBind({
+                      primitives,
+                      index: morphTargetIndex,
+                      weight: 0.01 * ((_a4 = bind.weight) != null ? _a4 : 100)
+                      // narrowing the range from [ 0.0 - 100.0 ] to [ 0.0 - 1.0 ]
+                    })
+                  );
+                }))
+              );
+            }));
+          }
+          const materialValues = schemaGroup.materialValues;
+          if (materialValues && materialValues.length !== 0) {
+            materialValues.forEach((materialValue) => {
+              if (materialValue.materialName === void 0 || materialValue.propertyName === void 0 || materialValue.targetValue === void 0) {
+                return;
+              }
+              const materials = [];
+              gltf.scene.traverse((object) => {
+                if (object.material) {
+                  const material = object.material;
+                  if (Array.isArray(material)) {
+                    materials.push(
+                      ...material.filter(
+                        (mtl) => (mtl.name === materialValue.materialName || mtl.name === materialValue.materialName + " (Outline)") && materials.indexOf(mtl) === -1
+                      )
+                    );
+                  } else if (material.name === materialValue.materialName && materials.indexOf(material) === -1) {
+                    materials.push(material);
+                  }
+                }
+              });
+              const materialPropertyName = materialValue.propertyName;
+              materials.forEach((material) => {
+                if (materialPropertyName === "_MainTex_ST") {
+                  const scale = new THREE5.Vector2(materialValue.targetValue[0], materialValue.targetValue[1]);
+                  const offset = new THREE5.Vector2(materialValue.targetValue[2], materialValue.targetValue[3]);
+                  offset.y = 1 - offset.y - scale.y;
+                  expression.addBind(
+                    new VRMExpressionTextureTransformBind({
+                      material,
+                      scale,
+                      offset
+                    })
+                  );
+                  return;
+                }
+                const materialColorType = v0ExpressionMaterialColorMap[materialPropertyName];
+                if (materialColorType) {
+                  expression.addBind(
+                    new VRMExpressionMaterialColorBind({
+                      material,
+                      type: materialColorType,
+                      targetValue: new THREE5.Color().fromArray(materialValue.targetValue),
+                      targetAlpha: materialValue.targetValue[3]
+                    })
+                  );
+                  return;
+                }
+                console.warn(materialPropertyName + " is not supported");
+              });
+            });
+          }
+          manager.registerExpression(expression);
+        }))
+      );
+      return manager;
+    });
+  }
+};
+_VRMExpressionLoaderPlugin.v0v1PresetNameMap = {
+  a: "aa",
+  e: "ee",
+  i: "ih",
+  o: "oh",
+  u: "ou",
+  blink: "blink",
+  joy: "happy",
+  angry: "angry",
+  sorrow: "sad",
+  fun: "relaxed",
+  lookup: "lookUp",
+  lookdown: "lookDown",
+  lookleft: "lookLeft",
+  lookright: "lookRight",
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  blink_l: "blinkLeft",
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  blink_r: "blinkRight",
+  neutral: "neutral"
+};
+var VRMExpressionLoaderPlugin = _VRMExpressionLoaderPlugin;
+
+// src/expressions/VRMExpressionOverrideType.ts
+var VRMExpressionOverrideType = {
+  None: "none",
+  Block: "block",
+  Blend: "blend"
+};
+
+// src/firstPerson/VRMFirstPerson.ts
+var THREE6 = __toESM(require("three"), 1);
+var _VRMFirstPerson = 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 THREE6.SkinnedMesh(src.geometry.clone(), src.material);
+    dst.name = `${src.name}(erase)`;
+    dst.frustumCulled = src.frustumCulled;
+    dst.layers.set(this._firstPersonOnlyLayer);
+    const geometry = dst.geometry;
+    const skinIndexAttr = geometry.getAttribute("skinIndex");
+    const skinIndexAttrArray = skinIndexAttr instanceof THREE6.GLBufferAttribute ? [] : skinIndexAttr.array;
+    const skinIndex = [];
+    for (let i = 0; i < skinIndexAttrArray.length; i += 4) {
+      skinIndex.push([
+        skinIndexAttrArray[i],
+        skinIndexAttrArray[i + 1],
+        skinIndexAttrArray[i + 2],
+        skinIndexAttrArray[i + 3]
+      ]);
+    }
+    const skinWeightAttr = geometry.getAttribute("skinWeight");
+    const skinWeightAttrArray = skinWeightAttr instanceof THREE6.GLBufferAttribute ? [] : skinWeightAttr.array;
+    const skinWeight = [];
+    for (let i = 0; i < skinWeightAttrArray.length; i += 4) {
+      skinWeight.push([
+        skinWeightAttrArray[i],
+        skinWeightAttrArray[i + 1],
+        skinWeightAttrArray[i + 2],
+        skinWeightAttrArray[i + 3]
+      ]);
+    }
+    const index = geometry.getIndex();
+    if (!index) {
+      throw new Error("The geometry doesn't have an index buffer");
+    }
+    const oldTriangles = Array.from(index.array);
+    const count = this._excludeTriangles(oldTriangles, skinWeight, skinIndex, erasingBonesIndex);
+    const newTriangle = [];
+    for (let i = 0; i < count; i++) {
+      newTriangle[i] = oldTriangles[i];
+    }
+    geometry.setIndex(newTriangle);
+    if (src.onBeforeRender) {
+      dst.onBeforeRender = src.onBeforeRender;
+    }
+    dst.bind(new THREE6.Skeleton(src.skeleton.bones, src.skeleton.boneInverses), new THREE6.Matrix4());
+    return dst;
+  }
+  _createHeadlessModelForSkinnedMesh(parent, mesh) {
+    const eraseBoneIndexes = [];
+    mesh.skeleton.bones.forEach((bone, index) => {
+      if (this._isEraseTarget(bone)) eraseBoneIndexes.push(index);
+    });
+    if (!eraseBoneIndexes.length) {
+      mesh.layers.enable(this._thirdPersonOnlyLayer);
+      mesh.layers.enable(this._firstPersonOnlyLayer);
+      return;
+    }
+    mesh.layers.set(this._thirdPersonOnlyLayer);
+    const newMesh = this._createErasedMesh(mesh, eraseBoneIndexes);
+    parent.add(newMesh);
+  }
+  _createHeadlessModel(node) {
+    if (node.type === "Group") {
+      node.layers.set(this._thirdPersonOnlyLayer);
+      if (this._isEraseTarget(node)) {
+        node.traverse((child) => child.layers.set(this._thirdPersonOnlyLayer));
+      } else {
+        const parent = new THREE6.Group();
+        parent.name = `_headless_${node.name}`;
+        parent.layers.set(this._firstPersonOnlyLayer);
+        node.parent.add(parent);
+        node.children.filter((child) => child.type === "SkinnedMesh").forEach((child) => {
+          const skinnedMesh = child;
+          this._createHeadlessModelForSkinnedMesh(parent, skinnedMesh);
+        });
+      }
+    } else if (node.type === "SkinnedMesh") {
+      const skinnedMesh = node;
+      this._createHeadlessModelForSkinnedMesh(node.parent, skinnedMesh);
+    } else {
+      if (this._isEraseTarget(node)) {
+        node.layers.set(this._thirdPersonOnlyLayer);
+        node.traverse((child) => child.layers.set(this._thirdPersonOnlyLayer));
+      }
+    }
+  }
+  _isEraseTarget(bone) {
+    if (bone === this.humanoid.getRawBoneNode("head")) {
+      return true;
+    } else if (!bone.parent) {
+      return false;
+    } else {
+      return this._isEraseTarget(bone.parent);
+    }
+  }
+};
+/**
+ * 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;
+var VRMFirstPerson = _VRMFirstPerson;
+
+// src/firstPerson/VRMFirstPersonLoaderPlugin.ts
+var POSSIBLE_SPEC_VERSIONS2 = /* @__PURE__ */ new Set(["1.0", "1.0-beta"]);
+var VRMFirstPersonLoaderPlugin = class {
+  get name() {
+    return "VRMFirstPersonLoaderPlugin";
+  }
+  constructor(parser) {
+    this.parser = parser;
+  }
+  afterRoot(gltf) {
+    return __async(this, null, function* () {
+      const vrmHumanoid = gltf.userData.vrmHumanoid;
+      if (vrmHumanoid === null) {
+        return;
+      } else if (vrmHumanoid === void 0) {
+        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 __async(this, null, 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) {
+    return __async(this, null, function* () {
+      var _a, _b;
+      const json = this.parser.json;
+      const isVRMUsed = ((_a = json.extensionsUsed) == null ? void 0 : _a.indexOf("VRMC_vrm")) !== -1;
+      if (!isVRMUsed) {
+        return null;
+      }
+      const extension = (_b = json.extensions) == null ? void 0 : _b["VRMC_vrm"];
+      if (!extension) {
+        return null;
+      }
+      const specVersion = extension.specVersion;
+      if (!POSSIBLE_SPEC_VERSIONS2.has(specVersion)) {
+        console.warn(`VRMFirstPersonLoaderPlugin: Unknown VRMC_vrm specVersion "${specVersion}"`);
+        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 _a2;
+        const annotation = schemaFirstPerson.meshAnnotations ? schemaFirstPerson.meshAnnotations.find((a) => a.node === nodeIndex) : void 0;
+        meshAnnotations.push({
+          meshes: primitives,
+          type: (_a2 = annotation == null ? void 0 : annotation.type) != null ? _a2 : "both"
+        });
+      });
+      return new VRMFirstPerson(humanoid, meshAnnotations);
+    });
+  }
+  _v0Import(gltf, humanoid) {
+    return __async(this, null, function* () {
+      var _a;
+      const json = this.parser.json;
+      const vrmExt = (_a = json.extensions) == null ? void 0 : _a.VRM;
+      if (!vrmExt) {
+        return null;
+      }
+      const 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) : void 0;
+        meshAnnotations.push({
+          meshes: primitives,
+          type: this._convertV0FlagToV1Type(flag == null ? 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";
+    }
+  }
+};
+
+// src/firstPerson/VRMFirstPersonMeshAnnotationType.ts
+var VRMFirstPersonMeshAnnotationType = {
+  Auto: "auto",
+  Both: "both",
+  ThirdPersonOnly: "thirdPersonOnly",
+  FirstPersonOnly: "firstPersonOnly"
+};
+
+// src/humanoid/helpers/VRMHumanoidHelper.ts
+var THREE7 = __toESM(require("three"), 1);
+var _v3A = new THREE7.Vector3();
+var _v3B = new THREE7.Vector3();
+var _quatA = new THREE7.Quaternion();
+var VRMHumanoidHelper = class extends THREE7.Group {
+  constructor(humanoid) {
+    super();
+    this.vrmHumanoid = humanoid;
+    this._boneAxesMap = /* @__PURE__ */ new Map();
+    Object.values(humanoid.humanBones).forEach((bone) => {
+      const helper = new THREE7.AxesHelper(1);
+      helper.matrixAutoUpdate = false;
+      helper.material.depthTest = false;
+      helper.material.depthWrite = false;
+      this.add(helper);
+      this._boneAxesMap.set(bone, helper);
+    });
+  }
+  dispose() {
+    Array.from(this._boneAxesMap.values()).forEach((axes) => {
+      axes.geometry.dispose();
+      axes.material.dispose();
+    });
+  }
+  updateMatrixWorld(force) {
+    Array.from(this._boneAxesMap.entries()).forEach(([bone, axes]) => {
+      bone.node.updateWorldMatrix(true, false);
+      bone.node.matrixWorld.decompose(_v3A, _quatA, _v3B);
+      const scale = _v3A.set(0.1, 0.1, 0.1).divide(_v3B);
+      axes.matrix.copy(bone.node.matrixWorld).scale(scale);
+    });
+    super.updateMatrixWorld(force);
+  }
+};
+
+// src/humanoid/VRMHumanBoneList.ts
+var VRMHumanBoneList = [
+  "hips",
+  "spine",
+  "chest",
+  "upperChest",
+  "neck",
+  "head",
+  "leftEye",
+  "rightEye",
+  "jaw",
+  "leftUpperLeg",
+  "leftLowerLeg",
+  "leftFoot",
+  "leftToes",
+  "rightUpperLeg",
+  "rightLowerLeg",
+  "rightFoot",
+  "rightToes",
+  "leftShoulder",
+  "leftUpperArm",
+  "leftLowerArm",
+  "leftHand",
+  "rightShoulder",
+  "rightUpperArm",
+  "rightLowerArm",
+  "rightHand",
+  "leftThumbMetacarpal",
+  "leftThumbProximal",
+  "leftThumbDistal",
+  "leftIndexProximal",
+  "leftIndexIntermediate",
+  "leftIndexDistal",
+  "leftMiddleProximal",
+  "leftMiddleIntermediate",
+  "leftMiddleDistal",
+  "leftRingProximal",
+  "leftRingIntermediate",
+  "leftRingDistal",
+  "leftLittleProximal",
+  "leftLittleIntermediate",
+  "leftLittleDistal",
+  "rightThumbMetacarpal",
+  "rightThumbProximal",
+  "rightThumbDistal",
+  "rightIndexProximal",
+  "rightIndexIntermediate",
+  "rightIndexDistal",
+  "rightMiddleProximal",
+  "rightMiddleIntermediate",
+  "rightMiddleDistal",
+  "rightRingProximal",
+  "rightRingIntermediate",
+  "rightRingDistal",
+  "rightLittleProximal",
+  "rightLittleIntermediate",
+  "rightLittleDistal"
+];
+
+// src/humanoid/VRMHumanBoneName.ts
+var 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",
+  LeftThumbMetacarpal: "leftThumbMetacarpal",
+  LeftThumbProximal: "leftThumbProximal",
+  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",
+  RightThumbMetacarpal: "rightThumbMetacarpal",
+  RightThumbProximal: "rightThumbProximal",
+  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"
+};
+
+// src/humanoid/VRMHumanBoneParentMap.ts
+var VRMHumanBoneParentMap = {
+  hips: null,
+  spine: "hips",
+  chest: "spine",
+  upperChest: "chest",
+  neck: "upperChest",
+  head: "neck",
+  leftEye: "head",
+  rightEye: "head",
+  jaw: "head",
+  leftUpperLeg: "hips",
+  leftLowerLeg: "leftUpperLeg",
+  leftFoot: "leftLowerLeg",
+  leftToes: "leftFoot",
+  rightUpperLeg: "hips",
+  rightLowerLeg: "rightUpperLeg",
+  rightFoot: "rightLowerLeg",
+  rightToes: "rightFoot",
+  leftShoulder: "upperChest",
+  leftUpperArm: "leftShoulder",
+  leftLowerArm: "leftUpperArm",
+  leftHand: "leftLowerArm",
+  rightShoulder: "upperChest",
+  rightUpperArm: "rightShoulder",
+  rightLowerArm: "rightUpperArm",
+  rightHand: "rightLowerArm",
+  leftThumbMetacarpal: "leftHand",
+  leftThumbProximal: "leftThumbMetacarpal",
+  leftThumbDistal: "leftThumbProximal",
+  leftIndexProximal: "leftHand",
+  leftIndexIntermediate: "leftIndexProximal",
+  leftIndexDistal: "leftIndexIntermediate",
+  leftMiddleProximal: "leftHand",
+  leftMiddleIntermediate: "leftMiddleProximal",
+  leftMiddleDistal: "leftMiddleIntermediate",
+  leftRingProximal: "leftHand",
+  leftRingIntermediate: "leftRingProximal",
+  leftRingDistal: "leftRingIntermediate",
+  leftLittleProximal: "leftHand",
+  leftLittleIntermediate: "leftLittleProximal",
+  leftLittleDistal: "leftLittleIntermediate",
+  rightThumbMetacarpal: "rightHand",
+  rightThumbProximal: "rightThumbMetacarpal",
+  rightThumbDistal: "rightThumbProximal",
+  rightIndexProximal: "rightHand",
+  rightIndexIntermediate: "rightIndexProximal",
+  rightIndexDistal: "rightIndexIntermediate",
+  rightMiddleProximal: "rightHand",
+  rightMiddleIntermediate: "rightMiddleProximal",
+  rightMiddleDistal: "rightMiddleIntermediate",
+  rightRingProximal: "rightHand",
+  rightRingIntermediate: "rightRingProximal",
+  rightRingDistal: "rightRingIntermediate",
+  rightLittleProximal: "rightHand",
+  rightLittleIntermediate: "rightLittleProximal",
+  rightLittleDistal: "rightLittleIntermediate"
+};
+
+// src/humanoid/VRMRig.ts
+var THREE8 = __toESM(require("three"), 1);
+
+// src/utils/quatInvertCompat.ts
+function quatInvertCompat(target) {
+  if (target.invert) {
+    target.invert();
+  } else {
+    target.inverse();
+  }
+  return target;
+}
+
+// src/humanoid/VRMRig.ts
+var _v3A2 = new THREE8.Vector3();
+var _quatA2 = new THREE8.Quaternion();
+var VRMRig = class {
+  /**
+   * Create a new {@link VRMHumanoid}.
+   * @param humanBones A {@link VRMHumanBones} contains all the bones of the new humanoid
+   */
+  constructor(humanBones) {
+    this.humanBones = humanBones;
+    this.restPose = this.getAbsolutePose();
+  }
+  /**
+   * 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);
+      if (!node) {
+        return;
+      }
+      _v3A2.copy(node.position);
+      _quatA2.copy(node.quaternion);
+      pose[vrmBoneName] = {
+        position: _v3A2.toArray(),
+        rotation: _quatA2.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);
+      if (!node) {
+        return;
+      }
+      _v3A2.set(0, 0, 0);
+      _quatA2.identity();
+      const restState = this.restPose[boneName];
+      if (restState == null ? void 0 : restState.position) {
+        _v3A2.fromArray(restState.position).negate();
+      }
+      if (restState == null ? void 0 : restState.rotation) {
+        quatInvertCompat(_quatA2.fromArray(restState.rotation));
+      }
+      _v3A2.add(node.position);
+      _quatA2.premultiply(node.quaternion);
+      pose[boneName] = {
+        position: _v3A2.toArray(),
+        rotation: _quatA2.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);
+      if (!node) {
+        return;
+      }
+      const restState = this.restPose[boneName];
+      if (!restState) {
+        return;
+      }
+      if (state == null ? void 0 : state.position) {
+        node.position.fromArray(state.position);
+        if (restState.position) {
+          node.position.add(_v3A2.fromArray(restState.position));
+        }
+      }
+      if (state == null ? void 0 : state.rotation) {
+        node.quaternion.fromArray(state.rotation);
+        if (restState.rotation) {
+          node.quaternion.multiply(_quatA2.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 ? void 0 : rest.position) {
+        node.position.fromArray(rest.position);
+      }
+      if (rest == null ? 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;
+  }
+  /**
+   * 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 ? void 0 : _a.node) != null ? _b : null;
+  }
+};
+
+// src/humanoid/VRMHumanoidRig.ts
+var THREE9 = __toESM(require("three"), 1);
+var _v3A3 = new THREE9.Vector3();
+var _quatA3 = new THREE9.Quaternion();
+var _boneWorldPos = new THREE9.Vector3();
+var VRMHumanoidRig = class _VRMHumanoidRig extends VRMRig {
+  static _setupTransforms(modelRig) {
+    const root = new THREE9.Object3D();
+    root.name = "VRMHumanoidRig";
+    const boneWorldPositions = {};
+    const boneWorldRotations = {};
+    const boneRotations = {};
+    const parentWorldRotations = {};
+    VRMHumanBoneList.forEach((boneName) => {
+      var _a;
+      const boneNode = modelRig.getBoneNode(boneName);
+      if (boneNode) {
+        const boneWorldPosition = new THREE9.Vector3();
+        const boneWorldRotation = new THREE9.Quaternion();
+        boneNode.updateWorldMatrix(true, false);
+        boneNode.matrixWorld.decompose(boneWorldPosition, boneWorldRotation, _v3A3);
+        boneWorldPositions[boneName] = boneWorldPosition;
+        boneWorldRotations[boneName] = boneWorldRotation;
+        boneRotations[boneName] = boneNode.quaternion.clone();
+        const parentWorldRotation = new THREE9.Quaternion();
+        (_a = boneNode.parent) == null ? void 0 : _a.matrixWorld.decompose(_v3A3, parentWorldRotation, _v3A3);
+        parentWorldRotations[boneName] = parentWorldRotation;
+      }
+    });
+    const rigBones = {};
+    VRMHumanBoneList.forEach((boneName) => {
+      var _a;
+      const boneNode = modelRig.getBoneNode(boneName);
+      if (boneNode) {
+        const boneWorldPosition = boneWorldPositions[boneName];
+        let currentBoneName = boneName;
+        let parentBoneWorldPosition;
+        while (parentBoneWorldPosition == null) {
+          currentBoneName = VRMHumanBoneParentMap[currentBoneName];
+          if (currentBoneName == null) {
+            break;
+          }
+          parentBoneWorldPosition = boneWorldPositions[currentBoneName];
+        }
+        const rigBoneNode = new THREE9.Object3D();
+        rigBoneNode.name = "Normalized_" + boneNode.name;
+        const parentRigBoneNode = currentBoneName ? (_a = rigBones[currentBoneName]) == null ? void 0 : _a.node : root;
+        parentRigBoneNode.add(rigBoneNode);
+        rigBoneNode.position.copy(boneWorldPosition);
+        if (parentBoneWorldPosition) {
+          rigBoneNode.position.sub(parentBoneWorldPosition);
+        }
+        rigBones[boneName] = { node: rigBoneNode };
+      }
+    });
+    return {
+      rigBones,
+      root,
+      parentWorldRotations,
+      boneRotations
+    };
+  }
+  constructor(humanoid) {
+    const { rigBones, root, parentWorldRotations, boneRotations } = _VRMHumanoidRig._setupTransforms(humanoid);
+    super(rigBones);
+    this.original = humanoid;
+    this.root = root;
+    this._parentWorldRotations = parentWorldRotations;
+    this._boneRotations = boneRotations;
+  }
+  /**
+   * Update this humanoid rig.
+   */
+  update() {
+    VRMHumanBoneList.forEach((boneName) => {
+      const boneNode = this.original.getBoneNode(boneName);
+      if (boneNode != null) {
+        const rigBoneNode = this.getBoneNode(boneName);
+        const parentWorldRotation = this._parentWorldRotations[boneName];
+        const invParentWorldRotation = _quatA3.copy(parentWorldRotation).invert();
+        const boneRotation = this._boneRotations[boneName];
+        boneNode.quaternion.copy(rigBoneNode.quaternion).multiply(parentWorldRotation).premultiply(invParentWorldRotation).multiply(boneRotation);
+        if (boneName === "hips") {
+          const boneWorldPosition = rigBoneNode.getWorldPosition(_boneWorldPos);
+          boneNode.parent.updateWorldMatrix(true, false);
+          const parentWorldMatrix = boneNode.parent.matrixWorld;
+          const localPosition = boneWorldPosition.applyMatrix4(parentWorldMatrix.invert());
+          boneNode.position.copy(localPosition);
+        }
+      }
+    });
+  }
+};
+
+// src/humanoid/VRMHumanoid.ts
+var VRMHumanoid = class _VRMHumanoid {
+  // TODO: Rename
+  /**
+   * @deprecated Deprecated. Use either {@link rawRestPose} or {@link normalizedRestPose} instead.
+   */
+  get restPose() {
+    console.warn("VRMHumanoid: restPose is deprecated. Use either rawRestPose or normalizedRestPose instead.");
+    return this.rawRestPose;
+  }
+  /**
+   * A {@link VRMPose} of its raw human bones that is its default state.
+   * Note that it's not compatible with {@link setRawPose} and {@link getRawPose}, since it contains non-relative values of each local transforms.
+   */
+  get rawRestPose() {
+    return this._rawHumanBones.restPose;
+  }
+  /**
+   * A {@link VRMPose} of its normalized human bones that is its default state.
+   * Note that it's not compatible with {@link setNormalizedPose} and {@link getNormalizedPose}, since it contains non-relative values of each local transforms.
+   */
+  get normalizedRestPose() {
+    return this._normalizedHumanBones.restPose;
+  }
+  /**
+   * A map from {@link VRMHumanBoneName} to raw {@link VRMHumanBone}s.
+   */
+  get humanBones() {
+    return this._rawHumanBones.humanBones;
+  }
+  /**
+   * A map from {@link VRMHumanBoneName} to raw {@link VRMHumanBone}s.
+   */
+  get rawHumanBones() {
+    return this._rawHumanBones.humanBones;
+  }
+  /**
+   * A map from {@link VRMHumanBoneName} to normalized {@link VRMHumanBone}s.
+   */
+  get normalizedHumanBones() {
+    return this._normalizedHumanBones.humanBones;
+  }
+  /**
+   * The root of normalized {@link VRMHumanBone}s.
+   */
+  get normalizedHumanBonesRoot() {
+    return this._normalizedHumanBones.root;
+  }
+  /**
+   * Create a new {@link VRMHumanoid}.
+   * @param humanBones A {@link VRMHumanBones} contains all the bones of the new humanoid
+   * @param autoUpdateHumanBones Whether it copies pose from normalizedHumanBones to rawHumanBones on {@link update}. `true` by default.
+   */
+  constructor(humanBones, options) {
+    var _a;
+    this.autoUpdateHumanBones = (_a = options == null ? void 0 : options.autoUpdateHumanBones) != null ? _a : true;
+    this._rawHumanBones = new VRMRig(humanBones);
+    this._normalizedHumanBones = new VRMHumanoidRig(this._rawHumanBones);
+  }
+  /**
+   * Copy the given {@link VRMHumanoid} into this one.
+   * @param source The {@link VRMHumanoid} you want to copy
+   * @returns this
+   */
+  copy(source) {
+    this.autoUpdateHumanBones = source.autoUpdateHumanBones;
+    this._rawHumanBones = new VRMRig(source.humanBones);
+    this._normalizedHumanBones = new VRMHumanoidRig(this._rawHumanBones);
+    return this;
+  }
+  /**
+   * Returns a clone of this {@link VRMHumanoid}.
+   * @returns Copied {@link VRMHumanoid}
+   */
+  clone() {
+    return new _VRMHumanoid(this.humanBones, { autoUpdateHumanBones: this.autoUpdateHumanBones }).copy(this);
+  }
+  /**
+   * @deprecated Deprecated. Use either {@link getRawAbsolutePose} or {@link getNormalizedAbsolutePose} instead.
+   */
+  getAbsolutePose() {
+    console.warn(
+      "VRMHumanoid: getAbsolutePose() is deprecated. Use either getRawAbsolutePose() or getNormalizedAbsolutePose() instead."
+    );
+    return this.getRawAbsolutePose();
+  }
+  /**
+   * Return the current absolute pose of this raw human bones as a {@link VRMPose}.
+   * Note that the output result will contain initial state of the VRM and not compatible between different models.
+   * You might want to use {@link getRawPose} instead.
+   */
+  getRawAbsolutePose() {
+    return this._rawHumanBones.getAbsolutePose();
+  }
+  /**
+   * Return the current absolute pose of this normalized human bones as a {@link VRMPose}.
+   * Note that the output result will contain initial state of the VRM and not compatible between different models.
+   * You might want to use {@link getNormalizedPose} instead.
+   */
+  getNormalizedAbsolutePose() {
+    return this._normalizedHumanBones.getAbsolutePose();
+  }
+  /**
+   * @deprecated Deprecated. Use either {@link getRawPose} or {@link getNormalizedPose} instead.
+   */
+  getPose() {
+    console.warn("VRMHumanoid: getPose() is deprecated. Use either getRawPose() or getNormalizedPose() instead.");
+    return this.getRawPose();
+  }
+  /**
+   * Return the current pose of raw human bones as a {@link VRMPose}.
+   *
+   * Each transform is a local transform relative from rest pose (T-pose).
+   */
+  getRawPose() {
+    return this._rawHumanBones.getPose();
+  }
+  /**
+   * Return the current pose of normalized human bones as a {@link VRMPose}.
+   *
+   * Each transform is a local transform relative from rest pose (T-pose).
+   */
+  getNormalizedPose() {
+    return this._normalizedHumanBones.getPose();
+  }
+  /**
+   * @deprecated Deprecated. Use either {@link setRawPose} or {@link setNormalizedPose} instead.
+   */
+  setPose(poseObject) {
+    console.warn("VRMHumanoid: setPose() is deprecated. Use either setRawPose() or setNormalizedPose() instead.");
+    return this.setRawPose(poseObject);
+  }
+  /**
+   * Let the raw human bones do a specified pose.
+   *
+   * Each transform have to be a local transform relative from rest pose (T-pose).
+   * You can pass what you got from {@link getRawPose}.
+   *
+   * If you are using {@link autoUpdateHumanBones}, you might want to use {@link setNormalizedPose} instead.
+   *
+   * @param poseObject A {@link VRMPose} that represents a single pose
+   */
+  setRawPose(poseObject) {
+    return this._rawHumanBones.setPose(poseObject);
+  }
+  /**
+   * Let the normalized human bones do a specified pose.
+   *
+   * Each transform have to be a local transform relative from rest pose (T-pose).
+   * You can pass what you got from {@link getNormalizedPose}.
+   *
+   * @param poseObject A {@link VRMPose} that represents a single pose
+   */
+  setNormalizedPose(poseObject) {
+    return this._normalizedHumanBones.setPose(poseObject);
+  }
+  /**
+   * @deprecated Deprecated. Use either {@link resetRawPose} or {@link resetNormalizedPose} instead.
+   */
+  resetPose() {
+    console.warn("VRMHumanoid: resetPose() is deprecated. Use either resetRawPose() or resetNormalizedPose() instead.");
+    return this.resetRawPose();
+  }
+  /**
+   * Reset the raw humanoid to its rest pose.
+   *
+   * If you are using {@link autoUpdateHumanBones}, you might want to use {@link resetNormalizedPose} instead.
+   */
+  resetRawPose() {
+    return this._rawHumanBones.resetPose();
+  }
+  /**
+   * Reset the normalized humanoid to its rest pose.
+   */
+  resetNormalizedPose() {
+    return this._normalizedHumanBones.resetPose();
+  }
+  /**
+   * @deprecated Deprecated. Use either {@link getRawBone} or {@link getNormalizedBone} instead.
+   */
+  getBone(name) {
+    console.warn("VRMHumanoid: getBone() is deprecated. Use either getRawBone() or getNormalizedBone() instead.");
+    return this.getRawBone(name);
+  }
+  /**
+   * Return a raw {@link VRMHumanBone} bound to a specified {@link VRMHumanBoneName}.
+   *
+   * @param name Name of the bone you want
+   */
+  getRawBone(name) {
+    return this._rawHumanBones.getBone(name);
+  }
+  /**
+   * Return a normalized {@link VRMHumanBone} bound to a specified {@link VRMHumanBoneName}.
+   *
+   * @param name Name of the bone you want
+   */
+  getNormalizedBone(name) {
+    return this._normalizedHumanBones.getBone(name);
+  }
+  /**
+   * @deprecated Deprecated. Use either {@link getRawBoneNode} or {@link getNormalizedBoneNode} instead.
+   */
+  getBoneNode(name) {
+    console.warn(
+      "VRMHumanoid: getBoneNode() is deprecated. Use either getRawBoneNode() or getNormalizedBoneNode() instead."
+    );
+    return this.getRawBoneNode(name);
+  }
+  /**
+   * Return a raw bone as a `THREE.Object3D` bound to a specified {@link VRMHumanBoneName}.
+   *
+   * @param name Name of the bone you want
+   */
+  getRawBoneNode(name) {
+    return this._rawHumanBones.getBoneNode(name);
+  }
+  /**
+   * Return a normalized bone as a `THREE.Object3D` bound to a specified {@link VRMHumanBoneName}.
+   *
+   * @param name Name of the bone you want
+   */
+  getNormalizedBoneNode(name) {
+    return this._normalizedHumanBones.getBoneNode(name);
+  }
+  /**
+   * Update the humanoid component.
+   *
+   * If {@link autoUpdateHumanBones} is `true`, it transfers the pose of normalized human bones to raw human bones.
+   */
+  update() {
+    if (this.autoUpdateHumanBones) {
+      this._normalizedHumanBones.update();
+    }
+  }
+};
+
+// src/humanoid/VRMRequiredHumanBoneName.ts
+var 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"
+};
+
+// src/humanoid/VRMHumanoidLoaderPlugin.ts
+var POSSIBLE_SPEC_VERSIONS3 = /* @__PURE__ */ new Set(["1.0", "1.0-beta"]);
+var thumbBoneNameMap = {
+  leftThumbProximal: "leftThumbMetacarpal",
+  leftThumbIntermediate: "leftThumbProximal",
+  rightThumbProximal: "rightThumbMetacarpal",
+  rightThumbIntermediate: "rightThumbProximal"
+};
+var VRMHumanoidLoaderPlugin = class {
+  get name() {
+    return "VRMHumanoidLoaderPlugin";
+  }
+  constructor(parser, options) {
+    this.parser = parser;
+    this.helperRoot = options == null ? void 0 : options.helperRoot;
+    this.autoUpdateHumanBones = options == null ? void 0 : options.autoUpdateHumanBones;
+  }
+  afterRoot(gltf) {
+    return __async(this, null, 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 __async(this, null, function* () {
+      const v1Result = yield this._v1Import(gltf);
+      if (v1Result) {
+        return v1Result;
+      }
+      const v0Result = yield this._v0Import(gltf);
+      if (v0Result) {
+        return v0Result;
+      }
+      return null;
+    });
+  }
+  _v1Import(gltf) {
+    return __async(this, null, function* () {
+      var _a, _b;
+      const json = this.parser.json;
+      const isVRMUsed = ((_a = json.extensionsUsed) == null ? void 0 : _a.indexOf("VRMC_vrm")) !== -1;
+      if (!isVRMUsed) {
+        return null;
+      }
+      const extension = (_b = json.extensions) == null ? void 0 : _b["VRMC_vrm"];
+      if (!extension) {
+        return null;
+      }
+      const specVersion = extension.specVersion;
+      if (!POSSIBLE_SPEC_VERSIONS3.has(specVersion)) {
+        console.warn(`VRMHumanoidLoaderPlugin: Unknown VRMC_vrm specVersion "${specVersion}"`);
+        return null;
+      }
+      const schemaHumanoid = extension.humanoid;
+      if (!schemaHumanoid) {
+        return null;
+      }
+      const existsPreviousThumbName = schemaHumanoid.humanBones.leftThumbIntermediate != null || schemaHumanoid.humanBones.rightThumbIntermediate != null;
+      const humanBones = {};
+      if (schemaHumanoid.humanBones != null) {
+        yield Promise.all(
+          Object.entries(schemaHumanoid.humanBones).map((_0) => __async(this, [_0], function* ([boneNameString, schemaHumanBone]) {
+            let boneName = boneNameString;
+            const index = schemaHumanBone.node;
+            if (existsPreviousThumbName) {
+              const thumbBoneName = thumbBoneNameMap[boneName];
+              if (thumbBoneName != null) {
+                boneName = thumbBoneName;
+              }
+            }
+            const node = yield this.parser.getDependency("node", index);
+            if (node == null) {
+              console.warn(`A glTF node bound to the humanoid bone ${boneName} (index = ${index}) does not exist`);
+              return;
+            }
+            humanBones[boneName] = { node };
+          }))
+        );
+      }
+      const humanoid = new VRMHumanoid(this._ensureRequiredBonesExist(humanBones), {
+        autoUpdateHumanBones: this.autoUpdateHumanBones
+      });
+      gltf.scene.add(humanoid.normalizedHumanBonesRoot);
+      if (this.helperRoot) {
+        const helper = new VRMHumanoidHelper(humanoid);
+        this.helperRoot.add(helper);
+        helper.renderOrder = this.helperRoot.renderOrder;
+      }
+      return humanoid;
+    });
+  }
+  _v0Import(gltf) {
+    return __async(this, null, function* () {
+      var _a;
+      const json = this.parser.json;
+      const vrmExt = (_a = json.extensions) == null ? void 0 : _a.VRM;
+      if (!vrmExt) {
+        return null;
+      }
+      const schemaHumanoid = vrmExt.humanoid;
+      if (!schemaHumanoid) {
+        return null;
+      }
+      const humanBones = {};
+      if (schemaHumanoid.humanBones != null) {
+        yield Promise.all(
+          schemaHumanoid.humanBones.map((bone) => __async(this, null, function* () {
+            const boneName = bone.bone;
+            const index = bone.node;
+            if (boneName == null || index == null) {
+              return;
+            }
+            const node = yield this.parser.getDependency("node", index);
+            if (node == null) {
+              console.warn(`A glTF node bound to the humanoid bone ${boneName} (index = ${index}) does not exist`);
+              return;
+            }
+            const thumbBoneName = thumbBoneNameMap[boneName];
+            const newBoneName = thumbBoneName != null ? thumbBoneName : boneName;
+            if (humanBones[newBoneName] != null) {
+              console.warn(
+                `Multiple bone entries for ${newBoneName} detected (index = ${index}), ignoring duplicated entries.`
+              );
+              return;
+            }
+            humanBones[newBoneName] = { node };
+          }))
+        );
+      }
+      const humanoid = new VRMHumanoid(this._ensureRequiredBonesExist(humanBones), {
+        autoUpdateHumanBones: this.autoUpdateHumanBones
+      });
+      gltf.scene.add(humanoid.normalizedHumanBonesRoot);
+      if (this.helperRoot) {
+        const helper = new VRMHumanoidHelper(humanoid);
+        this.helperRoot.add(helper);
+        helper.renderOrder = this.helperRoot.renderOrder;
+      }
+      return humanoid;
+    });
+  }
+  /**
+   * Ensure required bones exist in given human bones.
+   * @param humanBones Human bones
+   * @returns Human bones, no longer partial!
+   */
+  _ensureRequiredBonesExist(humanBones) {
+    const missingRequiredBones = Object.values(VRMRequiredHumanBoneName).filter(
+      (requiredBoneName) => humanBones[requiredBoneName] == null
+    );
+    if (missingRequiredBones.length > 0) {
+      throw new Error(
+        `VRMHumanoidLoaderPlugin: These humanoid bones are required but not exist: ${missingRequiredBones.join(", ")}`
+      );
+    }
+    return humanBones;
+  }
+};
+
+// src/lookAt/helpers/VRMLookAtHelper.ts
+var THREE12 = __toESM(require("three"), 1);
+
+// src/lookAt/helpers/utils/FanBufferGeometry.ts
+var THREE10 = __toESM(require("three"), 1);
+var FanBufferGeometry = class extends THREE10.BufferGeometry {
+  constructor() {
+    super();
+    this._currentTheta = 0;
+    this._currentRadius = 0;
+    this.theta = 0;
+    this.radius = 0;
+    this._currentTheta = 0;
+    this._currentRadius = 0;
+    this._attrPos = new THREE10.BufferAttribute(new Float32Array(65 * 3), 3);
+    this.setAttribute("position", this._attrPos);
+    this._attrIndex = new THREE10.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);
+    for (let i = 0; i < 64; i++) {
+      const t = i / 63 * this._currentTheta;
+      this._attrPos.setXYZ(i + 1, this._currentRadius * Math.sin(t), 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;
+  }
+};
+
+// src/lookAt/helpers/utils/LineAndSphereBufferGeometry.ts
+var THREE11 = __toESM(require("three"), 1);
+var LineAndSphereBufferGeometry = class extends THREE11.BufferGeometry {
+  constructor() {
+    super();
+    this.radius = 0;
+    this._currentRadius = 0;
+    this.tail = new THREE11.Vector3();
+    this._currentTail = new THREE11.Vector3();
+    this._attrPos = new THREE11.BufferAttribute(new Float32Array(294), 3);
+    this.setAttribute("position", this._attrPos);
+    this._attrIndex = new THREE11.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 * Math.PI;
+      this._attrPos.setXYZ(i, Math.cos(t), Math.sin(t), 0);
+      this._attrPos.setXYZ(32 + i, 0, Math.cos(t), Math.sin(t));
+      this._attrPos.setXYZ(64 + i, Math.sin(t), 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;
+  }
+};
+
+// src/lookAt/helpers/VRMLookAtHelper.ts
+var _quatA4 = new THREE12.Quaternion();
+var _quatB = new THREE12.Quaternion();
+var _v3A4 = new THREE12.Vector3();
+var _v3B2 = new THREE12.Vector3();
+var SQRT_2_OVER_2 = Math.sqrt(2) / 2;
+var QUAT_XY_CW90 = new THREE12.Quaternion(0, 0, -SQRT_2_OVER_2, SQRT_2_OVER_2);
+var VEC3_POSITIVE_Y = new THREE12.Vector3(0, 1, 0);
+var VRMLookAtHelper = class extends THREE12.Group {
+  constructor(lookAt) {
+    super();
+    this.matrixAutoUpdate = false;
+    this.vrmLookAt = lookAt;
+    {
+      const geometry = new FanBufferGeometry();
+      geometry.radius = 0.5;
+      const material = new THREE12.MeshBasicMaterial({
+        color: 65280,
+        transparent: true,
+        opacity: 0.5,
+        side: THREE12.DoubleSide,
+        depthTest: false,
+        depthWrite: false
+      });
+      this._meshPitch = new THREE12.Mesh(geometry, material);
+      this.add(this._meshPitch);
+    }
+    {
+      const geometry = new FanBufferGeometry();
+      geometry.radius = 0.5;
+      const material = new THREE12.MeshBasicMaterial({
+        color: 16711680,
+        transparent: true,
+        opacity: 0.5,
+        side: THREE12.DoubleSide,
+        depthTest: false,
+        depthWrite: false
+      });
+      this._meshYaw = new THREE12.Mesh(geometry, material);
+      this.add(this._meshYaw);
+    }
+    {
+      const geometry = new LineAndSphereBufferGeometry();
+      geometry.radius = 0.1;
+      const material = new THREE12.LineBasicMaterial({
+        color: 16777215,
+        depthTest: false,
+        depthWrite: false
+      });
+      this._lineTarget = new THREE12.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) {
+    const yaw = THREE12.MathUtils.DEG2RAD * this.vrmLookAt.yaw;
+    this._meshYaw.geometry.theta = yaw;
+    this._meshYaw.geometry.update();
+    const pitch = THREE12.MathUtils.DEG2RAD * this.vrmLookAt.pitch;
+    this._meshPitch.geometry.theta = pitch;
+    this._meshPitch.geometry.update();
+    this.vrmLookAt.getLookAtWorldPosition(_v3A4);
+    this.vrmLookAt.getLookAtWorldQuaternion(_quatA4);
+    _quatA4.multiply(this.vrmLookAt.getFaceFrontQuaternion(_quatB));
+    this._meshYaw.position.copy(_v3A4);
+    this._meshYaw.quaternion.copy(_quatA4);
+    this._meshPitch.position.copy(_v3A4);
+    this._meshPitch.quaternion.copy(_quatA4);
+    this._meshPitch.quaternion.multiply(_quatB.setFromAxisAngle(VEC3_POSITIVE_Y, yaw));
+    this._meshPitch.quaternion.multiply(QUAT_XY_CW90);
+    const { target, autoUpdate } = this.vrmLookAt;
+    if (target != null && autoUpdate) {
+      target.getWorldPosition(_v3B2).sub(_v3A4);
+      this._lineTarget.geometry.tail.copy(_v3B2);
+      this._lineTarget.geometry.update();
+      this._lineTarget.position.copy(_v3A4);
+    }
+    super.updateMatrixWorld(force);
+  }
+};
+
+// src/lookAt/VRMLookAt.ts
+var THREE14 = __toESM(require("three"), 1);
+
+// src/utils/getWorldQuaternionLite.ts
+var THREE13 = __toESM(require("three"), 1);
+var _position = new THREE13.Vector3();
+var _scale = new THREE13.Vector3();
+function getWorldQuaternionLite(object, out) {
+  object.matrixWorld.decompose(_position, out, _scale);
+  return out;
+}
+
+// src/lookAt/utils/calcAzimuthAltitude.ts
+function calcAzimuthAltitude(vector) {
+  return [Math.atan2(-vector.z, vector.x), Math.atan2(vector.y, Math.sqrt(vector.x * vector.x + vector.z * vector.z))];
+}
+
+// src/lookAt/utils/sanitizeAngle.ts
+function sanitizeAngle(angle) {
+  const roundTurn = Math.round(angle / 2 / Math.PI);
+  return angle - 2 * Math.PI * roundTurn;
+}
+
+// src/lookAt/VRMLookAt.ts
+var VEC3_POSITIVE_Z = new THREE14.Vector3(0, 0, 1);
+var _v3A5 = new THREE14.Vector3();
+var _v3B3 = new THREE14.Vector3();
+var _v3C = new THREE14.Vector3();
+var _quatA5 = new THREE14.Quaternion();
+var _quatB2 = new THREE14.Quaternion();
+var _quatC = new THREE14.Quaternion();
+var _quatD = new THREE14.Quaternion();
+var _eulerA = new THREE14.Euler();
+var _VRMLookAt = class _VRMLookAt {
+  /**
+   * Create a new {@link VRMLookAt}.
+   *
+   * @param humanoid A {@link VRMHumanoid}
+   * @param applier A {@link VRMLookAtApplier}
+   */
+  constructor(humanoid, applier) {
+    // yaw-pitch-roll
+    /**
+     * The origin of LookAt. Position offset from the head bone.
+     */
+    this.offsetFromHeadBone = new THREE14.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 THREE14.Vector3(0, 0, 1);
+    this.humanoid = humanoid;
+    this.applier = applier;
+    this._yaw = 0;
+    this._pitch = 0;
+    this._needsUpdate = true;
+    this._restHeadWorldQuaternion = this.getLookAtWorldQuaternion(new THREE14.Quaternion());
+  }
+  /**
+   * Its current angle around Y axis, in degree.
+   */
+  get yaw() {
+    return this._yaw;
+  }
+  /**
+   * Its current angle around Y axis, in degree.
+   */
+  set yaw(value) {
+    this._yaw = value;
+    this._needsUpdate = true;
+  }
+  /**
+   * Its current angle around X axis, in degree.
+   */
+  get pitch() {
+    return this._pitch;
+  }
+  /**
+   * Its current angle around X axis, in degree.
+   */
+  set pitch(value) {
+    this._pitch = value;
+    this._needsUpdate = true;
+  }
+  /**
+   * @deprecated Use {@link getEuler} instead.
+   */
+  get euler() {
+    console.warn("VRMLookAt: euler is deprecated. use getEuler() instead.");
+    return this.getEuler(new THREE14.Euler());
+  }
+  /**
+   * Get its yaw-pitch angles as an `Euler`.
+   * Does NOT consider {@link faceFront}; it returns `Euler(0, 0, 0; "YXZ")` by default regardless of the faceFront value.
+   *
+   * @param target The target euler
+   */
+  getEuler(target) {
+    return target.set(THREE14.MathUtils.DEG2RAD * this._pitch, THREE14.MathUtils.DEG2RAD * this._yaw, 0, "YXZ");
+  }
+  /**
+   * Copy the given {@link VRMLookAt} into this one.
+   * {@link humanoid} must be same as the source one.
+   * {@link applier} will reference the same instance as the source one.
+   * @param source The {@link VRMLookAt} you want to copy
+   * @returns this
+   */
+  copy(source) {
+    if (this.humanoid !== source.humanoid) {
+      throw new Error("VRMLookAt: humanoid must be same in order to copy");
+    }
+    this.offsetFromHeadBone.copy(source.offsetFromHeadBone);
+    this.applier = source.applier;
+    this.autoUpdate = source.autoUpdate;
+    this.target = source.target;
+    this.faceFront.copy(source.faceFront);
+    return this;
+  }
+  /**
+   * Returns a clone of this {@link VRMLookAt}.
+   * Note that {@link humanoid} and {@link applier} will reference the same instance as this one.
+   * @returns Copied {@link VRMLookAt}
+   */
+  clone() {
+    return new _VRMLookAt(this.humanoid, this.applier).copy(this);
+  }
+  /**
+   * Reset the lookAt direction (yaw and pitch) to the initial direction.
+   */
+  reset() {
+    this._yaw = 0;
+    this._pitch = 0;
+    this._needsUpdate = true;
+  }
+  /**
+   * Get its lookAt position in world coordinate.
+   *
+   * @param target A target `THREE.Vector3`
+   */
+  getLookAtWorldPosition(target) {
+    const head = this.humanoid.getRawBoneNode("head");
+    return target.copy(this.offsetFromHeadBone).applyMatrix4(head.matrixWorld);
+  }
+  /**
+   * Get its lookAt rotation in world coordinate.
+   * Does NOT consider {@link faceFront}.
+   *
+   * @param target A target `THREE.Quaternion`
+   */
+  getLookAtWorldQuaternion(target) {
+    const head = this.humanoid.getRawBoneNode("head");
+    return getWorldQuaternionLite(head, target);
+  }
+  /**
+   * Get a quaternion that rotates the +Z unit vector of the humanoid Head to the {@link faceFront} direction.
+   *
+   * @param target A target `THREE.Quaternion`
+   */
+  getFaceFrontQuaternion(target) {
+    if (this.faceFront.distanceToSquared(VEC3_POSITIVE_Z) < 0.01) {
+      return target.copy(this._restHeadWorldQuaternion).invert();
+    }
+    const [faceFrontAzimuth, faceFrontAltitude] = calcAzimuthAltitude(this.faceFront);
+    _eulerA.set(0, 0.5 * Math.PI + faceFrontAzimuth, faceFrontAltitude, "YZX");
+    return target.setFromEuler(_eulerA).premultiply(_quatD.copy(this._restHeadWorldQuaternion).invert());
+  }
+  /**
+   * Get its LookAt direction in world coordinate.
+   *
+   * @param target A target `THREE.Vector3`
+   */
+  getLookAtWorldDirection(target) {
+    this.getLookAtWorldQuaternion(_quatB2);
+    this.getFaceFrontQuaternion(_quatC);
+    return target.copy(VEC3_POSITIVE_Z).applyQuaternion(_quatB2).applyQuaternion(_quatC).applyEuler(this.getEuler(_eulerA));
+  }
+  /**
+   * Set its lookAt target position.
+   *
+   * Note that its result will be instantly overwritten if {@link VRMLookAtHead.autoUpdate} is enabled.
+   *
+   * If you want to track an object continuously, you might want to use {@link target} instead.
+   *
+   * @param position A target position, in world space
+   */
+  lookAt(position) {
+    const headRotDiffInv = _quatA5.copy(this._restHeadWorldQuaternion).multiply(quatInvertCompat(this.getLookAtWorldQuaternion(_quatB2)));
+    const headPos = this.getLookAtWorldPosition(_v3B3);
+    const lookAtDir = _v3C.copy(position).sub(headPos).applyQuaternion(headRotDiffInv).normalize();
+    const [azimuthFrom, altitudeFrom] = calcAzimuthAltitude(this.faceFront);
+    const [azimuthTo, altitudeTo] = calcAzimuthAltitude(lookAtDir);
+    const yaw = sanitizeAngle(azimuthTo - azimuthFrom);
+    const pitch = sanitizeAngle(altitudeFrom - altitudeTo);
+    this._yaw = THREE14.MathUtils.RAD2DEG * yaw;
+    this._pitch = THREE14.MathUtils.RAD2DEG * pitch;
+    this._needsUpdate = true;
+  }
+  /**
+   * Update the VRMLookAtHead.
+   * If {@link autoUpdate} is enabled, this will make it look at the {@link target}.
+   *
+   * @param delta deltaTime, it isn't used though. You can use the parameter if you want to use this in your own extended {@link VRMLookAt}.
+   */
+  update(delta) {
+    if (this.target != null && this.autoUpdate) {
+      this.lookAt(this.target.getWorldPosition(_v3A5));
+    }
+    if (this._needsUpdate) {
+      this._needsUpdate = false;
+      this.applier.applyYawPitch(this._yaw, this._pitch);
+    }
+  }
+};
+_VRMLookAt.EULER_ORDER = "YXZ";
+var VRMLookAt = _VRMLookAt;
+
+// src/lookAt/VRMLookAtBoneApplier.ts
+var THREE15 = __toESM(require("three"), 1);
+var VEC3_POSITIVE_Z2 = new THREE15.Vector3(0, 0, 1);
+var _quatA6 = new THREE15.Quaternion();
+var _quatB3 = new THREE15.Quaternion();
+var _eulerA2 = new THREE15.Euler(0, 0, 0, "YXZ");
+var VRMLookAtBoneApplier = class {
+  /**
+   * Create a new {@link VRMLookAtBoneApplier}.
+   *
+   * @param humanoid A {@link VRMHumanoid}
+   * @param rangeMapHorizontalInner A {@link VRMLookAtRangeMap} used for inner transverse direction
+   * @param rangeMapHorizontalOuter A {@link VRMLookAtRangeMap} used for outer transverse direction
+   * @param rangeMapVerticalDown A {@link VRMLookAtRangeMap} used for down direction
+   * @param rangeMapVerticalUp A {@link VRMLookAtRangeMap} used for up direction
+   */
+  constructor(humanoid, rangeMapHorizontalInner, rangeMapHorizontalOuter, rangeMapVerticalDown, rangeMapVerticalUp) {
+    this.humanoid = humanoid;
+    this.rangeMapHorizontalInner = rangeMapHorizontalInner;
+    this.rangeMapHorizontalOuter = rangeMapHorizontalOuter;
+    this.rangeMapVerticalDown = rangeMapVerticalDown;
+    this.rangeMapVerticalUp = rangeMapVerticalUp;
+    this.faceFront = new THREE15.Vector3(0, 0, 1);
+    this._restQuatLeftEye = new THREE15.Quaternion();
+    this._restQuatRightEye = new THREE15.Quaternion();
+    this._restLeftEyeParentWorldQuat = new THREE15.Quaternion();
+    this._restRightEyeParentWorldQuat = new THREE15.Quaternion();
+    const leftEye = this.humanoid.getRawBoneNode("leftEye");
+    const rightEye = this.humanoid.getRawBoneNode("rightEye");
+    if (leftEye) {
+      this._restQuatLeftEye.copy(leftEye.quaternion);
+      getWorldQuaternionLite(leftEye.parent, this._restLeftEyeParentWorldQuat);
+    }
+    if (rightEye) {
+      this._restQuatRightEye.copy(rightEye.quaternion);
+      getWorldQuaternionLite(rightEye.parent, this._restRightEyeParentWorldQuat);
+    }
+  }
+  /**
+   * Apply the input angle to its associated VRM model.
+   *
+   * @param yaw Rotation around Y axis, in degree
+   * @param pitch Rotation around X axis, in degree
+   */
+  applyYawPitch(yaw, pitch) {
+    const leftEye = this.humanoid.getRawBoneNode("leftEye");
+    const rightEye = this.humanoid.getRawBoneNode("rightEye");
+    const leftEyeNormalized = this.humanoid.getNormalizedBoneNode("leftEye");
+    const rightEyeNormalized = this.humanoid.getNormalizedBoneNode("rightEye");
+    if (leftEye) {
+      if (pitch < 0) {
+        _eulerA2.x = -THREE15.MathUtils.DEG2RAD * this.rangeMapVerticalDown.map(-pitch);
+      } else {
+        _eulerA2.x = THREE15.MathUtils.DEG2RAD * this.rangeMapVerticalUp.map(pitch);
+      }
+      if (yaw < 0) {
+        _eulerA2.y = -THREE15.MathUtils.DEG2RAD * this.rangeMapHorizontalInner.map(-yaw);
+      } else {
+        _eulerA2.y = THREE15.MathUtils.DEG2RAD * this.rangeMapHorizontalOuter.map(yaw);
+      }
+      _quatA6.setFromEuler(_eulerA2);
+      this._getWorldFaceFrontQuat(_quatB3);
+      leftEyeNormalized.quaternion.copy(_quatB3).multiply(_quatA6).multiply(_quatB3.invert());
+      _quatA6.copy(this._restLeftEyeParentWorldQuat);
+      leftEye.quaternion.copy(leftEyeNormalized.quaternion).multiply(_quatA6).premultiply(_quatA6.invert()).multiply(this._restQuatLeftEye);
+    }
+    if (rightEye) {
+      if (pitch < 0) {
+        _eulerA2.x = -THREE15.MathUtils.DEG2RAD * this.rangeMapVerticalDown.map(-pitch);
+      } else {
+        _eulerA2.x = THREE15.MathUtils.DEG2RAD * this.rangeMapVerticalUp.map(pitch);
+      }
+      if (yaw < 0) {
+        _eulerA2.y = -THREE15.MathUtils.DEG2RAD * this.rangeMapHorizontalOuter.map(-yaw);
+      } else {
+        _eulerA2.y = THREE15.MathUtils.DEG2RAD * this.rangeMapHorizontalInner.map(yaw);
+      }
+      _quatA6.setFromEuler(_eulerA2);
+      this._getWorldFaceFrontQuat(_quatB3);
+      rightEyeNormalized.quaternion.copy(_quatB3).multiply(_quatA6).multiply(_quatB3.invert());
+      _quatA6.copy(this._restRightEyeParentWorldQuat);
+      rightEye.quaternion.copy(rightEyeNormalized.quaternion).multiply(_quatA6).premultiply(_quatA6.invert()).multiply(this._restQuatRightEye);
+    }
+  }
+  /**
+   * @deprecated Use {@link applyYawPitch} instead.
+   */
+  lookAt(euler) {
+    console.warn("VRMLookAtBoneApplier: lookAt() is deprecated. use apply() instead.");
+    const yaw = THREE15.MathUtils.RAD2DEG * euler.y;
+    const pitch = THREE15.MathUtils.RAD2DEG * euler.x;
+    this.applyYawPitch(yaw, pitch);
+  }
+  /**
+   * Get a quaternion that rotates the world-space +Z unit vector to the {@link faceFront} direction.
+   *
+   * @param target A target `THREE.Quaternion`
+   */
+  _getWorldFaceFrontQuat(target) {
+    if (this.faceFront.distanceToSquared(VEC3_POSITIVE_Z2) < 0.01) {
+      return target.identity();
+    }
+    const [faceFrontAzimuth, faceFrontAltitude] = calcAzimuthAltitude(this.faceFront);
+    _eulerA2.set(0, 0.5 * Math.PI + faceFrontAzimuth, faceFrontAltitude, "YZX");
+    return target.setFromEuler(_eulerA2);
+  }
+};
+/**
+ * Represent its type of applier.
+ */
+VRMLookAtBoneApplier.type = "bone";
+
+// src/lookAt/VRMLookAtExpressionApplier.ts
+var THREE16 = __toESM(require("three"), 1);
+var VRMLookAtExpressionApplier = class {
+  /**
+   * Create a new {@link VRMLookAtExpressionApplier}.
+   *
+   * @param expressions A {@link VRMExpressionManager}
+   * @param rangeMapHorizontalInner A {@link VRMLookAtRangeMap} used for inner transverse direction
+   * @param rangeMapHorizontalOuter A {@link VRMLookAtRangeMap} used for outer transverse direction
+   * @param rangeMapVerticalDown A {@link VRMLookAtRangeMap} used for down direction
+   * @param rangeMapVerticalUp A {@link VRMLookAtRangeMap} used for up direction
+   */
+  constructor(expressions, rangeMapHorizontalInner, rangeMapHorizontalOuter, rangeMapVerticalDown, rangeMapVerticalUp) {
+    this.expressions = expressions;
+    this.rangeMapHorizontalInner = rangeMapHorizontalInner;
+    this.rangeMapHorizontalOuter = rangeMapHorizontalOuter;
+    this.rangeMapVerticalDown = rangeMapVerticalDown;
+    this.rangeMapVerticalUp = rangeMapVerticalUp;
+  }
+  /**
+   * Apply the input angle to its associated VRM model.
+   *
+   * @param yaw Rotation around Y axis, in degree
+   * @param pitch Rotation around X axis, in degree
+   */
+  applyYawPitch(yaw, pitch) {
+    if (pitch < 0) {
+      this.expressions.setValue("lookDown", 0);
+      this.expressions.setValue("lookUp", this.rangeMapVerticalUp.map(-pitch));
+    } else {
+      this.expressions.setValue("lookUp", 0);
+      this.expressions.setValue("lookDown", this.rangeMapVerticalDown.map(pitch));
+    }
+    if (yaw < 0) {
+      this.expressions.setValue("lookLeft", 0);
+      this.expressions.setValue("lookRight", this.rangeMapHorizontalOuter.map(-yaw));
+    } else {
+      this.expressions.setValue("lookRight", 0);
+      this.expressions.setValue("lookLeft", this.rangeMapHorizontalOuter.map(yaw));
+    }
+  }
+  /**
+   * @deprecated Use {@link applyYawPitch} instead.
+   */
+  lookAt(euler) {
+    console.warn("VRMLookAtBoneApplier: lookAt() is deprecated. use apply() instead.");
+    const yaw = THREE16.MathUtils.RAD2DEG * euler.y;
+    const pitch = THREE16.MathUtils.RAD2DEG * euler.x;
+    this.applyYawPitch(yaw, pitch);
+  }
+};
+/**
+ * Represent its type of applier.
+ */
+VRMLookAtExpressionApplier.type = "expression";
+
+// src/lookAt/VRMLookAtRangeMap.ts
+var VRMLookAtRangeMap = class {
+  /**
+   * 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);
+  }
+};
+
+// src/lookAt/VRMLookAtLoaderPlugin.ts
+var POSSIBLE_SPEC_VERSIONS4 = /* @__PURE__ */ new Set(["1.0", "1.0-beta"]);
+var INPUT_MAX_VALUE_MINIMUM = 0.01;
+var VRMLookAtLoaderPlugin = class {
+  get name() {
+    return "VRMLookAtLoaderPlugin";
+  }
+  constructor(parser, options) {
+    this.parser = parser;
+    this.helperRoot = options == null ? void 0 : options.helperRoot;
+  }
+  afterRoot(gltf) {
+    return __async(this, null, function* () {
+      const vrmHumanoid = gltf.userData.vrmHumanoid;
+      if (vrmHumanoid === null) {
+        return;
+      } else if (vrmHumanoid === void 0) {
+        throw new Error("VRMLookAtLoaderPlugin: vrmHumanoid is undefined. VRMHumanoidLoaderPlugin have to be used first");
+      }
+      const vrmExpressionManager = gltf.userData.vrmExpressionManager;
+      if (vrmExpressionManager === null) {
+        return;
+      } else if (vrmExpressionManager === void 0) {
+        throw new Error(
+          "VRMLookAtLoaderPlugin: 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 __async(this, null, 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) {
+    return __async(this, null, function* () {
+      var _a, _b, _c;
+      const json = this.parser.json;
+      const isVRMUsed = ((_a = json.extensionsUsed) == null ? void 0 : _a.indexOf("VRMC_vrm")) !== -1;
+      if (!isVRMUsed) {
+        return null;
+      }
+      const extension = (_b = json.extensions) == null ? void 0 : _b["VRMC_vrm"];
+      if (!extension) {
+        return null;
+      }
+      const specVersion = extension.specVersion;
+      if (!POSSIBLE_SPEC_VERSIONS4.has(specVersion)) {
+        console.warn(`VRMLookAtLoaderPlugin: Unknown VRMC_vrm specVersion "${specVersion}"`);
+        return null;
+      }
+      const schemaLookAt = extension.lookAt;
+      if (!schemaLookAt) {
+        return null;
+      }
+      const defaultOutputScale = schemaLookAt.type === "expression" ? 1 : 10;
+      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 : [0, 0.06, 0]);
+      return lookAt;
+    });
+  }
+  _v1ImportRangeMap(schemaRangeMap, defaultOutputScale) {
+    var _a, _b;
+    let inputMaxValue = (_a = schemaRangeMap == null ? void 0 : schemaRangeMap.inputMaxValue) != null ? _a : 90;
+    const outputScale = (_b = schemaRangeMap == null ? void 0 : schemaRangeMap.outputScale) != null ? _b : defaultOutputScale;
+    if (inputMaxValue < INPUT_MAX_VALUE_MINIMUM) {
+      console.warn(
+        "VRMLookAtLoaderPlugin: inputMaxValue of a range map is too small. Consider reviewing the range map!"
+      );
+      inputMaxValue = INPUT_MAX_VALUE_MINIMUM;
+    }
+    return new VRMLookAtRangeMap(inputMaxValue, outputScale);
+  }
+  _v0Import(gltf, humanoid, expressions) {
+    return __async(this, null, function* () {
+      var _a, _b, _c, _d;
+      const json = this.parser.json;
+      const vrmExt = (_a = json.extensions) == null ? void 0 : _a.VRM;
+      if (!vrmExt) {
+        return null;
+      }
+      const schemaFirstPerson = vrmExt.firstPerson;
+      if (!schemaFirstPerson) {
+        return null;
+      }
+      const defaultOutputScale = schemaFirstPerson.lookAtTypeName === "BlendShape" ? 1 : 10;
+      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 : 0,
+          (_c = schemaFirstPerson.firstPersonBoneOffset.y) != null ? _c : 0.06,
+          -((_d = schemaFirstPerson.firstPersonBoneOffset.z) != null ? _d : 0)
+        );
+      } else {
+        lookAt.offsetFromHeadBone.set(0, 0.06, 0);
+      }
+      lookAt.faceFront.set(0, 0, -1);
+      if (applier instanceof VRMLookAtBoneApplier) {
+        applier.faceFront.set(0, 0, -1);
+      }
+      return lookAt;
+    });
+  }
+  _v0ImportDegreeMap(schemaDegreeMap, defaultOutputScale) {
+    var _a, _b;
+    const curve = schemaDegreeMap == null ? 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");
+    }
+    let xRange = (_a = schemaDegreeMap == null ? void 0 : schemaDegreeMap.xRange) != null ? _a : 90;
+    const yRange = (_b = schemaDegreeMap == null ? void 0 : schemaDegreeMap.yRange) != null ? _b : defaultOutputScale;
+    if (xRange < INPUT_MAX_VALUE_MINIMUM) {
+      console.warn("VRMLookAtLoaderPlugin: xRange of a degree map is too small. Consider reviewing the degree map!");
+      xRange = INPUT_MAX_VALUE_MINIMUM;
+    }
+    return new VRMLookAtRangeMap(xRange, yRange);
+  }
+  _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;
+  }
+};
+
+// src/lookAt/VRMLookAtTypeName.ts
+var VRMLookAtTypeName = {
+  Bone: "bone",
+  Expression: "expression"
+};
+
+// src/meta/VRMMetaLoaderPlugin.ts
+var THREE17 = __toESM(require("three"), 1);
+
+// src/utils/resolveURL.ts
+function resolveURL(url, path) {
+  if (typeof url !== "string" || url === "") return "";
+  if (/^https?:\/\//i.test(path) && /^\//.test(url)) {
+    path = path.replace(/(^https?:\/\/[^/]+).*/i, "$1");
+  }
+  if (/^(https?:)?\/\//i.test(url)) return url;
+  if (/^data:.*,.*$/i.test(url)) return url;
+  if (/^blob:.*$/i.test(url)) return url;
+  return path + url;
+}
+
+// src/meta/VRMMetaLoaderPlugin.ts
+var POSSIBLE_SPEC_VERSIONS5 = /* @__PURE__ */ new Set(["1.0", "1.0-beta"]);
+var VRMMetaLoaderPlugin = class {
+  get name() {
+    return "VRMMetaLoaderPlugin";
+  }
+  constructor(parser, options) {
+    var _a, _b, _c;
+    this.parser = parser;
+    this.needThumbnailImage = (_a = options == null ? void 0 : options.needThumbnailImage) != null ? _a : false;
+    this.acceptLicenseUrls = (_b = options == null ? void 0 : options.acceptLicenseUrls) != null ? _b : ["https://vrm.dev/licenses/1.0/"];
+    this.acceptV0Meta = (_c = options == null ? void 0 : options.acceptV0Meta) != null ? _c : true;
+  }
+  afterRoot(gltf) {
+    return __async(this, null, function* () {
+      gltf.userData.vrmMeta = yield this._import(gltf);
+    });
+  }
+  _import(gltf) {
+    return __async(this, null, 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) {
+    return __async(this, null, function* () {
+      var _a, _b, _c;
+      const json = this.parser.json;
+      const isVRMUsed = ((_a = json.extensionsUsed) == null ? void 0 : _a.indexOf("VRMC_vrm")) !== -1;
+      if (!isVRMUsed) {
+        return null;
+      }
+      const extension = (_b = json.extensions) == null ? void 0 : _b["VRMC_vrm"];
+      if (extension == null) {
+        return null;
+      }
+      const specVersion = extension.specVersion;
+      if (!POSSIBLE_SPEC_VERSIONS5.has(specVersion)) {
+        console.warn(`VRMMetaLoaderPlugin: Unknown VRMC_vrm specVersion "${specVersion}"`);
+        return null;
+      }
+      const schemaMeta = extension.meta;
+      if (!schemaMeta) {
+        return null;
+      }
+      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 = void 0;
+      if (this.needThumbnailImage && schemaMeta.thumbnailImage != null) {
+        thumbnailImage = (_c = yield this._extractGLTFImage(schemaMeta.thumbnailImage)) != null ? _c : void 0;
+      }
+      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) {
+    return __async(this, null, function* () {
+      var _a;
+      const json = this.parser.json;
+      const vrmExt = (_a = json.extensions) == null ? void 0 : _a.VRM;
+      if (!vrmExt) {
+        return null;
+      }
+      const schemaMeta = vrmExt.meta;
+      if (!schemaMeta) {
+        return null;
+      }
+      if (!this.acceptV0Meta) {
+        throw new Error("VRMMetaLoaderPlugin: Attempted to load VRM0.0 meta but acceptV0Meta is false");
+      }
+      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,
+        title: schemaMeta.title,
+        version: schemaMeta.version,
+        violentUssageName: schemaMeta.violentUssageName
+      };
+    });
+  }
+  _extractGLTFImage(index) {
+    return __async(this, null, function* () {
+      var _a;
+      const json = this.parser.json;
+      const source = (_a = json.images) == null ? 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;
+      }
+      let sourceURI = source.uri;
+      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 THREE17.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;
+      });
+    });
+  }
+};
+
+// src/VRMCore.ts
+var VRMCore = class {
+  /**
+   * Create a new VRM instance.
+   *
+   * @param params [[VRMParameters]] that represents components of the VRM
+   */
+  constructor(params) {
+    this.scene = params.scene;
+    this.meta = params.meta;
+    this.humanoid = params.humanoid;
+    this.expressionManager = params.expressionManager;
+    this.firstPerson = params.firstPerson;
+    this.lookAt = params.lookAt;
+  }
+  /**
+   * **You need to call this on your update loop.**
+   *
+   * This function updates every VRM components.
+   *
+   * @param delta deltaTime
+   */
+  update(delta) {
+    this.humanoid.update();
+    if (this.lookAt) {
+      this.lookAt.update(delta);
+    }
+    if (this.expressionManager) {
+      this.expressionManager.update();
+    }
+  }
+};
+
+// src/VRMCoreLoaderPlugin.ts
+var VRMCoreLoaderPlugin = class {
+  get name() {
+    return "VRMC_vrm";
+  }
+  constructor(parser, options) {
+    var _a, _b, _c, _d, _e;
+    this.parser = parser;
+    const helperRoot = options == null ? void 0 : options.helperRoot;
+    const autoUpdateHumanBones = options == null ? void 0 : options.autoUpdateHumanBones;
+    this.expressionPlugin = (_a = options == null ? void 0 : options.expressionPlugin) != null ? _a : new VRMExpressionLoaderPlugin(parser);
+    this.firstPersonPlugin = (_b = options == null ? void 0 : options.firstPersonPlugin) != null ? _b : new VRMFirstPersonLoaderPlugin(parser);
+    this.humanoidPlugin = (_c = options == null ? void 0 : options.humanoidPlugin) != null ? _c : new VRMHumanoidLoaderPlugin(parser, { helperRoot, autoUpdateHumanBones });
+    this.lookAtPlugin = (_d = options == null ? void 0 : options.lookAtPlugin) != null ? _d : new VRMLookAtLoaderPlugin(parser, { helperRoot });
+    this.metaPlugin = (_e = options == null ? void 0 : options.metaPlugin) != null ? _e : new VRMMetaLoaderPlugin(parser);
+  }
+  afterRoot(gltf) {
+    return __async(this, null, 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 meta = gltf.userData.vrmMeta;
+      const humanoid = gltf.userData.vrmHumanoid;
+      if (meta && humanoid) {
+        const vrmCore = new VRMCore({
+          scene: gltf.scene,
+          expressionManager: gltf.userData.vrmExpressionManager,
+          firstPerson: gltf.userData.vrmFirstPerson,
+          humanoid,
+          lookAt: gltf.userData.vrmLookAt,
+          meta
+        });
+        gltf.userData.vrmCore = vrmCore;
+      }
+    });
+  }
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/index.ts", "../src/expressions/VRMExpression.ts", "../src/expressions/VRMExpressionLoaderPlugin.ts", "../src/utils/gltfExtractPrimitivesFromNode.ts", "../src/utils/gltfGetAssociatedMaterialIndex.ts", "../src/expressions/VRMExpressionPresetName.ts", "../src/utils/saturate.ts", "../src/expressions/VRMExpressionManager.ts", "../src/expressions/VRMExpressionMaterialColorType.ts", "../src/expressions/VRMExpressionMaterialColorBind.ts", "../src/expressions/VRMExpressionMorphTargetBind.ts", "../src/expressions/VRMExpressionTextureTransformBind.ts", "../src/expressions/VRMExpressionOverrideType.ts", "../src/firstPerson/VRMFirstPerson.ts", "../src/firstPerson/VRMFirstPersonLoaderPlugin.ts", "../src/firstPerson/VRMFirstPersonMeshAnnotationType.ts", "../src/humanoid/helpers/VRMHumanoidHelper.ts", "../src/humanoid/VRMHumanBoneList.ts", "../src/humanoid/VRMHumanBoneName.ts", "../src/humanoid/VRMHumanBoneParentMap.ts", "../src/humanoid/VRMRig.ts", "../src/utils/quatInvertCompat.ts", "../src/humanoid/VRMHumanoidRig.ts", "../src/humanoid/VRMHumanoid.ts", "../src/humanoid/VRMRequiredHumanBoneName.ts", "../src/humanoid/VRMHumanoidLoaderPlugin.ts", "../src/lookAt/helpers/VRMLookAtHelper.ts", "../src/lookAt/helpers/utils/FanBufferGeometry.ts", "../src/lookAt/helpers/utils/LineAndSphereBufferGeometry.ts", "../src/lookAt/VRMLookAt.ts", "../src/utils/getWorldQuaternionLite.ts", "../src/lookAt/utils/calcAzimuthAltitude.ts", "../src/lookAt/utils/sanitizeAngle.ts", "../src/lookAt/VRMLookAtBoneApplier.ts", "../src/lookAt/VRMLookAtExpressionApplier.ts", "../src/lookAt/VRMLookAtRangeMap.ts", "../src/lookAt/VRMLookAtLoaderPlugin.ts", "../src/lookAt/VRMLookAtTypeName.ts", "../src/meta/VRMMetaLoaderPlugin.ts", "../src/utils/resolveURL.ts", "../src/VRMCore.ts", "../src/VRMCoreLoaderPlugin.ts"],
  "sourcesContent": ["export * from './expressions';\nexport * from './firstPerson';\nexport * from './humanoid';\nexport * from './lookAt';\nexport * from './meta';\n\nexport { VRMCore } from './VRMCore';\nexport { VRMCoreLoaderPlugin } from './VRMCoreLoaderPlugin';\nexport type { VRMCoreLoaderPluginOptions } from './VRMCoreLoaderPluginOptions';\nexport type { VRMCoreParameters } from './VRMCoreParameters';\n", "import * as THREE from 'three';\nimport { VRMExpressionBind } from './VRMExpressionBind';\nimport type { VRMExpressionOverrideType } from './VRMExpressionOverrideType';\n\n// animationMixer \u306E\u76E3\u8996\u5BFE\u8C61\u306F\u3001Scene \u306E\u4E2D\u306B\u5165\u3063\u3066\u3044\u308B\u5FC5\u8981\u304C\u3042\u308B\u3002\n// \u305D\u306E\u305F\u3081\u3001\u8868\u793A\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u3067\u306F\u306A\u3044\u3051\u308C\u3069\u3001Object3D \u3092\u7D99\u627F\u3057\u3066 Scene \u306B\u6295\u5165\u3067\u304D\u308B\u3088\u3046\u306B\u3059\u308B\u3002\nexport class VRMExpression extends THREE.Object3D {\n  /**\n   * Name of this expression.\n   * Distinguished with `name` since `name` will be conflicted with Object3D.\n   */\n  public expressionName: string;\n\n  /**\n   * The current weight of the expression.\n   */\n  public weight = 0.0;\n\n  /**\n   * Interpret values greater than 0.5 as 1.0, ortherwise 0.0.\n   */\n  public isBinary = false;\n\n  /**\n   * Specify how the expression overrides blink expressions.\n   */\n  public overrideBlink: VRMExpressionOverrideType = 'none';\n\n  /**\n   * Specify how the expression overrides lookAt expressions.\n   */\n  public overrideLookAt: VRMExpressionOverrideType = 'none';\n\n  /**\n   * Specify how the expression overrides mouth expressions.\n   */\n  public overrideMouth: VRMExpressionOverrideType = 'none';\n\n  private _binds: VRMExpressionBind[] = [];\n\n  override readonly type: string | 'VRMExpression';\n\n  /**\n   * A value represents how much it should override blink expressions.\n   * `0.0` == no override at all, `1.0` == completely block the expressions.\n   */\n  public get overrideBlinkAmount(): number {\n    if (this.overrideBlink === 'block') {\n      return 0.0 < this.weight ? 1.0 : 0.0;\n    } else if (this.overrideBlink === 'blend') {\n      return this.weight;\n    } else {\n      return 0.0;\n    }\n  }\n\n  /**\n   * A value represents how much it should override lookAt expressions.\n   * `0.0` == no override at all, `1.0` == completely block the expressions.\n   */\n  public get overrideLookAtAmount(): number {\n    if (this.overrideLookAt === 'block') {\n      return 0.0 < this.weight ? 1.0 : 0.0;\n    } else if (this.overrideLookAt === 'blend') {\n      return this.weight;\n    } else {\n      return 0.0;\n    }\n  }\n\n  /**\n   * A value represents how much it should override mouth expressions.\n   * `0.0` == no override at all, `1.0` == completely block the expressions.\n   */\n  public get overrideMouthAmount(): number {\n    if (this.overrideMouth === 'block') {\n      return 0.0 < this.weight ? 1.0 : 0.0;\n    } else if (this.overrideMouth === 'blend') {\n      return this.weight;\n    } else {\n      return 0.0;\n    }\n  }\n\n  constructor(expressionName: string) {\n    super();\n\n    this.name = `VRMExpression_${expressionName}`;\n    this.expressionName = expressionName;\n\n    // traverse \u6642\u306E\u6551\u6E08\u624B\u6BB5\u3068\u3057\u3066 Object3D \u3067\u306F\u306A\u3044\u3053\u3068\u3092\u660E\u793A\u3057\u3066\u304A\u304F\n    this.type = 'VRMExpression';\n\n    // \u8868\u793A\u76EE\u7684\u306E\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u3067\u306F\u306A\u3044\u306E\u3067\u3001\u8CA0\u8377\u8EFD\u6E1B\u306E\u305F\u3081\u306B visible \u3092 false \u306B\u3057\u3066\u304A\u304F\u3002\n    // \u3053\u308C\u306B\u3088\u308A\u3001\u3053\u306E\u30A4\u30F3\u30B9\u30BF\u30F3\u30B9\u306B\u5BFE\u3059\u308B\u6BCE\u30D5\u30EC\u30FC\u30E0\u306E matrix \u81EA\u52D5\u8A08\u7B97\u3092\u7701\u7565\u3067\u304D\u308B\u3002\n    this.visible = false;\n  }\n\n  public addBind(bind: VRMExpressionBind): void {\n    this._binds.push(bind);\n  }\n\n  /**\n   * Apply weight to every assigned blend shapes.\n   * Should be called every frame.\n   */\n  public applyWeight(options?: {\n    /**\n     * Multiplies a value to its weight to apply.\n     * Intended to be used for overriding an expression weight by another expression.\n     * See also: {@link overrideBlink}, {@link overrideLookAt}, {@link overrideMouth}\n     */\n    multiplier?: number;\n  }): void {\n    let actualWeight = this.isBinary ? (this.weight <= 0.5 ? 0.0 : 1.0) : this.weight;\n    actualWeight *= options?.multiplier ?? 1.0;\n\n    this._binds.forEach((bind) => bind.applyWeight(actualWeight));\n  }\n\n  /**\n   * Clear previously assigned blend shapes.\n   */\n  public clearAppliedWeight(): void {\n    this._binds.forEach((bind) => bind.clearAppliedWeight());\n  }\n}\n", "import type * as V0VRM from '@pixiv/types-vrm-0.0';\nimport type * as V1VRMSchema from '@pixiv/types-vrmc-vrm-1.0';\nimport * as THREE from 'three';\nimport { GLTF, GLTFLoaderPlugin, GLTFParser } from 'three/examples/jsm/loaders/GLTFLoader.js';\nimport { gltfExtractPrimitivesFromNode } from '../utils/gltfExtractPrimitivesFromNode';\nimport { gltfGetAssociatedMaterialIndex } from '../utils/gltfGetAssociatedMaterialIndex';\nimport { VRMExpression } from './VRMExpression';\nimport { VRMExpressionManager } from './VRMExpressionManager';\nimport { v0ExpressionMaterialColorMap } from './VRMExpressionMaterialColorType';\nimport { VRMExpressionMaterialColorBind } from './VRMExpressionMaterialColorBind';\nimport { VRMExpressionMorphTargetBind } from './VRMExpressionMorphTargetBind';\nimport { VRMExpressionPresetName } from './VRMExpressionPresetName';\nimport { VRMExpressionTextureTransformBind } from './VRMExpressionTextureTransformBind';\nimport { GLTF as GLTFSchema } from '@gltf-transform/core';\n\n/**\n * Possible spec versions it recognizes.\n */\nconst POSSIBLE_SPEC_VERSIONS = new Set(['1.0', '1.0-beta']);\n\n/**\n * A plugin of GLTFLoader that imports a {@link VRMExpressionManager} from a VRM extension of a GLTF.\n */\nexport class VRMExpressionLoaderPlugin implements GLTFLoaderPlugin {\n  public static readonly v0v1PresetNameMap: { [v0Name in V0VRM.BlendShapePresetName]?: VRMExpressionPresetName } = {\n    a: 'aa',\n    e: 'ee',\n    i: 'ih',\n    o: 'oh',\n    u: 'ou',\n    blink: 'blink',\n    joy: 'happy',\n    angry: 'angry',\n    sorrow: 'sad',\n    fun: 'relaxed',\n    lookup: 'lookUp',\n    lookdown: 'lookDown',\n    lookleft: 'lookLeft',\n    lookright: 'lookRight',\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    blink_l: 'blinkLeft',\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    blink_r: 'blinkRight',\n    neutral: 'neutral',\n  };\n\n  public readonly parser: GLTFParser;\n\n  public get name(): string {\n    // We should use the extension name instead but we have multiple plugins for an extension...\n    return 'VRMExpressionLoaderPlugin';\n  }\n\n  public constructor(parser: GLTFParser) {\n    this.parser = parser;\n  }\n\n  public async afterRoot(gltf: GLTF): Promise<void> {\n    gltf.userData.vrmExpressionManager = await this._import(gltf);\n  }\n\n  /**\n   * Import a {@link VRMExpressionManager} from a VRM.\n   *\n   * @param gltf A parsed result of GLTF taken from GLTFLoader\n   */\n  private async _import(gltf: GLTF): Promise<VRMExpressionManager | null> {\n    const v1Result = await this._v1Import(gltf);\n    if (v1Result) {\n      return v1Result;\n    }\n\n    const v0Result = await this._v0Import(gltf);\n    if (v0Result) {\n      return v0Result;\n    }\n\n    return null;\n  }\n\n  private async _v1Import(gltf: GLTF): Promise<VRMExpressionManager | null> {\n    const json = this.parser.json as GLTFSchema.IGLTF;\n\n    // early abort if it doesn't use vrm\n    const isVRMUsed = json.extensionsUsed?.indexOf('VRMC_vrm') !== -1;\n    if (!isVRMUsed) {\n      return null;\n    }\n\n    const extension = json.extensions?.['VRMC_vrm'] as V1VRMSchema.VRMCVRM | undefined;\n    if (!extension) {\n      return null;\n    }\n\n    const specVersion = extension.specVersion;\n    if (!POSSIBLE_SPEC_VERSIONS.has(specVersion)) {\n      console.warn(`VRMExpressionLoaderPlugin: Unknown VRMC_vrm specVersion \"${specVersion}\"`);\n      return null;\n    }\n\n    const schemaExpressions = extension.expressions;\n    if (!schemaExpressions) {\n      return null;\n    }\n\n    // list expressions\n    const presetNameSet = new Set<string>(Object.values(VRMExpressionPresetName));\n    const nameSchemaExpressionMap = new Map<string, V1VRMSchema.Expression>();\n\n    if (schemaExpressions.preset != null) {\n      Object.entries(schemaExpressions.preset).forEach(([name, schemaExpression]) => {\n        if (schemaExpression == null) {\n          return;\n        } // typescript\n\n        if (!presetNameSet.has(name)) {\n          console.warn(`VRMExpressionLoaderPlugin: Unknown preset name \"${name}\" detected. Ignoring the expression`);\n          return;\n        }\n\n        nameSchemaExpressionMap.set(name, schemaExpression);\n      });\n    }\n\n    if (schemaExpressions.custom != null) {\n      Object.entries(schemaExpressions.custom).forEach(([name, schemaExpression]) => {\n        if (presetNameSet.has(name)) {\n          console.warn(\n            `VRMExpressionLoaderPlugin: Custom expression cannot have preset name \"${name}\". Ignoring the expression`,\n          );\n          return;\n        }\n\n        nameSchemaExpressionMap.set(name, schemaExpression);\n      });\n    }\n\n    // prepare manager\n    const manager = new VRMExpressionManager();\n\n    // load expressions\n    await Promise.all(\n      Array.from(nameSchemaExpressionMap.entries()).map(async ([name, schemaExpression]) => {\n        const expression = new VRMExpression(name);\n        gltf.scene.add(expression);\n\n        expression.isBinary = schemaExpression.isBinary ?? false;\n        expression.overrideBlink = schemaExpression.overrideBlink ?? 'none';\n        expression.overrideLookAt = schemaExpression.overrideLookAt ?? 'none';\n        expression.overrideMouth = schemaExpression.overrideMouth ?? 'none';\n\n        schemaExpression.morphTargetBinds?.forEach(async (bind) => {\n          if (bind.node === undefined || bind.index === undefined) {\n            return;\n          }\n\n          const primitives = (await gltfExtractPrimitivesFromNode(gltf, bind.node))!;\n          const morphTargetIndex = bind.index;\n\n          // check if the mesh has the target morph target\n          if (\n            !primitives.every(\n              (primitive) =>\n                Array.isArray(primitive.morphTargetInfluences) &&\n                morphTargetIndex < primitive.morphTargetInfluences.length,\n            )\n          ) {\n            console.warn(\n              `VRMExpressionLoaderPlugin: ${schemaExpression.name} attempts to index morph #${morphTargetIndex} but not found.`,\n            );\n            return;\n          }\n\n          expression.addBind(\n            new VRMExpressionMorphTargetBind({\n              primitives,\n              index: morphTargetIndex,\n              weight: bind.weight ?? 1.0,\n            }),\n          );\n        });\n\n        if (schemaExpression.materialColorBinds || schemaExpression.textureTransformBinds) {\n          // list up every material in `gltf.scene`\n          const gltfMaterials: THREE.Material[] = [];\n          gltf.scene.traverse((object) => {\n            const material = (object as any).material as THREE.Material | undefined;\n            if (material) {\n              gltfMaterials.push(material);\n            }\n          });\n\n          schemaExpression.materialColorBinds?.forEach(async (bind) => {\n            const materials = gltfMaterials.filter((material) => {\n              const materialIndex = gltfGetAssociatedMaterialIndex(this.parser, material);\n              return bind.material === materialIndex;\n            });\n\n            materials.forEach((material) => {\n              expression.addBind(\n                new VRMExpressionMaterialColorBind({\n                  material,\n                  type: bind.type,\n                  targetValue: new THREE.Color().fromArray(bind.targetValue),\n                  targetAlpha: bind.targetValue[3],\n                }),\n              );\n            });\n          });\n\n          schemaExpression.textureTransformBinds?.forEach(async (bind) => {\n            const materials = gltfMaterials.filter((material) => {\n              const materialIndex = gltfGetAssociatedMaterialIndex(this.parser, material);\n              return bind.material === materialIndex;\n            });\n\n            materials.forEach((material) => {\n              expression.addBind(\n                new VRMExpressionTextureTransformBind({\n                  material,\n                  offset: new THREE.Vector2().fromArray(bind.offset ?? [0.0, 0.0]),\n                  scale: new THREE.Vector2().fromArray(bind.scale ?? [1.0, 1.0]),\n                }),\n              );\n            });\n          });\n        }\n\n        manager.registerExpression(expression);\n      }),\n    );\n\n    return manager;\n  }\n\n  private async _v0Import(gltf: GLTF): Promise<VRMExpressionManager | null> {\n    const json = this.parser.json as GLTFSchema.IGLTF;\n\n    // early abort if it doesn't use vrm\n    const vrmExt = json.extensions?.VRM as V0VRM.VRM | undefined;\n    if (!vrmExt) {\n      return null;\n    }\n\n    const schemaBlendShape = vrmExt.blendShapeMaster;\n    if (!schemaBlendShape) {\n      return null;\n    }\n\n    const manager = new VRMExpressionManager();\n\n    const schemaBlendShapeGroups = schemaBlendShape.blendShapeGroups;\n    if (!schemaBlendShapeGroups) {\n      return manager;\n    }\n\n    const blendShapeNameSet = new Set<string>();\n\n    await Promise.all(\n      schemaBlendShapeGroups.map(async (schemaGroup) => {\n        const v0PresetName = schemaGroup.presetName;\n        const v1PresetName =\n          (v0PresetName != null && VRMExpressionLoaderPlugin.v0v1PresetNameMap[v0PresetName]) || null;\n        const name = v1PresetName ?? schemaGroup.name;\n\n        if (name == null) {\n          console.warn('VRMExpressionLoaderPlugin: One of custom expressions has no name. Ignoring the expression');\n          return;\n        }\n\n        // duplication check\n        if (blendShapeNameSet.has(name)) {\n          console.warn(\n            `VRMExpressionLoaderPlugin: An expression preset ${v0PresetName} has duplicated entries. Ignoring the expression`,\n          );\n          return;\n        }\n\n        blendShapeNameSet.add(name);\n\n        const expression = new VRMExpression(name);\n        gltf.scene.add(expression);\n\n        expression.isBinary = schemaGroup.isBinary ?? false;\n        // v0 doesn't have ignore properties\n\n        // Bind morphTarget\n        if (schemaGroup.binds) {\n          schemaGroup.binds.forEach(async (bind) => {\n            if (bind.mesh === undefined || bind.index === undefined) {\n              return;\n            }\n\n            const nodesUsingMesh: number[] = [];\n            json.nodes?.forEach((node, i) => {\n              if (node.mesh === bind.mesh) {\n                nodesUsingMesh.push(i);\n              }\n            });\n\n            const morphTargetIndex = bind.index;\n\n            await Promise.all(\n              nodesUsingMesh.map(async (nodeIndex) => {\n                const primitives = (await gltfExtractPrimitivesFromNode(gltf, nodeIndex))!;\n\n                // check if the mesh has the target morph target\n                if (\n                  !primitives.every(\n                    (primitive) =>\n                      Array.isArray(primitive.morphTargetInfluences) &&\n                      morphTargetIndex < primitive.morphTargetInfluences.length,\n                  )\n                ) {\n                  console.warn(\n                    `VRMExpressionLoaderPlugin: ${schemaGroup.name} attempts to index ${morphTargetIndex}th morph but not found.`,\n                  );\n                  return;\n                }\n\n                expression.addBind(\n                  new VRMExpressionMorphTargetBind({\n                    primitives,\n                    index: morphTargetIndex,\n                    weight: 0.01 * (bind.weight ?? 100), // narrowing the range from [ 0.0 - 100.0 ] to [ 0.0 - 1.0 ]\n                  }),\n                );\n              }),\n            );\n          });\n        }\n\n        // Bind MaterialColor and TextureTransform\n        const materialValues = schemaGroup.materialValues;\n        if (materialValues && materialValues.length !== 0) {\n          materialValues.forEach((materialValue) => {\n            if (\n              materialValue.materialName === undefined ||\n              materialValue.propertyName === undefined ||\n              materialValue.targetValue === undefined\n            ) {\n              return;\n            }\n\n            /**\n             * \u30A2\u30D0\u30BF\u30FC\u306E\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u306B\u8A2D\u5B9A\u3055\u308C\u3066\u3044\u308B\u30DE\u30C6\u30EA\u30A2\u30EB\u306E\u5185\u304B\u3089\n             * materialValue\u3067\u6307\u5B9A\u3055\u308C\u3066\u3044\u308B\u30DE\u30C6\u30EA\u30A2\u30EB\u3092\u96C6\u3081\u308B\u3002\n             *\n             * \u7279\u5B9A\u306B\u306F\u540D\u524D\u3092\u4F7F\u7528\u3059\u308B\u3002\n             * \u30A2\u30A6\u30C8\u30E9\u30A4\u30F3\u63CF\u753B\u7528\u306E\u30DE\u30C6\u30EA\u30A2\u30EB\u3082\u540C\u6642\u306B\u96C6\u3081\u308B\u3002\n             */\n            const materials: THREE.Material[] = [];\n            gltf.scene.traverse((object) => {\n              if ((object as any).material) {\n                const material: THREE.Material[] | THREE.Material = (object as any).material;\n                if (Array.isArray(material)) {\n                  materials.push(\n                    ...material.filter(\n                      (mtl) =>\n                        (mtl.name === materialValue.materialName! ||\n                          mtl.name === materialValue.materialName! + ' (Outline)') &&\n                        materials.indexOf(mtl) === -1,\n                    ),\n                  );\n                } else if (material.name === materialValue.materialName && materials.indexOf(material) === -1) {\n                  materials.push(material);\n                }\n              }\n            });\n\n            const materialPropertyName = materialValue.propertyName;\n            materials.forEach((material) => {\n              // TextureTransformBind\n              if (materialPropertyName === '_MainTex_ST') {\n                const scale = new THREE.Vector2(materialValue.targetValue![0], materialValue.targetValue![1]);\n                const offset = new THREE.Vector2(materialValue.targetValue![2], materialValue.targetValue![3]);\n\n                offset.y = 1.0 - offset.y - scale.y;\n\n                expression.addBind(\n                  new VRMExpressionTextureTransformBind({\n                    material,\n                    scale,\n                    offset,\n                  }),\n                );\n\n                return;\n              }\n\n              // MaterialColorBind\n              const materialColorType = v0ExpressionMaterialColorMap[materialPropertyName];\n              if (materialColorType) {\n                expression.addBind(\n                  new VRMExpressionMaterialColorBind({\n                    material,\n                    type: materialColorType,\n                    targetValue: new THREE.Color().fromArray(materialValue.targetValue!),\n                    targetAlpha: materialValue.targetValue![3],\n                  }),\n                );\n\n                return;\n              }\n\n              console.warn(materialPropertyName + ' is not supported');\n            });\n          });\n        }\n\n        manager.registerExpression(expression);\n      }),\n    );\n\n    return manager;\n  }\n}\n", "import type * as THREE from 'three';\nimport type { GLTF } from 'three/examples/jsm/loaders/GLTFLoader.js';\nimport { GLTF as GLTFSchema } from '@gltf-transform/core';\n\nfunction extractPrimitivesInternal(gltf: GLTF, nodeIndex: number, node: THREE.Object3D): THREE.Mesh[] | null {\n  const json = gltf.parser.json as GLTFSchema.IGLTF;\n\n  /**\n   * Let's list up every possible patterns that parsed gltf nodes with a mesh can have,,,\n   *\n   * \"*\" indicates that those meshes should be listed up using this function\n   *\n   * ### A node with a (mesh, a signle primitive)\n   *\n   * - `THREE.Mesh`: The only primitive of the mesh *\n   *\n   * ### A node with a (mesh, multiple primitives)\n   *\n   * - `THREE.Group`: The root of the mesh\n   *   - `THREE.Mesh`: A primitive of the mesh *\n   *   - `THREE.Mesh`: A primitive of the mesh (2) *\n   *\n   * ### A node with a (mesh, multiple primitives) AND (a child with a mesh, a single primitive)\n   *\n   * - `THREE.Group`: The root of the mesh\n   *   - `THREE.Mesh`: A primitive of the mesh *\n   *   - `THREE.Mesh`: A primitive of the mesh (2) *\n   *   - `THREE.Mesh`: A primitive of a MESH OF THE CHILD\n   *\n   * ### A node with a (mesh, multiple primitives) AND (a child with a mesh, multiple primitives)\n   *\n   * - `THREE.Group`: The root of the mesh\n   *   - `THREE.Mesh`: A primitive of the mesh *\n   *   - `THREE.Mesh`: A primitive of the mesh (2) *\n   *   - `THREE.Group`: The root of a MESH OF THE CHILD\n   *     - `THREE.Mesh`: A primitive of the mesh of the child\n   *     - `THREE.Mesh`: A primitive of the mesh of the child (2)\n   *\n   * ### A node with a (mesh, multiple primitives) BUT the node is a bone\n   *\n   * - `THREE.Bone`: The root of the node, as a bone\n   *   - `THREE.Group`: The root of the mesh\n   *     - `THREE.Mesh`: A primitive of the mesh *\n   *     - `THREE.Mesh`: A primitive of the mesh (2) *\n   *\n   * ### A node with a (mesh, multiple primitives) AND (a child with a mesh, multiple primitives) BUT the node is a bone\n   *\n   * - `THREE.Bone`: The root of the node, as a bone\n   *   - `THREE.Group`: The root of the mesh\n   *     - `THREE.Mesh`: A primitive of the mesh *\n   *     - `THREE.Mesh`: A primitive of the mesh (2) *\n   *   - `THREE.Group`: The root of a MESH OF THE CHILD\n   *     - `THREE.Mesh`: A primitive of the mesh of the child\n   *     - `THREE.Mesh`: A primitive of the mesh of the child (2)\n   *\n   * ...I will take a strategy that traverses the root of the node and take first (primitiveCount) meshes.\n   */\n\n  // Make sure that the node has a mesh\n  const schemaNode = json.nodes?.[nodeIndex];\n  if (schemaNode == null) {\n    console.warn(`extractPrimitivesInternal: Attempt to use nodes[${nodeIndex}] of glTF but the node doesn't exist`);\n    return null;\n  }\n\n  const meshIndex = schemaNode.mesh;\n  if (meshIndex == null) {\n    return null;\n  }\n\n  // How many primitives the mesh has?\n  const schemaMesh = json.meshes?.[meshIndex];\n  if (schemaMesh == null) {\n    console.warn(`extractPrimitivesInternal: Attempt to use meshes[${meshIndex}] of glTF but the mesh doesn't exist`);\n    return null;\n  }\n\n  const primitiveCount = schemaMesh.primitives.length;\n\n  // Traverse the node and take first (primitiveCount) meshes\n  const primitives: THREE.Mesh[] = [];\n  node.traverse((object) => {\n    if (primitives.length < primitiveCount) {\n      if ((object as any).isMesh) {\n        primitives.push(object as THREE.Mesh);\n      }\n    }\n  });\n\n  return primitives;\n}\n\n/**\n * Extract primitives ( `THREE.Mesh[]` ) of a node from a loaded GLTF.\n * The main purpose of this function is to distinguish primitives and children from a node that has both meshes and children.\n *\n * It utilizes the behavior that GLTFLoader adds mesh primitives to the node object ( `THREE.Group` ) first then adds its children.\n *\n * @param gltf A GLTF object taken from GLTFLoader\n * @param nodeIndex The index of the node\n */\nexport async function gltfExtractPrimitivesFromNode(gltf: GLTF, nodeIndex: number): Promise<THREE.Mesh[] | null> {\n  const node: THREE.Object3D = await gltf.parser.getDependency('node', nodeIndex);\n  return extractPrimitivesInternal(gltf, nodeIndex, node);\n}\n\n/**\n * Extract primitives ( `THREE.Mesh[]` ) of nodes from a loaded GLTF.\n * See {@link gltfExtractPrimitivesFromNode} for more details.\n *\n * It returns a map from node index to extraction result.\n * If a node does not have a mesh, the entry for the node will not be put in the returning map.\n *\n * @param gltf A GLTF object taken from GLTFLoader\n */\nexport async function gltfExtractPrimitivesFromNodes(gltf: GLTF): Promise<Map<number, THREE.Mesh[]>> {\n  const nodes: THREE.Object3D[] = await gltf.parser.getDependencies('node');\n  const map = new Map<number, THREE.Mesh[]>();\n\n  nodes.forEach((node, index) => {\n    const result = extractPrimitivesInternal(gltf, index, node);\n    if (result != null) {\n      map.set(index, result);\n    }\n  });\n\n  return map;\n}\n", "import * as THREE from 'three';\nimport { GLTFParser } from 'three/examples/jsm/loaders/GLTFLoader.js';\n\n/**\n * Get a material definition index of glTF from associated material.\n * It's basically a comat code between Three.js r133 or above and previous versions.\n * @param parser GLTFParser\n * @param material A material of gltf\n * @returns Material definition index of glTF\n */\nexport function gltfGetAssociatedMaterialIndex(parser: GLTFParser, material: THREE.Material): number | null {\n  const threeRevision = parseInt(THREE.REVISION, 10);\n\n  let index: number | null = null;\n\n  if (threeRevision >= 133) {\n    index = parser.associations.get(material)?.materials ?? null;\n  } else {\n    // COMPAT: structure of `parser.associations` has been changed @ r133\n    // See: https://github.com/mrdoob/three.js/pull/21737\n    // Ref: https://github.com/three-types/three-ts-types/commit/5246676e479b61a9ff2db71df4119f6f1462580d\n    type GLTFReferencePre133 = {\n      type: 'materials' | 'nodes' | 'textures' | 'meshes';\n      index: number;\n    };\n\n    type GLTFAssociationsPre133 = Map<THREE.Object3D | THREE.Material | THREE.Texture, GLTFReferencePre133>;\n\n    const associations = parser.associations as GLTFAssociationsPre133;\n\n    const reference = associations.get(material);\n\n    if (reference?.type === 'materials') {\n      index = reference.index;\n    }\n  }\n\n  return index;\n}\n", "/* eslint-disable @typescript-eslint/naming-convention */\n\nexport const VRMExpressionPresetName = {\n  Aa: 'aa',\n  Ih: 'ih',\n  Ou: 'ou',\n  Ee: 'ee',\n  Oh: 'oh',\n  Blink: 'blink',\n  Happy: 'happy',\n  Angry: 'angry',\n  Sad: 'sad',\n  Relaxed: 'relaxed',\n  LookUp: 'lookUp',\n  Surprised: 'surprised',\n  LookDown: 'lookDown',\n  LookLeft: 'lookLeft',\n  LookRight: 'lookRight',\n  BlinkLeft: 'blinkLeft',\n  BlinkRight: 'blinkRight',\n  Neutral: 'neutral',\n} as const;\n\nexport type VRMExpressionPresetName = typeof VRMExpressionPresetName[keyof typeof VRMExpressionPresetName];\n", "/**\n * Clamp the input value within [0.0 - 1.0].\n *\n * @param value The input value\n */\nexport function saturate(value: number): number {\n  return Math.max(Math.min(value, 1.0), 0.0);\n}\n", "import { VRMExpressionPresetName } from './VRMExpressionPresetName';\nimport { saturate } from '../utils/saturate';\nimport type { VRMExpression } from './VRMExpression';\n\nexport class VRMExpressionManager {\n  /**\n   * A set of name or preset name of expressions that will be overridden by {@link VRMExpression.overrideBlink}.\n   */\n  public blinkExpressionNames = ['blink', 'blinkLeft', 'blinkRight'];\n\n  /**\n   * A set of name or preset name of expressions that will be overridden by {@link VRMExpression.overrideLookAt}.\n   */\n  public lookAtExpressionNames = ['lookLeft', 'lookRight', 'lookUp', 'lookDown'];\n\n  /**\n   * A set of name or preset name of expressions that will be overridden by {@link VRMExpression.overrideMouth}.\n   */\n  public mouthExpressionNames = ['aa', 'ee', 'ih', 'oh', 'ou'];\n\n  /**\n   * A set of {@link VRMExpression}.\n   * When you want to register expressions, use {@link registerExpression}\n   */\n  private _expressions: VRMExpression[] = [];\n  public get expressions(): VRMExpression[] {\n    return this._expressions.concat();\n  }\n\n  /**\n   * A map from name to expression.\n   */\n  private _expressionMap: { [name: string]: VRMExpression } = {};\n  public get expressionMap(): { [name: string]: VRMExpression } {\n    return Object.assign({}, this._expressionMap);\n  }\n\n  /**\n   * A map from name to expression, but excluding custom expressions.\n   */\n  public get presetExpressionMap(): { [name in VRMExpressionPresetName]?: VRMExpression } {\n    const result: { [name in VRMExpressionPresetName]?: VRMExpression } = {};\n\n    const presetNameSet = new Set<string>(Object.values(VRMExpressionPresetName));\n\n    Object.entries(this._expressionMap).forEach(([name, expression]) => {\n      if (presetNameSet.has(name)) {\n        result[name as VRMExpressionPresetName] = expression;\n      }\n    });\n\n    return result;\n  }\n\n  /**\n   * A map from name to expression, but excluding preset expressions.\n   */\n  public get customExpressionMap(): { [name: string]: VRMExpression } {\n    const result: { [name: string]: VRMExpression } = {};\n\n    const presetNameSet = new Set<string>(Object.values(VRMExpressionPresetName));\n\n    Object.entries(this._expressionMap).forEach(([name, expression]) => {\n      if (!presetNameSet.has(name)) {\n        result[name] = expression;\n      }\n    });\n\n    return result;\n  }\n\n  /**\n   * Create a new {@link VRMExpressionManager}.\n   */\n  public constructor() {\n    // do nothing\n  }\n\n  /**\n   * Copy the given {@link VRMExpressionManager} into this one.\n   * @param source The {@link VRMExpressionManager} you want to copy\n   * @returns this\n   */\n  public copy(source: VRMExpressionManager): this {\n    // first unregister all the expression it has\n    const expressions = this._expressions.concat();\n    expressions.forEach((expression) => {\n      this.unregisterExpression(expression);\n    });\n\n    // then register all the expression of the source\n    source._expressions.forEach((expression) => {\n      this.registerExpression(expression);\n    });\n\n    // copy remaining members\n    this.blinkExpressionNames = source.blinkExpressionNames.concat();\n    this.lookAtExpressionNames = source.lookAtExpressionNames.concat();\n    this.mouthExpressionNames = source.mouthExpressionNames.concat();\n\n    return this;\n  }\n\n  /**\n   * Returns a clone of this {@link VRMExpressionManager}.\n   * @returns Copied {@link VRMExpressionManager}\n   */\n  public clone(): VRMExpressionManager {\n    return new VRMExpressionManager().copy(this);\n  }\n\n  /**\n   * Return a registered expression.\n   * If it cannot find an expression, it will return `null` instead.\n   *\n   * @param name Name or preset name of the expression\n   */\n  public getExpression(name: VRMExpressionPresetName | string): VRMExpression | null {\n    return this._expressionMap[name] ?? null;\n  }\n\n  /**\n   * Register an expression.\n   *\n   * @param expression {@link VRMExpression} that describes the expression\n   */\n  public registerExpression(expression: VRMExpression): void {\n    this._expressions.push(expression);\n    this._expressionMap[expression.expressionName] = expression;\n  }\n\n  /**\n   * Unregister an expression.\n   *\n   * @param expression The expression you want to unregister\n   */\n  public unregisterExpression(expression: VRMExpression): void {\n    const index = this._expressions.indexOf(expression);\n    if (index === -1) {\n      console.warn('VRMExpressionManager: The specified expressions is not registered');\n    }\n\n    this._expressions.splice(index, 1);\n    delete this._expressionMap[expression.expressionName];\n  }\n\n  /**\n   * Get the current weight of the specified expression.\n   * If it doesn't have an expression of given name, it will return `null` instead.\n   *\n   * @param name Name of the expression\n   */\n  public getValue(name: VRMExpressionPresetName | string): number | null {\n    const expression = this.getExpression(name);\n    return expression?.weight ?? null;\n  }\n\n  /**\n   * Set a weight to the specified expression.\n   *\n   * @param name Name of the expression\n   * @param weight Weight\n   */\n  public setValue(name: VRMExpressionPresetName | string, weight: number): void {\n    const expression = this.getExpression(name);\n    if (expression) {\n      expression.weight = saturate(weight);\n    }\n  }\n\n  /**\n   * Get a track name of specified expression.\n   * This track name is needed to manipulate its expression via keyframe animations.\n   *\n   * @example Manipulate an expression using keyframe animation\n   * ```js\n   * const trackName = vrm.expressionManager.getExpressionTrackName( 'blink' );\n   * const track = new THREE.NumberKeyframeTrack(\n   *   name,\n   *   [ 0.0, 0.5, 1.0 ], // times\n   *   [ 0.0, 1.0, 0.0 ] // values\n   * );\n   *\n   * const clip = new THREE.AnimationClip(\n   *   'blink', // name\n   *   1.0, // duration\n   *   [ track ] // tracks\n   * );\n   *\n   * const mixer = new THREE.AnimationMixer( vrm.scene );\n   * const action = mixer.clipAction( clip );\n   * action.play();\n   * ```\n   *\n   * @param name Name of the expression\n   */\n  public getExpressionTrackName(name: VRMExpressionPresetName | string): string | null {\n    const expression = this.getExpression(name);\n    return expression ? `${expression.name}.weight` : null;\n  }\n\n  /**\n   * Update every expressions.\n   */\n  public update(): void {\n    // see how much we should override certain expressions\n    const weightMultipliers = this._calculateWeightMultipliers();\n\n    // reset expression binds first\n    this._expressions.forEach((expression) => {\n      expression.clearAppliedWeight();\n    });\n\n    // then apply binds\n    this._expressions.forEach((expression) => {\n      let multiplier = 1.0;\n      const name = expression.expressionName;\n\n      if (this.blinkExpressionNames.indexOf(name) !== -1) {\n        multiplier *= weightMultipliers.blink;\n      }\n\n      if (this.lookAtExpressionNames.indexOf(name) !== -1) {\n        multiplier *= weightMultipliers.lookAt;\n      }\n\n      if (this.mouthExpressionNames.indexOf(name) !== -1) {\n        multiplier *= weightMultipliers.mouth;\n      }\n\n      expression.applyWeight({ multiplier });\n    });\n  }\n\n  /**\n   * Calculate sum of override amounts to see how much we should multiply weights of certain expressions.\n   */\n  private _calculateWeightMultipliers(): {\n    blink: number;\n    lookAt: number;\n    mouth: number;\n  } {\n    let blink = 1.0;\n    let lookAt = 1.0;\n    let mouth = 1.0;\n\n    this._expressions.forEach((expression) => {\n      blink -= expression.overrideBlinkAmount;\n      lookAt -= expression.overrideLookAtAmount;\n      mouth -= expression.overrideMouthAmount;\n    });\n\n    blink = Math.max(0.0, blink);\n    lookAt = Math.max(0.0, lookAt);\n    mouth = Math.max(0.0, mouth);\n\n    return { blink, lookAt, mouth };\n  }\n}\n", "/* eslint-disable @typescript-eslint/naming-convention */\n\nexport const VRMExpressionMaterialColorType = {\n  Color: 'color',\n  EmissionColor: 'emissionColor',\n  ShadeColor: 'shadeColor',\n  MatcapColor: 'matcapColor',\n  RimColor: 'rimColor',\n  OutlineColor: 'outlineColor',\n} as const;\n\nexport type VRMExpressionMaterialColorType =\n  typeof VRMExpressionMaterialColorType[keyof typeof VRMExpressionMaterialColorType];\n\nexport const v0ExpressionMaterialColorMap: { [key: string]: VRMExpressionMaterialColorType | undefined } = {\n  _Color: VRMExpressionMaterialColorType.Color,\n  _EmissionColor: VRMExpressionMaterialColorType.EmissionColor,\n  _ShadeColor: VRMExpressionMaterialColorType.ShadeColor,\n  _RimColor: VRMExpressionMaterialColorType.RimColor,\n  _OutlineColor: VRMExpressionMaterialColorType.OutlineColor,\n};\n", "import * as THREE from 'three';\nimport type { VRMExpressionBind } from './VRMExpressionBind';\nimport type { VRMExpressionMaterialColorType } from './VRMExpressionMaterialColorType';\n\nconst _color = new THREE.Color();\n\ninterface ColorBindState {\n  propertyName: string;\n  initialValue: THREE.Color;\n  deltaValue: THREE.Color;\n}\n\ninterface AlphaBindState {\n  propertyName: string;\n  initialValue: number;\n  deltaValue: number;\n}\n\ninterface BindState {\n  color: ColorBindState | null;\n  alpha: AlphaBindState | null;\n}\n\n/**\n * A bind of expression influences to a material color.\n */\nexport class VRMExpressionMaterialColorBind implements VRMExpressionBind {\n  /**\n   * Mapping of property names from VRMC/materialColorBinds.type to three.js/Material.\n   * The first element stands for color channels, the second element stands for the alpha channel.\n   * The second element can be null if the target property doesn't exist.\n   */\n  // TODO: We might want to use the `satisfies` operator once we bump TS to 4.9 or higher\n  // See: https://github.com/pixiv/three-vrm/pull/1323#discussion_r1374020035\n  private static _propertyNameMapMap: {\n    [distinguisher: string]: { [type in VRMExpressionMaterialColorType]?: readonly [string, string | null] };\n  } = {\n    isMeshStandardMaterial: {\n      color: ['color', 'opacity'],\n      emissionColor: ['emissive', null],\n    },\n    isMeshBasicMaterial: {\n      color: ['color', 'opacity'],\n    },\n    isMToonMaterial: {\n      color: ['color', 'opacity'],\n      emissionColor: ['emissive', null],\n      outlineColor: ['outlineColorFactor', null],\n      matcapColor: ['matcapFactor', null],\n      rimColor: ['parametricRimColorFactor', null],\n      shadeColor: ['shadeColorFactor', null],\n    },\n  };\n\n  /**\n   * The target material.\n   */\n  public readonly material: THREE.Material;\n\n  /**\n   * The type of the target property of the material.\n   */\n  public readonly type: VRMExpressionMaterialColorType;\n\n  /**\n   * The target color.\n   */\n  public readonly targetValue: THREE.Color;\n\n  /**\n   * The target alpha.\n   */\n  public readonly targetAlpha: number;\n\n  /**\n   * Its binding state.\n   * If it cannot find the target property in the constructor, each property will be null instead.\n   */\n  private _state: BindState;\n\n  public constructor({\n    material,\n    type,\n    targetValue,\n    targetAlpha,\n  }: {\n    /**\n     * The target material.\n     */\n    material: THREE.Material;\n\n    /**\n     * The type of the target property of the material.\n     */\n    type: VRMExpressionMaterialColorType;\n\n    /**\n     * The target color.\n     */\n    targetValue: THREE.Color;\n\n    /**\n     * The target alpha.\n     */\n    targetAlpha?: number;\n  }) {\n    this.material = material;\n    this.type = type;\n    this.targetValue = targetValue;\n    this.targetAlpha = targetAlpha ?? 1.0;\n\n    // init bind state\n    const color = this._initColorBindState();\n    const alpha = this._initAlphaBindState();\n    this._state = { color, alpha };\n  }\n\n  public applyWeight(weight: number): void {\n    const { color, alpha } = this._state;\n\n    if (color != null) {\n      const { propertyName, deltaValue } = color;\n\n      const target = (this.material as any)[propertyName] as THREE.Color;\n      if (target != undefined) {\n        target.add(_color.copy(deltaValue).multiplyScalar(weight));\n      }\n    }\n\n    if (alpha != null) {\n      const { propertyName, deltaValue } = alpha;\n\n      const target = (this.material as any)[propertyName] as number;\n      if (target != undefined) {\n        ((this.material as any)[propertyName] as number) += deltaValue * weight;\n      }\n    }\n  }\n\n  public clearAppliedWeight(): void {\n    const { color, alpha } = this._state;\n\n    if (color != null) {\n      const { propertyName, initialValue } = color;\n\n      const target = (this.material as any)[propertyName] as THREE.Color;\n      if (target != undefined) {\n        target.copy(initialValue);\n      }\n    }\n\n    if (alpha != null) {\n      const { propertyName, initialValue } = alpha;\n\n      const target = (this.material as any)[propertyName] as number;\n      if (target != undefined) {\n        ((this.material as any)[propertyName] as number) = initialValue;\n      }\n    }\n  }\n\n  private _initColorBindState(): ColorBindState | null {\n    const { material, type, targetValue } = this;\n\n    const propertyNameMap = this._getPropertyNameMap();\n    const propertyName = propertyNameMap?.[type]?.[0] ?? null;\n\n    if (propertyName == null) {\n      console.warn(\n        `Tried to add a material color bind to the material ${\n          material.name ?? '(no name)'\n        }, the type ${type} but the material or the type is not supported.`,\n      );\n\n      return null;\n    }\n\n    const target = (material as any)[propertyName] as THREE.Color;\n\n    const initialValue = target.clone();\n\n    // \u8CA0\u306E\u5024\u3092\u4FDD\u6301\u3059\u308B\u305F\u3081\u306BColor.sub\u3092\u4F7F\u308F\u305A\u306B\u5DEE\u5206\u3092\u8A08\u7B97\u3059\u308B\n    const deltaValue = new THREE.Color(\n      targetValue.r - initialValue.r,\n      targetValue.g - initialValue.g,\n      targetValue.b - initialValue.b,\n    );\n\n    return { propertyName, initialValue, deltaValue };\n  }\n\n  private _initAlphaBindState(): AlphaBindState | null {\n    const { material, type, targetAlpha } = this;\n\n    const propertyNameMap = this._getPropertyNameMap();\n    const propertyName = propertyNameMap?.[type]?.[1] ?? null;\n\n    if (propertyName == null && targetAlpha !== 1.0) {\n      console.warn(\n        `Tried to add a material alpha bind to the material ${\n          material.name ?? '(no name)'\n        }, the type ${type} but the material or the type does not support alpha.`,\n      );\n\n      return null;\n    }\n\n    if (propertyName == null) {\n      return null;\n    }\n\n    const initialValue = (material as any)[propertyName] as number;\n\n    const deltaValue = targetAlpha - initialValue;\n\n    return { propertyName, initialValue, deltaValue };\n  }\n\n  private _getPropertyNameMap():\n    | { [type in VRMExpressionMaterialColorType]?: readonly [string, string | null] }\n    | null {\n    return (\n      Object.entries(VRMExpressionMaterialColorBind._propertyNameMapMap).find(([distinguisher]) => {\n        return (this.material as any)[distinguisher] === true;\n      })?.[1] ?? null\n    );\n  }\n}\n", "import type * as THREE from 'three';\nimport type { VRMExpressionBind } from './VRMExpressionBind';\n\n/**\n * A bind of {@link VRMExpression} influences to morph targets.\n */\nexport class VRMExpressionMorphTargetBind implements VRMExpressionBind {\n  /**\n   * The mesh primitives that attached to target mesh.\n   */\n  public readonly primitives: THREE.Mesh[];\n\n  /**\n   * The index of the morph target in the mesh.\n   */\n  public readonly index: number;\n\n  /**\n   * The weight value of target morph target. Ranging in [0.0 - 1.0].\n   */\n  public readonly weight: number;\n\n  public constructor({\n    primitives,\n    index,\n    weight,\n  }: {\n    /**\n     * The mesh primitives that attached to target mesh.\n     */\n    primitives: THREE.Mesh[];\n\n    /**\n     * The index of the morph target in the mesh.\n     */\n    index: number;\n\n    /**\n     * The weight value of target morph target. Ranging in [0.0 - 1.0].\n     */\n    weight: number;\n  }) {\n    this.primitives = primitives;\n    this.index = index;\n    this.weight = weight;\n  }\n\n  public applyWeight(weight: number): void {\n    this.primitives.forEach((mesh) => {\n      if (mesh.morphTargetInfluences?.[this.index] != null) {\n        mesh.morphTargetInfluences[this.index] += this.weight * weight;\n      }\n    });\n  }\n\n  public clearAppliedWeight(): void {\n    this.primitives.forEach((mesh) => {\n      if (mesh.morphTargetInfluences?.[this.index] != null) {\n        mesh.morphTargetInfluences[this.index] = 0.0;\n      }\n    });\n  }\n}\n", "import * as THREE from 'three';\nimport type { VRMExpressionBind } from './VRMExpressionBind';\n\nconst _v2 = new THREE.Vector2();\n\n/**\n * A bind of expression influences to texture transforms.\n */\nexport class VRMExpressionTextureTransformBind implements VRMExpressionBind {\n  private static _propertyNamesMap: { [distinguisher: string]: string[] } = {\n    isMeshStandardMaterial: [\n      'map',\n      'emissiveMap',\n      'bumpMap',\n      'normalMap',\n      'displacementMap',\n      'roughnessMap',\n      'metalnessMap',\n      'alphaMap',\n    ],\n    isMeshBasicMaterial: ['map', 'specularMap', 'alphaMap'],\n    isMToonMaterial: [\n      'map',\n      'normalMap',\n      'emissiveMap',\n      'shadeMultiplyTexture',\n      'rimMultiplyTexture',\n      'outlineWidthMultiplyTexture',\n      'uvAnimationMaskTexture',\n    ],\n  };\n\n  /**\n   * The target material.\n   */\n  public readonly material: THREE.Material;\n\n  /**\n   * The uv scale of the texture.\n   */\n  public readonly scale: THREE.Vector2;\n\n  /**\n   * The uv offset of the texture.\n   */\n  public readonly offset: THREE.Vector2;\n\n  /**\n   * The list of texture names and its state that should be transformed by this bind.\n   */\n  private _properties: {\n    name: string;\n    initialOffset: THREE.Vector2;\n    initialScale: THREE.Vector2;\n    deltaOffset: THREE.Vector2;\n    deltaScale: THREE.Vector2;\n  }[];\n\n  public constructor({\n    material,\n    scale,\n    offset,\n  }: {\n    /**\n     * The target material.\n     */\n    material: THREE.Material;\n\n    /**\n     * The uv scale of the texture.\n     */\n    scale: THREE.Vector2;\n\n    /**\n     * The uv offset of the texture.\n     */\n    offset: THREE.Vector2;\n  }) {\n    this.material = material;\n    this.scale = scale;\n    this.offset = offset;\n\n    const propertyNames = Object.entries(VRMExpressionTextureTransformBind._propertyNamesMap).find(\n      ([distinguisher]) => {\n        return (material as any)[distinguisher] === true;\n      },\n    )?.[1];\n\n    if (propertyNames == null) {\n      console.warn(\n        `Tried to add a texture transform bind to the material ${\n          material.name ?? '(no name)'\n        } but the material is not supported.`,\n      );\n\n      this._properties = [];\n    } else {\n      this._properties = [];\n\n      propertyNames.forEach((propertyName) => {\n        const texture = ((material as any)[propertyName] as THREE.Texture | undefined)?.clone();\n        if (!texture) {\n          return null;\n        }\n\n        (material as any)[propertyName] = texture; // because the texture is cloned\n\n        const initialOffset = texture.offset.clone();\n        const initialScale = texture.repeat.clone();\n        const deltaOffset = offset.clone().sub(initialOffset);\n        const deltaScale = scale.clone().sub(initialScale);\n\n        this._properties.push({\n          name: propertyName,\n          initialOffset,\n          deltaOffset,\n          initialScale,\n          deltaScale,\n        });\n      });\n    }\n  }\n\n  public applyWeight(weight: number): void {\n    this._properties.forEach((property) => {\n      const target = (this.material as any)[property.name] as THREE.Texture;\n      if (target === undefined) {\n        return;\n      } // TODO: we should kick this at `addMaterialValue`\n\n      target.offset.add(_v2.copy(property.deltaOffset).multiplyScalar(weight));\n      target.repeat.add(_v2.copy(property.deltaScale).multiplyScalar(weight));\n    });\n  }\n\n  public clearAppliedWeight(): void {\n    this._properties.forEach((property) => {\n      const target = (this.material as any)[property.name] as THREE.Texture;\n      if (target === undefined) {\n        return;\n      } // TODO: we should kick this at `addMaterialValue`\n\n      target.offset.copy(property.initialOffset);\n      target.repeat.copy(property.initialScale);\n    });\n  }\n}\n", "/* eslint-disable @typescript-eslint/naming-convention */\n\nexport const VRMExpressionOverrideType = {\n  None: 'none',\n  Block: 'block',\n  Blend: 'blend',\n} as const;\n\nexport type VRMExpressionOverrideType = typeof VRMExpressionOverrideType[keyof typeof VRMExpressionOverrideType];\n", "import type { VRMFirstPersonMeshAnnotation } from './VRMFirstPersonMeshAnnotation';\nimport * as THREE from 'three';\nimport type { VRMHumanoid } from '../humanoid';\n\nexport class VRMFirstPerson {\n  /**\n   * A default camera layer for `FirstPersonOnly` layer.\n   *\n   * @see [[getFirstPersonOnlyLayer]]\n   */\n  public static readonly DEFAULT_FIRSTPERSON_ONLY_LAYER = 9;\n\n  /**\n   * A default camera layer for `ThirdPersonOnly` layer.\n   *\n   * @see [[getThirdPersonOnlyLayer]]\n   */\n  public static readonly DEFAULT_THIRDPERSON_ONLY_LAYER = 10;\n\n  /**\n   * Its associated {@link VRMHumanoid}.\n   */\n  public readonly humanoid: VRMHumanoid;\n  public meshAnnotations: VRMFirstPersonMeshAnnotation[];\n\n  private _firstPersonOnlyLayer = VRMFirstPerson.DEFAULT_FIRSTPERSON_ONLY_LAYER;\n  private _thirdPersonOnlyLayer = VRMFirstPerson.DEFAULT_THIRDPERSON_ONLY_LAYER;\n\n  private _initializedLayers = false;\n\n  /**\n   * Create a new VRMFirstPerson object.\n   *\n   * @param humanoid A {@link VRMHumanoid}\n   * @param meshAnnotations A renderer settings. See the description of [[RendererFirstPersonFlags]] for more info\n   */\n  public constructor(humanoid: VRMHumanoid, meshAnnotations: VRMFirstPersonMeshAnnotation[]) {\n    this.humanoid = humanoid;\n    this.meshAnnotations = meshAnnotations;\n  }\n\n  /**\n   * Copy the given {@link VRMFirstPerson} into this one.\n   * {@link humanoid} must be same as the source one.\n   * @param source The {@link VRMFirstPerson} you want to copy\n   * @returns this\n   */\n  public copy(source: VRMFirstPerson): this {\n    if (this.humanoid !== source.humanoid) {\n      throw new Error('VRMFirstPerson: humanoid must be same in order to copy');\n    }\n\n    this.meshAnnotations = source.meshAnnotations.map((annotation) => ({\n      meshes: annotation.meshes.concat(),\n      type: annotation.type,\n    }));\n\n    return this;\n  }\n\n  /**\n   * Returns a clone of this {@link VRMFirstPerson}.\n   * @returns Copied {@link VRMFirstPerson}\n   */\n  public clone(): VRMFirstPerson {\n    return new VRMFirstPerson(this.humanoid, this.meshAnnotations).copy(this);\n  }\n\n  /**\n   * A camera layer represents `FirstPersonOnly` layer.\n   * Note that **you must call {@link setup} first before you use the layer feature** or it does not work properly.\n   *\n   * The value is {@link DEFAULT_FIRSTPERSON_ONLY_LAYER} by default but you can change the layer by specifying via {@link setup} if you prefer.\n   *\n   * @see https://vrm.dev/en/univrm/api/univrm_use_firstperson/\n   * @see https://threejs.org/docs/#api/en/core/Layers\n   */\n  public get firstPersonOnlyLayer(): number {\n    return this._firstPersonOnlyLayer;\n  }\n\n  /**\n   * A camera layer represents `ThirdPersonOnly` layer.\n   * Note that **you must call {@link setup} first before you use the layer feature** or it does not work properly.\n   *\n   * The value is {@link DEFAULT_THIRDPERSON_ONLY_LAYER} by default but you can change the layer by specifying via {@link setup} if you prefer.\n   *\n   * @see https://vrm.dev/en/univrm/api/univrm_use_firstperson/\n   * @see https://threejs.org/docs/#api/en/core/Layers\n   */\n  public get thirdPersonOnlyLayer(): number {\n    return this._thirdPersonOnlyLayer;\n  }\n\n  /**\n   * In this method, it assigns layers for every meshes based on mesh annotations.\n   * You must call this method first before you use the layer feature.\n   *\n   * This is an equivalent of [VRMFirstPerson.Setup](https://github.com/vrm-c/UniVRM/blob/73a5bd8fcddaa2a7a8735099a97e63c9db3e5ea0/Assets/VRM/Runtime/FirstPerson/VRMFirstPerson.cs#L295-L299) of the UniVRM.\n   *\n   * The `cameraLayer` parameter specifies which layer will be assigned for `FirstPersonOnly` / `ThirdPersonOnly`.\n   * In UniVRM, we specified those by naming each desired layer as `FIRSTPERSON_ONLY_LAYER` / `THIRDPERSON_ONLY_LAYER`\n   * but we are going to specify these layers at here since we are unable to name layers in Three.js.\n   *\n   * @param cameraLayer Specify which layer will be for `FirstPersonOnly` / `ThirdPersonOnly`.\n   */\n  public setup({\n    firstPersonOnlyLayer = VRMFirstPerson.DEFAULT_FIRSTPERSON_ONLY_LAYER,\n    thirdPersonOnlyLayer = VRMFirstPerson.DEFAULT_THIRDPERSON_ONLY_LAYER,\n  } = {}): void {\n    if (this._initializedLayers) {\n      return;\n    }\n    this._firstPersonOnlyLayer = firstPersonOnlyLayer;\n    this._thirdPersonOnlyLayer = thirdPersonOnlyLayer;\n\n    this.meshAnnotations.forEach((item) => {\n      item.meshes.forEach((mesh) => {\n        if (item.type === 'firstPersonOnly') {\n          mesh.layers.set(this._firstPersonOnlyLayer);\n          mesh.traverse((child) => child.layers.set(this._firstPersonOnlyLayer));\n        } else if (item.type === 'thirdPersonOnly') {\n          mesh.layers.set(this._thirdPersonOnlyLayer);\n          mesh.traverse((child) => child.layers.set(this._thirdPersonOnlyLayer));\n        } else if (item.type === 'auto') {\n          this._createHeadlessModel(mesh);\n        }\n      });\n    });\n\n    this._initializedLayers = true;\n  }\n\n  private _excludeTriangles(triangles: number[], bws: number[][], skinIndex: number[][], exclude: number[]): number {\n    let count = 0;\n    if (bws != null && bws.length > 0) {\n      for (let i = 0; i < triangles.length; i += 3) {\n        const a = triangles[i];\n        const b = triangles[i + 1];\n        const c = triangles[i + 2];\n        const bw0 = bws[a];\n        const skin0 = skinIndex[a];\n\n        if (bw0[0] > 0 && exclude.includes(skin0[0])) continue;\n        if (bw0[1] > 0 && exclude.includes(skin0[1])) continue;\n        if (bw0[2] > 0 && exclude.includes(skin0[2])) continue;\n        if (bw0[3] > 0 && exclude.includes(skin0[3])) continue;\n\n        const bw1 = bws[b];\n        const skin1 = skinIndex[b];\n        if (bw1[0] > 0 && exclude.includes(skin1[0])) continue;\n        if (bw1[1] > 0 && exclude.includes(skin1[1])) continue;\n        if (bw1[2] > 0 && exclude.includes(skin1[2])) continue;\n        if (bw1[3] > 0 && exclude.includes(skin1[3])) continue;\n\n        const bw2 = bws[c];\n        const skin2 = skinIndex[c];\n        if (bw2[0] > 0 && exclude.includes(skin2[0])) continue;\n        if (bw2[1] > 0 && exclude.includes(skin2[1])) continue;\n        if (bw2[2] > 0 && exclude.includes(skin2[2])) continue;\n        if (bw2[3] > 0 && exclude.includes(skin2[3])) continue;\n\n        triangles[count++] = a;\n        triangles[count++] = b;\n        triangles[count++] = c;\n      }\n    }\n    return count;\n  }\n\n  private _createErasedMesh(src: THREE.SkinnedMesh, erasingBonesIndex: number[]): THREE.SkinnedMesh {\n    const dst = new THREE.SkinnedMesh(src.geometry.clone(), src.material);\n    dst.name = `${src.name}(erase)`;\n    dst.frustumCulled = src.frustumCulled;\n    dst.layers.set(this._firstPersonOnlyLayer);\n\n    const geometry = dst.geometry;\n\n    const skinIndexAttr = geometry.getAttribute('skinIndex');\n    const skinIndexAttrArray = skinIndexAttr instanceof THREE.GLBufferAttribute ? [] : skinIndexAttr.array;\n    const skinIndex = [];\n    for (let i = 0; i < skinIndexAttrArray.length; i += 4) {\n      skinIndex.push([\n        skinIndexAttrArray[i],\n        skinIndexAttrArray[i + 1],\n        skinIndexAttrArray[i + 2],\n        skinIndexAttrArray[i + 3],\n      ]);\n    }\n\n    const skinWeightAttr = geometry.getAttribute('skinWeight');\n    const skinWeightAttrArray = skinWeightAttr instanceof THREE.GLBufferAttribute ? [] : skinWeightAttr.array;\n    const skinWeight = [];\n    for (let i = 0; i < skinWeightAttrArray.length; i += 4) {\n      skinWeight.push([\n        skinWeightAttrArray[i],\n        skinWeightAttrArray[i + 1],\n        skinWeightAttrArray[i + 2],\n        skinWeightAttrArray[i + 3],\n      ]);\n    }\n\n    const index = geometry.getIndex();\n    if (!index) {\n      throw new Error(\"The geometry doesn't have an index buffer\");\n    }\n    const oldTriangles = Array.from(index.array);\n\n    const count = this._excludeTriangles(oldTriangles, skinWeight, skinIndex, erasingBonesIndex);\n    const newTriangle: number[] = [];\n    for (let i = 0; i < count; i++) {\n      newTriangle[i] = oldTriangles[i];\n    }\n    geometry.setIndex(newTriangle);\n\n    // mtoon material includes onBeforeRender. this is unsupported at SkinnedMesh#clone\n    if (src.onBeforeRender) {\n      dst.onBeforeRender = src.onBeforeRender;\n    }\n    dst.bind(new THREE.Skeleton(src.skeleton.bones, src.skeleton.boneInverses), new THREE.Matrix4());\n    return dst;\n  }\n\n  private _createHeadlessModelForSkinnedMesh(parent: THREE.Object3D, mesh: THREE.SkinnedMesh): void {\n    const eraseBoneIndexes: number[] = [];\n    mesh.skeleton.bones.forEach((bone, index) => {\n      if (this._isEraseTarget(bone)) eraseBoneIndexes.push(index);\n    });\n\n    // Unlike UniVRM we don't copy mesh if no invisible bone was found\n    if (!eraseBoneIndexes.length) {\n      mesh.layers.enable(this._thirdPersonOnlyLayer);\n      mesh.layers.enable(this._firstPersonOnlyLayer);\n      return;\n    }\n    mesh.layers.set(this._thirdPersonOnlyLayer);\n    const newMesh = this._createErasedMesh(mesh, eraseBoneIndexes);\n    parent.add(newMesh);\n  }\n\n  private _createHeadlessModel(node: THREE.Object3D): void {\n    if (node.type === 'Group') {\n      node.layers.set(this._thirdPersonOnlyLayer);\n      if (this._isEraseTarget(node)) {\n        node.traverse((child) => child.layers.set(this._thirdPersonOnlyLayer));\n      } else {\n        const parent = new THREE.Group();\n        parent.name = `_headless_${node.name}`;\n        parent.layers.set(this._firstPersonOnlyLayer);\n        node.parent!.add(parent);\n        node.children\n          .filter((child) => child.type === 'SkinnedMesh')\n          .forEach((child) => {\n            const skinnedMesh = child as THREE.SkinnedMesh;\n            this._createHeadlessModelForSkinnedMesh(parent, skinnedMesh);\n          });\n      }\n    } else if (node.type === 'SkinnedMesh') {\n      const skinnedMesh = node as THREE.SkinnedMesh;\n      this._createHeadlessModelForSkinnedMesh(node.parent!, skinnedMesh);\n    } else {\n      if (this._isEraseTarget(node)) {\n        node.layers.set(this._thirdPersonOnlyLayer);\n        node.traverse((child) => child.layers.set(this._thirdPersonOnlyLayer));\n      }\n    }\n  }\n\n  private _isEraseTarget(bone: THREE.Object3D): boolean {\n    if (bone === this.humanoid.getRawBoneNode('head')) {\n      return true;\n    } else if (!bone.parent) {\n      return false;\n    } else {\n      return this._isEraseTarget(bone.parent);\n    }\n  }\n}\n", "import type * as V0VRM from '@pixiv/types-vrm-0.0';\nimport type * as V1VRMSchema from '@pixiv/types-vrmc-vrm-1.0';\nimport type { GLTF, GLTFLoaderPlugin, GLTFParser } from 'three/examples/jsm/loaders/GLTFLoader.js';\nimport type { VRMHumanoid } from '../humanoid/VRMHumanoid';\nimport { gltfExtractPrimitivesFromNodes } from '../utils/gltfExtractPrimitivesFromNode';\nimport { VRMFirstPerson } from './VRMFirstPerson';\nimport type { VRMFirstPersonMeshAnnotation } from './VRMFirstPersonMeshAnnotation';\nimport type { VRMFirstPersonMeshAnnotationType } from './VRMFirstPersonMeshAnnotationType';\nimport { GLTF as GLTFSchema } from '@gltf-transform/core';\n\n/**\n * Possible spec versions it recognizes.\n */\nconst POSSIBLE_SPEC_VERSIONS = new Set(['1.0', '1.0-beta']);\n\n/**\n * A plugin of GLTFLoader that imports a {@link VRMFirstPerson} from a VRM extension of a GLTF.\n */\nexport class VRMFirstPersonLoaderPlugin implements GLTFLoaderPlugin {\n  public readonly parser: GLTFParser;\n\n  public get name(): string {\n    // We should use the extension name instead but we have multiple plugins for an extension...\n    return 'VRMFirstPersonLoaderPlugin';\n  }\n\n  public constructor(parser: GLTFParser) {\n    this.parser = parser;\n  }\n\n  public async afterRoot(gltf: GLTF): Promise<void> {\n    const vrmHumanoid = gltf.userData.vrmHumanoid as VRMHumanoid | undefined;\n\n    // explicitly distinguish null and undefined\n    // since vrmHumanoid might be null as a result\n    if (vrmHumanoid === null) {\n      return;\n    } else if (vrmHumanoid === undefined) {\n      throw new Error(\n        'VRMFirstPersonLoaderPlugin: vrmHumanoid is undefined. VRMHumanoidLoaderPlugin have to be used first',\n      );\n    }\n\n    gltf.userData.vrmFirstPerson = await this._import(gltf, vrmHumanoid);\n  }\n\n  /**\n   * Import a {@link VRMFirstPerson} from a VRM.\n   *\n   * @param gltf A parsed result of GLTF taken from GLTFLoader\n   * @param humanoid A {@link VRMHumanoid} instance that represents the VRM\n   */\n\n  private async _import(gltf: GLTF, humanoid: VRMHumanoid | null): Promise<VRMFirstPerson | null> {\n    if (humanoid == null) {\n      return null;\n    }\n\n    const v1Result = await this._v1Import(gltf, humanoid);\n    if (v1Result) {\n      return v1Result;\n    }\n\n    const v0Result = await this._v0Import(gltf, humanoid);\n    if (v0Result) {\n      return v0Result;\n    }\n\n    return null;\n  }\n\n  private async _v1Import(gltf: GLTF, humanoid: VRMHumanoid): Promise<VRMFirstPerson | null> {\n    const json = this.parser.json as GLTFSchema.IGLTF;\n\n    // early abort if it doesn't use vrm\n    const isVRMUsed = json.extensionsUsed?.indexOf('VRMC_vrm') !== -1;\n    if (!isVRMUsed) {\n      return null;\n    }\n\n    const extension = json.extensions?.['VRMC_vrm'] as V1VRMSchema.VRMCVRM | undefined;\n    if (!extension) {\n      return null;\n    }\n\n    const specVersion = extension.specVersion;\n    if (!POSSIBLE_SPEC_VERSIONS.has(specVersion)) {\n      console.warn(`VRMFirstPersonLoaderPlugin: Unknown VRMC_vrm specVersion \"${specVersion}\"`);\n      return null;\n    }\n\n    const schemaFirstPerson = extension.firstPerson;\n    if (!schemaFirstPerson) {\n      return null;\n    }\n\n    const meshAnnotations: VRMFirstPersonMeshAnnotation[] = [];\n    const nodePrimitivesMap = await gltfExtractPrimitivesFromNodes(gltf);\n    Array.from(nodePrimitivesMap.entries()).forEach(([nodeIndex, primitives]) => {\n      const annotation = schemaFirstPerson.meshAnnotations\n        ? schemaFirstPerson.meshAnnotations.find((a) => a.node === nodeIndex)\n        : undefined;\n\n      meshAnnotations.push({\n        meshes: primitives,\n        type: annotation?.type ?? 'both',\n      });\n    });\n\n    return new VRMFirstPerson(humanoid, meshAnnotations);\n  }\n\n  private async _v0Import(gltf: GLTF, humanoid: VRMHumanoid): Promise<VRMFirstPerson | null> {\n    const json = this.parser.json as GLTFSchema.IGLTF;\n\n    const vrmExt = json.extensions?.VRM as V0VRM.VRM | undefined;\n    if (!vrmExt) {\n      return null;\n    }\n\n    const schemaFirstPerson: V0VRM.FirstPerson | undefined = vrmExt.firstPerson;\n    if (!schemaFirstPerson) {\n      return null;\n    }\n\n    const meshAnnotations: VRMFirstPersonMeshAnnotation[] = [];\n    const nodePrimitivesMap = await gltfExtractPrimitivesFromNodes(gltf);\n\n    Array.from(nodePrimitivesMap.entries()).forEach(([nodeIndex, primitives]) => {\n      const schemaNode = json.nodes![nodeIndex];\n\n      const flag = schemaFirstPerson.meshAnnotations\n        ? schemaFirstPerson.meshAnnotations.find((a) => a.mesh === schemaNode.mesh)\n        : undefined;\n\n      meshAnnotations.push({\n        meshes: primitives,\n        type: this._convertV0FlagToV1Type(flag?.firstPersonFlag),\n      });\n    });\n\n    return new VRMFirstPerson(humanoid, meshAnnotations);\n  }\n\n  private _convertV0FlagToV1Type(flag: string | undefined): VRMFirstPersonMeshAnnotationType {\n    if (flag === 'FirstPersonOnly') {\n      return 'firstPersonOnly';\n    } else if (flag === 'ThirdPersonOnly') {\n      return 'thirdPersonOnly';\n    } else if (flag === 'Auto') {\n      return 'auto';\n    } else {\n      return 'both';\n    }\n  }\n}\n", "/* eslint-disable @typescript-eslint/naming-convention */\n\nexport const VRMFirstPersonMeshAnnotationType = {\n  Auto: 'auto',\n  Both: 'both',\n  ThirdPersonOnly: 'thirdPersonOnly',\n  FirstPersonOnly: 'firstPersonOnly',\n} as const;\n\nexport type VRMFirstPersonMeshAnnotationType =\n  typeof VRMFirstPersonMeshAnnotationType[keyof typeof VRMFirstPersonMeshAnnotationType];\n", "import * as THREE from 'three';\nimport { VRMHumanBone } from '../VRMHumanBone';\nimport { VRMHumanoid } from '../VRMHumanoid';\n\nconst _v3A = new THREE.Vector3();\nconst _v3B = new THREE.Vector3();\nconst _quatA = new THREE.Quaternion();\n\nexport class VRMHumanoidHelper extends THREE.Group {\n  public readonly vrmHumanoid: VRMHumanoid;\n  private _boneAxesMap: Map<VRMHumanBone, THREE.AxesHelper>;\n\n  public constructor(humanoid: VRMHumanoid) {\n    super();\n\n    this.vrmHumanoid = humanoid;\n\n    this._boneAxesMap = new Map();\n\n    Object.values(humanoid.humanBones).forEach((bone) => {\n      const helper = new THREE.AxesHelper(1.0);\n\n      helper.matrixAutoUpdate = false;\n\n      (helper.material as THREE.Material).depthTest = false;\n      (helper.material as THREE.Material).depthWrite = false;\n\n      this.add(helper);\n\n      this._boneAxesMap.set(bone, helper);\n    });\n  }\n\n  public dispose(): void {\n    Array.from(this._boneAxesMap.values()).forEach((axes) => {\n      axes.geometry.dispose();\n      (axes.material as THREE.Material).dispose();\n    });\n  }\n\n  public updateMatrixWorld(force: boolean): void {\n    Array.from(this._boneAxesMap.entries()).forEach(([bone, axes]) => {\n      bone.node.updateWorldMatrix(true, false);\n\n      bone.node.matrixWorld.decompose(_v3A, _quatA, _v3B);\n\n      const scale = _v3A.set(0.1, 0.1, 0.1).divide(_v3B);\n      axes.matrix.copy(bone.node.matrixWorld).scale(scale);\n    });\n\n    super.updateMatrixWorld(force);\n  }\n}\n", "/* eslint-disable @typescript-eslint/naming-convention */\n\nimport { VRMHumanBoneName } from './VRMHumanBoneName';\n\n/**\n * The list of {@link VRMHumanBoneName}. Dependency aware.\n */\nexport const VRMHumanBoneList: VRMHumanBoneName[] = [\n  'hips',\n  'spine',\n  'chest',\n  'upperChest',\n  'neck',\n\n  'head',\n  'leftEye',\n  'rightEye',\n  'jaw',\n\n  'leftUpperLeg',\n  'leftLowerLeg',\n  'leftFoot',\n  'leftToes',\n\n  'rightUpperLeg',\n  'rightLowerLeg',\n  'rightFoot',\n  'rightToes',\n\n  'leftShoulder',\n  'leftUpperArm',\n  'leftLowerArm',\n  'leftHand',\n\n  'rightShoulder',\n  'rightUpperArm',\n  'rightLowerArm',\n  'rightHand',\n\n  'leftThumbMetacarpal',\n  'leftThumbProximal',\n  'leftThumbDistal',\n  'leftIndexProximal',\n  'leftIndexIntermediate',\n  'leftIndexDistal',\n  'leftMiddleProximal',\n  'leftMiddleIntermediate',\n  'leftMiddleDistal',\n  'leftRingProximal',\n  'leftRingIntermediate',\n  'leftRingDistal',\n  'leftLittleProximal',\n  'leftLittleIntermediate',\n  'leftLittleDistal',\n\n  'rightThumbMetacarpal',\n  'rightThumbProximal',\n  'rightThumbDistal',\n  'rightIndexProximal',\n  'rightIndexIntermediate',\n  'rightIndexDistal',\n  'rightMiddleProximal',\n  'rightMiddleIntermediate',\n  'rightMiddleDistal',\n  'rightRingProximal',\n  'rightRingIntermediate',\n  'rightRingDistal',\n  'rightLittleProximal',\n  'rightLittleIntermediate',\n  'rightLittleDistal',\n];\n", "/* eslint-disable @typescript-eslint/naming-convention */\n\n/**\n * The names of {@link VRMHumanoid} bone names.\n *\n * Ref: https://github.com/vrm-c/vrm-specification/blob/master/specification/VRMC_vrm-1.0/humanoid.md\n */\nexport const VRMHumanBoneName = {\n  Hips: 'hips',\n  Spine: 'spine',\n  Chest: 'chest',\n  UpperChest: 'upperChest',\n  Neck: 'neck',\n\n  Head: 'head',\n  LeftEye: 'leftEye',\n  RightEye: 'rightEye',\n  Jaw: 'jaw',\n\n  LeftUpperLeg: 'leftUpperLeg',\n  LeftLowerLeg: 'leftLowerLeg',\n  LeftFoot: 'leftFoot',\n  LeftToes: 'leftToes',\n\n  RightUpperLeg: 'rightUpperLeg',\n  RightLowerLeg: 'rightLowerLeg',\n  RightFoot: 'rightFoot',\n  RightToes: 'rightToes',\n\n  LeftShoulder: 'leftShoulder',\n  LeftUpperArm: 'leftUpperArm',\n  LeftLowerArm: 'leftLowerArm',\n  LeftHand: 'leftHand',\n\n  RightShoulder: 'rightShoulder',\n  RightUpperArm: 'rightUpperArm',\n  RightLowerArm: 'rightLowerArm',\n  RightHand: 'rightHand',\n\n  LeftThumbMetacarpal: 'leftThumbMetacarpal',\n  LeftThumbProximal: 'leftThumbProximal',\n  LeftThumbDistal: 'leftThumbDistal',\n  LeftIndexProximal: 'leftIndexProximal',\n  LeftIndexIntermediate: 'leftIndexIntermediate',\n  LeftIndexDistal: 'leftIndexDistal',\n  LeftMiddleProximal: 'leftMiddleProximal',\n  LeftMiddleIntermediate: 'leftMiddleIntermediate',\n  LeftMiddleDistal: 'leftMiddleDistal',\n  LeftRingProximal: 'leftRingProximal',\n  LeftRingIntermediate: 'leftRingIntermediate',\n  LeftRingDistal: 'leftRingDistal',\n  LeftLittleProximal: 'leftLittleProximal',\n  LeftLittleIntermediate: 'leftLittleIntermediate',\n  LeftLittleDistal: 'leftLittleDistal',\n\n  RightThumbMetacarpal: 'rightThumbMetacarpal',\n  RightThumbProximal: 'rightThumbProximal',\n  RightThumbDistal: 'rightThumbDistal',\n  RightIndexProximal: 'rightIndexProximal',\n  RightIndexIntermediate: 'rightIndexIntermediate',\n  RightIndexDistal: 'rightIndexDistal',\n  RightMiddleProximal: 'rightMiddleProximal',\n  RightMiddleIntermediate: 'rightMiddleIntermediate',\n  RightMiddleDistal: 'rightMiddleDistal',\n  RightRingProximal: 'rightRingProximal',\n  RightRingIntermediate: 'rightRingIntermediate',\n  RightRingDistal: 'rightRingDistal',\n  RightLittleProximal: 'rightLittleProximal',\n  RightLittleIntermediate: 'rightLittleIntermediate',\n  RightLittleDistal: 'rightLittleDistal',\n} as const;\n\nexport type VRMHumanBoneName = typeof VRMHumanBoneName[keyof typeof VRMHumanBoneName];\n", "/* eslint-disable @typescript-eslint/naming-convention */\n\nimport { VRMHumanBoneName } from './VRMHumanBoneName';\n\n/**\n * An object that maps from {@link VRMHumanBoneName} to its parent {@link VRMHumanBoneName}.\n *\n * Ref: https://github.com/vrm-c/vrm-specification/blob/master/specification/VRMC_vrm-1.0/humanoid.md\n */\nexport const VRMHumanBoneParentMap: { [bone in VRMHumanBoneName]: VRMHumanBoneName | null } = {\n  hips: null,\n  spine: 'hips',\n  chest: 'spine',\n  upperChest: 'chest',\n  neck: 'upperChest',\n\n  head: 'neck',\n  leftEye: 'head',\n  rightEye: 'head',\n  jaw: 'head',\n\n  leftUpperLeg: 'hips',\n  leftLowerLeg: 'leftUpperLeg',\n  leftFoot: 'leftLowerLeg',\n  leftToes: 'leftFoot',\n\n  rightUpperLeg: 'hips',\n  rightLowerLeg: 'rightUpperLeg',\n  rightFoot: 'rightLowerLeg',\n  rightToes: 'rightFoot',\n\n  leftShoulder: 'upperChest',\n  leftUpperArm: 'leftShoulder',\n  leftLowerArm: 'leftUpperArm',\n  leftHand: 'leftLowerArm',\n\n  rightShoulder: 'upperChest',\n  rightUpperArm: 'rightShoulder',\n  rightLowerArm: 'rightUpperArm',\n  rightHand: 'rightLowerArm',\n\n  leftThumbMetacarpal: 'leftHand',\n  leftThumbProximal: 'leftThumbMetacarpal',\n  leftThumbDistal: 'leftThumbProximal',\n  leftIndexProximal: 'leftHand',\n  leftIndexIntermediate: 'leftIndexProximal',\n  leftIndexDistal: 'leftIndexIntermediate',\n  leftMiddleProximal: 'leftHand',\n  leftMiddleIntermediate: 'leftMiddleProximal',\n  leftMiddleDistal: 'leftMiddleIntermediate',\n  leftRingProximal: 'leftHand',\n  leftRingIntermediate: 'leftRingProximal',\n  leftRingDistal: 'leftRingIntermediate',\n  leftLittleProximal: 'leftHand',\n  leftLittleIntermediate: 'leftLittleProximal',\n  leftLittleDistal: 'leftLittleIntermediate',\n\n  rightThumbMetacarpal: 'rightHand',\n  rightThumbProximal: 'rightThumbMetacarpal',\n  rightThumbDistal: 'rightThumbProximal',\n  rightIndexProximal: 'rightHand',\n  rightIndexIntermediate: 'rightIndexProximal',\n  rightIndexDistal: 'rightIndexIntermediate',\n  rightMiddleProximal: 'rightHand',\n  rightMiddleIntermediate: 'rightMiddleProximal',\n  rightMiddleDistal: 'rightMiddleIntermediate',\n  rightRingProximal: 'rightHand',\n  rightRingIntermediate: 'rightRingProximal',\n  rightRingDistal: 'rightRingIntermediate',\n  rightLittleProximal: 'rightHand',\n  rightLittleIntermediate: 'rightLittleProximal',\n  rightLittleDistal: 'rightLittleIntermediate',\n};\n", "import * as THREE from 'three';\nimport { quatInvertCompat } from '../utils/quatInvertCompat';\nimport type { VRMHumanBone } from './VRMHumanBone';\nimport type { VRMHumanBones } from './VRMHumanBones';\nimport type { VRMHumanBoneName } from './VRMHumanBoneName';\nimport type { VRMPose } from './VRMPose';\n\nconst _v3A = new THREE.Vector3();\nconst _quatA = new THREE.Quaternion();\n\n/**\n * A class represents the Rig of a VRM.\n */\nexport class VRMRig {\n  /**\n   * A {@link VRMHumanBones} that contains all the human bones of the VRM.\n   * You might want to get these bones using {@link VRMHumanoid.getBone}.\n   */\n  public humanBones: VRMHumanBones;\n\n  /**\n   * A {@link VRMPose} that is its default state.\n   * Note that it's not compatible with {@link setPose} and {@link getPose}, since it contains non-relative values of each local transforms.\n   */\n  public restPose: VRMPose;\n\n  /**\n   * Create a new {@link VRMHumanoid}.\n   * @param humanBones A {@link VRMHumanBones} contains all the bones of the new humanoid\n   */\n  public constructor(humanBones: VRMHumanBones) {\n    this.humanBones = humanBones;\n\n    this.restPose = this.getAbsolutePose();\n  }\n\n  /**\n   * Return the current absolute pose of this humanoid as a {@link VRMPose}.\n   * Note that the output result will contain initial state of the VRM and not compatible between different models.\n   * You might want to use {@link getPose} instead.\n   */\n  public getAbsolutePose(): VRMPose {\n    const pose = {} as VRMPose;\n\n    Object.keys(this.humanBones).forEach((vrmBoneNameString) => {\n      const vrmBoneName = vrmBoneNameString as VRMHumanBoneName;\n      const node = this.getBoneNode(vrmBoneName);\n\n      // Ignore when there are no bone on the VRMHumanoid\n      if (!node) {\n        return;\n      }\n\n      // Get the position / rotation from the node\n      _v3A.copy(node.position);\n      _quatA.copy(node.quaternion);\n\n      // Convert to raw arrays\n      pose[vrmBoneName] = {\n        position: _v3A.toArray() as [number, number, number],\n        rotation: _quatA.toArray() as [number, number, number, number],\n      };\n    });\n\n    return pose;\n  }\n\n  /**\n   * Return the current pose of this humanoid as a {@link VRMPose}.\n   *\n   * Each transform is a local transform relative from rest pose (T-pose).\n   */\n  public getPose(): VRMPose {\n    const pose = {} as VRMPose;\n\n    Object.keys(this.humanBones).forEach((boneNameString) => {\n      const boneName = boneNameString as VRMHumanBoneName;\n      const node = this.getBoneNode(boneName);\n\n      // Ignore when there are no bone on the VRMHumanoid\n      if (!node) {\n        return;\n      }\n\n      // Take a diff from restPose\n      _v3A.set(0, 0, 0);\n      _quatA.identity();\n\n      const restState = this.restPose[boneName];\n      if (restState?.position) {\n        _v3A.fromArray(restState.position).negate();\n      }\n      if (restState?.rotation) {\n        quatInvertCompat(_quatA.fromArray(restState.rotation));\n      }\n\n      // Get the position / rotation from the node\n      _v3A.add(node.position);\n      _quatA.premultiply(node.quaternion);\n\n      // Convert to raw arrays\n      pose[boneName] = {\n        position: _v3A.toArray() as [number, number, number],\n        rotation: _quatA.toArray() as [number, number, number, number],\n      };\n    });\n\n    return pose;\n  }\n\n  /**\n   * Let the humanoid do a specified pose.\n   *\n   * Each transform have to be a local transform relative from rest pose (T-pose).\n   * You can pass what you got from {@link getPose}.\n   *\n   * @param poseObject A [[VRMPose]] that represents a single pose\n   */\n  public setPose(poseObject: VRMPose): void {\n    Object.entries(poseObject).forEach(([boneNameString, state]) => {\n      const boneName = boneNameString as VRMHumanBoneName;\n      const node = this.getBoneNode(boneName);\n\n      // Ignore when there are no bone that is defined in the pose on the VRMHumanoid\n      if (!node) {\n        return;\n      }\n\n      const restState = this.restPose[boneName];\n      if (!restState) {\n        // It's very unlikely. Possibly a bug\n        return;\n      }\n\n      // Apply the state to the actual bone\n      if (state?.position) {\n        node.position.fromArray(state.position);\n\n        if (restState.position) {\n          node.position.add(_v3A.fromArray(restState.position));\n        }\n      }\n\n      if (state?.rotation) {\n        node.quaternion.fromArray(state.rotation);\n\n        if (restState.rotation) {\n          node.quaternion.multiply(_quatA.fromArray(restState.rotation));\n        }\n      }\n    });\n  }\n\n  /**\n   * Reset the humanoid to its rest pose.\n   */\n  public resetPose(): void {\n    Object.entries(this.restPose).forEach(([boneName, rest]) => {\n      const node = this.getBoneNode(boneName as VRMHumanBoneName);\n\n      if (!node) {\n        return;\n      }\n\n      if (rest?.position) {\n        node.position.fromArray(rest.position);\n      }\n\n      if (rest?.rotation) {\n        node.quaternion.fromArray(rest.rotation);\n      }\n    });\n  }\n\n  /**\n   * Return a bone bound to a specified {@link VRMHumanBoneName}, as a {@link VRMHumanBone}.\n   *\n   * @param name Name of the bone you want\n   */\n  public getBone(name: VRMHumanBoneName): VRMHumanBone | undefined {\n    return this.humanBones[name] ?? undefined;\n  }\n\n  /**\n   * Return a bone bound to a specified {@link VRMHumanBoneName}, as a `THREE.Object3D`.\n   *\n   * @param name Name of the bone you want\n   */\n  public getBoneNode(name: VRMHumanBoneName): THREE.Object3D | null {\n    return this.humanBones[name]?.node ?? null;\n  }\n}\n", "import * as THREE from 'three';\n\n/**\n * A compat function for `Quaternion.invert()` / `Quaternion.inverse()`.\n * `Quaternion.invert()` is introduced in r123 and `Quaternion.inverse()` emits a warning.\n * We are going to use this compat for a while.\n * @param target A target quaternion\n */\nexport function quatInvertCompat<T extends THREE.Quaternion>(target: T): T {\n  if ((target as any).invert) {\n    target.invert();\n  } else {\n    (target as any).inverse();\n  }\n\n  return target;\n}\n", "import * as THREE from 'three';\nimport { VRMHumanBoneName, VRMHumanBones } from '.';\nimport { VRMHumanBoneList } from './VRMHumanBoneList';\nimport { VRMHumanBoneParentMap } from './VRMHumanBoneParentMap';\nimport { VRMRig } from './VRMRig';\n\nconst _v3A = new THREE.Vector3();\nconst _quatA = new THREE.Quaternion();\nconst _boneWorldPos = new THREE.Vector3();\n\n/**\n * A class represents the normalized Rig of a VRM.\n */\nexport class VRMHumanoidRig extends VRMRig {\n  protected static _setupTransforms(modelRig: VRMRig): {\n    rigBones: VRMHumanBones;\n    root: THREE.Object3D;\n    parentWorldRotations: { [boneName in VRMHumanBoneName]?: THREE.Quaternion };\n    boneRotations: { [boneName in VRMHumanBoneName]?: THREE.Quaternion };\n  } {\n    const root = new THREE.Object3D();\n    root.name = 'VRMHumanoidRig';\n\n    // store boneWorldPositions, boneWorldRotations, and parentWorldRotations\n    const boneWorldPositions: { [boneName in VRMHumanBoneName]?: THREE.Vector3 } = {};\n    const boneWorldRotations: { [boneName in VRMHumanBoneName]?: THREE.Quaternion } = {};\n    const boneRotations: { [boneName in VRMHumanBoneName]?: THREE.Quaternion } = {};\n    const parentWorldRotations: { [boneName in VRMHumanBoneName]?: THREE.Quaternion } = {};\n\n    VRMHumanBoneList.forEach((boneName) => {\n      const boneNode = modelRig.getBoneNode(boneName);\n\n      if (boneNode) {\n        const boneWorldPosition = new THREE.Vector3();\n        const boneWorldRotation = new THREE.Quaternion();\n\n        boneNode.updateWorldMatrix(true, false);\n        boneNode.matrixWorld.decompose(boneWorldPosition, boneWorldRotation, _v3A);\n\n        boneWorldPositions[boneName] = boneWorldPosition;\n        boneWorldRotations[boneName] = boneWorldRotation;\n        boneRotations[boneName] = boneNode.quaternion.clone();\n\n        const parentWorldRotation = new THREE.Quaternion();\n        boneNode.parent?.matrixWorld.decompose(_v3A, parentWorldRotation, _v3A);\n        parentWorldRotations[boneName] = parentWorldRotation;\n      }\n    });\n\n    // build rig hierarchy + store parentWorldRotations\n    const rigBones: Partial<VRMHumanBones> = {};\n    VRMHumanBoneList.forEach((boneName) => {\n      const boneNode = modelRig.getBoneNode(boneName);\n\n      if (boneNode) {\n        const boneWorldPosition = boneWorldPositions[boneName] as THREE.Vector3;\n\n        // see the nearest parent position\n        let currentBoneName: VRMHumanBoneName | null = boneName;\n        let parentBoneWorldPosition: THREE.Vector3 | undefined;\n        while (parentBoneWorldPosition == null) {\n          currentBoneName = VRMHumanBoneParentMap[currentBoneName];\n          if (currentBoneName == null) {\n            break;\n          }\n          parentBoneWorldPosition = boneWorldPositions[currentBoneName];\n        }\n\n        // add to hierarchy\n        const rigBoneNode = new THREE.Object3D();\n        rigBoneNode.name = 'Normalized_' + boneNode.name;\n\n        const parentRigBoneNode = (currentBoneName ? rigBones[currentBoneName]?.node : root) as THREE.Object3D;\n\n        parentRigBoneNode.add(rigBoneNode);\n        rigBoneNode.position.copy(boneWorldPosition);\n        if (parentBoneWorldPosition) {\n          rigBoneNode.position.sub(parentBoneWorldPosition);\n        }\n\n        rigBones[boneName] = { node: rigBoneNode };\n      }\n    });\n\n    return {\n      rigBones: rigBones as VRMHumanBones,\n      root,\n      parentWorldRotations,\n      boneRotations,\n    };\n  }\n\n  public readonly original: VRMRig;\n  public readonly root: THREE.Object3D;\n  protected readonly _parentWorldRotations: { [boneName in VRMHumanBoneName]?: THREE.Quaternion };\n  protected readonly _boneRotations: { [boneName in VRMHumanBoneName]?: THREE.Quaternion };\n\n  public constructor(humanoid: VRMRig) {\n    const { rigBones, root, parentWorldRotations, boneRotations } = VRMHumanoidRig._setupTransforms(humanoid);\n\n    super(rigBones);\n\n    this.original = humanoid;\n    this.root = root;\n    this._parentWorldRotations = parentWorldRotations;\n    this._boneRotations = boneRotations;\n  }\n\n  /**\n   * Update this humanoid rig.\n   */\n  public update(): void {\n    VRMHumanBoneList.forEach((boneName) => {\n      const boneNode = this.original.getBoneNode(boneName);\n\n      if (boneNode != null) {\n        const rigBoneNode = this.getBoneNode(boneName)!;\n        const parentWorldRotation = this._parentWorldRotations[boneName]!;\n        const invParentWorldRotation = _quatA.copy(parentWorldRotation).invert();\n        const boneRotation = this._boneRotations[boneName]!;\n\n        boneNode.quaternion\n          .copy(rigBoneNode.quaternion)\n          .multiply(parentWorldRotation)\n          .premultiply(invParentWorldRotation)\n          .multiply(boneRotation);\n\n        // Move the mass center of the VRM\n        if (boneName === 'hips') {\n          const boneWorldPosition = rigBoneNode.getWorldPosition(_boneWorldPos);\n          boneNode.parent!.updateWorldMatrix(true, false);\n          const parentWorldMatrix = boneNode.parent!.matrixWorld;\n          const localPosition = boneWorldPosition.applyMatrix4(parentWorldMatrix.invert());\n          boneNode.position.copy(localPosition);\n        }\n      }\n    });\n  }\n}\n", "import * as THREE from 'three';\nimport type { VRMHumanBone } from './VRMHumanBone';\nimport type { VRMHumanBones } from './VRMHumanBones';\nimport type { VRMHumanBoneName } from './VRMHumanBoneName';\nimport type { VRMPose } from './VRMPose';\nimport { VRMRig } from './VRMRig';\nimport { VRMHumanoidRig } from './VRMHumanoidRig';\n\n/**\n * A class represents a humanoid of a VRM.\n */\nexport class VRMHumanoid {\n  /**\n   * Whether it copies pose from normalizedHumanBones to rawHumanBones on {@link update}.\n   * `true` by default.\n   *\n   * @default true\n   */\n  public autoUpdateHumanBones: boolean;\n\n  /**\n   * A raw rig of the VRM.\n   */\n  private _rawHumanBones: VRMRig; // TODO: Rename\n\n  /**\n   * A normalized rig of the VRM.\n   */\n  private _normalizedHumanBones: VRMHumanoidRig; // TODO: Rename\n\n  /**\n   * @deprecated Deprecated. Use either {@link rawRestPose} or {@link normalizedRestPose} instead.\n   */\n  public get restPose(): VRMPose {\n    console.warn('VRMHumanoid: restPose is deprecated. Use either rawRestPose or normalizedRestPose instead.');\n\n    return this.rawRestPose;\n  }\n\n  /**\n   * A {@link VRMPose} of its raw human bones that is its default state.\n   * Note that it's not compatible with {@link setRawPose} and {@link getRawPose}, since it contains non-relative values of each local transforms.\n   */\n  public get rawRestPose(): VRMPose {\n    return this._rawHumanBones.restPose;\n  }\n\n  /**\n   * A {@link VRMPose} of its normalized human bones that is its default state.\n   * Note that it's not compatible with {@link setNormalizedPose} and {@link getNormalizedPose}, since it contains non-relative values of each local transforms.\n   */\n  public get normalizedRestPose(): VRMPose {\n    return this._normalizedHumanBones.restPose;\n  }\n\n  /**\n   * A map from {@link VRMHumanBoneName} to raw {@link VRMHumanBone}s.\n   */\n  public get humanBones(): VRMHumanBones {\n    // an alias of `rawHumanBones`\n    return this._rawHumanBones.humanBones;\n  }\n\n  /**\n   * A map from {@link VRMHumanBoneName} to raw {@link VRMHumanBone}s.\n   */\n  public get rawHumanBones(): VRMHumanBones {\n    return this._rawHumanBones.humanBones;\n  }\n\n  /**\n   * A map from {@link VRMHumanBoneName} to normalized {@link VRMHumanBone}s.\n   */\n  public get normalizedHumanBones(): VRMHumanBones {\n    return this._normalizedHumanBones.humanBones;\n  }\n\n  /**\n   * The root of normalized {@link VRMHumanBone}s.\n   */\n  public get normalizedHumanBonesRoot(): THREE.Object3D {\n    return this._normalizedHumanBones.root;\n  }\n\n  /**\n   * Create a new {@link VRMHumanoid}.\n   * @param humanBones A {@link VRMHumanBones} contains all the bones of the new humanoid\n   * @param autoUpdateHumanBones Whether it copies pose from normalizedHumanBones to rawHumanBones on {@link update}. `true` by default.\n   */\n  public constructor(humanBones: VRMHumanBones, options?: { autoUpdateHumanBones?: boolean }) {\n    this.autoUpdateHumanBones = options?.autoUpdateHumanBones ?? true;\n    this._rawHumanBones = new VRMRig(humanBones);\n    this._normalizedHumanBones = new VRMHumanoidRig(this._rawHumanBones);\n  }\n\n  /**\n   * Copy the given {@link VRMHumanoid} into this one.\n   * @param source The {@link VRMHumanoid} you want to copy\n   * @returns this\n   */\n  public copy(source: VRMHumanoid): this {\n    this.autoUpdateHumanBones = source.autoUpdateHumanBones;\n    this._rawHumanBones = new VRMRig(source.humanBones);\n    this._normalizedHumanBones = new VRMHumanoidRig(this._rawHumanBones);\n\n    return this;\n  }\n\n  /**\n   * Returns a clone of this {@link VRMHumanoid}.\n   * @returns Copied {@link VRMHumanoid}\n   */\n  public clone(): VRMHumanoid {\n    return new VRMHumanoid(this.humanBones, { autoUpdateHumanBones: this.autoUpdateHumanBones }).copy(this);\n  }\n\n  /**\n   * @deprecated Deprecated. Use either {@link getRawAbsolutePose} or {@link getNormalizedAbsolutePose} instead.\n   */\n  public getAbsolutePose(): VRMPose {\n    console.warn(\n      'VRMHumanoid: getAbsolutePose() is deprecated. Use either getRawAbsolutePose() or getNormalizedAbsolutePose() instead.',\n    );\n\n    return this.getRawAbsolutePose();\n  }\n\n  /**\n   * Return the current absolute pose of this raw human bones as a {@link VRMPose}.\n   * Note that the output result will contain initial state of the VRM and not compatible between different models.\n   * You might want to use {@link getRawPose} instead.\n   */\n  public getRawAbsolutePose(): VRMPose {\n    return this._rawHumanBones.getAbsolutePose();\n  }\n\n  /**\n   * Return the current absolute pose of this normalized human bones as a {@link VRMPose}.\n   * Note that the output result will contain initial state of the VRM and not compatible between different models.\n   * You might want to use {@link getNormalizedPose} instead.\n   */\n  public getNormalizedAbsolutePose(): VRMPose {\n    return this._normalizedHumanBones.getAbsolutePose();\n  }\n\n  /**\n   * @deprecated Deprecated. Use either {@link getRawPose} or {@link getNormalizedPose} instead.\n   */\n  public getPose(): VRMPose {\n    console.warn('VRMHumanoid: getPose() is deprecated. Use either getRawPose() or getNormalizedPose() instead.');\n\n    return this.getRawPose();\n  }\n\n  /**\n   * Return the current pose of raw human bones as a {@link VRMPose}.\n   *\n   * Each transform is a local transform relative from rest pose (T-pose).\n   */\n  public getRawPose(): VRMPose {\n    return this._rawHumanBones.getPose();\n  }\n\n  /**\n   * Return the current pose of normalized human bones as a {@link VRMPose}.\n   *\n   * Each transform is a local transform relative from rest pose (T-pose).\n   */\n  public getNormalizedPose(): VRMPose {\n    return this._normalizedHumanBones.getPose();\n  }\n\n  /**\n   * @deprecated Deprecated. Use either {@link setRawPose} or {@link setNormalizedPose} instead.\n   */\n  public setPose(poseObject: VRMPose): void {\n    console.warn('VRMHumanoid: setPose() is deprecated. Use either setRawPose() or setNormalizedPose() instead.');\n\n    return this.setRawPose(poseObject);\n  }\n\n  /**\n   * Let the raw human bones do a specified pose.\n   *\n   * Each transform have to be a local transform relative from rest pose (T-pose).\n   * You can pass what you got from {@link getRawPose}.\n   *\n   * If you are using {@link autoUpdateHumanBones}, you might want to use {@link setNormalizedPose} instead.\n   *\n   * @param poseObject A {@link VRMPose} that represents a single pose\n   */\n  public setRawPose(poseObject: VRMPose): void {\n    return this._rawHumanBones.setPose(poseObject);\n  }\n\n  /**\n   * Let the normalized human bones do a specified pose.\n   *\n   * Each transform have to be a local transform relative from rest pose (T-pose).\n   * You can pass what you got from {@link getNormalizedPose}.\n   *\n   * @param poseObject A {@link VRMPose} that represents a single pose\n   */\n  public setNormalizedPose(poseObject: VRMPose): void {\n    return this._normalizedHumanBones.setPose(poseObject);\n  }\n\n  /**\n   * @deprecated Deprecated. Use either {@link resetRawPose} or {@link resetNormalizedPose} instead.\n   */\n  public resetPose(): void {\n    console.warn('VRMHumanoid: resetPose() is deprecated. Use either resetRawPose() or resetNormalizedPose() instead.');\n\n    return this.resetRawPose();\n  }\n\n  /**\n   * Reset the raw humanoid to its rest pose.\n   *\n   * If you are using {@link autoUpdateHumanBones}, you might want to use {@link resetNormalizedPose} instead.\n   */\n  public resetRawPose(): void {\n    return this._rawHumanBones.resetPose();\n  }\n\n  /**\n   * Reset the normalized humanoid to its rest pose.\n   */\n  public resetNormalizedPose(): void {\n    return this._normalizedHumanBones.resetPose();\n  }\n\n  /**\n   * @deprecated Deprecated. Use either {@link getRawBone} or {@link getNormalizedBone} instead.\n   */\n  public getBone(name: VRMHumanBoneName): VRMHumanBone | undefined {\n    console.warn('VRMHumanoid: getBone() is deprecated. Use either getRawBone() or getNormalizedBone() instead.');\n\n    return this.getRawBone(name);\n  }\n\n  /**\n   * Return a raw {@link VRMHumanBone} bound to a specified {@link VRMHumanBoneName}.\n   *\n   * @param name Name of the bone you want\n   */\n  public getRawBone(name: VRMHumanBoneName): VRMHumanBone | undefined {\n    return this._rawHumanBones.getBone(name);\n  }\n\n  /**\n   * Return a normalized {@link VRMHumanBone} bound to a specified {@link VRMHumanBoneName}.\n   *\n   * @param name Name of the bone you want\n   */\n  public getNormalizedBone(name: VRMHumanBoneName): VRMHumanBone | undefined {\n    return this._normalizedHumanBones.getBone(name);\n  }\n\n  /**\n   * @deprecated Deprecated. Use either {@link getRawBoneNode} or {@link getNormalizedBoneNode} instead.\n   */\n  public getBoneNode(name: VRMHumanBoneName): THREE.Object3D | null {\n    console.warn(\n      'VRMHumanoid: getBoneNode() is deprecated. Use either getRawBoneNode() or getNormalizedBoneNode() instead.',\n    );\n\n    return this.getRawBoneNode(name);\n  }\n\n  /**\n   * Return a raw bone as a `THREE.Object3D` bound to a specified {@link VRMHumanBoneName}.\n   *\n   * @param name Name of the bone you want\n   */\n  public getRawBoneNode(name: VRMHumanBoneName): THREE.Object3D | null {\n    return this._rawHumanBones.getBoneNode(name);\n  }\n\n  /**\n   * Return a normalized bone as a `THREE.Object3D` bound to a specified {@link VRMHumanBoneName}.\n   *\n   * @param name Name of the bone you want\n   */\n  public getNormalizedBoneNode(name: VRMHumanBoneName): THREE.Object3D | null {\n    return this._normalizedHumanBones.getBoneNode(name);\n  }\n\n  /**\n   * Update the humanoid component.\n   *\n   * If {@link autoUpdateHumanBones} is `true`, it transfers the pose of normalized human bones to raw human bones.\n   */\n  public update(): void {\n    if (this.autoUpdateHumanBones) {\n      this._normalizedHumanBones.update();\n    }\n  }\n}\n", "/* eslint-disable @typescript-eslint/naming-convention */\n\nexport const VRMRequiredHumanBoneName = {\n  Hips: 'hips',\n  Spine: 'spine',\n  Head: 'head',\n  LeftUpperLeg: 'leftUpperLeg',\n  LeftLowerLeg: 'leftLowerLeg',\n  LeftFoot: 'leftFoot',\n  RightUpperLeg: 'rightUpperLeg',\n  RightLowerLeg: 'rightLowerLeg',\n  RightFoot: 'rightFoot',\n  LeftUpperArm: 'leftUpperArm',\n  LeftLowerArm: 'leftLowerArm',\n  LeftHand: 'leftHand',\n  RightUpperArm: 'rightUpperArm',\n  RightLowerArm: 'rightLowerArm',\n  RightHand: 'rightHand',\n} as const;\n\nexport type VRMRequiredHumanBoneName = typeof VRMRequiredHumanBoneName[keyof typeof VRMRequiredHumanBoneName];\n", "import type * as THREE from 'three';\nimport type * as V0VRM from '@pixiv/types-vrm-0.0';\nimport type * as V1VRMSchema from '@pixiv/types-vrmc-vrm-1.0';\nimport type { GLTF, GLTFLoaderPlugin, GLTFParser } from 'three/examples/jsm/loaders/GLTFLoader.js';\nimport { VRMHumanoid } from './VRMHumanoid';\nimport type { VRMHumanBones } from './VRMHumanBones';\nimport { VRMRequiredHumanBoneName } from './VRMRequiredHumanBoneName';\nimport { GLTF as GLTFSchema } from '@gltf-transform/core';\nimport { VRMHumanoidHelper } from './helpers/VRMHumanoidHelper';\nimport { VRMHumanoidLoaderPluginOptions } from './VRMHumanoidLoaderPluginOptions';\n\n/**\n * Possible spec versions it recognizes.\n */\nconst POSSIBLE_SPEC_VERSIONS = new Set(['1.0', '1.0-beta']);\n\n/**\n * A map from old thumb bone names to new thumb bone names\n */\nconst thumbBoneNameMap: { [key: string]: V1VRMSchema.HumanoidHumanBoneName | undefined } = {\n  leftThumbProximal: 'leftThumbMetacarpal',\n  leftThumbIntermediate: 'leftThumbProximal',\n  rightThumbProximal: 'rightThumbMetacarpal',\n  rightThumbIntermediate: 'rightThumbProximal',\n};\n\n/**\n * A plugin of GLTFLoader that imports a {@link VRMHumanoid} from a VRM extension of a GLTF.\n */\nexport class VRMHumanoidLoaderPlugin implements GLTFLoaderPlugin {\n  /**\n   * Specify an Object3D to add {@link VRMHumanoidHelper}.\n   * If not specified, helper will not be created.\n   * If `renderOrder` is set to the root, the helper will copy the same `renderOrder` .\n   */\n  public helperRoot?: THREE.Object3D;\n\n  public autoUpdateHumanBones?: boolean;\n\n  public readonly parser: GLTFParser;\n\n  public get name(): string {\n    // We should use the extension name instead but we have multiple plugins for an extension...\n    return 'VRMHumanoidLoaderPlugin';\n  }\n\n  public constructor(parser: GLTFParser, options?: VRMHumanoidLoaderPluginOptions) {\n    this.parser = parser;\n\n    this.helperRoot = options?.helperRoot;\n    this.autoUpdateHumanBones = options?.autoUpdateHumanBones;\n  }\n\n  public async afterRoot(gltf: GLTF): Promise<void> {\n    gltf.userData.vrmHumanoid = await this._import(gltf);\n  }\n\n  /**\n   * Import a {@link VRMHumanoid} from a VRM.\n   *\n   * @param gltf A parsed result of GLTF taken from GLTFLoader\n   */\n  private async _import(gltf: GLTF): Promise<VRMHumanoid | null> {\n    const v1Result = await this._v1Import(gltf);\n    if (v1Result) {\n      return v1Result;\n    }\n\n    const v0Result = await this._v0Import(gltf);\n    if (v0Result) {\n      return v0Result;\n    }\n\n    return null;\n  }\n\n  private async _v1Import(gltf: GLTF): Promise<VRMHumanoid | null> {\n    const json = this.parser.json as GLTFSchema.IGLTF;\n\n    // early abort if it doesn't use vrm\n    const isVRMUsed = json.extensionsUsed?.indexOf('VRMC_vrm') !== -1;\n    if (!isVRMUsed) {\n      return null;\n    }\n\n    const extension = json.extensions?.['VRMC_vrm'] as V1VRMSchema.VRMCVRM | undefined;\n    if (!extension) {\n      return null;\n    }\n\n    const specVersion = extension.specVersion;\n    if (!POSSIBLE_SPEC_VERSIONS.has(specVersion)) {\n      console.warn(`VRMHumanoidLoaderPlugin: Unknown VRMC_vrm specVersion \"${specVersion}\"`);\n      return null;\n    }\n\n    const schemaHumanoid = extension.humanoid;\n    if (!schemaHumanoid) {\n      return null;\n    }\n\n    /**\n     * compat: 1.0-beta thumb bone names\n     *\n     * `true` if `leftThumbIntermediate` or `rightThumbIntermediate` exists\n     */\n    const existsPreviousThumbName =\n      (schemaHumanoid.humanBones as any).leftThumbIntermediate != null ||\n      (schemaHumanoid.humanBones as any).rightThumbIntermediate != null;\n\n    const humanBones: Partial<VRMHumanBones> = {};\n    if (schemaHumanoid.humanBones != null) {\n      await Promise.all(\n        Object.entries(schemaHumanoid.humanBones).map(async ([boneNameString, schemaHumanBone]) => {\n          let boneName = boneNameString as V1VRMSchema.HumanoidHumanBoneName;\n          const index = schemaHumanBone.node;\n\n          // compat: 1.0-beta previous thumb bone names\n          if (existsPreviousThumbName) {\n            const thumbBoneName = thumbBoneNameMap[boneName];\n            if (thumbBoneName != null) {\n              boneName = thumbBoneName;\n            }\n          }\n\n          const node = await this.parser.getDependency('node', index);\n\n          // if the specified node does not exist, emit a warning\n          if (node == null) {\n            console.warn(`A glTF node bound to the humanoid bone ${boneName} (index = ${index}) does not exist`);\n            return;\n          }\n\n          // set to the `humanBones`\n          humanBones[boneName] = { node };\n        }),\n      );\n    }\n\n    const humanoid = new VRMHumanoid(this._ensureRequiredBonesExist(humanBones), {\n      autoUpdateHumanBones: this.autoUpdateHumanBones,\n    });\n    gltf.scene.add(humanoid.normalizedHumanBonesRoot);\n\n    if (this.helperRoot) {\n      const helper = new VRMHumanoidHelper(humanoid);\n      this.helperRoot.add(helper);\n      helper.renderOrder = this.helperRoot.renderOrder;\n    }\n\n    return humanoid;\n  }\n\n  private async _v0Import(gltf: GLTF): Promise<VRMHumanoid | null> {\n    const json = this.parser.json as GLTFSchema.IGLTF;\n\n    const vrmExt = json.extensions?.VRM as V0VRM.VRM | undefined;\n    if (!vrmExt) {\n      return null;\n    }\n\n    const schemaHumanoid: V0VRM.Humanoid | undefined = vrmExt.humanoid;\n    if (!schemaHumanoid) {\n      return null;\n    }\n\n    const humanBones: Partial<VRMHumanBones> = {};\n    if (schemaHumanoid.humanBones != null) {\n      await Promise.all(\n        schemaHumanoid.humanBones.map(async (bone) => {\n          const boneName = bone.bone;\n          const index = bone.node;\n\n          if (boneName == null || index == null) {\n            return;\n          }\n\n          const node = await this.parser.getDependency('node', index);\n\n          // if the specified node does not exist, emit a warning\n          if (node == null) {\n            console.warn(`A glTF node bound to the humanoid bone ${boneName} (index = ${index}) does not exist`);\n            return;\n          }\n\n          // map to new bone name\n          const thumbBoneName = thumbBoneNameMap[boneName];\n          const newBoneName = (thumbBoneName ?? boneName) as V1VRMSchema.HumanoidHumanBoneName;\n\n          // v0 VRMs might have a multiple nodes attached to a single bone...\n          // so if there already is an entry in the `humanBones`, show a warning and ignore it\n          if (humanBones[newBoneName] != null) {\n            console.warn(\n              `Multiple bone entries for ${newBoneName} detected (index = ${index}), ignoring duplicated entries.`,\n            );\n            return;\n          }\n\n          // set to the `humanBones`\n          humanBones[newBoneName] = { node };\n        }),\n      );\n    }\n\n    const humanoid = new VRMHumanoid(this._ensureRequiredBonesExist(humanBones), {\n      autoUpdateHumanBones: this.autoUpdateHumanBones,\n    });\n    gltf.scene.add(humanoid.normalizedHumanBonesRoot);\n\n    if (this.helperRoot) {\n      const helper = new VRMHumanoidHelper(humanoid);\n      this.helperRoot.add(helper);\n      helper.renderOrder = this.helperRoot.renderOrder;\n    }\n\n    return humanoid;\n  }\n\n  /**\n   * Ensure required bones exist in given human bones.\n   * @param humanBones Human bones\n   * @returns Human bones, no longer partial!\n   */\n  private _ensureRequiredBonesExist(humanBones: Partial<VRMHumanBones>): VRMHumanBones {\n    // ensure required bones exist\n    const missingRequiredBones = Object.values(VRMRequiredHumanBoneName).filter(\n      (requiredBoneName) => humanBones[requiredBoneName] == null,\n    );\n\n    // throw an error if there are missing bones\n    if (missingRequiredBones.length > 0) {\n      throw new Error(\n        `VRMHumanoidLoaderPlugin: These humanoid bones are required but not exist: ${missingRequiredBones.join(', ')}`,\n      );\n    }\n\n    return humanBones as VRMHumanBones;\n  }\n}\n", "import * as THREE from 'three';\nimport { VRMLookAt } from '../VRMLookAt';\nimport { FanBufferGeometry } from './utils/FanBufferGeometry';\nimport { LineAndSphereBufferGeometry } from './utils/LineAndSphereBufferGeometry';\n\nconst _quatA = new THREE.Quaternion();\nconst _quatB = new THREE.Quaternion();\nconst _v3A = new THREE.Vector3();\nconst _v3B = new THREE.Vector3();\n\nconst SQRT_2_OVER_2 = Math.sqrt(2.0) / 2.0;\nconst QUAT_XY_CW90 = new THREE.Quaternion(0, 0, -SQRT_2_OVER_2, SQRT_2_OVER_2);\nconst VEC3_POSITIVE_Y = new THREE.Vector3(0.0, 1.0, 0.0);\n\nexport class VRMLookAtHelper extends THREE.Group {\n  public readonly vrmLookAt: VRMLookAt;\n  private readonly _meshYaw: THREE.Mesh<FanBufferGeometry, THREE.MeshBasicMaterial>;\n  private readonly _meshPitch: THREE.Mesh<FanBufferGeometry, THREE.MeshBasicMaterial>;\n  private readonly _lineTarget: THREE.LineSegments<LineAndSphereBufferGeometry, THREE.LineBasicMaterial>;\n\n  public constructor(lookAt: VRMLookAt) {\n    super();\n    this.matrixAutoUpdate = false;\n\n    this.vrmLookAt = lookAt;\n\n    {\n      const geometry = new FanBufferGeometry();\n      geometry.radius = 0.5;\n\n      const material = new THREE.MeshBasicMaterial({\n        color: 0x00ff00,\n        transparent: true,\n        opacity: 0.5,\n        side: THREE.DoubleSide,\n        depthTest: false,\n        depthWrite: false,\n      });\n\n      this._meshPitch = new THREE.Mesh(geometry, material);\n      this.add(this._meshPitch);\n    }\n\n    {\n      const geometry = new FanBufferGeometry();\n      geometry.radius = 0.5;\n\n      const material = new THREE.MeshBasicMaterial({\n        color: 0xff0000,\n        transparent: true,\n        opacity: 0.5,\n        side: THREE.DoubleSide,\n        depthTest: false,\n        depthWrite: false,\n      });\n\n      this._meshYaw = new THREE.Mesh(geometry, material);\n      this.add(this._meshYaw);\n    }\n\n    {\n      const geometry = new LineAndSphereBufferGeometry();\n      geometry.radius = 0.1;\n\n      const material = new THREE.LineBasicMaterial({\n        color: 0xffffff,\n        depthTest: false,\n        depthWrite: false,\n      });\n\n      this._lineTarget = new THREE.LineSegments(geometry, material);\n      this._lineTarget.frustumCulled = false;\n      this.add(this._lineTarget);\n    }\n  }\n\n  public dispose(): void {\n    this._meshYaw.geometry.dispose();\n    this._meshYaw.material.dispose();\n\n    this._meshPitch.geometry.dispose();\n    this._meshPitch.material.dispose();\n\n    this._lineTarget.geometry.dispose();\n    this._lineTarget.material.dispose();\n  }\n\n  public updateMatrixWorld(force: boolean): void {\n    // update geometries\n    const yaw = THREE.MathUtils.DEG2RAD * this.vrmLookAt.yaw;\n    this._meshYaw.geometry.theta = yaw;\n    this._meshYaw.geometry.update();\n\n    const pitch = THREE.MathUtils.DEG2RAD * this.vrmLookAt.pitch;\n    this._meshPitch.geometry.theta = pitch;\n    this._meshPitch.geometry.update();\n\n    // get world position and quaternion\n    this.vrmLookAt.getLookAtWorldPosition(_v3A);\n    this.vrmLookAt.getLookAtWorldQuaternion(_quatA);\n\n    // calculate rotation using faceFront\n    _quatA.multiply(this.vrmLookAt.getFaceFrontQuaternion(_quatB));\n\n    // set transform to meshes\n    this._meshYaw.position.copy(_v3A);\n    this._meshYaw.quaternion.copy(_quatA);\n\n    this._meshPitch.position.copy(_v3A);\n    this._meshPitch.quaternion.copy(_quatA);\n    this._meshPitch.quaternion.multiply(_quatB.setFromAxisAngle(VEC3_POSITIVE_Y, yaw));\n    this._meshPitch.quaternion.multiply(QUAT_XY_CW90);\n\n    // update target line and sphere\n    const { target, autoUpdate } = this.vrmLookAt;\n    if (target != null && autoUpdate) {\n      target.getWorldPosition(_v3B).sub(_v3A);\n      this._lineTarget.geometry.tail.copy(_v3B);\n      this._lineTarget.geometry.update();\n      this._lineTarget.position.copy(_v3A);\n    }\n\n    // apply transform to meshes\n    super.updateMatrixWorld(force);\n  }\n}\n", "import * as THREE from 'three';\n\nexport class FanBufferGeometry extends THREE.BufferGeometry {\n  public theta: number;\n  public radius: number;\n  private _currentTheta = 0;\n  private _currentRadius = 0;\n  private readonly _attrPos: THREE.BufferAttribute;\n  private readonly _attrIndex: THREE.BufferAttribute;\n\n  public constructor() {\n    super();\n\n    this.theta = 0.0;\n    this.radius = 0.0;\n    this._currentTheta = 0.0;\n    this._currentRadius = 0.0;\n\n    this._attrPos = new THREE.BufferAttribute(new Float32Array(65 * 3), 3);\n    this.setAttribute('position', this._attrPos);\n\n    this._attrIndex = new THREE.BufferAttribute(new Uint16Array(3 * 63), 1);\n    this.setIndex(this._attrIndex);\n\n    this._buildIndex();\n    this.update();\n  }\n\n  public update(): void {\n    let shouldUpdateGeometry = false;\n\n    if (this._currentTheta !== this.theta) {\n      this._currentTheta = this.theta;\n      shouldUpdateGeometry = true;\n    }\n\n    if (this._currentRadius !== this.radius) {\n      this._currentRadius = this.radius;\n      shouldUpdateGeometry = true;\n    }\n\n    if (shouldUpdateGeometry) {\n      this._buildPosition();\n    }\n  }\n\n  private _buildPosition(): void {\n    this._attrPos.setXYZ(0, 0.0, 0.0, 0.0);\n\n    for (let i = 0; i < 64; i++) {\n      const t = (i / 63.0) * this._currentTheta;\n\n      this._attrPos.setXYZ(i + 1, this._currentRadius * Math.sin(t), 0.0, this._currentRadius * Math.cos(t));\n    }\n\n    this._attrPos.needsUpdate = true;\n  }\n\n  private _buildIndex(): void {\n    for (let i = 0; i < 63; i++) {\n      this._attrIndex.setXYZ(i * 3, 0, i + 1, i + 2);\n    }\n\n    this._attrIndex.needsUpdate = true;\n  }\n}\n", "import * as THREE from 'three';\n\nexport class LineAndSphereBufferGeometry extends THREE.BufferGeometry {\n  public radius: number;\n  public tail: THREE.Vector3;\n  private _currentRadius: number;\n  private _currentTail: THREE.Vector3;\n  private readonly _attrPos: THREE.BufferAttribute;\n  private readonly _attrIndex: THREE.BufferAttribute;\n\n  public constructor() {\n    super();\n\n    this.radius = 0.0;\n    this._currentRadius = 0.0;\n\n    this.tail = new THREE.Vector3();\n    this._currentTail = new THREE.Vector3();\n\n    this._attrPos = new THREE.BufferAttribute(new Float32Array(294), 3);\n    this.setAttribute('position', this._attrPos);\n\n    this._attrIndex = new THREE.BufferAttribute(new Uint16Array(194), 1);\n    this.setIndex(this._attrIndex);\n\n    this._buildIndex();\n    this.update();\n  }\n\n  public update(): void {\n    let shouldUpdateGeometry = false;\n\n    if (this._currentRadius !== this.radius) {\n      this._currentRadius = this.radius;\n      shouldUpdateGeometry = true;\n    }\n\n    if (!this._currentTail.equals(this.tail)) {\n      this._currentTail.copy(this.tail);\n      shouldUpdateGeometry = true;\n    }\n\n    if (shouldUpdateGeometry) {\n      this._buildPosition();\n    }\n  }\n\n  private _buildPosition(): void {\n    for (let i = 0; i < 32; i++) {\n      const t = (i / 16.0) * Math.PI;\n\n      this._attrPos.setXYZ(i, Math.cos(t), Math.sin(t), 0.0);\n      this._attrPos.setXYZ(32 + i, 0.0, Math.cos(t), Math.sin(t));\n      this._attrPos.setXYZ(64 + i, Math.sin(t), 0.0, Math.cos(t));\n    }\n\n    this.scale(this._currentRadius, this._currentRadius, this._currentRadius);\n    this.translate(this._currentTail.x, this._currentTail.y, this._currentTail.z);\n\n    this._attrPos.setXYZ(96, 0, 0, 0);\n    this._attrPos.setXYZ(97, this._currentTail.x, this._currentTail.y, this._currentTail.z);\n\n    this._attrPos.needsUpdate = true;\n  }\n\n  private _buildIndex(): void {\n    for (let i = 0; i < 32; i++) {\n      const i1 = (i + 1) % 32;\n\n      this._attrIndex.setXY(i * 2, i, i1);\n      this._attrIndex.setXY(64 + i * 2, 32 + i, 32 + i1);\n      this._attrIndex.setXY(128 + i * 2, 64 + i, 64 + i1);\n    }\n    this._attrIndex.setXY(192, 96, 97);\n\n    this._attrIndex.needsUpdate = true;\n  }\n}\n", "import * as THREE from 'three';\nimport { VRMHumanoid } from '../humanoid';\nimport { getWorldQuaternionLite } from '../utils/getWorldQuaternionLite';\nimport { quatInvertCompat } from '../utils/quatInvertCompat';\nimport { calcAzimuthAltitude } from './utils/calcAzimuthAltitude';\nimport type { VRMLookAtApplier } from './VRMLookAtApplier';\nimport { sanitizeAngle } from './utils/sanitizeAngle';\n\nconst VEC3_POSITIVE_Z = new THREE.Vector3(0.0, 0.0, 1.0);\n\nconst _v3A = new THREE.Vector3();\nconst _v3B = new THREE.Vector3();\nconst _v3C = new THREE.Vector3();\nconst _quatA = new THREE.Quaternion();\nconst _quatB = new THREE.Quaternion();\nconst _quatC = new THREE.Quaternion();\nconst _quatD = new THREE.Quaternion();\nconst _eulerA = new THREE.Euler();\n\n/**\n * A class controls eye gaze movements of a VRM.\n */\nexport class VRMLookAt {\n  public static readonly EULER_ORDER = 'YXZ'; // yaw-pitch-roll\n\n  /**\n   * The origin of LookAt. Position offset from the head bone.\n   */\n  public offsetFromHeadBone = new THREE.Vector3();\n\n  /**\n   * Its associated {@link VRMHumanoid}.\n   */\n  public readonly humanoid: VRMHumanoid;\n\n  /**\n   * The {@link VRMLookAtApplier} of the LookAt.\n   */\n  public applier: VRMLookAtApplier;\n\n  /**\n   * If this is true, the LookAt will be updated automatically by calling {@link update}, towarding the direction to the {@link target}.\n   * `true` by default.\n   *\n   * See also: {@link target}\n   */\n  public autoUpdate = true;\n\n  /**\n   * The target object of the LookAt.\n   * Note that it does not make any sense if {@link autoUpdate} is disabled.\n   *\n   * See also: {@link autoUpdate}\n   */\n  public target?: THREE.Object3D | null;\n\n  /**\n   * The front direction of the face.\n   * Intended to be used for VRM 0.0 compat (VRM 0.0 models are facing Z- instead of Z+).\n   * You usually don't want to touch this.\n   */\n  public faceFront = new THREE.Vector3(0.0, 0.0, 1.0);\n\n  /**\n   * Its current angle around Y axis, in degree.\n   */\n  protected _yaw: number;\n\n  /**\n   * Its current angle around Y axis, in degree.\n   */\n  public get yaw(): number {\n    return this._yaw;\n  }\n\n  /**\n   * Its current angle around Y axis, in degree.\n   */\n  public set yaw(value: number) {\n    this._yaw = value;\n    this._needsUpdate = true;\n  }\n\n  /**\n   * Its current angle around X axis, in degree.\n   */\n  protected _pitch: number;\n\n  /**\n   * Its current angle around X axis, in degree.\n   */\n  public get pitch(): number {\n    return this._pitch;\n  }\n\n  /**\n   * Its current angle around X axis, in degree.\n   */\n  public set pitch(value: number) {\n    this._pitch = value;\n    this._needsUpdate = true;\n  }\n\n  /**\n   * Specifies that angles need to be applied to its [@link applier].\n   */\n  protected _needsUpdate: boolean;\n\n  /**\n   * World rotation of the head in its rest pose.\n   */\n  private _restHeadWorldQuaternion: THREE.Quaternion;\n\n  /**\n   * @deprecated Use {@link getEuler} instead.\n   */\n  public get euler(): THREE.Euler {\n    console.warn('VRMLookAt: euler is deprecated. use getEuler() instead.');\n\n    return this.getEuler(new THREE.Euler());\n  }\n\n  /**\n   * Create a new {@link VRMLookAt}.\n   *\n   * @param humanoid A {@link VRMHumanoid}\n   * @param applier A {@link VRMLookAtApplier}\n   */\n  public constructor(humanoid: VRMHumanoid, applier: VRMLookAtApplier) {\n    this.humanoid = humanoid;\n    this.applier = applier;\n\n    this._yaw = 0.0;\n    this._pitch = 0.0;\n    this._needsUpdate = true;\n\n    this._restHeadWorldQuaternion = this.getLookAtWorldQuaternion(new THREE.Quaternion());\n  }\n\n  /**\n   * Get its yaw-pitch angles as an `Euler`.\n   * Does NOT consider {@link faceFront}; it returns `Euler(0, 0, 0; \"YXZ\")` by default regardless of the faceFront value.\n   *\n   * @param target The target euler\n   */\n  public getEuler(target: THREE.Euler): THREE.Euler {\n    return target.set(THREE.MathUtils.DEG2RAD * this._pitch, THREE.MathUtils.DEG2RAD * this._yaw, 0.0, 'YXZ');\n  }\n\n  /**\n   * Copy the given {@link VRMLookAt} into this one.\n   * {@link humanoid} must be same as the source one.\n   * {@link applier} will reference the same instance as the source one.\n   * @param source The {@link VRMLookAt} you want to copy\n   * @returns this\n   */\n  public copy(source: VRMLookAt): this {\n    if (this.humanoid !== source.humanoid) {\n      throw new Error('VRMLookAt: humanoid must be same in order to copy');\n    }\n\n    this.offsetFromHeadBone.copy(source.offsetFromHeadBone);\n    this.applier = source.applier;\n    this.autoUpdate = source.autoUpdate;\n    this.target = source.target;\n    this.faceFront.copy(source.faceFront);\n\n    return this;\n  }\n\n  /**\n   * Returns a clone of this {@link VRMLookAt}.\n   * Note that {@link humanoid} and {@link applier} will reference the same instance as this one.\n   * @returns Copied {@link VRMLookAt}\n   */\n  public clone(): VRMLookAt {\n    return new VRMLookAt(this.humanoid, this.applier).copy(this);\n  }\n\n  /**\n   * Reset the lookAt direction (yaw and pitch) to the initial direction.\n   */\n  public reset(): void {\n    this._yaw = 0.0;\n    this._pitch = 0.0;\n    this._needsUpdate = true;\n  }\n\n  /**\n   * Get its lookAt position in world coordinate.\n   *\n   * @param target A target `THREE.Vector3`\n   */\n  public getLookAtWorldPosition(target: THREE.Vector3): THREE.Vector3 {\n    const head = this.humanoid.getRawBoneNode('head')!;\n\n    return target.copy(this.offsetFromHeadBone).applyMatrix4(head.matrixWorld);\n  }\n\n  /**\n   * Get its lookAt rotation in world coordinate.\n   * Does NOT consider {@link faceFront}.\n   *\n   * @param target A target `THREE.Quaternion`\n   */\n  public getLookAtWorldQuaternion(target: THREE.Quaternion): THREE.Quaternion {\n    const head = this.humanoid.getRawBoneNode('head')!;\n\n    return getWorldQuaternionLite(head, target);\n  }\n\n  /**\n   * Get a quaternion that rotates the +Z unit vector of the humanoid Head to the {@link faceFront} direction.\n   *\n   * @param target A target `THREE.Quaternion`\n   */\n  public getFaceFrontQuaternion(target: THREE.Quaternion): THREE.Quaternion {\n    if (this.faceFront.distanceToSquared(VEC3_POSITIVE_Z) < 0.01) {\n      return target.copy(this._restHeadWorldQuaternion).invert();\n    }\n\n    const [faceFrontAzimuth, faceFrontAltitude] = calcAzimuthAltitude(this.faceFront);\n    _eulerA.set(0.0, 0.5 * Math.PI + faceFrontAzimuth, faceFrontAltitude, 'YZX');\n\n    return target.setFromEuler(_eulerA).premultiply(_quatD.copy(this._restHeadWorldQuaternion).invert());\n  }\n\n  /**\n   * Get its LookAt direction in world coordinate.\n   *\n   * @param target A target `THREE.Vector3`\n   */\n  public getLookAtWorldDirection(target: THREE.Vector3): THREE.Vector3 {\n    this.getLookAtWorldQuaternion(_quatB);\n    this.getFaceFrontQuaternion(_quatC);\n\n    return target\n      .copy(VEC3_POSITIVE_Z)\n      .applyQuaternion(_quatB)\n      .applyQuaternion(_quatC)\n      .applyEuler(this.getEuler(_eulerA));\n  }\n\n  /**\n   * Set its lookAt target position.\n   *\n   * Note that its result will be instantly overwritten if {@link VRMLookAtHead.autoUpdate} is enabled.\n   *\n   * If you want to track an object continuously, you might want to use {@link target} instead.\n   *\n   * @param position A target position, in world space\n   */\n  public lookAt(position: THREE.Vector3): void {\n    // Look at direction in local coordinate\n    const headRotDiffInv = _quatA\n      .copy(this._restHeadWorldQuaternion)\n      .multiply(quatInvertCompat(this.getLookAtWorldQuaternion(_quatB)));\n    const headPos = this.getLookAtWorldPosition(_v3B);\n    const lookAtDir = _v3C.copy(position).sub(headPos).applyQuaternion(headRotDiffInv).normalize();\n\n    // calculate angles\n    const [azimuthFrom, altitudeFrom] = calcAzimuthAltitude(this.faceFront);\n    const [azimuthTo, altitudeTo] = calcAzimuthAltitude(lookAtDir);\n    const yaw = sanitizeAngle(azimuthTo - azimuthFrom);\n    const pitch = sanitizeAngle(altitudeFrom - altitudeTo); // spinning (1, 0, 0) CCW around Z axis makes the vector look up, while spinning (0, 0, 1) CCW around X axis makes the vector look down\n\n    // apply angles\n    this._yaw = THREE.MathUtils.RAD2DEG * yaw;\n    this._pitch = THREE.MathUtils.RAD2DEG * pitch;\n\n    this._needsUpdate = true;\n  }\n\n  /**\n   * Update the VRMLookAtHead.\n   * If {@link autoUpdate} is enabled, this will make it look at the {@link target}.\n   *\n   * @param delta deltaTime, it isn't used though. You can use the parameter if you want to use this in your own extended {@link VRMLookAt}.\n   */\n  public update(delta: number): void {\n    if (this.target != null && this.autoUpdate) {\n      this.lookAt(this.target.getWorldPosition(_v3A));\n    }\n\n    if (this._needsUpdate) {\n      this._needsUpdate = false;\n\n      this.applier.applyYawPitch(this._yaw, this._pitch);\n    }\n  }\n}\n", "import * as THREE from 'three';\n\nconst _position = new THREE.Vector3();\nconst _scale = new THREE.Vector3();\n\n/**\n * A replacement of `Object3D.getWorldQuaternion`.\n * Extract the world quaternion of an object from its world space matrix, without calling `Object3D.updateWorldMatrix`.\n * Use this when you're sure that the world matrix is up-to-date.\n *\n * @param object The object\n * @param out A target quaternion\n */\nexport function getWorldQuaternionLite(object: THREE.Object3D, out: THREE.Quaternion): THREE.Quaternion {\n  object.matrixWorld.decompose(_position, out, _scale);\n  return out;\n}\n", "import * as THREE from 'three';\n\n/**\n * Calculate azimuth / altitude angles from a vector.\n *\n * This returns a difference of angles from (1, 0, 0).\n * Azimuth represents an angle around Y axis.\n * Altitude represents an angle around Z axis.\n * It is rotated in intrinsic Y-Z order.\n *\n * @param vector The vector\n * @returns A tuple contains two angles, `[ azimuth, altitude ]`\n */\nexport function calcAzimuthAltitude(vector: THREE.Vector3): [azimuth: number, altitude: number] {\n  return [Math.atan2(-vector.z, vector.x), Math.atan2(vector.y, Math.sqrt(vector.x * vector.x + vector.z * vector.z))];\n}\n", "/**\n * Make sure the angle is within -PI to PI.\n *\n * @example\n * ```js\n * sanitizeAngle(1.5 * Math.PI) // -0.5 * PI\n * ```\n *\n * @param angle An input angle\n */\nexport function sanitizeAngle(angle: number): number {\n  const roundTurn = Math.round(angle / 2.0 / Math.PI);\n  return angle - 2.0 * Math.PI * roundTurn;\n}\n", "import { VRMHumanoid } from '../humanoid';\nimport * as THREE from 'three';\nimport type { VRMLookAtApplier } from './VRMLookAtApplier';\nimport { VRMLookAtRangeMap } from './VRMLookAtRangeMap';\nimport { calcAzimuthAltitude } from './utils/calcAzimuthAltitude';\nimport { getWorldQuaternionLite } from '../utils/getWorldQuaternionLite';\n\nconst VEC3_POSITIVE_Z = new THREE.Vector3(0.0, 0.0, 1.0);\n\nconst _quatA = new THREE.Quaternion();\nconst _quatB = new THREE.Quaternion();\nconst _eulerA = new THREE.Euler(0.0, 0.0, 0.0, 'YXZ');\n\n/**\n * A class that applies eye gaze directions to a VRM.\n * It will be used by {@link VRMLookAt}.\n */\nexport class VRMLookAtBoneApplier implements VRMLookAtApplier {\n  /**\n   * Represent its type of applier.\n   */\n  public static readonly type = 'bone';\n\n  /**\n   * Its associated {@link VRMHumanoid}.\n   */\n  public readonly humanoid: VRMHumanoid;\n\n  /**\n   * A {@link VRMLookAtRangeMap} for horizontal inward movement. The left eye moves right. The right eye moves left.\n   */\n  public rangeMapHorizontalInner: VRMLookAtRangeMap;\n\n  /**\n   * A {@link VRMLookAtRangeMap} for horizontal outward movement. The left eye moves left. The right eye moves right.\n   */\n  public rangeMapHorizontalOuter: VRMLookAtRangeMap;\n\n  /**\n   * A {@link VRMLookAtRangeMap} for vertical downward movement. Both eyes move upwards.\n   */\n  public rangeMapVerticalDown: VRMLookAtRangeMap;\n\n  /**\n   * A {@link VRMLookAtRangeMap} for vertical upward movement. Both eyes move downwards.\n   */\n  public rangeMapVerticalUp: VRMLookAtRangeMap;\n\n  /**\n   * The front direction of the face.\n   * Intended to be used for VRM 0.0 compat (VRM 0.0 models are facing Z- instead of Z+).\n   * You usually don't want to touch this.\n   */\n  public faceFront: THREE.Vector3;\n\n  /**\n   * The rest quaternion of LeftEye bone.\n   */\n  private _restQuatLeftEye: THREE.Quaternion;\n\n  /**\n   * The rest quaternion of RightEye bone.\n   */\n  private _restQuatRightEye: THREE.Quaternion;\n\n  /**\n   * The world-space rest quaternion of the parent of the humanoid LeftEye.\n   */\n  private _restLeftEyeParentWorldQuat: THREE.Quaternion;\n\n  /**\n   * The world-space rest quaternion of the parent of the humanoid RightEye.\n   */\n  private _restRightEyeParentWorldQuat: THREE.Quaternion;\n\n  /**\n   * Create a new {@link VRMLookAtBoneApplier}.\n   *\n   * @param humanoid A {@link VRMHumanoid}\n   * @param rangeMapHorizontalInner A {@link VRMLookAtRangeMap} used for inner transverse direction\n   * @param rangeMapHorizontalOuter A {@link VRMLookAtRangeMap} used for outer transverse direction\n   * @param rangeMapVerticalDown A {@link VRMLookAtRangeMap} used for down direction\n   * @param rangeMapVerticalUp A {@link VRMLookAtRangeMap} used for up direction\n   */\n  public constructor(\n    humanoid: VRMHumanoid,\n    rangeMapHorizontalInner: VRMLookAtRangeMap,\n    rangeMapHorizontalOuter: VRMLookAtRangeMap,\n    rangeMapVerticalDown: VRMLookAtRangeMap,\n    rangeMapVerticalUp: VRMLookAtRangeMap,\n  ) {\n    this.humanoid = humanoid;\n\n    this.rangeMapHorizontalInner = rangeMapHorizontalInner;\n    this.rangeMapHorizontalOuter = rangeMapHorizontalOuter;\n    this.rangeMapVerticalDown = rangeMapVerticalDown;\n    this.rangeMapVerticalUp = rangeMapVerticalUp;\n\n    this.faceFront = new THREE.Vector3(0.0, 0.0, 1.0);\n\n    // set rest quaternions\n    this._restQuatLeftEye = new THREE.Quaternion();\n    this._restQuatRightEye = new THREE.Quaternion();\n    this._restLeftEyeParentWorldQuat = new THREE.Quaternion();\n    this._restRightEyeParentWorldQuat = new THREE.Quaternion();\n\n    const leftEye = this.humanoid.getRawBoneNode('leftEye');\n    const rightEye = this.humanoid.getRawBoneNode('rightEye');\n\n    if (leftEye) {\n      this._restQuatLeftEye.copy(leftEye.quaternion);\n      getWorldQuaternionLite(leftEye.parent!, this._restLeftEyeParentWorldQuat);\n    }\n\n    if (rightEye) {\n      this._restQuatRightEye.copy(rightEye.quaternion);\n      getWorldQuaternionLite(rightEye.parent!, this._restRightEyeParentWorldQuat);\n    }\n  }\n\n  /**\n   * Apply the input angle to its associated VRM model.\n   *\n   * @param yaw Rotation around Y axis, in degree\n   * @param pitch Rotation around X axis, in degree\n   */\n  public applyYawPitch(yaw: number, pitch: number): void {\n    const leftEye = this.humanoid.getRawBoneNode('leftEye');\n    const rightEye = this.humanoid.getRawBoneNode('rightEye');\n    const leftEyeNormalized = this.humanoid.getNormalizedBoneNode('leftEye');\n    const rightEyeNormalized = this.humanoid.getNormalizedBoneNode('rightEye');\n    // left\n    if (leftEye) {\n      if (pitch < 0.0) {\n        _eulerA.x = -THREE.MathUtils.DEG2RAD * this.rangeMapVerticalDown.map(-pitch);\n      } else {\n        _eulerA.x = THREE.MathUtils.DEG2RAD * this.rangeMapVerticalUp.map(pitch);\n      }\n\n      if (yaw < 0.0) {\n        _eulerA.y = -THREE.MathUtils.DEG2RAD * this.rangeMapHorizontalInner.map(-yaw);\n      } else {\n        _eulerA.y = THREE.MathUtils.DEG2RAD * this.rangeMapHorizontalOuter.map(yaw);\n      }\n\n      _quatA.setFromEuler(_eulerA);\n      this._getWorldFaceFrontQuat(_quatB);\n\n      // _quatB * _quatA * _quatB^-1\n      // where _quatA is LookAt rotation\n      // and _quatB is worldFaceFrontQuat\n      leftEyeNormalized!.quaternion.copy(_quatB).multiply(_quatA).multiply(_quatB.invert());\n\n      _quatA.copy(this._restLeftEyeParentWorldQuat);\n\n      // _quatA^-1 * leftEyeNormalized.quaternion * _quatA * restQuatLeftEye\n      // where _quatA is restLeftEyeParentWorldQuat\n      leftEye.quaternion\n        .copy(leftEyeNormalized!.quaternion)\n        .multiply(_quatA)\n        .premultiply(_quatA.invert())\n        .multiply(this._restQuatLeftEye);\n    }\n\n    // right\n    if (rightEye) {\n      if (pitch < 0.0) {\n        _eulerA.x = -THREE.MathUtils.DEG2RAD * this.rangeMapVerticalDown.map(-pitch);\n      } else {\n        _eulerA.x = THREE.MathUtils.DEG2RAD * this.rangeMapVerticalUp.map(pitch);\n      }\n\n      if (yaw < 0.0) {\n        _eulerA.y = -THREE.MathUtils.DEG2RAD * this.rangeMapHorizontalOuter.map(-yaw);\n      } else {\n        _eulerA.y = THREE.MathUtils.DEG2RAD * this.rangeMapHorizontalInner.map(yaw);\n      }\n\n      _quatA.setFromEuler(_eulerA);\n      this._getWorldFaceFrontQuat(_quatB);\n\n      // _quatB * _quatA * _quatB^-1\n      // where _quatA is LookAt rotation\n      // and _quatB is worldFaceFrontQuat\n      rightEyeNormalized!.quaternion.copy(_quatB).multiply(_quatA).multiply(_quatB.invert());\n\n      _quatA.copy(this._restRightEyeParentWorldQuat);\n\n      // _quatA^-1 * rightEyeNormalized.quaternion * _quatA * restQuatRightEye\n      // where _quatA is restRightEyeParentWorldQuat\n      rightEye.quaternion\n        .copy(rightEyeNormalized!.quaternion)\n        .multiply(_quatA)\n        .premultiply(_quatA.invert())\n        .multiply(this._restQuatRightEye);\n    }\n  }\n\n  /**\n   * @deprecated Use {@link applyYawPitch} instead.\n   */\n  public lookAt(euler: THREE.Euler): void {\n    console.warn('VRMLookAtBoneApplier: lookAt() is deprecated. use apply() instead.');\n\n    const yaw = THREE.MathUtils.RAD2DEG * euler.y;\n    const pitch = THREE.MathUtils.RAD2DEG * euler.x;\n\n    this.applyYawPitch(yaw, pitch);\n  }\n\n  /**\n   * Get a quaternion that rotates the world-space +Z unit vector to the {@link faceFront} direction.\n   *\n   * @param target A target `THREE.Quaternion`\n   */\n  private _getWorldFaceFrontQuat(target: THREE.Quaternion): THREE.Quaternion {\n    if (this.faceFront.distanceToSquared(VEC3_POSITIVE_Z) < 0.01) {\n      return target.identity();\n    }\n\n    const [faceFrontAzimuth, faceFrontAltitude] = calcAzimuthAltitude(this.faceFront);\n    _eulerA.set(0.0, 0.5 * Math.PI + faceFrontAzimuth, faceFrontAltitude, 'YZX');\n\n    return target.setFromEuler(_eulerA);\n  }\n}\n", "import { VRMExpressionManager } from '../expressions';\nimport * as THREE from 'three';\nimport type { VRMLookAtApplier } from './VRMLookAtApplier';\nimport { VRMLookAtRangeMap } from './VRMLookAtRangeMap';\n\n/**\n * A class that applies eye gaze directions to a VRM.\n * It will be used by {@link VRMLookAt}.\n */\nexport class VRMLookAtExpressionApplier implements VRMLookAtApplier {\n  /**\n   * Represent its type of applier.\n   */\n  public static readonly type = 'expression';\n\n  /**\n   * Its associated {@link VRMExpressionManager}.\n   */\n  public readonly expressions: VRMExpressionManager;\n\n  /**\n   * It won't be used in expression applier.\n   * See also: {@link rangeMapHorizontalOuter}\n   */\n  public rangeMapHorizontalInner: VRMLookAtRangeMap;\n\n  /**\n   * A {@link VRMLookAtRangeMap} for horizontal movement. Both eyes move left or right.\n   */\n  public rangeMapHorizontalOuter: VRMLookAtRangeMap;\n\n  /**\n   * A {@link VRMLookAtRangeMap} for vertical downward movement. Both eyes move upwards.\n   */\n  public rangeMapVerticalDown: VRMLookAtRangeMap;\n\n  /**\n   * A {@link VRMLookAtRangeMap} for vertical upward movement. Both eyes move downwards.\n   */\n  public rangeMapVerticalUp: VRMLookAtRangeMap;\n\n  /**\n   * Create a new {@link VRMLookAtExpressionApplier}.\n   *\n   * @param expressions A {@link VRMExpressionManager}\n   * @param rangeMapHorizontalInner A {@link VRMLookAtRangeMap} used for inner transverse direction\n   * @param rangeMapHorizontalOuter A {@link VRMLookAtRangeMap} used for outer transverse direction\n   * @param rangeMapVerticalDown A {@link VRMLookAtRangeMap} used for down direction\n   * @param rangeMapVerticalUp A {@link VRMLookAtRangeMap} used for up direction\n   */\n  public constructor(\n    expressions: VRMExpressionManager,\n    rangeMapHorizontalInner: VRMLookAtRangeMap,\n    rangeMapHorizontalOuter: VRMLookAtRangeMap,\n    rangeMapVerticalDown: VRMLookAtRangeMap,\n    rangeMapVerticalUp: VRMLookAtRangeMap,\n  ) {\n    this.expressions = expressions;\n\n    this.rangeMapHorizontalInner = rangeMapHorizontalInner;\n    this.rangeMapHorizontalOuter = rangeMapHorizontalOuter;\n    this.rangeMapVerticalDown = rangeMapVerticalDown;\n    this.rangeMapVerticalUp = rangeMapVerticalUp;\n  }\n\n  /**\n   * Apply the input angle to its associated VRM model.\n   *\n   * @param yaw Rotation around Y axis, in degree\n   * @param pitch Rotation around X axis, in degree\n   */\n  public applyYawPitch(yaw: number, pitch: number): void {\n    if (pitch < 0.0) {\n      this.expressions.setValue('lookDown', 0.0);\n      this.expressions.setValue('lookUp', this.rangeMapVerticalUp.map(-pitch));\n    } else {\n      this.expressions.setValue('lookUp', 0.0);\n      this.expressions.setValue('lookDown', this.rangeMapVerticalDown.map(pitch));\n    }\n\n    if (yaw < 0.0) {\n      this.expressions.setValue('lookLeft', 0.0);\n      this.expressions.setValue('lookRight', this.rangeMapHorizontalOuter.map(-yaw));\n    } else {\n      this.expressions.setValue('lookRight', 0.0);\n      this.expressions.setValue('lookLeft', this.rangeMapHorizontalOuter.map(yaw));\n    }\n  }\n\n  /**\n   * @deprecated Use {@link applyYawPitch} instead.\n   */\n  public lookAt(euler: THREE.Euler): void {\n    console.warn('VRMLookAtBoneApplier: lookAt() is deprecated. use apply() instead.');\n\n    const yaw = THREE.MathUtils.RAD2DEG * euler.y;\n    const pitch = THREE.MathUtils.RAD2DEG * euler.x;\n\n    this.applyYawPitch(yaw, pitch);\n  }\n}\n", "import { saturate } from '../utils/saturate';\n\nexport class VRMLookAtRangeMap {\n  /**\n   * Limits the maximum angle of the input angle of the LookAt vector from the front of the head (the positive z axis).\n   */\n  public inputMaxValue: number;\n\n  /**\n   * Represents an angle (in degrees) for bone type of LookAt appliers, or a weight for expression type of LookAt appliers.\n   * The input value will take `1.0` when the input angle equals (or greater) to {@link inputMaxValue}.\n   */\n  public outputScale: number;\n\n  /**\n   * Create a new {@link VRMLookAtRangeMap}.\n   *\n   * @param inputMaxValue The {@link inputMaxValue} of the map\n   * @param outputScale The {@link outputScale} of the map\n   */\n  public constructor(inputMaxValue: number, outputScale: number) {\n    this.inputMaxValue = inputMaxValue;\n    this.outputScale = outputScale;\n  }\n\n  /**\n   * Evaluate an input value and output a mapped value.\n   * @param src The input value\n   */\n  public map(src: number): number {\n    return this.outputScale * saturate(src / this.inputMaxValue);\n  }\n}\n", "import type * as THREE from 'three';\nimport type * as V0VRM from '@pixiv/types-vrm-0.0';\nimport type * as V1VRMSchema from '@pixiv/types-vrmc-vrm-1.0';\nimport type { GLTF, GLTFLoaderPlugin, GLTFParser } from 'three/examples/jsm/loaders/GLTFLoader.js';\nimport type { VRMExpressionManager } from '../expressions/VRMExpressionManager';\nimport type { VRMHumanoid } from '../humanoid/VRMHumanoid';\nimport { VRMLookAtHelper } from './helpers/VRMLookAtHelper';\nimport { VRMLookAt } from './VRMLookAt';\nimport type { VRMLookAtApplier } from './VRMLookAtApplier';\nimport { VRMLookAtBoneApplier } from './VRMLookAtBoneApplier';\nimport { VRMLookAtExpressionApplier } from './VRMLookAtExpressionApplier';\nimport type { VRMLookAtLoaderPluginOptions } from './VRMLookAtLoaderPluginOptions';\nimport { VRMLookAtRangeMap } from './VRMLookAtRangeMap';\nimport { GLTF as GLTFSchema } from '@gltf-transform/core';\n\n/**\n * Possible spec versions it recognizes.\n */\nconst POSSIBLE_SPEC_VERSIONS = new Set(['1.0', '1.0-beta']);\n\n/**\n * The minimum permitted value for {@link V1VRMSchema.LookAtRangeMap.inputMaxValue}.\n * If the given value is smaller than this, the loader shows a warning and clamps up the value.\n */\nconst INPUT_MAX_VALUE_MINIMUM = 0.01;\n\n/**\n * A plugin of GLTFLoader that imports a {@link VRMLookAt} from a VRM extension of a GLTF.\n */\nexport class VRMLookAtLoaderPlugin implements GLTFLoaderPlugin {\n  /**\n   * Specify an Object3D to add {@link VRMLookAtHelper} s.\n   * If not specified, helper will not be created.\n   * If `renderOrder` is set to the root, helpers will copy the same `renderOrder` .\n   */\n  public helperRoot?: THREE.Object3D;\n\n  public readonly parser: GLTFParser;\n\n  public get name(): string {\n    // We should use the extension name instead but we have multiple plugins for an extension...\n    return 'VRMLookAtLoaderPlugin';\n  }\n\n  public constructor(parser: GLTFParser, options?: VRMLookAtLoaderPluginOptions) {\n    this.parser = parser;\n\n    this.helperRoot = options?.helperRoot;\n  }\n\n  public async afterRoot(gltf: GLTF): Promise<void> {\n    const vrmHumanoid = gltf.userData.vrmHumanoid as VRMHumanoid | undefined;\n\n    // explicitly distinguish null and undefined\n    // since vrmHumanoid might be null as a result\n    if (vrmHumanoid === null) {\n      return;\n    } else if (vrmHumanoid === undefined) {\n      throw new Error('VRMLookAtLoaderPlugin: vrmHumanoid is undefined. VRMHumanoidLoaderPlugin have to be used first');\n    }\n\n    const vrmExpressionManager = gltf.userData.vrmExpressionManager as VRMExpressionManager | undefined;\n\n    if (vrmExpressionManager === null) {\n      return;\n    } else if (vrmExpressionManager === undefined) {\n      throw new Error(\n        'VRMLookAtLoaderPlugin: vrmExpressionManager is undefined. VRMExpressionLoaderPlugin have to be used first',\n      );\n    }\n\n    gltf.userData.vrmLookAt = await this._import(gltf, vrmHumanoid, vrmExpressionManager);\n  }\n\n  /**\n   * Import a {@link VRMLookAt} from a VRM.\n   *\n   * @param gltf A parsed result of GLTF taken from GLTFLoader\n   * @param humanoid A {@link VRMHumanoid} instance that represents the VRM\n   * @param expressions A {@link VRMExpressionManager} instance that represents the VRM\n   */\n  private async _import(\n    gltf: GLTF,\n    humanoid: VRMHumanoid | null,\n    expressions: VRMExpressionManager | null,\n  ): Promise<VRMLookAt | null> {\n    if (humanoid == null || expressions == null) {\n      return null;\n    }\n\n    const v1Result = await this._v1Import(gltf, humanoid, expressions);\n    if (v1Result) {\n      return v1Result;\n    }\n\n    const v0Result = await this._v0Import(gltf, humanoid, expressions);\n    if (v0Result) {\n      return v0Result;\n    }\n\n    return null;\n  }\n\n  private async _v1Import(\n    gltf: GLTF,\n    humanoid: VRMHumanoid,\n    expressions: VRMExpressionManager,\n  ): Promise<VRMLookAt | null> {\n    const json = this.parser.json as GLTFSchema.IGLTF;\n\n    // early abort if it doesn't use vrm\n    const isVRMUsed = json.extensionsUsed?.indexOf('VRMC_vrm') !== -1;\n    if (!isVRMUsed) {\n      return null;\n    }\n\n    const extension = json.extensions?.['VRMC_vrm'] as V1VRMSchema.VRMCVRM | undefined;\n    if (!extension) {\n      return null;\n    }\n\n    const specVersion = extension.specVersion;\n    if (!POSSIBLE_SPEC_VERSIONS.has(specVersion)) {\n      console.warn(`VRMLookAtLoaderPlugin: Unknown VRMC_vrm specVersion \"${specVersion}\"`);\n      return null;\n    }\n\n    const schemaLookAt = extension.lookAt;\n    if (!schemaLookAt) {\n      return null;\n    }\n\n    const defaultOutputScale = schemaLookAt.type === 'expression' ? 1.0 : 10.0;\n\n    const mapHI = this._v1ImportRangeMap(schemaLookAt.rangeMapHorizontalInner, defaultOutputScale);\n    const mapHO = this._v1ImportRangeMap(schemaLookAt.rangeMapHorizontalOuter, defaultOutputScale);\n    const mapVD = this._v1ImportRangeMap(schemaLookAt.rangeMapVerticalDown, defaultOutputScale);\n    const mapVU = this._v1ImportRangeMap(schemaLookAt.rangeMapVerticalUp, defaultOutputScale);\n\n    let applier;\n\n    if (schemaLookAt.type === 'expression') {\n      applier = new VRMLookAtExpressionApplier(expressions, mapHI, mapHO, mapVD, mapVU);\n    } else {\n      applier = new VRMLookAtBoneApplier(humanoid, mapHI, mapHO, mapVD, mapVU);\n    }\n\n    const lookAt = this._importLookAt(humanoid, applier);\n\n    lookAt.offsetFromHeadBone.fromArray(schemaLookAt.offsetFromHeadBone ?? [0.0, 0.06, 0.0]);\n\n    return lookAt;\n  }\n\n  private _v1ImportRangeMap(\n    schemaRangeMap: V1VRMSchema.LookAtRangeMap | undefined,\n    defaultOutputScale: number,\n  ): VRMLookAtRangeMap {\n    let inputMaxValue = schemaRangeMap?.inputMaxValue ?? 90.0;\n    const outputScale = schemaRangeMap?.outputScale ?? defaultOutputScale;\n\n    // It might cause NaN when `inputMaxValue` is too small\n    // which makes the mesh of the head disappear\n    // See: https://github.com/pixiv/three-vrm/issues/1201\n    if (inputMaxValue < INPUT_MAX_VALUE_MINIMUM) {\n      console.warn(\n        'VRMLookAtLoaderPlugin: inputMaxValue of a range map is too small. Consider reviewing the range map!',\n      );\n      inputMaxValue = INPUT_MAX_VALUE_MINIMUM;\n    }\n\n    return new VRMLookAtRangeMap(inputMaxValue, outputScale);\n  }\n\n  private async _v0Import(\n    gltf: GLTF,\n    humanoid: VRMHumanoid,\n    expressions: VRMExpressionManager,\n  ): Promise<VRMLookAt | null> {\n    const json = this.parser.json as GLTFSchema.IGLTF;\n\n    // early abort if it doesn't use vrm\n    const vrmExt = json.extensions?.VRM as V0VRM.VRM | undefined;\n    if (!vrmExt) {\n      return null;\n    }\n\n    const schemaFirstPerson = vrmExt.firstPerson;\n    if (!schemaFirstPerson) {\n      return null;\n    }\n\n    const defaultOutputScale = schemaFirstPerson.lookAtTypeName === 'BlendShape' ? 1.0 : 10.0;\n\n    const mapHI = this._v0ImportDegreeMap(schemaFirstPerson.lookAtHorizontalInner, defaultOutputScale);\n    const mapHO = this._v0ImportDegreeMap(schemaFirstPerson.lookAtHorizontalOuter, defaultOutputScale);\n    const mapVD = this._v0ImportDegreeMap(schemaFirstPerson.lookAtVerticalDown, defaultOutputScale);\n    const mapVU = this._v0ImportDegreeMap(schemaFirstPerson.lookAtVerticalUp, defaultOutputScale);\n\n    let applier;\n\n    if (schemaFirstPerson.lookAtTypeName === 'BlendShape') {\n      applier = new VRMLookAtExpressionApplier(expressions, mapHI, mapHO, mapVD, mapVU);\n    } else {\n      applier = new VRMLookAtBoneApplier(humanoid, mapHI, mapHO, mapVD, mapVU);\n    }\n\n    const lookAt = this._importLookAt(humanoid, applier);\n\n    if (schemaFirstPerson.firstPersonBoneOffset) {\n      lookAt.offsetFromHeadBone.set(\n        schemaFirstPerson.firstPersonBoneOffset.x ?? 0.0,\n        schemaFirstPerson.firstPersonBoneOffset.y ?? 0.06,\n        -(schemaFirstPerson.firstPersonBoneOffset.z ?? 0.0),\n      );\n    } else {\n      lookAt.offsetFromHeadBone.set(0.0, 0.06, 0.0);\n    }\n\n    // VRM 0.0 are facing Z- instead of Z+\n    lookAt.faceFront.set(0.0, 0.0, -1.0);\n\n    if (applier instanceof VRMLookAtBoneApplier) {\n      applier.faceFront.set(0.0, 0.0, -1.0);\n    }\n\n    return lookAt;\n  }\n\n  private _v0ImportDegreeMap(\n    schemaDegreeMap: V0VRM.FirstPersonDegreeMap | undefined,\n    defaultOutputScale: number,\n  ): VRMLookAtRangeMap {\n    const curve = schemaDegreeMap?.curve;\n    if (JSON.stringify(curve) !== '[0,0,0,1,1,1,1,0]') {\n      console.warn('Curves of LookAtDegreeMap defined in VRM 0.0 are not supported');\n    }\n\n    let xRange = schemaDegreeMap?.xRange ?? 90.0;\n    const yRange = schemaDegreeMap?.yRange ?? defaultOutputScale;\n\n    // It might cause NaN when `xRange` is too small\n    // which makes the mesh of the head disappear\n    // See: https://github.com/pixiv/three-vrm/issues/1201\n    if (xRange < INPUT_MAX_VALUE_MINIMUM) {\n      console.warn('VRMLookAtLoaderPlugin: xRange of a degree map is too small. Consider reviewing the degree map!');\n      xRange = INPUT_MAX_VALUE_MINIMUM;\n    }\n\n    return new VRMLookAtRangeMap(xRange, yRange);\n  }\n\n  private _importLookAt(humanoid: VRMHumanoid, applier: VRMLookAtApplier): VRMLookAt {\n    const lookAt = new VRMLookAt(humanoid, applier);\n\n    if (this.helperRoot) {\n      const helper = new VRMLookAtHelper(lookAt);\n      this.helperRoot.add(helper);\n      helper.renderOrder = this.helperRoot.renderOrder;\n    }\n\n    return lookAt;\n  }\n}\n", "/* eslint-disable @typescript-eslint/naming-convention */\n\n/**\n * Represents a type of applier.\n */\nexport const VRMLookAtTypeName = {\n  Bone: 'bone',\n  Expression: 'expression',\n};\n\nexport type VRMLookAtTypeName = typeof VRMLookAtTypeName[keyof typeof VRMLookAtTypeName];\n", "import type { GLTF, GLTFLoaderPlugin, GLTFParser } from 'three/examples/jsm/loaders/GLTFLoader.js';\nimport type { VRM0Meta } from './VRM0Meta';\nimport type { VRM1Meta } from './VRM1Meta';\nimport type { VRMMeta } from './VRMMeta';\nimport type { VRMMetaLoaderPluginOptions } from './VRMMetaLoaderPluginOptions';\nimport type * as V0VRM from '@pixiv/types-vrm-0.0';\nimport type * as V1VRMSchema from '@pixiv/types-vrmc-vrm-1.0';\nimport * as THREE from 'three';\nimport { resolveURL } from '../utils/resolveURL';\nimport { GLTF as GLTFSchema } from '@gltf-transform/core';\n\n/**\n * Possible spec versions it recognizes.\n */\nconst POSSIBLE_SPEC_VERSIONS = new Set(['1.0', '1.0-beta']);\n\n/**\n * A plugin of GLTFLoader that imports a {@link VRM1Meta} from a VRM extension of a GLTF.\n */\nexport class VRMMetaLoaderPlugin implements GLTFLoaderPlugin {\n  public readonly parser: GLTFParser;\n\n  /**\n   * If `false`, it won't load its thumbnail image ({@link VRM1Meta.thumbnailImage}).\n   * `false` by default.\n   */\n  public needThumbnailImage: boolean;\n\n  /**\n   * A list of license urls.\n   * This meta loader will accept these `licenseUrl`s.\n   * Otherwise it won't be loaded.\n   */\n  public acceptLicenseUrls: string[];\n\n  /**\n   * Whether it should accept VRM0.0 meta or not.\n   * Note that it might load {@link VRM0Meta} instead of {@link VRM1Meta} when this is `true`.\n   * `true` by default.\n   */\n  public acceptV0Meta: boolean;\n\n  public get name(): string {\n    // We should use the extension name instead but we have multiple plugins for an extension...\n    return 'VRMMetaLoaderPlugin';\n  }\n\n  public constructor(parser: GLTFParser, options?: VRMMetaLoaderPluginOptions) {\n    this.parser = parser;\n\n    this.needThumbnailImage = options?.needThumbnailImage ?? false;\n    this.acceptLicenseUrls = options?.acceptLicenseUrls ?? ['https://vrm.dev/licenses/1.0/'];\n    this.acceptV0Meta = options?.acceptV0Meta ?? true;\n  }\n\n  public async afterRoot(gltf: GLTF): Promise<void> {\n    gltf.userData.vrmMeta = await this._import(gltf);\n  }\n\n  private async _import(gltf: GLTF): Promise<VRMMeta | null> {\n    const v1Result = await this._v1Import(gltf);\n    if (v1Result != null) {\n      return v1Result;\n    }\n\n    const v0Result = await this._v0Import(gltf);\n    if (v0Result != null) {\n      return v0Result;\n    }\n\n    return null;\n  }\n\n  private async _v1Import(gltf: GLTF): Promise<VRM1Meta | null> {\n    const json = this.parser.json as GLTFSchema.IGLTF;\n\n    // early abort if it doesn't use vrm\n    const isVRMUsed = json.extensionsUsed?.indexOf('VRMC_vrm') !== -1;\n    if (!isVRMUsed) {\n      return null;\n    }\n\n    const extension = json.extensions?.['VRMC_vrm'] as V1VRMSchema.VRMCVRM | undefined;\n    if (extension == null) {\n      return null;\n    }\n\n    const specVersion = extension.specVersion;\n    if (!POSSIBLE_SPEC_VERSIONS.has(specVersion)) {\n      console.warn(`VRMMetaLoaderPlugin: Unknown VRMC_vrm specVersion \"${specVersion}\"`);\n      return null;\n    }\n\n    const schemaMeta = extension.meta;\n    if (!schemaMeta) {\n      return null;\n    }\n\n    // throw an error if acceptV0Meta is false\n    const licenseUrl = schemaMeta.licenseUrl;\n    const acceptLicenseUrlsSet = new Set(this.acceptLicenseUrls);\n    if (!acceptLicenseUrlsSet.has(licenseUrl)) {\n      throw new Error(`VRMMetaLoaderPlugin: The license url \"${licenseUrl}\" is not accepted`);\n    }\n\n    let thumbnailImage: HTMLImageElement | undefined = undefined;\n    if (this.needThumbnailImage && schemaMeta.thumbnailImage != null) {\n      thumbnailImage = (await this._extractGLTFImage(schemaMeta.thumbnailImage)) ?? undefined;\n    }\n\n    return {\n      metaVersion: '1',\n      name: schemaMeta.name,\n      version: schemaMeta.version,\n      authors: schemaMeta.authors,\n      copyrightInformation: schemaMeta.copyrightInformation,\n      contactInformation: schemaMeta.contactInformation,\n      references: schemaMeta.references,\n      thirdPartyLicenses: schemaMeta.thirdPartyLicenses,\n      thumbnailImage,\n      licenseUrl: schemaMeta.licenseUrl,\n      avatarPermission: schemaMeta.avatarPermission,\n      allowExcessivelyViolentUsage: schemaMeta.allowExcessivelyViolentUsage,\n      allowExcessivelySexualUsage: schemaMeta.allowExcessivelySexualUsage,\n      commercialUsage: schemaMeta.commercialUsage,\n      allowPoliticalOrReligiousUsage: schemaMeta.allowPoliticalOrReligiousUsage,\n      allowAntisocialOrHateUsage: schemaMeta.allowAntisocialOrHateUsage,\n      creditNotation: schemaMeta.creditNotation,\n      allowRedistribution: schemaMeta.allowRedistribution,\n      modification: schemaMeta.modification,\n      otherLicenseUrl: schemaMeta.otherLicenseUrl,\n    };\n  }\n\n  private async _v0Import(gltf: GLTF): Promise<VRM0Meta | null> {\n    const json = this.parser.json as GLTFSchema.IGLTF;\n\n    // early abort if it doesn't use vrm\n    const vrmExt = json.extensions?.VRM as V0VRM.VRM | undefined;\n    if (!vrmExt) {\n      return null;\n    }\n\n    const schemaMeta = vrmExt.meta;\n    if (!schemaMeta) {\n      return null;\n    }\n\n    // throw an error if acceptV0Meta is false\n    if (!this.acceptV0Meta) {\n      throw new Error('VRMMetaLoaderPlugin: Attempted to load VRM0.0 meta but acceptV0Meta is false');\n    }\n\n    // load thumbnail texture\n    let texture: THREE.Texture | null | undefined;\n    if (this.needThumbnailImage && schemaMeta.texture != null && schemaMeta.texture !== -1) {\n      texture = await this.parser.getDependency('texture', schemaMeta.texture);\n    }\n\n    return {\n      metaVersion: '0',\n      allowedUserName: schemaMeta.allowedUserName,\n      author: schemaMeta.author,\n      commercialUssageName: schemaMeta.commercialUssageName,\n      contactInformation: schemaMeta.contactInformation,\n      licenseName: schemaMeta.licenseName,\n      otherLicenseUrl: schemaMeta.otherLicenseUrl,\n      otherPermissionUrl: schemaMeta.otherPermissionUrl,\n      reference: schemaMeta.reference,\n      sexualUssageName: schemaMeta.sexualUssageName,\n      texture: texture ?? undefined,\n      title: schemaMeta.title,\n      version: schemaMeta.version,\n      violentUssageName: schemaMeta.violentUssageName,\n    };\n  }\n\n  private async _extractGLTFImage(index: number): Promise<HTMLImageElement | null> {\n    const json = this.parser.json as GLTFSchema.IGLTF;\n\n    const source = json.images?.[index];\n\n    if (source == null) {\n      console.warn(\n        `VRMMetaLoaderPlugin: Attempt to use images[${index}] of glTF as a thumbnail but the image doesn't exist`,\n      );\n      return null;\n    }\n\n    // Ref: https://github.com/mrdoob/three.js/blob/r124/examples/jsm/loaders/GLTFLoader.js#L2467\n\n    // `source.uri` might be a reference to a file\n    let sourceURI: string | undefined = source.uri;\n\n    // Load the binary as a blob\n    if (source.bufferView != null) {\n      const bufferView = await this.parser.getDependency('bufferView', source.bufferView);\n      const blob = new Blob([bufferView], { type: source.mimeType });\n      sourceURI = URL.createObjectURL(blob);\n    }\n\n    if (sourceURI == null) {\n      console.warn(\n        `VRMMetaLoaderPlugin: Attempt to use images[${index}] of glTF as a thumbnail but the image couldn't load properly`,\n      );\n      return null;\n    }\n\n    const loader = new THREE.ImageLoader();\n    return await loader.loadAsync(resolveURL(sourceURI, (this.parser as any).options.path)).catch((error) => {\n      console.error(error);\n      console.warn('VRMMetaLoaderPlugin: Failed to load a thumbnail image');\n      return null;\n    });\n  }\n}\n", "/**\n * Yoinked from https://github.com/mrdoob/three.js/blob/master/examples/jsm/loaders/GLTFLoader.js\n */\nexport function resolveURL(url: string, path: string): string {\n  // Invalid URL\n  if (typeof url !== 'string' || url === '') return '';\n\n  // Host Relative URL\n  if (/^https?:\\/\\//i.test(path) && /^\\//.test(url)) {\n    path = path.replace(/(^https?:\\/\\/[^/]+).*/i, '$1');\n  }\n\n  // Absolute URL http://,https://,//\n  if (/^(https?:)?\\/\\//i.test(url)) return url;\n\n  // Data URI\n  if (/^data:.*,.*$/i.test(url)) return url;\n\n  // Blob URL\n  if (/^blob:.*$/i.test(url)) return url;\n\n  // Relative URL\n  return path + url;\n}\n", "import * as THREE from 'three';\nimport { VRMExpressionManager } from './expressions/VRMExpressionManager';\nimport { VRMFirstPerson } from './firstPerson/VRMFirstPerson';\nimport { VRMHumanoid } from './humanoid/VRMHumanoid';\nimport { VRMLookAt } from './lookAt/VRMLookAt';\nimport { VRMMeta } from './meta/VRMMeta';\nimport { VRMCoreParameters } from './VRMCoreParameters';\n\n/**\n * A class that represents a single VRM model.\n * This class only includes core spec of the VRM (`VRMC_vrm`).\n */\nexport class VRMCore {\n  /**\n   * `THREE.Group` that contains the entire VRM.\n   */\n  public readonly scene: THREE.Group;\n\n  /**\n   * Contains meta fields of the VRM.\n   * You might want to refer these license fields before use your VRMs.\n   */\n  public readonly meta: VRMMeta;\n\n  /**\n   * Contains {@link VRMHumanoid} of the VRM.\n   * You can control each bones using {@link VRMHumanoid.getNormalizedBoneNode} or {@link VRMHumanoid.getRawBoneNode}.\n   *\n   * @TODO Add a link to VRM spec\n   */\n  public readonly humanoid: VRMHumanoid;\n\n  /**\n   * Contains {@link VRMExpressionManager} of the VRM.\n   * You might want to control these facial expressions via {@link VRMExpressionManager.setValue}.\n   */\n  public readonly expressionManager?: VRMExpressionManager;\n\n  /**\n   * Contains {@link VRMFirstPerson} of the VRM.\n   * VRMFirstPerson is mostly used for mesh culling for first person view.\n   */\n  public readonly firstPerson?: VRMFirstPerson;\n\n  /**\n   * Contains {@link VRMLookAt} of the VRM.\n   * You might want to use {@link VRMLookAt.target} to control the eye direction of your VRMs.\n   */\n  public readonly lookAt?: VRMLookAt;\n\n  /**\n   * Create a new VRM instance.\n   *\n   * @param params [[VRMParameters]] that represents components of the VRM\n   */\n  public constructor(params: VRMCoreParameters) {\n    this.scene = params.scene;\n    this.meta = params.meta;\n    this.humanoid = params.humanoid;\n    this.expressionManager = params.expressionManager;\n    this.firstPerson = params.firstPerson;\n    this.lookAt = params.lookAt;\n  }\n\n  /**\n   * **You need to call this on your update loop.**\n   *\n   * This function updates every VRM components.\n   *\n   * @param delta deltaTime\n   */\n  public update(delta: number): void {\n    this.humanoid.update();\n\n    if (this.lookAt) {\n      this.lookAt.update(delta);\n    }\n\n    if (this.expressionManager) {\n      this.expressionManager.update();\n    }\n  }\n}\n", "import { GLTF, GLTFLoaderPlugin, GLTFParser } from 'three/examples/jsm/loaders/GLTFLoader.js';\nimport { VRMCoreLoaderPluginOptions } from './VRMCoreLoaderPluginOptions';\nimport { VRMCore } from './VRMCore';\nimport { VRMExpressionLoaderPlugin } from './expressions/VRMExpressionLoaderPlugin';\nimport { VRMFirstPersonLoaderPlugin } from './firstPerson/VRMFirstPersonLoaderPlugin';\nimport { VRMHumanoidLoaderPlugin } from './humanoid/VRMHumanoidLoaderPlugin';\nimport { VRMMetaLoaderPlugin } from './meta/VRMMetaLoaderPlugin';\nimport { VRMLookAtLoaderPlugin } from './lookAt/VRMLookAtLoaderPlugin';\nimport type { VRMHumanoid } from './humanoid';\nimport type { VRMMeta } from './meta';\n\nexport class VRMCoreLoaderPlugin implements GLTFLoaderPlugin {\n  public get name(): string {\n    // We should use the extension name instead but we have multiple plugins for an extension...\n    return 'VRMC_vrm';\n  }\n\n  public readonly parser: GLTFParser;\n\n  public readonly expressionPlugin: VRMExpressionLoaderPlugin;\n  public readonly firstPersonPlugin: VRMFirstPersonLoaderPlugin;\n  public readonly humanoidPlugin: VRMHumanoidLoaderPlugin;\n  public readonly lookAtPlugin: VRMLookAtLoaderPlugin;\n  public readonly metaPlugin: VRMMetaLoaderPlugin;\n\n  public constructor(parser: GLTFParser, options?: VRMCoreLoaderPluginOptions) {\n    this.parser = parser;\n\n    const helperRoot = options?.helperRoot;\n    const autoUpdateHumanBones = options?.autoUpdateHumanBones;\n\n    this.expressionPlugin = options?.expressionPlugin ?? new VRMExpressionLoaderPlugin(parser);\n    this.firstPersonPlugin = options?.firstPersonPlugin ?? new VRMFirstPersonLoaderPlugin(parser);\n    this.humanoidPlugin =\n      options?.humanoidPlugin ?? new VRMHumanoidLoaderPlugin(parser, { helperRoot, autoUpdateHumanBones });\n    this.lookAtPlugin = options?.lookAtPlugin ?? new VRMLookAtLoaderPlugin(parser, { helperRoot });\n    this.metaPlugin = options?.metaPlugin ?? new VRMMetaLoaderPlugin(parser);\n  }\n\n  public async afterRoot(gltf: GLTF): Promise<void> {\n    await this.metaPlugin.afterRoot(gltf);\n    await this.humanoidPlugin.afterRoot(gltf);\n    await this.expressionPlugin.afterRoot(gltf);\n    await this.lookAtPlugin.afterRoot(gltf);\n    await this.firstPersonPlugin.afterRoot(gltf);\n\n    const meta = gltf.userData.vrmMeta as VRMMeta | null;\n    const humanoid = gltf.userData.vrmHumanoid as VRMHumanoid | null;\n\n    // meta and humanoid are required to be a VRM.\n    // Don't create VRM if they are null\n    if (meta && humanoid) {\n      const vrmCore = new VRMCore({\n        scene: gltf.scene,\n        expressionManager: gltf.userData.vrmExpressionManager,\n        firstPerson: gltf.userData.vrmFirstPerson,\n        humanoid,\n        lookAt: gltf.userData.vrmLookAt,\n        meta,\n      });\n\n      gltf.userData.vrmCore = vrmCore;\n    }\n  }\n}\n"],
  "mappings": "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",
  "names": ["THREE", "THREE", "THREE", "THREE", "_a", "_a", "_b", "THREE", "POSSIBLE_SPEC_VERSIONS", "_a", "THREE", "THREE", "_v3A", "_quatA", "THREE", "_v3A", "_quatA", "POSSIBLE_SPEC_VERSIONS", "THREE", "THREE", "THREE", "_quatA", "_v3A", "_v3B", "THREE", "THREE", "_v3A", "_v3B", "_quatA", "_quatB", "THREE", "VEC3_POSITIVE_Z", "_quatA", "_quatB", "_eulerA", "THREE", "POSSIBLE_SPEC_VERSIONS", "THREE", "POSSIBLE_SPEC_VERSIONS"]
}
