three-stdlib 2.22.9 → 2.22.10

package/dist/utils/SkeletonUtils.mjs

@@ -1,292 +1,211 @@
-import { Vector3, Quaternion, Matrix4, AnimationMixer, VectorKeyframeTrack, QuaternionKeyframeTrack, AnimationClip, SkeletonHelper, Vector2, Euler } from "three";
-var SkeletonUtils = {
-  retarget: function() {
-    var pos = new Vector3(), quat = new Quaternion(), scale = new Vector3(), bindBoneMatrix = new Matrix4(), relativeMatrix = new Matrix4(), globalMatrix = new Matrix4();
-    return function(target, source, options) {
-      options = options || {};
-      options.preserveMatrix = options.preserveMatrix !== void 0 ? options.preserveMatrix : true;
-      options.preservePosition = options.preservePosition !== void 0 ? options.preservePosition : true;
-      options.preserveHipPosition = options.preserveHipPosition !== void 0 ? options.preserveHipPosition : false;
-      options.useTargetMatrix = options.useTargetMatrix !== void 0 ? options.useTargetMatrix : false;
-      options.hip = options.hip !== void 0 ? options.hip : "hip";
-      options.names = options.names || {};
-      var sourceBones = source.isObject3D ? source.skeleton.bones : this.getBones(source), bones = target.isObject3D ? target.skeleton.bones : this.getBones(target), bindBones, bone, name, boneTo, bonesPosition, i;
-      if (target.isObject3D) {
-        target.skeleton.pose();
-      } else {
-        options.useTargetMatrix = true;
-        options.preserveMatrix = false;
-      }
-      if (options.preservePosition) {
-        bonesPosition = [];
-        for (i = 0; i < bones.length; i++) {
-          bonesPosition.push(bones[i].position.clone());
-        }
-      }
-      if (options.preserveMatrix) {
-        target.updateMatrixWorld();
-        target.matrixWorld.identity();
-        for (i = 0; i < target.children.length; ++i) {
-          target.children[i].updateMatrixWorld(true);
-        }
-      }
-      if (options.offsets) {
-        bindBones = [];
-        for (i = 0; i < bones.length; ++i) {
-          bone = bones[i];
-          name = options.names[bone.name] || bone.name;
-          if (options.offsets && options.offsets[name]) {
-            bone.matrix.multiply(options.offsets[name]);
-            bone.matrix.decompose(bone.position, bone.quaternion, bone.scale);
-            bone.updateMatrixWorld();
-          }
-          bindBones.push(bone.matrixWorld.clone());
-        }
-      }
-      for (i = 0; i < bones.length; ++i) {
-        bone = bones[i];
-        name = options.names[bone.name] || bone.name;
-        boneTo = this.getBoneByName(name, sourceBones);
-        globalMatrix.copy(bone.matrixWorld);
-        if (boneTo) {
-          boneTo.updateMatrixWorld();
-          if (options.useTargetMatrix) {
-            relativeMatrix.copy(boneTo.matrixWorld);
-          } else {
-            relativeMatrix.copy(target.matrixWorld).invert();
-            relativeMatrix.multiply(boneTo.matrixWorld);
-          }
-          scale.setFromMatrixScale(relativeMatrix);
-          relativeMatrix.scale(scale.set(1 / scale.x, 1 / scale.y, 1 / scale.z));
-          globalMatrix.makeRotationFromQuaternion(quat.setFromRotationMatrix(relativeMatrix));
-          if (target.isObject3D) {
-            var boneIndex = bones.indexOf(bone), wBindMatrix = bindBones ? bindBones[boneIndex] : bindBoneMatrix.copy(target.skeleton.boneInverses[boneIndex]).invert();
-            globalMatrix.multiply(wBindMatrix);
-          }
-          globalMatrix.copyPosition(relativeMatrix);
-        }
-        if (bone.parent && bone.parent.isBone) {
-          bone.matrix.copy(bone.parent.matrixWorld).invert();
-          bone.matrix.multiply(globalMatrix);
-        } else {
-          bone.matrix.copy(globalMatrix);
-        }
-        if (options.preserveHipPosition && name === options.hip) {
-          bone.matrix.setPosition(pos.set(0, bone.position.y, 0));
-        }
+import { Vector3, Quaternion, Matrix4, AnimationMixer, VectorKeyframeTrack, QuaternionKeyframeTrack, AnimationClip, SkeletonHelper } from "three";
+function retarget(target, source, options = {}) {
+  const pos = new Vector3(), quat = new Quaternion(), scale = new Vector3(), bindBoneMatrix = new Matrix4(), relativeMatrix = new Matrix4(), globalMatrix = new Matrix4();
+  options.preserveMatrix = options.preserveMatrix !== void 0 ? options.preserveMatrix : true;
+  options.preservePosition = options.preservePosition !== void 0 ? options.preservePosition : true;
+  options.preserveHipPosition = options.preserveHipPosition !== void 0 ? options.preserveHipPosition : false;
+  options.useTargetMatrix = options.useTargetMatrix !== void 0 ? options.useTargetMatrix : false;
+  options.hip = options.hip !== void 0 ? options.hip : "hip";
+  options.names = options.names || {};
+  const sourceBones = source.isObject3D ? source.skeleton.bones : getBones(source), bones = target.isObject3D ? target.skeleton.bones : getBones(target);
+  let bindBones, bone, name, boneTo, bonesPosition;
+  if (target.isObject3D) {
+    target.skeleton.pose();
+  } else {
+    options.useTargetMatrix = true;
+    options.preserveMatrix = false;
+  }
+  if (options.preservePosition) {
+    bonesPosition = [];
+    for (let i = 0; i < bones.length; i++) {
+      bonesPosition.push(bones[i].position.clone());
+    }
+  }
+  if (options.preserveMatrix) {
+    target.updateMatrixWorld();
+    target.matrixWorld.identity();
+    for (let i = 0; i < target.children.length; ++i) {
+      target.children[i].updateMatrixWorld(true);
+    }
+  }
+  if (options.offsets) {
+    bindBones = [];
+    for (let i = 0; i < bones.length; ++i) {
+      bone = bones[i];
+      name = options.names[bone.name] || bone.name;
+      if (options.offsets[name]) {
+        bone.matrix.multiply(options.offsets[name]);
         bone.matrix.decompose(bone.position, bone.quaternion, bone.scale);
         bone.updateMatrixWorld();
       }
-      if (options.preservePosition) {
-        for (i = 0; i < bones.length; ++i) {
-          bone = bones[i];
-          name = options.names[bone.name] || bone.name;
-          if (name !== options.hip) {
-            bone.position.copy(bonesPosition[i]);
-          }
-        }
+      bindBones.push(bone.matrixWorld.clone());
+    }
+  }
+  for (let i = 0; i < bones.length; ++i) {
+    bone = bones[i];
+    name = options.names[bone.name] || bone.name;
+    boneTo = getBoneByName(name, sourceBones);
+    globalMatrix.copy(bone.matrixWorld);
+    if (boneTo) {
+      boneTo.updateMatrixWorld();
+      if (options.useTargetMatrix) {
+        relativeMatrix.copy(boneTo.matrixWorld);
+      } else {
+        relativeMatrix.copy(target.matrixWorld).invert();
+        relativeMatrix.multiply(boneTo.matrixWorld);
       }
-      if (options.preserveMatrix) {
-        target.updateMatrixWorld(true);
+      scale.setFromMatrixScale(relativeMatrix);
+      relativeMatrix.scale(scale.set(1 / scale.x, 1 / scale.y, 1 / scale.z));
+      globalMatrix.makeRotationFromQuaternion(quat.setFromRotationMatrix(relativeMatrix));
+      if (target.isObject3D) {
+        const boneIndex = bones.indexOf(bone), wBindMatrix = bindBones ? bindBones[boneIndex] : bindBoneMatrix.copy(target.skeleton.boneInverses[boneIndex]).invert();
+        globalMatrix.multiply(wBindMatrix);
       }
-    };
-  }(),
-  retargetClip: function(target, source, clip, options) {
-    options = options || {};
-    options.useFirstFramePosition = options.useFirstFramePosition !== void 0 ? options.useFirstFramePosition : false;
-    options.fps = options.fps !== void 0 ? options.fps : 30;
-    options.names = options.names || [];
-    if (!source.isObject3D) {
-      source = this.getHelperFromSkeleton(source);
+      globalMatrix.copyPosition(relativeMatrix);
     }
-    var numFrames = Math.round(clip.duration * (options.fps / 1e3) * 1e3), delta = 1 / options.fps, convertedTracks = [], mixer = new AnimationMixer(source), bones = this.getBones(target.skeleton), boneDatas = [], positionOffset, bone, boneTo, boneData, name, i, j;
-    mixer.clipAction(clip).play();
-    mixer.update(0);
-    source.updateMatrixWorld();
-    for (i = 0; i < numFrames; ++i) {
-      var time = i * delta;
-      this.retarget(target, source, options);
-      for (j = 0; j < bones.length; ++j) {
-        name = options.names[bones[j].name] || bones[j].name;
-        boneTo = this.getBoneByName(name, source.skeleton);
-        if (boneTo) {
-          bone = bones[j];
-          boneData = boneDatas[j] = boneDatas[j] || { bone };
-          if (options.hip === name) {
-            if (!boneData.pos) {
-              boneData.pos = {
-                times: new Float32Array(numFrames),
-                values: new Float32Array(numFrames * 3)
-              };
-            }
-            if (options.useFirstFramePosition) {
-              if (i === 0) {
-                positionOffset = bone.position.clone();
-              }
-              bone.position.sub(positionOffset);
-            }
-            boneData.pos.times[i] = time;
-            bone.position.toArray(boneData.pos.values, i * 3);
-          }
-          if (!boneData.quat) {
-            boneData.quat = {
+    if (bone.parent && bone.parent.isBone) {
+      bone.matrix.copy(bone.parent.matrixWorld).invert();
+      bone.matrix.multiply(globalMatrix);
+    } else {
+      bone.matrix.copy(globalMatrix);
+    }
+    if (options.preserveHipPosition && name === options.hip) {
+      bone.matrix.setPosition(pos.set(0, bone.position.y, 0));
+    }
+    bone.matrix.decompose(bone.position, bone.quaternion, bone.scale);
+    bone.updateMatrixWorld();
+  }
+  if (options.preservePosition) {
+    for (let i = 0; i < bones.length; ++i) {
+      bone = bones[i];
+      name = options.names[bone.name] || bone.name;
+      if (name !== options.hip) {
+        bone.position.copy(bonesPosition[i]);
+      }
+    }
+  }
+  if (options.preserveMatrix) {
+    target.updateMatrixWorld(true);
+  }
+}
+function retargetClip(target, source, clip, options = {}) {
+  options.useFirstFramePosition = options.useFirstFramePosition !== void 0 ? options.useFirstFramePosition : false;
+  options.fps = options.fps !== void 0 ? options.fps : 30;
+  options.names = options.names || [];
+  if (!source.isObject3D) {
+    source = getHelperFromSkeleton(source);
+  }
+  const numFrames = Math.round(clip.duration * (options.fps / 1e3) * 1e3), delta = 1 / options.fps, convertedTracks = [], mixer = new AnimationMixer(source), bones = getBones(target.skeleton), boneDatas = [];
+  let positionOffset, bone, boneTo, boneData, name;
+  mixer.clipAction(clip).play();
+  mixer.update(0);
+  source.updateMatrixWorld();
+  for (let i = 0; i < numFrames; ++i) {
+    const time = i * delta;
+    retarget(target, source, options);
+    for (let j = 0; j < bones.length; ++j) {
+      name = options.names[bones[j].name] || bones[j].name;
+      boneTo = getBoneByName(name, source.skeleton);
+      if (boneTo) {
+        bone = bones[j];
+        boneData = boneDatas[j] = boneDatas[j] || { bone };
+        if (options.hip === name) {
+          if (!boneData.pos) {
+            boneData.pos = {
               times: new Float32Array(numFrames),
-              values: new Float32Array(numFrames * 4)
+              values: new Float32Array(numFrames * 3)
             };
           }
-          boneData.quat.times[i] = time;
-          bone.quaternion.toArray(boneData.quat.values, i * 4);
+          if (options.useFirstFramePosition) {
+            if (i === 0) {
+              positionOffset = bone.position.clone();
+            }
+            bone.position.sub(positionOffset);
+          }
+          boneData.pos.times[i] = time;
+          bone.position.toArray(boneData.pos.values, i * 3);
+        }
+        if (!boneData.quat) {
+          boneData.quat = {
+            times: new Float32Array(numFrames),
+            values: new Float32Array(numFrames * 4)
+          };
         }
+        boneData.quat.times[i] = time;
+        bone.quaternion.toArray(boneData.quat.values, i * 4);
       }
-      mixer.update(delta);
-      source.updateMatrixWorld();
     }
-    for (i = 0; i < boneDatas.length; ++i) {
-      boneData = boneDatas[i];
-      if (boneData) {
-        if (boneData.pos) {
-          convertedTracks.push(
-            new VectorKeyframeTrack(
-              ".bones[" + boneData.bone.name + "].position",
-              boneData.pos.times,
-              boneData.pos.values
-            )
-          );
-        }
+    mixer.update(delta);
+    source.updateMatrixWorld();
+  }
+  for (let i = 0; i < boneDatas.length; ++i) {
+    boneData = boneDatas[i];
+    if (boneData) {
+      if (boneData.pos) {
         convertedTracks.push(
-          new QuaternionKeyframeTrack(
-            ".bones[" + boneData.bone.name + "].quaternion",
-            boneData.quat.times,
-            boneData.quat.values
+          new VectorKeyframeTrack(
+            ".bones[" + boneData.bone.name + "].position",
+            boneData.pos.times,
+            boneData.pos.values
           )
         );
       }
+      convertedTracks.push(
+        new QuaternionKeyframeTrack(
+          ".bones[" + boneData.bone.name + "].quaternion",
+          boneData.quat.times,
+          boneData.quat.values
+        )
+      );
     }
-    mixer.uncacheAction(clip);
-    return new AnimationClip(clip.name, -1, convertedTracks);
-  },
-  getHelperFromSkeleton: function(skeleton) {
-    var source = new SkeletonHelper(skeleton.bones[0]);
-    source.skeleton = skeleton;
-    return source;
-  },
-  getSkeletonOffsets: function() {
-    var targetParentPos = new Vector3(), targetPos = new Vector3(), sourceParentPos = new Vector3(), sourcePos = new Vector3(), targetDir = new Vector2(), sourceDir = new Vector2();
-    return function(target, source, options) {
-      options = options || {};
-      options.hip = options.hip !== void 0 ? options.hip : "hip";
-      options.names = options.names || {};
-      if (!source.isObject3D) {
-        source = this.getHelperFromSkeleton(source);
-      }
-      var nameKeys = Object.keys(options.names), nameValues = Object.values(options.names), sourceBones = source.isObject3D ? source.skeleton.bones : this.getBones(source), bones = target.isObject3D ? target.skeleton.bones : this.getBones(target), offsets = [], bone, boneTo, name, i;
-      target.skeleton.pose();
-      for (i = 0; i < bones.length; ++i) {
-        bone = bones[i];
-        name = options.names[bone.name] || bone.name;
-        boneTo = this.getBoneByName(name, sourceBones);
-        if (boneTo && name !== options.hip) {
-          var boneParent = this.getNearestBone(bone.parent, nameKeys), boneToParent = this.getNearestBone(boneTo.parent, nameValues);
-          boneParent.updateMatrixWorld();
-          boneToParent.updateMatrixWorld();
-          targetParentPos.setFromMatrixPosition(boneParent.matrixWorld);
-          targetPos.setFromMatrixPosition(bone.matrixWorld);
-          sourceParentPos.setFromMatrixPosition(boneToParent.matrixWorld);
-          sourcePos.setFromMatrixPosition(boneTo.matrixWorld);
-          targetDir.subVectors(new Vector2(targetPos.x, targetPos.y), new Vector2(targetParentPos.x, targetParentPos.y)).normalize();
-          sourceDir.subVectors(new Vector2(sourcePos.x, sourcePos.y), new Vector2(sourceParentPos.x, sourceParentPos.y)).normalize();
-          var laterialAngle = targetDir.angle() - sourceDir.angle();
-          var offset = new Matrix4().makeRotationFromEuler(new Euler(0, 0, laterialAngle));
-          bone.matrix.multiply(offset);
-          bone.matrix.decompose(bone.position, bone.quaternion, bone.scale);
-          bone.updateMatrixWorld();
-          offsets[name] = offset;
-        }
-      }
-      return offsets;
-    };
-  }(),
-  renameBones: function(skeleton, names) {
-    var bones = this.getBones(skeleton);
-    for (let i = 0; i < bones.length; ++i) {
-      var bone = bones[i];
-      if (names[bone.name]) {
-        bone.name = names[bone.name];
-      }
-    }
-    return this;
-  },
-  getBones: function(skeleton) {
-    return Array.isArray(skeleton) ? skeleton : skeleton.bones;
-  },
-  getBoneByName: function(name, skeleton) {
-    for (let i = 0, bones = this.getBones(skeleton); i < bones.length; i++) {
-      if (name === bones[i].name)
-        return bones[i];
-    }
-  },
-  getNearestBone: function(bone, names) {
-    while (bone.isBone) {
-      if (names.indexOf(bone.name) !== -1) {
-        return bone;
-      }
-      bone = bone.parent;
-    }
-  },
-  findBoneTrackData: function(name, tracks) {
-    var regexp = /\[(.*)\]\.(.*)/, result = { name };
-    for (let i = 0; i < tracks.length; ++i) {
-      var trackData = regexp.exec(tracks[i].name);
-      if (trackData && name === trackData[1]) {
-        result[trackData[2]] = i;
-      }
-    }
-    return result;
-  },
-  getEqualsBonesNames: function(skeleton, targetSkeleton) {
-    var sourceBones = this.getBones(skeleton), targetBones = this.getBones(targetSkeleton), bones = [];
-    search:
-      for (let i = 0; i < sourceBones.length; i++) {
-        var boneName = sourceBones[i].name;
-        for (let j = 0; j < targetBones.length; j++) {
-          if (boneName === targetBones[j].name) {
-            bones.push(boneName);
-            continue search;
-          }
-        }
-      }
-    return bones;
-  },
-  clone: function(source) {
-    var sourceLookup = /* @__PURE__ */ new Map();
-    var cloneLookup = /* @__PURE__ */ new Map();
-    var clone = source.clone();
-    parallelTraverse(source, clone, function(sourceNode, clonedNode) {
-      sourceLookup.set(clonedNode, sourceNode);
-      cloneLookup.set(sourceNode, clonedNode);
-    });
-    clone.traverse(function(node) {
-      if (!node.isSkinnedMesh)
-        return;
-      var clonedMesh = node;
-      var sourceMesh = sourceLookup.get(node);
-      var sourceBones = sourceMesh.skeleton.bones;
-      clonedMesh.skeleton = sourceMesh.skeleton.clone();
-      clonedMesh.bindMatrix.copy(sourceMesh.bindMatrix);
-      clonedMesh.skeleton.bones = sourceBones.map(function(bone) {
-        return cloneLookup.get(bone);
-      });
-      clonedMesh.bind(clonedMesh.skeleton, clonedMesh.bindMatrix);
+  }
+  mixer.uncacheAction(clip);
+  return new AnimationClip(clip.name, -1, convertedTracks);
+}
+function clone(source) {
+  const sourceLookup = /* @__PURE__ */ new Map();
+  const cloneLookup = /* @__PURE__ */ new Map();
+  const clone2 = source.clone();
+  parallelTraverse(source, clone2, function(sourceNode, clonedNode) {
+    sourceLookup.set(clonedNode, sourceNode);
+    cloneLookup.set(sourceNode, clonedNode);
+  });
+  clone2.traverse(function(node) {
+    if (!node.isSkinnedMesh)
+      return;
+    const clonedMesh = node;
+    const sourceMesh = sourceLookup.get(node);
+    const sourceBones = sourceMesh.skeleton.bones;
+    clonedMesh.skeleton = sourceMesh.skeleton.clone();
+    clonedMesh.bindMatrix.copy(sourceMesh.bindMatrix);
+    clonedMesh.skeleton.bones = sourceBones.map(function(bone) {
+      return cloneLookup.get(bone);
     });
-    return clone;
+    clonedMesh.bind(clonedMesh.skeleton, clonedMesh.bindMatrix);
+  });
+  return clone2;
+}
+function getBoneByName(name, skeleton) {
+  for (let i = 0, bones = getBones(skeleton); i < bones.length; i++) {
+    if (name === bones[i].name)
+      return bones[i];
   }
-};
+}
+function getBones(skeleton) {
+  return Array.isArray(skeleton) ? skeleton : skeleton.bones;
+}
+function getHelperFromSkeleton(skeleton) {
+  const source = new SkeletonHelper(skeleton.bones[0]);
+  source.skeleton = skeleton;
+  return source;
+}
 function parallelTraverse(a, b, callback) {
   callback(a, b);
   for (let i = 0; i < a.children.length; i++) {
     parallelTraverse(a.children[i], b.children[i], callback);
   }
 }
+const SkeletonUtils = { retarget, retargetClip, clone };
 export {
   SkeletonUtils
 };

package/dist/utils/UVsDebug.js

@@ -1,60 +1,55 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const THREE = require("three");
-var UVsDebug = function(geometry, size) {
-  var abc = "abc";
-  var a = new THREE.Vector2();
-  var b = new THREE.Vector2();
-  var uvs = [new THREE.Vector2(), new THREE.Vector2(), new THREE.Vector2()];
-  var face = [];
-  var canvas = document.createElement("canvas");
-  var width = size || 1024;
-  var height = size || 1024;
+function UVsDebug(geometry, size = 1024) {
+  const abc = "abc";
+  const a = new THREE.Vector2();
+  const b = new THREE.Vector2();
+  const uvs = [new THREE.Vector2(), new THREE.Vector2(), new THREE.Vector2()];
+  const face = [];
+  const canvas = document.createElement("canvas");
+  const width = size;
+  const height = size;
   canvas.width = width;
   canvas.height = height;
-  var ctx = canvas.getContext("2d");
+  const ctx = canvas.getContext("2d");
   ctx.lineWidth = 1;
   ctx.strokeStyle = "rgb( 63, 63, 63 )";
   ctx.textAlign = "center";
   ctx.fillStyle = "rgb( 255, 255, 255 )";
   ctx.fillRect(0, 0, width, height);
-  if (geometry.isGeometry) {
-    console.error("THREE.UVsDebug no longer supports Geometry. Use THREE.BufferGeometry instead.");
-    return;
+  const index = geometry.index;
+  const uvAttribute = geometry.attributes.uv;
+  if (index) {
+    for (let i = 0, il = index.count; i < il; i += 3) {
+      face[0] = index.getX(i);
+      face[1] = index.getX(i + 1);
+      face[2] = index.getX(i + 2);
+      uvs[0].fromBufferAttribute(uvAttribute, face[0]);
+      uvs[1].fromBufferAttribute(uvAttribute, face[1]);
+      uvs[2].fromBufferAttribute(uvAttribute, face[2]);
+      processFace(face, uvs, i / 3);
+    }
   } else {
-    var index = geometry.index;
-    var uvAttribute = geometry.attributes.uv;
-    if (index) {
-      for (let i = 0, il = index.count; i < il; i += 3) {
-        face[0] = index.getX(i);
-        face[1] = index.getX(i + 1);
-        face[2] = index.getX(i + 2);
-        uvs[0].fromBufferAttribute(uvAttribute, face[0]);
-        uvs[1].fromBufferAttribute(uvAttribute, face[1]);
-        uvs[2].fromBufferAttribute(uvAttribute, face[2]);
-        processFace(face, uvs, i / 3);
-      }
-    } else {
-      for (let i = 0, il = uvAttribute.count; i < il; i += 3) {
-        face[0] = i;
-        face[1] = i + 1;
-        face[2] = i + 2;
-        uvs[0].fromBufferAttribute(uvAttribute, face[0]);
-        uvs[1].fromBufferAttribute(uvAttribute, face[1]);
-        uvs[2].fromBufferAttribute(uvAttribute, face[2]);
-        processFace(face, uvs, i / 3);
-      }
+    for (let i = 0, il = uvAttribute.count; i < il; i += 3) {
+      face[0] = i;
+      face[1] = i + 1;
+      face[2] = i + 2;
+      uvs[0].fromBufferAttribute(uvAttribute, face[0]);
+      uvs[1].fromBufferAttribute(uvAttribute, face[1]);
+      uvs[2].fromBufferAttribute(uvAttribute, face[2]);
+      processFace(face, uvs, i / 3);
     }
   }
   return canvas;
   function processFace(face2, uvs2, index2) {
     ctx.beginPath();
     a.set(0, 0);
-    for (let j2 = 0, jl2 = uvs2.length; j2 < jl2; j2++) {
-      var uv = uvs2[j2];
+    for (let j = 0, jl = uvs2.length; j < jl; j++) {
+      const uv = uvs2[j];
       a.x += uv.x;
       a.y += uv.y;
-      if (j2 === 0) {
+      if (j === 0) {
         ctx.moveTo(uv.x * (width - 2) + 0.5, (1 - uv.y) * (height - 2) + 0.5);
       } else {
         ctx.lineTo(uv.x * (width - 2) + 0.5, (1 - uv.y) * (height - 2) + 0.5);
@@ -71,15 +66,15 @@ var UVsDebug = function(geometry, size) {
     }
     ctx.font = "12px Arial";
     ctx.fillStyle = "rgb( 191, 191, 191 )";
-    for (j = 0, jl = uvs2.length; j < jl; j++) {
-      var uv = uvs2[j];
+    for (let j = 0, jl = uvs2.length; j < jl; j++) {
+      const uv = uvs2[j];
       b.addVectors(a, uv).divideScalar(2);
-      var vnum = face2[j];
+      const vnum = face2[j];
       ctx.fillText(abc[j] + vnum, b.x * width, (1 - b.y) * height);
       if (b.x > 0.95) {
         ctx.fillText(abc[j] + vnum, b.x % 1 * width, (1 - b.y) * height);
       }
     }
   }
-};
+}
 exports.UVsDebug = UVsDebug;