three-stdlib 2.22.10 → 2.23.1

package/dist/loaders/{OBJLoader.mjs → OBJLoader.cjs}

@@ -1,13 +1,15 @@
-import { Vector3, Loader, FileLoader, Group, BufferGeometry, Float32BufferAttribute, LineBasicMaterial, Material, PointsMaterial, MeshPhongMaterial, LineSegments, Points, Mesh } from "three";
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
 const _object_pattern = /^[og]\s*(.+)?/;
 const _material_library_pattern = /^mtllib /;
 const _material_use_pattern = /^usemtl /;
 const _map_use_pattern = /^usemap /;
-const _vA = /* @__PURE__ */ new Vector3();
-const _vB = /* @__PURE__ */ new Vector3();
-const _vC = /* @__PURE__ */ new Vector3();
-const _ab = /* @__PURE__ */ new Vector3();
-const _cb = /* @__PURE__ */ new Vector3();
+const _vA = /* @__PURE__ */ new THREE.Vector3();
+const _vB = /* @__PURE__ */ new THREE.Vector3();
+const _vC = /* @__PURE__ */ new THREE.Vector3();
+const _ab = /* @__PURE__ */ new THREE.Vector3();
+const _cb = /* @__PURE__ */ new THREE.Vector3();
 function ParserState() {
   const state = {
     objects: [],
@@ -242,14 +244,14 @@ function ParserState() {
   state.startObject("", false);
   return state;
 }
-class OBJLoader extends Loader {
+class OBJLoader extends THREE.Loader {
   constructor(manager) {
     super(manager);
     this.materials = null;
   }
   load(url, onLoad, onProgress, onError) {
     const scope = this;
-    const loader = new FileLoader(this.manager);
+    const loader = new THREE.FileLoader(this.manager);
     loader.setPath(this.path);
     loader.setRequestHeader(this.requestHeader);
     loader.setWithCredentials(this.withCredentials);
@@ -381,7 +383,7 @@ class OBJLoader extends Loader {
       }
     }
     state.finalize();
-    const container = new Group();
+    const container = new THREE.Group();
     container.materialLibraries = [].concat(state.materialLibraries);
     const hasPrimitives = !(state.objects.length === 1 && state.objects[0].geometry.vertices.length === 0);
     if (hasPrimitives === true) {
@@ -394,17 +396,17 @@ class OBJLoader extends Loader {
         let hasVertexColors = false;
         if (geometry.vertices.length === 0)
           continue;
-        const buffergeometry = new BufferGeometry();
-        buffergeometry.setAttribute("position", new Float32BufferAttribute(geometry.vertices, 3));
+        const buffergeometry = new THREE.BufferGeometry();
+        buffergeometry.setAttribute("position", new THREE.Float32BufferAttribute(geometry.vertices, 3));
         if (geometry.normals.length > 0) {
-          buffergeometry.setAttribute("normal", new Float32BufferAttribute(geometry.normals, 3));
+          buffergeometry.setAttribute("normal", new THREE.Float32BufferAttribute(geometry.normals, 3));
         }
         if (geometry.colors.length > 0) {
           hasVertexColors = true;
-          buffergeometry.setAttribute("color", new Float32BufferAttribute(geometry.colors, 3));
+          buffergeometry.setAttribute("color", new THREE.Float32BufferAttribute(geometry.colors, 3));
         }
         if (geometry.hasUVIndices === true) {
-          buffergeometry.setAttribute("uv", new Float32BufferAttribute(geometry.uvs, 2));
+          buffergeometry.setAttribute("uv", new THREE.Float32BufferAttribute(geometry.uvs, 2));
         }
         const createdMaterials = [];
         for (let mi = 0, miLen = materials.length; mi < miLen; mi++) {
@@ -413,14 +415,14 @@ class OBJLoader extends Loader {
           let material = state.materials[materialHash];
           if (this.materials !== null) {
             material = this.materials.create(sourceMaterial.name);
-            if (isLine && material && !(material instanceof LineBasicMaterial)) {
-              const materialLine = new LineBasicMaterial();
-              Material.prototype.copy.call(materialLine, material);
+            if (isLine && material && !(material instanceof THREE.LineBasicMaterial)) {
+              const materialLine = new THREE.LineBasicMaterial();
+              THREE.Material.prototype.copy.call(materialLine, material);
               materialLine.color.copy(material.color);
               material = materialLine;
-            } else if (isPoints && material && !(material instanceof PointsMaterial)) {
-              const materialPoints = new PointsMaterial({ size: 10, sizeAttenuation: false });
-              Material.prototype.copy.call(materialPoints, material);
+            } else if (isPoints && material && !(material instanceof THREE.PointsMaterial)) {
+              const materialPoints = new THREE.PointsMaterial({ size: 10, sizeAttenuation: false });
+              THREE.Material.prototype.copy.call(materialPoints, material);
               materialPoints.color.copy(material.color);
               materialPoints.map = material.map;
               material = materialPoints;
@@ -428,11 +430,11 @@ class OBJLoader extends Loader {
           }
           if (material === void 0) {
             if (isLine) {
-              material = new LineBasicMaterial();
+              material = new THREE.LineBasicMaterial();
             } else if (isPoints) {
-              material = new PointsMaterial({ size: 1, sizeAttenuation: false });
+              material = new THREE.PointsMaterial({ size: 1, sizeAttenuation: false });
             } else {
-              material = new MeshPhongMaterial();
+              material = new THREE.MeshPhongMaterial();
             }
             material.name = sourceMaterial.name;
             material.flatShading = sourceMaterial.smooth ? false : true;
@@ -448,19 +450,19 @@ class OBJLoader extends Loader {
             buffergeometry.addGroup(sourceMaterial.groupStart, sourceMaterial.groupCount, mi);
           }
           if (isLine) {
-            mesh = new LineSegments(buffergeometry, createdMaterials);
+            mesh = new THREE.LineSegments(buffergeometry, createdMaterials);
           } else if (isPoints) {
-            mesh = new Points(buffergeometry, createdMaterials);
+            mesh = new THREE.Points(buffergeometry, createdMaterials);
           } else {
-            mesh = new Mesh(buffergeometry, createdMaterials);
+            mesh = new THREE.Mesh(buffergeometry, createdMaterials);
           }
         } else {
           if (isLine) {
-            mesh = new LineSegments(buffergeometry, createdMaterials[0]);
+            mesh = new THREE.LineSegments(buffergeometry, createdMaterials[0]);
           } else if (isPoints) {
-            mesh = new Points(buffergeometry, createdMaterials[0]);
+            mesh = new THREE.Points(buffergeometry, createdMaterials[0]);
           } else {
-            mesh = new Mesh(buffergeometry, createdMaterials[0]);
+            mesh = new THREE.Mesh(buffergeometry, createdMaterials[0]);
           }
         }
         mesh.name = object.name;
@@ -468,20 +470,18 @@ class OBJLoader extends Loader {
       }
     } else {
       if (state.vertices.length > 0) {
-        const material = new PointsMaterial({ size: 1, sizeAttenuation: false });
-        const buffergeometry = new BufferGeometry();
-        buffergeometry.setAttribute("position", new Float32BufferAttribute(state.vertices, 3));
+        const material = new THREE.PointsMaterial({ size: 1, sizeAttenuation: false });
+        const buffergeometry = new THREE.BufferGeometry();
+        buffergeometry.setAttribute("position", new THREE.Float32BufferAttribute(state.vertices, 3));
         if (state.colors.length > 0 && state.colors[0] !== void 0) {
-          buffergeometry.setAttribute("color", new Float32BufferAttribute(state.colors, 3));
+          buffergeometry.setAttribute("color", new THREE.Float32BufferAttribute(state.colors, 3));
           material.vertexColors = true;
         }
-        const points = new Points(buffergeometry, material);
+        const points = new THREE.Points(buffergeometry, material);
         container.add(points);
       }
     }
     return container;
   }
 }
-export {
-  OBJLoader
-};
+exports.OBJLoader = OBJLoader;

package/dist/loaders/OBJLoader.js

@@ -1,15 +1,13 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const THREE = require("three");
+import { Vector3, Loader, FileLoader, Group, BufferGeometry, Float32BufferAttribute, LineBasicMaterial, Material, PointsMaterial, MeshPhongMaterial, LineSegments, Points, Mesh } from "three";
 const _object_pattern = /^[og]\s*(.+)?/;
 const _material_library_pattern = /^mtllib /;
 const _material_use_pattern = /^usemtl /;
 const _map_use_pattern = /^usemap /;
-const _vA = /* @__PURE__ */ new THREE.Vector3();
-const _vB = /* @__PURE__ */ new THREE.Vector3();
-const _vC = /* @__PURE__ */ new THREE.Vector3();
-const _ab = /* @__PURE__ */ new THREE.Vector3();
-const _cb = /* @__PURE__ */ new THREE.Vector3();
+const _vA = /* @__PURE__ */ new Vector3();
+const _vB = /* @__PURE__ */ new Vector3();
+const _vC = /* @__PURE__ */ new Vector3();
+const _ab = /* @__PURE__ */ new Vector3();
+const _cb = /* @__PURE__ */ new Vector3();
 function ParserState() {
   const state = {
     objects: [],
@@ -244,14 +242,14 @@ function ParserState() {
   state.startObject("", false);
   return state;
 }
-class OBJLoader extends THREE.Loader {
+class OBJLoader extends Loader {
   constructor(manager) {
     super(manager);
     this.materials = null;
   }
   load(url, onLoad, onProgress, onError) {
     const scope = this;
-    const loader = new THREE.FileLoader(this.manager);
+    const loader = new FileLoader(this.manager);
     loader.setPath(this.path);
     loader.setRequestHeader(this.requestHeader);
     loader.setWithCredentials(this.withCredentials);
@@ -383,7 +381,7 @@ class OBJLoader extends THREE.Loader {
       }
     }
     state.finalize();
-    const container = new THREE.Group();
+    const container = new Group();
     container.materialLibraries = [].concat(state.materialLibraries);
     const hasPrimitives = !(state.objects.length === 1 && state.objects[0].geometry.vertices.length === 0);
     if (hasPrimitives === true) {
@@ -396,17 +394,17 @@ class OBJLoader extends THREE.Loader {
         let hasVertexColors = false;
         if (geometry.vertices.length === 0)
           continue;
-        const buffergeometry = new THREE.BufferGeometry();
-        buffergeometry.setAttribute("position", new THREE.Float32BufferAttribute(geometry.vertices, 3));
+        const buffergeometry = new BufferGeometry();
+        buffergeometry.setAttribute("position", new Float32BufferAttribute(geometry.vertices, 3));
         if (geometry.normals.length > 0) {
-          buffergeometry.setAttribute("normal", new THREE.Float32BufferAttribute(geometry.normals, 3));
+          buffergeometry.setAttribute("normal", new Float32BufferAttribute(geometry.normals, 3));
         }
         if (geometry.colors.length > 0) {
           hasVertexColors = true;
-          buffergeometry.setAttribute("color", new THREE.Float32BufferAttribute(geometry.colors, 3));
+          buffergeometry.setAttribute("color", new Float32BufferAttribute(geometry.colors, 3));
         }
         if (geometry.hasUVIndices === true) {
-          buffergeometry.setAttribute("uv", new THREE.Float32BufferAttribute(geometry.uvs, 2));
+          buffergeometry.setAttribute("uv", new Float32BufferAttribute(geometry.uvs, 2));
         }
         const createdMaterials = [];
         for (let mi = 0, miLen = materials.length; mi < miLen; mi++) {
@@ -415,14 +413,14 @@ class OBJLoader extends THREE.Loader {
           let material = state.materials[materialHash];
           if (this.materials !== null) {
             material = this.materials.create(sourceMaterial.name);
-            if (isLine && material && !(material instanceof THREE.LineBasicMaterial)) {
-              const materialLine = new THREE.LineBasicMaterial();
-              THREE.Material.prototype.copy.call(materialLine, material);
+            if (isLine && material && !(material instanceof LineBasicMaterial)) {
+              const materialLine = new LineBasicMaterial();
+              Material.prototype.copy.call(materialLine, material);
               materialLine.color.copy(material.color);
               material = materialLine;
-            } else if (isPoints && material && !(material instanceof THREE.PointsMaterial)) {
-              const materialPoints = new THREE.PointsMaterial({ size: 10, sizeAttenuation: false });
-              THREE.Material.prototype.copy.call(materialPoints, material);
+            } else if (isPoints && material && !(material instanceof PointsMaterial)) {
+              const materialPoints = new PointsMaterial({ size: 10, sizeAttenuation: false });
+              Material.prototype.copy.call(materialPoints, material);
               materialPoints.color.copy(material.color);
               materialPoints.map = material.map;
               material = materialPoints;
@@ -430,11 +428,11 @@ class OBJLoader extends THREE.Loader {
           }
           if (material === void 0) {
             if (isLine) {
-              material = new THREE.LineBasicMaterial();
+              material = new LineBasicMaterial();
             } else if (isPoints) {
-              material = new THREE.PointsMaterial({ size: 1, sizeAttenuation: false });
+              material = new PointsMaterial({ size: 1, sizeAttenuation: false });
             } else {
-              material = new THREE.MeshPhongMaterial();
+              material = new MeshPhongMaterial();
             }
             material.name = sourceMaterial.name;
             material.flatShading = sourceMaterial.smooth ? false : true;
@@ -450,19 +448,19 @@ class OBJLoader extends THREE.Loader {
             buffergeometry.addGroup(sourceMaterial.groupStart, sourceMaterial.groupCount, mi);
           }
           if (isLine) {
-            mesh = new THREE.LineSegments(buffergeometry, createdMaterials);
+            mesh = new LineSegments(buffergeometry, createdMaterials);
           } else if (isPoints) {
-            mesh = new THREE.Points(buffergeometry, createdMaterials);
+            mesh = new Points(buffergeometry, createdMaterials);
           } else {
-            mesh = new THREE.Mesh(buffergeometry, createdMaterials);
+            mesh = new Mesh(buffergeometry, createdMaterials);
           }
         } else {
           if (isLine) {
-            mesh = new THREE.LineSegments(buffergeometry, createdMaterials[0]);
+            mesh = new LineSegments(buffergeometry, createdMaterials[0]);
           } else if (isPoints) {
-            mesh = new THREE.Points(buffergeometry, createdMaterials[0]);
+            mesh = new Points(buffergeometry, createdMaterials[0]);
           } else {
-            mesh = new THREE.Mesh(buffergeometry, createdMaterials[0]);
+            mesh = new Mesh(buffergeometry, createdMaterials[0]);
           }
         }
         mesh.name = object.name;
@@ -470,18 +468,20 @@ class OBJLoader extends THREE.Loader {
       }
     } else {
       if (state.vertices.length > 0) {
-        const material = new THREE.PointsMaterial({ size: 1, sizeAttenuation: false });
-        const buffergeometry = new THREE.BufferGeometry();
-        buffergeometry.setAttribute("position", new THREE.Float32BufferAttribute(state.vertices, 3));
+        const material = new PointsMaterial({ size: 1, sizeAttenuation: false });
+        const buffergeometry = new BufferGeometry();
+        buffergeometry.setAttribute("position", new Float32BufferAttribute(state.vertices, 3));
         if (state.colors.length > 0 && state.colors[0] !== void 0) {
-          buffergeometry.setAttribute("color", new THREE.Float32BufferAttribute(state.colors, 3));
+          buffergeometry.setAttribute("color", new Float32BufferAttribute(state.colors, 3));
           material.vertexColors = true;
         }
-        const points = new THREE.Points(buffergeometry, material);
+        const points = new Points(buffergeometry, material);
         container.add(points);
       }
     }
     return container;
   }
 }
-exports.OBJLoader = OBJLoader;
+export {
+  OBJLoader
+};

package/dist/loaders/{PCDLoader.mjs → PCDLoader.cjs}

@@ -1,12 +1,14 @@
-import { Loader, FileLoader, LoaderUtils, BufferGeometry, Float32BufferAttribute, PointsMaterial, Points } from "three";
-class PCDLoader extends Loader {
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+class PCDLoader extends THREE.Loader {
   constructor(manager) {
     super(manager);
     this.littleEndian = true;
   }
   load(url, onLoad, onProgress, onError) {
     const scope = this;
-    const loader = new FileLoader(scope.manager);
+    const loader = new THREE.FileLoader(scope.manager);
     loader.setPath(scope.path);
     loader.setResponseType("arraybuffer");
     loader.setRequestHeader(scope.requestHeader);
@@ -134,7 +136,7 @@ class PCDLoader extends Loader {
       PCDheader2.rowSize = sizeSum;
       return PCDheader2;
     }
-    const textData = LoaderUtils.decodeText(new Uint8Array(data));
+    const textData = THREE.LoaderUtils.decodeText(new Uint8Array(data));
     const PCDheader = parseHeader(textData);
     const position = [];
     const normal = [];
@@ -221,21 +223,21 @@ class PCDLoader extends Loader {
         }
       }
     }
-    const geometry = new BufferGeometry();
+    const geometry = new THREE.BufferGeometry();
     if (position.length > 0)
-      geometry.setAttribute("position", new Float32BufferAttribute(position, 3));
+      geometry.setAttribute("position", new THREE.Float32BufferAttribute(position, 3));
     if (normal.length > 0)
-      geometry.setAttribute("normal", new Float32BufferAttribute(normal, 3));
+      geometry.setAttribute("normal", new THREE.Float32BufferAttribute(normal, 3));
     if (color.length > 0)
-      geometry.setAttribute("color", new Float32BufferAttribute(color, 3));
+      geometry.setAttribute("color", new THREE.Float32BufferAttribute(color, 3));
     geometry.computeBoundingSphere();
-    const material = new PointsMaterial({ size: 5e-3 });
+    const material = new THREE.PointsMaterial({ size: 5e-3 });
     if (color.length > 0) {
       material.vertexColors = true;
     } else {
       material.color.setHex(Math.random() * 16777215);
     }
-    const mesh = new Points(geometry, material);
+    const mesh = new THREE.Points(geometry, material);
     let name = url.split("").reverse().join("");
     name = /([^\/]*)/.exec(name);
     name = name[1].split("").reverse().join("");
@@ -243,6 +245,4 @@ class PCDLoader extends Loader {
     return mesh;
   }
 }
-export {
-  PCDLoader
-};
+exports.PCDLoader = PCDLoader;

package/dist/loaders/PCDLoader.js

@@ -1,14 +1,12 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const THREE = require("three");
-class PCDLoader extends THREE.Loader {
+import { Loader, FileLoader, LoaderUtils, BufferGeometry, Float32BufferAttribute, PointsMaterial, Points } from "three";
+class PCDLoader extends Loader {
   constructor(manager) {
     super(manager);
     this.littleEndian = true;
   }
   load(url, onLoad, onProgress, onError) {
     const scope = this;
-    const loader = new THREE.FileLoader(scope.manager);
+    const loader = new FileLoader(scope.manager);
     loader.setPath(scope.path);
     loader.setResponseType("arraybuffer");
     loader.setRequestHeader(scope.requestHeader);
@@ -136,7 +134,7 @@ class PCDLoader extends THREE.Loader {
       PCDheader2.rowSize = sizeSum;
       return PCDheader2;
     }
-    const textData = THREE.LoaderUtils.decodeText(new Uint8Array(data));
+    const textData = LoaderUtils.decodeText(new Uint8Array(data));
     const PCDheader = parseHeader(textData);
     const position = [];
     const normal = [];
@@ -223,21 +221,21 @@ class PCDLoader extends THREE.Loader {
         }
       }
     }
-    const geometry = new THREE.BufferGeometry();
+    const geometry = new BufferGeometry();
     if (position.length > 0)
-      geometry.setAttribute("position", new THREE.Float32BufferAttribute(position, 3));
+      geometry.setAttribute("position", new Float32BufferAttribute(position, 3));
     if (normal.length > 0)
-      geometry.setAttribute("normal", new THREE.Float32BufferAttribute(normal, 3));
+      geometry.setAttribute("normal", new Float32BufferAttribute(normal, 3));
     if (color.length > 0)
-      geometry.setAttribute("color", new THREE.Float32BufferAttribute(color, 3));
+      geometry.setAttribute("color", new Float32BufferAttribute(color, 3));
     geometry.computeBoundingSphere();
-    const material = new THREE.PointsMaterial({ size: 5e-3 });
+    const material = new PointsMaterial({ size: 5e-3 });
     if (color.length > 0) {
       material.vertexColors = true;
     } else {
       material.color.setHex(Math.random() * 16777215);
     }
-    const mesh = new THREE.Points(geometry, material);
+    const mesh = new Points(geometry, material);
     let name = url.split("").reverse().join("");
     name = /([^\/]*)/.exec(name);
     name = name[1].split("").reverse().join("");
@@ -245,4 +243,6 @@ class PCDLoader extends THREE.Loader {
     return mesh;
   }
 }
-exports.PCDLoader = PCDLoader;
+export {
+  PCDLoader
+};

package/dist/loaders/{PDBLoader.mjs → PDBLoader.cjs}

@@ -1,11 +1,13 @@
-import { Loader, FileLoader, BufferGeometry, Float32BufferAttribute } from "three";
-class PDBLoader extends Loader {
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+class PDBLoader extends THREE.Loader {
   constructor(manager) {
     super(manager);
   }
   load(url, onLoad, onProgress, onError) {
     const scope = this;
-    const loader = new FileLoader(scope.manager);
+    const loader = new THREE.FileLoader(scope.manager);
     loader.setPath(scope.path);
     loader.setRequestHeader(scope.requestHeader);
     loader.setWithCredentials(scope.withCredentials);
@@ -51,8 +53,8 @@ class PDBLoader extends Loader {
     }
     function buildGeometry() {
       const build = {
-        geometryAtoms: new BufferGeometry(),
-        geometryBonds: new BufferGeometry(),
+        geometryAtoms: new THREE.BufferGeometry(),
+        geometryBonds: new THREE.BufferGeometry(),
         json: {
           atoms
         }
@@ -88,9 +90,9 @@ class PDBLoader extends Loader {
         z = endAtom[2];
         verticesBonds.push(x, y, z);
       }
-      geometryAtoms.setAttribute("position", new Float32BufferAttribute(verticesAtoms, 3));
-      geometryAtoms.setAttribute("color", new Float32BufferAttribute(colorsAtoms, 3));
-      geometryBonds.setAttribute("position", new Float32BufferAttribute(verticesBonds, 3));
+      geometryAtoms.setAttribute("position", new THREE.Float32BufferAttribute(verticesAtoms, 3));
+      geometryAtoms.setAttribute("color", new THREE.Float32BufferAttribute(colorsAtoms, 3));
+      geometryBonds.setAttribute("position", new THREE.Float32BufferAttribute(verticesBonds, 3));
       return build;
     }
     const CPK = {
@@ -242,6 +244,4 @@ class PDBLoader extends Loader {
     return buildGeometry();
   }
 }
-export {
-  PDBLoader
-};
+exports.PDBLoader = PDBLoader;

package/dist/loaders/PDBLoader.js

@@ -1,13 +1,11 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const THREE = require("three");
-class PDBLoader extends THREE.Loader {
+import { Loader, FileLoader, BufferGeometry, Float32BufferAttribute } from "three";
+class PDBLoader extends Loader {
   constructor(manager) {
     super(manager);
   }
   load(url, onLoad, onProgress, onError) {
     const scope = this;
-    const loader = new THREE.FileLoader(scope.manager);
+    const loader = new FileLoader(scope.manager);
     loader.setPath(scope.path);
     loader.setRequestHeader(scope.requestHeader);
     loader.setWithCredentials(scope.withCredentials);
@@ -53,8 +51,8 @@ class PDBLoader extends THREE.Loader {
     }
     function buildGeometry() {
       const build = {
-        geometryAtoms: new THREE.BufferGeometry(),
-        geometryBonds: new THREE.BufferGeometry(),
+        geometryAtoms: new BufferGeometry(),
+        geometryBonds: new BufferGeometry(),
         json: {
           atoms
         }
@@ -90,9 +88,9 @@ class PDBLoader extends THREE.Loader {
         z = endAtom[2];
         verticesBonds.push(x, y, z);
       }
-      geometryAtoms.setAttribute("position", new THREE.Float32BufferAttribute(verticesAtoms, 3));
-      geometryAtoms.setAttribute("color", new THREE.Float32BufferAttribute(colorsAtoms, 3));
-      geometryBonds.setAttribute("position", new THREE.Float32BufferAttribute(verticesBonds, 3));
+      geometryAtoms.setAttribute("position", new Float32BufferAttribute(verticesAtoms, 3));
+      geometryAtoms.setAttribute("color", new Float32BufferAttribute(colorsAtoms, 3));
+      geometryBonds.setAttribute("position", new Float32BufferAttribute(verticesBonds, 3));
       return build;
     }
     const CPK = {
@@ -244,4 +242,6 @@ class PDBLoader extends THREE.Loader {
     return buildGeometry();
   }
 }
-exports.PDBLoader = PDBLoader;
+export {
+  PDBLoader
+};

package/dist/loaders/{PLYLoader.mjs → PLYLoader.cjs}

@@ -1,12 +1,14 @@
-import { Loader, FileLoader, BufferGeometry, Float32BufferAttribute, LoaderUtils } from "three";
-class PLYLoader extends Loader {
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+class PLYLoader extends THREE.Loader {
   constructor(manager) {
     super(manager);
     this.propertyNameMapping = {};
   }
   load(url, onLoad, onProgress, onError) {
     const scope = this;
-    const loader = new FileLoader(this.manager);
+    const loader = new THREE.FileLoader(this.manager);
     loader.setPath(this.path);
     loader.setResponseType("arraybuffer");
     loader.setRequestHeader(this.requestHeader);
@@ -178,23 +180,23 @@ class PLYLoader extends Loader {
       return postProcess(buffer);
     }
     function postProcess(buffer) {
-      let geometry2 = new BufferGeometry();
+      let geometry2 = new THREE.BufferGeometry();
       if (buffer.indices.length > 0) {
         geometry2.setIndex(buffer.indices);
       }
-      geometry2.setAttribute("position", new Float32BufferAttribute(buffer.vertices, 3));
+      geometry2.setAttribute("position", new THREE.Float32BufferAttribute(buffer.vertices, 3));
       if (buffer.normals.length > 0) {
-        geometry2.setAttribute("normal", new Float32BufferAttribute(buffer.normals, 3));
+        geometry2.setAttribute("normal", new THREE.Float32BufferAttribute(buffer.normals, 3));
       }
       if (buffer.uvs.length > 0) {
-        geometry2.setAttribute("uv", new Float32BufferAttribute(buffer.uvs, 2));
+        geometry2.setAttribute("uv", new THREE.Float32BufferAttribute(buffer.uvs, 2));
       }
       if (buffer.colors.length > 0) {
-        geometry2.setAttribute("color", new Float32BufferAttribute(buffer.colors, 3));
+        geometry2.setAttribute("color", new THREE.Float32BufferAttribute(buffer.colors, 3));
       }
       if (buffer.faceVertexUvs.length > 0) {
         geometry2 = geometry2.toNonIndexed();
-        geometry2.setAttribute("uv", new Float32BufferAttribute(buffer.faceVertexUvs, 2));
+        geometry2.setAttribute("uv", new THREE.Float32BufferAttribute(buffer.faceVertexUvs, 2));
       }
       geometry2.computeBoundingSphere();
       return geometry2;
@@ -303,7 +305,7 @@ class PLYLoader extends Loader {
     let geometry;
     const scope = this;
     if (data instanceof ArrayBuffer) {
-      const text = LoaderUtils.decodeText(new Uint8Array(data));
+      const text = THREE.LoaderUtils.decodeText(new Uint8Array(data));
       const header = parseHeader(text);
       geometry = header.format === "ascii" ? parseASCII(text, header) : parseBinary(data, header);
     } else {
@@ -312,6 +314,4 @@ class PLYLoader extends Loader {
     return geometry;
   }
 }
-export {
-  PLYLoader
-};
+exports.PLYLoader = PLYLoader;