Initial project import

node_modules/three-stdlib/deprecated/Geometry.cjs

@@ -0,0 +1,979 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+const _m1 = /* @__PURE__ */ new THREE.Matrix4();
+const _obj = /* @__PURE__ */ new THREE.Object3D();
+const _offset = /* @__PURE__ */ new THREE.Vector3();
+const Geometry = /* @__PURE__ */ (() => {
+  class Geometry2 extends THREE.EventDispatcher {
+    static createBufferGeometryFromObject(object) {
+      let buffergeometry = new THREE.BufferGeometry();
+      const geometry = object.geometry;
+      if (object.isPoints || object.isLine) {
+        const positions = new THREE.Float32BufferAttribute(geometry.vertices.length * 3, 3);
+        const colors = new THREE.Float32BufferAttribute(geometry.colors.length * 3, 3);
+        buffergeometry.setAttribute("position", positions.copyVector3sArray(geometry.vertices));
+        buffergeometry.setAttribute("color", colors.copyColorsArray(geometry.colors));
+        if (geometry.lineDistances && geometry.lineDistances.length === geometry.vertices.length) {
+          const lineDistances = new THREE.Float32BufferAttribute(geometry.lineDistances.length, 1);
+          buffergeometry.setAttribute("lineDistance", lineDistances.copyArray(geometry.lineDistances));
+        }
+        if (geometry.boundingSphere !== null) {
+          buffergeometry.boundingSphere = geometry.boundingSphere.clone();
+        }
+        if (geometry.boundingBox !== null) {
+          buffergeometry.boundingBox = geometry.boundingBox.clone();
+        }
+      } else if (object.isMesh) {
+        buffergeometry = geometry.toBufferGeometry();
+      }
+      return buffergeometry;
+    }
+    constructor() {
+      super();
+      this.isGeometry = true;
+      this.uuid = THREE.MathUtils.generateUUID();
+      this.name = "";
+      this.type = "Geometry";
+      this.vertices = [];
+      this.colors = [];
+      this.faces = [];
+      this.faceVertexUvs = [[]];
+      this.morphTargets = [];
+      this.morphNormals = [];
+      this.skinWeights = [];
+      this.skinIndices = [];
+      this.lineDistances = [];
+      this.boundingBox = null;
+      this.boundingSphere = null;
+      this.elementsNeedUpdate = false;
+      this.verticesNeedUpdate = false;
+      this.uvsNeedUpdate = false;
+      this.normalsNeedUpdate = false;
+      this.colorsNeedUpdate = false;
+      this.lineDistancesNeedUpdate = false;
+      this.groupsNeedUpdate = false;
+    }
+    applyMatrix4(matrix) {
+      const normalMatrix = new THREE.Matrix3().getNormalMatrix(matrix);
+      for (let i = 0, il = this.vertices.length; i < il; i++) {
+        const vertex = this.vertices[i];
+        vertex.applyMatrix4(matrix);
+      }
+      for (let i = 0, il = this.faces.length; i < il; i++) {
+        const face = this.faces[i];
+        face.normal.applyMatrix3(normalMatrix).normalize();
+        for (let j = 0, jl = face.vertexNormals.length; j < jl; j++) {
+          face.vertexNormals[j].applyMatrix3(normalMatrix).normalize();
+        }
+      }
+      if (this.boundingBox !== null) {
+        this.computeBoundingBox();
+      }
+      if (this.boundingSphere !== null) {
+        this.computeBoundingSphere();
+      }
+      this.verticesNeedUpdate = true;
+      this.normalsNeedUpdate = true;
+      return this;
+    }
+    rotateX(angle) {
+      _m1.makeRotationX(angle);
+      this.applyMatrix4(_m1);
+      return this;
+    }
+    rotateY(angle) {
+      _m1.makeRotationY(angle);
+      this.applyMatrix4(_m1);
+      return this;
+    }
+    rotateZ(angle) {
+      _m1.makeRotationZ(angle);
+      this.applyMatrix4(_m1);
+      return this;
+    }
+    translate(x, y, z) {
+      _m1.makeTranslation(x, y, z);
+      this.applyMatrix4(_m1);
+      return this;
+    }
+    scale(x, y, z) {
+      _m1.makeScale(x, y, z);
+      this.applyMatrix4(_m1);
+      return this;
+    }
+    lookAt(vector) {
+      _obj.lookAt(vector);
+      _obj.updateMatrix();
+      this.applyMatrix4(_obj.matrix);
+      return this;
+    }
+    fromBufferGeometry(geometry) {
+      const scope = this;
+      const index = geometry.index !== null ? geometry.index : void 0;
+      const attributes = geometry.attributes;
+      if (attributes.position === void 0) {
+        console.error("THREE.Geometry.fromBufferGeometry(): Position attribute required for conversion.");
+        return this;
+      }
+      const position = attributes.position;
+      const normal = attributes.normal;
+      const color = attributes.color;
+      const uv = attributes.uv;
+      const uv2 = attributes.uv2;
+      if (uv2 !== void 0)
+        this.faceVertexUvs[1] = [];
+      for (let i = 0; i < position.count; i++) {
+        scope.vertices.push(new THREE.Vector3().fromBufferAttribute(position, i));
+        if (color !== void 0) {
+          scope.colors.push(new THREE.Color().fromBufferAttribute(color, i));
+        }
+      }
+      function addFace(a, b, c, materialIndex) {
+        const vertexColors = color === void 0 ? [] : [scope.colors[a].clone(), scope.colors[b].clone(), scope.colors[c].clone()];
+        const vertexNormals = normal === void 0 ? [] : [
+          new THREE.Vector3().fromBufferAttribute(normal, a),
+          new THREE.Vector3().fromBufferAttribute(normal, b),
+          new THREE.Vector3().fromBufferAttribute(normal, c)
+        ];
+        const face = new Face3(a, b, c, vertexNormals, vertexColors, materialIndex);
+        scope.faces.push(face);
+        if (uv !== void 0) {
+          scope.faceVertexUvs[0].push([
+            new THREE.Vector2().fromBufferAttribute(uv, a),
+            new THREE.Vector2().fromBufferAttribute(uv, b),
+            new THREE.Vector2().fromBufferAttribute(uv, c)
+          ]);
+        }
+        if (uv2 !== void 0) {
+          scope.faceVertexUvs[1].push([
+            new THREE.Vector2().fromBufferAttribute(uv2, a),
+            new THREE.Vector2().fromBufferAttribute(uv2, b),
+            new THREE.Vector2().fromBufferAttribute(uv2, c)
+          ]);
+        }
+      }
+      const groups = geometry.groups;
+      if (groups.length > 0) {
+        for (let i = 0; i < groups.length; i++) {
+          const group = groups[i];
+          const start = group.start;
+          const count = group.count;
+          for (let j = start, jl = start + count; j < jl; j += 3) {
+            if (index !== void 0) {
+              addFace(index.getX(j), index.getX(j + 1), index.getX(j + 2), group.materialIndex);
+            } else {
+              addFace(j, j + 1, j + 2, group.materialIndex);
+            }
+          }
+        }
+      } else {
+        if (index !== void 0) {
+          for (let i = 0; i < index.count; i += 3) {
+            addFace(index.getX(i), index.getX(i + 1), index.getX(i + 2));
+          }
+        } else {
+          for (let i = 0; i < position.count; i += 3) {
+            addFace(i, i + 1, i + 2);
+          }
+        }
+      }
+      this.computeFaceNormals();
+      if (geometry.boundingBox !== null) {
+        this.boundingBox = geometry.boundingBox.clone();
+      }
+      if (geometry.boundingSphere !== null) {
+        this.boundingSphere = geometry.boundingSphere.clone();
+      }
+      return this;
+    }
+    center() {
+      this.computeBoundingBox();
+      this.boundingBox.getCenter(_offset).negate();
+      this.translate(_offset.x, _offset.y, _offset.z);
+      return this;
+    }
+    normalize() {
+      this.computeBoundingSphere();
+      const center = this.boundingSphere.center;
+      const radius = this.boundingSphere.radius;
+      const s = radius === 0 ? 1 : 1 / radius;
+      const matrix = new THREE.Matrix4();
+      matrix.set(s, 0, 0, -s * center.x, 0, s, 0, -s * center.y, 0, 0, s, -s * center.z, 0, 0, 0, 1);
+      this.applyMatrix4(matrix);
+      return this;
+    }
+    computeFaceNormals() {
+      const cb = new THREE.Vector3(), ab = new THREE.Vector3();
+      for (let f = 0, fl = this.faces.length; f < fl; f++) {
+        const face = this.faces[f];
+        const vA = this.vertices[face.a];
+        const vB = this.vertices[face.b];
+        const vC = this.vertices[face.c];
+        cb.subVectors(vC, vB);
+        ab.subVectors(vA, vB);
+        cb.cross(ab);
+        cb.normalize();
+        face.normal.copy(cb);
+      }
+    }
+    computeVertexNormals(areaWeighted = true) {
+      const vertices = new Array(this.vertices.length);
+      for (let v = 0, vl = this.vertices.length; v < vl; v++) {
+        vertices[v] = new THREE.Vector3();
+      }
+      if (areaWeighted) {
+        const cb = new THREE.Vector3(), ab = new THREE.Vector3();
+        for (let f = 0, fl = this.faces.length; f < fl; f++) {
+          const face = this.faces[f];
+          const vA = this.vertices[face.a];
+          const vB = this.vertices[face.b];
+          const vC = this.vertices[face.c];
+          cb.subVectors(vC, vB);
+          ab.subVectors(vA, vB);
+          cb.cross(ab);
+          vertices[face.a].add(cb);
+          vertices[face.b].add(cb);
+          vertices[face.c].add(cb);
+        }
+      } else {
+        this.computeFaceNormals();
+        for (let f = 0, fl = this.faces.length; f < fl; f++) {
+          const face = this.faces[f];
+          vertices[face.a].add(face.normal);
+          vertices[face.b].add(face.normal);
+          vertices[face.c].add(face.normal);
+        }
+      }
+      for (let v = 0, vl = this.vertices.length; v < vl; v++) {
+        vertices[v].normalize();
+      }
+      for (let f = 0, fl = this.faces.length; f < fl; f++) {
+        const face = this.faces[f];
+        const vertexNormals = face.vertexNormals;
+        if (vertexNormals.length === 3) {
+          vertexNormals[0].copy(vertices[face.a]);
+          vertexNormals[1].copy(vertices[face.b]);
+          vertexNormals[2].copy(vertices[face.c]);
+        } else {
+          vertexNormals[0] = vertices[face.a].clone();
+          vertexNormals[1] = vertices[face.b].clone();
+          vertexNormals[2] = vertices[face.c].clone();
+        }
+      }
+      if (this.faces.length > 0) {
+        this.normalsNeedUpdate = true;
+      }
+    }
+    computeFlatVertexNormals() {
+      this.computeFaceNormals();
+      for (let f = 0, fl = this.faces.length; f < fl; f++) {
+        const face = this.faces[f];
+        const vertexNormals = face.vertexNormals;
+        if (vertexNormals.length === 3) {
+          vertexNormals[0].copy(face.normal);
+          vertexNormals[1].copy(face.normal);
+          vertexNormals[2].copy(face.normal);
+        } else {
+          vertexNormals[0] = face.normal.clone();
+          vertexNormals[1] = face.normal.clone();
+          vertexNormals[2] = face.normal.clone();
+        }
+      }
+      if (this.faces.length > 0) {
+        this.normalsNeedUpdate = true;
+      }
+    }
+    computeMorphNormals() {
+      for (let f = 0, fl = this.faces.length; f < fl; f++) {
+        const face = this.faces[f];
+        if (!face.__originalFaceNormal) {
+          face.__originalFaceNormal = face.normal.clone();
+        } else {
+          face.__originalFaceNormal.copy(face.normal);
+        }
+        if (!face.__originalVertexNormals)
+          face.__originalVertexNormals = [];
+        for (let i = 0, il = face.vertexNormals.length; i < il; i++) {
+          if (!face.__originalVertexNormals[i]) {
+            face.__originalVertexNormals[i] = face.vertexNormals[i].clone();
+          } else {
+            face.__originalVertexNormals[i].copy(face.vertexNormals[i]);
+          }
+        }
+      }
+      const tmpGeo = new Geometry2();
+      tmpGeo.faces = this.faces;
+      for (let i = 0, il = this.morphTargets.length; i < il; i++) {
+        if (!this.morphNormals[i]) {
+          this.morphNormals[i] = {};
+          this.morphNormals[i].faceNormals = [];
+          this.morphNormals[i].vertexNormals = [];
+          const dstNormalsFace = this.morphNormals[i].faceNormals;
+          const dstNormalsVertex = this.morphNormals[i].vertexNormals;
+          for (let f = 0, fl = this.faces.length; f < fl; f++) {
+            const faceNormal = new THREE.Vector3();
+            const vertexNormals = {
+              a: new THREE.Vector3(),
+              b: new THREE.Vector3(),
+              c: new THREE.Vector3()
+            };
+            dstNormalsFace.push(faceNormal);
+            dstNormalsVertex.push(vertexNormals);
+          }
+        }
+        const morphNormals = this.morphNormals[i];
+        tmpGeo.vertices = this.morphTargets[i].vertices;
+        tmpGeo.computeFaceNormals();
+        tmpGeo.computeVertexNormals();
+        for (let f = 0, fl = this.faces.length; f < fl; f++) {
+          const face = this.faces[f];
+          const faceNormal = morphNormals.faceNormals[f];
+          const vertexNormals = morphNormals.vertexNormals[f];
+          faceNormal.copy(face.normal);
+          vertexNormals.a.copy(face.vertexNormals[0]);
+          vertexNormals.b.copy(face.vertexNormals[1]);
+          vertexNormals.c.copy(face.vertexNormals[2]);
+        }
+      }
+      for (let f = 0, fl = this.faces.length; f < fl; f++) {
+        const face = this.faces[f];
+        face.normal = face.__originalFaceNormal;
+        face.vertexNormals = face.__originalVertexNormals;
+      }
+    }
+    computeBoundingBox() {
+      if (this.boundingBox === null) {
+        this.boundingBox = new THREE.Box3();
+      }
+      this.boundingBox.setFromPoints(this.vertices);
+    }
+    computeBoundingSphere() {
+      if (this.boundingSphere === null) {
+        this.boundingSphere = new THREE.Sphere();
+      }
+      this.boundingSphere.setFromPoints(this.vertices);
+    }
+    merge(geometry, matrix, materialIndexOffset = 0) {
+      if (!(geometry && geometry.isGeometry)) {
+        console.error("THREE.Geometry.merge(): geometry not an instance of THREE.Geometry.", geometry);
+        return;
+      }
+      let normalMatrix;
+      const vertexOffset = this.vertices.length, vertices1 = this.vertices, vertices2 = geometry.vertices, faces1 = this.faces, faces2 = geometry.faces, colors1 = this.colors, colors2 = geometry.colors;
+      if (matrix !== void 0) {
+        normalMatrix = new THREE.Matrix3().getNormalMatrix(matrix);
+      }
+      for (let i = 0, il = vertices2.length; i < il; i++) {
+        const vertex = vertices2[i];
+        const vertexCopy = vertex.clone();
+        if (matrix !== void 0)
+          vertexCopy.applyMatrix4(matrix);
+        vertices1.push(vertexCopy);
+      }
+      for (let i = 0, il = colors2.length; i < il; i++) {
+        colors1.push(colors2[i].clone());
+      }
+      for (let i = 0, il = faces2.length; i < il; i++) {
+        const face = faces2[i];
+        let normal, color;
+        const faceVertexNormals = face.vertexNormals, faceVertexColors = face.vertexColors;
+        const faceCopy = new Face3(face.a + vertexOffset, face.b + vertexOffset, face.c + vertexOffset);
+        faceCopy.normal.copy(face.normal);
+        if (normalMatrix !== void 0) {
+          faceCopy.normal.applyMatrix3(normalMatrix).normalize();
+        }
+        for (let j = 0, jl = faceVertexNormals.length; j < jl; j++) {
+          normal = faceVertexNormals[j].clone();
+          if (normalMatrix !== void 0) {
+            normal.applyMatrix3(normalMatrix).normalize();
+          }
+          faceCopy.vertexNormals.push(normal);
+        }
+        faceCopy.color.copy(face.color);
+        for (let j = 0, jl = faceVertexColors.length; j < jl; j++) {
+          color = faceVertexColors[j];
+          faceCopy.vertexColors.push(color.clone());
+        }
+        faceCopy.materialIndex = face.materialIndex + materialIndexOffset;
+        faces1.push(faceCopy);
+      }
+      for (let i = 0, il = geometry.faceVertexUvs.length; i < il; i++) {
+        const faceVertexUvs2 = geometry.faceVertexUvs[i];
+        if (this.faceVertexUvs[i] === void 0)
+          this.faceVertexUvs[i] = [];
+        for (let j = 0, jl = faceVertexUvs2.length; j < jl; j++) {
+          const uvs2 = faceVertexUvs2[j], uvsCopy = [];
+          for (let k = 0, kl = uvs2.length; k < kl; k++) {
+            uvsCopy.push(uvs2[k].clone());
+          }
+          this.faceVertexUvs[i].push(uvsCopy);
+        }
+      }
+    }
+    mergeMesh(mesh) {
+      if (!(mesh && mesh.isMesh)) {
+        console.error("THREE.Geometry.mergeMesh(): mesh not an instance of THREE.Mesh.", mesh);
+        return;
+      }
+      if (mesh.matrixAutoUpdate)
+        mesh.updateMatrix();
+      this.merge(mesh.geometry, mesh.matrix);
+    }
+    /*
+     * Checks for duplicate vertices with hashmap.
+     * Duplicated vertices are removed
+     * and faces' vertices are updated.
+     */
+    mergeVertices(precisionPoints = 4) {
+      const verticesMap = {};
+      const unique = [], changes = [];
+      const precision = Math.pow(10, precisionPoints);
+      for (let i = 0, il = this.vertices.length; i < il; i++) {
+        const v = this.vertices[i];
+        const key = `${Math.round(v.x * precision)}_${Math.round(v.y * precision)}_${Math.round(v.z * precision)}`;
+        if (verticesMap[key] === void 0) {
+          verticesMap[key] = i;
+          unique.push(this.vertices[i]);
+          changes[i] = unique.length - 1;
+        } else {
+          changes[i] = changes[verticesMap[key]];
+        }
+      }
+      const faceIndicesToRemove = [];
+      for (let i = 0, il = this.faces.length; i < il; i++) {
+        const face = this.faces[i];
+        face.a = changes[face.a];
+        face.b = changes[face.b];
+        face.c = changes[face.c];
+        const indices = [face.a, face.b, face.c];
+        for (let n = 0; n < 3; n++) {
+          if (indices[n] === indices[(n + 1) % 3]) {
+            faceIndicesToRemove.push(i);
+            break;
+          }
+        }
+      }
+      for (let i = faceIndicesToRemove.length - 1; i >= 0; i--) {
+        const idx = faceIndicesToRemove[i];
+        this.faces.splice(idx, 1);
+        for (let j = 0, jl = this.faceVertexUvs.length; j < jl; j++) {
+          this.faceVertexUvs[j].splice(idx, 1);
+        }
+      }
+      const diff = this.vertices.length - unique.length;
+      this.vertices = unique;
+      return diff;
+    }
+    setFromPoints(points) {
+      this.vertices = [];
+      for (let i = 0, l = points.length; i < l; i++) {
+        const point = points[i];
+        this.vertices.push(new THREE.Vector3(point.x, point.y, point.z || 0));
+      }
+      return this;
+    }
+    sortFacesByMaterialIndex() {
+      const faces = this.faces;
+      const length = faces.length;
+      for (let i = 0; i < length; i++) {
+        faces[i]._id = i;
+      }
+      function materialIndexSort(a, b) {
+        return a.materialIndex - b.materialIndex;
+      }
+      faces.sort(materialIndexSort);
+      const uvs1 = this.faceVertexUvs[0];
+      const uvs2 = this.faceVertexUvs[1];
+      let newUvs1, newUvs2;
+      if (uvs1 && uvs1.length === length)
+        newUvs1 = [];
+      if (uvs2 && uvs2.length === length)
+        newUvs2 = [];
+      for (let i = 0; i < length; i++) {
+        const id = faces[i]._id;
+        if (newUvs1)
+          newUvs1.push(uvs1[id]);
+        if (newUvs2)
+          newUvs2.push(uvs2[id]);
+      }
+      if (newUvs1)
+        this.faceVertexUvs[0] = newUvs1;
+      if (newUvs2)
+        this.faceVertexUvs[1] = newUvs2;
+    }
+    toJSON() {
+      const data = {
+        metadata: {
+          version: 4.5,
+          type: "Geometry",
+          generator: "Geometry.toJSON"
+        }
+      };
+      data.uuid = this.uuid;
+      data.type = this.type;
+      if (this.name !== "")
+        data.name = this.name;
+      if (this.parameters !== void 0) {
+        const parameters = this.parameters;
+        for (let key in parameters) {
+          if (parameters[key] !== void 0)
+            data[key] = parameters[key];
+        }
+        return data;
+      }
+      const vertices = [];
+      for (let i = 0; i < this.vertices.length; i++) {
+        const vertex = this.vertices[i];
+        vertices.push(vertex.x, vertex.y, vertex.z);
+      }
+      const faces = [];
+      const normals = [];
+      const normalsHash = {};
+      const colors = [];
+      const colorsHash = {};
+      const uvs = [];
+      const uvsHash = {};
+      for (let i = 0; i < this.faces.length; i++) {
+        const face = this.faces[i];
+        const hasMaterial = true;
+        const hasFaceUv = false;
+        const hasFaceVertexUv = this.faceVertexUvs[0][i] !== void 0;
+        const hasFaceNormal = face.normal.length() > 0;
+        const hasFaceVertexNormal = face.vertexNormals.length > 0;
+        const hasFaceColor = face.color.r !== 1 || face.color.g !== 1 || face.color.b !== 1;
+        const hasFaceVertexColor = face.vertexColors.length > 0;
+        let faceType = 0;
+        faceType = setBit(faceType, 0, 0);
+        faceType = setBit(faceType, 1, hasMaterial);
+        faceType = setBit(faceType, 2, hasFaceUv);
+        faceType = setBit(faceType, 3, hasFaceVertexUv);
+        faceType = setBit(faceType, 4, hasFaceNormal);
+        faceType = setBit(faceType, 5, hasFaceVertexNormal);
+        faceType = setBit(faceType, 6, hasFaceColor);
+        faceType = setBit(faceType, 7, hasFaceVertexColor);
+        faces.push(faceType);
+        faces.push(face.a, face.b, face.c);
+        faces.push(face.materialIndex);
+        if (hasFaceVertexUv) {
+          const faceVertexUvs = this.faceVertexUvs[0][i];
+          faces.push(getUvIndex(faceVertexUvs[0]), getUvIndex(faceVertexUvs[1]), getUvIndex(faceVertexUvs[2]));
+        }
+        if (hasFaceNormal) {
+          faces.push(getNormalIndex(face.normal));
+        }
+        if (hasFaceVertexNormal) {
+          const vertexNormals = face.vertexNormals;
+          faces.push(
+            getNormalIndex(vertexNormals[0]),
+            getNormalIndex(vertexNormals[1]),
+            getNormalIndex(vertexNormals[2])
+          );
+        }
+        if (hasFaceColor) {
+          faces.push(getColorIndex(face.color));
+        }
+        if (hasFaceVertexColor) {
+          const vertexColors = face.vertexColors;
+          faces.push(getColorIndex(vertexColors[0]), getColorIndex(vertexColors[1]), getColorIndex(vertexColors[2]));
+        }
+      }
+      function setBit(value, position, enabled) {
+        return enabled ? value | 1 << position : value & ~(1 << position);
+      }
+      function getNormalIndex(normal) {
+        const hash = normal.x.toString() + normal.y.toString() + normal.z.toString();
+        if (normalsHash[hash] !== void 0) {
+          return normalsHash[hash];
+        }
+        normalsHash[hash] = normals.length / 3;
+        normals.push(normal.x, normal.y, normal.z);
+        return normalsHash[hash];
+      }
+      function getColorIndex(color) {
+        const hash = color.r.toString() + color.g.toString() + color.b.toString();
+        if (colorsHash[hash] !== void 0) {
+          return colorsHash[hash];
+        }
+        colorsHash[hash] = colors.length;
+        colors.push(color.getHex());
+        return colorsHash[hash];
+      }
+      function getUvIndex(uv) {
+        const hash = uv.x.toString() + uv.y.toString();
+        if (uvsHash[hash] !== void 0) {
+          return uvsHash[hash];
+        }
+        uvsHash[hash] = uvs.length / 2;
+        uvs.push(uv.x, uv.y);
+        return uvsHash[hash];
+      }
+      data.data = {};
+      data.data.vertices = vertices;
+      data.data.normals = normals;
+      if (colors.length > 0)
+        data.data.colors = colors;
+      if (uvs.length > 0)
+        data.data.uvs = [uvs];
+      data.data.faces = faces;
+      return data;
+    }
+    clone() {
+      return new Geometry2().copy(this);
+    }
+    copy(source) {
+      this.vertices = [];
+      this.colors = [];
+      this.faces = [];
+      this.faceVertexUvs = [[]];
+      this.morphTargets = [];
+      this.morphNormals = [];
+      this.skinWeights = [];
+      this.skinIndices = [];
+      this.lineDistances = [];
+      this.boundingBox = null;
+      this.boundingSphere = null;
+      this.name = source.name;
+      const vertices = source.vertices;
+      for (let i = 0, il = vertices.length; i < il; i++) {
+        this.vertices.push(vertices[i].clone());
+      }
+      const colors = source.colors;
+      for (let i = 0, il = colors.length; i < il; i++) {
+        this.colors.push(colors[i].clone());
+      }
+      const faces = source.faces;
+      for (let i = 0, il = faces.length; i < il; i++) {
+        this.faces.push(faces[i].clone());
+      }
+      for (let i = 0, il = source.faceVertexUvs.length; i < il; i++) {
+        const faceVertexUvs = source.faceVertexUvs[i];
+        if (this.faceVertexUvs[i] === void 0) {
+          this.faceVertexUvs[i] = [];
+        }
+        for (let j = 0, jl = faceVertexUvs.length; j < jl; j++) {
+          const uvs = faceVertexUvs[j], uvsCopy = [];
+          for (let k = 0, kl = uvs.length; k < kl; k++) {
+            const uv = uvs[k];
+            uvsCopy.push(uv.clone());
+          }
+          this.faceVertexUvs[i].push(uvsCopy);
+        }
+      }
+      const morphTargets = source.morphTargets;
+      for (let i = 0, il = morphTargets.length; i < il; i++) {
+        const morphTarget = {};
+        morphTarget.name = morphTargets[i].name;
+        if (morphTargets[i].vertices !== void 0) {
+          morphTarget.vertices = [];
+          for (let j = 0, jl = morphTargets[i].vertices.length; j < jl; j++) {
+            morphTarget.vertices.push(morphTargets[i].vertices[j].clone());
+          }
+        }
+        if (morphTargets[i].normals !== void 0) {
+          morphTarget.normals = [];
+          for (let j = 0, jl = morphTargets[i].normals.length; j < jl; j++) {
+            morphTarget.normals.push(morphTargets[i].normals[j].clone());
+          }
+        }
+        this.morphTargets.push(morphTarget);
+      }
+      const morphNormals = source.morphNormals;
+      for (let i = 0, il = morphNormals.length; i < il; i++) {
+        const morphNormal = {};
+        if (morphNormals[i].vertexNormals !== void 0) {
+          morphNormal.vertexNormals = [];
+          for (let j = 0, jl = morphNormals[i].vertexNormals.length; j < jl; j++) {
+            const srcVertexNormal = morphNormals[i].vertexNormals[j];
+            const destVertexNormal = {};
+            destVertexNormal.a = srcVertexNormal.a.clone();
+            destVertexNormal.b = srcVertexNormal.b.clone();
+            destVertexNormal.c = srcVertexNormal.c.clone();
+            morphNormal.vertexNormals.push(destVertexNormal);
+          }
+        }
+        if (morphNormals[i].faceNormals !== void 0) {
+          morphNormal.faceNormals = [];
+          for (let j = 0, jl = morphNormals[i].faceNormals.length; j < jl; j++) {
+            morphNormal.faceNormals.push(morphNormals[i].faceNormals[j].clone());
+          }
+        }
+        this.morphNormals.push(morphNormal);
+      }
+      const skinWeights = source.skinWeights;
+      for (let i = 0, il = skinWeights.length; i < il; i++) {
+        this.skinWeights.push(skinWeights[i].clone());
+      }
+      const skinIndices = source.skinIndices;
+      for (let i = 0, il = skinIndices.length; i < il; i++) {
+        this.skinIndices.push(skinIndices[i].clone());
+      }
+      const lineDistances = source.lineDistances;
+      for (let i = 0, il = lineDistances.length; i < il; i++) {
+        this.lineDistances.push(lineDistances[i]);
+      }
+      const boundingBox = source.boundingBox;
+      if (boundingBox !== null) {
+        this.boundingBox = boundingBox.clone();
+      }
+      const boundingSphere = source.boundingSphere;
+      if (boundingSphere !== null) {
+        this.boundingSphere = boundingSphere.clone();
+      }
+      this.elementsNeedUpdate = source.elementsNeedUpdate;
+      this.verticesNeedUpdate = source.verticesNeedUpdate;
+      this.uvsNeedUpdate = source.uvsNeedUpdate;
+      this.normalsNeedUpdate = source.normalsNeedUpdate;
+      this.colorsNeedUpdate = source.colorsNeedUpdate;
+      this.lineDistancesNeedUpdate = source.lineDistancesNeedUpdate;
+      this.groupsNeedUpdate = source.groupsNeedUpdate;
+      return this;
+    }
+    toBufferGeometry() {
+      const geometry = new DirectGeometry().fromGeometry(this);
+      const buffergeometry = new THREE.BufferGeometry();
+      const positions = new Float32Array(geometry.vertices.length * 3);
+      buffergeometry.setAttribute("position", new THREE.BufferAttribute(positions, 3).copyVector3sArray(geometry.vertices));
+      if (geometry.normals.length > 0) {
+        const normals = new Float32Array(geometry.normals.length * 3);
+        buffergeometry.setAttribute("normal", new THREE.BufferAttribute(normals, 3).copyVector3sArray(geometry.normals));
+      }
+      if (geometry.colors.length > 0) {
+        const colors = new Float32Array(geometry.colors.length * 3);
+        buffergeometry.setAttribute("color", new THREE.BufferAttribute(colors, 3).copyColorsArray(geometry.colors));
+      }
+      if (geometry.uvs.length > 0) {
+        const uvs = new Float32Array(geometry.uvs.length * 2);
+        buffergeometry.setAttribute("uv", new THREE.BufferAttribute(uvs, 2).copyVector2sArray(geometry.uvs));
+      }
+      if (geometry.uvs2.length > 0) {
+        const uvs2 = new Float32Array(geometry.uvs2.length * 2);
+        buffergeometry.setAttribute("uv2", new THREE.BufferAttribute(uvs2, 2).copyVector2sArray(geometry.uvs2));
+      }
+      buffergeometry.groups = geometry.groups;
+      for (let name in geometry.morphTargets) {
+        const array = [];
+        const morphTargets = geometry.morphTargets[name];
+        for (let i = 0, l = morphTargets.length; i < l; i++) {
+          const morphTarget = morphTargets[i];
+          const attribute = new THREE.Float32BufferAttribute(morphTarget.data.length * 3, 3);
+          attribute.name = morphTarget.name;
+          array.push(attribute.copyVector3sArray(morphTarget.data));
+        }
+        buffergeometry.morphAttributes[name] = array;
+      }
+      if (geometry.skinIndices.length > 0) {
+        const skinIndices = new THREE.Float32BufferAttribute(geometry.skinIndices.length * 4, 4);
+        buffergeometry.setAttribute("skinIndex", skinIndices.copyVector4sArray(geometry.skinIndices));
+      }
+      if (geometry.skinWeights.length > 0) {
+        const skinWeights = new THREE.Float32BufferAttribute(geometry.skinWeights.length * 4, 4);
+        buffergeometry.setAttribute("skinWeight", skinWeights.copyVector4sArray(geometry.skinWeights));
+      }
+      if (geometry.boundingSphere !== null) {
+        buffergeometry.boundingSphere = geometry.boundingSphere.clone();
+      }
+      if (geometry.boundingBox !== null) {
+        buffergeometry.boundingBox = geometry.boundingBox.clone();
+      }
+      return buffergeometry;
+    }
+    computeTangents() {
+      console.error("THREE.Geometry: .computeTangents() has been removed.");
+    }
+    computeLineDistances() {
+      console.error(
+        "THREE.Geometry: .computeLineDistances() has been removed. Use THREE.Line.computeLineDistances() instead."
+      );
+    }
+    applyMatrix(matrix) {
+      console.warn("THREE.Geometry: .applyMatrix() has been renamed to .applyMatrix4().");
+      return this.applyMatrix4(matrix);
+    }
+    dispose() {
+      this.dispatchEvent({ type: "dispose" });
+    }
+  }
+  return Geometry2;
+})();
+class DirectGeometry {
+  constructor() {
+    this.vertices = [];
+    this.normals = [];
+    this.colors = [];
+    this.uvs = [];
+    this.uvs2 = [];
+    this.groups = [];
+    this.morphTargets = {};
+    this.skinWeights = [];
+    this.skinIndices = [];
+    this.boundingBox = null;
+    this.boundingSphere = null;
+    this.verticesNeedUpdate = false;
+    this.normalsNeedUpdate = false;
+    this.colorsNeedUpdate = false;
+    this.uvsNeedUpdate = false;
+    this.groupsNeedUpdate = false;
+  }
+  computeGroups(geometry) {
+    const groups = [];
+    let group, i;
+    let materialIndex = void 0;
+    const faces = geometry.faces;
+    for (i = 0; i < faces.length; i++) {
+      const face = faces[i];
+      if (face.materialIndex !== materialIndex) {
+        materialIndex = face.materialIndex;
+        if (group !== void 0) {
+          group.count = i * 3 - group.start;
+          groups.push(group);
+        }
+        group = {
+          start: i * 3,
+          materialIndex
+        };
+      }
+    }
+    if (group !== void 0) {
+      group.count = i * 3 - group.start;
+      groups.push(group);
+    }
+    this.groups = groups;
+  }
+  fromGeometry(geometry) {
+    const faces = geometry.faces;
+    const vertices = geometry.vertices;
+    const faceVertexUvs = geometry.faceVertexUvs;
+    const hasFaceVertexUv = faceVertexUvs[0] && faceVertexUvs[0].length > 0;
+    const hasFaceVertexUv2 = faceVertexUvs[1] && faceVertexUvs[1].length > 0;
+    const morphTargets = geometry.morphTargets;
+    const morphTargetsLength = morphTargets.length;
+    let morphTargetsPosition;
+    if (morphTargetsLength > 0) {
+      morphTargetsPosition = [];
+      for (let i = 0; i < morphTargetsLength; i++) {
+        morphTargetsPosition[i] = {
+          name: morphTargets[i].name,
+          data: []
+        };
+      }
+      this.morphTargets.position = morphTargetsPosition;
+    }
+    const morphNormals = geometry.morphNormals;
+    const morphNormalsLength = morphNormals.length;
+    let morphTargetsNormal;
+    if (morphNormalsLength > 0) {
+      morphTargetsNormal = [];
+      for (let i = 0; i < morphNormalsLength; i++) {
+        morphTargetsNormal[i] = {
+          name: morphNormals[i].name,
+          data: []
+        };
+      }
+      this.morphTargets.normal = morphTargetsNormal;
+    }
+    const skinIndices = geometry.skinIndices;
+    const skinWeights = geometry.skinWeights;
+    const hasSkinIndices = skinIndices.length === vertices.length;
+    const hasSkinWeights = skinWeights.length === vertices.length;
+    if (vertices.length > 0 && faces.length === 0) {
+      console.error("THREE.DirectGeometry: Faceless geometries are not supported.");
+    }
+    for (let i = 0; i < faces.length; i++) {
+      const face = faces[i];
+      this.vertices.push(vertices[face.a], vertices[face.b], vertices[face.c]);
+      const vertexNormals = face.vertexNormals;
+      if (vertexNormals.length === 3) {
+        this.normals.push(vertexNormals[0], vertexNormals[1], vertexNormals[2]);
+      } else {
+        const normal = face.normal;
+        this.normals.push(normal, normal, normal);
+      }
+      const vertexColors = face.vertexColors;
+      if (vertexColors.length === 3) {
+        this.colors.push(vertexColors[0], vertexColors[1], vertexColors[2]);
+      } else {
+        const color = face.color;
+        this.colors.push(color, color, color);
+      }
+      if (hasFaceVertexUv === true) {
+        const vertexUvs = faceVertexUvs[0][i];
+        if (vertexUvs !== void 0) {
+          this.uvs.push(vertexUvs[0], vertexUvs[1], vertexUvs[2]);
+        } else {
+          console.warn("THREE.DirectGeometry.fromGeometry(): Undefined vertexUv ", i);
+          this.uvs.push(new THREE.Vector2(), new THREE.Vector2(), new THREE.Vector2());
+        }
+      }
+      if (hasFaceVertexUv2 === true) {
+        const vertexUvs = faceVertexUvs[1][i];
+        if (vertexUvs !== void 0) {
+          this.uvs2.push(vertexUvs[0], vertexUvs[1], vertexUvs[2]);
+        } else {
+          console.warn("THREE.DirectGeometry.fromGeometry(): Undefined vertexUv2 ", i);
+          this.uvs2.push(new THREE.Vector2(), new THREE.Vector2(), new THREE.Vector2());
+        }
+      }
+      for (let j = 0; j < morphTargetsLength; j++) {
+        const morphTarget = morphTargets[j].vertices;
+        morphTargetsPosition[j].data.push(morphTarget[face.a], morphTarget[face.b], morphTarget[face.c]);
+      }
+      for (let j = 0; j < morphNormalsLength; j++) {
+        const morphNormal = morphNormals[j].vertexNormals[i];
+        morphTargetsNormal[j].data.push(morphNormal.a, morphNormal.b, morphNormal.c);
+      }
+      if (hasSkinIndices) {
+        this.skinIndices.push(skinIndices[face.a], skinIndices[face.b], skinIndices[face.c]);
+      }
+      if (hasSkinWeights) {
+        this.skinWeights.push(skinWeights[face.a], skinWeights[face.b], skinWeights[face.c]);
+      }
+    }
+    this.computeGroups(geometry);
+    this.verticesNeedUpdate = geometry.verticesNeedUpdate;
+    this.normalsNeedUpdate = geometry.normalsNeedUpdate;
+    this.colorsNeedUpdate = geometry.colorsNeedUpdate;
+    this.uvsNeedUpdate = geometry.uvsNeedUpdate;
+    this.groupsNeedUpdate = geometry.groupsNeedUpdate;
+    if (geometry.boundingSphere !== null) {
+      this.boundingSphere = geometry.boundingSphere.clone();
+    }
+    if (geometry.boundingBox !== null) {
+      this.boundingBox = geometry.boundingBox.clone();
+    }
+    return this;
+  }
+}
+class Face3 {
+  constructor(a, b, c, normal, color, materialIndex = 0) {
+    this.a = a;
+    this.b = b;
+    this.c = c;
+    this.normal = normal && normal.isVector3 ? normal : new THREE.Vector3();
+    this.vertexNormals = Array.isArray(normal) ? normal : [];
+    this.color = color && color.isColor ? color : new THREE.Color();
+    this.vertexColors = Array.isArray(color) ? color : [];
+    this.materialIndex = materialIndex;
+  }
+  clone() {
+    return new this.constructor().copy(this);
+  }
+  copy(source) {
+    this.a = source.a;
+    this.b = source.b;
+    this.c = source.c;
+    this.normal.copy(source.normal);
+    this.color.copy(source.color);
+    this.materialIndex = source.materialIndex;
+    for (let i = 0, il = source.vertexNormals.length; i < il; i++) {
+      this.vertexNormals[i] = source.vertexNormals[i].clone();
+    }
+    for (let i = 0, il = source.vertexColors.length; i < il; i++) {
+      this.vertexColors[i] = source.vertexColors[i].clone();
+    }
+    return this;
+  }
+}
+exports.Face3 = Face3;
+exports.Geometry = Geometry;
+//# sourceMappingURL=Geometry.cjs.map

node_modules/three-stdlib/deprecated/Geometry.d.ts

@@ -0,0 +1,341 @@
+import {
+  Vector3,
+  Color,
+  Vector2,
+  Vector4,
+  Box3,
+  Sphere,
+  Matrix4,
+  BufferGeometry,
+  Mesh,
+  Bone,
+  AnimationClip,
+  EventDispatcher,
+  Object3D,
+} from 'three'
+
+/**
+ * @deprecated Use Face3 instead.
+ */
+
+export interface MorphTarget {
+  name: string
+  vertices: Vector3[]
+}
+
+export interface MorphColor {
+  name: string
+  colors: Color[]
+}
+
+export interface MorphNormals {
+  name: string
+  normals: Vector3[]
+}
+
+/**
+ * Base class for geometries
+ */
+export class Geometry extends EventDispatcher {
+  constructor()
+
+  /**
+   * Unique number of this geometry instance
+   */
+  id: number
+
+  uuid: string
+
+  readonly isGeometry: true
+
+  /**
+   * Name for this geometry. Default is an empty string.
+   * @default ''
+   */
+  name: string
+
+  /**
+   * @default 'Geometry'
+   */
+  type: string
+
+  /**
+   * The array of vertices hold every position of points of the model.
+   * To signal an update in this array, Geometry.verticesNeedUpdate needs to be set to true.
+   * @default []
+   */
+  vertices: Vector3[]
+
+  /**
+   * Array of vertex colors, matching number and order of vertices.
+   * Used in ParticleSystem, Line and Ribbon.
+   * Meshes use per-face-use-of-vertex colors embedded directly in faces.
+   * To signal an update in this array, Geometry.colorsNeedUpdate needs to be set to true.
+   * @default []
+   */
+  colors: Color[]
+
+  /**
+   * Array of triangles or/and quads.
+   * The array of faces describe how each vertex in the model is connected with each other.
+   * To signal an update in this array, Geometry.elementsNeedUpdate needs to be set to true.
+   * @default []
+   */
+  faces: Face3[]
+
+  /**
+   * Array of face UV layers.
+   * Each UV layer is an array of UV matching order and number of vertices in faces.
+   * To signal an update in this array, Geometry.uvsNeedUpdate needs to be set to true.
+   * @default [[]]
+   */
+  faceVertexUvs: Vector2[][][]
+
+  /**
+   * Array of morph targets. Each morph target is a Javascript object:
+   *
+   * { name: "targetName", vertices: [ new THREE.Vector3(), ... ] }
+   *
+   * Morph vertices match number and order of primary vertices.
+   * @default []
+   */
+  morphTargets: MorphTarget[]
+
+  /**
+   * Array of morph normals. Morph normals have similar structure as morph targets, each normal set is a Javascript object:
+   *
+   * morphNormal = { name: "NormalName", normals: [ new THREE.Vector3(), ... ] }
+   * @default []
+   */
+  morphNormals: MorphNormals[]
+
+  /**
+   * Array of skinning weights, matching number and order of vertices.
+   * @default []
+   */
+  skinWeights: Vector4[]
+
+  /**
+   * Array of skinning indices, matching number and order of vertices.
+   * @default []
+   */
+  skinIndices: Vector4[]
+
+  /**
+   * @default []
+   */
+  lineDistances: number[]
+
+  /**
+   * Bounding box.
+   * @default null
+   */
+  boundingBox: Box3 | null
+
+  /**
+   * Bounding sphere.
+   * @default null
+   */
+  boundingSphere: Sphere | null
+
+  /**
+   * Set to true if the vertices array has been updated.
+   * @default false
+   */
+  verticesNeedUpdate: boolean
+
+  /**
+   * Set to true if the faces array has been updated.
+   * @default false
+   */
+  elementsNeedUpdate: boolean
+
+  /**
+   * Set to true if the uvs array has been updated.
+   * @default false
+   */
+  uvsNeedUpdate: boolean
+
+  /**
+   * Set to true if the normals array has been updated.
+   * @default false
+   */
+  normalsNeedUpdate: boolean
+
+  /**
+   * Set to true if the colors array has been updated.
+   * @default false
+   */
+  colorsNeedUpdate: boolean
+
+  /**
+   * Set to true if the linedistances array has been updated.
+   * @default false
+   */
+  lineDistancesNeedUpdate: boolean
+
+  /**
+   *
+   * @default false
+   */
+  groupsNeedUpdate: boolean
+
+  /**
+   * Bakes matrix transform directly into vertex coordinates.
+   */
+  applyMatrix4(matrix: Matrix4): Geometry
+
+  rotateX(angle: number): Geometry
+  rotateY(angle: number): Geometry
+  rotateZ(angle: number): Geometry
+
+  translate(x: number, y: number, z: number): Geometry
+  scale(x: number, y: number, z: number): Geometry
+  lookAt(vector: Vector3): void
+
+  fromBufferGeometry(geometry: BufferGeometry): Geometry
+
+  center(): Geometry
+
+  normalize(): Geometry
+
+  /**
+   * Computes face normals.
+   */
+  computeFaceNormals(): void
+
+  /**
+   * Computes vertex normals by averaging face normals.
+   * Face normals must be existing / computed beforehand.
+   */
+  computeVertexNormals(areaWeighted?: boolean): void
+
+  /**
+   * Compute vertex normals, but duplicating face normals.
+   */
+  computeFlatVertexNormals(): void
+
+  /**
+   * Computes morph normals.
+   */
+  computeMorphNormals(): void
+
+  /**
+   * Computes bounding box of the geometry, updating {@link Geometry.boundingBox} attribute.
+   */
+  computeBoundingBox(): void
+
+  /**
+   * Computes bounding sphere of the geometry, updating Geometry.boundingSphere attribute.
+   * Neither bounding boxes or bounding spheres are computed by default. They need to be explicitly computed, otherwise they are null.
+   */
+  computeBoundingSphere(): void
+
+  merge(geometry: Geometry, matrix?: Matrix4, materialIndexOffset?: number): void
+
+  mergeMesh(mesh: Mesh): void
+
+  /**
+   * Checks for duplicate vertices using hashmap for specified number of decimal points, e.g. 4 for epsilon of 0.0001
+   * Duplicated vertices are removed and faces' vertices are updated.
+   */
+  mergeVertices(precisionPoints?: number): number
+
+  setFromPoints(points: Vector2[] | Vector3[]): this
+
+  sortFacesByMaterialIndex(): void
+
+  toBufferGeometry(): BufferGeometry
+
+  static createBufferGeometryFromObject(object: Object3D): BufferGeometry
+
+  toJSON(): any
+
+  /**
+   * Creates a new clone of the Geometry.
+   */
+  clone(): Geometry
+
+  copy(source: Geometry): this
+
+  /**
+   * Removes The object from memory.
+   * Don't forget to call this method when you remove an geometry because it can cuase meomory leaks.
+   */
+  dispose(): void
+
+  // These properties do not exist in a normal Geometry class, but if you use the instance that was passed by JSONLoader, it will be added.
+  bones: Bone[]
+  animation: AnimationClip
+  animations: AnimationClip[]
+}
+
+/**
+ * Triangle face.
+ */
+export class Face3 {
+  /**
+   * @param a Vertex A index.
+   * @param b Vertex B index.
+   * @param c Vertex C index.
+   * @param normal Face normal or array of vertex normals.
+   * @param color Face color or array of vertex colors.
+   * @param materialIndex Material index.
+   */
+  constructor(
+    a: number,
+    b: number,
+    c: number,
+    normal?: Vector3 | Vector3[],
+    color?: Color | Color[],
+    materialIndex?: number,
+  )
+
+  /**
+   * Vertex A index.
+   */
+  a: number
+
+  /**
+   * Vertex B index.
+   */
+  b: number
+
+  /**
+   * Vertex C index.
+   */
+  c: number
+
+  /**
+   * Face normal.
+   * @default new THREE.Vector3()
+   */
+  normal: Vector3
+
+  /**
+   * Array of 3 vertex normals.
+   * @default []
+   */
+  vertexNormals: Vector3[]
+
+  /**
+   * Face color.
+   * @default new THREE.Color()
+   */
+  color: Color
+
+  /**
+   * Array of 3 vertex colors.
+   * @default []
+   */
+  vertexColors: Color[]
+
+  /**
+   * Material index (points to {@link Mesh.material}).
+   * @default 0
+   */
+  materialIndex: number
+
+  clone(): this
+  copy(source: Face3): this
+}

node_modules/three-stdlib/deprecated/Geometry.js

@@ -0,0 +1,979 @@
+import { Vector3, Color, EventDispatcher, BufferGeometry, Float32BufferAttribute, MathUtils, Matrix3, Matrix4, Box3, Sphere, BufferAttribute, Vector2, Object3D } from "three";
+const _m1 = /* @__PURE__ */ new Matrix4();
+const _obj = /* @__PURE__ */ new Object3D();
+const _offset = /* @__PURE__ */ new Vector3();
+const Geometry = /* @__PURE__ */ (() => {
+  class Geometry2 extends EventDispatcher {
+    static createBufferGeometryFromObject(object) {
+      let buffergeometry = new BufferGeometry();
+      const geometry = object.geometry;
+      if (object.isPoints || object.isLine) {
+        const positions = new Float32BufferAttribute(geometry.vertices.length * 3, 3);
+        const colors = new Float32BufferAttribute(geometry.colors.length * 3, 3);
+        buffergeometry.setAttribute("position", positions.copyVector3sArray(geometry.vertices));
+        buffergeometry.setAttribute("color", colors.copyColorsArray(geometry.colors));
+        if (geometry.lineDistances && geometry.lineDistances.length === geometry.vertices.length) {
+          const lineDistances = new Float32BufferAttribute(geometry.lineDistances.length, 1);
+          buffergeometry.setAttribute("lineDistance", lineDistances.copyArray(geometry.lineDistances));
+        }
+        if (geometry.boundingSphere !== null) {
+          buffergeometry.boundingSphere = geometry.boundingSphere.clone();
+        }
+        if (geometry.boundingBox !== null) {
+          buffergeometry.boundingBox = geometry.boundingBox.clone();
+        }
+      } else if (object.isMesh) {
+        buffergeometry = geometry.toBufferGeometry();
+      }
+      return buffergeometry;
+    }
+    constructor() {
+      super();
+      this.isGeometry = true;
+      this.uuid = MathUtils.generateUUID();
+      this.name = "";
+      this.type = "Geometry";
+      this.vertices = [];
+      this.colors = [];
+      this.faces = [];
+      this.faceVertexUvs = [[]];
+      this.morphTargets = [];
+      this.morphNormals = [];
+      this.skinWeights = [];
+      this.skinIndices = [];
+      this.lineDistances = [];
+      this.boundingBox = null;
+      this.boundingSphere = null;
+      this.elementsNeedUpdate = false;
+      this.verticesNeedUpdate = false;
+      this.uvsNeedUpdate = false;
+      this.normalsNeedUpdate = false;
+      this.colorsNeedUpdate = false;
+      this.lineDistancesNeedUpdate = false;
+      this.groupsNeedUpdate = false;
+    }
+    applyMatrix4(matrix) {
+      const normalMatrix = new Matrix3().getNormalMatrix(matrix);
+      for (let i = 0, il = this.vertices.length; i < il; i++) {
+        const vertex = this.vertices[i];
+        vertex.applyMatrix4(matrix);
+      }
+      for (let i = 0, il = this.faces.length; i < il; i++) {
+        const face = this.faces[i];
+        face.normal.applyMatrix3(normalMatrix).normalize();
+        for (let j = 0, jl = face.vertexNormals.length; j < jl; j++) {
+          face.vertexNormals[j].applyMatrix3(normalMatrix).normalize();
+        }
+      }
+      if (this.boundingBox !== null) {
+        this.computeBoundingBox();
+      }
+      if (this.boundingSphere !== null) {
+        this.computeBoundingSphere();
+      }
+      this.verticesNeedUpdate = true;
+      this.normalsNeedUpdate = true;
+      return this;
+    }
+    rotateX(angle) {
+      _m1.makeRotationX(angle);
+      this.applyMatrix4(_m1);
+      return this;
+    }
+    rotateY(angle) {
+      _m1.makeRotationY(angle);
+      this.applyMatrix4(_m1);
+      return this;
+    }
+    rotateZ(angle) {
+      _m1.makeRotationZ(angle);
+      this.applyMatrix4(_m1);
+      return this;
+    }
+    translate(x, y, z) {
+      _m1.makeTranslation(x, y, z);
+      this.applyMatrix4(_m1);
+      return this;
+    }
+    scale(x, y, z) {
+      _m1.makeScale(x, y, z);
+      this.applyMatrix4(_m1);
+      return this;
+    }
+    lookAt(vector) {
+      _obj.lookAt(vector);
+      _obj.updateMatrix();
+      this.applyMatrix4(_obj.matrix);
+      return this;
+    }
+    fromBufferGeometry(geometry) {
+      const scope = this;
+      const index = geometry.index !== null ? geometry.index : void 0;
+      const attributes = geometry.attributes;
+      if (attributes.position === void 0) {
+        console.error("THREE.Geometry.fromBufferGeometry(): Position attribute required for conversion.");
+        return this;
+      }
+      const position = attributes.position;
+      const normal = attributes.normal;
+      const color = attributes.color;
+      const uv = attributes.uv;
+      const uv2 = attributes.uv2;
+      if (uv2 !== void 0)
+        this.faceVertexUvs[1] = [];
+      for (let i = 0; i < position.count; i++) {
+        scope.vertices.push(new Vector3().fromBufferAttribute(position, i));
+        if (color !== void 0) {
+          scope.colors.push(new Color().fromBufferAttribute(color, i));
+        }
+      }
+      function addFace(a, b, c, materialIndex) {
+        const vertexColors = color === void 0 ? [] : [scope.colors[a].clone(), scope.colors[b].clone(), scope.colors[c].clone()];
+        const vertexNormals = normal === void 0 ? [] : [
+          new Vector3().fromBufferAttribute(normal, a),
+          new Vector3().fromBufferAttribute(normal, b),
+          new Vector3().fromBufferAttribute(normal, c)
+        ];
+        const face = new Face3(a, b, c, vertexNormals, vertexColors, materialIndex);
+        scope.faces.push(face);
+        if (uv !== void 0) {
+          scope.faceVertexUvs[0].push([
+            new Vector2().fromBufferAttribute(uv, a),
+            new Vector2().fromBufferAttribute(uv, b),
+            new Vector2().fromBufferAttribute(uv, c)
+          ]);
+        }
+        if (uv2 !== void 0) {
+          scope.faceVertexUvs[1].push([
+            new Vector2().fromBufferAttribute(uv2, a),
+            new Vector2().fromBufferAttribute(uv2, b),
+            new Vector2().fromBufferAttribute(uv2, c)
+          ]);
+        }
+      }
+      const groups = geometry.groups;
+      if (groups.length > 0) {
+        for (let i = 0; i < groups.length; i++) {
+          const group = groups[i];
+          const start = group.start;
+          const count = group.count;
+          for (let j = start, jl = start + count; j < jl; j += 3) {
+            if (index !== void 0) {
+              addFace(index.getX(j), index.getX(j + 1), index.getX(j + 2), group.materialIndex);
+            } else {
+              addFace(j, j + 1, j + 2, group.materialIndex);
+            }
+          }
+        }
+      } else {
+        if (index !== void 0) {
+          for (let i = 0; i < index.count; i += 3) {
+            addFace(index.getX(i), index.getX(i + 1), index.getX(i + 2));
+          }
+        } else {
+          for (let i = 0; i < position.count; i += 3) {
+            addFace(i, i + 1, i + 2);
+          }
+        }
+      }
+      this.computeFaceNormals();
+      if (geometry.boundingBox !== null) {
+        this.boundingBox = geometry.boundingBox.clone();
+      }
+      if (geometry.boundingSphere !== null) {
+        this.boundingSphere = geometry.boundingSphere.clone();
+      }
+      return this;
+    }
+    center() {
+      this.computeBoundingBox();
+      this.boundingBox.getCenter(_offset).negate();
+      this.translate(_offset.x, _offset.y, _offset.z);
+      return this;
+    }
+    normalize() {
+      this.computeBoundingSphere();
+      const center = this.boundingSphere.center;
+      const radius = this.boundingSphere.radius;
+      const s = radius === 0 ? 1 : 1 / radius;
+      const matrix = new Matrix4();
+      matrix.set(s, 0, 0, -s * center.x, 0, s, 0, -s * center.y, 0, 0, s, -s * center.z, 0, 0, 0, 1);
+      this.applyMatrix4(matrix);
+      return this;
+    }
+    computeFaceNormals() {
+      const cb = new Vector3(), ab = new Vector3();
+      for (let f = 0, fl = this.faces.length; f < fl; f++) {
+        const face = this.faces[f];
+        const vA = this.vertices[face.a];
+        const vB = this.vertices[face.b];
+        const vC = this.vertices[face.c];
+        cb.subVectors(vC, vB);
+        ab.subVectors(vA, vB);
+        cb.cross(ab);
+        cb.normalize();
+        face.normal.copy(cb);
+      }
+    }
+    computeVertexNormals(areaWeighted = true) {
+      const vertices = new Array(this.vertices.length);
+      for (let v = 0, vl = this.vertices.length; v < vl; v++) {
+        vertices[v] = new Vector3();
+      }
+      if (areaWeighted) {
+        const cb = new Vector3(), ab = new Vector3();
+        for (let f = 0, fl = this.faces.length; f < fl; f++) {
+          const face = this.faces[f];
+          const vA = this.vertices[face.a];
+          const vB = this.vertices[face.b];
+          const vC = this.vertices[face.c];
+          cb.subVectors(vC, vB);
+          ab.subVectors(vA, vB);
+          cb.cross(ab);
+          vertices[face.a].add(cb);
+          vertices[face.b].add(cb);
+          vertices[face.c].add(cb);
+        }
+      } else {
+        this.computeFaceNormals();
+        for (let f = 0, fl = this.faces.length; f < fl; f++) {
+          const face = this.faces[f];
+          vertices[face.a].add(face.normal);
+          vertices[face.b].add(face.normal);
+          vertices[face.c].add(face.normal);
+        }
+      }
+      for (let v = 0, vl = this.vertices.length; v < vl; v++) {
+        vertices[v].normalize();
+      }
+      for (let f = 0, fl = this.faces.length; f < fl; f++) {
+        const face = this.faces[f];
+        const vertexNormals = face.vertexNormals;
+        if (vertexNormals.length === 3) {
+          vertexNormals[0].copy(vertices[face.a]);
+          vertexNormals[1].copy(vertices[face.b]);
+          vertexNormals[2].copy(vertices[face.c]);
+        } else {
+          vertexNormals[0] = vertices[face.a].clone();
+          vertexNormals[1] = vertices[face.b].clone();
+          vertexNormals[2] = vertices[face.c].clone();
+        }
+      }
+      if (this.faces.length > 0) {
+        this.normalsNeedUpdate = true;
+      }
+    }
+    computeFlatVertexNormals() {
+      this.computeFaceNormals();
+      for (let f = 0, fl = this.faces.length; f < fl; f++) {
+        const face = this.faces[f];
+        const vertexNormals = face.vertexNormals;
+        if (vertexNormals.length === 3) {
+          vertexNormals[0].copy(face.normal);
+          vertexNormals[1].copy(face.normal);
+          vertexNormals[2].copy(face.normal);
+        } else {
+          vertexNormals[0] = face.normal.clone();
+          vertexNormals[1] = face.normal.clone();
+          vertexNormals[2] = face.normal.clone();
+        }
+      }
+      if (this.faces.length > 0) {
+        this.normalsNeedUpdate = true;
+      }
+    }
+    computeMorphNormals() {
+      for (let f = 0, fl = this.faces.length; f < fl; f++) {
+        const face = this.faces[f];
+        if (!face.__originalFaceNormal) {
+          face.__originalFaceNormal = face.normal.clone();
+        } else {
+          face.__originalFaceNormal.copy(face.normal);
+        }
+        if (!face.__originalVertexNormals)
+          face.__originalVertexNormals = [];
+        for (let i = 0, il = face.vertexNormals.length; i < il; i++) {
+          if (!face.__originalVertexNormals[i]) {
+            face.__originalVertexNormals[i] = face.vertexNormals[i].clone();
+          } else {
+            face.__originalVertexNormals[i].copy(face.vertexNormals[i]);
+          }
+        }
+      }
+      const tmpGeo = new Geometry2();
+      tmpGeo.faces = this.faces;
+      for (let i = 0, il = this.morphTargets.length; i < il; i++) {
+        if (!this.morphNormals[i]) {
+          this.morphNormals[i] = {};
+          this.morphNormals[i].faceNormals = [];
+          this.morphNormals[i].vertexNormals = [];
+          const dstNormalsFace = this.morphNormals[i].faceNormals;
+          const dstNormalsVertex = this.morphNormals[i].vertexNormals;
+          for (let f = 0, fl = this.faces.length; f < fl; f++) {
+            const faceNormal = new Vector3();
+            const vertexNormals = {
+              a: new Vector3(),
+              b: new Vector3(),
+              c: new Vector3()
+            };
+            dstNormalsFace.push(faceNormal);
+            dstNormalsVertex.push(vertexNormals);
+          }
+        }
+        const morphNormals = this.morphNormals[i];
+        tmpGeo.vertices = this.morphTargets[i].vertices;
+        tmpGeo.computeFaceNormals();
+        tmpGeo.computeVertexNormals();
+        for (let f = 0, fl = this.faces.length; f < fl; f++) {
+          const face = this.faces[f];
+          const faceNormal = morphNormals.faceNormals[f];
+          const vertexNormals = morphNormals.vertexNormals[f];
+          faceNormal.copy(face.normal);
+          vertexNormals.a.copy(face.vertexNormals[0]);
+          vertexNormals.b.copy(face.vertexNormals[1]);
+          vertexNormals.c.copy(face.vertexNormals[2]);
+        }
+      }
+      for (let f = 0, fl = this.faces.length; f < fl; f++) {
+        const face = this.faces[f];
+        face.normal = face.__originalFaceNormal;
+        face.vertexNormals = face.__originalVertexNormals;
+      }
+    }
+    computeBoundingBox() {
+      if (this.boundingBox === null) {
+        this.boundingBox = new Box3();
+      }
+      this.boundingBox.setFromPoints(this.vertices);
+    }
+    computeBoundingSphere() {
+      if (this.boundingSphere === null) {
+        this.boundingSphere = new Sphere();
+      }
+      this.boundingSphere.setFromPoints(this.vertices);
+    }
+    merge(geometry, matrix, materialIndexOffset = 0) {
+      if (!(geometry && geometry.isGeometry)) {
+        console.error("THREE.Geometry.merge(): geometry not an instance of THREE.Geometry.", geometry);
+        return;
+      }
+      let normalMatrix;
+      const vertexOffset = this.vertices.length, vertices1 = this.vertices, vertices2 = geometry.vertices, faces1 = this.faces, faces2 = geometry.faces, colors1 = this.colors, colors2 = geometry.colors;
+      if (matrix !== void 0) {
+        normalMatrix = new Matrix3().getNormalMatrix(matrix);
+      }
+      for (let i = 0, il = vertices2.length; i < il; i++) {
+        const vertex = vertices2[i];
+        const vertexCopy = vertex.clone();
+        if (matrix !== void 0)
+          vertexCopy.applyMatrix4(matrix);
+        vertices1.push(vertexCopy);
+      }
+      for (let i = 0, il = colors2.length; i < il; i++) {
+        colors1.push(colors2[i].clone());
+      }
+      for (let i = 0, il = faces2.length; i < il; i++) {
+        const face = faces2[i];
+        let normal, color;
+        const faceVertexNormals = face.vertexNormals, faceVertexColors = face.vertexColors;
+        const faceCopy = new Face3(face.a + vertexOffset, face.b + vertexOffset, face.c + vertexOffset);
+        faceCopy.normal.copy(face.normal);
+        if (normalMatrix !== void 0) {
+          faceCopy.normal.applyMatrix3(normalMatrix).normalize();
+        }
+        for (let j = 0, jl = faceVertexNormals.length; j < jl; j++) {
+          normal = faceVertexNormals[j].clone();
+          if (normalMatrix !== void 0) {
+            normal.applyMatrix3(normalMatrix).normalize();
+          }
+          faceCopy.vertexNormals.push(normal);
+        }
+        faceCopy.color.copy(face.color);
+        for (let j = 0, jl = faceVertexColors.length; j < jl; j++) {
+          color = faceVertexColors[j];
+          faceCopy.vertexColors.push(color.clone());
+        }
+        faceCopy.materialIndex = face.materialIndex + materialIndexOffset;
+        faces1.push(faceCopy);
+      }
+      for (let i = 0, il = geometry.faceVertexUvs.length; i < il; i++) {
+        const faceVertexUvs2 = geometry.faceVertexUvs[i];
+        if (this.faceVertexUvs[i] === void 0)
+          this.faceVertexUvs[i] = [];
+        for (let j = 0, jl = faceVertexUvs2.length; j < jl; j++) {
+          const uvs2 = faceVertexUvs2[j], uvsCopy = [];
+          for (let k = 0, kl = uvs2.length; k < kl; k++) {
+            uvsCopy.push(uvs2[k].clone());
+          }
+          this.faceVertexUvs[i].push(uvsCopy);
+        }
+      }
+    }
+    mergeMesh(mesh) {
+      if (!(mesh && mesh.isMesh)) {
+        console.error("THREE.Geometry.mergeMesh(): mesh not an instance of THREE.Mesh.", mesh);
+        return;
+      }
+      if (mesh.matrixAutoUpdate)
+        mesh.updateMatrix();
+      this.merge(mesh.geometry, mesh.matrix);
+    }
+    /*
+     * Checks for duplicate vertices with hashmap.
+     * Duplicated vertices are removed
+     * and faces' vertices are updated.
+     */
+    mergeVertices(precisionPoints = 4) {
+      const verticesMap = {};
+      const unique = [], changes = [];
+      const precision = Math.pow(10, precisionPoints);
+      for (let i = 0, il = this.vertices.length; i < il; i++) {
+        const v = this.vertices[i];
+        const key = `${Math.round(v.x * precision)}_${Math.round(v.y * precision)}_${Math.round(v.z * precision)}`;
+        if (verticesMap[key] === void 0) {
+          verticesMap[key] = i;
+          unique.push(this.vertices[i]);
+          changes[i] = unique.length - 1;
+        } else {
+          changes[i] = changes[verticesMap[key]];
+        }
+      }
+      const faceIndicesToRemove = [];
+      for (let i = 0, il = this.faces.length; i < il; i++) {
+        const face = this.faces[i];
+        face.a = changes[face.a];
+        face.b = changes[face.b];
+        face.c = changes[face.c];
+        const indices = [face.a, face.b, face.c];
+        for (let n = 0; n < 3; n++) {
+          if (indices[n] === indices[(n + 1) % 3]) {
+            faceIndicesToRemove.push(i);
+            break;
+          }
+        }
+      }
+      for (let i = faceIndicesToRemove.length - 1; i >= 0; i--) {
+        const idx = faceIndicesToRemove[i];
+        this.faces.splice(idx, 1);
+        for (let j = 0, jl = this.faceVertexUvs.length; j < jl; j++) {
+          this.faceVertexUvs[j].splice(idx, 1);
+        }
+      }
+      const diff = this.vertices.length - unique.length;
+      this.vertices = unique;
+      return diff;
+    }
+    setFromPoints(points) {
+      this.vertices = [];
+      for (let i = 0, l = points.length; i < l; i++) {
+        const point = points[i];
+        this.vertices.push(new Vector3(point.x, point.y, point.z || 0));
+      }
+      return this;
+    }
+    sortFacesByMaterialIndex() {
+      const faces = this.faces;
+      const length = faces.length;
+      for (let i = 0; i < length; i++) {
+        faces[i]._id = i;
+      }
+      function materialIndexSort(a, b) {
+        return a.materialIndex - b.materialIndex;
+      }
+      faces.sort(materialIndexSort);
+      const uvs1 = this.faceVertexUvs[0];
+      const uvs2 = this.faceVertexUvs[1];
+      let newUvs1, newUvs2;
+      if (uvs1 && uvs1.length === length)
+        newUvs1 = [];
+      if (uvs2 && uvs2.length === length)
+        newUvs2 = [];
+      for (let i = 0; i < length; i++) {
+        const id = faces[i]._id;
+        if (newUvs1)
+          newUvs1.push(uvs1[id]);
+        if (newUvs2)
+          newUvs2.push(uvs2[id]);
+      }
+      if (newUvs1)
+        this.faceVertexUvs[0] = newUvs1;
+      if (newUvs2)
+        this.faceVertexUvs[1] = newUvs2;
+    }
+    toJSON() {
+      const data = {
+        metadata: {
+          version: 4.5,
+          type: "Geometry",
+          generator: "Geometry.toJSON"
+        }
+      };
+      data.uuid = this.uuid;
+      data.type = this.type;
+      if (this.name !== "")
+        data.name = this.name;
+      if (this.parameters !== void 0) {
+        const parameters = this.parameters;
+        for (let key in parameters) {
+          if (parameters[key] !== void 0)
+            data[key] = parameters[key];
+        }
+        return data;
+      }
+      const vertices = [];
+      for (let i = 0; i < this.vertices.length; i++) {
+        const vertex = this.vertices[i];
+        vertices.push(vertex.x, vertex.y, vertex.z);
+      }
+      const faces = [];
+      const normals = [];
+      const normalsHash = {};
+      const colors = [];
+      const colorsHash = {};
+      const uvs = [];
+      const uvsHash = {};
+      for (let i = 0; i < this.faces.length; i++) {
+        const face = this.faces[i];
+        const hasMaterial = true;
+        const hasFaceUv = false;
+        const hasFaceVertexUv = this.faceVertexUvs[0][i] !== void 0;
+        const hasFaceNormal = face.normal.length() > 0;
+        const hasFaceVertexNormal = face.vertexNormals.length > 0;
+        const hasFaceColor = face.color.r !== 1 || face.color.g !== 1 || face.color.b !== 1;
+        const hasFaceVertexColor = face.vertexColors.length > 0;
+        let faceType = 0;
+        faceType = setBit(faceType, 0, 0);
+        faceType = setBit(faceType, 1, hasMaterial);
+        faceType = setBit(faceType, 2, hasFaceUv);
+        faceType = setBit(faceType, 3, hasFaceVertexUv);
+        faceType = setBit(faceType, 4, hasFaceNormal);
+        faceType = setBit(faceType, 5, hasFaceVertexNormal);
+        faceType = setBit(faceType, 6, hasFaceColor);
+        faceType = setBit(faceType, 7, hasFaceVertexColor);
+        faces.push(faceType);
+        faces.push(face.a, face.b, face.c);
+        faces.push(face.materialIndex);
+        if (hasFaceVertexUv) {
+          const faceVertexUvs = this.faceVertexUvs[0][i];
+          faces.push(getUvIndex(faceVertexUvs[0]), getUvIndex(faceVertexUvs[1]), getUvIndex(faceVertexUvs[2]));
+        }
+        if (hasFaceNormal) {
+          faces.push(getNormalIndex(face.normal));
+        }
+        if (hasFaceVertexNormal) {
+          const vertexNormals = face.vertexNormals;
+          faces.push(
+            getNormalIndex(vertexNormals[0]),
+            getNormalIndex(vertexNormals[1]),
+            getNormalIndex(vertexNormals[2])
+          );
+        }
+        if (hasFaceColor) {
+          faces.push(getColorIndex(face.color));
+        }
+        if (hasFaceVertexColor) {
+          const vertexColors = face.vertexColors;
+          faces.push(getColorIndex(vertexColors[0]), getColorIndex(vertexColors[1]), getColorIndex(vertexColors[2]));
+        }
+      }
+      function setBit(value, position, enabled) {
+        return enabled ? value | 1 << position : value & ~(1 << position);
+      }
+      function getNormalIndex(normal) {
+        const hash = normal.x.toString() + normal.y.toString() + normal.z.toString();
+        if (normalsHash[hash] !== void 0) {
+          return normalsHash[hash];
+        }
+        normalsHash[hash] = normals.length / 3;
+        normals.push(normal.x, normal.y, normal.z);
+        return normalsHash[hash];
+      }
+      function getColorIndex(color) {
+        const hash = color.r.toString() + color.g.toString() + color.b.toString();
+        if (colorsHash[hash] !== void 0) {
+          return colorsHash[hash];
+        }
+        colorsHash[hash] = colors.length;
+        colors.push(color.getHex());
+        return colorsHash[hash];
+      }
+      function getUvIndex(uv) {
+        const hash = uv.x.toString() + uv.y.toString();
+        if (uvsHash[hash] !== void 0) {
+          return uvsHash[hash];
+        }
+        uvsHash[hash] = uvs.length / 2;
+        uvs.push(uv.x, uv.y);
+        return uvsHash[hash];
+      }
+      data.data = {};
+      data.data.vertices = vertices;
+      data.data.normals = normals;
+      if (colors.length > 0)
+        data.data.colors = colors;
+      if (uvs.length > 0)
+        data.data.uvs = [uvs];
+      data.data.faces = faces;
+      return data;
+    }
+    clone() {
+      return new Geometry2().copy(this);
+    }
+    copy(source) {
+      this.vertices = [];
+      this.colors = [];
+      this.faces = [];
+      this.faceVertexUvs = [[]];
+      this.morphTargets = [];
+      this.morphNormals = [];
+      this.skinWeights = [];
+      this.skinIndices = [];
+      this.lineDistances = [];
+      this.boundingBox = null;
+      this.boundingSphere = null;
+      this.name = source.name;
+      const vertices = source.vertices;
+      for (let i = 0, il = vertices.length; i < il; i++) {
+        this.vertices.push(vertices[i].clone());
+      }
+      const colors = source.colors;
+      for (let i = 0, il = colors.length; i < il; i++) {
+        this.colors.push(colors[i].clone());
+      }
+      const faces = source.faces;
+      for (let i = 0, il = faces.length; i < il; i++) {
+        this.faces.push(faces[i].clone());
+      }
+      for (let i = 0, il = source.faceVertexUvs.length; i < il; i++) {
+        const faceVertexUvs = source.faceVertexUvs[i];
+        if (this.faceVertexUvs[i] === void 0) {
+          this.faceVertexUvs[i] = [];
+        }
+        for (let j = 0, jl = faceVertexUvs.length; j < jl; j++) {
+          const uvs = faceVertexUvs[j], uvsCopy = [];
+          for (let k = 0, kl = uvs.length; k < kl; k++) {
+            const uv = uvs[k];
+            uvsCopy.push(uv.clone());
+          }
+          this.faceVertexUvs[i].push(uvsCopy);
+        }
+      }
+      const morphTargets = source.morphTargets;
+      for (let i = 0, il = morphTargets.length; i < il; i++) {
+        const morphTarget = {};
+        morphTarget.name = morphTargets[i].name;
+        if (morphTargets[i].vertices !== void 0) {
+          morphTarget.vertices = [];
+          for (let j = 0, jl = morphTargets[i].vertices.length; j < jl; j++) {
+            morphTarget.vertices.push(morphTargets[i].vertices[j].clone());
+          }
+        }
+        if (morphTargets[i].normals !== void 0) {
+          morphTarget.normals = [];
+          for (let j = 0, jl = morphTargets[i].normals.length; j < jl; j++) {
+            morphTarget.normals.push(morphTargets[i].normals[j].clone());
+          }
+        }
+        this.morphTargets.push(morphTarget);
+      }
+      const morphNormals = source.morphNormals;
+      for (let i = 0, il = morphNormals.length; i < il; i++) {
+        const morphNormal = {};
+        if (morphNormals[i].vertexNormals !== void 0) {
+          morphNormal.vertexNormals = [];
+          for (let j = 0, jl = morphNormals[i].vertexNormals.length; j < jl; j++) {
+            const srcVertexNormal = morphNormals[i].vertexNormals[j];
+            const destVertexNormal = {};
+            destVertexNormal.a = srcVertexNormal.a.clone();
+            destVertexNormal.b = srcVertexNormal.b.clone();
+            destVertexNormal.c = srcVertexNormal.c.clone();
+            morphNormal.vertexNormals.push(destVertexNormal);
+          }
+        }
+        if (morphNormals[i].faceNormals !== void 0) {
+          morphNormal.faceNormals = [];
+          for (let j = 0, jl = morphNormals[i].faceNormals.length; j < jl; j++) {
+            morphNormal.faceNormals.push(morphNormals[i].faceNormals[j].clone());
+          }
+        }
+        this.morphNormals.push(morphNormal);
+      }
+      const skinWeights = source.skinWeights;
+      for (let i = 0, il = skinWeights.length; i < il; i++) {
+        this.skinWeights.push(skinWeights[i].clone());
+      }
+      const skinIndices = source.skinIndices;
+      for (let i = 0, il = skinIndices.length; i < il; i++) {
+        this.skinIndices.push(skinIndices[i].clone());
+      }
+      const lineDistances = source.lineDistances;
+      for (let i = 0, il = lineDistances.length; i < il; i++) {
+        this.lineDistances.push(lineDistances[i]);
+      }
+      const boundingBox = source.boundingBox;
+      if (boundingBox !== null) {
+        this.boundingBox = boundingBox.clone();
+      }
+      const boundingSphere = source.boundingSphere;
+      if (boundingSphere !== null) {
+        this.boundingSphere = boundingSphere.clone();
+      }
+      this.elementsNeedUpdate = source.elementsNeedUpdate;
+      this.verticesNeedUpdate = source.verticesNeedUpdate;
+      this.uvsNeedUpdate = source.uvsNeedUpdate;
+      this.normalsNeedUpdate = source.normalsNeedUpdate;
+      this.colorsNeedUpdate = source.colorsNeedUpdate;
+      this.lineDistancesNeedUpdate = source.lineDistancesNeedUpdate;
+      this.groupsNeedUpdate = source.groupsNeedUpdate;
+      return this;
+    }
+    toBufferGeometry() {
+      const geometry = new DirectGeometry().fromGeometry(this);
+      const buffergeometry = new BufferGeometry();
+      const positions = new Float32Array(geometry.vertices.length * 3);
+      buffergeometry.setAttribute("position", new BufferAttribute(positions, 3).copyVector3sArray(geometry.vertices));
+      if (geometry.normals.length > 0) {
+        const normals = new Float32Array(geometry.normals.length * 3);
+        buffergeometry.setAttribute("normal", new BufferAttribute(normals, 3).copyVector3sArray(geometry.normals));
+      }
+      if (geometry.colors.length > 0) {
+        const colors = new Float32Array(geometry.colors.length * 3);
+        buffergeometry.setAttribute("color", new BufferAttribute(colors, 3).copyColorsArray(geometry.colors));
+      }
+      if (geometry.uvs.length > 0) {
+        const uvs = new Float32Array(geometry.uvs.length * 2);
+        buffergeometry.setAttribute("uv", new BufferAttribute(uvs, 2).copyVector2sArray(geometry.uvs));
+      }
+      if (geometry.uvs2.length > 0) {
+        const uvs2 = new Float32Array(geometry.uvs2.length * 2);
+        buffergeometry.setAttribute("uv2", new BufferAttribute(uvs2, 2).copyVector2sArray(geometry.uvs2));
+      }
+      buffergeometry.groups = geometry.groups;
+      for (let name in geometry.morphTargets) {
+        const array = [];
+        const morphTargets = geometry.morphTargets[name];
+        for (let i = 0, l = morphTargets.length; i < l; i++) {
+          const morphTarget = morphTargets[i];
+          const attribute = new Float32BufferAttribute(morphTarget.data.length * 3, 3);
+          attribute.name = morphTarget.name;
+          array.push(attribute.copyVector3sArray(morphTarget.data));
+        }
+        buffergeometry.morphAttributes[name] = array;
+      }
+      if (geometry.skinIndices.length > 0) {
+        const skinIndices = new Float32BufferAttribute(geometry.skinIndices.length * 4, 4);
+        buffergeometry.setAttribute("skinIndex", skinIndices.copyVector4sArray(geometry.skinIndices));
+      }
+      if (geometry.skinWeights.length > 0) {
+        const skinWeights = new Float32BufferAttribute(geometry.skinWeights.length * 4, 4);
+        buffergeometry.setAttribute("skinWeight", skinWeights.copyVector4sArray(geometry.skinWeights));
+      }
+      if (geometry.boundingSphere !== null) {
+        buffergeometry.boundingSphere = geometry.boundingSphere.clone();
+      }
+      if (geometry.boundingBox !== null) {
+        buffergeometry.boundingBox = geometry.boundingBox.clone();
+      }
+      return buffergeometry;
+    }
+    computeTangents() {
+      console.error("THREE.Geometry: .computeTangents() has been removed.");
+    }
+    computeLineDistances() {
+      console.error(
+        "THREE.Geometry: .computeLineDistances() has been removed. Use THREE.Line.computeLineDistances() instead."
+      );
+    }
+    applyMatrix(matrix) {
+      console.warn("THREE.Geometry: .applyMatrix() has been renamed to .applyMatrix4().");
+      return this.applyMatrix4(matrix);
+    }
+    dispose() {
+      this.dispatchEvent({ type: "dispose" });
+    }
+  }
+  return Geometry2;
+})();
+class DirectGeometry {
+  constructor() {
+    this.vertices = [];
+    this.normals = [];
+    this.colors = [];
+    this.uvs = [];
+    this.uvs2 = [];
+    this.groups = [];
+    this.morphTargets = {};
+    this.skinWeights = [];
+    this.skinIndices = [];
+    this.boundingBox = null;
+    this.boundingSphere = null;
+    this.verticesNeedUpdate = false;
+    this.normalsNeedUpdate = false;
+    this.colorsNeedUpdate = false;
+    this.uvsNeedUpdate = false;
+    this.groupsNeedUpdate = false;
+  }
+  computeGroups(geometry) {
+    const groups = [];
+    let group, i;
+    let materialIndex = void 0;
+    const faces = geometry.faces;
+    for (i = 0; i < faces.length; i++) {
+      const face = faces[i];
+      if (face.materialIndex !== materialIndex) {
+        materialIndex = face.materialIndex;
+        if (group !== void 0) {
+          group.count = i * 3 - group.start;
+          groups.push(group);
+        }
+        group = {
+          start: i * 3,
+          materialIndex
+        };
+      }
+    }
+    if (group !== void 0) {
+      group.count = i * 3 - group.start;
+      groups.push(group);
+    }
+    this.groups = groups;
+  }
+  fromGeometry(geometry) {
+    const faces = geometry.faces;
+    const vertices = geometry.vertices;
+    const faceVertexUvs = geometry.faceVertexUvs;
+    const hasFaceVertexUv = faceVertexUvs[0] && faceVertexUvs[0].length > 0;
+    const hasFaceVertexUv2 = faceVertexUvs[1] && faceVertexUvs[1].length > 0;
+    const morphTargets = geometry.morphTargets;
+    const morphTargetsLength = morphTargets.length;
+    let morphTargetsPosition;
+    if (morphTargetsLength > 0) {
+      morphTargetsPosition = [];
+      for (let i = 0; i < morphTargetsLength; i++) {
+        morphTargetsPosition[i] = {
+          name: morphTargets[i].name,
+          data: []
+        };
+      }
+      this.morphTargets.position = morphTargetsPosition;
+    }
+    const morphNormals = geometry.morphNormals;
+    const morphNormalsLength = morphNormals.length;
+    let morphTargetsNormal;
+    if (morphNormalsLength > 0) {
+      morphTargetsNormal = [];
+      for (let i = 0; i < morphNormalsLength; i++) {
+        morphTargetsNormal[i] = {
+          name: morphNormals[i].name,
+          data: []
+        };
+      }
+      this.morphTargets.normal = morphTargetsNormal;
+    }
+    const skinIndices = geometry.skinIndices;
+    const skinWeights = geometry.skinWeights;
+    const hasSkinIndices = skinIndices.length === vertices.length;
+    const hasSkinWeights = skinWeights.length === vertices.length;
+    if (vertices.length > 0 && faces.length === 0) {
+      console.error("THREE.DirectGeometry: Faceless geometries are not supported.");
+    }
+    for (let i = 0; i < faces.length; i++) {
+      const face = faces[i];
+      this.vertices.push(vertices[face.a], vertices[face.b], vertices[face.c]);
+      const vertexNormals = face.vertexNormals;
+      if (vertexNormals.length === 3) {
+        this.normals.push(vertexNormals[0], vertexNormals[1], vertexNormals[2]);
+      } else {
+        const normal = face.normal;
+        this.normals.push(normal, normal, normal);
+      }
+      const vertexColors = face.vertexColors;
+      if (vertexColors.length === 3) {
+        this.colors.push(vertexColors[0], vertexColors[1], vertexColors[2]);
+      } else {
+        const color = face.color;
+        this.colors.push(color, color, color);
+      }
+      if (hasFaceVertexUv === true) {
+        const vertexUvs = faceVertexUvs[0][i];
+        if (vertexUvs !== void 0) {
+          this.uvs.push(vertexUvs[0], vertexUvs[1], vertexUvs[2]);
+        } else {
+          console.warn("THREE.DirectGeometry.fromGeometry(): Undefined vertexUv ", i);
+          this.uvs.push(new Vector2(), new Vector2(), new Vector2());
+        }
+      }
+      if (hasFaceVertexUv2 === true) {
+        const vertexUvs = faceVertexUvs[1][i];
+        if (vertexUvs !== void 0) {
+          this.uvs2.push(vertexUvs[0], vertexUvs[1], vertexUvs[2]);
+        } else {
+          console.warn("THREE.DirectGeometry.fromGeometry(): Undefined vertexUv2 ", i);
+          this.uvs2.push(new Vector2(), new Vector2(), new Vector2());
+        }
+      }
+      for (let j = 0; j < morphTargetsLength; j++) {
+        const morphTarget = morphTargets[j].vertices;
+        morphTargetsPosition[j].data.push(morphTarget[face.a], morphTarget[face.b], morphTarget[face.c]);
+      }
+      for (let j = 0; j < morphNormalsLength; j++) {
+        const morphNormal = morphNormals[j].vertexNormals[i];
+        morphTargetsNormal[j].data.push(morphNormal.a, morphNormal.b, morphNormal.c);
+      }
+      if (hasSkinIndices) {
+        this.skinIndices.push(skinIndices[face.a], skinIndices[face.b], skinIndices[face.c]);
+      }
+      if (hasSkinWeights) {
+        this.skinWeights.push(skinWeights[face.a], skinWeights[face.b], skinWeights[face.c]);
+      }
+    }
+    this.computeGroups(geometry);
+    this.verticesNeedUpdate = geometry.verticesNeedUpdate;
+    this.normalsNeedUpdate = geometry.normalsNeedUpdate;
+    this.colorsNeedUpdate = geometry.colorsNeedUpdate;
+    this.uvsNeedUpdate = geometry.uvsNeedUpdate;
+    this.groupsNeedUpdate = geometry.groupsNeedUpdate;
+    if (geometry.boundingSphere !== null) {
+      this.boundingSphere = geometry.boundingSphere.clone();
+    }
+    if (geometry.boundingBox !== null) {
+      this.boundingBox = geometry.boundingBox.clone();
+    }
+    return this;
+  }
+}
+class Face3 {
+  constructor(a, b, c, normal, color, materialIndex = 0) {
+    this.a = a;
+    this.b = b;
+    this.c = c;
+    this.normal = normal && normal.isVector3 ? normal : new Vector3();
+    this.vertexNormals = Array.isArray(normal) ? normal : [];
+    this.color = color && color.isColor ? color : new Color();
+    this.vertexColors = Array.isArray(color) ? color : [];
+    this.materialIndex = materialIndex;
+  }
+  clone() {
+    return new this.constructor().copy(this);
+  }
+  copy(source) {
+    this.a = source.a;
+    this.b = source.b;
+    this.c = source.c;
+    this.normal.copy(source.normal);
+    this.color.copy(source.color);
+    this.materialIndex = source.materialIndex;
+    for (let i = 0, il = source.vertexNormals.length; i < il; i++) {
+      this.vertexNormals[i] = source.vertexNormals[i].clone();
+    }
+    for (let i = 0, il = source.vertexColors.length; i < il; i++) {
+      this.vertexColors[i] = source.vertexColors[i].clone();
+    }
+    return this;
+  }
+}
+export {
+  Face3,
+  Geometry
+};
+//# sourceMappingURL=Geometry.js.map